package com.liusoft.dlog4j.

test;

import java.io.File;
import java.util.Iterator;

import com.drew.imaging.jpeg.JpegMetadataReader;
import com.drew.metadata.Directory;
import com.drew.metadata.Metadata;
import com.drew.metadata.Tag;
import com.drew.metadata.exif.ExifDirectory;

/**
* �������‫�ڶ‬ȡͼƬ��EXIF��Ϣ
* @author Winter Lau
*/
public class ExifTester {
public static void main(String[] args) throws Exception {
File jpegFile = new File("D:\\�ҵ��ĵ�\\�ҵ����\\DSCF1749.JPG");
Metadata metadata = JpegMetadataReader.readMetadata(jpegFile);
Directory exif = metadata.getDirectory(ExifDirectory.class);
Iterator tags = exif.getTagIterator();
while (tags.hasNext()) {
Tag tag = (Tag)tags.next();
System.out.println(tag);
}
}
}

Code:
import java.awt.*;
import java.awt.image.*;
import java.io.*;
import java.net.*;
import javax.imageio.*;

import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.awt.Image;

import java.io.File;
import java.io.FileOutputStream;

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.stream.FileImageInputStream;
import javax.swing.ImageIcon;

import org.w3c.dom.Element;
import org.w3c.dom.Node;

import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGEncodeParam;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

public class ImageManipulation {

public static void main(String[] args) throws Exception {

File infile = new File("/35670v.jpg");
File outfile = new File("/35670_600.jpg");

ImageReader reader = ImageIO.getImageReadersByFormatName("jpeg").next();

reader.setInput(new FileImageInputStream(infile), true, false);
IIOMetadata data = reader.getImageMetadata(0);
BufferedImage image = reader.read(0);

int w = 600, h = -1;

Image rescaled = image.getScaledInstance(w, h,
Image.SCALE_AREA_AVERAGING);
BufferedImage output = toBufferedImage(rescaled,
BufferedImage.TYPE_INT_RGB);

Element tree = (Element)

data.getAsTree("javax_imageio_jpeg_image_1.0");
Element jfif = (Element) tree.getElementsByTagName("app0JFIF").item(0);
for (int i = 0; i < jfif.getAttributes().getLength(); i++) {
Node attribute = jfif.getAttributes().item(i);
System.out.println(attribute.getNodeName() + "="
+ attribute.getNodeValue());
}
FileOutputStream fos = new FileOutputStream(outfile);
JPEGImageEncoder jpegEncoder = JPEGCodec.createJPEGEncoder(fos);
JPEGEncodeParam jpegEncodeParam =
jpegEncoder.getDefaultJPEGEncodeParam(output);
jpegEncodeParam.setDensityUnit(JPEGEncodeParam.DENSITY_UNIT_DOTS_INCH);
jpegEncodeParam.setXDensity(300);
jpegEncodeParam.setYDensity(300);
jpegEncoder.encode(output, jpegEncodeParam);
fos.close();
}

public static BufferedImage toBufferedImage(Image image, int type) {

int w = image.getWidth(null);
int h = image.getHeight(null);
BufferedImage result = new BufferedImage(w, h, type);
Graphics2D g = result.createGraphics();
g.drawImage(image, 0, 0, null);
g.dispose();
return result;
}
}
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;

import javax.imageio.ImageIO;

import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGDecodeParam;
import com.sun.image.codec.jpeg.JPEGImageDecoder;

