Painting pixels images in Java

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;

import javax.swing.JFrame;

public class PixelCanvas extends Canvas {
    private static final int WIDTH = 400;
    private static final int HEIGHT = 400;
    private static final Random random = new Random();

    @Override
    public void paint(Graphics g) {
        super.paint(g);

        for(int x = 0; x < WIDTH; x++) {
            for(int y = 0; y < HEIGHT; y++) {
                g.setColor(randomColor());
                g.drawLine(x, y, x, y);
            }
        }
    }

    private Color randomColor() {
        return new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256));
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame();

        frame.setSize(WIDTH, HEIGHT);
        frame.add(new PixelCanvas());

        frame.setVisible(true);
    }
}

Create RenderImage based on BufferedImage

package display.surrogate;
import java.awt.RenderingHints;
import java.awt.image.ColorModel;
import java.awt.image.IndexColorModel;
import java.awt.image.RenderedImage;
import java.awt.image.renderable.ParameterBlock;
import java.util.HashMap;

import javax.media.jai.ImageLayout;
import javax.media.jai.JAI;
import javax.media.jai.PlanarImage;

/**
 * This class extends the DisplayNBImage class to allow the setting of a false-color
 * LUT to the displayed image.
 */
public class DisplayNBImageWithLUTs extends DisplayNBImage
  {
 /**
  * The constructor for the class, which calls the constructor for its ancestral class.
  */
  public DisplayNBImageWithLUTs(RenderedImage image)
    {
    super(image);
    }

 /**
  * This method sets a look-up-table for the surrogate image, converting it to an image with a
  * color model.
  */
  public void setLUT(short[][] colors)
    {
    // Now we convert the color array (which data type is short) into three
    // separate byte arrays. We always assume that the LUT has 256 entries.
    byte[] reds = new byte[256];
    byte[] greens = new byte[256];
    byte[] blues = new byte[256];
    for(int i=0;i<256;i++)
      {
      reds[i] = (byte)colors[i][0];
      greens[i] = (byte)colors[i][1];
      blues[i] = (byte)colors[i][2];
      }
    // Create an IndexColorModel using the arrays above.
    ColorModel colorModel = new IndexColorModel(8,256,reds,greens,blues);
    // To change the color model of the surrogate image, we need to create a new
    // image layout based on the image, and change the layout's color model.
    ImageLayout layout = new ImageLayout(surrogateImage);
    layout.setColorModel(colorModel);
    // In order to change the image layout we need to set its rendering hints.
    HashMap<RenderingHints.Key,ImageLayout> map = new HashMap<RenderingHints.Key,ImageLayout>();
    map.put(JAI.KEY_IMAGE_LAYOUT,layout);
    RenderingHints hints = new RenderingHints(map);
    // Reformat the image using the above hints.
    ParameterBlock pb = new ParameterBlock();
    pb.addSource(surrogateImage);
    // We don't really want to change the original surrogate image...
    PlanarImage newSurrogateImage = JAI.create("format",pb,hints);
    // Set the new, LUT-applied image.
    set(newSurrogateImage);
    }

  }

How to convert a 24 Bit PNG to 3 Bit PNG using Floyd–Steinberg dithering?

class Test {
  private static BufferedImage floydSteinbergDithering(BufferedImage img) {

    C3[] palette = new C3[] {
        new C3(  0,   0,   0),
        new C3(  0,   0, 255),
        new C3(  0, 255,   0),
        new C3(  0, 255, 255),
        new C3(255,   0,   0),
        new C3(255,   0, 255),
        new C3(255, 255,   0),
        new C3(255, 255, 255)
    };

    int w = img.getWidth();
    int h = img.getHeight();

    C3[][] d = new C3[h][w];

    for (int y = 0; y < h; y++) 
      for (int x = 0; x < w; x++) 
        d[y][x] = new C3(img.getRGB(x, y));

    for (int y = 0; y < img.getHeight(); y++) {
      for (int x = 0; x < img.getWidth(); x++) {

        C3 oldColor = d[y][x];
        C3 newColor = findClosestPaletteColor(oldColor, palette);
        img.setRGB(x, y, newColor.toColor().getRGB());

        C3 err = oldColor.sub(newColor);

        if (x+1 < w)         d[y  ][x+1] = d[y  ][x+1].add(err.mul(7./16));
        if (x-1>=0 && y+1<h) d[y+1][x-1] = d[y+1][x-1].add(err.mul(3./16));
        if (y+1 < h)         d[y+1][x  ] = d[y+1][x  ].add(err.mul(5./16));
        if (x+1<w && y+1<h)  d[y+1][x+1] = d[y+1][x+1].add(err.mul(1./16));
      }
    }

    return img;
  }

