// PixelImages.java
// David Kosbie, 15-111/AB, Spring 2007

/*
Standard disclaimer:  As usual with sample code designed (often in
class!) to demonstrate specific issues, the style may not be perfect
(it is especially lacking comments and some top-down design, and as we've
not yet reviewed classes, it's lacking those, too!), and there may
even be a bug or two lurking in the code!

Note:  you are not responsible for the code in the bottom half of
this file (there is a comment clearly indicating where this occurs).

This code allows you to create a 2d array of integers representing pixels
and then display these pixels on the screen.  Each pixel is a 32-bit int,
where the top byte is the "alpha" (transparency), and the next 3 bytes are,
in order, the red, green, and blue values for that pixel.  Each of alpha,
4red, green, and blue, being one unsigned byte, vary from 0 to 255.  You will
find that these are usually written in hexadecimal (good thing we all
know that!).  For example, check out the colors on the Wikipedia page on
web colors (just scroll around and find text in various colors -- the text
is usually the hexadecimal RGB value for that color!).  For example, here
are a few interesting colors:
   color         R  G  B (in hex!)
   Crimson       DC 14 3C     
   Chartreuse    7F FF 00 
   Sienna        A0 52 2D

The important methods for you are as follows:

LOADING A JPEG FILE INTO A PIXEL ARRAY:
	public static int[][] loadPixels(String filename)

SETTING PIXELS:
	public static void setPixel(int[][] pixels, int row, int col,
								int alpha, int red, int green, int blue)
GETTING PIXELS:
	public static int getAlpha(int[][] pixels, int row, int col)
	public static int getRed  (int[][] pixels, int row, int col)
	public static int getGreen(int[][] pixels, int row, int col)
	public static int getBlue (int[][] pixels, int row, int col)

DISPLAYING PIXELS:
	public static void displayPixels(int[][] pixels)

*/

import java.util.*;
import java.awt.*;
import javax.swing.*;
import java.awt.image.*;

public class PixelImages {

	// The types of fades that we support
	public enum FadeType { HORIZONTAL_FADE, VERTICAL_FADE, RADIAL_FADE };
	
	public static void main(String[] args) {
		makeSamplePicture1();
		makeSamplePicture2();
	}

	public static void makeSamplePicture2() {
		int[][] pixels = loadPixels("sampleImage.jpg");
		displayPixels(pixels); // display the original
		
		int width = pixels.length, height = pixels[0].length;
		for (int x=0; x<width; x++)
			for (int y=0; y<height; y++) {
				pixels[x][y] |= 0xFF; // make it blue
			}
		displayPixels(pixels); // and now display the blue version
	}
	
	public static void makeSamplePicture1() {
		int width=600, height=300;
		int[][] pixels = new int[width][height];
		int x,y,alpha = 255,red,green,blue;

		// Place a large sienna rectangle in the middle (Sienna = A0 52 2D)
		red = 0xA0;
		green = 0x52;
		blue = 0x2D;
		fillRect(pixels,50,50,width-100,height-100,alpha,red,green,blue);

		// add chartreuse vertical stripes (Chartreuse = 7F FF 00)
		red = 0x7F;
		green = 0xFF;
		blue = 0;
		for (int left=0; left<600; left += 60)
			fillRect(pixels,left,0,10,height,alpha,red,green,blue);

		// add a horizontal fade from blue to red in top-left corner
		fadeRect(pixels,FadeType.HORIZONTAL_FADE,
				0,0,100,100,     // left, top, width, height
				255, 0, 0, 255,  // alpha1, red1, green1, blue1
				255, 255, 0, 0); // alpha2, red2, green2, blue2

		// add a vertical fade from green to white in bottom-left corner
		fadeRect(pixels,FadeType.VERTICAL_FADE,
				0,height-100,100,100, // left, top, width, height
				255, 0, 255, 0,       // alpha1, red1, green1, blue1
				255, 255,255,255);    // alpha2, red2, green2, blue2

		// finally, display our picture!
		displayPixels(pixels);
	}

	// Fills in the given rectangle with the given color
	public static void fillRect(int[][] pixels, int left, int top, int width, int height,
								int alpha, int red, int green, int blue) {
		for (int x=left; x<left+width; x++)
		for (int y=top;  y<top+height; y++)
			setPixel(pixels,x,y,alpha,red,green,blue);
	}

