private BufferedImage bufferedImage = null;

private java.util.ArrayList corners = null;

private float outputQuality = 1f; //0.9f; //0.5f;

private static final boolean useSunCodec = getSunCodec();

private static Class JPEGCodec;

private static Class JPEGEncodeParam;

private Graphics2D g2d = null;

public static String[] InputFormats = getFormats(ImageIO.getReaderFormatNames());

public static String[] OutputFormats = getFormats(ImageIO.getWriterFormatNames());

private IIOMetadata metadata;

private HashMap<Integer, Object> exif;

private HashMap<Integer, Object> iptc;

private HashMap<Integer, Object> gps;

private boolean saveMetadata = false;

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using an existing image */

public Image(String PathToImageFile){

this(new java.io.File(PathToImageFile));

}

public Image(java.io.File file){

if (!file.exists()) throw new IllegalArgumentException("Input file not found.");

try{ createBufferedImage(new FileInputStream(file)); }

catch(Exception e){}

}

public Image(java.io.InputStream InputStream){

createBufferedImage(InputStream);

}

public Image(byte[] byteArray){

this(new ByteArrayInputStream(byteArray));

}

public Image(int width, int height){

this.bufferedImage =

new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

this.g2d = getGraphics();

}

public Image(BufferedImage bufferedImage){

this.bufferedImage = bufferedImage;

}

public Image(RenderedImage img) {

if (img instanceof BufferedImage) {

this.bufferedImage = (BufferedImage) img;

}

else{

java.awt.image.ColorModel cm = img.getColorModel();

java.awt.image.WritableRaster raster =

cm.createCompatibleWritableRaster(img.getWidth(), img.getHeight());

boolean isAlphaPremultiplied = cm.isAlphaPremultiplied();

java.util.Hashtable properties = new java.util.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);

this.bufferedImage = result;

}

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a block of text.

public Image(String text, String fontName, int fontSize, int r, int g, int b){

this(text, new Font(fontName, Font.TRUETYPE_FONT, fontSize), r,g,b);

}

public Image(String text, Font font, int r, int g, int b){

//Get Font Metrics

Graphics2D t = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB).createGraphics();

t.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

FontMetrics fm = t.getFontMetrics(font);

int width = fm.stringWidth(text);

int height = fm.getHeight();

int descent = fm.getDescent();

t.dispose();

//Create Image

bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

g2d = bufferedImage.createGraphics();

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

//Add Text

float alpha = 1.0f; //Set alpha. 0.0f is 100% transparent and 1.0f is 100% opaque.

g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));

g2d.setColor(new Color(r, g, b));

g2d.setFont(font);

g2d.drawString(text, 0, height-descent);

}

//**************************************************************************

//** setBackgroundColor

//**************************************************************************

/** Used to set the background color. Creates an image layer and inserts it

public void setBackgroundColor(int r, int g, int b){

/*

int imageType = bufferedImage.getType();

if (imageType == 0) {

imageType = BufferedImage.TYPE_INT_ARGB;

}

int width = this.getWidth();

int height = this.getHeight();

BufferedImage bi = new BufferedImage(width, height, imageType);

Graphics2D g2d = bi.createGraphics();

g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f));

g2d.setColor(new Color(r,g,b));

g2d.fillRect(0,0,width,height);

java.awt.Image img = bufferedImage;

g2d.drawImage(img, 0, 0, null);

this.bufferedImage = bi;

g2d.dispose();

}

//**************************************************************************

//** getInputFormats

//**************************************************************************

/** Used to retrieve a list of supported input (read) formats. */

public String[] getInputFormats(){

return getFormats(ImageIO.getReaderFormatNames());

}

//**************************************************************************

//** getOutputFormats

//**************************************************************************

/** Used to retrieve a list of supported output (write) formats. */

public String[] getOutputFormats(){

return getFormats(ImageIO.getWriterFormatNames());

}

//**************************************************************************

//** getFormats

//**************************************************************************

/** Used to trim the list of formats. */

private static String[] getFormats(String[] inputFormats){

//Build a unique list of file formats

HashSet<String> formats = new HashSet<String> ();

for (int i=0; i<inputFormats.length; i++){

String format = inputFormats[i].toUpperCase();

if (format.contains("JPEG") && format.contains("2000")){

formats.add("JP2");

formats.add("J2C");

formats.add("J2K");

formats.add("JPX");

}

else if (format.equals("JPEG") || format.equals("JPG")){

formats.add("JPE");

formats.add("JFF");

formats.add(format);

}

else{

formats.add(format);

}

}

//Sort and return the hashset as an array

inputFormats = formats.toArray(new String[formats.size()]);

java.util.Collections.sort(java.util.Arrays.asList(inputFormats));

return inputFormats;

}