  private static C3 findClosestPaletteColor(C3 c, C3[] palette) {
    C3 closest = palette[0];

    for (C3 n : palette) 
      if (n.diff(c) < closest.diff(c))
        closest = n;

    return closest;
  }

  public static void main(String[] args) throws IOException {

    final BufferedImage normal  = ImageIO.read(new URL("http://upload.wikimedia.org/wikipedia/en/2/24/Lenna.png")).getSubimage(100, 100, 300, 300);
    final BufferedImage dietered = floydSteinbergDithering(ImageIO.read(new URL("http://upload.wikimedia.org/wikipedia/en/2/24/Lenna.png"))).getSubimage(100, 100, 300, 300);

    JFrame frame = new JFrame("Test");
    frame.setLayout(new GridLayout(1, 2));

    frame.add(new JComponent() {
      @Override
      protected void paintComponent(Graphics g) {
         super.paintComponent(g);
         g.drawImage(normal, 0, 0, this);
      }
    });
    frame.add(new JComponent() {
      @Override
      protected void paintComponent(Graphics g) {
         super.paintComponent(g);
         g.drawImage(dietered, 0, 0, this);
      }
    });

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setSize(400, 400);
    frame.setVisible(true);
  }


  static class C3 {
    int r, g, b;

    public C3(int c) {
      Color color = new Color(c);
      this.r = color.getRed();
      this.g = color.getGreen();
      this.b = color.getBlue();
    }
    public C3(int r, int g, int b) {
      this.r = r;
      this.g = g;
      this.b = b;
    }

    public C3 add(C3 o) {
      return new C3(r + o.r, g + o.g, b + o.b);
    }
    public C3 sub(C3 o) {
      return new C3(r - o.r, g - o.g, b - o.b);
    }
    public C3 mul(double d) {
      return new C3((int) (d * r), (int) (d * g), (int) (d * b));
    }

    public int toRGB() {
      return toColor().getRGB();
    }
    public Color toColor() {
      return new Color(clamp(r), clamp(g), clamp(b));
    }
    public int clamp(int c) {
      return Math.max(0, Math.min(255, c));
    }
  }
}

Java: convert image to byte array, convert byte array to image

Method-1

import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
 
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;
 
public class ConvertImage {
 
    public static void main(String[] args) throws FileNotFoundException, IOException {
     /*
      * 1. How to convert an image file to  byte array?
      */
 
        File file = new File("C:\\rose.jpg");
 
        FileInputStream fis = new FileInputStream(file);
        //create FileInputStream which obtains input bytes from a file in a file system
        //FileInputStream is meant for reading streams of raw bytes such as image data. For reading streams of characters, consider using FileReader.
 
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] buf = new byte[1024];
        try {
            for (int readNum; (readNum = fis.read(buf)) != -1;) {
                //Writes to this byte array output stream
                bos.write(buf, 0, readNum); 
                System.out.println("read " + readNum + " bytes,");
            }
        } catch (IOException ex) {
            Logger.getLogger(ConvertImage.class.getName()).log(Level.SEVERE, null, ex);
        }
 
        byte[] bytes = bos.toByteArray();
 
        /*
         * 2. How to convert byte array back to an image file?
         */
 
        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        Iterator<?> readers = ImageIO.getImageReadersByFormatName("jpg");
 
        //ImageIO is a class containing static methods for locating ImageReaders
        //and ImageWriters, and performing simple encoding and decoding. 
 
        ImageReader reader = (ImageReader) readers.next();
        Object source = bis; 
        ImageInputStream iis = ImageIO.createImageInputStream(source); 
        reader.setInput(iis, true);
        ImageReadParam param = reader.getDefaultReadParam();
 