public class ImageManage {

public void getSize() throws Exception {

JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(new
FileInputStream("c:/test.jpg"));
BufferedImage image = decoder.decodeAsBufferedImage();
JPEGDecodeParam param = decoder.getJPEGDecodeParam();
System.out.println("Height:" + image.getHeight());
System.out.println("Width:" + image.getWidth());
System.out.println("XDensity:" + param.getXDensity());
System.out.println("YDensity:" + param.getYDensity());

public static void main(String[] args) {

try {
ImageManage im = new ImageManage();
im.getSize();

} catch (Exception e) {

e.printStackTrace();
}
}
}
public class SetDPI4TIFF ...{

private static String METADATA_NAME =

"com_sun_media_imageio_plugins_tiff_image_1.0";
private static int DPI_X = 300;
private static int DPI_Y = 300;

public static void main(String[] args) throws Throwable ...{

// Create sample image.
RenderedImage image = new BufferedImage(256, 256,
BufferedImage.TYPE_3BYTE_BGR);

// Get TIFF writer.

Iterator writers = ImageIO.getImageWritersByFormatName("TIFF");
if (writers == null || !writers.hasNext()) ...{
throw new IllegalStateException("No TIFF writers!");
}
ImageWriter writer = (ImageWriter) writers.next();

// Get the default image metadata.

ImageTypeSpecifier imageType =
ImageTypeSpecifier.createFromRenderedImage(image);
IIOMetadata imageMetadata = writer.getDefaultImageMetadata(imageType,
null);

// Set DPI.
String fileName;
String methodology;
if (args.length == 0 || args[0].equalsIgnoreCase("DOM")) ...{
fileName = "dpi_dom.tif";
setDPIViaDOM(imageMetadata);
methodology = "DOM";
} else ...{
fileName = "dpi_api.tif";
imageMetadata = setDPIViaAPI(imageMetadata);
methodology = "API";
}

System.out.println(" Writing " + fileName + " using " + methodology + "

methodology ");

// Write image.
writer.setOutput(new FileImageOutputStream(new File(fileName)));
writer.write(new IIOImage(image, null, imageMetadata));
}

/** *//**
* Set DPI using DOM nodes.
*/
private static void setDPIViaDOM(IIOMetadata imageMetadata) throws
IIOInvalidTreeException ...{
// Get the DOM tree.
IIOMetadataNode root = (IIOMetadataNode)
imageMetadata.getAsTree(METADATA_NAME);
 // Get the IFD.
IIOMetadataNode ifd = (IIOMetadataNode)
root.getElementsByTagName("TIFFIFD").item(0);

// Get {X,Y}Resolution tags.

BaselineTIFFTagSet base = BaselineTIFFTagSet.getInstance();
TIFFTag tagXRes = base.getTag(BaselineTIFFTagSet.TAG_X_RESOLUTION);
TIFFTag tagYRes = base.getTag(BaselineTIFFTagSet.TAG_Y_RESOLUTION);

// Create {X,Y}Resolution nodes.

IIOMetadataNode nodeXRes = createRationalNode(tagXRes.getName(),
tagXRes.getNumber(), DPI_X, 1);
IIOMetadataNode nodeYRes = createRationalNode(tagYRes.getName(),
tagYRes.getNumber(), DPI_Y, 1);

// Append {X,Y}Resolution nodes to IFD node.

ifd.appendChild(nodeXRes);
ifd.appendChild(nodeYRes);

// Set metadata from tree.

imageMetadata.setFromTree(METADATA_NAME, root);
}

/** *//**
* Creates a node of TIFF data type RATIONAL.
*/
private static IIOMetadataNode createRationalNode(String tagName, int
tagNumber, int numerator, int denominator) ...{
// Create the field node with tag name and number.
IIOMetadataNode field = new IIOMetadataNode("TIFFField");
field.setAttribute("name", tagName);
field.setAttribute("number", "" + tagNumber);

// Create the RATIONAL node.

IIOMetadataNode rational = new IIOMetadataNode("TIFFRational");
rational.setAttribute("value", numerator + "/" + denominator);

// Create the RATIONAL node and append RATIONAL node.

IIOMetadataNode rationals = new IIOMetadataNode("TIFFRationals");
rationals.appendChild(rational);

// Append RATIONALS node to field node.

field.appendChild(rationals);

return field;
}

/** *//**
* Set DPI using API.
*/
private static IIOMetadata setDPIViaAPI(IIOMetadata imageMetadata) throws
IIOInvalidTreeException ...{
// Derive the TIFFDirectory from the metadata.
TIFFDirectory dir = TIFFDirectory.createFromMetadata(imageMetadata);

// Get {X,Y}Resolution tags.

BaselineTIFFTagSet base = BaselineTIFFTagSet.getInstance();
 TIFFTag tagXRes = base.getTag(BaselineTIFFTagSet.TAG_X_RESOLUTION);
TIFFTag tagYRes = base.getTag(BaselineTIFFTagSet.TAG_Y_RESOLUTION);

// Create {X,Y}Resolution fields.

TIFFField fieldXRes = new TIFFField(tagXRes, TIFFTag.TIFF_RATIONAL, 1, new
long[][]...{...{DPI_X, 1}});
TIFFField fieldYRes = new TIFFField(tagYRes, TIFFTag.TIFF_RATIONAL, 1, new
long[][]...{...{DPI_Y, 1}});

// Append {X,Y}Resolution fields to directory.

dir.addTIFFField(fieldXRes);
dir.addTIFFField(fieldYRes);

// Convert to metadata object and return.

return dir.getAsMetadata();
}
}

FingerprintImage

import java.awt.image.BufferedImage;import java.awt.image.WritableRaster;import

java.io.File;import javax.imageio.IIOImage;import javax.imageio.ImageIO;import
javax.imageio.ImageTypeSpecifier;import javax.imageio.metadata.IIOMetadata;import
javax.imageio.plugins.jpeg.JPEGImageWriteParam;import
javax.imageio.stream.ImageOutputStream import org.w3c.dom.Element; import
com.sun.imageio.plugins.jpeg.JPEGImageWriter;public boolean saveJpeg(int[]
byteArray, int width, int height, int dpi, String file){ BufferedImage
bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
WritableRaster wr = bufferedImage.getRaster(); wr.setPixels(0, 0, width,
height, byteArray); try { //
Image writer JPEGImageWriter imageWriter = (JPEGImageWriter)
ImageIO.getImageWritersBySuffix("jpeg").next(); ImageOutputStream
ios = ImageIO.createImageOutputStream(new File(file));
imageWriter.setOutput(ios); // Compression
JPEGImageWriteParam jpegParams = (JPEGImageWriteParam)
imageWriter.getDefaultWriteParam();
jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
jpegParams.setCompressionQuality(0.85f); // Metadata (dpi)
IIOMetadata data = imageWriter.getDefaultImageMetadata(new
ImageTypeSpecifier(bufferedImage), jpegParams); Element tree =
(Element)data.getAsTree("javax_imageio_jpeg_image_1.0"); Element
jfif = (Element)tree.getElementsByTagName("app0JFIF").item(0);
jfif.setAttribute("Xdensity", Integer.toString(dpi));
jfif.setAttribute("Ydensity", Integer.toString(dpi));
jfif.setAttribute("resUnits", "1"); // density is dots per inch
// Write and clean up imageWriter.write(data, new
IIOImage(bufferedImage, null, null), jpegParams); ios.close();
imageWriter.dispose(); } catch (Exception e)
{ return false; } return true;}
public boolean saveJpeg(int[] byteArray, int width, int height, int dpi, String
file){ BufferedImage bufferedImage = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB); WritableRaster wr = bufferedImage.getRaster();
wr.setPixels(0, 0, width, height, byteArray); try {
// Image writer JPEGImageWriter imageWriter = (JPEGImageWriter)
ImageIO.getImageWritersBySuffix("jpeg").next(); ImageOutputStream
ios = ImageIO.createImageOutputStream(new File(file));
imageWriter.setOutput(ios); // Compression
JPEGImageWriteParam jpegParams = (JPEGImageWriteParam)
imageWriter.getDefaultWriteParam();
jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
jpegParams.setCompressionQuality(0.85f); // Metadata (dpi)
IIOMetadata data = imageWriter.getDefaultImageMetadata(new
ImageTypeSpecifier(bufferedImage), jpegParams); Element tree =
(Element)data.getAsTree("javax_imageio_jpeg_image_1.0"); Element
jfif = (Element)tree.getElementsByTagName("app0JFIF").item(0);
jfif.setAttribute("Xdensity", Integer.toString(dpi));
jfif.setAttribute("Ydensity", Integer.toString(dpi));
jfif.setAttribute("resUnits", "1"); // density is dots per inch
// Write and clean up imageWriter.write(data, new
IIOImage(bufferedImage, null, null), jpegParams); ios.close();
imageWriter.dispose(); } catch (Exception e)
{ return false; } return true;}