How do I create a new image composed of a number of smaller images?

Question

Hi,
I'm attempting to work with the assorted image APIs for the first time and am experiencing one main problem with what I'm trying to do. Here's the scenario;
I have an image file (currently a JPEG) which is 320*200 pixels in size, it contains a set of 20*20 images. I want to take such a file and convert it into a new JPG file containing all those 20*20 images but in a different grid, for example a single column.
I'm currently having no problem in working my way through the input file and have created an ArrayList containing one BufferedImage for each 20*20 image. My problem is that I just can't see how to create a new file containing all those images in new grid.
Any help would be much appreciated and FWIW I've included the code I've written so far.
package mkhan.image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import javax.imageio.ImageIO;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
public class ImageTileConvertor {
   // arg 1 = input file
   // arg 2 = output file
   // arg 3 = tile x dimension
   // arg 4 = tile y dimension
   // arg 5 = number of tiles in x dimension
   // arg 6 = number of tiles in y dimension
   public static void main(String[] args) throws IllegalArgumentException,
                                                 IOException {
     if (args.length != 6) {
       System.out.println("Invalid argument list, please supply the following information in the specified order:");
       System.out.println("  - The input file name including full path");
       System.out.println("  - The output file name including full path");
       System.out.println("  - The size of the tile in the x dimension");
       System.out.println("  - The size of the tile in the y dimension");
       System.out.println("  - The number of tiles in the x dimension");
       System.out.println("  - The number of tiles in the y dimension");
     } else {
       ImageTileConvertor imageConvertor = new ImageTileConvertor(args[0], args[1], args[2],
                                                                  args[3], args[4], args[5]);
   * Instance member vars
  private File m_sourceFile = null;
  private File m_outputFile = null;
  private int m_tileSizeX = 0;
  private int m_tileSizeY = 0;
  private int m_numberOfXTiles = 0;
  private int m_numberOfYTiles = 0;
   * Ctor
  public ImageTileConvertor(String sourceFile, String outputFile,
                            String tileSizeX, String tileSizeY,
                            String tilesX, String tilesY) throws IllegalArgumentException,
                                                                 IOException {
    try {
      Integer tileSizeXInt = new Integer(tileSizeX);
      Integer tileSizeYInt = new Integer(tileSizeY);
      Integer tilesXInt = new Integer(tilesX);
      Integer tilesYInt = new Integer(tilesY);
      m_tileSizeX = tileSizeXInt.intValue();
      m_tileSizeY = tileSizeYInt.intValue();
      m_numberOfXTiles = tilesXInt.intValue() - 1;
      m_numberOfYTiles = tilesYInt.intValue() - 1; // convert to zero base
    } catch (NumberFormatException e) {
      throw new IllegalArgumentException("Tile Sizes must be integers");
    m_sourceFile = new File(sourceFile);
    m_outputFile = new File(outputFile);
    if (!m_sourceFile.exists()) {
      throw new IllegalArgumentException("Input file must exist and be a valid file");
    try {
      translateToTiles();
    } catch (IOException e) {
      throw e;
   * Performs the translation from one format to the other
  private void translateToTiles() throws IOException {
    ImageInputStream imageIn = null;
    BufferedImage bufferedWholeImage = null;
    int imageHeight = 0;
    int imageWidth = 0;
    int currentX = 0;
    int currentY = 0;
    ArrayList imageList = new ArrayList();
    try {
      imageIn = ImageIO.createImageInputStream(m_sourceFile);
      bufferedWholeImage = ImageIO.read(imageIn);
      if (bufferedWholeImage != null) {
        imageHeight = bufferedWholeImage.getHeight();
        imageWidth = bufferedWholeImage.getWidth();
        if (((m_tileSizeX * m_numberOfXTiles) > imageWidth) || ((m_tileSizeY * m_numberOfYTiles) > imageHeight)) {
          throw new IOException("Specified Tile Size is larger then image");
        } else {
          // Process each tile, work in columns
          for (int i=0; i <= m_numberOfXTiles; i++) {
            for (int j=0; j <= m_numberOfYTiles; j++) {
              currentX = i * m_tileSizeX;
              currentY = j * m_tileSizeY;
              createTiledImage(imageList, bufferedWholeImage, currentX, currentY);
        createOutputTiles(imageList);
      } else {
        throw new IOException("Unable to identify source image format");
    } catch (IOException e) {
      throw e;
  private void createTiledImage(ArrayList listOfImages, BufferedImage wholeImage,
                                int xPosition, int yPosition) {
    BufferedImage bufferedTileImage = wholeImage.getSubimage(xPosition, yPosition, m_tileSizeX, m_tileSizeY);
    listOfImages.add(bufferedTileImage);
  private void createOutputTiles(ArrayList imageList) throws IOException {
    ImageOutputStream out = ImageIO.createImageOutputStream(m_outputFile);
    Iterator iterator = imageList.iterator();
    // This doesn't work at the moment, it appears to output all the images but the end file only seems to contain the first small image
    while (iterator.hasNext()) {
      BufferedImage bi = (BufferedImage)iterator.next();
      ImageIO.write(bi, "JPG", out);
      System.out.println(out1.getStreamPosition());
    out.close();
    // This is another attempt in which I can see how to populate a Graphics object with a small sample of the images
    // Although I'm not sure how to output this to anywhere in order to see if it works - can this approach output to a file?
    BufferedImage singleTile = (BufferedImage)imageList.get(0);
    // Now populate the image with the tiles
    Graphics gr = singleTile.createGraphics();
    gr.drawImage(singleTile, 0, 0, Color.BLACK, null);
    singleTile = (BufferedImage)imageList.get(1);
    gr.drawImage(singleTile, 0, 20, Color.BLACK, null);
}Thanks,
Matt

Answer 1

Construct a new BufferedImage whose width is the width of a tile, and whose height is the height of a tile times the number of tiles.BufferedImage colImg = new BufferedImage(m_tileSizeX,
                                         m_tileSizeY * m_numberOfXTiles * m_numberOfYTiles,
                                         BufferedImage.TYPE_INT_ARGB);Now write the tiles onto it.Iterator it = imageList.iterator();
int columnYPos = 0;
Graphics g = colImg.getGraphics();
while (it.hasNext())
    g.drawImage((Image)it.next(), 0, columnYPos, null);
    columnYPos += m_tileSizeY;
}Now save your image.*******************************************************************************
Answer provided by Friends of the Water Cooler. Please inform forum admin via the
'Discuss the JDC Web Site' forum that off-topic threads should be supported.