|
JavaXT
|
|
Image Class
package javaxt.io;
import java.io.*;
import javax.imageio.*;
import javax.imageio.metadata.*;
import java.awt.image.*;
import java.awt.color.ColorSpace;
import java.awt.geom.AffineTransform;
import java.awt.*;
import java.util.HashSet;
import java.util.HashMap;
import java.util.Iterator;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.NamedNodeMap;
//Imports for JPEG
//import com.sun.image.codec.jpeg.*; //<-- Not always available in newer versions
import javax.imageio.plugins.jpeg.JPEGImageWriteParam;
//Imports for JP2
//import javax.media.jai.RenderedOp;
//import com.sun.media.imageio.plugins.jpeg2000.J2KImageReadParam;
//******************************************************************************
//** Image Class
//******************************************************************************
/**
* Used to open, resize, rotate, crop and save images.
*
******************************************************************************/
public class Image {
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.
* @param fontName Name of the font you with to use. Note that you can get
* a list of available fonts like this:
<pre>
for (String fontName : GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames()){
System.out.println(fontName);
}
</pre>
*/
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
* under the existing graphic. This method should only be called once.
*/
public void setBackgroundColor(int r, int g, int b){
/*
Color org = g2d.getColor();
g2d.setColor(new Color(r,g,b));
g2d.fillRect(1,1,width-2,height-2); //g2d.fillRect(0,0,width,height);
g2d.setColor(org);
*/
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
* to compress jpeg images. These classes are marked as deprecated in Java
* 1.7 and several distributions of Java no longer include these classes
* (e.g. "IcedTea" OpenJDK 7). Returns true of the classes are available.
*/
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.
* @param x Lower left coordinate of the text
* @param y Lower left coordinate of the text
*/
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.
* @param x Lower left coordinate of the text
* @param y Lower left coordinate of the text
* @param fontName Name of the font face (e.g. "Tahoma", "Helvetica", etc.)
* @param fontSize Size of the font
* @param r Value for the red channel (0-255)
* @param g Value for the green channel (0-255)
* @param b Value for the blue channel (0-255)
*/
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.
* @param x Lower left coordinate of the text
* @param y Lower left coordinate of the text
* @param font Font
* @param r Value for the red channel (0-255)
* @param g Value for the green channel (0-255)
* @param b Value for the blue channel (0-255)
*/
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
* image.
*/
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.
* Note that input x,y values are relative to the upper left corner of the
* image, starting at 0,0.
*/
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
* image. Returns a java.awt.Color object. Note that input x,y values are
* relative to the upper left corner of the image, starting at 0,0.
*/
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
<pre>
ArrayList<int[]> histogram = image.getHistogram();
int[] red = histogram.get(0);
int[] green = histogram.get(1);
int[] blue = histogram.get(2);
int[] average = histogram.get(3);
</pre>
*/
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
* position. This method can also be used to create image mosiacs.
*/
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
* position. This method can also be used to create image mosiacs.
*/
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
* degrees relative to the top of the image.
*/
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
* (e.g. EXIF Orientation tag)
*/
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
* maintained.
*/
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
* maintained.
*/
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
* aspect ratio.
*/
public void resize(int width, int height){
resize(width, height, false);
}
//**************************************************************************
//** resize
//**************************************************************************
/** Used to resize an image. Provides the option to maintain the original
* aspect ratio.
* @param maintainRatio If true, will interpret the given width and height
* as maximum desired width and height
*/
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
* are supplied in clockwise order starting from the upper left corner.
*/
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
* supplied in clockwise order starting from the upper left corner. This
* information is particularly useful for generating drop shadows, inner
* and outer glow, and reflections.
* NOTE: Coordinates are not updated after resize(), rotate(), or addImage()
*/
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
* applied twice, once horizontally and once vertically.
* @author Jerry Huxtable
*/
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;
int ir = clamp((int)(r+0.5));
int ig = clamp((int)(g+0.5));
int ib = clamp((int)(b+0.5));
outPixels[index] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
index += height;
}
}
}
//**************************************************************************
//** clamp
//**************************************************************************
/** Clamp a value to the range 0..255
*/
private static int clamp(int c) {
if (c < 0) return 0;
if (c > 255) return 255;
return c;
}
//**************************************************************************
//** Desaturate
//**************************************************************************
/** Used to completely desaturate an image (creates a gray-scale image).
*/
public void desaturate(){
bufferedImage = desaturate(bufferedImage);
}
//**************************************************************************
//** Desaturate
//**************************************************************************
/** Used to desaturate an image by a specified percentage (expressed as
* a double or float). The larger the percentage, the greater the
* desaturation and the "grayer" the image. Valid ranges are from 0-1.
*/
public void desaturate(double percent){
float alpha = (float) (percent);
java.awt.Image overlay = desaturate(bufferedImage);
Graphics2D g2d = bufferedImage.createGraphics();
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
g2d.drawImage(overlay,0,0,null);
g2d.dispose();
}
//**************************************************************************
//** Desaturate (Private Function)
//**************************************************************************
/** Convenience function called by the other 2 desaturation methods.
*/
private BufferedImage desaturate(BufferedImage in){
BufferedImage out = new BufferedImage(in.getWidth(), in.getHeight(), getImageType(in) );
BufferedImageOp op = new ColorConvertOp(
ColorSpace.getInstance(ColorSpace.CS_GRAY), null);
return op.filter(in, out);
}
//**************************************************************************
//** setOpacity
//**************************************************************************
/** Used to adjust the opacity of the image.
*/
public void setOpacity(double percent){
if (percent>1) percent=percent/100;
float alpha = (float) (percent);
int imageType = bufferedImage.getType();
if (imageType == 0) {
imageType = BufferedImage.TYPE_INT_ARGB;
}
BufferedImage out = new BufferedImage(getWidth(),getHeight(),imageType);
Graphics2D g2d = out.createGraphics();
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
g2d.drawImage(bufferedImage,0,0,null);
g2d.dispose();
bufferedImage = out;
}
//**************************************************************************
//** Flip (Horizonal)
//**************************************************************************
/** Used to flip an image along it's y-axis (horizontal). Vertical flipping
* is supported via the rotate method (i.e. rotate +/-180).
*/
public void flip(){
BufferedImage out = new BufferedImage(getWidth(), getHeight(), getImageType());
AffineTransform tx = AffineTransform.getScaleInstance(-1, 1);
tx.translate(-bufferedImage.getWidth(), 0);
AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_BICUBIC);
bufferedImage = op.filter(bufferedImage, out);
}
//**************************************************************************
//** Crop
//**************************************************************************
/** Used to crop/subset the current image.
*/
public void crop(int x, int y, int width, int height){
bufferedImage = getSubimage(x,y,width,height);
}
//**************************************************************************
//** copy
//**************************************************************************
/** Returns a copy of the current image.
*/
public Image copy(){
ColorModel cm = bufferedImage.getColorModel();
boolean isAlphaPremultiplied = cm.isAlphaPremultiplied();
WritableRaster raster = bufferedImage.copyData(null);
BufferedImage bi = new BufferedImage(cm, raster, isAlphaPremultiplied, null);
bi = bi.getSubimage(0, 0, bufferedImage.getWidth(), bufferedImage.getHeight());
return new Image(bi);
}
//**************************************************************************
//** copyRect
//**************************************************************************
/** Returns a copy of the image at a given rectangle.
*/
public Image copyRect(int x, int y, int width, int height){
return new Image(getSubimage(x,y,width,height));
}
//**************************************************************************
//** getSubimage
//**************************************************************************
/** Returns a copy of the image at a given rectangle. In Java 1.6, the
* BufferedImage.getSubimage() throws an exception if the rectangle falls
* outside the image bounds. This method was written to overcome this
* limitation.
*/
private BufferedImage getSubimage(int x, int y, int width, int height){
Rectangle rect1 = new Rectangle(0, 0, bufferedImage.getWidth(), bufferedImage.getHeight());
Rectangle rect2 = new Rectangle(x, y, width, height);
//If the requested rectangle falls inside the image bounds, simply return
//the subimage
if (rect1.contains(rect2)){
return (bufferedImage.getSubimage(x,y,width,height));
}
else{ //requested rectangle falls outside the image bounds!
//Create buffered image
BufferedImage bi = new BufferedImage(width, height, getImageType());
//If the requested rectangle intersects the image bounds, crop the
//the source image and insert it into the BufferedImage
if (rect1.intersects(rect2)){
Graphics2D g2d = bi.createGraphics();
BufferedImage subImage = null;
int X;
int Y;
if (x<0){
int x1 = 0;
int y1;
int h;
int w;
if (y<0){
y1 = 0;
h = y+height;
Y = height - h;
}
else{
y1 = y;
h = height;
Y = 0;
}
if (h+y1>bufferedImage.getHeight()) h = bufferedImage.getHeight()-y1;
w = x+width;
if (w>bufferedImage.getWidth()) w = bufferedImage.getWidth();
subImage = bufferedImage.getSubimage(x1,y1,w,h);
X = width - w;
}
else{
int x1 = x;
int y1;
int h;
int w;
if (y<0){
y1 = 0;
h = y+height;
Y = height - h;
}
else{
y1 = y;
h = height;
Y = 0;
}
if (h+y1>bufferedImage.getHeight()) h = bufferedImage.getHeight()-y1;
w = width;
if (w+x1>bufferedImage.getWidth()) w = bufferedImage.getWidth()-x1;
X = 0;
subImage = bufferedImage.getSubimage(x1,y1,w,h);
}
g2d.drawImage(subImage, X, Y, null);
g2d.dispose();
}
return bi;
}
}
//**************************************************************************
//** trim
//**************************************************************************
/** Used to remove excess pixels around an image by cropping the image to its
* "true" extents. Crop bounds are determined by finding the first non-null
* or non-black pixel on each side of the image.
*/
public void trim(){
trim(0,0,0);
}
//**************************************************************************
//** trim
//**************************************************************************
/** Used to remove excess pixels around an image by cropping the image to its
* "true" extents. Crop bounds are determined by finding pixels that *don't*
* match the input color. For example, you can trim off excess black pixels
* around an image by specifying an rgb value of 0,0,0. Similarly, you can
* trim off pure white pixels around an image by specifying an rgb value of
* 255,255,255. Note that transparent pixels are considered as null values
* and will be automatically trimmed from the edges.
*/
public void trim(int r, int g, int b){
int top = 0;
int bottom = 0;
int left = 0;
int right = 0;
for (int y=0; y<bufferedImage.getHeight(); y++){
for (int x=0; x<bufferedImage.getWidth(); x++){
if (hasColor(bufferedImage.getRGB(x, y), r, g, b)){
bottom = y;
break;
}
}
}
for (int y=bufferedImage.getHeight()-1; y>-1; y--){
for (int x=0; x<bufferedImage.getWidth(); x++){
if (hasColor(bufferedImage.getRGB(x, y), r, g, b)){
top = y;
break;
}
}
}
for (int x=0; x<bufferedImage.getWidth(); x++){
for (int y=0; y<bufferedImage.getHeight(); y++){
if (hasColor(bufferedImage.getRGB(x, y), r, g, b)){
right = x;
break;
}
}
}
for (int x=bufferedImage.getWidth()-1; x>-1; x--){
for (int y=0; y<bufferedImage.getHeight(); y++){
if (hasColor(bufferedImage.getRGB(x, y), r, g, b)){
left = x;
break;
}
}
}
if (left==right || top==bottom){
bufferedImage = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
}
else{
bufferedImage = bufferedImage.getSubimage(left,top,right-left,bottom-top);
}
}
//**************************************************************************
//** getBufferedImage
//**************************************************************************
/** Returns the java.awt.image.BufferedImage represented by the current
* image.
*/
public BufferedImage getBufferedImage(){
return bufferedImage;
}
//**************************************************************************
//** getImage
//**************************************************************************
/** Returns a java.awt.Image copy of the current image. */
public java.awt.Image getImage(){
return getBufferedImage();
}
//**************************************************************************
//** getImage
//**************************************************************************
/** Returns a java.awt.image.RenderedImage copy of the current image. */
public java.awt.image.RenderedImage getRenderedImage(){
return getBufferedImage();
}
//**************************************************************************
//** getBufferedImage
//**************************************************************************
/** Used to retrieve a scaled copy of the current image. */
public BufferedImage getBufferedImage(int width, int height, boolean maintainRatio){
Image image = new Image(getBufferedImage());
image.resize(width,height,maintainRatio);
return image.getBufferedImage();
}
//**************************************************************************
//** getByteArray
//**************************************************************************
/** Returns the image as a jpeg byte array. Output quality is set using
* the setOutputQuality method.
*/
public byte[] getByteArray(){
return getByteArray("jpeg");
}
//**************************************************************************
//** getByteArray
//**************************************************************************
/** Returns the image as a byte array. */
public byte[] getByteArray(String format){
byte[] rgb = null;
format = format.toLowerCase();
if (format.startsWith("image/")){
format = format.substring(format.indexOf("/")+1);
}
try{
if (isJPEG(format)){
rgb = getJPEGByteArray(outputQuality);
}
else{
ByteArrayOutputStream bas = new ByteArrayOutputStream();
ImageIO.write(bufferedImage, format.toLowerCase(), bas);
rgb = bas.toByteArray();
}
}
catch(Exception e){}
return rgb;
}
//**************************************************************************
//** saveAs
//**************************************************************************
/** Exports the image to a file. Output format is determined by the output
* file extension.
*/
public void saveAs(String PathToImageFile){
saveAs(new java.io.File(PathToImageFile));
}
//**************************************************************************
//** saveAs
//**************************************************************************
/** Exports the image to a file. Output format is determined by the output
* file extension.
*/
public void saveAs(java.io.File OutputFile){
try{
//Create output directory
OutputFile.getParentFile().mkdirs();
//Write buffered image to disk
String FileExtension = getExtension(OutputFile.getName()).toLowerCase();
if (isJPEG(FileExtension)){
FileOutputStream output = new FileOutputStream(OutputFile);
output.write(getJPEGByteArray(outputQuality));
output.close();
}
else{
RenderedImage rendImage = bufferedImage;
if (isJPEG2000(FileExtension)){
ImageIO.write(rendImage, "JPEG 2000", OutputFile);
}
else{
ImageIO.write(rendImage, FileExtension, OutputFile);
}
rendImage = null;
}
//System.out.println("Output image is " + width + "x" + height + "...");
}
catch(Exception e){
//printError(e);
}
}
/*
public void setCacheDirectory(java.io.File cacheDirectory){
try{
if (cacheDirectory.isFile()){
cacheDirectory = cacheDirectory.getParentFile();
}
cacheDirectory.mkdirs();
ImageIO.setUseCache(true);
this.cacheDirectory = cacheDirectory;
}
catch(Exception e){
this.cacheDirectory = null;
}
}
public java.io.File getCacheDirectory(){
return cacheDirectory;
}
*/
//**************************************************************************
//** setOutputQuality
//**************************************************************************
/** Used to set the output quality/compression ratio. Only applies when
* creating JPEG images. Applied only when writing the image to a file or
* byte array. Accepts values between 0-1. Also accepts values between
* 1-100. If the latter, it divides the value by 100.
*/
public void setOutputQuality(float quality){
if (quality>1&&quality<=100) quality=quality/100;
if (quality==1f && useSunCodec) quality = 1.2f;
if (quality>=0f && quality<=1.2f) outputQuality = quality;
}
//**************************************************************************
//** isJPEG
//**************************************************************************
/** Returns true if the given file extension is associated with a jpeg
* compressed image.
*/
private boolean isJPEG(String FileExtension){
FileExtension = FileExtension.trim().toLowerCase();
if (FileExtension.equals("jpg") ||
FileExtension.equals("jpeg") ||
FileExtension.equals("jpe") ||
FileExtension.equals("jff") ){
return true;
}
return false;
}
//**************************************************************************
//** isJPEG2000
//**************************************************************************
/** Returns true if the given file extension is associated with a jpeg2000
* compressed image.
*/
private boolean isJPEG2000(String FileExtension){
FileExtension = FileExtension.trim().toLowerCase();
if (FileExtension.equals("jp2") ||
FileExtension.equals("jpc") ||
FileExtension.equals("j2k") ||
FileExtension.equals("jpx") ){
return true;
}
return false;
}
//**************************************************************************
//** getJPEGByteArray
//**************************************************************************
/** Returns a JPEG compressed byte array. */
private byte[] getJPEGByteArray(float outputQuality) throws IOException {
if (outputQuality>=0f && outputQuality<=1.2f) {
ByteArrayOutputStream bas = new ByteArrayOutputStream();
BufferedImage bi = bufferedImage;
int t = bufferedImage.getTransparency();
//if (t==BufferedImage.BITMASK) System.out.println("BITMASK");
//if (t==BufferedImage.OPAQUE) System.out.println("OPAQUE");
if (t==BufferedImage.TRANSLUCENT){
bi = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
Graphics2D biContext = bi.createGraphics();
biContext.drawImage ( bufferedImage, 0, 0, null );
}
//First we will try to compress the image using the com.sun.image.codec.jpeg
//package. These classes are marked as deprecated in JDK 1.7 and several
//users have reported problems with this method. Instead, we are
//supposed to use the JPEGImageWriteParam class. However, I have not
//been able to adequatly test the compression quality or find an
//anology to the setHorizontalSubsampling and setVerticalSubsampling
//methods. Therefore, we will attempt to compress the image using the
//com.sun.image.codec.jpeg package. If the compression fails, we will
//use the JPEGImageWriteParam.
if (useSunCodec){
try{
//For Java 1.7 users, we will try to invoke the Sun JPEG Codec using reflection
Object encoder = JPEGCodec.getMethod("createJPEGEncoder", java.io.OutputStream.class).invoke(JPEGCodec, bas);
Object params = JPEGCodec.getMethod("getDefaultJPEGEncodeParam", BufferedImage.class).invoke(JPEGCodec, bi);
params.getClass().getMethod("setQuality", float.class, boolean.class).invoke(params, outputQuality, true);
params.getClass().getMethod("setHorizontalSubsampling", int.class, int.class).invoke(params, 0, 2);
params.getClass().getMethod("setVerticalSubsampling", int.class, int.class).invoke(params, 0, 2);
//Here's the original compression code without reflection
/*
JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(bas);
JPEGEncodeParam params = JPEGCodec.getDefaultJPEGEncodeParam(bi);
params.setQuality(outputQuality, true); //true
params.setHorizontalSubsampling(0,2);
params.setVerticalSubsampling(0,2);
params.setMarkerData(...);
encoder.encode(bi, params);
*/
//Save metadata as needed
if (saveMetadata && metadata!=null){
java.lang.reflect.Method setMarkerData = params.getClass().getMethod("setMarkerData", int.class, byte[][].class);
//Parse unknown markers (similar logic to the getUnknownTags method)
java.util.HashSet<Integer> markers = new java.util.HashSet<Integer>();
for (String name : metadata.getMetadataFormatNames()) {
IIOMetadataNode node = (IIOMetadataNode) metadata.getAsTree(name);
for (Node unknownNode : getElementsByTagName("unknown", node)){
String markerTag = getAttributeValue(unknownNode.getAttributes(), "MarkerTag");
try{
int marker = Integer.parseInt(markerTag);
if (!markers.contains(marker)){
markers.add(marker);
byte[] data = (byte[]) ((IIOMetadataNode) unknownNode).getUserObject();
if (data!=null){
byte[][] app = new byte[1][data.length];
app[0] = data;
setMarkerData.invoke(params, marker, app);
}
}
}
catch(Exception e){
//e.printStackTrace();
}
}
}
}
encoder.getClass().getMethod("encode", BufferedImage.class, JPEGEncodeParam).invoke(encoder, bi, params);
}
catch(Exception e){
bas.reset();
}
}
//If the com.sun.image.codec.jpeg package is not found or if the
//compression failed, we will use the JPEGImageWriteParam class.
if (bas.size()==0){
if (outputQuality>1f) outputQuality = 1f;
ImageWriter writer = ImageIO.getImageWritersByFormatName("jpg").next();
JPEGImageWriteParam params = (JPEGImageWriteParam) writer.getDefaultWriteParam();
params.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
params.setCompressionQuality(outputQuality);
writer.setOutput(ImageIO.createImageOutputStream(bas));
if (saveMetadata){
writer.write(metadata, new IIOImage(bi, null, metadata), params);
}
else{
writer.write(null, new IIOImage(bi, null, null), params);
}
}
bas.flush();
return bas.toByteArray();
}
else{
return getByteArray();
}
}
//**************************************************************************
//** getImageType
//**************************************************************************
private int getImageType(){
return getImageType(this.bufferedImage);
}
private int getImageType(BufferedImage bufferedImage){
int imageType = bufferedImage.getType();
if (imageType <= 0 || imageType == 12) {
imageType = BufferedImage.TYPE_INT_ARGB;
}
return imageType;
}
//**************************************************************************
//** getExtension
//**************************************************************************
/** Returns the file extension for a given file name, if one exists. */
private String getExtension(String FileName){
if (FileName.contains((CharSequence) ".")){
return FileName.substring(FileName.lastIndexOf(".")+1,FileName.length());
}
else{
return "";
}
}
//**************************************************************************
//** hasColor
//**************************************************************************
/** Used to determine whether a given pixel has a color value. Returns false
* if the pixel matches the input color or is transparent.
*/
private boolean hasColor(int pixel, int red, int green, int blue){
int a = (pixel >> 24) & 0xff;
int r = (pixel >> 16) & 0xff;
int g = (pixel >> 8) & 0xff;
int b = (pixel) & 0xff;
if ((r==red && g==green && b==blue) || a==0 ){
return false;
}
return true;
}
//**************************************************************************
//** equals
//**************************************************************************
/** Used to compare this image to another. Returns true if the all the
* pixels (ARGB values) match. See isSimilarTo() to compare similar images.
*/
public boolean equals(Object obj){
if (obj!=null){
if (obj instanceof javaxt.io.Image){
javaxt.io.Image image = (javaxt.io.Image) obj;
if (image.getWidth()==this.getWidth() &&
image.getHeight()==this.getHeight())
{
//Iterate through all the pixels in the image and compare RGB values
for (int i=0; i<image.getWidth(); i++){
for (int j=0; j<image.getHeight(); j++){
if (!image.getColor(i,j).equals(this.getColor(i,j))){
return false;
}
}
}
return true;
}
}
}
return false;
}
//**************************************************************************
//** isSimilarTo
//**************************************************************************
/** Returns true if a given image is similar to (or equal to) this image.
* Unlike the equals() method which performs an exact match, this method
* performs a fuzzy match using perceptual hash values for the images.
* Returns true if the Hamming Distance between the two images is 0.
*/
public boolean isSimilarTo(Image image){
return isSimilarTo(image, 0);
}
//**************************************************************************
//** isSimilarTo
//**************************************************************************
/** Returns true if a given image is similar to this image. Performs a fuzzy
* match using perceptual hash values for the images.
* @param image An image to compare to
* @param threshold The minimum hamming distance between the two images
*/
public boolean isSimilarTo(Image image, int threshold){
if (image==null) return false;
int d = getHammingDistance(image);
return (d<=threshold);
}
//**************************************************************************
//** getHammingDistance
//**************************************************************************
/** Returns the Hamming Distance between this image and a given image using
* perceptual hash values for the images.
*/
public int getHammingDistance(Image image){
String hash = Long.toBinaryString(getPHash());
String target = Long.toBinaryString(image.getPHash());
int d = 0;
for (int i=0; i<hash.length(); i++) {
if (hash.charAt(i) != target.charAt(i)) {
d++;
}
}
return d;
}
//**************************************************************************
//** getPHash
//**************************************************************************
/** Returns a perceptual hash value for the image. Unlike traditional
* cryptographic hashes like SHA1, PHash is not sensitive to tiny
* variations in an image. This makes it ideal to find similar images.
* @return A 64-bit long value (PHash). A string representation of the
* hash (e.g. Long.toBinaryString) would look something like this:
* "1101001010111111010011111110111000011001001011110011110111001101"
*/
public long getPHash(){
//Clone the image
BufferedImage bi = new BufferedImage(
bufferedImage.getWidth(), bufferedImage.getHeight(), getImageType());
Graphics2D g = bi.createGraphics();
g.drawImage(bufferedImage, 0, 0, bi.getWidth(), bi.getHeight(), null);
g.dispose();
Image image = new Image(bi);
//Resize and desaturate
int size = 32;
image.resize(size, size, false);
image.desaturate();
bi = image.getBufferedImage();
//Perform DCT-II by row
double N = size;
double[][] f = new double[size][size];
for (int y = 0; y < image.getHeight(); y++) {
for (int x = 0; x < image.getWidth(); x++) {
double k = x;
double sum = 0.0;
for (double n=0; n<N; n++){
double v = (bi.getRGB((int)n, y)) & 0xff;
sum += (2.0*v)*Math.cos(Math.PI * k * ((2.0*n+1)/(2.0*N)));
}
f[x][y] = sum;
}
}
//Perform DCT-II by column
double[][] F = new double[size][size];
for (int x = 0; x < image.getWidth(); x++) {
for (int y = 0; y < image.getHeight(); y++) {
double k = y;
double sum = 0.0;
for (double n=0; n<N; n++){
double v = f[x][(int)n];
sum += (2.0*v)*Math.cos(Math.PI * k * ((2.0*n+1)/(2.0*N)));
}
F[x][y] = sum;
}
}
//Compute the mean DCT value using an 8x8 sample from the top-left corner
//of the DCT, excluding the first term since the it can be significantly
//different from the other values.
double total = 0;
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
total += F[x][y];
}
}
total -= F[0][0];
double avg = total / (double) ((8 * 8) - 1);
//Set the 64 hash bits to 0 or 1 depending on whether a DCT value is
//above or below the average
long hashBits = 0;
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
hashBits = (F[x][y] > avg ? (hashBits << 1) | 0x01 : (hashBits << 1) & 0xFFFFFFFFFFFFFFFEl);
}
}
return hashBits;
}
//**************************************************************************
//** getIIOMetadata
//**************************************************************************
/** Returns the raw, javax.imageio.metadata.IIOMetadata associated with this
* image. You can iterate through the metadata using an xml parser like this:
<pre>
IIOMetadata metadata = image.getIIOMetadata();
for (String name : metadata.getMetadataFormatNames()) {
System.out.println( "Format name: " + name );
org.w3c.dom.Node metadataNode = metadata.getAsTree(name);
System.out.println(javaxt.xml.DOM.getNodeValue(metadataNode));
}
</pre>
*/
public IIOMetadata getIIOMetadata(){
return metadata;
}
//**************************************************************************
//** setIIOMetadata
//**************************************************************************
/** Used to set/update the raw javax.imageio.metadata.IIOMetadata associated
* with this image.
*/
public void setIIOMetadata(IIOMetadata metadata){
this.metadata = metadata;
iptc = null;
exif = null;
gps = null;
saveMetadata = true;
}
//**************************************************************************
//** getIptcData
//**************************************************************************
/** Returns the raw IPTC byte array (marker 0xED).
*/
public byte[] getIptcData(){
IIOMetadataNode[] tags = getUnknownTags(0xED);
if (tags.length==0) return null;
return (byte[]) tags[0].getUserObject();
}
//**************************************************************************
//** getIptcTags
//**************************************************************************
/** Used to parse IPTC metadata and return a list of key/value pairs found
* in the metadata. You can retrieve specific IPTC metadata values like
* this:
<pre>
javaxt.io.Image image = new javaxt.io.Image("/temp/image.jpg");
java.util.HashMap<Integer, String> iptc = image.getIptcTags();
System.out.println("Date: " + iptc.get(0x0237));
System.out.println("Caption: " + iptc.get(0x0278));
System.out.println("Copyright: " + iptc.get(0x0274));
</pre>
*/
public HashMap<Integer, Object> getIptcTags(){
if (iptc==null){
iptc = new HashMap<Integer, Object>();
for (IIOMetadataNode marker : getUnknownTags(0xED)){
byte[] iptcData = (byte[]) marker.getUserObject();
HashMap<Integer, Object> tags = new MetadataParser(iptcData, 0xED).getTags("IPTC");
iptc.putAll(tags);
}
}
return iptc;
}
//**************************************************************************
//** getExifData
//**************************************************************************
/** Returns the raw EXIF byte array (marker 0xE1).
*/
public byte[] getExifData(){
IIOMetadataNode[] tags = getUnknownTags(0xE1);
if (tags.length==0) return null;
return (byte[]) tags[0].getUserObject();
}
//**************************************************************************
//** getExifTags
//**************************************************************************
/** Used to parse EXIF metadata and return a list of key/value pairs found
* in the metadata. Values can be Strings, Integers, or raw Byte Arrays.
* You can retrieve specific EXIF metadata values like this:
<pre>
javaxt.io.Image image = new javaxt.io.Image("/temp/image.jpg");
java.util.HashMap<Integer, Object> exif = image.getExifTags();
System.out.println("Date: " + exif.get(0x0132));
System.out.println("Camera: " + exif.get(0x0110));
System.out.println("Focal Length: " + exif.get(0x920A));
System.out.println("F-Stop: " + exif.get(0x829D));
System.out.println("Shutter Speed: " + exif.get(0x829A));
</pre>
* Note that the EXIF MakerNote is not parsed.
*/
public HashMap<Integer, Object> getExifTags(){
if (exif==null) parseExif();
return exif;
}
//**************************************************************************
//** getGpsTags
//**************************************************************************
/** Used to parse EXIF metadata and return a list of key/value pairs
* associated with GPS metadata. Values can be Strings, Integers, or raw
* Byte Arrays.
*/
public HashMap<Integer, Object> getGpsTags(){
if (gps==null) parseExif();
return gps;
}
/** Private method used to initialize the exif and gps hashmaps */
private void parseExif(){
exif = new HashMap<Integer, Object>();
gps = new HashMap<Integer, Object>();
for (IIOMetadataNode marker : getUnknownTags(0xE1)){
byte[] exifData = (byte[]) marker.getUserObject();
MetadataParser metadataParser = new MetadataParser(exifData, 0xE1);
HashMap<Integer, Object> exif = metadataParser.getTags("EXIF");
HashMap<Integer, Object> gps = metadataParser.getTags("GPS");
if (exif!=null) this.exif.putAll(exif);
if (gps!=null) this.gps.putAll(gps);
metadataParser = null;
}
}
//**************************************************************************
//** getGPSCoordinate
//**************************************************************************
/** Returns the x/y (lon/lat) coordinate tuple for the image. Value is
* derived from EXIF GPS metadata (tags 0x0001, 0x0002, 0x0003, 0x0004).
*/
public double[] getGPSCoordinate(){
getExifTags();
try{
Double lat = getCoordinate((String) gps.get(0x0002));
Double lon = getCoordinate((String) gps.get(0x0004));
String latRef = (String) gps.get(0x0001); //N
String lonRef = (String) gps.get(0x0003); //W
if (!latRef.equalsIgnoreCase("N")) lat = -lat;
if (!lonRef.equalsIgnoreCase("E")) lon = -lon;
return new double[]{lon, lat};
}
catch(Exception e){
return null;
}
}
private double getCoordinate(String RationalArray) {
//num + "/" + den
String[] arr = RationalArray.substring(1, RationalArray.length()-1).split(",");
String[] deg = arr[0].trim().split("/");
String[] min = arr[1].trim().split("/");
String[] sec = arr[2].trim().split("/");
double degNumerator = Double.parseDouble(deg[0]);
double degDenominator = 1D; try{degDenominator = Double.parseDouble(deg[1]);} catch(Exception e){}
double minNumerator = Double.parseDouble(min[0]);
double minDenominator = 1D; try{minDenominator = Double.parseDouble(min[1]);} catch(Exception e){}
double secNumerator = Double.parseDouble(sec[0]);
double secDenominator = 1D; try{secDenominator = Double.parseDouble(sec[1]);} catch(Exception e){}
double m = 0;
if (degDenominator != 0 || degNumerator != 0){
m = (degNumerator / degDenominator);
}
if (minDenominator != 0 || minNumerator != 0){
m += (minNumerator / minDenominator) / 60D;
}
if (secDenominator != 0 || secNumerator != 0){
m += (secNumerator / secDenominator / 3600D);
}
return m;
}
//**************************************************************************
//** getGPSDatum
//**************************************************************************
/** Returns the datum associated with the GPS coordinate. Value is
* derived from EXIF GPS metadata (tag 0x0012).
*/
public String getGPSDatum(){
getExifTags();
return (String) gps.get(0x0012);
}
//**************************************************************************
//** getUnknownTags
//**************************************************************************
/** Returns a list of "unknown" IIOMetadataNodes for a given MarkerTag. You
* can use this method to retrieve EXIF, IPTC, XPM, and other format
* specific metadata. Example:
<pre>
byte[] IptcData = (byte[]) metadata.getUnknownTags(0xED)[0].getUserObject();
byte[] ExifData = (byte[]) metadata.getUnknownTags(0xE1)[0].getUserObject();
</pre>
*/
public IIOMetadataNode[] getUnknownTags(int MarkerTag){
java.util.ArrayList<IIOMetadataNode> markers = new java.util.ArrayList<IIOMetadataNode>();
if (metadata!=null)
for (String name : metadata.getMetadataFormatNames()) {
IIOMetadataNode node=(IIOMetadataNode) metadata.getAsTree(name);
Node[] unknownNodes = getElementsByTagName("unknown", node);
for (Node unknownNode : unknownNodes){
try{
int marker = Integer.parseInt(getAttributeValue(unknownNode.getAttributes(), "MarkerTag"));
if (marker==MarkerTag) markers.add((IIOMetadataNode) unknownNode);
}
catch(Exception e){
e.printStackTrace();
}
}
}
return markers.toArray(new IIOMetadataNode[markers.size()]);
}
//**************************************************************************
//** getMetadataByTagName
//**************************************************************************
/** Returns a list of IIOMetadataNodes for a given tag name (e.g. "Chroma",
* "Compression", "Data", "Dimension", "Transparency", etc).
<pre>
//Print unknown tags
for (IIOMetadataNode unknownNode : metadata.getMetadataByTagName("unknown")){
int marker = Integer.parseInt(javaxt.xml.DOM.getAttributeValue(unknownNode, "MarkerTag"));
System.out.println(marker + "\t" + "0x" + Integer.toHexString(marker));
}
</pre>
*/
public IIOMetadataNode[] getMetadataByTagName(String tagName){
java.util.ArrayList<IIOMetadataNode> tags = new java.util.ArrayList<IIOMetadataNode>();
if (metadata!=null)
for (String name : metadata.getMetadataFormatNames()) {
IIOMetadataNode node=(IIOMetadataNode) metadata.getAsTree(name);
Node[] unknownNodes = getElementsByTagName(tagName, node);
for (Node unknownNode : unknownNodes){
tags.add((IIOMetadataNode) unknownNode);
}
}
return tags.toArray(new IIOMetadataNode[tags.size()]);
}
//**************************************************************************
//** getElementsByTagName (Copied from javaxt.xml.DOM)
//**************************************************************************
/** Returns an array of nodes that match a given tagName (node name). The
* results will include all nodes that match, regardless of namespace. To
* narrow the results to a specific namespace, simply include the namespace
* prefix in the tag name (e.g. "t:Contact"). Returns an empty array if
* no nodes are found.
*/
private static Node[] getElementsByTagName(String tagName, Node node){
java.util.ArrayList<Node> nodes = new java.util.ArrayList<Node>();
getElementsByTagName(tagName, node, nodes);
return nodes.toArray(new Node[nodes.size()]);
}
private static void getElementsByTagName(String tagName, Node node, java.util.ArrayList<Node> nodes){
if (node!=null && node.getNodeType()==1){
String nodeName = node.getNodeName().trim();
if (nodeName.contains(":") && !tagName.contains(":")){
nodeName = nodeName.substring(nodeName.indexOf(":")+1);
}
if (nodeName.equalsIgnoreCase(tagName)){
nodes.add(node);
}
NodeList childNodes = node.getChildNodes();
for (int i=0; i<childNodes.getLength(); i++){
getElementsByTagName(tagName, childNodes.item(i), nodes);
}
}
}
//**************************************************************************
//** getAttributeValue (Copied from javaxt.xml.DOM)
//**************************************************************************
/** Used to return the value of a given node attribute. The search is case
* insensitive. If no match is found, returns an empty string.
*/
public static String getAttributeValue(NamedNodeMap attrCollection, String attrName){
if (attrCollection!=null){
for (int i=0; i < attrCollection.getLength(); i++ ) {
Node node = attrCollection.item(i);
if (node.getNodeName().equalsIgnoreCase(attrName)) {
return node.getNodeValue();
}
}
}
return "";
}
//******************************************************************************
//** MetadataParser Class
//******************************************************************************
/**
* Used to decode EXIF and IPTC metadata. Adapted from 2 classes developed by
* Norman Walsh and released under the W3C open source license. The original
* exif classes can be found in the W3C Jigsaw project in the
* org.w3c.tools.jpeg package.
*
* @author Norman Walsh
* @copyright Copyright (c) 2003 Norman Walsh
******************************************************************************/
private class MetadataParser {
// Implementation notes:
// (1) Merged Version 1.1 of the "Exif.java" and "ExifData.java" classes.
// (2) Added new IPTC metadata parser.
// (3) All unsigned integers are treated as signed ints (should be longs).
// (4) Added logic to parse GPS Info using the GPS IFD offset value (tag 34853,
// hex 0x8825).
// (5) Added logic to parse an array of rational numbers (e.g. GPS metadata).
// (6) Improved performance in the parseExif() method by serializing only the
// first 8 characters into a string (vs the entire EXIF byte array).
// (7) TODO: Need to come up with a clever scheme to parse MakerNotes.
private final int bytesPerFormat[] = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8};
private final int NUM_FORMATS = 12;
private final int FMT_BYTE = 1;
private final int FMT_STRING = 2;
private final int FMT_USHORT = 3;
private final int FMT_ULONG = 4;
private final int FMT_URATIONAL = 5;
private final int FMT_SBYTE = 6;
//private final int FMT_UNDEFINED = 7;
private final int FMT_SSHORT = 8;
private final int FMT_SLONG = 9;
private final int FMT_SRATIONAL = 10;
//private final int FMT_SINGLE = 11;
//private final int FMT_DOUBLE = 12;
private byte[] data = null;
private boolean intelOrder = false;
private final int TAG_EXIF_OFFSET = 0x8769;
private final int TAG_INTEROP_OFFSET = 0xa005;
private final int TAG_GPS_OFFSET = 0x8825;
private final int TAG_USERCOMMENT = 0x9286;
private HashMap<String, HashMap<Integer, Object>> tags =
new HashMap<String, HashMap<Integer, Object>>();
public MetadataParser(byte[] data, int marker) {
switch (marker) {
case 0xED: parseIptc(data); break;
case 0xE1: parseExif(data); break;
}
data = null;
}
//**************************************************************************
//** parseIptc
//**************************************************************************
/** Used to parse IPTC metadata
*/
private void parseIptc(byte[] iptcData) {
HashMap<Integer, Object> tags = new HashMap<Integer, Object>();
this.tags.put("IPTC", tags);
data = iptcData;
int offset = 0;
while (offset < data.length) {
if (data[offset] == 0x1c) {
offset++;
int directoryType;
int tagType;
int tagByteCount;
try {
directoryType = data[offset++];
tagType = data[offset++];
tagByteCount = get16u(offset);
offset += 2;
}
catch (Exception e) {
return;
}
int tagIdentifier = tagType | (directoryType << 8);
String str = "";
if (tagByteCount < 1 || tagByteCount>(data.length-offset)) {
}
else {
try {
str = new String(data, offset, tagByteCount, "UTF-8");
offset += tagByteCount;
}
catch (Exception e) {
}
}
tags.put(tagIdentifier, str);
}
else{
offset++;
}
}
}
//**************************************************************************
//** parseExif
//**************************************************************************
/** Used to parse EXIF metadata
*/
public void parseExif(byte[] exifData) {
HashMap<Integer, Object> tags = new HashMap<Integer, Object>();
this.tags.put("EXIF", tags);
try{
String dataStr = new String(exifData, 0, 8, "UTF-8"); //new String(exifData);
if (exifData.length <= 4 || !"Exif".equals(dataStr.substring(0, 4))) {
//System.err.println("Not really EXIF data");
return;
}
String byteOrderMarker = dataStr.substring(6, 8);
if ("II".equals(byteOrderMarker)) {
intelOrder = true;
} else if ("MM".equals(byteOrderMarker)) {
intelOrder = false;
} else {
//System.err.println("Incorrect byte order in EXIF data.");
return;
}
}
catch(Exception e){
return;
}
data = exifData;
int checkValue = get16u(8);
if (checkValue != 0x2a) {
data = null;
//System.err.println("Check value fails: 0x"+ Integer.toHexString(checkValue));
return;
}
if (data==null) return;
int firstOffset = get32u(10);
processExifDir(6 + firstOffset, 6, tags);
}
//**************************************************************************
//** getTags
//**************************************************************************
/** Returns key/value pairs representing the EXIF or IPTC data.
*/
public HashMap<Integer, Object> getTags(String dir) {
return tags.get(dir);
}
private void processExifDir(int dirStart, int offsetBase, HashMap<Integer, Object> tags) {
if (dirStart>=data.length) return;
int numEntries = get16u(dirStart);
for (int de = 0; de < numEntries; de++) {
int dirOffset = dirStart + 2 + (12 * de);
int tag = get16u(dirOffset);
int format = get16u(dirOffset + 2);
int components = get32u(dirOffset + 4);
//System.err.println("EXIF: entry: 0x" + Integer.toHexString(tag)
// + " " + format
// + " " + components);
if (format < 0 || format > NUM_FORMATS) {
//System.err.println("Bad number of formats in EXIF dir: " + format);
return;
}
int byteCount = components * bytesPerFormat[format];
int valueOffset = dirOffset + 8;
if (byteCount > 4) {
int offsetVal = get32u(dirOffset + 8);
valueOffset = offsetBase + offsetVal;
}
if (tag == TAG_EXIF_OFFSET || tag == TAG_INTEROP_OFFSET || tag == TAG_GPS_OFFSET) {
String dirName = "";
switch (tag) {
case TAG_EXIF_OFFSET:
dirName = "EXIF";
break;
case TAG_INTEROP_OFFSET:
dirName = "EXIF";
break;
case TAG_GPS_OFFSET:
dirName = "GPS";
break;
}
tags = this.tags.get(dirName);
if (tags==null){
tags = new HashMap<Integer, Object>();
this.tags.put(dirName, tags);
}
int subdirOffset = get32u(valueOffset);
processExifDir(offsetBase + subdirOffset, offsetBase, tags);
}
//else if (tag==0x927c){ //Maker Note
//TODO: Come up with a clever way to process the Maker Note
//data = java.util.Arrays.copyOfRange(data, valueOffset, byteCount);
//tags = new HashMap<Integer, String>();
//processExifDir(0, 6);
//}
else {
switch (format) {
case FMT_STRING:
String value = getString(valueOffset, byteCount);
if (value!=null) tags.put(tag, value);
break;
case FMT_SBYTE:
case FMT_BYTE:
case FMT_USHORT:
case FMT_SSHORT:
case FMT_ULONG:
case FMT_SLONG:
tags.put(tag, (int) getDouble(format, valueOffset));
break;
case FMT_URATIONAL:
case FMT_SRATIONAL:
if (components>1) {
//Create a string representing an array of rational numbers
StringBuffer str = new StringBuffer();
str.append("[");
for (int i=0; i<components; i++){
str.append( getRational(valueOffset + (8 * i)) );
if (i<components-1) str.append(",");
}
str.append("]");
tags.put(tag, str.toString());
}
else{
tags.put(tag, getRational(valueOffset));
}
break;
default: //including FMT_UNDEFINED
byte[] result = getUndefined(valueOffset, byteCount);
if (result!=null) tags.put(tag, result);
break;
}
}
}
}
//**************************************************************************
//** getRational
//**************************************************************************
/** Returns a string representation of a rational number (numerator and
* denominator separated with a "/" character).
*/
private String getRational(int offset) {
int num = get32s(offset);
int den = get32s(offset + 4);
String result = "";
// This is a bit silly, I really ought to find a real GCD algorithm
if (num % 10 == 0 && den % 10 == 0) {
num = num / 10;
den = den / 10;
}
if (num % 5 == 0 && den % 5 == 0) {
num = num / 5;
den = den / 5;
}
if (num % 3 == 0 && den % 3 == 0) {
num = num / 3;
den = den / 3;
}
if (num % 2 == 0 && den % 2 == 0) {
num = num / 2;
den = den / 2;
}
if (den == 0) {
result = "0";
} else if (den == 1) {
result = "" + num; // "" + int sure looks ugly...
} else {
result = "" + num + "/" + den;
}
return result;
}
private int get16s(int offset) {
int hi, lo;
if (intelOrder) {
hi = data[offset + 1];
lo = data[offset];
} else {
hi = data[offset];
lo = data[offset + 1];
}
lo = lo & 0xFF;
hi = hi & 0xFF;
return (hi << 8) + lo;
}
private int get16u(int offset) {
int value = get16s(offset);
return value & 0xFFFF;
}
private int get32s(int offset) {
int n1, n2, n3, n4;
if (intelOrder) {
n1 = data[offset + 3] & 0xFF;
n2 = data[offset + 2] & 0xFF;
n3 = data[offset + 1] & 0xFF;
n4 = data[offset] & 0xFF;
} else {
n1 = data[offset] & 0xFF;
n2 = data[offset + 1] & 0xFF;
n3 = data[offset + 2] & 0xFF;
n4 = data[offset + 3] & 0xFF;
}
return (n1 << 24) + (n2 << 16) + (n3 << 8) + n4;
}
private int get32u(int offset) {
return get32s(offset); //Should probably return a long instead...
}
private byte[] getUndefined(int offset, int length) {
return java.util.Arrays.copyOfRange(data, offset, offset+length);
}
private String getString(int offset, int length) {
try{
return new String(data, offset, length, "UTF-8").trim();
}
catch(Exception e){
return null;
}
}
//**************************************************************************
//** getDouble
//**************************************************************************
/** Used convert a byte into a double. Note that this method used to be
* called convertAnyValue().
*/
private double getDouble(int format, int offset) {
switch (format) {
case FMT_SBYTE:
return data[offset];
case FMT_BYTE:
int iValue = data[offset];
return iValue & 0xFF;
case FMT_USHORT:
return get16u(offset);
case FMT_ULONG:
return get32u(offset);
case FMT_URATIONAL:
case FMT_SRATIONAL:
int num = get32s(offset);
int den = get32s(offset + 4);
if (den == 0) return 0;
else return (double) num / (double) den;
case FMT_SSHORT:
return get16s(offset);
case FMT_SLONG:
return get32s(offset);
default:
return 0.0;
}
}
}
//***************************************************************************
//** Skew Class
//***************************************************************************
/**
* Used to skew an image. Adapted from 2 image processing classes developed
* by Jerry Huxtable (http://www.jhlabs.com) and released under
* the Apache License, Version 2.0.
*
***************************************************************************/
private class Skew {
public final static int ZERO = 0;
public final static int CLAMP = 1;
public final static int WRAP = 2;
public final static int NEAREST_NEIGHBOUR = 0;
public final static int BILINEAR = 1;
protected int edgeAction = ZERO;
protected int interpolation = BILINEAR;
protected Rectangle transformedSpace;
protected Rectangle originalSpace;
private float x0, y0, x1, y1, x2, y2, x3, y3;
private float dx1, dy1, dx2, dy2, dx3, dy3;
private float A, B, C, D, E, F, G, H, I;
private BufferedImage src;
private BufferedImage dst;
public Skew(BufferedImage src) {
this.src = src;
this.dst = new BufferedImage(src.getWidth(), src.getHeight(), src.getType());
}
public Skew(javaxt.io.Image src) {
this(src.getBufferedImage());
}
public BufferedImage setCorners(float x0, float y0,
float x1, float y1,
float x2, float y2,
float x3, float y3)
{
this.x0 = x0;
this.y0 = y0;
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
this.x3 = x3;
this.y3 = y3;
dx1 = x1-x2;
dy1 = y1-y2;
dx2 = x3-x2;
dy2 = y3-y2;
dx3 = x0-x1+x2-x3;
dy3 = y0-y1+y2-y3;
float a11, a12, a13, a21, a22, a23, a31, a32;
if (dx3 == 0 && dy3 == 0) {
a11 = x1-x0;
a21 = x2-x1;
a31 = x0;
a12 = y1-y0;
a22 = y2-y1;
a32 = y0;
a13 = a23 = 0;
} else {
a13 = (dx3*dy2-dx2*dy3)/(dx1*dy2-dy1*dx2);
a23 = (dx1*dy3-dy1*dx3)/(dx1*dy2-dy1*dx2);
a11 = x1-x0+a13*x1;
a21 = x3-x0+a23*x3;
a31 = x0;
a12 = y1-y0+a13*y1;
a22 = y3-y0+a23*y3;
a32 = y0;
}
A = a22 - a32*a23;
B = a31*a23 - a21;
C = a21*a32 - a31*a22;
D = a32*a13 - a12;
E = a11 - a31*a13;
F = a31*a12 - a11*a32;
G = a12*a23 - a22*a13;
H = a21*a13 - a11*a23;
I = a11*a22 - a21*a12;
return filter(src,dst);
}
protected void transformSpace(Rectangle rect) {
rect.x = (int)Math.min( Math.min( x0, x1 ), Math.min( x2, x3 ) );
rect.y = (int)Math.min( Math.min( y0, y1 ), Math.min( y2, y3 ) );
rect.width = (int)Math.max( Math.max( x0, x1 ), Math.max( x2, x3 ) ) - rect.x;
rect.height = (int)Math.max( Math.max( y0, y1 ), Math.max( y2, y3 ) ) - rect.y;
}
public float getOriginX() {
return x0 - (int)Math.min( Math.min( x0, x1 ), Math.min( x2, x3 ) );
}
public float getOriginY() {
return y0 - (int)Math.min( Math.min( y0, y1 ), Math.min( y2, y3 ) );
}
private BufferedImage filter( BufferedImage src, BufferedImage dst ) {
int width = src.getWidth();
int height = src.getHeight();
//int type = src.getType();
//WritableRaster srcRaster = src.getRaster();
originalSpace = new Rectangle(0, 0, width, height);
transformedSpace = new Rectangle(0, 0, width, height);
transformSpace(transformedSpace);
if ( dst == null ) {
ColorModel dstCM = src.getColorModel();
dst = new BufferedImage(
dstCM,
dstCM.createCompatibleWritableRaster(transformedSpace.width, transformedSpace.height),
dstCM.isAlphaPremultiplied(),
null
);
}
//WritableRaster dstRaster = dst.getRaster();
int[] inPixels = getRGB( src, 0, 0, width, height, null );
if ( interpolation == NEAREST_NEIGHBOUR )
return filterPixelsNN( dst, width, height, inPixels, transformedSpace );
int srcWidth = width;
int srcHeight = height;
int srcWidth1 = width-1;
int srcHeight1 = height-1;
int outWidth = transformedSpace.width;
int outHeight = transformedSpace.height;
int outX, outY;
//int index = 0;
int[] outPixels = new int[outWidth];
outX = transformedSpace.x;
outY = transformedSpace.y;
float[] out = new float[2];
for (int y = 0; y < outHeight; y++) {
for (int x = 0; x < outWidth; x++) {
transformInverse(outX+x, outY+y, out);
int srcX = (int)Math.floor( out[0] );
int srcY = (int)Math.floor( out[1] );
float xWeight = out[0]-srcX;
float yWeight = out[1]-srcY;
int nw, ne, sw, se;
if ( srcX >= 0 && srcX < srcWidth1 && srcY >= 0 && srcY < srcHeight1) {
// Easy case, all corners are in the image
int i = srcWidth*srcY + srcX;
nw = inPixels[i];
ne = inPixels[i+1];
sw = inPixels[i+srcWidth];
se = inPixels[i+srcWidth+1];
} else {
// Some of the corners are off the image
nw = getPixel( inPixels, srcX, srcY, srcWidth, srcHeight );
ne = getPixel( inPixels, srcX+1, srcY, srcWidth, srcHeight );
sw = getPixel( inPixels, srcX, srcY+1, srcWidth, srcHeight );
se = getPixel( inPixels, srcX+1, srcY+1, srcWidth, srcHeight );
}
outPixels[x] = bilinearInterpolate(xWeight, yWeight, nw, ne, sw, se);
}
setRGB( dst, 0, y, transformedSpace.width, 1, outPixels );
}
return dst;
}
final private int getPixel( int[] pixels, int x, int y, int width, int height ) {
if (x < 0 || x >= width || y < 0 || y >= height) {
switch (edgeAction) {
case ZERO:
default:
return 0;
case WRAP:
return pixels[(mod(y, height) * width) + mod(x, width)];
case CLAMP:
return pixels[(clamp(y, 0, height-1) * width) + clamp(x, 0, width-1)];
}
}
return pixels[ y*width+x ];
}
protected BufferedImage filterPixelsNN( BufferedImage dst, int width,
int height, int[] inPixels, Rectangle transformedSpace )
{
int srcWidth = width;
int srcHeight = height;
int outWidth = transformedSpace.width;
int outHeight = transformedSpace.height;
int outX, outY, srcX, srcY;
int[] outPixels = new int[outWidth];
outX = transformedSpace.x;
outY = transformedSpace.y;
int[] rgb = new int[4];
float[] out = new float[2];
for (int y = 0; y < outHeight; y++) {
for (int x = 0; x < outWidth; x++) {
transformInverse(outX+x, outY+y, out);
srcX = (int)out[0];
srcY = (int)out[1];
// int casting rounds towards zero, so we check out[0] < 0, not srcX < 0
if (out[0] < 0 || srcX >= srcWidth || out[1] < 0 || srcY >= srcHeight) {
int p;
switch (edgeAction) {
case ZERO:
default:
p = 0;
break;
case WRAP:
p = inPixels[(mod(srcY, srcHeight) * srcWidth) + mod(srcX, srcWidth)];
break;
case CLAMP:
p = inPixels[(clamp(srcY, 0, srcHeight-1) * srcWidth) + clamp(srcX, 0, srcWidth-1)];
break;
}
outPixels[x] = p;
} else {
int i = srcWidth*srcY + srcX;
rgb[0] = inPixels[i];
outPixels[x] = inPixels[i];
}
}
setRGB( dst, 0, y, transformedSpace.width, 1, outPixels );
}
return dst;
}
protected void transformInverse(int x, int y, float[] out) {
out[0] = originalSpace.width * (A*x+B*y+C)/(G*x+H*y+I);
out[1] = originalSpace.height * (D*x+E*y+F)/(G*x+H*y+I);
}
/*
public Rectangle2D getBounds2D( BufferedImage src ) {
return new Rectangle(0, 0, src.getWidth(), src.getHeight());
}
public Point2D getPoint2D( Point2D srcPt, Point2D dstPt ) {
if ( dstPt == null )
dstPt = new Point2D.Double();
dstPt.setLocation( srcPt.getX(), srcPt.getY() );
return dstPt;
}
*/
/**
* A convenience method for getting ARGB pixels from an image. This tries to avoid the performance
* penalty of BufferedImage.getRGB unmanaging the image.
*/
public int[] getRGB( BufferedImage image, int x, int y, int width, int height, int[] pixels ) {
int type = image.getType();
if ( type == BufferedImage.TYPE_INT_ARGB || type == BufferedImage.TYPE_INT_RGB )
return (int [])image.getRaster().getDataElements( x, y, width, height, pixels );
return image.getRGB( x, y, width, height, pixels, 0, width );
}
/**
* A convenience method for setting ARGB pixels in an image. This tries to avoid the performance
* penalty of BufferedImage.setRGB unmanaging the image.
*/
public void setRGB( BufferedImage image, int x, int y, int width, int height, int[] pixels ) {
int type = image.getType();
if (type == BufferedImage.TYPE_INT_ARGB || type == BufferedImage.TYPE_INT_RGB)
image.getRaster().setDataElements( x, y, width, height, pixels );
else
image.setRGB( x, y, width, height, pixels, 0, width );
}
/**
* Clamp a value to an interval.
* @param a the lower clamp threshold
* @param b the upper clamp threshold
* @param x the input parameter
* @return the clamped value
*/
private float clamp(float x, float a, float b) {
return (x < a) ? a : (x > b) ? b : x;
}
/**
* Clamp a value to an interval.
* @param a the lower clamp threshold
* @param b the upper clamp threshold
* @param x the input parameter
* @return the clamped value
*/
private int clamp(int x, int a, int b) {
return (x < a) ? a : (x > b) ? b : x;
}
/**
* Return a mod b. This differs from the % operator with respect to negative numbers.
* @param a the dividend
* @param b the divisor
* @return a mod b
*/
private double mod(double a, double b) {
int n = (int)(a/b);
a -= n*b;
if (a < 0)
return a + b;
return a;
}
/**
* Return a mod b. This differs from the % operator with respect to negative numbers.
* @param a the dividend
* @param b the divisor
* @return a mod b
*/
private float mod(float a, float b) {
int n = (int)(a/b);
a -= n*b;
if (a < 0)
return a + b;
return a;
}
/**
* Return a mod b. This differs from the % operator with respect to negative numbers.
* @param a the dividend
* @param b the divisor
* @return a mod b
*/
private int mod(int a, int b) {
int n = a/b;
a -= n*b;
if (a < 0)
return a + b;
return a;
}
/**
* Bilinear interpolation of ARGB values.
* @param x the X interpolation parameter 0..1
* @param y the y interpolation parameter 0..1
* @param rgb array of four ARGB values in the order NW, NE, SW, SE
* @return the interpolated value
*/
private int bilinearInterpolate(float x, float y, int nw, int ne, int sw, int se) {
float m0, m1;
int a0 = (nw >> 24) & 0xff;
int r0 = (nw >> 16) & 0xff;
int g0 = (nw >> 8) & 0xff;
int b0 = nw & 0xff;
int a1 = (ne >> 24) & 0xff;
int r1 = (ne >> 16) & 0xff;
int g1 = (ne >> 8) & 0xff;
int b1 = ne & 0xff;
int a2 = (sw >> 24) & 0xff;
int r2 = (sw >> 16) & 0xff;
int g2 = (sw >> 8) & 0xff;
int b2 = sw & 0xff;
int a3 = (se >> 24) & 0xff;
int r3 = (se >> 16) & 0xff;
int g3 = (se >> 8) & 0xff;
int b3 = se & 0xff;
float cx = 1.0f-x;
float cy = 1.0f-y;
m0 = cx * a0 + x * a1;
m1 = cx * a2 + x * a3;
int a = (int)(cy * m0 + y * m1);
m0 = cx * r0 + x * r1;
m1 = cx * r2 + x * r3;
int r = (int)(cy * m0 + y * m1);
m0 = cx * g0 + x * g1;
m1 = cx * g2 + x * g3;
int g = (int)(cy * m0 + y * m1);
m0 = cx * b0 + x * b1;
m1 = cx * b2 + x * b3;
int b = (int)(cy * m0 + y * m1);
return (a << 24) | (r << 16) | (g << 8) | b;
}
} //end skew class
} //end image class
|
|