        Image image = reader.read(0, param);
        //got an image file
 
        BufferedImage bufferedImage = new BufferedImage(image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB);
        //bufferedImage is the RenderedImage to be written
 
        Graphics2D g2 = bufferedImage.createGraphics();
        g2.drawImage(image, null, null);
 
        File imageFile = new File("C:\\newrose2.jpg");
        ImageIO.write(bufferedImage, "jpg", imageFile);
 
        System.out.println(imageFile.getPath());
    }
}

Method-2

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
 
 
public class SimpleConvertImage {
 public static void main(String[] args) throws IOException{
  String dirName="C:\\";
  ByteArrayOutputStream baos=new ByteArrayOutputStream(1000);
  BufferedImage img=ImageIO.read(new File(dirName,"rose.jpg"));
  ImageIO.write(img, "jpg", baos);
  baos.flush();
 
  String base64String=Base64.encode(baos.toByteArray());
  baos.close();
 
  byte[] bytearray = Base64.decode(base64String);
 
  BufferedImage imag=ImageIO.read(new ByteArrayInputStream(bytearray));
  ImageIO.write(imag, "jpg", new File(dirName,"snap.jpg"));
 }
}

Convert negative image to positive

class Convert
{
    public static void main(String[] args)
    {
        invertImage("img.png");
    }

    public static void invertImage(String imageName) {
        BufferedImage inputFile = null;
        try {
            inputFile = ImageIO.read(new File(imageName));
        } catch (IOException e) {
            e.printStackTrace();
        }

        for (int x = 0; x < inputFile.getWidth(); x++) {
            for (int y = 0; y < inputFile.getHeight(); y++) {
                int rgba = inputFile.getRGB(x, y);
                Color col = new Color(rgba, true);
                col = new Color(255 - col.getRed(),
                                255 - col.getGreen(),
                                255 - col.getBlue());
                inputFile.setRGB(x, y, col.getRGB());
            }
        }

        try {
            File outputFile = new File("invert-"+imageName);
            ImageIO.write(inputFile, "png", outputFile);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Convert RenderedImage to BufferedImage in java

	public static BufferedImage convertRenderedImage(RenderedImage img) {
	if (img instanceof BufferedImage) {
	return (BufferedImage) img;
	}
	ColorModel cm = img.getColorModel();
	int width = img.getWidth();
	int height = img.getHeight();
	WritableRaster raster = cm
	.createCompatibleWritableRaster(width, height);
	boolean isAlphaPremultiplied = cm.isAlphaPremultiplied();
	Hashtable properties = new Hashtable();
	String[] keys = img.getPropertyNames();
	if (keys != null) {
	for (int i = 0; i < keys.length; i++) {
	properties.put(keys[i], img.getProperty(keys[i]));
	}
	}
	BufferedImage result = new BufferedImage(cm, raster,
	isAlphaPremultiplied, properties);
	img.copyData(raster);
	return result;
	}

view raw ConvertRenderedImage hosted with ❤ by GitHub

Read dicom images from Dicom File(.DCM)

• Require ALL DCMCHE jar file
• dcm4che-imageio-2.0.25 (Special One)
• dcm4che-imageio-rle-2.0.25 (Special One)

	Iterator<ImageReader> iter = ImageIO.getImageReadersByFormatName("DICOM");
	ImageReader readers = (ImageReader)iter.next();
	//return DicomImageReadParam
	DicomImageReadParam param1 = (DicomImageReadParam) readers.getDefaultReadParam();
	// Adjust the values of Rows and Columns in it and add a Pixel Data attribute with the byte array from the DataBuffer of the scaled Raster
	ImageInputStream iis = ImageIO.createImageInputStream(file);
	//sets the input source to use the given ImageInputSteam or other Object
	readers.setInput(iis, true);
	BufferedImage image = readers.read(frameNumber, param1);
	//Releases all of the native sreen resources used by this Window, its subcomponents, and all of its owned children
	readers.dispose();
	ImageIO.write(image, "jpg", new File("D://dd1//"+value+".jpg"));

view raw ReadDicomImage hosted with ❤ by GitHub