Backups/TwelveMonkeys
2
0
Fork 0
mirror of https://github.com/haraldk/TwelveMonkeys.git synced 2025-08-05 04:25:29 -04:00
Code Issues Projects Releases Wiki Activity

Merge pull request #2 from haraldk/master

Browse Source 
merge from upstream
This commit is contained in:
Oliver Schmidtmer 2015-08-13 18:05:16 +02:00
commit 6ef5a5a7ee
12 changed files with 1709 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -422,9 +422,9 @@ Build the project (using [Maven](http://maven.apache.org/download.cgi)):
$ mvn package
Currently, the only supported JDK for making a build is Oracle JDK 7.x.
Currently, the recommended JDK for making a build is Oracle JDK 7.x or 8.x.
It's possible to build using OpenJDK, but some tests will fail due to some minor differences between the color management systems used. You will need to either disable the tests in question, or build without tests altogether. To build using JDK 8, you need to pass `-Dsun.java2d.cmm=sun.java2d.cmm.kcms.KcmsServiceProvider` to revert to the color manangement system used in Java 7.
It's possible to build using OpenJDK, but some tests might fail due to some minor differences between the color management systems used. You will need to either disable the tests in question, or build without tests altogether.
Because the unit tests needs quite a bit of memory to run, you might have to set the environment variable `MAVEN_OPTS`
to give the Java process that runs Maven more memory. I suggest something like `-Xmx512m -XX:MaxPermSize=256m`.

5
bom/pom.xml
View File

@ -58,6 +58,11 @@
<artifactId>imageio-bmp</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.twelvemonkeys.imageio</groupId>
<artifactId>imageio-hdr</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.twelvemonkeys.imageio</groupId>
<artifactId>imageio-icns</artifactId>

9
imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/AbstractMetadata.java
View File

@ -98,15 +98,6 @@ public abstract class AbstractMetadata extends IIOMetadata implements Cloneable
if (!root.getNodeName().equals(formatName)) {
throw new IIOInvalidTreeException("Root must be " + formatName, root);
}
// TODO: Merge both native and standard!
Node node = root.getFirstChild();
while (node != null) {
// TODO: Merge values from node into this
// Move to the next sibling
node = node.getNextSibling();
}
}
@Override

10
imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/ImageWriterAbstractTestCase.java
View File

@ -63,6 +63,7 @@ public abstract class ImageWriterAbstractTestCase {
static {
IIORegistry.getDefaultInstance().registerServiceProvider(new URLImageInputStreamSpi());
ImageIO.setUseCache(false);
}
protected abstract ImageWriter createImageWriter();
@ -120,23 +121,20 @@ public abstract class ImageWriterAbstractTestCase {
for (RenderedImage testData : getTestData()) {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
ImageOutputStream stream = ImageIO.createImageOutputStream(buffer);
writer.setOutput(stream);
try {
try (ImageOutputStream stream = ImageIO.createImageOutputStream(buffer)) {
writer.setOutput(stream);
writer.write(drawSomething((BufferedImage) testData));
}
catch (IOException e) {
fail(e.getMessage());
}
finally {
stream.close(); // Force data to be written
}
assertTrue("No image data written", buffer.size() > 0);
}
}
@SuppressWarnings("ConstantConditions")
@Test
public void testWriteNull() throws IOException {
ImageWriter writer = createImageWriter();

7
imageio/imageio-metadata/src/main/java/com/twelvemonkeys/imageio/metadata/exif/EXIFEntry.java
View File

@ -38,13 +38,14 @@ import com.twelvemonkeys.imageio.metadata.AbstractEntry;
* @version $Id: EXIFEntry.java,v 1.0 Nov 13, 2009 5:47:35 PM haraldk Exp$
*/
final class EXIFEntry extends AbstractEntry {
// TODO: Expose as TIFFEntry
final private short type;
EXIFEntry(final int identifier, final Object value, final short type) {
super(identifier, value);
if (type < 1 || type >= TIFF.TYPE_NAMES.length) {
throw new IllegalArgumentException(String.format("Illegal EXIF type: %s", type));
throw new IllegalArgumentException(String.format("Illegal TIFF type: %s", type));
}
// TODO: Validate that type is applicable to value?
@ -114,6 +115,8 @@ final class EXIFEntry extends AbstractEntry {
return "PlanarConfiguration";
case TIFF.TAG_RESOLUTION_UNIT:
return "ResolutionUnit";
case TIFF.TAG_PAGE_NAME:
return "PageName";
case TIFF.TAG_PAGE_NUMBER:
return "PageNumber";
case TIFF.TAG_SOFTWARE:
@ -228,6 +231,8 @@ final class EXIFEntry extends AbstractEntry {
return "DateTimeDigitized";
case EXIF.TAG_IMAGE_NUMBER:
return "ImageNumber";
case EXIF.TAG_MAKER_NOTE:
return "MakerNote";
case EXIF.TAG_USER_COMMENT:
return "UserComment";

72
imageio/imageio-metadata/src/main/java/com/twelvemonkeys/imageio/metadata/exif/EXIFWriter.java
View File

@ -40,6 +40,7 @@ import java.io.IOException;
import java.lang.reflect.Array;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.*;
/**
@ -248,9 +249,12 @@ public final class EXIFWriter extends MetadataWriter {
switch (type) {
case TIFF.TYPE_UNDEFINED:
case TIFF.TYPE_BYTE:
case TIFF.TYPE_SBYTE:
stream.write((byte[]) value);
break;
case TIFF.TYPE_SHORT:
case TIFF.TYPE_SSHORT:
short[] shorts;
if (value instanceof short[]) {
@ -279,7 +283,9 @@ public final class EXIFWriter extends MetadataWriter {
stream.writeShorts(shorts, 0, shorts.length);
break;
case TIFF.TYPE_LONG:
case TIFF.TYPE_SLONG:
int[] ints;
if (value instanceof int[]) {
@ -298,17 +304,45 @@ public final class EXIFWriter extends MetadataWriter {
}
stream.writeInts(ints, 0, ints.length);
break;
case TIFF.TYPE_RATIONAL:
case TIFF.TYPE_SRATIONAL:
Rational[] rationals = (Rational[]) value;
for (Rational rational : rationals) {
stream.writeInt((int) rational.numerator());
stream.writeInt((int) rational.denominator());
}
// TODO: More types
break;
case TIFF.TYPE_FLOAT:
float[] floats;
if (value instanceof float[]) {
floats = (float[]) value;
}
else {
throw new IllegalArgumentException("Unsupported type for TIFF FLOAT: " + value.getClass());
}
stream.writeFloats(floats, 0, floats.length);
break;
case TIFF.TYPE_DOUBLE:
double[] doubles;
if (value instanceof double[]) {
doubles = (double[]) value;
}
else {
throw new IllegalArgumentException("Unsupported type for TIFF FLOAT: " + value.getClass());
}
stream.writeDoubles(doubles, 0, doubles.length);
break;
default:
throw new IllegalArgumentException("Unsupported TIFF type: " + type);
@ -319,27 +353,36 @@ public final class EXIFWriter extends MetadataWriter {
// }
else {
switch (type) {
case TIFF.TYPE_UNDEFINED:
case TIFF.TYPE_BYTE:
stream.writeByte((Integer) value);
case TIFF.TYPE_SBYTE:
case TIFF.TYPE_UNDEFINED:
stream.writeByte(((Number) value).intValue());
break;
case TIFF.TYPE_ASCII:
byte[] bytes = ((String) value).getBytes(Charset.forName("UTF-8"));
byte[] bytes = ((String) value).getBytes(StandardCharsets.UTF_8);
stream.write(bytes);
stream.write(0);
break;
case TIFF.TYPE_SHORT:
stream.writeShort((Integer) value);
case TIFF.TYPE_SSHORT:
stream.writeShort(((Number) value).intValue());
break;
case TIFF.TYPE_LONG:
case TIFF.TYPE_SLONG:
stream.writeInt(((Number) value).intValue());
break;
case TIFF.TYPE_RATIONAL:
case TIFF.TYPE_SRATIONAL:
Rational rational = (Rational) value;
stream.writeInt((int) rational.numerator());
stream.writeInt((int) rational.denominator());
break;
// TODO: More types
case TIFF.TYPE_FLOAT:
stream.writeFloat(((Number) value).floatValue());
break;
case TIFF.TYPE_DOUBLE:
stream.writeDouble(((Number) value).doubleValue());
break;
default:
throw new IllegalArgumentException("Unsupported TIFF type: " + type);
@ -356,11 +399,26 @@ public final class EXIFWriter extends MetadataWriter {
}
private short getType(final Entry entry) {
// TODO: What a MESS! Rewrite and expose EXIFEntry as TIFFEntry or so...
// For internal entries use type directly
if (entry instanceof EXIFEntry) {
EXIFEntry exifEntry = (EXIFEntry) entry;
return exifEntry.getType();
}
// For other entries, use name if it matches
String typeName = entry.getTypeName();
if (typeName != null) {
for (int i = 1; i < TIFF.TYPE_NAMES.length; i++) {
if (typeName.equals(TIFF.TYPE_NAMES[i])) {
return (short) i;
}
}
}
// Otherwise, fall back to the native Java type
Object value = Validate.notNull(entry.getValue());
boolean array = value.getClass().isArray();

2
imageio/imageio-metadata/src/main/java/com/twelvemonkeys/imageio/metadata/exif/TIFF.java
View File

@ -95,6 +95,7 @@ public interface TIFF {
null, null,
"LONG8", "SLONG8", "IFD8"
};
/** Length of the corresponding type, in bytes. */
int[] TYPE_LENGTHS = {
-1,
1, 1, 2, 4, 8,
@ -165,6 +166,7 @@ public interface TIFF {
int TAG_IMAGE_DESCRIPTION = 270;
int TAG_MAKE = 271;
int TAG_MODEL = 272;
int TAG_PAGE_NAME = 285;
int TAG_PAGE_NUMBER = 297;
int TAG_SOFTWARE = 305;
int TAG_ARTIST = 315;

534
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageMetadata.java
View File

@ -1,18 +1,24 @@
package com.twelvemonkeys.imageio.plugins.tiff;
import com.twelvemonkeys.imageio.AbstractMetadata;
import com.twelvemonkeys.imageio.metadata.AbstractDirectory;
import com.twelvemonkeys.imageio.metadata.Directory;
import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.lang.Validate;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.imageio.metadata.IIOInvalidTreeException;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.metadata.IIOMetadataNode;
import java.lang.reflect.Array;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.*;
/**
* TIFFImageMetadata.
@ -21,18 +27,46 @@ import java.util.Calendar;
* @author last modified by $Author: harald.kuhr$
* @version $Id: TIFFImageMetadata.java,v 1.0 17/04/15 harald.kuhr Exp$
*/
final class TIFFImageMetadata extends AbstractMetadata {
public final class TIFFImageMetadata extends AbstractMetadata {
private final Directory ifd;
static final int RATIONAL_SCALE_FACTOR = 100000;
TIFFImageMetadata(final Directory ifd) {
super(true, TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME, TIFFMedataFormat.class.getName(), null, null);
this.ifd = Validate.notNull(ifd, "IFD");
private final Directory original;
private Directory ifd;
/**
* Creates an empty TIFF metadata object.
*
* Client code can update or change the metadata using the
* {@link #setFromTree(String, Node)}
* or {@link #mergeTree(String, Node)} methods.
*/
public TIFFImageMetadata() {
this(new TIFFIFD(Collections.<Entry>emptyList()));
}
@Override
public boolean isReadOnly() {
return false;
/**
* Creates a TIFF metadata object, using the values from the given IFD.
*
* Client code can update or change the metadata using the
* {@link #setFromTree(String, Node)}
* or {@link #mergeTree(String, Node)} methods.
*/
public TIFFImageMetadata(final Directory ifd) {
super(true, TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME, TIFFMedataFormat.class.getName(), null, null);
this.ifd = Validate.notNull(ifd, "IFD");
this.original = ifd;
}
/**
* Creates a TIFF metadata object, using the values from the given entries.
*
* Client code can update or change the metadata using the
* {@link #setFromTree(String, Node)}
* or {@link #mergeTree(String, Node)} methods.
*/
public TIFFImageMetadata(final Collection<Entry> entries) {
this(new TIFFIFD(entries));
}
protected IIOMetadataNode getNativeTree() {
@ -99,7 +133,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
IIOMetadataNode elementNode = new IIOMetadataNode(typeName);
valueNode.appendChild(elementNode);
setValue(value, unsigned, elementNode);
setTIFFNativeValue(value, unsigned, elementNode);
}
else {
for (int i = 0; i < count; i++) {
@ -107,7 +141,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
IIOMetadataNode elementNode = new IIOMetadataNode(typeName);
valueNode.appendChild(elementNode);
setValue(val, unsigned, elementNode);
setTIFFNativeValue(val, unsigned, elementNode);
}
}
}
@ -119,7 +153,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
return ifdNode;
}
private void setValue(final Object value, final boolean unsigned, final IIOMetadataNode elementNode) {
private void setTIFFNativeValue(final Object value, final boolean unsigned, final IIOMetadataNode elementNode) {
if (unsigned && value instanceof Byte) {
elementNode.setAttribute("value", String.valueOf((Byte) value & 0xFF));
}
@ -289,12 +323,12 @@ final class TIFFImageMetadata extends AbstractMetadata {
// Handle ColorSpaceType (RGB/CMYK/YCbCr etc)...
Entry photometricTag = ifd.getEntryById(TIFF.TAG_PHOTOMETRIC_INTERPRETATION);
int photometricValue = ((Number) photometricTag.getValue()).intValue(); // No default for this tag!
int photometricValue = getValueAsInt(photometricTag); // No default for this tag!
Entry samplesPerPixelTag = ifd.getEntryById(TIFF.TAG_SAMPLES_PER_PIXEL);
Entry bitsPerSampleTag = ifd.getEntryById(TIFF.TAG_BITS_PER_SAMPLE);
int numChannelsValue = samplesPerPixelTag != null
? ((Number) samplesPerPixelTag.getValue()).intValue()
? getValueAsInt(samplesPerPixelTag)
: bitsPerSampleTag.valueCount();
IIOMetadataNode colorSpaceType = new IIOMetadataNode("ColorSpaceType");
@ -393,7 +427,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
Entry compressionTag = ifd.getEntryById(TIFF.TAG_COMPRESSION);
int compressionValue = compressionTag == null
? TIFFBaseline.COMPRESSION_NONE
: ((Number) compressionTag.getValue()).intValue();
: getValueAsInt(compressionTag);
// Naming is identical to JAI ImageIO metadata as far as possible
switch (compressionValue) {
@ -502,7 +536,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
Entry planarConfigurationTag = ifd.getEntryById(TIFF.TAG_PLANAR_CONFIGURATION);
int planarConfigurationValue = planarConfigurationTag == null
? TIFFBaseline.PLANARCONFIG_CHUNKY
: ((Number) planarConfigurationTag.getValue()).intValue();
: getValueAsInt(planarConfigurationTag);
switch (planarConfigurationValue) {
case TIFFBaseline.PLANARCONFIG_CHUNKY:
@ -519,14 +553,16 @@ final class TIFFImageMetadata extends AbstractMetadata {
Entry photometricInterpretationTag = ifd.getEntryById(TIFF.TAG_PHOTOMETRIC_INTERPRETATION);
int photometricInterpretationValue = photometricInterpretationTag == null
? TIFFBaseline.PHOTOMETRIC_WHITE_IS_ZERO
: ((Number) photometricInterpretationTag.getValue()).intValue();
: getValueAsInt(photometricInterpretationTag);
Entry samleFormatTag = ifd.getEntryById(TIFF.TAG_SAMPLE_FORMAT);
// TODO: Fix for sampleformat 1 1 1 (as int[]) ??!?!?
int sampleFormatValue = samleFormatTag == null
? TIFFBaseline.SAMPLEFORMAT_UINT
: ((Number) samleFormatTag.getValue()).intValue();
: getValueAsInt(samleFormatTag);
IIOMetadataNode sampleFormat = new IIOMetadataNode("SampleFormat");
node.appendChild(sampleFormat);
switch (sampleFormatValue) {
case TIFFBaseline.SAMPLEFORMAT_UINT:
if (photometricInterpretationValue == TIFFBaseline.PHOTOMETRIC_PALETTE) {
@ -562,13 +598,13 @@ final class TIFFImageMetadata extends AbstractMetadata {
Entry samplesPerPixelTag = ifd.getEntryById(TIFF.TAG_SAMPLES_PER_PIXEL);
int numChannelsValue = samplesPerPixelTag != null
? ((Number) samplesPerPixelTag.getValue()).intValue()
? getValueAsInt(samplesPerPixelTag)
: bitsPerSampleTag.valueCount();
// SampleMSB
Entry fillOrderTag = ifd.getEntryById(TIFF.TAG_FILL_ORDER);
int fillOrder = fillOrderTag != null
? ((Number) fillOrderTag.getValue()).intValue()
? getValueAsInt(fillOrderTag)
: TIFFBaseline.FILL_LEFT_TO_RIGHT;
IIOMetadataNode sampleMSB = new IIOMetadataNode("SampleMSB");
node.appendChild(sampleMSB);
@ -588,6 +624,22 @@ final class TIFFImageMetadata extends AbstractMetadata {
return node;
}
private static int getValueAsInt(final Entry entry) {
Object value = entry.getValue();
if (value instanceof Number) {
return ((Number) value).intValue();
}
else if (value instanceof short[]) {
return ((short[]) value)[0];
}
else if (value instanceof int[]) {
return ((int[]) value)[0];
}
throw new IllegalArgumentException("Unsupported type: " + entry);
}
// TODO: Candidate superclass method!
private String createListValue(final int itemCount, final String... values) {
StringBuilder buffer = new StringBuilder();
@ -620,7 +672,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
// ImageOrientation
Entry orientationTag = ifd.getEntryById(TIFF.TAG_ORIENTATION);
if (orientationTag != null) {
int orientationValue = ((Number) orientationTag.getValue()).intValue();
int orientationValue = getValueAsInt(orientationTag);
String value = null;
switch (orientationValue) {
@ -659,7 +711,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
}
Entry resUnitTag = ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT);
int resUnitValue = resUnitTag == null ? TIFFBaseline.RESOLUTION_UNIT_DPI : ((Number) resUnitTag.getValue()).intValue();
int resUnitValue = resUnitTag == null ? TIFFBaseline.RESOLUTION_UNIT_DPI : getValueAsInt(resUnitTag);
if (resUnitValue == TIFFBaseline.RESOLUTION_UNIT_CENTIMETER || resUnitValue == TIFFBaseline.RESOLUTION_UNIT_DPI) {
// 10 mm in 1 cm or 25.4 mm in 1 inch
double scale = resUnitValue == TIFFBaseline.RESOLUTION_UNIT_CENTIMETER ? 10 : 25.4;
@ -703,7 +755,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
if (extraSamplesTag != null) {
int extraSamplesValue = (extraSamplesTag.getValue() instanceof Number)
? ((Number) extraSamplesTag.getValue()).intValue()
? getValueAsInt(extraSamplesTag)
: ((Number) Array.get(extraSamplesTag.getValue(), 0)).intValue();
// Other values exists, these are not alpha
@ -739,7 +791,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
if (subFileTypeTag != null) {
// NOTE: The JAI metadata is somewhat broken here, as these are bit flags, not values...
String value = null;
int subFileTypeValue = ((Number) subFileTypeTag.getValue()).intValue();
int subFileTypeValue = getValueAsInt(subFileTypeTag);
if ((subFileTypeValue & TIFFBaseline.FILETYPE_MASK) != 0) {
value = "TransparencyMask";
}
@ -795,6 +847,7 @@ final class TIFFImageMetadata extends AbstractMetadata {
addTextEntryIfPresent(text, TIFF.TAG_IMAGE_DESCRIPTION);
addTextEntryIfPresent(text, TIFF.TAG_MAKE);
addTextEntryIfPresent(text, TIFF.TAG_MODEL);
addTextEntryIfPresent(text, TIFF.TAG_PAGE_NAME);
addTextEntryIfPresent(text, TIFF.TAG_SOFTWARE);
addTextEntryIfPresent(text, TIFF.TAG_ARTIST);
addTextEntryIfPresent(text, TIFF.TAG_HOST_COMPUTER);
@ -821,4 +874,435 @@ final class TIFFImageMetadata extends AbstractMetadata {
// See http://stackoverflow.com/questions/30910719/javax-imageio-1-0-standard-plug-in-neutral-metadata-format-tiling-information
return super.getStandardTileNode();
}
/// Mutation
@Override
public boolean isReadOnly() {
return false;
}
public void setFromTree(final String formatName, final Node root) throws IIOInvalidTreeException {
// Standard validation
super.mergeTree(formatName, root);
// Set by "merging" with empty map
LinkedHashMap<Integer, Entry> entries = new LinkedHashMap<>();
mergeEntries(formatName, root, entries);
// TODO: Consistency validation?
// Finally create a new IFD from merged values
ifd = new TIFFIFD(entries.values());
}
@Override
public void mergeTree(final String formatName, final Node root) throws IIOInvalidTreeException {
// Standard validation
super.mergeTree(formatName, root);
// Clone entries (shallow clone, as entries themselves are immutable)
LinkedHashMap<Integer, Entry> entries = new LinkedHashMap<>(ifd.size() + 10);
for (Entry entry : ifd) {
entries.put((Integer) entry.getIdentifier(), entry);
}
mergeEntries(formatName, root, entries);
// TODO: Consistency validation?
// Finally create a new IFD from merged values
ifd = new TIFFIFD(entries.values());
}
private void mergeEntries(final String formatName, final Node root, final Map<Integer, Entry> entries) throws IIOInvalidTreeException {
// Merge from both native and standard trees
if (getNativeMetadataFormatName().equals(formatName)) {
mergeNativeTree(root, entries);
}
else if (IIOMetadataFormatImpl.standardMetadataFormatName.equals(formatName)) {
mergeStandardTree(root, entries);
}
else {
// Should already be checked for
throw new AssertionError();
}
}
private void mergeStandardTree(final Node root, final Map<Integer, Entry> entries) throws IIOInvalidTreeException {
NodeList nodes = root.getChildNodes();
// Merge selected values from standard tree
for (int i = 0; i < nodes.getLength(); i++) {
Node node = nodes.item(i);
if ("Dimension".equals(node.getNodeName())) {
mergeFromStandardDimensionNode(node, entries);
}
else if ("Document".equals(node.getNodeName())) {
mergeFromStandardDocumentNode(node, entries);
}
else if ("Text".equals(node.getNodeName())) {
mergeFromStandardTextNode(node, entries);
}
}
}
private void mergeFromStandardDimensionNode(final Node dimensionNode, final Map<Integer, Entry> entries) {
// Dimension: xRes/yRes
// - If set, set res unit to pixels per cm as this better reflects values?
// - Or, convert to DPI, if we already had values in DPI??
// Also, if we have only aspect, set these values, and use unknown as unit?
// TODO: ImageOrientation => Orientation
NodeList children = dimensionNode.getChildNodes();
Float aspect = null;
Float xRes = null;
Float yRes = null;
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
String nodeName = child.getNodeName();
if ("PixelAspectRatio".equals(nodeName)) {
aspect = Float.parseFloat(getAttribute(child, "value"));
}
else if ("HorizontalPixelSize".equals(nodeName)) {
xRes = Float.parseFloat(getAttribute(child, "value"));
}
else if ("VerticalPixelSize".equals(nodeName)) {
yRes = Float.parseFloat(getAttribute(child, "value"));
}
}
// If we have one size compute the other
if (xRes == null && yRes != null) {
xRes = yRes * (aspect != null ? aspect : 1f);
}
else if (yRes == null && xRes != null) {
yRes = xRes / (aspect != null ? aspect : 1f);
}
// If we have resolution
if (xRes != null && yRes != null) {
// If old unit was DPI, convert values and keep DPI, otherwise use PPCM
Entry resUnitEntry = entries.get(TIFF.TAG_RESOLUTION_UNIT);
int resUnitValue = resUnitEntry != null && resUnitEntry.getValue() != null
&& ((Number) resUnitEntry.getValue()).intValue() == TIFFBaseline.RESOLUTION_UNIT_DPI
? TIFFBaseline.RESOLUTION_UNIT_DPI
: TIFFBaseline.RESOLUTION_UNIT_CENTIMETER;
// Units from standard format are pixels per mm, convert to cm or inches
float scale = resUnitValue == TIFFBaseline.RESOLUTION_UNIT_CENTIMETER ? 10 : 25.4f;
int x = Math.round(xRes * scale * RATIONAL_SCALE_FACTOR);
int y = Math.round(yRes * scale * RATIONAL_SCALE_FACTOR);
entries.put(TIFF.TAG_X_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_X_RESOLUTION, new Rational(x, RATIONAL_SCALE_FACTOR)));
entries.put(TIFF.TAG_Y_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_Y_RESOLUTION, new Rational(y, RATIONAL_SCALE_FACTOR)));
entries.put(TIFF.TAG_RESOLUTION_UNIT,
new TIFFImageWriter.TIFFEntry(TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, resUnitValue));
}
else if (aspect != null) {
if (aspect >= 1) {
int v = Math.round(aspect * RATIONAL_SCALE_FACTOR);
entries.put(TIFF.TAG_X_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_X_RESOLUTION, new Rational(v, RATIONAL_SCALE_FACTOR)));
entries.put(TIFF.TAG_Y_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_Y_RESOLUTION, new Rational(1)));
}
else {
int v = Math.round(RATIONAL_SCALE_FACTOR / aspect);
entries.put(TIFF.TAG_X_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_X_RESOLUTION, new Rational(1)));
entries.put(TIFF.TAG_Y_RESOLUTION, new TIFFImageWriter.TIFFEntry(TIFF.TAG_Y_RESOLUTION, new Rational(v, RATIONAL_SCALE_FACTOR)));
}
entries.put(TIFF.TAG_RESOLUTION_UNIT,
new TIFFImageWriter.TIFFEntry(TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, TIFFBaseline.RESOLUTION_UNIT_NONE));
}
// Else give up...
}
private void mergeFromStandardDocumentNode(final Node documentNode, final Map<Integer, Entry> entries) {
// Document: SubfileType, CreationDate
NodeList children = documentNode.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
String nodeName = child.getNodeName();
if ("SubimageInterpretation".equals(nodeName)) {
// TODO: SubFileType
}
else if ("ImageCreationTime".equals(nodeName)) {
// TODO: CreationDate
}
}
}
private void mergeFromStandardTextNode(final Node textNode, final Map<Integer, Entry> entries) throws IIOInvalidTreeException {
NodeList textEntries = textNode.getChildNodes();
for (int i = 0; i < textEntries.getLength(); i++) {
Node textEntry = textEntries.item(i);
if (!"TextEntry".equals(textEntry.getNodeName())) {
throw new IIOInvalidTreeException("Text node should only contain TextEntry nodes", textNode);
}
String keyword = getAttribute(textEntry, "keyword");
String value = getAttribute(textEntry, "value");
// DocumentName, ImageDescription, Make, Model, PageName,
// Software, Artist, HostComputer, InkNames, Copyright
if (value != null && !value.isEmpty() && keyword != null) {
// We do all comparisons in lower case, for compatibility
keyword = keyword.toLowerCase();
TIFFImageWriter.TIFFEntry entry;
if ("documentname".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_DOCUMENT_NAME, TIFF.TYPE_ASCII, value);
}
else if ("imagedescription".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_IMAGE_DESCRIPTION, TIFF.TYPE_ASCII, value);
}
else if ("make".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_MAKE, TIFF.TYPE_ASCII, value);
}
else if ("model".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_MODEL, TIFF.TYPE_ASCII, value);
}
else if ("pagename".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_PAGE_NAME, TIFF.TYPE_ASCII, value);
}
else if ("software".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_SOFTWARE, TIFF.TYPE_ASCII, value);
}
else if ("artist".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_ARTIST, TIFF.TYPE_ASCII, value);
}
else if ("hostcomputer".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_HOST_COMPUTER, TIFF.TYPE_ASCII, value);
}
else if ("inknames".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_INK_NAMES, TIFF.TYPE_ASCII, value);
}
else if ("copyright".equals(keyword)) {
entry = new TIFFImageWriter.TIFFEntry(TIFF.TAG_COPYRIGHT, TIFF.TYPE_ASCII, value);
}
else {
continue;
}
entries.put((Integer) entry.getIdentifier(), entry);
}
}
}
private void mergeNativeTree(final Node root, final Map<Integer, Entry> entries) throws IIOInvalidTreeException {
Directory ifd = toIFD(root.getFirstChild());
// Merge (overwrite) entries with entries from IFD
for (Entry entry : ifd) {
entries.put((Integer) entry.getIdentifier(), entry);
}
}
private Directory toIFD(final Node ifdNode) throws IIOInvalidTreeException {
if (ifdNode == null || !ifdNode.getNodeName().equals("TIFFIFD")) {
throw new IIOInvalidTreeException("Expected \"TIFFIFD\" node", ifdNode);
}
List<Entry> entries = new ArrayList<>();
NodeList nodes = ifdNode.getChildNodes();
for (int i = 0; i < nodes.getLength(); i++) {
entries.add(toEntry(nodes.item(i)));
}
return new TIFFIFD(entries);
}
private Entry toEntry(final Node node) throws IIOInvalidTreeException {
String name = node.getNodeName();
if (name.equals("TIFFIFD")) {
int tag = Integer.parseInt(getAttribute(node, "parentTagNumber"));
Directory subIFD = toIFD(node);
return new TIFFImageWriter.TIFFEntry(tag, TIFF.TYPE_IFD, subIFD);
}
else if (name.equals("TIFFField")) {
int tag = Integer.parseInt(getAttribute(node, "number"));
short type = getTIFFType(node);
Object value = getValue(node, type);
return value != null ? new TIFFImageWriter.TIFFEntry(tag, type, value) : null;
}
else {
throw new IIOInvalidTreeException("Expected \"TIFFIFD\" or \"TIFFField\" node: " + name, node);
}
}
private short getTIFFType(final Node node) throws IIOInvalidTreeException {
Node containerNode = node.getFirstChild();
if (containerNode == null) {
throw new IIOInvalidTreeException("Missing value wrapper node", node);
}
String nodeName = containerNode.getNodeName();
if (!nodeName.startsWith("TIFF")) {
throw new IIOInvalidTreeException("Unexpected value wrapper node, expected type", containerNode);
}
String typeName = nodeName.substring(4);
if (typeName.equals("Undefined")) {
return TIFF.TYPE_UNDEFINED;
}
typeName = typeName.substring(0, typeName.length() - 1).toUpperCase();
for (int i = 1; i < TIFF.TYPE_NAMES.length; i++) {
if (typeName.equals(TIFF.TYPE_NAMES[i])) {
return (short) i;
}
}
throw new IIOInvalidTreeException("Unknown TIFF type: " + typeName, containerNode);
}
private Object getValue(final Node node, final short type) throws IIOInvalidTreeException {
Node child = node.getFirstChild();
if (child != null) {
String typeName = child.getNodeName();
if (type == TIFF.TYPE_UNDEFINED) {
String values = getAttribute(child, "value");
String[] vals = values.split(",\\s?");
byte[] bytes = new byte[vals.length];
for (int i = 0; i < vals.length; i++) {
bytes[i] = Byte.parseByte(vals[i]);
}
return bytes;
}
else {
NodeList valueNodes = child.getChildNodes();
// Create array for each type
int count = valueNodes.getLength();
Object value = createArrayForType(type, count);
// Parse each value
for (int i = 0; i < count; i++) {
Node valueNode = valueNodes.item(i);
if (!typeName.startsWith(valueNode.getNodeName())) {
throw new IIOInvalidTreeException("Value node does not match container node", child);
}
String stringValue = getAttribute(valueNode, "value");
// NOTE: The reason for parsing "wider" type, is to allow for unsigned values
switch (type) {
case TIFF.TYPE_BYTE:
case TIFF.TYPE_SBYTE:
((byte[]) value)[i] = (byte) Short.parseShort(stringValue);
break;
case TIFF.TYPE_ASCII:
((String[]) value)[i] = stringValue;
break;
case TIFF.TYPE_SHORT:
case TIFF.TYPE_SSHORT:
((short[]) value)[i] = (short) Integer.parseInt(stringValue);
break;
case TIFF.TYPE_LONG:
case TIFF.TYPE_SLONG:
((int[]) value)[i] = (int) Long.parseLong(stringValue);
break;
case TIFF.TYPE_RATIONAL:
case TIFF.TYPE_SRATIONAL:
String[] numDenom = stringValue.split("/");
((Rational[]) value)[i] = numDenom.length > 1
? new Rational(Long.parseLong(numDenom[0]), Long.parseLong(numDenom[1]))
: new Rational(Long.parseLong(numDenom[0]));
break;
case TIFF.TYPE_FLOAT:
((float[]) value)[i] = Float.parseFloat(stringValue);
break;
case TIFF.TYPE_DOUBLE:
((double[]) value)[i] = Double.parseDouble(stringValue);
break;
default:
throw new AssertionError("Unsupported TIFF type: " + type);
}
}
// Normalize value
if (count == 0) {
return null;
}
if (count == 1) {
return Array.get(value, 0);
}
return value;
}
}
throw new IIOInvalidTreeException("Empty TIFField node", node);
}
private Object createArrayForType(final short type, final int length) {
switch (type) {
case TIFF.TYPE_ASCII:
return new String[length];
case TIFF.TYPE_BYTE:
case TIFF.TYPE_SBYTE:
case TIFF.TYPE_UNDEFINED: // Not used here, but for completeness
return new byte[length];
case TIFF.TYPE_SHORT:
case TIFF.TYPE_SSHORT:
return new short[length];
case TIFF.TYPE_LONG:
case TIFF.TYPE_SLONG:
return new int[length];
case TIFF.TYPE_IFD:
return new long[length];
case TIFF.TYPE_RATIONAL:
case TIFF.TYPE_SRATIONAL:
return new Rational[length];
case TIFF.TYPE_FLOAT:
return new float[length];
case TIFF.TYPE_DOUBLE:
return new double[length];
default:
throw new AssertionError("Unsupported TIFF type: " + type);
}
}
private String getAttribute(final Node node, final String attribute) {
return node instanceof Element ? ((Element) node).getAttribute(attribute) : null;
}
@Override
public void reset() {
super.reset();
ifd = original;
}
Directory getIFD() {
return ifd;
}
// TODO: Replace with IFD class when moved to new package and made public!
private final static class TIFFIFD extends AbstractDirectory {
public TIFFIFD(final Collection<Entry> entries) {
super(entries);
}
}
}

161
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageReader.java
View File

@ -36,7 +36,10 @@ import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.EXIFReader;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.imageio.metadata.iptc.IPTCReader;
import com.twelvemonkeys.imageio.metadata.jpeg.JPEG;
import com.twelvemonkeys.imageio.metadata.psd.PSDReader;
import com.twelvemonkeys.imageio.metadata.xmp.XMPReader;
import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream;
import com.twelvemonkeys.imageio.stream.SubImageInputStream;
import com.twelvemonkeys.imageio.util.IIOUtil;
@ -64,7 +67,9 @@ import java.awt.image.*;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
@ -82,15 +87,16 @@ import java.util.zip.InflaterInputStream;
* In addition, it supports many common TIFF extensions such as:
* <ul>
* <li>Tiling</li>
* <li>Class F (Facsimile), CCITT T.4 and T.6 compression (types 3 and 4), 1 bit per sample</li>
* <li>LZW Compression (type 5)</li>
* <li>"Old-style" JPEG Compression (type 6), as a best effort, as the spec is not well-defined</li>
* <li>JPEG Compression (type 7)</li>
* <li>ZLib (aka Adobe-style Deflate) Compression (type 8)</li>
* <li>Deflate Compression (type 32946)</li>
* <li>Horizontal differencing Predictor (type 2) for LZW, ZLib, Deflate and PackBits compression</li>
* <li>Alpha channel (ExtraSamples type 1/Associated Alpha)</li>
* <li>CMYK data (PhotometricInterpretation type 5/Separated)</li>
* <li>YCbCr data (PhotometricInterpretation type 6/YCbCr) for JPEG</li>
* <li>Alpha channel (ExtraSamples types 1/Associated Alpha and 2/Unassociated Alpha)</li>
* <li>Class S, CMYK data (PhotometricInterpretation type 5/Separated)</li>
* <li>Class Y, YCbCr data (PhotometricInterpretation type 6/YCbCr for both JPEG and other compressions</li>
* <li>Planar data (PlanarConfiguration type 2/Planar)</li>
* <li>ICC profiles (ICCProfile)</li>
* <li>BitsPerSample values up to 16 for most PhotometricInterpretations</li>
@ -119,7 +125,6 @@ public class TIFFImageReader extends ImageReaderBase {
// TODO: Implement readAsRenderedImage to allow tiled RenderedImage?
// For some layouts, we could do reads super-fast with a memory mapped buffer.
// TODO: Implement readAsRaster directly
// TODO: IIOMetadata (stay close to Sun's TIFF metadata)
// http://download.java.net/media/jai-imageio/javadoc/1.1/com/sun/media/imageio/plugins/tiff/package-summary.html#ImageMetadata
// TODOs Extension support
@ -136,6 +141,7 @@ public class TIFFImageReader extends ImageReaderBase {
// Support Compression 2 (CCITT Modified Huffman RLE) for bi-level images
// Source region
// Subsampling
// IIOMetadata (stay close to Sun's TIFF metadata)
final static boolean DEBUG = "true".equalsIgnoreCase(System.getProperty("com.twelvemonkeys.imageio.plugins.tiff.debug"));
@ -167,6 +173,73 @@ public class TIFFImageReader extends ImageReaderBase {
for (int i = 0; i < IFDs.directoryCount(); i++) {
System.err.printf("IFD %d: %s\n", i, IFDs.getDirectory(i));
}
Entry tiffXMP = IFDs.getEntryById(TIFF.TAG_XMP);
if (tiffXMP != null) {
byte[] value = (byte[]) tiffXMP.getValue();
// The XMPReader doesn't like null-termination...
int len = value.length;
for (int i = len - 1; i > 0; i--) {
if (value[i] == 0) {
len--;
}
else {
break;
}
}
Directory xmp = new XMPReader().read(new ByteArrayImageInputStream(value, 0, len));
System.err.println("-----------------------------------------------------------------------------");
System.err.println("xmp: " + xmp);
}
Entry tiffIPTC = IFDs.getEntryById(TIFF.TAG_IPTC);
if (tiffIPTC != null) {
Object value = tiffIPTC.getValue();
if (value instanceof short[]) {
System.err.println("short[]: " + value);
}
if (value instanceof long[]) {
// As seen in a Magick produced image...
System.err.println("long[]: " + value);
long[] longs = (long[]) value;
value = new byte[longs.length * 8];
ByteBuffer.wrap((byte[]) value).asLongBuffer().put(longs);
}
if (value instanceof float[]) {
System.err.println("float[]: " + value);
}
if (value instanceof double[]) {
System.err.println("double[]: " + value);
}
Directory iptc = new IPTCReader().read(new ByteArrayImageInputStream((byte[]) value));
System.err.println("-----------------------------------------------------------------------------");
System.err.println("iptc: " + iptc);
}
Entry tiffPSD = IFDs.getEntryById(TIFF.TAG_PHOTOSHOP);
if (tiffPSD != null) {
Directory psd = new PSDReader().read(new ByteArrayImageInputStream((byte[]) tiffPSD.getValue()));
System.err.println("-----------------------------------------------------------------------------");
System.err.println("psd: " + psd);
}
Entry tiffPSD2 = IFDs.getEntryById(TIFF.TAG_PHOTOSHOP_IMAGE_SOURCE_DATA);
if (tiffPSD2 != null) {
byte[] value = (byte[]) tiffPSD2.getValue();
String foo = "Adobe Photoshop Document Data Block";
if (Arrays.equals(foo.getBytes(StandardCharsets.US_ASCII), Arrays.copyOf(value, foo.length()))) {
System.err.println("foo: " + foo);
// int offset = foo.length() + 1;
// ImageInputStream input = new ByteArrayImageInputStream(value, offset, value.length - offset);
// input.setByteOrder(ByteOrder.LITTLE_ENDIAN); // TODO: WHY???!
// Directory psd2 = new PSDReader().read(input);
// System.err.println("-----------------------------------------------------------------------------");
// System.err.println("psd2: " + psd2);
}
}
}
}
}
@ -414,11 +487,17 @@ public class TIFFImageReader extends ImageReaderBase {
if (bitsPerSample == 16) {
return DataBuffer.TYPE_SHORT;
}
throw new IIOException("Unsupported BitPerSample for SampleFormat 2/Signed Integer (expected 16): " + bitsPerSample);
throw new IIOException("Unsupported BitsPerSample for SampleFormat 2/Signed Integer (expected 16): " + bitsPerSample);
case TIFFExtension.SAMPLEFORMAT_FP:
throw new IIOException("Unsupported TIFF SampleFormat: (3/Floating point)");
throw new IIOException("Unsupported TIFF SampleFormat: 3 (Floating point)");
case TIFFExtension.SAMPLEFORMAT_UNDEFINED:
throw new IIOException("Unsupported TIFF SampleFormat (4/Undefined)");
// Spec says:
// A field value of “undefined” is a statement by the writer that it did not know how
// to interpret the data samples; for example, if it were copying an existing image. A
// reader would typically treat an image with “undefined” data as if the field were
// not present (i.e. as unsigned integer data).
// TODO: We should probably issue a warning instead, and assume SAMPLEFORMAT_UINT
throw new IIOException("Unsupported TIFF SampleFormat: 4 (Undefined)");
default:
throw new IIOException("Unknown TIFF SampleFormat (expected 1, 2, 3 or 4): " + sampleFormat);
}
@ -888,7 +967,7 @@ public class TIFFImageReader extends ImageReaderBase {
imageInput.seek(realJPEGOffset);
stream = new SubImageInputStream(imageInput, jpegLenght != -1 ? jpegLenght : Short.MAX_VALUE);
stream = new SubImageInputStream(imageInput, jpegLenght != -1 ? jpegLenght : Integer.MAX_VALUE);
jpegReader.setInput(stream);
// Read data
@ -1500,27 +1579,30 @@ public class TIFFImageReader extends ImageReaderBase {
// param.setSourceSubsampling(sub, sub, 0, 0);
// }
long start = System.currentTimeMillis();
try {
long start = System.currentTimeMillis();
// int width = reader.getWidth(imageNo);
// int height = reader.getHeight(imageNo);
// param.setSourceRegion(new Rectangle(width / 4, height / 4, width / 2, height / 2));
// param.setSourceRegion(new Rectangle(100, 300, 400, 400));
// param.setSourceRegion(new Rectangle(3, 3, 9, 9));
// param.setDestinationOffset(new Point(50, 150));
// param.setSourceSubsampling(2, 2, 0, 0);
BufferedImage image = reader.read(imageNo, param);
System.err.println("Read time: " + (System.currentTimeMillis() - start) + " ms");
BufferedImage image = reader.read(imageNo, param);
System.err.println("Read time: " + (System.currentTimeMillis() - start) + " ms");
IIOMetadata metadata = reader.getImageMetadata(imageNo);
if (metadata != null) {
if (metadata.getNativeMetadataFormatName() != null) {
new XMLSerializer(System.out, "UTF-8").serialize(metadata.getAsTree(metadata.getNativeMetadataFormatName()), false);
IIOMetadata metadata = reader.getImageMetadata(imageNo);
if (metadata != null) {
if (metadata.getNativeMetadataFormatName() != null) {
new XMLSerializer(System.out, "UTF-8").serialize(metadata.getAsTree(metadata.getNativeMetadataFormatName()), false);
}
/*else*/
if (metadata.isStandardMetadataFormatSupported()) {
new XMLSerializer(System.out, "UTF-8").serialize(metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName), false);
}
}
/*else*/ if (metadata.isStandardMetadataFormatSupported()) {
new XMLSerializer(System.out, "UTF-8").serialize(metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName), false);
}
}
System.err.println("image: " + image);
System.err.println("image: " + image);
// File tempFile = File.createTempFile("lzw-", ".bin");
// byte[] data = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
@ -1536,7 +1618,7 @@ public class TIFFImageReader extends ImageReaderBase {
//
// System.err.println("tempFile: " + tempFile.getAbsolutePath());
// image = new ResampleOp(reader.getWidth(0) / 4, reader.getHeight(0) / 4, ResampleOp.FILTER_LANCZOS).filter(image, null);
// image = new ResampleOp(reader.getWidth(0) / 4, reader.getHeight(0) / 4, ResampleOp.FILTER_LANCZOS).filter(image, null);
//
// int maxW = 800;
// int maxH = 800;
@ -1553,30 +1635,35 @@ public class TIFFImageReader extends ImageReaderBase {
// // System.err.println("Scale time: " + (System.currentTimeMillis() - start) + " ms");
// }
if (image.getType() == BufferedImage.TYPE_CUSTOM) {
start = System.currentTimeMillis();
image = new ColorConvertOp(null).filter(image, new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB));
System.err.println("Conversion time: " + (System.currentTimeMillis() - start) + " ms");
}
if (image.getType() == BufferedImage.TYPE_CUSTOM) {
start = System.currentTimeMillis();
image = new ColorConvertOp(null).filter(image, new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB));
System.err.println("Conversion time: " + (System.currentTimeMillis() - start) + " ms");
}
showIt(image, String.format("Image: %s [%d x %d]", file.getName(), reader.getWidth(imageNo), reader.getHeight(imageNo)));
showIt(image, String.format("Image: %s [%d x %d]", file.getName(), reader.getWidth(imageNo), reader.getHeight(imageNo)));
try {
int numThumbnails = reader.getNumThumbnails(0);
for (int thumbnailNo = 0; thumbnailNo < numThumbnails; thumbnailNo++) {
BufferedImage thumbnail = reader.readThumbnail(imageNo, thumbnailNo);
// System.err.println("thumbnail: " + thumbnail);
showIt(thumbnail, String.format("Thumbnail: %s [%d x %d]", file.getName(), thumbnail.getWidth(), thumbnail.getHeight()));
try {
int numThumbnails = reader.getNumThumbnails(0);
for (int thumbnailNo = 0; thumbnailNo < numThumbnails; thumbnailNo++) {
BufferedImage thumbnail = reader.readThumbnail(imageNo, thumbnailNo);
// System.err.println("thumbnail: " + thumbnail);
showIt(thumbnail, String.format("Thumbnail: %s [%d x %d]", file.getName(), thumbnail.getWidth(), thumbnail.getHeight()));
}
}
catch (IIOException e) {
System.err.println("Could not read thumbnails: " + e.getMessage());
e.printStackTrace();
}
}
catch (IIOException e) {
System.err.println("Could not read thumbnails: " + e.getMessage());
e.printStackTrace();
catch (Throwable t) {
System.err.println(file + " image " + imageNo + " can't be read:");
t.printStackTrace();
}
}
}
catch (Throwable t) {
System.err.println(file);
System.err.println(file + " can't be read:");
t.printStackTrace();
}
finally {

192
imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageWriter.java
View File

@ -31,6 +31,7 @@ package com.twelvemonkeys.imageio.plugins.tiff;
import com.twelvemonkeys.image.ImageUtil;
import com.twelvemonkeys.imageio.ImageWriterBase;
import com.twelvemonkeys.imageio.metadata.AbstractEntry;
import com.twelvemonkeys.imageio.metadata.Directory;
import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.EXIFWriter;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
@ -39,9 +40,12 @@ import com.twelvemonkeys.imageio.stream.SubImageOutputStream;
import com.twelvemonkeys.imageio.util.IIOUtil;
import com.twelvemonkeys.io.enc.EncoderStream;
import com.twelvemonkeys.io.enc.PackBitsEncoder;
import com.twelvemonkeys.lang.Validate;
import javax.imageio.*;
import javax.imageio.metadata.IIOInvalidTreeException;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.spi.ImageWriterSpi;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
@ -50,10 +54,9 @@ import java.awt.color.ColorSpace;
import java.awt.color.ICC_ColorSpace;
import java.awt.image.*;
import java.io.*;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.*;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
@ -65,13 +68,16 @@ import java.util.zip.DeflaterOutputStream;
* @version $Id: TIFFImageWriter.java,v 1.0 18.09.13 12:46 haraldk Exp$
*/
public final class TIFFImageWriter extends ImageWriterBase {
// Short term
// TODO: Support more of the ImageIO metadata (ie. compression from metadata, etc)
// Long term
// TODO: Support tiling
// TODO: Support thumbnails
// TODO: Support ImageIO metadata
// TODO: Support CCITT Modified Huffman compression (2)
// TODO: Full "Baseline TIFF" support (pending CCITT compression 2)
// TODO: CCITT compressions T.4 and T.6
// TODO: Support JPEG compression of CMYK data (pending JPEGImageWriter CMYK write support)
// ----
// TODO: Support storing multiple images in one stream (multi-page TIFF)
// TODO: Support use-case: Transcode multi-layer PSD to multi-page TIFF with metadata
@ -91,6 +97,7 @@ public final class TIFFImageWriter extends ImageWriterBase {
// Support LZW compression (5)
// Support JPEG compression (7) - might need extra input to allow multiple images with single DQT
// Use sensible defaults for compression based on input? None is sensible... :-)
// Support resolution, resolution unit and software tags from ImageIO metadata
public static final Rational STANDARD_DPI = new Rational(72);
@ -98,14 +105,81 @@ public final class TIFFImageWriter extends ImageWriterBase {
super(provider);
}
@Override
public void setOutput(final Object output) {
super.setOutput(output);
// TODO: Allow appending/partly overwrite of existing file...
}
static final class TIFFEntry extends AbstractEntry {
TIFFEntry(Object identifier, Object value) {
// TODO: Expose a merge of this and the EXIFEntry class...
private final short type;
private static short guessType(final Object val) {
// TODO: This code is duplicated in EXIFWriter.getType, needs refactor!
Object value = Validate.notNull(val);
boolean array = value.getClass().isArray();
if (array) {
value = Array.get(value, 0);
}
// Note: This "narrowing" is to keep data consistent between read/write.
// TODO: Check for negative values and use signed types?
if (value instanceof Byte) {
return TIFF.TYPE_BYTE;
}
if (value instanceof Short) {
if (!array && (Short) value < Byte.MAX_VALUE) {
return TIFF.TYPE_BYTE;
}
return TIFF.TYPE_SHORT;
}
if (value instanceof Integer) {
if (!array && (Integer) value < Short.MAX_VALUE) {
return TIFF.TYPE_SHORT;
}
return TIFF.TYPE_LONG;
}
if (value instanceof Long) {
if (!array && (Long) value < Integer.MAX_VALUE) {
return TIFF.TYPE_LONG;
}
}
if (value instanceof Rational) {
return TIFF.TYPE_RATIONAL;
}
if (value instanceof String) {
return TIFF.TYPE_ASCII;
}
// TODO: More types
throw new UnsupportedOperationException(String.format("Method guessType not implemented for value of type %s", value.getClass()));
}
TIFFEntry(final int identifier, final Object value) {
this(identifier, guessType(value), value);
}
TIFFEntry(int identifier, short type, Object value) {
super(identifier, value);
this.type = type;
}
@Override
public String getTypeName() {
return TIFF.TYPE_NAMES[type];
}
}
@Override
public void write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param) throws IOException {
public void write(final IIOMetadata streamMetadata, final IIOImage image, final ImageWriteParam param) throws IOException {
// TODO: Validate input
assertOutput();
@ -120,6 +194,14 @@ public final class TIFFImageWriter extends ImageWriterBase {
ColorModel colorModel = renderedImage.getColorModel();
int numComponents = colorModel.getNumComponents();
TIFFImageMetadata metadata;
if (image.getMetadata() != null) {
metadata = convertImageMetadata(image.getMetadata(), ImageTypeSpecifier.createFromRenderedImage(renderedImage), param);
}
else {
metadata = initMeta(null, ImageTypeSpecifier.createFromRenderedImage(renderedImage), param);
}
SampleModel sampleModel = renderedImage.getSampleModel();
int[] bandOffsets;
@ -140,7 +222,7 @@ public final class TIFFImageWriter extends ImageWriterBase {
throw new IllegalArgumentException("Unknown bit/bandOffsets for sample model: " + sampleModel);
}
List<Entry> entries = new ArrayList<>();
Set<Entry> entries = new LinkedHashSet<>();
entries.add(new TIFFEntry(TIFF.TAG_IMAGE_WIDTH, renderedImage.getWidth()));
entries.add(new TIFFEntry(TIFF.TAG_IMAGE_HEIGHT, renderedImage.getHeight()));
// entries.add(new TIFFEntry(TIFF.TAG_ORIENTATION, 1)); // (optional)
@ -157,10 +239,12 @@ public final class TIFFImageWriter extends ImageWriterBase {
}
// Write compression field from param or metadata
// TODO: Support COPY_FROM_METADATA
int compression = TIFFImageWriteParam.getCompressionType(param);
entries.add(new TIFFEntry(TIFF.TAG_COMPRESSION, compression));
// TODO: Let param/metadata control predictor
// TODO: Depending on param.getCompressionMode(): DISABLED/EXPLICIT/COPY_FROM_METADATA/DEFAULT
switch (compression) {
case TIFFExtension.COMPRESSION_ZLIB:
case TIFFExtension.COMPRESSION_DEFLATE:
@ -169,7 +253,7 @@ public final class TIFFImageWriter extends ImageWriterBase {
default:
}
// TODO: We might want to support CMYK in JPEG as well...
// TODO: We might want to support CMYK in JPEG as well... Pending JPEG CMYK write support.
int photometric = compression == TIFFExtension.COMPRESSION_JPEG ?
TIFFExtension.PHOTOMETRIC_YCBCR :
getPhotometricInterpretation(colorModel);
@ -189,15 +273,24 @@ public final class TIFFImageWriter extends ImageWriterBase {
}
}
// Default sample format SAMPLEFORMAT_UINT need not be written
if (sampleModel.getDataType() == DataBuffer.TYPE_SHORT /* TODO: if (isSigned(sampleModel.getDataType) or getSampleFormat(sampleModel) != 0 */) {
entries.add(new TIFFEntry(TIFF.TAG_SAMPLE_FORMAT, TIFFExtension.SAMPLEFORMAT_INT));
}
// TODO: Float values!
entries.add(new TIFFEntry(TIFF.TAG_SOFTWARE, "TwelveMonkeys ImageIO TIFF writer")); // TODO: Get from metadata (optional) + fill in version number
// Get Software from metadata, or use default
Entry software = metadata.getIFD().getEntryById(TIFF.TAG_SOFTWARE);
entries.add(software != null ? software : new TIFFEntry(TIFF.TAG_SOFTWARE, "TwelveMonkeys ImageIO TIFF writer " + originatingProvider.getVersion()));
entries.add(new TIFFEntry(TIFF.TAG_X_RESOLUTION, STANDARD_DPI));
entries.add(new TIFFEntry(TIFF.TAG_Y_RESOLUTION, STANDARD_DPI));
entries.add(new TIFFEntry(TIFF.TAG_RESOLUTION_UNIT, TIFFBaseline.RESOLUTION_UNIT_DPI));
// Get X/YResolution and ResolutionUnit from metadata if set, otherwise use defaults
// TODO: Add logic here OR in metadata merging, to make sure these 3 values are consistent.
Entry xRes = metadata.getIFD().getEntryById(TIFF.TAG_X_RESOLUTION);
entries.add(xRes != null ? xRes : new TIFFEntry(TIFF.TAG_X_RESOLUTION, STANDARD_DPI));
Entry yRes = metadata.getIFD().getEntryById(TIFF.TAG_Y_RESOLUTION);
entries.add(yRes != null ? yRes : new TIFFEntry(TIFF.TAG_Y_RESOLUTION, STANDARD_DPI));
Entry resUnit = metadata.getIFD().getEntryById(TIFF.TAG_RESOLUTION_UNIT);
entries.add(resUnit != null ? resUnit : new TIFFEntry(TIFF.TAG_RESOLUTION_UNIT, TIFFBaseline.RESOLUTION_UNIT_DPI));
// TODO: RowsPerStrip - can be entire image (or even 2^32 -1), but it's recommended to write "about 8K bytes" per strip
entries.add(new TIFFEntry(TIFF.TAG_ROWS_PER_STRIP, Integer.MAX_VALUE)); // TODO: Allowed but not recommended
@ -208,7 +301,8 @@ public final class TIFFImageWriter extends ImageWriterBase {
TIFFEntry dummyStripOffsets = new TIFFEntry(TIFF.TAG_STRIP_OFFSETS, -1);
entries.add(dummyStripOffsets); // Updated later
// TODO: If tiled, write tile indexes etc, or always do that?
// TODO: If tiled, write tile indexes etc
// Depending on param.getTilingMode
EXIFWriter exifWriter = new EXIFWriter();
@ -233,6 +327,7 @@ public final class TIFFImageWriter extends ImageWriterBase {
// TODO: Create compressor stream per Tile/Strip
if (compression == TIFFExtension.COMPRESSION_JPEG) {
Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("JPEG");
if (!writers.hasNext()) {
// This can only happen if someone deliberately uninstalled it
throw new IIOException("No JPEG ImageWriter found!");
@ -607,13 +702,75 @@ public final class TIFFImageWriter extends ImageWriterBase {
// Metadata
@Override
public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageType, ImageWriteParam param) {
return null;
public TIFFImageMetadata getDefaultImageMetadata(final ImageTypeSpecifier imageType, final ImageWriteParam param) {
return initMeta(null, imageType, param);
}
@Override
public IIOMetadata convertImageMetadata(IIOMetadata inData, ImageTypeSpecifier imageType, ImageWriteParam param) {
return null;
public TIFFImageMetadata convertImageMetadata(final IIOMetadata inData,
final ImageTypeSpecifier imageType,
final ImageWriteParam param) {
Validate.notNull(inData, "inData");
Validate.notNull(imageType, "imageType");
Directory ifd;
if (inData instanceof TIFFImageMetadata) {
ifd = ((TIFFImageMetadata) inData).getIFD();
}
else {
TIFFImageMetadata outData = new TIFFImageMetadata(Collections.<Entry>emptySet());
try {
if (Arrays.asList(inData.getMetadataFormatNames()).contains(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME)) {
outData.setFromTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME, inData.getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME));
}
else if (inData.isStandardMetadataFormatSupported()) {
outData.setFromTree(IIOMetadataFormatImpl.standardMetadataFormatName, inData.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName));
}
else {
// Unknown format, we can't convert it
return null;
}
}
catch (IIOInvalidTreeException e) {
// TODO: How to issue warning when warning requires imageIndex??? Use -1?
}
ifd = outData.getIFD();
}
// Overwrite in values with values from imageType and param as needed
return initMeta(ifd, imageType, param);
}
private TIFFImageMetadata initMeta(final Directory ifd, final ImageTypeSpecifier imageType, final ImageWriteParam param) {
Validate.notNull(imageType, "imageType");
Map<Integer, Entry> entries = new LinkedHashMap<>(ifd != null ? ifd.size() + 10 : 20);
if (ifd != null) {
for (Entry entry : ifd) {
entries.put((Integer) entry.getIdentifier(), entry);
}
}
// TODO: Set values from imageType
entries.put(TIFF.TAG_PHOTOMETRIC_INTERPRETATION, new TIFFEntry(TIFF.TAG_PHOTOMETRIC_INTERPRETATION, TIFF.TYPE_SHORT, getPhotometricInterpretation(imageType.getColorModel())));
// TODO: Set values from param if != null + combined values...
return new TIFFImageMetadata(entries.values());
}
@Override
public IIOMetadata getDefaultStreamMetadata(final ImageWriteParam param) {
return super.getDefaultStreamMetadata(param);
}
@Override
public IIOMetadata convertStreamMetadata(final IIOMetadata inData, final ImageWriteParam param) {
return super.convertStreamMetadata(inData, param);
}
// Param
@ -762,5 +919,4 @@ public final class TIFFImageWriter extends ImageWriterBase {
TIFFImageReader.showIt(read, output.getName());
}
}

599
imageio/imageio-tiff/src/test/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageMetadataTest.java Normal file
View File

@ -0,0 +1,599 @@
package com.twelvemonkeys.imageio.plugins.tiff;
import com.twelvemonkeys.imageio.metadata.Directory;
import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.EXIFReader;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.imageio.stream.URLImageInputStreamSpi;
import com.twelvemonkeys.lang.StringUtil;
import org.junit.Test;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.imageio.ImageIO;
import javax.imageio.metadata.IIOInvalidTreeException;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.metadata.IIOMetadataNode;
import javax.imageio.spi.IIORegistry;
import javax.imageio.stream.ImageInputStream;
import java.io.IOException;
import java.net.URL;
import java.util.Collections;
import static org.junit.Assert.*;
/**
* TIFFImageMetadataTest.
*
* @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
* @author last modified by $Author: harald.kuhr$
* @version $Id: TIFFImageMetadataTest.java,v 1.0 30/07/15 harald.kuhr Exp$
*/
public class TIFFImageMetadataTest {
static {
IIORegistry.getDefaultInstance().registerServiceProvider(new URLImageInputStreamSpi());
ImageIO.setUseCache(false);
}
// TODO: Candidate super method
private URL getClassLoaderResource(final String resource) {
return getClass().getResource(resource);
}
// TODO: Candidate abstract super method
private IIOMetadata createMetadata(final String resource) throws IOException {
try (ImageInputStream input = ImageIO.createImageInputStream(getClassLoaderResource(resource))) {
Directory ifd = new EXIFReader().read(input);
// System.err.println("ifd: " + ifd);
return new TIFFImageMetadata(ifd);
}
}
@Test
public void testMetadataStandardFormat() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/smallliz.tif");
Node root = metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName);
// Root: "javax_imageio_1.0"
assertNotNull(root);
assertEquals(IIOMetadataFormatImpl.standardMetadataFormatName, root.getNodeName());
assertEquals(6, root.getChildNodes().getLength());
// "Chroma"
Node chroma = root.getFirstChild();
assertEquals("Chroma", chroma.getNodeName());
assertEquals(3, chroma.getChildNodes().getLength());
Node colorSpaceType = chroma.getFirstChild();
assertEquals("ColorSpaceType", colorSpaceType.getNodeName());
assertEquals("YCbCr", ((Element) colorSpaceType).getAttribute("value"));
Node numChannels = colorSpaceType.getNextSibling();
assertEquals("NumChannels", numChannels.getNodeName());
assertEquals("3", ((Element) numChannels).getAttribute("value"));
Node blackIsZero = numChannels.getNextSibling();
assertEquals("BlackIsZero", blackIsZero.getNodeName());
assertEquals(0, blackIsZero.getAttributes().getLength());
// "Compression"
Node compression = chroma.getNextSibling();
assertEquals("Compression", compression.getNodeName());
assertEquals(2, compression.getChildNodes().getLength());
Node compressionTypeName = compression.getFirstChild();
assertEquals("CompressionTypeName", compressionTypeName.getNodeName());
assertEquals("Old JPEG", ((Element) compressionTypeName).getAttribute("value"));
Node lossless = compressionTypeName.getNextSibling();
assertEquals("Lossless", lossless.getNodeName());
assertEquals("FALSE", ((Element) lossless).getAttribute("value"));
// "Data"
Node data = compression.getNextSibling();
assertEquals("Data", data.getNodeName());
assertEquals(4, data.getChildNodes().getLength());
Node planarConfiguration = data.getFirstChild();
assertEquals("PlanarConfiguration", planarConfiguration.getNodeName());
assertEquals("PixelInterleaved", ((Element) planarConfiguration).getAttribute("value"));
Node sampleFormat = planarConfiguration.getNextSibling();
assertEquals("SampleFormat", sampleFormat.getNodeName());
assertEquals("UnsignedIntegral", ((Element) sampleFormat).getAttribute("value"));
Node bitsPerSample = sampleFormat.getNextSibling();
assertEquals("BitsPerSample", bitsPerSample.getNodeName());
assertEquals("8 8 8", ((Element) bitsPerSample).getAttribute("value"));
Node sampleMSB = bitsPerSample.getNextSibling();
assertEquals("SampleMSB", sampleMSB.getNodeName());
assertEquals("0 0 0", ((Element) sampleMSB).getAttribute("value"));
// "Dimension"
Node dimension = data.getNextSibling();
assertEquals("Dimension", dimension.getNodeName());
assertEquals(3, dimension.getChildNodes().getLength());
Node pixelAspectRatio = dimension.getFirstChild();
assertEquals("PixelAspectRatio", pixelAspectRatio.getNodeName());
assertEquals("1.0", ((Element) pixelAspectRatio).getAttribute("value"));
Node horizontalPixelSize = pixelAspectRatio.getNextSibling();
assertEquals("HorizontalPixelSize", horizontalPixelSize.getNodeName());
assertEquals("0.254", ((Element) horizontalPixelSize).getAttribute("value"));
Node verticalPixelSize = horizontalPixelSize.getNextSibling();
assertEquals("VerticalPixelSize", verticalPixelSize.getNodeName());
assertEquals("0.254", ((Element) verticalPixelSize).getAttribute("value"));
// "Document"
Node document = dimension.getNextSibling();
assertEquals("Document", document.getNodeName());
assertEquals(1, document.getChildNodes().getLength());
Node formatVersion = document.getFirstChild();
assertEquals("FormatVersion", formatVersion.getNodeName());
assertEquals("6.0", ((Element) formatVersion).getAttribute("value"));
// "Text"
Node text = document.getNextSibling();
assertEquals("Text", text.getNodeName());
assertEquals(1, text.getChildNodes().getLength());
// NOTE: Could be multiple "TextEntry" elements, with different "keyword" attributes
Node textEntry = text.getFirstChild();
assertEquals("TextEntry", textEntry.getNodeName());
assertEquals("Software", ((Element) textEntry).getAttribute("keyword"));
assertEquals("HP IL v1.1", ((Element) textEntry).getAttribute("value"));
}
@Test
public void testMetadataNativeFormat() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/quad-lzw.tif");
Node root = metadata.getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
// Root: "com_sun_media_imageio_plugins_tiff_image_1.0"
assertNotNull(root);
assertEquals(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME, root.getNodeName());
assertEquals(1, root.getChildNodes().getLength());
// IFD: "TIFFIFD"
Node ifd = root.getFirstChild();
assertEquals("TIFFIFD", ifd.getNodeName());
NodeList entries = ifd.getChildNodes();
assertEquals(13, entries.getLength());
String[] stripOffsets = {
"8", "150", "292", "434", "576", "718", "860", "1002", "1144", "1286",
"1793", "3823", "7580", "12225", "17737", "23978", "30534", "36863", "42975", "49180",
"55361", "61470", "67022", "71646", "74255", "75241", "75411", "75553", "75695", "75837",
"75979", "76316", "77899", "80466", "84068", "88471", "93623", "99105", "104483", "109663",
"114969", "120472", "126083", "131289", "135545", "138810", "140808", "141840", "141982", "142124",
"142266", "142408", "142615", "144074", "146327", "149721", "154066", "158927", "164022", "169217",
"174409", "179657", "185166", "190684", "196236", "201560", "206064", "209497", "211612", "212419",
"212561", "212703", "212845", "212987", "213129", "213271", "213413"
};
String[] stripByteCounts = {
"142", "142", "142", "142", "142", "142", "142", "142", "142", "507",
"2030", "3757", "4645", "5512", "6241", "6556", "6329", "6112", "6205", "6181",
"6109", "5552", "4624", "2609", "986", "170", "142", "142", "142", "142",
"337", "1583", "2567", "3602", "4403", "5152", "5482", "5378", "5180", "5306",
"5503", "5611", "5206", "4256", "3265", "1998", "1032", "142", "142", "142",
"142", "207", "1459", "2253", "3394", "4345", "4861", "5095", "5195", "5192",
"5248", "5509", "5518", "5552", "5324", "4504", "3433", "2115", "807", "142",
"142", "142", "142", "142", "142", "142", "128"
};
// The 13 entries
assertSingleNodeWithValue(entries, TIFF.TAG_IMAGE_WIDTH, TIFF.TYPE_SHORT, "512");
assertSingleNodeWithValue(entries, TIFF.TAG_IMAGE_HEIGHT, TIFF.TYPE_SHORT, "384");
assertSingleNodeWithValue(entries, TIFF.TAG_BITS_PER_SAMPLE, TIFF.TYPE_SHORT, "8", "8", "8");
assertSingleNodeWithValue(entries, TIFF.TAG_COMPRESSION, TIFF.TYPE_SHORT, "5");
assertSingleNodeWithValue(entries, TIFF.TAG_PHOTOMETRIC_INTERPRETATION, TIFF.TYPE_SHORT, "2");
assertSingleNodeWithValue(entries, TIFF.TAG_STRIP_OFFSETS, TIFF.TYPE_LONG, stripOffsets);
assertSingleNodeWithValue(entries, TIFF.TAG_SAMPLES_PER_PIXEL, TIFF.TYPE_SHORT, "3");
assertSingleNodeWithValue(entries, TIFF.TAG_ROWS_PER_STRIP, TIFF.TYPE_LONG, "5");
assertSingleNodeWithValue(entries, TIFF.TAG_STRIP_BYTE_COUNTS, TIFF.TYPE_LONG, stripByteCounts);
assertSingleNodeWithValue(entries, TIFF.TAG_PLANAR_CONFIGURATION, TIFF.TYPE_SHORT, "1");
assertSingleNodeWithValue(entries, TIFF.TAG_X_POSITION, TIFF.TYPE_RATIONAL, "0");
assertSingleNodeWithValue(entries, TIFF.TAG_Y_POSITION, TIFF.TYPE_RATIONAL, "0");
assertSingleNodeWithValue(entries, 32995, TIFF.TYPE_SHORT, "0"); // Matteing tag, obsoleted by ExtraSamples tag in TIFF 6.0
}
@Test
public void testTreeDetached() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
Node nativeTree = metadata.getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
assertNotNull(nativeTree);
Node nativeTree2 = metadata.getAsTree(TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
assertNotNull(nativeTree2);
assertNotSame(nativeTree, nativeTree2);
assertNodeEquals("Unmodified trees differs", nativeTree, nativeTree2); // Both not modified
// Modify one of the trees
Node ifdNode = nativeTree2.getFirstChild();
ifdNode.removeChild(ifdNode.getFirstChild());
IIOMetadataNode tiffField = new IIOMetadataNode("TIFFField");
ifdNode.appendChild(tiffField);
assertNodeNotEquals("Modified tree does not differ", nativeTree, nativeTree2);
}
@Test
public void testMergeTree() throws IOException {
TIFFImageMetadata metadata = (TIFFImageMetadata) createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
Node nativeTree = metadata.getAsTree(nativeFormat);
assertNotNull(nativeTree);
IIOMetadataNode newTree = new IIOMetadataNode("com_sun_media_imageio_plugins_tiff_image_1.0");
IIOMetadataNode ifdNode = new IIOMetadataNode("TIFFIFD");
newTree.appendChild(ifdNode);
createTIFFFieldNode(ifdNode, TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, TIFFBaseline.RESOLUTION_UNIT_DPI);
createTIFFFieldNode(ifdNode, TIFF.TAG_X_RESOLUTION, TIFF.TYPE_RATIONAL, new Rational(300));
createTIFFFieldNode(ifdNode, TIFF.TAG_Y_RESOLUTION, TIFF.TYPE_RATIONAL, new Rational(30001, 100));
metadata.mergeTree(nativeFormat, newTree);
Directory ifd = metadata.getIFD();
assertNotNull(ifd.getEntryById(TIFF.TAG_X_RESOLUTION));
assertEquals(new Rational(300), ifd.getEntryById(TIFF.TAG_X_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_Y_RESOLUTION));
assertEquals(new Rational(30001, 100), ifd.getEntryById(TIFF.TAG_Y_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT));
assertEquals(TIFFBaseline.RESOLUTION_UNIT_DPI, ((Number) ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT).getValue()).intValue());
Node mergedTree = metadata.getAsTree(nativeFormat);
NodeList fields = mergedTree.getFirstChild().getChildNodes();
// Validate there's one and only one resolution unit, x res and y res
// Validate resolution unit == 1, x res & y res
assertSingleNodeWithValue(fields, TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, String.valueOf(TIFFBaseline.RESOLUTION_UNIT_DPI));
assertSingleNodeWithValue(fields, TIFF.TAG_X_RESOLUTION, TIFF.TYPE_RATIONAL, "300");
assertSingleNodeWithValue(fields, TIFF.TAG_Y_RESOLUTION, TIFF.TYPE_RATIONAL, "30001/100");
}
@Test
public void testMergeTreeStandardFormat() throws IOException {
TIFFImageMetadata metadata = (TIFFImageMetadata) createMetadata("/tiff/zackthecat.tif");
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
Node standardTree = metadata.getAsTree(standardFormat);
assertNotNull(standardTree);
IIOMetadataNode newTree = new IIOMetadataNode(standardFormat);
IIOMetadataNode dimensionNode = new IIOMetadataNode("Dimension");
newTree.appendChild(dimensionNode);
IIOMetadataNode horizontalPixelSize = new IIOMetadataNode("HorizontalPixelSize");
dimensionNode.appendChild(horizontalPixelSize);
horizontalPixelSize.setAttribute("value", String.valueOf(300 / 25.4));
IIOMetadataNode verticalPixelSize = new IIOMetadataNode("VerticalPixelSize");
dimensionNode.appendChild(verticalPixelSize);
verticalPixelSize.setAttribute("value", String.valueOf(300 / 25.4));
metadata.mergeTree(standardFormat, newTree);
Directory ifd = metadata.getIFD();
assertNotNull(ifd.getEntryById(TIFF.TAG_X_RESOLUTION));
assertEquals(new Rational(300), ifd.getEntryById(TIFF.TAG_X_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_Y_RESOLUTION));
assertEquals(new Rational(300), ifd.getEntryById(TIFF.TAG_Y_RESOLUTION).getValue());
// Should keep DPI as unit
assertNotNull(ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT));
assertEquals(TIFFBaseline.RESOLUTION_UNIT_DPI, ((Number) ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT).getValue()).intValue());
}
@Test
public void testMergeTreeStandardFormatAspectOnly() throws IOException {
TIFFImageMetadata metadata = (TIFFImageMetadata) createMetadata("/tiff/sm_colors_tile.tif");
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
Node standardTree = metadata.getAsTree(standardFormat);
assertNotNull(standardTree);
IIOMetadataNode newTree = new IIOMetadataNode(standardFormat);
IIOMetadataNode dimensionNode = new IIOMetadataNode("Dimension");
newTree.appendChild(dimensionNode);
IIOMetadataNode aspectRatio = new IIOMetadataNode("PixelAspectRatio");
dimensionNode.appendChild(aspectRatio);
aspectRatio.setAttribute("value", String.valueOf(3f / 2f));
metadata.mergeTree(standardFormat, newTree);
Directory ifd = metadata.getIFD();
assertNotNull(ifd.getEntryById(TIFF.TAG_X_RESOLUTION));
assertEquals(new Rational(3, 2), ifd.getEntryById(TIFF.TAG_X_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_Y_RESOLUTION));
assertEquals(new Rational(1), ifd.getEntryById(TIFF.TAG_Y_RESOLUTION).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT));
assertEquals(TIFFBaseline.RESOLUTION_UNIT_NONE, ((Number) ifd.getEntryById(TIFF.TAG_RESOLUTION_UNIT).getValue()).intValue());
}
@Test(expected = IllegalArgumentException.class)
public void testMergeTreeUnsupportedFormat() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = "com_foo_bar_tiff_42";
metadata.mergeTree(nativeFormat, new IIOMetadataNode(nativeFormat));
}
@Test(expected = IIOInvalidTreeException.class)
public void testMergeTreeFormatMisMatch() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
metadata.mergeTree(nativeFormat, new IIOMetadataNode("com_foo_bar_tiff_42"));
}
@Test(expected = IIOInvalidTreeException.class)
public void testMergeTreeInvalid() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
metadata.mergeTree(nativeFormat, new IIOMetadataNode(nativeFormat)); // Requires at least one child node
}
// TODO: Test that failed merge leaves metadata unchanged
@Test
public void testSetFromTreeEmpty() throws IOException {
// Read from file, set empty to see that all is cleared
TIFFImageMetadata metadata = (TIFFImageMetadata) createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
IIOMetadataNode root = new IIOMetadataNode(nativeFormat);
root.appendChild(new IIOMetadataNode("TIFFIFD"));
metadata.setFromTree(nativeFormat, root);
Directory ifd = metadata.getIFD();
assertNotNull(ifd);
assertEquals(0, ifd.size());
Node tree = metadata.getAsTree(nativeFormat);
assertNotNull(tree);
assertNotNull(tree.getFirstChild());
assertEquals(1, tree.getChildNodes().getLength());
}
@Test
public void testSetFromTree() throws IOException {
String softwareString = "12M UberTIFF 1.0";
TIFFImageMetadata metadata = new TIFFImageMetadata(Collections.<Entry>emptySet());
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
IIOMetadataNode root = new IIOMetadataNode(nativeFormat);
IIOMetadataNode ifdNode = new IIOMetadataNode("TIFFIFD");
root.appendChild(ifdNode);
createTIFFFieldNode(ifdNode, TIFF.TAG_SOFTWARE, TIFF.TYPE_ASCII, softwareString);
metadata.setFromTree(nativeFormat, root);
Directory ifd = metadata.getIFD();
assertNotNull(ifd);
assertEquals(1, ifd.size());
assertNotNull(ifd.getEntryById(TIFF.TAG_SOFTWARE));
assertEquals(softwareString, ifd.getEntryById(TIFF.TAG_SOFTWARE).getValue());
Node tree = metadata.getAsTree(nativeFormat);
assertNotNull(tree);
assertNotNull(tree.getFirstChild());
assertEquals(1, tree.getChildNodes().getLength());
}
@Test
public void testSetFromTreeStandardFormat() throws IOException {
String softwareString = "12M UberTIFF 1.0";
String copyrightString = "Copyright (C) TwelveMonkeys, 2015";
TIFFImageMetadata metadata = new TIFFImageMetadata(Collections.<Entry>emptySet());
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
IIOMetadataNode root = new IIOMetadataNode(standardFormat);
IIOMetadataNode textNode = new IIOMetadataNode("Text");
root.appendChild(textNode);
IIOMetadataNode textEntry = new IIOMetadataNode("TextEntry");
textNode.appendChild(textEntry);
textEntry.setAttribute("keyword", "SOFTWARE"); // Spelling should not matter
textEntry.setAttribute("value", softwareString);
textEntry = new IIOMetadataNode("TextEntry");
textNode.appendChild(textEntry);
textEntry.setAttribute("keyword", "copyright"); // Spelling should not matter
textEntry.setAttribute("value", copyrightString);
metadata.setFromTree(standardFormat, root);
Directory ifd = metadata.getIFD();
assertNotNull(ifd);
assertEquals(2, ifd.size());
assertNotNull(ifd.getEntryById(TIFF.TAG_SOFTWARE));
assertEquals(softwareString, ifd.getEntryById(TIFF.TAG_SOFTWARE).getValue());
assertNotNull(ifd.getEntryById(TIFF.TAG_COPYRIGHT));
assertEquals(copyrightString, ifd.getEntryById(TIFF.TAG_COPYRIGHT).getValue());
}
@Test(expected = IllegalArgumentException.class)
public void testSetFromTreeUnsupportedFormat() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = "com_foo_bar_tiff_42";
metadata.setFromTree(nativeFormat, new IIOMetadataNode(nativeFormat));
}
@Test(expected = IIOInvalidTreeException.class)
public void testSetFromTreeFormatMisMatch() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
metadata.setFromTree(nativeFormat, new IIOMetadataNode("com_foo_bar_tiff_42"));
}
@Test(expected = IIOInvalidTreeException.class)
public void testSetFromTreeInvalid() throws IOException {
IIOMetadata metadata = createMetadata("/tiff/sm_colors_tile.tif");
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
metadata.setFromTree(nativeFormat, new IIOMetadataNode(nativeFormat)); // Requires at least one child node
}
private void assertSingleNodeWithValue(final NodeList fields, final int tag, int type, final String... expectedValue) {
String tagNumber = String.valueOf(tag);
String typeName = StringUtil.capitalize(TIFF.TYPE_NAMES[type].toLowerCase());
boolean foundTag = false;
for (int i = 0; i < fields.getLength(); i++) {
Element field = (Element) fields.item(i);
if (tagNumber.equals(field.getAttribute("number"))) {
assertFalse("Duplicate tag " + tagNumber + " found", foundTag);
assertEquals(1, field.getChildNodes().getLength());
Node containerNode = field.getFirstChild();
assertEquals("TIFF" + typeName + "s", containerNode.getNodeName());
NodeList valueNodes = containerNode.getChildNodes();
assertEquals("Unexpected number of values for tag " + tagNumber, expectedValue.length, valueNodes.getLength());
for (int j = 0; j < expectedValue.length; j++) {
Element valueNode = (Element) valueNodes.item(j);
assertEquals("TIFF" + typeName, valueNode.getNodeName());
assertEquals("Unexpected tag " + tagNumber + " value", expectedValue[j], valueNode.getAttribute("value"));
}
foundTag = true;
}
}
assertTrue("No tag " + tagNumber + " found", foundTag);
}
// TODO: Test that failed set leaves metadata unchanged
static void createTIFFFieldNode(final IIOMetadataNode parentIFDNode, int tag, short type, Object value) {
IIOMetadataNode fieldNode = new IIOMetadataNode("TIFFField");
parentIFDNode.appendChild(fieldNode);
fieldNode.setAttribute("number", String.valueOf(tag));
switch (type) {
case TIFF.TYPE_ASCII:
createTIFFFieldContainerNode(fieldNode, "Ascii", value);
break;
case TIFF.TYPE_BYTE:
createTIFFFieldContainerNode(fieldNode, "Byte", value);
break;
case TIFF.TYPE_SHORT:
createTIFFFieldContainerNode(fieldNode, "Short", value);
break;
case TIFF.TYPE_RATIONAL:
createTIFFFieldContainerNode(fieldNode, "Rational", value);
break;
default:
throw new IllegalArgumentException("Unsupported type: " + type);
}
}
static void createTIFFFieldContainerNode(final IIOMetadataNode fieldNode, final String type, final Object value) {
IIOMetadataNode containerNode = new IIOMetadataNode("TIFF" + type + "s");
fieldNode.appendChild(containerNode);
IIOMetadataNode valueNode = new IIOMetadataNode("TIFF" + type);
valueNode.setAttribute("value", String.valueOf(value));
containerNode.appendChild(valueNode);
}
private void assertNodeNotEquals(final String message, final Node expected, final Node actual) {
// Lame, lazy implementation...
try {
assertNodeEquals(message, expected, actual);
}
catch (AssertionError ignore) {
return;
}
fail(message);
}
private void assertNodeEquals(final String message, final Node expected, final Node actual) {
assertEquals(message + " class differs", expected.getClass(), actual.getClass());
assertEquals(message, expected.getNodeValue(), actual.getNodeValue());
if (expected instanceof IIOMetadataNode) {
IIOMetadataNode expectedIIO = (IIOMetadataNode) expected;
IIOMetadataNode actualIIO = (IIOMetadataNode) actual;
assertEquals(message, expectedIIO.getUserObject(), actualIIO.getUserObject());
}
NodeList expectedChildNodes = expected.getChildNodes();
NodeList actualChildNodes = actual.getChildNodes();
assertEquals(message + " child length differs: " + toString(expectedChildNodes) + " != " + toString(actualChildNodes),
expectedChildNodes.getLength(), actualChildNodes.getLength());
for (int i = 0; i < expectedChildNodes.getLength(); i++) {
Node expectedChild = expectedChildNodes.item(i);
Node actualChild = actualChildNodes.item(i);
assertEquals(message + " node name differs", expectedChild.getLocalName(), actualChild.getLocalName());
assertNodeEquals(message + "/" + expectedChild.getLocalName(), expectedChild, actualChild);
}
}
private String toString(final NodeList list) {
if (list.getLength() == 0) {
return "[]";
}
StringBuilder builder = new StringBuilder("[");
for (int i = 0; i < list.getLength(); i++) {
if (i > 0) {
builder.append(", ");
}
Node node = list.item(i);
builder.append(node.getLocalName());
}
builder.append("]");
return builder.toString();
}
}

231
imageio/imageio-tiff/src/test/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageWriterTest.java
View File

@ -28,15 +28,33 @@
package com.twelvemonkeys.imageio.plugins.tiff;
import com.twelvemonkeys.imageio.metadata.Directory;
import com.twelvemonkeys.imageio.metadata.Entry;
import com.twelvemonkeys.imageio.metadata.exif.EXIFReader;
import com.twelvemonkeys.imageio.metadata.exif.Rational;
import com.twelvemonkeys.imageio.metadata.exif.TIFF;
import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream;
import com.twelvemonkeys.imageio.util.ImageWriterAbstractTestCase;
import org.junit.Test;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriter;
import java.awt.*;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.metadata.IIOMetadataNode;
import javax.imageio.stream.ImageOutputStream;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import static com.twelvemonkeys.imageio.plugins.tiff.TIFFImageMetadataTest.createTIFFFieldNode;
import static org.junit.Assert.*;
/**
* TIFFImageWriterTest
*
@ -55,19 +73,208 @@ public class TIFFImageWriterTest extends ImageWriterAbstractTestCase {
@Override
protected List<? extends RenderedImage> getTestData() {
BufferedImage image = new BufferedImage(300, 200, BufferedImage.TYPE_INT_ARGB);
Graphics2D graphics = image.createGraphics();
try {
graphics.setColor(Color.RED);
graphics.fillRect(0, 0, 100, 200);
graphics.setColor(Color.BLUE);
graphics.fillRect(100, 0, 100, 200);
graphics.clearRect(200, 0, 100, 200);
return Arrays.asList(
new BufferedImage(300, 200, BufferedImage.TYPE_INT_RGB),
new BufferedImage(300, 200, BufferedImage.TYPE_INT_ARGB),
new BufferedImage(300, 200, BufferedImage.TYPE_3BYTE_BGR),
new BufferedImage(300, 200, BufferedImage.TYPE_4BYTE_ABGR),
new BufferedImage(300, 200, BufferedImage.TYPE_BYTE_GRAY),
new BufferedImage(300, 200, BufferedImage.TYPE_USHORT_GRAY),
// new BufferedImage(300, 200, BufferedImage.TYPE_BYTE_BINARY), // TODO!
new BufferedImage(300, 200, BufferedImage.TYPE_BYTE_INDEXED)
);
}
// TODO: Test write bilevel stays bilevel
// TODO: Test write indexed stays indexed
@Test
public void testWriteWithCustomResolutionNative() throws IOException {
// Issue 139 Writing TIFF files with custom resolution value
Rational resolutionValue = new Rational(1200);
int resolutionUnitValue = TIFFBaseline.RESOLUTION_UNIT_CENTIMETER;
RenderedImage image = getTestData(0);
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try (ImageOutputStream stream = ImageIO.createImageOutputStream(buffer)) {
writer.setOutput(stream);
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
IIOMetadata metadata = writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(image), null);
IIOMetadataNode customMeta = new IIOMetadataNode(nativeFormat);
IIOMetadataNode ifd = new IIOMetadataNode("TIFFIFD");
customMeta.appendChild(ifd);
createTIFFFieldNode(ifd, TIFF.TAG_RESOLUTION_UNIT, TIFF.TYPE_SHORT, resolutionUnitValue);
createTIFFFieldNode(ifd, TIFF.TAG_X_RESOLUTION, TIFF.TYPE_RATIONAL, resolutionValue);
createTIFFFieldNode(ifd, TIFF.TAG_Y_RESOLUTION, TIFF.TYPE_RATIONAL, resolutionValue);
metadata.mergeTree(nativeFormat, customMeta);
writer.write(null, new IIOImage(image, null, metadata), null);
}
finally {
graphics.dispose();
catch (IOException e) {
e.printStackTrace();
fail(e.getMessage());
}
return Arrays.asList(image);
assertTrue("No image data written", buffer.size() > 0);
Directory ifds = new EXIFReader().read(new ByteArrayImageInputStream(buffer.toByteArray()));
Entry resolutionUnit = ifds.getEntryById(TIFF.TAG_RESOLUTION_UNIT);
assertNotNull(resolutionUnit);
assertEquals(resolutionUnitValue, ((Number) resolutionUnit.getValue()).intValue());
Entry xResolution = ifds.getEntryById(TIFF.TAG_X_RESOLUTION);
assertNotNull(xResolution);
assertEquals(resolutionValue, xResolution.getValue());
Entry yResolution = ifds.getEntryById(TIFF.TAG_Y_RESOLUTION);
assertNotNull(yResolution);
assertEquals(resolutionValue, yResolution.getValue());
}
@Test
public void testWriteWithCustomSoftwareNative() throws IOException {
String softwareString = "12M TIFF Test 1.0 (build $foo$)";
RenderedImage image = getTestData(0);
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try (ImageOutputStream stream = ImageIO.createImageOutputStream(buffer)) {
writer.setOutput(stream);
String nativeFormat = TIFFMedataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
IIOMetadata metadata = writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(image), null);
IIOMetadataNode customMeta = new IIOMetadataNode(nativeFormat);
IIOMetadataNode ifd = new IIOMetadataNode("TIFFIFD");
customMeta.appendChild(ifd);
createTIFFFieldNode(ifd, TIFF.TAG_SOFTWARE, TIFF.TYPE_ASCII, softwareString);
metadata.mergeTree(nativeFormat, customMeta);
writer.write(null, new IIOImage(image, null, metadata), null);
}
catch (IOException e) {
e.printStackTrace();
fail(e.getMessage());
}
assertTrue("No image data written", buffer.size() > 0);
Directory ifds = new EXIFReader().read(new ByteArrayImageInputStream(buffer.toByteArray()));
Entry software = ifds.getEntryById(TIFF.TAG_SOFTWARE);
assertNotNull(software);
assertEquals(softwareString, software.getValueAsString());
}
@Test
public void testWriteWithCustomResolutionStandard() throws IOException {
// Issue 139 Writing TIFF files with custom resolution value
double resolutionValue = 300 / 25.4; // 300 dpi, 1 inch = 2.54 cm or 25.4 mm
int resolutionUnitValue = TIFFBaseline.RESOLUTION_UNIT_CENTIMETER;
Rational expectedResolutionValue = new Rational(Math.round(resolutionValue * 10 * TIFFImageMetadata.RATIONAL_SCALE_FACTOR), TIFFImageMetadata.RATIONAL_SCALE_FACTOR);
RenderedImage image = getTestData(0);
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try (ImageOutputStream stream = ImageIO.createImageOutputStream(buffer)) {
writer.setOutput(stream);
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
IIOMetadata metadata = writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(image), null);
IIOMetadataNode customMeta = new IIOMetadataNode(standardFormat);
IIOMetadataNode dimension = new IIOMetadataNode("Dimension");
customMeta.appendChild(dimension);
IIOMetadataNode xSize = new IIOMetadataNode("HorizontalPixelSize");
dimension.appendChild(xSize);
xSize.setAttribute("value", String.valueOf(resolutionValue));
IIOMetadataNode ySize = new IIOMetadataNode("VerticalPixelSize");
dimension.appendChild(ySize);
ySize.setAttribute("value", String.valueOf(resolutionValue));
metadata.mergeTree(standardFormat, customMeta);
writer.write(null, new IIOImage(image, null, metadata), null);
}
catch (IOException e) {
e.printStackTrace();
fail(e.getMessage());
}
assertTrue("No image data written", buffer.size() > 0);
Directory ifds = new EXIFReader().read(new ByteArrayImageInputStream(buffer.toByteArray()));
Entry resolutionUnit = ifds.getEntryById(TIFF.TAG_RESOLUTION_UNIT);
assertNotNull(resolutionUnit);
assertEquals(resolutionUnitValue, ((Number) resolutionUnit.getValue()).intValue());
Entry xResolution = ifds.getEntryById(TIFF.TAG_X_RESOLUTION);
assertNotNull(xResolution);
assertEquals(expectedResolutionValue, xResolution.getValue());
Entry yResolution = ifds.getEntryById(TIFF.TAG_Y_RESOLUTION);
assertNotNull(yResolution);
assertEquals(expectedResolutionValue, yResolution.getValue());
}
@Test
public void testWriteWithCustomSoftwareStandard() throws IOException {
String softwareString = "12M TIFF Test 1.0 (build $foo$)";
RenderedImage image = getTestData(0);
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try (ImageOutputStream stream = ImageIO.createImageOutputStream(buffer)) {
writer.setOutput(stream);
String standardFormat = IIOMetadataFormatImpl.standardMetadataFormatName;
IIOMetadata metadata = writer.getDefaultImageMetadata(ImageTypeSpecifier.createFromRenderedImage(image), null);
IIOMetadataNode customMeta = new IIOMetadataNode(standardFormat);
IIOMetadataNode dimension = new IIOMetadataNode("Text");
customMeta.appendChild(dimension);
IIOMetadataNode textEntry = new IIOMetadataNode("TextEntry");
dimension.appendChild(textEntry);
textEntry.setAttribute("keyword", "Software");
textEntry.setAttribute("value", softwareString);
metadata.mergeTree(standardFormat, customMeta);
writer.write(null, new IIOImage(image, null, metadata), null);
}
catch (IOException e) {
e.printStackTrace();
fail(e.getMessage());
}
assertTrue("No image data written", buffer.size() > 0);
Directory ifds = new EXIFReader().read(new ByteArrayImageInputStream(buffer.toByteArray()));
Entry software = ifds.getEntryById(TIFF.TAG_SOFTWARE);
assertNotNull(software);
assertEquals(softwareString, software.getValueAsString());
}
}