	// Draws a faded rectangle, from the first color to the second,
	// according to the given fadeType
	public static void fadeRect(int[][] pixels,
								FadeType fadeType,
								int left, int top, int width, int height,
								int alpha1, int red1, int green1, int blue1,
								int alpha2, int red2, int green2, int blue2) {
		for (int x=left; x<left+width; x++)
		for (int y=top;  y<top+height; y++) {
			int alpha = fadeValue(fadeType,alpha1,alpha2,left,top,width,height,x,y);
			int red   = fadeValue(fadeType,red1,red2,left,top,width,height,x,y);
			int green = fadeValue(fadeType,green1,green2,left,top,width,height,x,y);
			int blue  = fadeValue(fadeType,blue1,blue2,left,top,width,height,x,y);
			setPixel(pixels,x,y,alpha,red,green,blue);
		}
	}
	
	// provide a "fade" of the given value for the given fadeType for
	// the given x,y position within the given rectangle
	public static int fadeValue(FadeType fadeType, int value0, int value1,
								int left, int top, int width, int height, int x, int y) {
		switch (fadeType) {
			case HORIZONTAL_FADE:
				// we use value0 on the left and value1 on the right
				return value0 + (value1 - value0) * (x - left) / (width - 1);
			case VERTICAL_FADE:
				// we use value0 on the top and value1 on the bottom
				return value0 + (value1 - value0) * (y - top) / (height - 1);
			default:
				System.out.printf("Unknown fade type: %d\n",fadeType);
				return value0;
		}
	}

	// set the given pixel to the given color		
	public static void setPixel(int[][] pixels, int x, int y,
								int alpha, int red, int green, int blue) {
		pixels[x][y] = (alpha << 24) | (red << 16) | (green << 8) | blue;
	}

	// return just the alpha of the given pixel
	public static int getAlpha(int[][] pixels, int x, int y) {
		return pixels[x][y] >>> 24;
	}
	
	// return just the red of the given pixel
	public static int getRed(int[][] pixels, int x, int y) {
		return (pixels[x][y] >>> 16) & 0xFF;
	}

	// return just the green of the given pixel
	public static int getGreen(int[][] pixels, int x, int y) {
		return (pixels[x][y] >>> 8) & 0xFF;
	}

	// return just the blue of the given pixel
	public static int getBlue(int[][] pixels, int x, int y) {
		return pixels[x][y] & 0xFF;
	}


	///////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////
	/// YOU ARE NOT RESPONSIBLE FOR THE CODE BELOW HERE!!!! ///
	///////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////

	public static int[][] loadPixels(String filename) {
		Image image = getImageFromFile(filename);
		return getPixelsFromImage(image);
	}

	public static Image getImageFromFile(String filename) {
		// this is quick'n'dirty -- should use MediaTracker!
		Image image = new ImageIcon(filename).getImage();
		int width = image.getWidth(null);
		int height = image.getHeight(null);
		if ((width == -1) || (height == -1)) {
			System.err.printf("Could not load file: %s\n",filename);
			// just punt for now (should be more graceful, of course!)
			System.exit(1);
		}
		System.out.printf("%s: %dx%d\n",filename,width,height);
		return image;
	}

	public static int[][] getPixelsFromImage(Image image) {
		int width = image.getWidth(null);
		int height = image.getHeight(null);
		int[] pixarray = new int[width*height];
		PixelGrabber pg = new PixelGrabber(image,0,0,width,height,pixarray,0,width);
		try { pg.grabPixels(); }
		catch (InterruptedException e) {
		    System.err.println("Interrupted waiting for pixels!");
			// just punt for now (should be more graceful, of course!)
			System.exit(1);
		}
		if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
	    	System.err.println("Image fetch error!");
			// ditto
			System.exit(1);
		}
		int[][] pixels = new int[width][height];
		for (int y=0; y<height; y++)
			for (int x=0; x<width;  x++)
				pixels[x][y] = pixarray[y*width + x];
		return pixels;
	}


	public static void loadPixels(JLabel label, int[][] pixels) {
		// 1. convert to 1-d array
		int width  = pixels.length;
		int height = pixels[0].length; // just assume rectangular for now
		int i=0;  // index into new pixarray
		int[] pixarray = new int[width*height];
		for (int y=0; y<height; y++)
		for (int x=0; x<width;  x++)
			// these are stored y-major!
			pixarray[i++] = pixels[x][y];
		// 2. convert 1-d array into Image
		MemoryImageSource source = new MemoryImageSource(width,height,pixarray,0,width);
		Image image = label.createImage(source);
		// 3. store Image in the JLabel
		label.setIcon(new ImageIcon(image));		
	}
	
	public static void displayPixels(int[][] pixels) {
		JFrame frame = new JFrame("Pixel Image Viewer");
		frame.getContentPane().setBackground(Color.black);
		JLabel label = new JLabel();
		loadPixels(label,pixels);
		frame.getContentPane().add(label);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.pack();
		frame.setVisible(true);
	}
}