Chromakey using 2d arrays

[Jamal Nasar]

First time posting here, hope I'm formatting this right:

I'm having some trouble writing a chromaKey method that basically takes two images, one with a green screen and the other a background, and makes a new image replacing the green-screen with the background.
After compiling, when I try to run it, I get an ArrayIndexOutofBoundsException on the line:

if (pixels.length == background.pixels.length && pixels[0].length == background.pixels[0].length) {

Can someone point me in the right direction?

import java.util.Scanner;
import java.io.File;
import java.io.PrintWriter;
import java.io.FileNotFoundException;

/**
 * Class contains a picture represented as a 2D array of Colours, each colour is
 * represented by a RGB value.
 */
public class Picture {
	class RGB {
		int red;
		int green;
		int blue;
	}

	private int maxColourValue = 255;
	private RGB[][] pixels;
	private String version = "p3";
	private int length;

	public Picture() {
	}

	/**
	 * Creates a picture from the file with the given filename. The file is
	 * assumed to be in PPM format.
	 * 
	 * @param filename
	 *            name of the PPM file that contains picture information.
	 * @throws FileNotFoundException
	 *             if a file with the specified filename does not exist.
	 */
	public Picture(String filename) throws FileNotFoundException {
		File pictureFile = new File(filename);
		if (pictureFile.exists()) {
			readFile(pictureFile);
		} else {
			pixels = new RGB[0][0];
		}
	}

	/**
	 * Chroma keys this picture such that the green background is replaced with
	 * background picture provided. The resulting picture is returned by this
	 * method.
	 * 
	 * @param background
	 *            picture to be used as the background in chroma key.
	 * @return picture that has this picture as the foreground with the green
	 *         background replaced by the background picture provided.
	 */

	

	// make a new picture, check image size for same, for each row, nested for
	// each column, if green keep, if not green, do not keep
	// # of rows, pixels.length
	// # of columns, pixels[0].length
	public Picture chromaKey(Picture background) {

		Picture tempPicture = new Picture();
		
		// Check image size
		if (pixels.length == background.pixels.length && pixels[0].length == background.pixels[0].length) {
			for (int i = 0; i < background.length; i++) {
				for (int k = 0; k < background.pixels[0].length; k++) {
					tempPicture.pixels[i][k] = background.pixels[i][k];
				}
			}
		}
		if (pixels.length != background.pixels.length || pixels[0].length != background.pixels[0].length) {
			return background;
		}
			
			// Loop through the rows
			for (int row = 0; row < tempPicture.length; row++) {
				// Loop through the columns
				for (int column = 0; column < tempPicture.pixels[0].length; column++) {
					// If criteria is met, replace foreground pixel, if not, use background pixel 
					if ((background.pixels[row][column].red - background.pixels[row][column].blue) >= 50 && 
							(background.pixels[row][column].green - background.pixels[row][column].red) >= 20) {
						tempPicture.pixels[row][column] = background.pixels[row][column];
					} 
					
					else
						tempPicture.pixels[row][column] = pixels[row][column];
				}
			}
			return tempPicture;
		}

	

	
	/**
	 * Writes this picture to a file that has the filename specified.
	 * 
	 * @param filename
	 *            name of the file to write data for this picture too.
	 */
	public void writeToFile(String filename) throws FileNotFoundException {
		PrintWriter writer = new PrintWriter(filename);
		// First line in a PPM file must contain the PPM format version.
		writer.println(version);

		// The next line must contain the dimension of the picture.
		writer.print(pixels.length);
		writer.print(' ');
		writer.println(pixels[0].length);

		// The next line must contain the maximum value for each red/green/blue
		// value.
		writer.println(maxColourValue);

		// The remainder of the file contains the colours for each pixel. Each
		// line
		// represents a row of pixels. Each row contains a sequence of values
		// for
		// red green blue, one triple for each column.
		for (int row = 0; row < pixels.length; row++) {
			for (int column = 0; column < pixels[row].length; column++) {
				RGB colour = pixels[row][column];
				writer.print(colour.red);
				writer.print(' ');
				writer.print(colour.green);
				writer.print(' ');
				writer.print(colour.blue);
				writer.print(' ');
			}
			writer.println();
		}
		writer.close();
	}

	/*
	 * Reads data for this picture from the specified file.
	 */
	private void readFile(File pictureFile) throws FileNotFoundException {
		Scanner fileScanner = new Scanner(pictureFile);
		// The first line in a PPM file contains the version of PPM format used.
		version = fileScanner.nextLine();

		// The next line contains the dimension of the picture.
		int numRows = fileScanner.nextInt();
		int numColumns = fileScanner.nextInt();

		// The next line in the file contains the number of possible values for
		// red/green/blue
		maxColourValue = fileScanner.nextInt();

		// The remainder of the file contains the colour values of the pixels.
		// Each line
		// represents a row of pixels. Each row contains a sequence of values
		// for
		// red green blue, one triple for each column.
		pixels = new RGB[numRows][numColumns];
		for (int row = 0; row < numRows; row++) {
			for (int column = 0; column < numColumns; column++) {
				RGB nextColour = new RGB();
				nextColour.red = fileScanner.nextInt();
				nextColour.green = fileScanner.nextInt();
				nextColour.blue = fileScanner.nextInt();
				pixels[row][column] = nextColour;
			}
		}
		fileScanner.close();
	}
}




import java.io.FileNotFoundException;

public class PictureTest {
   public static void main(String[] args) {
	   
      String foregroundFilename = args[0];
      String backgroundFilename = args[1];
      String chromaKeyedFilename = args[2];
      
      try {
         Picture foreground = new Picture(foregroundFilename);
         Picture background = new Picture(backgroundFilename);
         Picture chromaKeyed = foreground.chromaKey(background);
         
         chromaKeyed.writeToFile(chromaKeyedFilename);
      } catch (FileNotFoundException fnfe) {
         fnfe.printStackTrace();
      }
   }   
}

[Winston Gutkowski]

Jamal Nasar wrote:After compiling, when I try to run it, I get an ArrayIndexOutofBoundsException on the line:

if (pixels.length == background.pixels.length && pixels[0].length == background.pixels[0].length) {

Well, the only reason for that would be that either pixels or background.pixels has a length of 0; but since you haven't shown us how those are created, it's impossible to guess why.

My suggestion: StopCoding and write down what you're trying to achieve.

Winston

[Jamal Nasar]

Thanks for the suggestion Winston, I added in the rest of the code so the method makes sense in context and I'll try looking for what's causing the length issue in the meanwhile.