//**************************************************************************

//** getSunCodec

//**************************************************************************

/** Attempts to load classes from the com.sun.image.codec.jpeg package used

private static boolean getSunCodec(){

try{

JPEGCodec = Class.forName("com.sun.image.codec.jpeg.JPEGCodec");

JPEGEncodeParam = Class.forName("com.sun.image.codec.jpeg.JPEGEncodeParam");

return true;

}

catch(Exception e){

return false;

}

}

//**************************************************************************

//** getWidth

//**************************************************************************

/** Returns the width of the image, in pixels. */

public int getWidth(){

return bufferedImage.getWidth();

}

//**************************************************************************

//** getHeight

//**************************************************************************

/** Returns the height of the image, in pixels.

public int getHeight(){

return bufferedImage.getHeight();

}

//**************************************************************************

//** getGraphics

//**************************************************************************

private Graphics2D getGraphics(){

if (g2d==null){

g2d = this.bufferedImage.createGraphics();

//Enable anti-alias

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

}

return g2d;

}

//**************************************************************************

//** addText

//**************************************************************************

/** Used to add text to the image at a given position.

public void addText(String text, int x, int y){

addText(text, x, y, new Font ("SansSerif",Font.TRUETYPE_FONT,12), 0, 0, 0);

}

//**************************************************************************

//** addText

//**************************************************************************

/** Used to add text to the image at a given position.

public void addText(String text, int x, int y, String fontName, int fontSize, int r, int g, int b){

addText(text, x, y, new Font(fontName, Font.TRUETYPE_FONT, fontSize), r,g,b);

}

//**************************************************************************

//** addText

//**************************************************************************

/** Used to add text to the image at a given position.

public void addText(String text, int x, int y, Font font, int r, int g, int b){

g2d = getGraphics();

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

g2d.setColor(new Color(r, g, b));

g2d.setFont(font);

g2d.drawString(text, x, y);

}

//**************************************************************************

//** addPoint

//**************************************************************************

/** Simple drawing function used to set color of a specific pixel in the

public void addPoint(int x, int y, int r, int g, int b){

setColor(x,y,new Color(r,g,b));

}

//**************************************************************************

//** setColor

//**************************************************************************

/** Used to set the color (ARGB value) for a specific pixel in the image.

public void setColor(int x, int y, Color color){

g2d = getGraphics();

Color org = g2d.getColor();

g2d.setColor(color);

g2d.fillRect(x,y,1,1);

g2d.setColor(org);

}

//**************************************************************************

//** getColor

//**************************************************************************

/** Used to retrieve the color (ARGB) values for a specific pixel in the

public Color getColor(int x, int y){

//return new Color(bufferedImage.getRGB(x, y)); //<--This will return an incorrect alpha value

int pixel = bufferedImage.getRGB(x, y);

int alpha = (pixel >> 24) & 0xff;

int red = (pixel >> 16) & 0xff;

int green = (pixel >> 8) & 0xff;

int blue = (pixel) & 0xff;

return new java.awt.Color(red, green, blue, alpha);

}

//**************************************************************************

//** getHistogram

//**************************************************************************

/** Returns an array with 4 histograms: red, green, blue, and average

public java.util.ArrayList<int[]> getHistogram(){

//Create empty histograms

int[] red = new int[256];

int[] green = new int[256];

int[] blue = new int[256];

int[] average = new int[256];

for (int i=0; i<red.length; i++) red[i] = 0;

for (int i=0; i<green.length; i++) green[i] = 0;

for (int i=0; i<blue.length; i++) blue[i] = 0;

for (int i=0; i<average.length; i++) average[i] = 0;

//Populate the histograms

for (int i=0; i<this.getWidth(); i++){

for (int j=0; j<this.getHeight(); j++){

Color color = this.getColor(i, j);

int r = color.getRed();

int g = color.getGreen();

int b = color.getBlue();

red[r] = red[r]+1;

green[g] = green[g]+1;

blue[b] = blue[b]+1;

int avg = Math.round((r+g+b)/3);

average[avg] = average[avg]+1;

}

}

java.util.ArrayList<int[]> hist = new java.util.ArrayList<int[]>();

hist.add(red);

hist.add(green);

hist.add(blue);

hist.add(average);

return hist;

}

//**************************************************************************

//** addImage

//**************************************************************************

/** Used to add an image "overlay" to the existing image at a given

public void addImage(BufferedImage in, int x, int y, boolean expand){

int x2 = 0;

int y2 = 0;

int w = bufferedImage.getWidth();

int h = bufferedImage.getHeight();

if (expand){

//Update Width and Horizontal Position of the Original Image

if (x<0) {

w = w + -x;

if (in.getWidth()>w){

w = w + (in.getWidth()-w);

}

x2 = -x;

x = 0;

}

else if (x>w) {

w = (w + (x-w)) + in.getWidth();

}

else{

if ((x+in.getWidth())>w){

w = w + ((x+in.getWidth())-w);

}

}

//Update Height and Vertical Position of the Original Image

if (y<0){

h = h + -y;

if (in.getHeight()>h){

h = h + (in.getHeight()-h);

}

y2 = -y;

y = 0;

}

else if(y>h){

h = (h + (y-h)) + in.getHeight();

}

else{

if ((y+in.getHeight())>h){

h = h + ((y+in.getHeight())-h);

}

}

}

//Create new image "collage"

if (w>bufferedImage.getWidth() || h>bufferedImage.getHeight()){

BufferedImage bi = new BufferedImage(w, h, getImageType());

Graphics2D g2d = bi.createGraphics();

java.awt.Image img = bufferedImage;

g2d.drawImage(img, x2, y2, null);

img = in;

g2d.drawImage(img, x, y, null);

g2d.dispose();

bufferedImage = bi;

}

else{

Graphics2D g2d = bufferedImage.createGraphics();

java.awt.Image img = in;

g2d.drawImage(img, x, y, null);

g2d.dispose();

}

}

//**************************************************************************

//** addImage

//**************************************************************************

/** Used to add an image "overlay" to the existing image at a given

public void addImage(javaxt.io.Image in, int x, int y, boolean expand){

addImage(in.getBufferedImage(),x,y,expand);

}

//**************************************************************************

//** createBufferedImage

//**************************************************************************

/** Used to create a BufferedImage from a InputStream

private void createBufferedImage(java.io.InputStream input) {

try{

//bufferedImage = ImageIO.read(input);

javax.imageio.stream.ImageInputStream stream = ImageIO.createImageInputStream(input);

Iterator iter = ImageIO.getImageReaders(stream);

if (!iter.hasNext()) {

return;

}

ImageReader reader = (ImageReader)iter.next();

ImageReadParam param = reader.getDefaultReadParam();

reader.setInput(stream, true, true);

try {

bufferedImage = reader.read(0, param);

metadata = reader.getImageMetadata(0);

}

finally {

reader.dispose();

stream.close();

}

input.close();

}

catch(Exception e){

//e.printStackTrace();

}

}

//**************************************************************************

//** Rotate

//**************************************************************************

/** Used to rotate the image (clockwise). Rotation angle is specified in

public void rotate(double Degrees){

//Define Image Center (Axis of Rotation)

int width = this.getWidth();

int height = this.getHeight();

int cx = width/2;

int cy = height/2;

//create an array containing the corners of the image (TL,TR,BR,BL)

int[] corners = { 0, 0, width, 0, width, height, 0, height };

//Define bounds of the image

int minX, minY, maxX, maxY;

minX = maxX = cx;

minY = maxY = cy;

double theta = Math.toRadians(Degrees);

for (int i=0; i<corners.length; i+=2){

//Rotates the given point theta radians around (cx,cy)

int x = (int) Math.round(

Math.cos(theta)*(corners[i]-cx) -

Math.sin(theta)*(corners[i+1]-cy)+cx

);

int y = (int) Math.round(

Math.sin(theta)*(corners[i]-cx) +

Math.cos(theta)*(corners[i+1]-cy)+cy

);

//Update our bounds

if(x>maxX) maxX = x;

if(x<minX) minX = x;

if(y>maxY) maxY = y;

if(y<minY) minY = y;

}

//Update Image Center Coordinates

cx = (int)(cx-minX);

cy = (int)(cy-minY);

//Create Buffered Image

BufferedImage result = new BufferedImage(maxX-minX, maxY-minY,

BufferedImage.TYPE_INT_ARGB);

//Create Graphics

Graphics2D g2d = result.createGraphics();

//Enable anti-alias and Cubic Resampling

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,

RenderingHints.VALUE_INTERPOLATION_BICUBIC);

//Rotate the image

AffineTransform xform = new AffineTransform();

xform.rotate(theta,cx,cy);

g2d.setTransform(xform);

g2d.drawImage(bufferedImage,-minX,-minY,null);

g2d.dispose();

//Update Class Variables

this.bufferedImage = result;

//Delete Heavy Objects

result = null;

xform = null;

}

//**************************************************************************

//** rotateClockwise

//**************************************************************************

/** Rotates the image 90 degrees clockwise

public void rotateClockwise(){

rotate(90);

}

//**************************************************************************

//** rotateCounterClockwise

//**************************************************************************

/** Rotates the image -90 degrees

public void rotateCounterClockwise(){

rotate(-90);

}

//**************************************************************************

//** rotate

//**************************************************************************

/** Used to automatically rotate the image based on the image metadata

public void rotate(){

try {

Integer orientation = (Integer) getExifTags().get(0x0112);

switch (orientation) {

case 1: return; //"Top, left side (Horizontal / normal)"

case 2: flip(); break; //"Top, right side (Mirror horizontal)";

case 3: rotate(180); break; //"Bottom, right side (Rotate 180)";

case 4: {flip(); rotate(180);} break; //"Bottom, left side (Mirror vertical)";

case 5: {flip(); rotate(270);} break; //"Left side, top (Mirror horizontal and rotate 270 CW)";

case 6: rotate(90); break; //"Right side, top (Rotate 90 CW)";

case 7: {flip(); rotate(90);} break; //"Right side, bottom (Mirror horizontal and rotate 90 CW)";

case 8: rotate(270); break; //"Left side, bottom (Rotate 270 CW)";

}

}

catch(Exception e){

//Failed to parse exif orientation.

}

}

//**************************************************************************

//** setWidth

//**************************************************************************

/** Resizes the image to a given width. The original aspect ratio is

public void setWidth(int Width){

double ratio = (double)Width/(double)this.getWidth();

double dw = this.getWidth() * ratio;

double dh = this.getHeight() * ratio;

int outputWidth = (int)Math.round(dw);

int outputHeight = (int)Math.round(dh);

resize(outputWidth,outputHeight);

}

//**************************************************************************

//** setHeight

//**************************************************************************

/** Resizes the image to a given height. The original aspect ratio is

public void setHeight(int Height){

double ratio = (double)Height/(double)this.getHeight();

double dw = this.getWidth() * ratio;

double dh = this.getHeight() * ratio;

int outputWidth = (int)Math.round(dw);

int outputHeight = (int)Math.round(dh);

resize(outputWidth,outputHeight);

}

//**************************************************************************

//** resize (Overloaded Member)

//**************************************************************************

/** Used to resize an image. Does NOT automatically retain the original

public void resize(int width, int height){

resize(width, height, false);

}

//**************************************************************************

//** resize

//**************************************************************************

/** Used to resize an image. Provides the option to maintain the original

public void resize(int width, int height, boolean maintainRatio){

if (maintainRatio){

int maxWidth = width;

int maxHeight = height;

if (maxHeight<maxWidth){

//Set height

double ratio = (double)maxHeight/(double)this.getHeight();

width = (int)Math.round(this.getWidth() * ratio);

height = (int)Math.round(this.getHeight() * ratio);

if (width>maxWidth){

//Set width

ratio = (double)maxWidth/(double)width;

width = (int)Math.round(width * ratio);

height = (int)Math.round(height * ratio);

}

}

else{

//Set width

double ratio = (double)maxWidth/(double)this.getWidth();

width = (int)Math.round(this.getWidth() * ratio);

height = (int)Math.round(this.getHeight() * ratio);

if (height>maxHeight){

//Set height

ratio = (double)maxHeight/(double)height;

width = (int)Math.round(width * ratio);

height = (int)Math.round(height * ratio);

}

}

}

//Resize the image (create new buffered image)

java.awt.Image outputImage = bufferedImage.getScaledInstance(width, height, BufferedImage.SCALE_AREA_AVERAGING);

BufferedImage bi = new BufferedImage(width, height, getImageType());

Graphics2D g2d = bi.createGraphics( );

g2d.drawImage(outputImage, 0, 0, null);

g2d.dispose();

this.bufferedImage = bi;

outputImage = null;

bi = null;

g2d = null;

}

//**************************************************************************

//** Set/Update Corners (Skew)

//**************************************************************************

/** Used to skew an image by updating the corner coordinates. Coordinates

public void setCorners(float x0, float y0, //UL

float x1, float y1, //UR

float x2, float y2, //LR

float x3, float y3){ //LL

Skew skew = new Skew(this.bufferedImage);

this.bufferedImage = skew.setCorners(x0,y0,x1,y1,x2,y2,x3,y3);

if (corners==null) corners = new java.util.ArrayList();

else corners.clear();

corners.add((Float)x0); corners.add((Float)y0);

corners.add((Float)x1); corners.add((Float)y1);

corners.add((Float)x2); corners.add((Float)y2);

corners.add((Float)x3); corners.add((Float)y3);

}

//**************************************************************************

//** Get Corners

//**************************************************************************

/** Used to retrieve the corner coordinates of the image. Coordinates are

public float[] getCorners(){

if (corners==null){

float w = getWidth();

float h = getHeight();

corners = new java.util.ArrayList();

corners.add((Float)0f); corners.add((Float)0f);

corners.add((Float)w); corners.add((Float)0f);

corners.add((Float)w); corners.add((Float)h);

corners.add((Float)0f); corners.add((Float)h);

}

Object[] arr = corners.toArray();

float[] ret = new float[arr.length];

for (int i=0; i<arr.length; i++){

Float f = (Float) arr[i];

ret[i] = f.floatValue();

}

return ret;

}

//**************************************************************************

//** Sharpen

//**************************************************************************

/** Used to sharpen the image using a 3x3 kernel.

public void sharpen(){

int width = this.getWidth();

int height = this.getHeight();

//define kernel

Kernel kernel = new Kernel(3, 3,

new float[] {

0.0f, -0.2f, 0.0f,

-0.2f, 1.8f, -0.2f,

0.0f, -0.2f, 0.0f });

//apply convolution

BufferedImage out = new BufferedImage(width, height, getImageType());

BufferedImageOp op = new ConvolveOp(kernel);

out = op.filter(bufferedImage, out);

//replace 2 pixel border created via convolution

java.awt.Image overlay = out.getSubimage(2,2,width-4,height-4);

Graphics2D g2d = bufferedImage.createGraphics();

g2d.drawImage(overlay,2,2,null);

g2d.dispose();

}

//**************************************************************************

//** blur

//**************************************************************************

/** Used to blur the image using a Gaussian kernel.

public void blur(float radius){

//Create kernel

int r = (int)Math.ceil(radius);

int rows = r*2+1;

float[] matrix = new float[rows];

float sigma = radius/3;

float sigma22 = 2*sigma*sigma;

float sigmaPi2 = (float)(2*Math.PI*sigma);

float sqrtSigmaPi2 = (float)Math.sqrt(sigmaPi2);

float radius2 = radius*radius;

float total = 0;

int index = 0;

for (int row = -r; row <= r; row++) {

float distance = row*row;

if (distance > radius2)

matrix[index] = 0;

else

matrix[index] = (float)Math.exp(-(distance)/sigma22) / sqrtSigmaPi2;

total += matrix[index];

index++;

}

for (int i = 0; i < rows; i++)

matrix[i] /= total;

Kernel kernel = new Kernel(rows, 1, matrix);

//

int width = this.getWidth();

int height = this.getHeight();

int[] inPixels = new int[width*height];

int[] outPixels = new int[width*height];

bufferedImage.getRGB( 0, 0, width, height, inPixels, 0, width );

convolveAndTranspose(kernel, inPixels, outPixels, width, height, true, CLAMP_EDGES);

convolveAndTranspose(kernel, outPixels, inPixels, height, width, true, CLAMP_EDGES);

bufferedImage.setRGB( 0, 0, width, height, inPixels, 0, width );

}

private static int CLAMP_EDGES = 1;

private static int WRAP_EDGES = 2;

//**************************************************************************

//** convolveAndTranspose

//**************************************************************************

/** Applies 1D Gaussian kernel used to blur an image. This filter should be

private static void convolveAndTranspose(Kernel kernel, int[] inPixels, int[] outPixels,

int width, int height, boolean alpha, int edgeAction) {

float[] matrix = kernel.getKernelData( null );

int cols = kernel.getWidth();

int cols2 = cols/2;

for (int y = 0; y < height; y++) {

int index = y;

int ioffset = y*width;

for (int x = 0; x < width; x++) {

float r = 0, g = 0, b = 0, a = 0;

int moffset = cols2;

for (int col = -cols2; col <= cols2; col++) {

float f = matrix[moffset+col];

if (f != 0) {

int ix = x+col;

if ( ix < 0 ) {

if ( edgeAction == CLAMP_EDGES )

ix = 0;

else if ( edgeAction == WRAP_EDGES )

ix = (x+width) % width;

} else if ( ix >= width) {

if ( edgeAction == CLAMP_EDGES )

ix = width-1;

else if ( edgeAction == WRAP_EDGES )

ix = (x+width) % width;

}

int rgb = inPixels[ioffset+ix];

a += f * ((rgb >> 24) & 0xff);

r += f * ((rgb >> 16) & 0xff);

g += f * ((rgb >> 8) & 0xff);

b += f * (rgb & 0xff);

}

}

int ia = alpha ? clamp((int)(a+0.5)) : 0xff;