Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.imaging.formats.tiff; import java.awt.image.BufferedImage; import java.io.IOException; import java.util.ArrayList; import java.util.Hashtable; import java.util.List; import java.util.Map; import org.apache.commons.imaging.ImageReadException; import org.apache.commons.imaging.ImageWriteException; import org.apache.commons.imaging.common.ByteOrder; import org.apache.commons.imaging.common.ImageMetadata; import org.apache.commons.imaging.common.RationalNumber; import org.apache.commons.imaging.formats.tiff.constants.AllTagConstants; import org.apache.commons.imaging.formats.tiff.constants.GpsTagConstants; import org.apache.commons.imaging.formats.tiff.constants.TiffDirectoryConstants; import org.apache.commons.imaging.formats.tiff.constants.TiffDirectoryType; import org.apache.commons.imaging.formats.tiff.fieldtypes.FieldType; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfo; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoAscii; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoByte; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoDouble; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoFloat; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoGpsText; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoLong; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoRational; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoSByte; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoSLong; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoSRational; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoSShort; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoShort; import org.apache.commons.imaging.formats.tiff.taginfos.TagInfoXpString; import org.apache.commons.imaging.formats.tiff.write.TiffOutputDirectory; import org.apache.commons.imaging.formats.tiff.write.TiffOutputField; import org.apache.commons.imaging.formats.tiff.write.TiffOutputSet; public class TiffImageMetadata extends ImageMetadata implements TiffDirectoryConstants { public final TiffContents contents; private static final Map<Object, Integer> tagCounts = countTags(AllTagConstants.ALL_TAGS); public TiffImageMetadata(final TiffContents contents) { this.contents = contents; } private static final Map<Object, Integer> countTags(final List<TagInfo> tags) { final Map<Object, Integer> map = new Hashtable<Object, Integer>(); for (int i = 0; i < tags.size(); i++) { final TagInfo tag = tags.get(i); final Integer count = map.get(tag.tag); if (count == null) { map.put(tag.tag, 1); } else { map.put(tag.tag, count + 1); } } return map; } public static class Directory extends ImageMetadata implements ImageMetadata.IImageMetadataItem { // private BufferedImage thumbnail = null; public final int type; private final TiffDirectory directory; private final ByteOrder byteOrder; public Directory(final ByteOrder byteOrder, final TiffDirectory directory) { this.type = directory.type; this.directory = directory; this.byteOrder = byteOrder; } public void add(final TiffField entry) { add(new TiffImageMetadata.Item(entry)); } public BufferedImage getThumbnail() throws ImageReadException, IOException { return directory.getTiffImage(byteOrder); } public TiffImageData getTiffImageData() { return directory.getTiffImageData(); } public TiffField findField(final TagInfo tagInfo) throws ImageReadException { return directory.findField(tagInfo); } public List<TiffField> getAllFields() { return directory.getDirectoryEntries(); } public JpegImageData getJpegImageData() { return directory.getJpegImageData(); } @Override public String toString(final String prefix) { return (prefix != null ? prefix : "") + directory.description() + ": " // + (getTiffImageData() != null ? " (tiffImageData)" : "") // + (getJpegImageData() != null ? " (jpegImageData)" : "") // + "\n" + super.toString(prefix) + "\n"; } public TiffOutputDirectory getOutputDirectory(final ByteOrder byteOrder) throws ImageWriteException { try { final TiffOutputDirectory dstDir = new TiffOutputDirectory(type, byteOrder); final List<? extends IImageMetadataItem> entries = getItems(); for (int i = 0; i < entries.size(); i++) { final TiffImageMetadata.Item item = (TiffImageMetadata.Item) entries.get(i); final TiffField srcField = item.getTiffField(); if (null != dstDir.findField(srcField.getTag())) { // ignore duplicate tags in a directory. continue; } else if (srcField.getTagInfo().isOffset()) { // ignore offset fields. continue; } final TagInfo tagInfo = srcField.getTagInfo(); final FieldType fieldType = srcField.getFieldType(); // byte bytes[] = srcField.fieldType.getRawBytes(srcField); // Debug.debug("tagInfo", tagInfo); final Object value = srcField.getValue(); // Debug.debug("value", Debug.getType(value)); final byte bytes[] = tagInfo.encodeValue(fieldType, value, byteOrder); // if (tagInfo.isUnknown()) // Debug.debug( // "\t" + "unknown tag(0x" // + Integer.toHexString(srcField.tag) // + ") bytes", bytes); final int count = bytes.length / fieldType.getSize(); final TiffOutputField dstField = new TiffOutputField(srcField.getTag(), tagInfo, fieldType, count, bytes); dstField.setSortHint(srcField.getSortHint()); dstDir.add(dstField); } dstDir.setTiffImageData(getTiffImageData()); dstDir.setJpegImageData(getJpegImageData()); return dstDir; } catch (final ImageReadException e) { throw new ImageWriteException(e.getMessage(), e); } } } public List<? extends IImageMetadataItem> getDirectories() { return super.getItems(); } @Override public List<? extends IImageMetadataItem> getItems() { final List<IImageMetadataItem> result = new ArrayList<IImageMetadataItem>(); final List<? extends IImageMetadataItem> items = super.getItems(); for (int i = 0; i < items.size(); i++) { final Directory dir = (Directory) items.get(i); result.addAll(dir.getItems()); } return result; } public static class Item extends ImageMetadata.Item { private final TiffField entry; public Item(final TiffField entry) { // super(entry.getTagName() + " (" + entry.getFieldTypeName() + ")", super(entry.getTagName(), entry.getValueDescription()); this.entry = entry; } public TiffField getTiffField() { return entry; } } public TiffOutputSet getOutputSet() throws ImageWriteException { final ByteOrder byteOrder = contents.header.byteOrder; final TiffOutputSet result = new TiffOutputSet(byteOrder); final List<? extends IImageMetadataItem> srcDirs = getDirectories(); for (int i = 0; i < srcDirs.size(); i++) { final TiffImageMetadata.Directory srcDir = (TiffImageMetadata.Directory) srcDirs.get(i); if (null != result.findDirectory(srcDir.type)) { // Certain cameras right directories more than once. // This is a bug. // Ignore second directory of a given type. continue; } final TiffOutputDirectory outputDirectory = srcDir.getOutputDirectory(byteOrder); result.addDirectory(outputDirectory); } return result; } public TiffField findField(final TagInfo tagInfo) throws ImageReadException { return findField(tagInfo, false); } public TiffField findField(final TagInfo tagInfo, final boolean exactDirectoryMatch) throws ImageReadException { // Please keep this method in sync with TiffField's getTag() final Integer tagCount = tagCounts.get(tagInfo.tag); final int tagsMatching = tagCount == null ? 0 : tagCount.intValue(); final List<? extends IImageMetadataItem> directories = getDirectories(); if (exactDirectoryMatch || tagInfo.directoryType != TiffDirectoryType.EXIF_DIRECTORY_UNKNOWN) { for (int i = 0; i < directories.size(); i++) { final Directory directory = (Directory) directories.get(i); if (directory.type == tagInfo.directoryType.directoryType) { final TiffField field = directory.findField(tagInfo); if (field != null) { return field; } } } if (exactDirectoryMatch || tagsMatching > 1) { return null; } for (int i = 0; i < directories.size(); i++) { final Directory directory = (Directory) directories.get(i); if (tagInfo.directoryType.isImageDirectory() && directory.type >= 0) { final TiffField field = directory.findField(tagInfo); if (field != null) { return field; } } else if (!tagInfo.directoryType.isImageDirectory() && directory.type < 0) { final TiffField field = directory.findField(tagInfo); if (field != null) { return field; } } } } for (int i = 0; i < directories.size(); i++) { final Directory directory = (Directory) directories.get(i); final TiffField field = directory.findField(tagInfo); if (field != null) { return field; } } return null; } public Object getFieldValue(final TagInfo tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } return field.getValue(); } public byte[] getFieldValue(final TagInfoByte tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } return field.getByteArrayValue(); } public String[] getFieldValue(final TagInfoAscii tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } final byte[] bytes = field.getByteArrayValue(); return tag.getValue(field.getByteOrder(), bytes); } public short[] getFieldValue(final TagInfoShort tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } final byte[] bytes = field.getByteArrayValue(); return tag.getValue(field.getByteOrder(), bytes); } public int[] getFieldValue(final TagInfoLong tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } final byte[] bytes = field.getByteArrayValue(); return tag.getValue(field.getByteOrder(), bytes); } public RationalNumber[] getFieldValue(final TagInfoRational tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } final byte[] bytes = field.getByteArrayValue(); return tag.getValue(field.getByteOrder(), bytes); } public byte[] getFieldValue(final TagInfoSByte tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } return field.getByteArrayValue(); } public short[] getFieldValue(final TagInfoSShort tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } final byte[] bytes = field.getByteArrayValue(); return tag.getValue(field.getByteOrder(), bytes); } public int[] getFieldValue(final TagInfoSLong tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } final byte[] bytes = field.getByteArrayValue(); return tag.getValue(field.getByteOrder(), bytes); } public RationalNumber[] getFieldValue(final TagInfoSRational tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } final byte[] bytes = field.getByteArrayValue(); return tag.getValue(field.getByteOrder(), bytes); } public float[] getFieldValue(final TagInfoFloat tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } final byte[] bytes = field.getByteArrayValue(); return tag.getValue(field.getByteOrder(), bytes); } public double[] getFieldValue(final TagInfoDouble tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } if (!tag.dataTypes.contains(field.getFieldType())) { return null; } final byte[] bytes = field.getByteArrayValue(); return tag.getValue(field.getByteOrder(), bytes); } public String getFieldValue(final TagInfoGpsText tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } return tag.getValue(field); } public String getFieldValue(final TagInfoXpString tag) throws ImageReadException { final TiffField field = findField(tag); if (field == null) { return null; } return tag.getValue(field); } public TiffDirectory findDirectory(final int directoryType) { final List<? extends IImageMetadataItem> directories = getDirectories(); for (int i = 0; i < directories.size(); i++) { final Directory directory = (Directory) directories.get(i); if (directory.type == directoryType) { return directory.directory; } } return null; } public List<TiffField> getAllFields() { final List<TiffField> result = new ArrayList<TiffField>(); final List<? extends IImageMetadataItem> directories = getDirectories(); for (int i = 0; i < directories.size(); i++) { final Directory directory = (Directory) directories.get(i); result.addAll(directory.getAllFields()); } return result; } public GPSInfo getGPS() throws ImageReadException { final TiffDirectory gpsDirectory = findDirectory(DIRECTORY_TYPE_GPS); if (null == gpsDirectory) { return null; } // more specific example of how to access GPS values. final TiffField latitudeRefField = gpsDirectory.findField(GpsTagConstants.GPS_TAG_GPS_LATITUDE_REF); final TiffField latitudeField = gpsDirectory.findField(GpsTagConstants.GPS_TAG_GPS_LATITUDE); final TiffField longitudeRefField = gpsDirectory.findField(GpsTagConstants.GPS_TAG_GPS_LONGITUDE_REF); final TiffField longitudeField = gpsDirectory.findField(GpsTagConstants.GPS_TAG_GPS_LONGITUDE); if (latitudeRefField == null || latitudeField == null || longitudeRefField == null || longitudeField == null) { return null; } // all of these values are strings. final String latitudeRef = latitudeRefField.getStringValue(); final RationalNumber latitude[] = (RationalNumber[]) latitudeField.getValue(); final String longitudeRef = longitudeRefField.getStringValue(); final RationalNumber longitude[] = (RationalNumber[]) longitudeField.getValue(); if (latitude.length != 3 || longitude.length != 3) { throw new ImageReadException("Expected three values for latitude and longitude."); } final RationalNumber latitudeDegrees = latitude[0]; final RationalNumber latitudeMinutes = latitude[1]; final RationalNumber latitudeSeconds = latitude[2]; final RationalNumber longitudeDegrees = longitude[0]; final RationalNumber longitudeMinutes = longitude[1]; final RationalNumber longitudeSeconds = longitude[2]; return new GPSInfo(latitudeRef, longitudeRef, latitudeDegrees, latitudeMinutes, latitudeSeconds, longitudeDegrees, longitudeMinutes, longitudeSeconds); } public static class GPSInfo { public final String latitudeRef; public final String longitudeRef; public final RationalNumber latitudeDegrees; public final RationalNumber latitudeMinutes; public final RationalNumber latitudeSeconds; public final RationalNumber longitudeDegrees; public final RationalNumber longitudeMinutes; public final RationalNumber longitudeSeconds; public GPSInfo(final String latitudeRef, final String longitudeRef, final RationalNumber latitudeDegrees, final RationalNumber latitudeMinutes, final RationalNumber latitudeSeconds, final RationalNumber longitudeDegrees, final RationalNumber longitudeMinutes, final RationalNumber longitudeSeconds) { this.latitudeRef = latitudeRef; this.longitudeRef = longitudeRef; this.latitudeDegrees = latitudeDegrees; this.latitudeMinutes = latitudeMinutes; this.latitudeSeconds = latitudeSeconds; this.longitudeDegrees = longitudeDegrees; this.longitudeMinutes = longitudeMinutes; this.longitudeSeconds = longitudeSeconds; } @Override public String toString() { // This will format the gps info like so: // // latitude: 8 degrees, 40 minutes, 42.2 seconds S // longitude: 115 degrees, 26 minutes, 21.8 seconds E final StringBuilder result = new StringBuilder(); result.append("[GPS. "); result.append("Latitude: " + latitudeDegrees.toDisplayString() + " degrees, " + latitudeMinutes.toDisplayString() + " minutes, " + latitudeSeconds.toDisplayString() + " seconds " + latitudeRef); result.append(", Longitude: " + longitudeDegrees.toDisplayString() + " degrees, " + longitudeMinutes.toDisplayString() + " minutes, " + longitudeSeconds.toDisplayString() + " seconds " + longitudeRef); result.append("]"); return result.toString(); } public double getLongitudeAsDegreesEast() throws ImageReadException { final double result = longitudeDegrees.doubleValue() + (longitudeMinutes.doubleValue() / 60.0) + (longitudeSeconds.doubleValue() / 3600.0); if (longitudeRef.trim().equalsIgnoreCase("e")) { return result; } else if (longitudeRef.trim().equalsIgnoreCase("w")) { return -result; } else { throw new ImageReadException("Unknown longitude ref: \"" + longitudeRef + "\""); } } public double getLatitudeAsDegreesNorth() throws ImageReadException { final double result = latitudeDegrees.doubleValue() + (latitudeMinutes.doubleValue() / 60.0) + (latitudeSeconds.doubleValue() / 3600.0); if (latitudeRef.trim().equalsIgnoreCase("n")) { return result; } else if (latitudeRef.trim().equalsIgnoreCase("s")) { return -result; } else { throw new ImageReadException("Unknown latitude ref: \"" + latitudeRef + "\""); } } } }