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:
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));
}
*/
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:
javaxt.io.Image image = new javaxt.io.Image("/temp/image.jpg");
java.util.HashMap iptc = image.getIptcTags();
System.out.println("Date: " + iptc.get(0x0237));
System.out.println("Caption: " + iptc.get(0x0278));
System.out.println("Copyright: " + iptc.get(0x0274));
*/
public HashMap getIptcTags(){
if (iptc==null){
iptc = new HashMap();
for (IIOMetadataNode marker : getUnknownTags(0xED)){
byte[] iptcData = (byte[]) marker.getUserObject();
HashMap 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:
javaxt.io.Image image = new javaxt.io.Image("/temp/image.jpg");
java.util.HashMap 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));
* Note that the EXIF MakerNote is not parsed.
*/
public HashMap 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 getGpsTags(){
if (gps==null) parseExif();
return gps;
}
/** Private method used to initialize the exif and gps hashmaps */
private void parseExif(){
exif = new HashMap();
gps = new HashMap();
for (IIOMetadataNode marker : getUnknownTags(0xE1)){
byte[] exifData = (byte[]) marker.getUserObject();
MetadataParser metadataParser = new MetadataParser(exifData, 0xE1);
HashMap exif = metadataParser.getTags("EXIF");
HashMap 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:
byte[] IptcData = (byte[]) metadata.getUnknownTags(0xED)[0].getUserObject();
byte[] ExifData = (byte[]) metadata.getUnknownTags(0xE1)[0].getUserObject();
*/
public IIOMetadataNode[] getUnknownTags(int MarkerTag){
java.util.ArrayList markers = new java.util.ArrayList();
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).
//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));
}
*/
public IIOMetadataNode[] getMetadataByTagName(String tagName){
java.util.ArrayList tags = new java.util.ArrayList();
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 nodes = new java.util.ArrayList();
getElementsByTagName(tagName, node, nodes);
return nodes.toArray(new Node[nodes.size()]);
}
private static void getElementsByTagName(String tagName, Node node, java.util.ArrayList 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> tags =
new HashMap>();
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 tags = new HashMap();
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 tags = new HashMap();
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 getTags(String dir) {
return tags.get(dir);
}
private void processExifDir(int dirStart, int offsetBase, HashMap 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();
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();
//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= 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