diff --git a/imageio/imageio-bmp/src/main/java/com/twelvemonkeys/imageio/plugins/bmp/BMPImageReader.java b/imageio/imageio-bmp/src/main/java/com/twelvemonkeys/imageio/plugins/bmp/BMPImageReader.java index c50dccd9..331348b9 100755 --- a/imageio/imageio-bmp/src/main/java/com/twelvemonkeys/imageio/plugins/bmp/BMPImageReader.java +++ b/imageio/imageio-bmp/src/main/java/com/twelvemonkeys/imageio/plugins/bmp/BMPImageReader.java @@ -31,11 +31,10 @@ package com.twelvemonkeys.imageio.plugins.bmp; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.stream.SubImageInputStream; import com.twelvemonkeys.imageio.util.IIOUtil; -import com.twelvemonkeys.imageio.util.IndexedImageTypeSpecifier; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import com.twelvemonkeys.imageio.util.ProgressListenerBase; import com.twelvemonkeys.io.LittleEndianDataInputStream; import com.twelvemonkeys.io.enc.DecoderStream; -import com.twelvemonkeys.lang.Validate; import com.twelvemonkeys.xml.XMLSerializer; import javax.imageio.*; @@ -167,7 +166,7 @@ public final class BMPImageReader extends ImageReaderBase { // Compute bits for > 8 bits (used only for meta data) int bits = header.getBitCount() <= 8 ? header.getBitCount() : mapSize <= 256 ? 8 : 16; - colorMap = new IndexColorModel(bits, mapSize, colors, 0, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE); + colorMap = new IndexColorModel(bits, mapSize, colors, 0, false, -1, DataBuffer.TYPE_BYTE); } } @@ -209,13 +208,13 @@ public final class BMPImageReader extends ImageReaderBase { case 2: case 4: case 8: - return IndexedImageTypeSpecifier.createFromIndexColorModel(readColorMap()); + return ImageTypeSpecifiers.createFromIndexColorModel(readColorMap()); case 16: if (header.hasMasks()) { int[] masks = getMasks(); - return ImageTypeSpecifier.createPacked( + return ImageTypeSpecifiers.createPacked( ColorSpace.getInstance(ColorSpace.CS_sRGB), masks[0], masks[1], masks[2], masks[3], DataBuffer.TYPE_USHORT, false @@ -223,20 +222,20 @@ public final class BMPImageReader extends ImageReaderBase { } // Default if no mask is 555 - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_USHORT_555_RGB); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_USHORT_555_RGB); case 24: if (header.getCompression() != DIB.COMPRESSION_RGB) { throw new IIOException("Unsupported compression for RGB: " + header.getCompression()); } - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); case 32: if (header.hasMasks()) { int[] masks = getMasks(); - return ImageTypeSpecifier.createPacked( + return ImageTypeSpecifiers.createPacked( ColorSpace.getInstance(ColorSpace.CS_sRGB), masks[0], masks[1], masks[2], masks[3], DataBuffer.TYPE_INT, false @@ -244,7 +243,7 @@ public final class BMPImageReader extends ImageReaderBase { } // Default if no mask - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB); case 0: if (header.getCompression() == DIB.COMPRESSION_JPEG || header.getCompression() == DIB.COMPRESSION_PNG) { diff --git a/imageio/imageio-bmp/src/main/java/com/twelvemonkeys/imageio/plugins/bmp/DIBImageReader.java b/imageio/imageio-bmp/src/main/java/com/twelvemonkeys/imageio/plugins/bmp/DIBImageReader.java index b1c4e612..bd8087ff 100644 --- a/imageio/imageio-bmp/src/main/java/com/twelvemonkeys/imageio/plugins/bmp/DIBImageReader.java +++ b/imageio/imageio-bmp/src/main/java/com/twelvemonkeys/imageio/plugins/bmp/DIBImageReader.java @@ -31,7 +31,7 @@ package com.twelvemonkeys.imageio.plugins.bmp; import com.twelvemonkeys.image.ImageUtil; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.util.IIOUtil; -import com.twelvemonkeys.imageio.util.IndexedImageTypeSpecifier; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import com.twelvemonkeys.util.WeakWeakMap; import javax.imageio.*; @@ -118,16 +118,16 @@ abstract class DIBImageReader extends ImageReaderBase { } BitmapIndexed indexed = new BitmapIndexed(entry, header); readColorMap(indexed); - specifier = IndexedImageTypeSpecifier.createFromIndexColorModel(indexed.createColorModel()); + specifier = ImageTypeSpecifiers.createFromIndexColorModel(indexed.createColorModel()); break; case 16: - specifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_USHORT_555_RGB); + specifier = ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_USHORT_555_RGB); break; case 24: - specifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); + specifier = ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); break; case 32: - specifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB); + specifier = ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB); break; default: throw new IIOException(String.format("Unknown bit depth: %d", header.getBitCount())); diff --git a/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/color/UInt32ColorModel.java b/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/color/UInt32ColorModel.java new file mode 100644 index 00000000..25318f60 --- /dev/null +++ b/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/color/UInt32ColorModel.java @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2014, Harald Kuhr + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name "TwelveMonkeys" nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package com.twelvemonkeys.imageio.color; + +import java.awt.color.ColorSpace; +import java.awt.image.ComponentColorModel; +import java.awt.image.DataBuffer; + +/** + * ComponentColorModel subclass that correctly handles full 32 bit {@code TYPE_INT} unsigned integral samples. + * + * @see + * ComponentColorModel.getNormalizedComponents() does not handle 32-bit TYPE_INT + * + * @author Harald Kuhr + * @author last modified by $Author: haraldk$ + * @version $Id: UInt32ColorModel.java,v 1.0 24.01.11 17.51 haraldk Exp$ + */ +public final class UInt32ColorModel extends ComponentColorModel { + public UInt32ColorModel(final ColorSpace cs, final boolean hasAlpha, boolean isAlphaPremultiplied) { + super(cs, hasAlpha, isAlphaPremultiplied, hasAlpha ? TRANSLUCENT : OPAQUE, DataBuffer.TYPE_INT); + } + + @Override + public float[] getNormalizedComponents(final Object pixel, float[] normComponents, final int normOffset) { + // Implementation borrowed from super class, with modifications to allow 32 bit shifts and unsigned values. + int numComponents = getNumComponents(); + + if (normComponents == null) { + normComponents = new float[numComponents + normOffset]; + } + + // This class only supports DataBuffer.TYPE_INT, cast is safe + int[] ipixel = (int[]) pixel; + for (int c = 0, nc = normOffset; c < numComponents; c++, nc++) { + normComponents[nc] = ((float) (ipixel[c] & 0xffffffffl)) / ((float) ((1l << getComponentSize(c)) - 1)); + } + + int numColorComponents = getNumColorComponents(); + + if (hasAlpha() && isAlphaPremultiplied()) { + float alpha = normComponents[numColorComponents + normOffset]; + + if (alpha != 0.0f) { + float invAlpha = 1.0f / alpha; + + for (int c = normOffset; c < numColorComponents + normOffset; c++) { + normComponents[c] *= invAlpha; + } + } + } + + // TODO: We don't currently support color spaces that has min and max other than 0.0f and 1.0f respectively. + + return normComponents; + } +} diff --git a/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/ImageTypeSpecifiers.java b/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/ImageTypeSpecifiers.java new file mode 100644 index 00000000..165e4152 --- /dev/null +++ b/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/ImageTypeSpecifiers.java @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2014, Harald Kuhr + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name "TwelveMonkeys" nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package com.twelvemonkeys.imageio.util; + +import javax.imageio.ImageTypeSpecifier; +import java.awt.color.ColorSpace; +import java.awt.image.DataBuffer; +import java.awt.image.IndexColorModel; + +/** + * Factory class for creating {@code ImageTypeSpecifier}s. + * In most cases, this class will delegate to the corresponding methods in {@link ImageTypeSpecifier}. + * + * @see javax.imageio.ImageTypeSpecifier + * @author Harald Kuhr + * @author last modified by $Author: haraldk$ + * @version $Id: ImageTypeSpecifiers.java,v 1.0 24.01.11 17.51 haraldk Exp$ + */ +public final class ImageTypeSpecifiers { + + private ImageTypeSpecifiers() {} + + public static ImageTypeSpecifier createFromBufferedImageType(final int bufferedImageType) { + return ImageTypeSpecifier.createFromBufferedImageType(bufferedImageType); + } + + public static ImageTypeSpecifier createPacked(final ColorSpace colorSpace, + final int redMask, final int greenMask, + final int blueMask, final int alphaMask, + final int transferType, boolean isAlphaPremultiplied) { + return ImageTypeSpecifier.createPacked(colorSpace, redMask, greenMask, blueMask, alphaMask, transferType, isAlphaPremultiplied); + } + + public static ImageTypeSpecifier createInterleaved(final ColorSpace colorSpace, + final int[] bandOffsets, + final int dataType, + final boolean hasAlpha, + final boolean isAlphaPremultiplied) { + // As the ComponentColorModel is broken for 32 bit unsigned int, we'll use our own version + if (dataType == DataBuffer.TYPE_INT) { + return new UInt32ImageTypeSpecifier(colorSpace, bandOffsets, hasAlpha, isAlphaPremultiplied); + } + + // ...or fall back to default for anything else + return ImageTypeSpecifier.createInterleaved(colorSpace, bandOffsets, dataType, hasAlpha, isAlphaPremultiplied); + } + + public static ImageTypeSpecifier createBanded(final ColorSpace colorSpace, + final int[] bankIndices, final int[] bandOffsets, + final int dataType, + final boolean hasAlpha, final boolean isAlphaPremultiplied) { + return ImageTypeSpecifier.createBanded(colorSpace, bankIndices, bandOffsets, dataType, hasAlpha, isAlphaPremultiplied); + } + + public static ImageTypeSpecifier createGrayscale(final int bits, final int dataType) { + if (bits == 32 && dataType == DataBuffer.TYPE_INT) { + // As the ComponentColorModel is broken for 32 bit unsigned int, we'll use our own version + return new UInt32ImageTypeSpecifier(ColorSpace.getInstance(ColorSpace.CS_GRAY), new int[] {0}, false, false); + } + + // NOTE: The isSigned boolean is stored but *not used for anything* in the Grayscale ImageTypeSpecifier... + return ImageTypeSpecifier.createGrayscale(bits, dataType, false); + } + + public static ImageTypeSpecifier createGrayscale(final int bits, final int dataType, final boolean isAlphaPremultiplied) { + if (bits == 32 && dataType == DataBuffer.TYPE_INT) { + // As the ComponentColorModel is broken for 32 bit unsigned int, we'll use our own version + return new UInt32ImageTypeSpecifier(ColorSpace.getInstance(ColorSpace.CS_GRAY), new int[] {0, 1}, true, isAlphaPremultiplied); + } + + // NOTE: The isSigned boolean is stored but *not used for anything* in the Grayscale ImageTypeSpecifier... + return ImageTypeSpecifier.createGrayscale(bits, dataType, false, isAlphaPremultiplied); + } + + public static ImageTypeSpecifier createIndexed(final byte[] redLUT, final byte[] greenLUT, + final byte[] blueLUT, final byte[] alphaLUT, + final int bits, final int dataType) { + return ImageTypeSpecifier.createIndexed(redLUT, greenLUT, blueLUT, alphaLUT, bits, dataType); + } + + public static ImageTypeSpecifier createIndexed(final int[] colors, final boolean hasAlpha, final int transIndex, + final int bits, final int dataType) { + return createFromIndexColorModel(new IndexColorModel(bits, colors.length, colors, 0, hasAlpha, transIndex, dataType)); + } + + public static ImageTypeSpecifier createFromIndexColorModel(final IndexColorModel pColorModel) { + return new IndexedImageTypeSpecifier(pColorModel); + } +} diff --git a/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifier.java b/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifier.java index a9ba4b6a..d5195ee7 100755 --- a/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifier.java +++ b/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifier.java @@ -1,11 +1,13 @@ package com.twelvemonkeys.imageio.util; import javax.imageio.ImageTypeSpecifier; -import java.awt.image.IndexColorModel; import java.awt.image.BufferedImage; +import java.awt.image.IndexColorModel; import java.awt.image.WritableRaster; import java.util.Hashtable; +import static com.twelvemonkeys.lang.Validate.notNull; + /** * IndexedImageTypeSpecifier * @@ -13,18 +15,14 @@ import java.util.Hashtable; * @author last modified by $Author: haraldk$ * @version $Id: IndexedImageTypeSpecifier.java,v 1.0 May 19, 2008 11:04:28 AM haraldk Exp$ */ -public class IndexedImageTypeSpecifier extends ImageTypeSpecifier { - IndexedImageTypeSpecifier(IndexColorModel pColorModel) { +final class IndexedImageTypeSpecifier extends ImageTypeSpecifier { + IndexedImageTypeSpecifier(final IndexColorModel pColorModel) { // For some reason, we need a sample model - super(pColorModel, pColorModel.createCompatibleSampleModel(1, 1)); - } - - public static ImageTypeSpecifier createFromIndexColorModel(final IndexColorModel pColorModel) { - return new IndexedImageTypeSpecifier(pColorModel); + super(notNull(pColorModel, "colorModel"), pColorModel.createCompatibleSampleModel(1, 1)); } @Override - public final BufferedImage createBufferedImage(int pWidth, int pHeight) { + public final BufferedImage createBufferedImage(final int pWidth, final int pHeight) { try { // This is a fix for the super-method, that first creates a sample model, and then // creates a raster from it, using Raster.createWritableRaster. The problem with diff --git a/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/UInt32ImageTypeSpecifier.java b/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/UInt32ImageTypeSpecifier.java new file mode 100644 index 00000000..2747ca32 --- /dev/null +++ b/imageio/imageio-core/src/main/java/com/twelvemonkeys/imageio/util/UInt32ImageTypeSpecifier.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2014, Harald Kuhr + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name "TwelveMonkeys" nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package com.twelvemonkeys.imageio.util; + +import com.twelvemonkeys.imageio.color.UInt32ColorModel; + +import javax.imageio.ImageTypeSpecifier; +import java.awt.color.ColorSpace; +import java.awt.image.DataBuffer; +import java.awt.image.PixelInterleavedSampleModel; + +/** + * ImageTypeSpecifier for interleaved 32 bit unsigned integral samples. + * + * @see com.twelvemonkeys.imageio.color.UInt32ColorModel + * @author Harald Kuhr + * @author last modified by $Author: haraldk$ + * @version $Id: UInt32ImageTypeSpecifier.java,v 1.0 24.01.11 17.51 haraldk Exp$ + */ +final class UInt32ImageTypeSpecifier extends ImageTypeSpecifier { + UInt32ImageTypeSpecifier(final ColorSpace cs, int[] bandOffsets, final boolean hasAlpha, final boolean isAlphaPremultiplied) { + super( + new UInt32ColorModel(cs, hasAlpha, isAlphaPremultiplied), + new PixelInterleavedSampleModel( + DataBuffer.TYPE_INT, 1, 1, + cs.getNumComponents() + (hasAlpha ? 1 : 0), + cs.getNumComponents() + (hasAlpha ? 1 : 0), + bandOffsets + ) + ); + } +} diff --git a/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/color/UInt32ColorModelTest.java b/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/color/UInt32ColorModelTest.java new file mode 100644 index 00000000..81ea76d6 --- /dev/null +++ b/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/color/UInt32ColorModelTest.java @@ -0,0 +1,106 @@ +package com.twelvemonkeys.imageio.color; + +import org.junit.Test; + +import java.awt.color.ColorSpace; +import java.awt.image.ComponentColorModel; + +import static org.junit.Assert.assertEquals; + +public class UInt32ColorModelTest { + + private static final ColorSpace sRGB = ColorSpace.getInstance(ColorSpace.CS_sRGB); + private static final ColorSpace GRAY = ColorSpace.getInstance(ColorSpace.CS_GRAY); + + @Test + public void testGetNormalizedComponentsRGBBlack() { + ComponentColorModel model = new UInt32ColorModel(sRGB, true, false); + float[] normalized = model.getNormalizedComponents(new int[]{0, 0, 0, 0}, null, 0); + for (float norm : normalized) { + assertEquals(0, norm, 0); + } + } + + @Test + public void testGetNormalizedComponentsRGBGray() { + ComponentColorModel model = new UInt32ColorModel(sRGB, true, false); + float[] normalized = model.getNormalizedComponents(new int[]{Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE}, null, 0); + for (float norm : normalized) { + assertEquals(0.5f, norm, 0); + } + } + + @Test + public void testGetNormalizedComponentsRGBWhite() { + ComponentColorModel model = new UInt32ColorModel(sRGB, true, false); + float[] normalized = model.getNormalizedComponents(new int[]{-1, -1, -1, -1}, null, 0); + for (float norm : normalized) { + assertEquals(1, norm, 0); + } + } + + @Test + public void testGetNormalizedComponentsRGB() { + ComponentColorModel model = new UInt32ColorModel(sRGB, true, false); + int[] pixel = new int[4]; + + float[] normalized = null; + for (long pix = 0; pix < 1l << 32; pix += Short.MAX_VALUE) { + float expected = ((float) (pix & 0xffffffffl)) / ((float) ((1l << 32) - 1)); + + for (int i = 0; i < pixel.length; i++) { + pixel[i] = (int) pix; + } + + normalized = model.getNormalizedComponents(pixel, normalized, 0); + + for (float norm : normalized) { + assertEquals(expected, norm, 0); + } + } + } + + @Test + public void testGetNormalizedComponentsGrayBlack() { + ComponentColorModel model = new UInt32ColorModel(GRAY, false, false); + float[] normalized = model.getNormalizedComponents(new int[]{0}, null, 0); + for (float norm : normalized) { + assertEquals(0, norm, 0); + } + } + + @Test + public void testGetNormalizedComponentsGrayGray() { + ComponentColorModel model = new UInt32ColorModel(GRAY, false, false); + float[] normalized = model.getNormalizedComponents(new int[]{Integer.MIN_VALUE}, null, 0); + for (float norm : normalized) { + assertEquals(0.5f, norm, 0); + } + } + + @Test + public void testGetNormalizedComponentsGrayWhite() { + ComponentColorModel model = new UInt32ColorModel(GRAY, false, false); + float[] normalized = model.getNormalizedComponents(new int[]{-1}, null, 0); + for (float norm : normalized) { + assertEquals(1, norm, 0); + } + } + + @Test + public void testGetNormalizedComponentsGray() { + ComponentColorModel model = new UInt32ColorModel(GRAY, false, false); + int[] pixel = new int[1]; + + float[] normalized = null; + for (long pix = 0; pix < 1l << 32; pix += Short.MAX_VALUE) { + float expected = ((float) (pix & 0xffffffffl)) / ((float) ((1l << 32) - 1)); + + pixel[0] = (int) pix; + + normalized = model.getNormalizedComponents(pixel, normalized, 0); + + assertEquals(expected, normalized[0], 0); + } + } +} diff --git a/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/ImageTypeSpecifiersTest.java b/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/ImageTypeSpecifiersTest.java new file mode 100644 index 00000000..88451917 --- /dev/null +++ b/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/ImageTypeSpecifiersTest.java @@ -0,0 +1,583 @@ +package com.twelvemonkeys.imageio.util; + +import org.junit.Test; + +import javax.imageio.ImageTypeSpecifier; +import java.awt.color.ColorSpace; +import java.awt.image.BufferedImage; +import java.awt.image.DataBuffer; +import java.awt.image.IndexColorModel; + +import static org.junit.Assert.assertEquals; + +public class ImageTypeSpecifiersTest { + + private static final ColorSpace sRGB = ColorSpace.getInstance(ColorSpace.CS_sRGB); + private static final ColorSpace GRAY = ColorSpace.getInstance(ColorSpace.CS_GRAY); + + private static final int DCM_RED_MASK = 0x00ff0000; + private static final int DCM_GREEN_MASK = 0x0000ff00; + private static final int DCM_BLUE_MASK = 0x000000ff; + private static final int DCM_ALPHA_MASK = 0xff000000; + private static final int DCM_565_RED_MASK = 0xf800; + private static final int DCM_565_GRN_MASK = 0x07E0; + private static final int DCM_565_BLU_MASK = 0x001F; + private static final int DCM_555_RED_MASK = 0x7C00; + private static final int DCM_555_GRN_MASK = 0x03E0; + private static final int DCM_555_BLU_MASK = 0x001F; + private static final int DCM_BGR_RED_MASK = 0x0000ff; + private static final int DCM_BGR_GRN_MASK = 0x00ff00; + private static final int DCM_BGR_BLU_MASK = 0xff0000; + + @Test + public void testCreateFromBufferedImageType() { + for (int type = BufferedImage.TYPE_INT_RGB; type < BufferedImage.TYPE_BYTE_INDEXED; type++) { + assertEquals( + ImageTypeSpecifier.createFromBufferedImageType(type), + ImageTypeSpecifiers.createFromBufferedImageType(type) + ); + } + } + + @Test + public void testCreatePacked() { + // TYPE_INT_RGB + assertEquals( + ImageTypeSpecifier.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, 0, DataBuffer.TYPE_INT, false), + ImageTypeSpecifiers.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, 0, DataBuffer.TYPE_INT, false) + ); + // TYPE_INT_ARGB + assertEquals( + ImageTypeSpecifier.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, DCM_ALPHA_MASK, DataBuffer.TYPE_INT, false), + ImageTypeSpecifiers.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, DCM_ALPHA_MASK, DataBuffer.TYPE_INT, false) + ); + // TYPE_INT_ARGB_PRE + assertEquals( + ImageTypeSpecifier.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, DCM_ALPHA_MASK, DataBuffer.TYPE_INT, true), + ImageTypeSpecifiers.createPacked(sRGB, DCM_RED_MASK, DCM_GREEN_MASK, DCM_BLUE_MASK, DCM_ALPHA_MASK, DataBuffer.TYPE_INT, true) + ); + // TYPE_INT_BGR + assertEquals( + ImageTypeSpecifier.createPacked(sRGB, DCM_BGR_RED_MASK, DCM_BGR_GRN_MASK, DCM_BGR_BLU_MASK, 0, DataBuffer.TYPE_INT, false), + ImageTypeSpecifiers.createPacked(sRGB, DCM_BGR_RED_MASK, DCM_BGR_GRN_MASK, DCM_BGR_BLU_MASK, 0, DataBuffer.TYPE_INT, false) + ); + // TYPE_USHORT_555_RGB + assertEquals( + ImageTypeSpecifier.createPacked(sRGB, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false), + ImageTypeSpecifiers.createPacked(sRGB, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false) + ); + // "SHORT 555 RGB" (impossible for some reason) +// assertEquals( +// ImageTypeSpecifier.createPacked(sRGB, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_SHORT, false), +// ImageTypeSpecifiers.createPacked(sRGB, DCM_555_RED_MASK, DCM_555_GRN_MASK, DCM_555_BLU_MASK, 0, DataBuffer.TYPE_SHORT, false) +// ); + // TYPE_USHORT_565_RGB + assertEquals( + ImageTypeSpecifier.createPacked(sRGB, DCM_565_RED_MASK, DCM_565_GRN_MASK, DCM_565_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false), + ImageTypeSpecifiers.createPacked(sRGB, DCM_565_RED_MASK, DCM_565_GRN_MASK, DCM_565_BLU_MASK, 0, DataBuffer.TYPE_USHORT, false) + ); + // "USHORT 4444 ARGB" + assertEquals( + ImageTypeSpecifier.createPacked(sRGB, 0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, false), + ImageTypeSpecifiers.createPacked(sRGB, 0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, false) + ); + // "USHORT 4444 ARGB PRE" + assertEquals( + ImageTypeSpecifier.createPacked(sRGB, 0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, true), + ImageTypeSpecifiers.createPacked(sRGB, 0xf00, 0xf0, 0xf, 0xf000, DataBuffer.TYPE_USHORT, true) + ); + } + + @Test + public void testCreateInterleaved8() { + // 8 bits/sample + assertEquals( + ImageTypeSpecifier.createInterleaved(GRAY, new int[] {0}, DataBuffer.TYPE_BYTE, false, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0}, DataBuffer.TYPE_BYTE, false, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(GRAY, new int[] {0, 1}, DataBuffer.TYPE_BYTE, true, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0, 1}, DataBuffer.TYPE_BYTE, true, false) + ); + + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2}, DataBuffer.TYPE_BYTE, false, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2}, DataBuffer.TYPE_BYTE, false, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_BYTE, true, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_BYTE, true, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_BYTE, true, true), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_BYTE, true, true) + ); + } + + @Test + public void testCreateInterleaved16() { + // 16 bits/sample + assertEquals( + ImageTypeSpecifier.createInterleaved(GRAY, new int[] {0}, DataBuffer.TYPE_USHORT, false, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0}, DataBuffer.TYPE_USHORT, false, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(GRAY, new int[] {0, 1}, DataBuffer.TYPE_USHORT, true, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0, 1}, DataBuffer.TYPE_USHORT, true, false) + ); + + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2}, DataBuffer.TYPE_USHORT, false, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2}, DataBuffer.TYPE_USHORT, false, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_USHORT, true, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_USHORT, true, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_USHORT, true, true), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_USHORT, true, true) + ); + } + + @Test + public void testCreateInterleaved32() { + // 32 bits/sample + assertEquals( + new UInt32ImageTypeSpecifier(GRAY, new int[] {0}, false, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0}, DataBuffer.TYPE_INT, false, false) + ); + assertEquals( + new UInt32ImageTypeSpecifier(GRAY, new int[] {0, 1}, true, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0, 1}, DataBuffer.TYPE_INT, true, false) + ); + + assertEquals( + new UInt32ImageTypeSpecifier(sRGB, new int[] {0, 1, 2}, false, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2}, DataBuffer.TYPE_INT, false, false) + ); + assertEquals( + new UInt32ImageTypeSpecifier(sRGB, new int[] {0, 1, 2, 3}, true, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_INT, true, false) + ); + assertEquals( + new UInt32ImageTypeSpecifier(sRGB, new int[] {0, 1, 2, 3}, true, true), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_INT, true, true) + ); + } + + @Test + public void testCreateInterleaved32fp() { + // 32 bits/sample + assertEquals( + ImageTypeSpecifier.createInterleaved(GRAY, new int[] {0}, DataBuffer.TYPE_FLOAT, false, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0}, DataBuffer.TYPE_FLOAT, false, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(GRAY, new int[] {0, 1}, DataBuffer.TYPE_FLOAT, true, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0, 1}, DataBuffer.TYPE_FLOAT, true, false) + ); + + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2}, DataBuffer.TYPE_FLOAT, false, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2}, DataBuffer.TYPE_FLOAT, false, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_FLOAT, true, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_FLOAT, true, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_FLOAT, true, true), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_FLOAT, true, true) + ); + } + + @Test + public void testCreateInterleaved64fp() { + // 64 bits/sample + assertEquals( + ImageTypeSpecifier.createInterleaved(GRAY, new int[] {0}, DataBuffer.TYPE_DOUBLE, false, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0}, DataBuffer.TYPE_DOUBLE, false, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(GRAY, new int[] {0, 1}, DataBuffer.TYPE_DOUBLE, true, false), + ImageTypeSpecifiers.createInterleaved(GRAY, new int[] {0, 1}, DataBuffer.TYPE_DOUBLE, true, false) + ); + + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2}, DataBuffer.TYPE_DOUBLE, false, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2}, DataBuffer.TYPE_DOUBLE, false, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_DOUBLE, true, false), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_DOUBLE, true, false) + ); + assertEquals( + ImageTypeSpecifier.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_DOUBLE, true, true), + ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {0, 1, 2, 3}, DataBuffer.TYPE_DOUBLE, true, true) + ); + } + + @Test + public void testCreateBanded8() { + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_BYTE, false, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_BYTE, false, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_BYTE, true, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_BYTE, true, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_BYTE, true, true), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_BYTE, true, true) + ); + } + + @Test + public void testCreateBanded16() { + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_USHORT, false, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_USHORT, false, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_USHORT, true, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_USHORT, true, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_USHORT, true, true), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_USHORT, true, true) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_SHORT, false, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_SHORT, false, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_SHORT, true, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_SHORT, true, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_SHORT, true, true), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_SHORT, true, true) + ); + } + + @Test + public void testCreateBanded32() { + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_INT, false, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_INT, false, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_INT, true, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_INT, true, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_INT, true, true), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_INT, true, true) + ); + } + + @Test + public void testCreateBanded32fp() { + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_FLOAT, false, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_FLOAT, false, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_FLOAT, true, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_FLOAT, true, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_FLOAT, true, true), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_FLOAT, true, true) + ); + } + + @Test + public void testCreateBanded64fp() { + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_DOUBLE, false, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_DOUBLE, false, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_DOUBLE, true, false), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_DOUBLE, true, false) + ); + assertEquals( + ImageTypeSpecifier.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_DOUBLE, true, true), + ImageTypeSpecifiers.createBanded(sRGB, new int[] {0, 1, 2, 3}, new int[] {0, 1000, 2000, 3000}, DataBuffer.TYPE_DOUBLE, true, true) + ); + } + + @Test + public void testCreateGrayscale1to8() { + for (int bits = 1; bits <= 8; bits <<= 1) { + assertEquals( + ImageTypeSpecifier.createGrayscale(bits, DataBuffer.TYPE_BYTE, false), + ImageTypeSpecifiers.createGrayscale(bits, DataBuffer.TYPE_BYTE) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(bits, DataBuffer.TYPE_BYTE, true), + ImageTypeSpecifiers.createGrayscale(bits, DataBuffer.TYPE_BYTE) + ); + } + + } + + @Test + public void testCreateGrayscale16() { + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_USHORT, false), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_USHORT) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_USHORT, true), // NOTE: Signed TYPE_USHORT makes no sense... + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_USHORT) + ); + + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_SHORT, false), // NOTE: Unsigned TYPE_SHORT makes no sense... + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_SHORT) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_SHORT, true), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_SHORT) + ); + } + + @Test + public void testCreateGrayscale32() { + assertEquals( + new UInt32ImageTypeSpecifier(GRAY, new int[] {0}, false, false), + ImageTypeSpecifiers.createGrayscale(32, DataBuffer.TYPE_INT) + ); + assertEquals( + new UInt32ImageTypeSpecifier(GRAY, new int[] {0}, false, false), + ImageTypeSpecifiers.createGrayscale(32, DataBuffer.TYPE_INT) + ); + } + + @Test + public void testCreateGrayscaleAlpha1to8() { + for (int bits = 1; bits <= 8; bits <<= 1) { + assertEquals( + ImageTypeSpecifier.createGrayscale(bits, DataBuffer.TYPE_BYTE, false, false), + ImageTypeSpecifiers.createGrayscale(bits, DataBuffer.TYPE_BYTE, false) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(bits, DataBuffer.TYPE_BYTE, false, true), + ImageTypeSpecifiers.createGrayscale(bits, DataBuffer.TYPE_BYTE, true) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(bits, DataBuffer.TYPE_BYTE, true, false), + ImageTypeSpecifiers.createGrayscale(bits, DataBuffer.TYPE_BYTE, false) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(bits, DataBuffer.TYPE_BYTE, true, true), + ImageTypeSpecifiers.createGrayscale(bits, DataBuffer.TYPE_BYTE, true) + ); + } + } + + @Test + public void testCreateGrayscaleAlpha16() { + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_USHORT, false, false), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_USHORT, false) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_USHORT, false, true), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_USHORT, true) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_USHORT, true, false), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_USHORT, false) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_USHORT, true, true), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_USHORT, true) + ); + + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_SHORT, false, false), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_SHORT, false) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_SHORT, false, true), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_SHORT, true) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_SHORT, true, false), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_SHORT, false) + ); + assertEquals( + ImageTypeSpecifier.createGrayscale(16, DataBuffer.TYPE_SHORT, true, true), + ImageTypeSpecifiers.createGrayscale(16, DataBuffer.TYPE_SHORT, true) + ); + } + + @Test + public void testCreateGrayscaleAlpha32() { + assertEquals( + new UInt32ImageTypeSpecifier(GRAY, new int[] {0, 1}, true, false), + ImageTypeSpecifiers.createGrayscale(32, DataBuffer.TYPE_INT, false) + ); + assertEquals( + new UInt32ImageTypeSpecifier(GRAY, new int[] {0, 1}, true, false), + ImageTypeSpecifiers.createGrayscale(32, DataBuffer.TYPE_INT, false) + ); + assertEquals( + new UInt32ImageTypeSpecifier(GRAY, new int[] {0, 1}, true, true), + ImageTypeSpecifiers.createGrayscale(32, DataBuffer.TYPE_INT, true) + ); + assertEquals( + new UInt32ImageTypeSpecifier(GRAY, new int[] {0, 1}, true, true), + ImageTypeSpecifiers.createGrayscale(32, DataBuffer.TYPE_INT, true) + ); + } + + @Test + public void testCreateIndexedByteArrays1to8() { + for (int bits = 1; bits <= 8; bits <<= 1) { + byte[] lut = createByteLut(1 << bits); + + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, null, bits, DataBuffer.TYPE_BYTE), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, null, bits, DataBuffer.TYPE_BYTE) + ); + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, lut, bits, DataBuffer.TYPE_BYTE), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, lut, bits, DataBuffer.TYPE_BYTE) + ); + } + } + + @Test + public void testCreateIndexedByteArrays16() { + for (int bits = 1; bits <= 8; bits <<= 1) { + byte[] lut = createByteLut(1 << bits); + + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, null, bits, DataBuffer.TYPE_USHORT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, null, bits, DataBuffer.TYPE_USHORT) + ); + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, lut, bits, DataBuffer.TYPE_USHORT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, lut, bits, DataBuffer.TYPE_USHORT) + ); + + // TYPE_SHORT is unsupported to MultiPixelPacked format (MultiPixelPackedSampleModel) + } + + byte[] lut = createByteLut(1 << 16); // This is stupid, but ImageTypeSpecifier enforces lut.length == 1 << bits + + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, null, 16, DataBuffer.TYPE_USHORT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, null, 16, DataBuffer.TYPE_USHORT) + ); + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, lut, 16, DataBuffer.TYPE_USHORT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, lut, 16, DataBuffer.TYPE_USHORT) + ); + + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, null, 16, DataBuffer.TYPE_SHORT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, null, 16, DataBuffer.TYPE_SHORT) + ); + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, lut, 16, DataBuffer.TYPE_SHORT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, lut, 16, DataBuffer.TYPE_SHORT) + ); + } + + @Test + public void testCreateIndexedByteArrays32() { + for (int bits = 1; bits <= 8; bits <<= 1) { + byte[] lut = createByteLut(1 << bits); + + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, null, bits, DataBuffer.TYPE_INT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, null, bits, DataBuffer.TYPE_INT) + ); + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, lut, bits, DataBuffer.TYPE_INT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, lut, bits, DataBuffer.TYPE_INT) + ); + } + + byte[] lut = createByteLut(1 << 16); // This is stupid, but ImageTypeSpecifier enforces lut.length == 1 << bits + + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, null, 16, DataBuffer.TYPE_INT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, null, 16, DataBuffer.TYPE_INT) + ); + assertEquals( + ImageTypeSpecifier.createIndexed(lut, lut, lut, lut, 16, DataBuffer.TYPE_INT), + ImageTypeSpecifiers.createIndexed(lut, lut, lut, lut, 16, DataBuffer.TYPE_INT) + ); + } + + @Test + public void testCreateIndexedIntArray1to8() { + for (int bits = 1; bits <= 8; bits <<= 1) { + int[] colors = createIntLut(1 << bits); + assertEquals( + new IndexedImageTypeSpecifier(new IndexColorModel(bits, colors.length, colors, 0, false, -1, DataBuffer.TYPE_BYTE)), + ImageTypeSpecifiers.createIndexed(colors, false, -1, bits, DataBuffer.TYPE_BYTE) + ); + } + } + + @Test + public void testCreateIndexedIntArray16() { + int[] colors = createIntLut(1 << 16); + assertEquals( + new IndexedImageTypeSpecifier(new IndexColorModel(16, colors.length, colors, 0, false, -1, DataBuffer.TYPE_USHORT)), + ImageTypeSpecifiers.createIndexed(colors, false, -1, 16, DataBuffer.TYPE_USHORT) + ); + + } + + @Test + public void testCreateFromIndexedColorModel1to8() { + for (int bits = 1; bits <= 8; bits <<= 1) { + int[] colors = createIntLut(1 << bits); + IndexColorModel colorModel = new IndexColorModel(bits, colors.length, colors, 0, false, -1, DataBuffer.TYPE_BYTE); + assertEquals( + new IndexedImageTypeSpecifier(colorModel), + ImageTypeSpecifiers.createFromIndexColorModel(colorModel) + ); + } + } + + @Test + public void testCreateFromIndexedColorModel16() { + int[] colors = createIntLut(1 << 16); + IndexColorModel colorModel = new IndexColorModel(16, colors.length, colors, 0, false, -1, DataBuffer.TYPE_USHORT); + assertEquals( + new IndexedImageTypeSpecifier(colorModel), + ImageTypeSpecifiers.createFromIndexColorModel(colorModel) + ); + + } + + + private static byte[] createByteLut(final int count) { + byte[] lut = new byte[count]; + for (int i = 0; i < count; i++) { + lut[i] = (byte) count; + } + return lut; + } + + private static int[] createIntLut(final int count) { + int[] lut = new int[count]; + + for (int i = 0; i < count; i++) { + lut[i] = 0xff000000 | count << 16 | count << 8 | count; + } + + return lut; + } +} diff --git a/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifierTest.java b/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifierTest.java new file mode 100755 index 00000000..399605fc --- /dev/null +++ b/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifierTest.java @@ -0,0 +1,82 @@ +package com.twelvemonkeys.imageio.util; + +import org.junit.Test; + +import java.awt.image.BufferedImage; +import java.awt.image.DataBuffer; +import java.awt.image.IndexColorModel; + +import static org.junit.Assert.*; + +/** + * IndexedImageTypeSpecifierTestCase + * + * @author Harald Kuhr + * @author last modified by $Author: haraldk$ + * @version $Id: IndexedImageTypeSpecifierTestCase.java,v 1.0 Jun 9, 2008 2:42:03 PM haraldk Exp$ + */ +public class IndexedImageTypeSpecifierTest { + @Test + public void testEquals() { + IndexColorModel cm = new IndexColorModel(1, 2, new int[]{0xffffff, 0x00}, 0, false, -1, DataBuffer.TYPE_BYTE); + + IndexedImageTypeSpecifier spec = new IndexedImageTypeSpecifier(cm); + IndexedImageTypeSpecifier other = new IndexedImageTypeSpecifier(cm); + IndexedImageTypeSpecifier different = new IndexedImageTypeSpecifier(new IndexColorModel(2, 2, new int[]{0xff00ff, 0x00, 0xff00ff, 0x00}, 0, false, -1, DataBuffer.TYPE_BYTE)); + + assertEquals(spec, other); + assertEquals(other, spec); + + assertEquals(spec.hashCode(), other.hashCode()); + + assertTrue(spec.equals(other)); + assertTrue(other.equals(spec)); + + // TODO: There is still a problem that IndexColorModel does not override equals, + // so any model with the same number of bits, transparency, and transfer type will be treated as equal + assertFalse(other.equals(different)); + } + + @Test + public void testHashCode() { + IndexColorModel cm = new IndexColorModel(1, 2, new int[]{0xffffff, 0x00}, 0, false, -1, DataBuffer.TYPE_BYTE); + + IndexedImageTypeSpecifier spec = new IndexedImageTypeSpecifier(cm); + IndexedImageTypeSpecifier other = new IndexedImageTypeSpecifier(cm); + IndexedImageTypeSpecifier different = new IndexedImageTypeSpecifier(new IndexColorModel(2, 2, new int[]{0xff00ff, 0x00, 0xff00ff, 0x00}, 0, false, -1, DataBuffer.TYPE_BYTE)); + + // TODO: There is still a problem that IndexColorModel does not override hashCode, + // so any model with the same number of bits, transparency, and transfer type will have same hash + assertEquals(spec.hashCode(), other.hashCode()); + assertFalse(spec.hashCode() == different.hashCode()); + } + + @Test(expected = IllegalArgumentException.class) + public void testCreateNull() { + new IndexedImageTypeSpecifier(null); + } + + @Test + public void testCreateBufferedImageBinary() { + IndexColorModel cm = new IndexColorModel(1, 2, new int[]{0xffffff, 0x00}, 0, false, -1, DataBuffer.TYPE_BYTE); + IndexedImageTypeSpecifier spec = new IndexedImageTypeSpecifier(cm); + + BufferedImage image = spec.createBufferedImage(2, 2); + + assertNotNull(image); + assertEquals(BufferedImage.TYPE_BYTE_BINARY, image.getType()); + assertEquals(cm, image.getColorModel()); + } + + @Test + public void testCreateBufferedImageIndexed() { + IndexColorModel cm = new IndexColorModel(8, 256, new int[256], 0, false, -1, DataBuffer.TYPE_BYTE); + IndexedImageTypeSpecifier spec = new IndexedImageTypeSpecifier(cm); + + BufferedImage image = spec.createBufferedImage(2, 2); + + assertNotNull(image); + assertEquals(BufferedImage.TYPE_BYTE_INDEXED, image.getType()); + assertEquals(cm, image.getColorModel()); + } +} diff --git a/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifierTestCase.java b/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifierTestCase.java deleted file mode 100755 index 3b24dfa9..00000000 --- a/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifierTestCase.java +++ /dev/null @@ -1,28 +0,0 @@ -package com.twelvemonkeys.imageio.util; - -import junit.framework.TestCase; - -import java.awt.image.DataBuffer; -import java.awt.image.IndexColorModel; - -/** - * IndexedImageTypeSpecifierTestCase - * - * @author Harald Kuhr - * @author last modified by $Author: haraldk$ - * @version $Id: IndexedImageTypeSpecifierTestCase.java,v 1.0 Jun 9, 2008 2:42:03 PM haraldk Exp$ - */ -public class IndexedImageTypeSpecifierTestCase extends TestCase { - public void testEquals() { - IndexColorModel cm = new IndexColorModel(1, 2, new int[]{0xffffff, 0x00}, 0, false, -1, DataBuffer.TYPE_BYTE); - - IndexedImageTypeSpecifier spec = new IndexedImageTypeSpecifier(cm); - IndexedImageTypeSpecifier other = new IndexedImageTypeSpecifier(cm); - - assertEquals(spec, other); - assertEquals(other, spec); - - assertTrue(spec.equals(other)); - assertTrue(other.equals(spec)); - } -} diff --git a/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/UInt32ImageTypeSpecifierTest.java b/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/UInt32ImageTypeSpecifierTest.java new file mode 100644 index 00000000..096fd535 --- /dev/null +++ b/imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/UInt32ImageTypeSpecifierTest.java @@ -0,0 +1,199 @@ +package com.twelvemonkeys.imageio.util; + +import com.twelvemonkeys.imageio.color.ColorSpaces; +import org.junit.Test; + +import javax.imageio.ImageTypeSpecifier; +import java.awt.color.ColorSpace; +import java.awt.image.ComponentColorModel; +import java.awt.image.DataBuffer; +import java.awt.image.PixelInterleavedSampleModel; + +import static org.hamcrest.core.Is.is; +import static org.junit.Assert.*; + +public class UInt32ImageTypeSpecifierTest { + private static final ColorSpace sRGB = ColorSpace.getInstance(ColorSpace.CS_sRGB); + private static final ColorSpace GRAY = ColorSpace.getInstance(ColorSpace.CS_GRAY); + private static final ColorSpace CMYK = ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK); + + @Test + public void testGray() { + ImageTypeSpecifier spec = new UInt32ImageTypeSpecifier(GRAY, new int [] {0}, false, false); + + assertEquals(1, spec.getNumBands()); + assertEquals(1, spec.getNumComponents()); + assertEquals(32, spec.getBitsPerBand(0)); + + assertThat(spec.getColorModel(), is(ComponentColorModel.class)); + assertFalse(spec.getColorModel().hasAlpha()); + assertFalse(spec.getColorModel().isAlphaPremultiplied()); + assertEquals(1, spec.getColorModel().getNumComponents()); + assertEquals(1, spec.getColorModel().getNumColorComponents()); + + assertThat(spec.getSampleModel(), is(PixelInterleavedSampleModel.class)); + assertEquals(1, spec.getSampleModel().getNumBands()); + assertEquals(1, spec.getSampleModel().getNumDataElements()); + } + + @Test + public void testGrayAlpha() { + ImageTypeSpecifier spec = new UInt32ImageTypeSpecifier(GRAY, new int [] {0, 1}, true, false); + assertEquals(2, spec.getNumBands()); + assertEquals(2, spec.getNumComponents()); + assertEquals(32, spec.getBitsPerBand(0)); + assertEquals(32, spec.getBitsPerBand(1)); + + assertThat(spec.getColorModel(), is(ComponentColorModel.class)); + assertTrue(spec.getColorModel().hasAlpha()); + assertFalse(spec.getColorModel().isAlphaPremultiplied()); + assertEquals(2, spec.getColorModel().getNumComponents()); + assertEquals(1, spec.getColorModel().getNumColorComponents()); + + assertThat(spec.getSampleModel(), is(PixelInterleavedSampleModel.class)); + assertEquals(2, spec.getSampleModel().getNumBands()); + assertEquals(2, spec.getSampleModel().getNumDataElements()); + } + + @Test + public void testRGB() { + ImageTypeSpecifier spec = new UInt32ImageTypeSpecifier(sRGB, new int [] {0, 1, 2}, false, false); + + assertEquals(3, spec.getNumBands()); + assertEquals(3, spec.getNumComponents()); + assertEquals(32, spec.getBitsPerBand(0)); + assertEquals(32, spec.getBitsPerBand(1)); + assertEquals(32, spec.getBitsPerBand(2)); + + assertThat(spec.getColorModel(), is(ComponentColorModel.class)); + assertFalse(spec.getColorModel().hasAlpha()); + assertFalse(spec.getColorModel().isAlphaPremultiplied()); + assertEquals(3, spec.getColorModel().getNumComponents()); + assertEquals(3, spec.getColorModel().getNumColorComponents()); + + assertThat(spec.getSampleModel(), is(PixelInterleavedSampleModel.class)); + assertEquals(3, spec.getSampleModel().getNumBands()); + assertEquals(3, spec.getSampleModel().getNumDataElements()); + } + + @Test + public void testRGBAlpha() { + ImageTypeSpecifier spec = new UInt32ImageTypeSpecifier(sRGB, new int [] {0, 1, 2, 3}, true, false); + assertEquals(4, spec.getNumBands()); + assertEquals(4, spec.getNumComponents()); + assertEquals(32, spec.getBitsPerBand(0)); + assertEquals(32, spec.getBitsPerBand(1)); + assertEquals(32, spec.getBitsPerBand(2)); + assertEquals(32, spec.getBitsPerBand(3)); + + assertThat(spec.getColorModel(), is(ComponentColorModel.class)); + assertTrue(spec.getColorModel().hasAlpha()); + assertFalse(spec.getColorModel().isAlphaPremultiplied()); + assertEquals(4, spec.getColorModel().getNumComponents()); + assertEquals(3, spec.getColorModel().getNumColorComponents()); + + assertThat(spec.getSampleModel(), is(PixelInterleavedSampleModel.class)); + assertEquals(4, spec.getSampleModel().getNumBands()); + assertEquals(4, spec.getSampleModel().getNumDataElements()); + } + + @Test + public void testRGBAlphaPre() { + ImageTypeSpecifier spec = new UInt32ImageTypeSpecifier(sRGB, new int [] {0, 1, 2, 3}, true, true); + assertEquals(4, spec.getNumBands()); + assertEquals(4, spec.getNumComponents()); + assertEquals(32, spec.getBitsPerBand(0)); + assertEquals(32, spec.getBitsPerBand(1)); + assertEquals(32, spec.getBitsPerBand(2)); + assertEquals(32, spec.getBitsPerBand(3)); + + assertThat(spec.getColorModel(), is(ComponentColorModel.class)); + assertTrue(spec.getColorModel().hasAlpha()); + assertTrue(spec.getColorModel().isAlphaPremultiplied()); + assertEquals(4, spec.getColorModel().getNumComponents()); + assertEquals(3, spec.getColorModel().getNumColorComponents()); + + assertThat(spec.getSampleModel(), is(PixelInterleavedSampleModel.class)); + assertEquals(4, spec.getSampleModel().getNumBands()); + assertEquals(4, spec.getSampleModel().getNumDataElements()); + } + + @Test + public void testCMYK() { + ImageTypeSpecifier spec = new UInt32ImageTypeSpecifier(CMYK, new int [] {0, 1, 2, 3}, false, false); + + assertEquals(4, spec.getNumBands()); + assertEquals(4, spec.getNumComponents()); + assertEquals(32, spec.getBitsPerBand(0)); + assertEquals(32, spec.getBitsPerBand(1)); + assertEquals(32, spec.getBitsPerBand(2)); + assertEquals(32, spec.getBitsPerBand(3)); + + assertThat(spec.getColorModel(), is(ComponentColorModel.class)); + assertFalse(spec.getColorModel().hasAlpha()); + assertFalse(spec.getColorModel().isAlphaPremultiplied()); + assertEquals(4, spec.getColorModel().getNumComponents()); + assertEquals(4, spec.getColorModel().getNumColorComponents()); + + assertThat(spec.getSampleModel(), is(PixelInterleavedSampleModel.class)); + assertEquals(4, spec.getSampleModel().getNumBands()); + assertEquals(4, spec.getSampleModel().getNumDataElements()); + } + + @Test + public void testCMYKAlpha() { + ImageTypeSpecifier spec = new UInt32ImageTypeSpecifier(CMYK, new int [] {0, 1, 2, 3, 4}, true, false); + assertEquals(5, spec.getNumBands()); + assertEquals(5, spec.getNumComponents()); + assertEquals(32, spec.getBitsPerBand(0)); + assertEquals(32, spec.getBitsPerBand(1)); + assertEquals(32, spec.getBitsPerBand(2)); + assertEquals(32, spec.getBitsPerBand(3)); + assertEquals(32, spec.getBitsPerBand(4)); + + assertThat(spec.getColorModel(), is(ComponentColorModel.class)); + assertTrue(spec.getColorModel().hasAlpha()); + assertFalse(spec.getColorModel().isAlphaPremultiplied()); + assertEquals(5, spec.getColorModel().getNumComponents()); + assertEquals(4, spec.getColorModel().getNumColorComponents()); + + assertThat(spec.getSampleModel(), is(PixelInterleavedSampleModel.class)); + assertEquals(5, spec.getSampleModel().getNumBands()); + assertEquals(5, spec.getSampleModel().getNumDataElements()); + } + + + @Test + public void testEquals() { + ImageTypeSpecifier spec = new UInt32ImageTypeSpecifier(sRGB, new int [] {0, 1, 2}, false, false); + ImageTypeSpecifier other = new UInt32ImageTypeSpecifier(sRGB, new int [] {0, 1, 2}, false, false); + ImageTypeSpecifier different = new UInt32ImageTypeSpecifier(sRGB, new int [] {0, 1, 2, 3}, true, false); + // Equivalent, but broken, not equal + ImageTypeSpecifier broken = + ImageTypeSpecifier.createInterleaved(sRGB, new int [] {0, 1, 2}, DataBuffer.TYPE_INT, false, false); + + assertEquals(spec, other); + assertEquals(other, spec); + + assertTrue(spec.equals(other)); + assertTrue(other.equals(spec)); + assertFalse(spec.equals(different)); + assertFalse(different.equals(spec)); + assertFalse(spec.equals(broken)); + assertFalse(broken.equals(spec)); + } + + @Test + public void testHashCode() { + ImageTypeSpecifier spec = new UInt32ImageTypeSpecifier(sRGB, new int [] {0, 1, 2}, false, false); + ImageTypeSpecifier other = new UInt32ImageTypeSpecifier(sRGB, new int [] {0, 1, 2}, false, false); + ImageTypeSpecifier different = new UInt32ImageTypeSpecifier(sRGB, new int [] {0, 1, 2, 3}, true, false); + // Equivalent, but broken, not equal + ImageTypeSpecifier broken = + ImageTypeSpecifier.createInterleaved(sRGB, new int [] {0, 1, 2}, DataBuffer.TYPE_INT, false, false); + + assertEquals(spec.hashCode(), other.hashCode()); + assertFalse(spec.hashCode() == different.hashCode()); + assertFalse(spec.hashCode() == broken.hashCode()); + } +} diff --git a/imageio/imageio-icns/src/main/java/com/twelvemonkeys/imageio/plugins/icns/ICNSImageReader.java b/imageio/imageio-icns/src/main/java/com/twelvemonkeys/imageio/plugins/icns/ICNSImageReader.java index 752499f7..719a51e5 100644 --- a/imageio/imageio-icns/src/main/java/com/twelvemonkeys/imageio/plugins/icns/ICNSImageReader.java +++ b/imageio/imageio-icns/src/main/java/com/twelvemonkeys/imageio/plugins/icns/ICNSImageReader.java @@ -30,7 +30,7 @@ package com.twelvemonkeys.imageio.plugins.icns; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.util.IIOUtil; -import com.twelvemonkeys.imageio.util.IndexedImageTypeSpecifier; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import javax.imageio.*; import javax.imageio.spi.ImageReaderSpi; @@ -99,21 +99,21 @@ public final class ICNSImageReader extends ImageReaderBase { switch (resource.depth()) { case 1: - return IndexedImageTypeSpecifier.createFromIndexColorModel(ICNS1BitColorModel.INSTANCE); + return ImageTypeSpecifiers.createFromIndexColorModel(ICNS1BitColorModel.INSTANCE); case 4: - return IndexedImageTypeSpecifier.createFromIndexColorModel(ICNS4BitColorModel.INSTANCE); + return ImageTypeSpecifiers.createFromIndexColorModel(ICNS4BitColorModel.INSTANCE); case 8: - return IndexedImageTypeSpecifier.createFromIndexColorModel(ICNS8BitColorModel.INSTANCE); + return ImageTypeSpecifiers.createFromIndexColorModel(ICNS8BitColorModel.INSTANCE); case 32: if (resource.isCompressed()) { - return ImageTypeSpecifier.createBanded( + return ImageTypeSpecifiers.createBanded( ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[]{0, 1, 2, 3}, createBandOffsets(resource.size().width * resource.size().height), DataBuffer.TYPE_BYTE, true, false ); } else { - return ImageTypeSpecifier.createInterleaved( + return ImageTypeSpecifiers.createInterleaved( ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[]{1, 2, 3, 0}, DataBuffer.TYPE_BYTE, true, false @@ -141,8 +141,8 @@ public final class ICNSImageReader extends ImageReaderBase { case 8: // Fall through & convert during read case 32: - specifiers.add(ImageTypeSpecifier.createPacked(ColorSpace.getInstance(ColorSpace.CS_sRGB), 0xff0000, 0x00ff00, 0x0000ff, 0xff000000, DataBuffer.TYPE_INT, false)); - specifiers.add(ImageTypeSpecifier.createInterleaved(ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[]{3, 2, 1, 0}, DataBuffer.TYPE_BYTE, true, false)); + specifiers.add(ImageTypeSpecifiers.createPacked(ColorSpace.getInstance(ColorSpace.CS_sRGB), 0xff0000, 0x00ff00, 0x0000ff, 0xff000000, DataBuffer.TYPE_INT, false)); + specifiers.add(ImageTypeSpecifiers.createInterleaved(ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[]{3, 2, 1, 0}, DataBuffer.TYPE_BYTE, true, false)); break; default: throw new IllegalStateException(String.format("Unknown bit depth: %d", resource.depth())); @@ -199,7 +199,7 @@ public final class ICNSImageReader extends ImageReaderBase { BufferedImage image = getDestination(param, getImageTypes(imageIndex), width, height); ImageTypeSpecifier rawType = getRawImageType(imageIndex); - if (rawType instanceof IndexedImageTypeSpecifier && rawType.getBufferedImageType() != image.getType()) { + if (rawType.getColorModel() instanceof IndexColorModel && rawType.getBufferedImageType() != image.getType()) { checkReadParamBandSettings(param, 4, image.getSampleModel().getNumBands()); } else { diff --git a/imageio/imageio-iff/src/main/java/com/twelvemonkeys/imageio/plugins/iff/IFFImageReader.java b/imageio/imageio-iff/src/main/java/com/twelvemonkeys/imageio/plugins/iff/IFFImageReader.java index 530e95c9..20405754 100755 --- a/imageio/imageio-iff/src/main/java/com/twelvemonkeys/imageio/plugins/iff/IFFImageReader.java +++ b/imageio/imageio-iff/src/main/java/com/twelvemonkeys/imageio/plugins/iff/IFFImageReader.java @@ -32,7 +32,7 @@ import com.twelvemonkeys.image.ResampleOp; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.stream.BufferedImageInputStream; import com.twelvemonkeys.imageio.util.IIOUtil; -import com.twelvemonkeys.imageio.util.IndexedImageTypeSpecifier; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import com.twelvemonkeys.io.enc.DecoderStream; import com.twelvemonkeys.io.enc.PackBitsDecoder; @@ -149,7 +149,7 @@ public class IFFImageReader extends ImageReaderBase { int remaining = imageInput.readInt() - 4; // We'll read 4 more in a sec formType = imageInput.readInt(); - if (formType != IFF.TYPE_ILBM && formType != IFF.TYPE_PBM) { + if (formType != IFF.TYPE_ILBM && formType != IFF.TYPE_PBM/* && formType != IFF.TYPE_DEEP*/) { throw new IIOException(String.format("Only IFF FORM types 'ILBM' and 'PBM ' supported: %s", IFFUtil.toChunkStr(formType))); } @@ -324,7 +324,7 @@ public class IFFImageReader extends ImageReaderBase { List types = Arrays.asList( getRawImageType(pIndex), - ImageTypeSpecifier.createFromBufferedImageType(header.bitplanes == 32 ? BufferedImage.TYPE_4BYTE_ABGR : BufferedImage.TYPE_3BYTE_BGR) + ImageTypeSpecifiers.createFromBufferedImageType(header.bitplanes == 32 ? BufferedImage.TYPE_4BYTE_ABGR : BufferedImage.TYPE_3BYTE_BGR) // TODO: ImageTypeSpecifier.createFromBufferedImageType(header.bitplanes == 32 ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB), // TODO: Allow 32 bit always. Allow RGB and discard alpha, if present? ); @@ -357,22 +357,22 @@ public class IFFImageReader extends ImageReaderBase { if (!isConvertToRGB()) { if (colorMap != null) { IndexColorModel cm = colorMap.getIndexColorModel(header, isEHB()); - specifier = IndexedImageTypeSpecifier.createFromIndexColorModel(cm); + specifier = ImageTypeSpecifiers.createFromIndexColorModel(cm); break; } else { - specifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY); + specifier = ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY); break; } } // NOTE: HAM modes falls through, as they are converted to RGB case 24: // 24 bit RGB - specifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); + specifier = ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); break; case 32: // 32 bit ARGB - specifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR); + specifier = ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR); break; default: throw new IIOException(String.format("Bit depth not implemented: %d", header.bitplanes)); @@ -819,6 +819,9 @@ public class IFFImageReader extends ImageReaderBase { showIt(image, arg); } + else { + System.err.println("Foo!"); + } } catch (IOException e) { System.err.println("Error reading file: " + file); diff --git a/imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/JPEGImageReader.java b/imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/JPEGImageReader.java index ba8837ea..33a3766a 100644 --- a/imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/JPEGImageReader.java +++ b/imageio/imageio-jpeg/src/main/java/com/twelvemonkeys/imageio/plugins/jpeg/JPEGImageReader.java @@ -39,6 +39,7 @@ import com.twelvemonkeys.imageio.metadata.exif.TIFF; import com.twelvemonkeys.imageio.metadata.jpeg.JPEG; import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegment; import com.twelvemonkeys.imageio.metadata.jpeg.JPEGSegmentUtil; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import com.twelvemonkeys.imageio.util.ProgressListenerBase; import com.twelvemonkeys.lang.Validate; import com.twelvemonkeys.xml.XMLSerializer; @@ -217,36 +218,36 @@ public class JPEGImageReader extends ImageReaderBase { if (types == null || !types.hasNext() || csType == JPEGColorSpace.CMYK || csType == JPEGColorSpace.YCCK) { ArrayList typeList = new ArrayList(); // Add the standard types, we can always convert to these - typeList.add(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR)); - typeList.add(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB)); - typeList.add(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_BGR)); + typeList.add(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR)); + typeList.add(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB)); + typeList.add(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_BGR)); // We also read and return CMYK if the source image is CMYK/YCCK + original color profile if present ICC_Profile profile = getEmbeddedICCProfile(false); if (csType == JPEGColorSpace.CMYK || csType == JPEGColorSpace.YCCK) { if (profile != null) { - typeList.add(ImageTypeSpecifier.createInterleaved(ColorSpaces.createColorSpace(profile), new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, false, false)); + typeList.add(ImageTypeSpecifiers.createInterleaved(ColorSpaces.createColorSpace(profile), new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, false, false)); } - typeList.add(ImageTypeSpecifier.createInterleaved(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, false, false)); + typeList.add(ImageTypeSpecifiers.createInterleaved(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, false, false)); } else if (csType == JPEGColorSpace.YCbCr || csType == JPEGColorSpace.RGB) { if (profile != null) { - typeList.add(ImageTypeSpecifier.createInterleaved(ColorSpaces.createColorSpace(profile), new int[] {0, 1, 2}, DataBuffer.TYPE_BYTE, false, false)); + typeList.add(ImageTypeSpecifiers.createInterleaved(ColorSpaces.createColorSpace(profile), new int[] {0, 1, 2}, DataBuffer.TYPE_BYTE, false, false)); } } else if (csType == JPEGColorSpace.YCbCrA || csType == JPEGColorSpace.RGBA) { // Prepend ARGB types typeList.addAll(0, Arrays.asList( - ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB), - ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR), - ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB_PRE), - ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR_PRE) + ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB), + ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR), + ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB_PRE), + ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR_PRE) )); if (profile != null) { - typeList.add(ImageTypeSpecifier.createInterleaved(ColorSpaces.createColorSpace(profile), new int[] {0, 1, 2, 3}, DataBuffer.TYPE_BYTE, false, false)); + typeList.add(ImageTypeSpecifiers.createInterleaved(ColorSpaces.createColorSpace(profile), new int[] {0, 1, 2, 3}, DataBuffer.TYPE_BYTE, false, false)); } } @@ -274,10 +275,12 @@ public class JPEGImageReader extends ImageReaderBase { ICC_Profile profile = getEmbeddedICCProfile(false); if (profile != null) { - return ImageTypeSpecifier.createInterleaved(ColorSpaces.createColorSpace(profile), new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, false, false); + return ImageTypeSpecifiers.createInterleaved(ColorSpaces.createColorSpace(profile), new int[]{ + 3, 2, 1, 0 + }, DataBuffer.TYPE_BYTE, false, false); } - return ImageTypeSpecifier.createInterleaved(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, false, false); + return ImageTypeSpecifiers.createInterleaved(ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK), new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, false, false); default: // For other types, we probably can't give a proper type, return null return null; @@ -1070,7 +1073,7 @@ public class JPEGImageReader extends ImageReaderBase { super.processWarningOccurred(warning); } - private static void invertCMYK(final Raster raster) { + static void invertCMYK(final Raster raster) { byte[] data = ((DataBufferByte) raster.getDataBuffer()).getData(); for (int i = 0, dataLength = data.length; i < dataLength; i++) { diff --git a/imageio/imageio-pcx/src/main/java/com/twelvemonkeys/imageio/plugins/pcx/PCXImageReader.java b/imageio/imageio-pcx/src/main/java/com/twelvemonkeys/imageio/plugins/pcx/PCXImageReader.java index 1eddfa15..a244dcfd 100755 --- a/imageio/imageio-pcx/src/main/java/com/twelvemonkeys/imageio/plugins/pcx/PCXImageReader.java +++ b/imageio/imageio-pcx/src/main/java/com/twelvemonkeys/imageio/plugins/pcx/PCXImageReader.java @@ -30,7 +30,7 @@ package com.twelvemonkeys.imageio.plugins.pcx; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.util.IIOUtil; -import com.twelvemonkeys.imageio.util.IndexedImageTypeSpecifier; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import com.twelvemonkeys.io.enc.DecoderStream; import com.twelvemonkeys.xml.XMLSerializer; @@ -45,7 +45,10 @@ import javax.imageio.stream.ImageInputStream; import java.awt.*; import java.awt.color.ColorSpace; import java.awt.image.*; -import java.io.*; +import java.io.DataInput; +import java.io.DataInputStream; +import java.io.File; +import java.io.IOException; import java.nio.ByteOrder; import java.util.ArrayList; import java.util.Iterator; @@ -53,7 +56,7 @@ import java.util.List; public final class PCXImageReader extends ImageReaderBase { /** 8 bit ImageTypeSpecifer used for reading bitplane images. */ - private static final ImageTypeSpecifier GRAYSCALE = ImageTypeSpecifier.createGrayscale(8, DataBuffer.TYPE_BYTE, false); + private static final ImageTypeSpecifier GRAYSCALE = ImageTypeSpecifiers.createGrayscale(8, DataBuffer.TYPE_BYTE, false); private PCXHeader header; private boolean readPalette; @@ -111,7 +114,7 @@ public final class PCXImageReader extends ImageReaderBase { case 1: case 2: case 4: - return IndexedImageTypeSpecifier.createFromIndexColorModel(header.getEGAPalette()); + return ImageTypeSpecifiers.createFromIndexColorModel(header.getEGAPalette()); case 8: // We may have IndexColorModel here for 1 channel images if (channels == 1 && paletteInfo != PCX.PALETTEINFO_GRAY) { @@ -120,17 +123,17 @@ public final class PCXImageReader extends ImageReaderBase { throw new IIOException("Expected VGA palette not found"); } - return IndexedImageTypeSpecifier.createFromIndexColorModel(palette); + return ImageTypeSpecifiers.createFromIndexColorModel(palette); } // PCX has 1 or 3 channels for 8 bit gray or 24 bit RGB, will be validated by ImageTypeSpecifier - return ImageTypeSpecifier.createBanded(cs, createIndices(channels, 1), createIndices(channels, 0), DataBuffer.TYPE_BYTE, false, false); + return ImageTypeSpecifiers.createBanded(cs, createIndices(channels, 1), createIndices(channels, 0), DataBuffer.TYPE_BYTE, false, false); case 24: // Some sources says this is possible... - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); case 32: // Some sources says this is possible... - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR); default: throw new IIOException("Unknown number of bytes per pixel: " + header.getBitsPerPixel()); } diff --git a/imageio/imageio-pict/src/main/java/com/twelvemonkeys/imageio/plugins/pict/PICTImageReader.java b/imageio/imageio-pict/src/main/java/com/twelvemonkeys/imageio/plugins/pict/PICTImageReader.java index f1ed38d8..2cc202d6 100644 --- a/imageio/imageio-pict/src/main/java/com/twelvemonkeys/imageio/plugins/pict/PICTImageReader.java +++ b/imageio/imageio-pict/src/main/java/com/twelvemonkeys/imageio/plugins/pict/PICTImageReader.java @@ -61,6 +61,7 @@ package com.twelvemonkeys.imageio.plugins.pict; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.util.IIOUtil; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import com.twelvemonkeys.io.enc.Decoder; import com.twelvemonkeys.io.enc.DecoderStream; import com.twelvemonkeys.io.enc.PackBits16Decoder; @@ -2659,7 +2660,7 @@ public class PICTImageReader extends ImageReaderBase { public Iterator getImageTypes(int pIndex) throws IOException { // TODO: The images look slightly different in Preview.. Could indicate the color space is wrong... return Arrays.asList( - ImageTypeSpecifier.createPacked( + ImageTypeSpecifiers.createPacked( ColorSpace.getInstance(ColorSpace.CS_sRGB), 0xff0000, 0xff00, 0xff, 0xff000000, DataBuffer.TYPE_INT, false ) diff --git a/imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PNMImageReader.java b/imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PNMImageReader.java index c72c8de8..726e5d72 100755 --- a/imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PNMImageReader.java +++ b/imageio/imageio-pnm/src/main/java/com/twelvemonkeys/imageio/plugins/pnm/PNMImageReader.java @@ -31,6 +31,7 @@ package com.twelvemonkeys.imageio.plugins.pnm; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.color.ColorSpaces; import com.twelvemonkeys.imageio.util.IIOUtil; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import javax.imageio.IIOException; import javax.imageio.ImageIO; @@ -116,29 +117,29 @@ public final class PNMImageReader extends ImageReaderBase { ColorSpace gray = ColorSpace.getInstance(ColorSpace.CS_GRAY); if (header.getTransferType() == DataBuffer.TYPE_FLOAT) { - return ImageTypeSpecifier.createInterleaved(gray, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); + return ImageTypeSpecifiers.createInterleaved(gray, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); } if (header.getMaxSample() <= PNM.MAX_VAL_16BIT) { - return hasAlpha ? ImageTypeSpecifier.createGrayscale(bitsPerSample, transferType, false, false) - : ImageTypeSpecifier.createGrayscale(bitsPerSample, transferType, false); + return hasAlpha ? ImageTypeSpecifiers.createGrayscale(bitsPerSample, transferType, false, false) + : ImageTypeSpecifiers.createGrayscale(bitsPerSample, transferType, false); } - return ImageTypeSpecifier.createInterleaved(gray, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); + return ImageTypeSpecifiers.createInterleaved(gray, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); case RGB: case RGB_ALPHA: // Using sRGB seems sufficient for PPM, as it is very close to ITU-R Recommendation BT.709 (same gamut and white point CIE D65) ColorSpace sRGB = ColorSpace.getInstance(ColorSpace.CS_sRGB); if (header.getTransferType() == DataBuffer.TYPE_FLOAT) { - return ImageTypeSpecifier.createInterleaved(sRGB, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); + return ImageTypeSpecifiers.createInterleaved(sRGB, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); } - return ImageTypeSpecifier.createInterleaved(sRGB, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); + return ImageTypeSpecifiers.createInterleaved(sRGB, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); case CMYK: case CMYK_ALPHA: ColorSpace cmyk = ColorSpaces.getColorSpace(ColorSpaces.CS_GENERIC_CMYK); - return ImageTypeSpecifier.createInterleaved(cmyk, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); + return ImageTypeSpecifiers.createInterleaved(cmyk, createBandOffsets(samplesPerPixel), transferType, hasAlpha, false); default: // TODO: Allow reading unknown tuple types as Raster! diff --git a/imageio/imageio-psd/src/main/java/com/twelvemonkeys/imageio/plugins/psd/PSDImageReader.java b/imageio/imageio-psd/src/main/java/com/twelvemonkeys/imageio/plugins/psd/PSDImageReader.java index a452dac7..e157ccea 100755 --- a/imageio/imageio-psd/src/main/java/com/twelvemonkeys/imageio/plugins/psd/PSDImageReader.java +++ b/imageio/imageio-psd/src/main/java/com/twelvemonkeys/imageio/plugins/psd/PSDImageReader.java @@ -31,7 +31,7 @@ package com.twelvemonkeys.imageio.plugins.psd; import com.twelvemonkeys.image.ImageUtil; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.color.ColorSpaces; -import com.twelvemonkeys.imageio.util.IndexedImageTypeSpecifier; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import javax.imageio.IIOException; import javax.imageio.ImageIO; @@ -145,14 +145,14 @@ public final class PSDImageReader extends ImageReaderBase { switch (header.mode) { case PSD.COLOR_MODE_BITMAP: if (header.channels == 1 && header.bits == 1) { - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_BINARY); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_BINARY); } throw new IIOException(String.format("Unsupported channel count/bit depth for Monochrome PSD: %d channels/%d bits", header.channels, header.bits)); case PSD.COLOR_MODE_INDEXED: if (header.channels == 1 && header.bits == 8) { - return IndexedImageTypeSpecifier.createFromIndexColorModel(metadata.colorData.getIndexColorModel()); + return ImageTypeSpecifiers.createFromIndexColorModel(metadata.colorData.getIndexColorModel()); } throw new IIOException(String.format("Unsupported channel count/bit depth for Indexed Color PSD: %d channels/%d bits", header.channels, header.bits)); @@ -167,22 +167,22 @@ public final class PSDImageReader extends ImageReaderBase { } if (header.channels == 1 && header.bits == 8) { - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY); } else if (header.channels == 2 && header.bits == 8) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1}, new int[] {0, 0}, DataBuffer.TYPE_BYTE, true, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1}, new int[] {0, 0}, DataBuffer.TYPE_BYTE, true, false); } else if (header.channels == 1 && header.bits == 16) { - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_USHORT_GRAY); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_USHORT_GRAY); } else if (header.channels == 2 && header.bits == 16) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1}, new int[] {0, 0}, DataBuffer.TYPE_USHORT, true, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1}, new int[] {0, 0}, DataBuffer.TYPE_USHORT, true, false); } else if (header.channels == 1 && header.bits == 32) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0}, new int[] {0}, DataBuffer.TYPE_INT, false, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0}, new int[] {0}, DataBuffer.TYPE_INT, false, false); } else if (header.channels == 2 && header.bits == 32) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1}, new int[] {0, 0}, DataBuffer.TYPE_INT, true, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1}, new int[] {0, 0}, DataBuffer.TYPE_INT, true, false); } throw new IIOException(String.format("Unsupported channel count/bit depth for Gray Scale PSD: %d channels/%d bits", header.channels, header.bits)); @@ -194,22 +194,22 @@ public final class PSDImageReader extends ImageReaderBase { } if (header.channels == 3 && header.bits == 8) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_BYTE, false, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_BYTE, false, false); } else if (header.channels >= 4 && header.bits == 8) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_BYTE, true, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_BYTE, true, false); } else if (header.channels == 3 && header.bits == 16) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_USHORT, false, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_USHORT, false, false); } else if (header.channels >= 4 && header.bits == 16) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_USHORT, true, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_USHORT, true, false); } else if (header.channels == 3 && header.bits == 32) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_INT, false, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2}, new int[] {0, 0, 0}, DataBuffer.TYPE_INT, false, false); } else if (header.channels >= 4 && header.bits == 32) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_INT, true, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_INT, true, false); } throw new IIOException(String.format("Unsupported channel count/bit depth for RGB PSD: %d channels/%d bits", header.channels, header.bits)); @@ -221,22 +221,22 @@ public final class PSDImageReader extends ImageReaderBase { } if (header.channels == 4 && header.bits == 8) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_BYTE, false, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_BYTE, false, false); } else if (header.channels == 5 && header.bits == 8) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3, 4}, new int[] {0, 0, 0, 0, 0}, DataBuffer.TYPE_BYTE, true, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3, 4}, new int[] {0, 0, 0, 0, 0}, DataBuffer.TYPE_BYTE, true, false); } else if (header.channels == 4 && header.bits == 16) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_USHORT, false, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_USHORT, false, false); } else if (header.channels == 5 && header.bits == 16) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3, 4}, new int[] {0, 0, 0, 0, 0}, DataBuffer.TYPE_USHORT, true, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3, 4}, new int[] {0, 0, 0, 0, 0}, DataBuffer.TYPE_USHORT, true, false); } else if (header.channels == 4 && header.bits == 32) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_INT, false, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, DataBuffer.TYPE_INT, false, false); } else if (header.channels == 5 && header.bits == 32) { - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3, 4}, new int[] {0, 0, 0, 0, 0}, DataBuffer.TYPE_INT, true, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3, 4}, new int[] {0, 0, 0, 0, 0}, DataBuffer.TYPE_INT, true, false); } throw new IIOException(String.format("Unsupported channel count/bit depth for CMYK PSD: %d channels/%d bits", header.channels, header.bits)); @@ -269,11 +269,11 @@ public final class PSDImageReader extends ImageReaderBase { // TODO: ColorConvertOp to CS_sRGB // TODO: Integer raster // types.add(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.INT_RGB)); - types.add(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR)); + types.add(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR)); if (!cs.isCS_sRGB()) { // Basically BufferedImage.TYPE_3BYTE_BGR, with corrected ColorSpace. Possibly slow. - types.add(ImageTypeSpecifier.createInterleaved(cs, new int[] {2, 1, 0}, DataBuffer.TYPE_BYTE, false, false)); + types.add(ImageTypeSpecifiers.createInterleaved(cs, new int[] {2, 1, 0}, DataBuffer.TYPE_BYTE, false, false)); } } // else if (header.channels >= 4 && header.bits == 8) { @@ -281,20 +281,20 @@ public final class PSDImageReader extends ImageReaderBase { // TODO: ColorConvertOp to CS_sRGB // TODO: Integer raster // types.add(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.INT_ARGB)); - types.add(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR)); + types.add(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR)); // if (!cs.isCS_sRGB()) { // Basically BufferedImage.TYPE_4BYTE_ABGR, with corrected ColorSpace. Possibly slow. - types.add(ImageTypeSpecifier.createInterleaved(cs, new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, true, false)); + types.add(ImageTypeSpecifiers.createInterleaved(cs, new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, true, false)); } } // else if (header.channels == 3 && header.bits == 16) { else if (rawType.getNumBands() == 3 && rawType.getBitsPerBand(0) == 16) { - types.add(ImageTypeSpecifier.createInterleaved(cs, new int[] {2, 1, 0}, DataBuffer.TYPE_USHORT, false, false)); + types.add(ImageTypeSpecifiers.createInterleaved(cs, new int[] {2, 1, 0}, DataBuffer.TYPE_USHORT, false, false)); } // else if (header.channels >= 4 && header.bits == 16) { else if (rawType.getNumBands() >= 4 && rawType.getBitsPerBand(0) == 16) { - types.add(ImageTypeSpecifier.createInterleaved(cs, new int[] {3, 2, 1, 0}, DataBuffer.TYPE_USHORT, true, false)); + types.add(ImageTypeSpecifiers.createInterleaved(cs, new int[] {3, 2, 1, 0}, DataBuffer.TYPE_USHORT, true, false)); } break; case PSD.COLOR_MODE_CMYK: @@ -306,19 +306,19 @@ public final class PSDImageReader extends ImageReaderBase { // Doing this, will require rewriting the image reading, as the raw image data is channelled, not interleaved :-/ // if (header.channels == 4 && header.bits == 8) { if (rawType.getNumBands() == 4 && rawType.getBitsPerBand(0) == 8) { - types.add(ImageTypeSpecifier.createInterleaved(cs, new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, false, false)); + types.add(ImageTypeSpecifiers.createInterleaved(cs, new int[] {3, 2, 1, 0}, DataBuffer.TYPE_BYTE, false, false)); } // else if (header.channels == 5 && header.bits == 8) { else if (rawType.getNumBands() == 5 && rawType.getBitsPerBand(0) == 8) { - types.add(ImageTypeSpecifier.createInterleaved(cs, new int[] {4, 3, 2, 1, 0}, DataBuffer.TYPE_BYTE, true, false)); + types.add(ImageTypeSpecifiers.createInterleaved(cs, new int[] {4, 3, 2, 1, 0}, DataBuffer.TYPE_BYTE, true, false)); } // else if (header.channels == 4 && header.bits == 16) { else if (rawType.getNumBands() == 4 && rawType.getBitsPerBand(0) == 16) { - types.add(ImageTypeSpecifier.createInterleaved(cs, new int[]{3, 2, 1, 0}, DataBuffer.TYPE_USHORT, false, false)); + types.add(ImageTypeSpecifiers.createInterleaved(cs, new int[]{3, 2, 1, 0}, DataBuffer.TYPE_USHORT, false, false)); } // else if (header.channels == 5 && header.bits == 16) { else if (rawType.getNumBands() == 5 && rawType.getBitsPerBand(0) == 16) { - types.add(ImageTypeSpecifier.createInterleaved(cs, new int[] {4, 3, 2, 1, 0}, DataBuffer.TYPE_USHORT, true, false)); + types.add(ImageTypeSpecifiers.createInterleaved(cs, new int[] {4, 3, 2, 1, 0}, DataBuffer.TYPE_USHORT, true, false)); } break; default: @@ -1134,7 +1134,7 @@ public final class PSDImageReader extends ImageReaderBase { offs[i] = 0; } - return ImageTypeSpecifier.createBanded(compositeType.getColorModel().getColorSpace(), indices, offs, compositeType.getSampleModel().getDataType(), true, false); + return ImageTypeSpecifiers.createBanded(compositeType.getColorModel().getColorSpace(), indices, offs, compositeType.getSampleModel().getDataType(), true, false); } } diff --git a/imageio/imageio-sgi/src/main/java/com/twelvemonkeys/imageio/plugins/sgi/SGIImageReader.java b/imageio/imageio-sgi/src/main/java/com/twelvemonkeys/imageio/plugins/sgi/SGIImageReader.java index 08082208..fce75c3f 100755 --- a/imageio/imageio-sgi/src/main/java/com/twelvemonkeys/imageio/plugins/sgi/SGIImageReader.java +++ b/imageio/imageio-sgi/src/main/java/com/twelvemonkeys/imageio/plugins/sgi/SGIImageReader.java @@ -30,6 +30,7 @@ package com.twelvemonkeys.imageio.plugins.sgi; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.util.IIOUtil; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import com.twelvemonkeys.io.enc.DecoderStream; import com.twelvemonkeys.xml.XMLSerializer; @@ -107,9 +108,9 @@ public final class SGIImageReader extends ImageReaderBase { switch (header.getBytesPerPixel()) { case 1: - return ImageTypeSpecifier.createBanded(cs, createIndices(channels, 1), createIndices(channels, 0), DataBuffer.TYPE_BYTE, channels == 2 || channels == 4, false); + return ImageTypeSpecifiers.createBanded(cs, createIndices(channels, 1), createIndices(channels, 0), DataBuffer.TYPE_BYTE, channels == 2 || channels == 4, false); case 2: - return ImageTypeSpecifier.createBanded(cs, createIndices(channels, 1), createIndices(channels, 0), DataBuffer.TYPE_USHORT, channels == 2 || channels == 4, false); + return ImageTypeSpecifiers.createBanded(cs, createIndices(channels, 1), createIndices(channels, 0), DataBuffer.TYPE_USHORT, channels == 2 || channels == 4, false); default: throw new IIOException("Unknown number of bytes per pixel: " + header.getBytesPerPixel()); } diff --git a/imageio/imageio-tga/src/main/java/com/twelvemonkeys/imageio/plugins/tga/TGAImageReader.java b/imageio/imageio-tga/src/main/java/com/twelvemonkeys/imageio/plugins/tga/TGAImageReader.java index ca8c6329..71caa4ed 100755 --- a/imageio/imageio-tga/src/main/java/com/twelvemonkeys/imageio/plugins/tga/TGAImageReader.java +++ b/imageio/imageio-tga/src/main/java/com/twelvemonkeys/imageio/plugins/tga/TGAImageReader.java @@ -30,7 +30,7 @@ package com.twelvemonkeys.imageio.plugins.tga; import com.twelvemonkeys.imageio.ImageReaderBase; import com.twelvemonkeys.imageio.util.IIOUtil; -import com.twelvemonkeys.imageio.util.IndexedImageTypeSpecifier; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import com.twelvemonkeys.io.LittleEndianDataInputStream; import com.twelvemonkeys.io.enc.DecoderStream; import com.twelvemonkeys.xml.XMLSerializer; @@ -107,22 +107,22 @@ public final class TGAImageReader extends ImageReaderBase { case TGA.IMAGETYPE_COLORMAPPED_RLE: case TGA.IMAGETYPE_COLORMAPPED_HUFFMAN: case TGA.IMAGETYPE_COLORMAPPED_HUFFMAN_QUADTREE: - return IndexedImageTypeSpecifier.createFromIndexColorModel(header.getColorMap()); + return ImageTypeSpecifiers.createFromIndexColorModel(header.getColorMap()); case TGA.IMAGETYPE_MONOCHROME: case TGA.IMAGETYPE_MONOCHROME_RLE: - return ImageTypeSpecifier.createGrayscale(1, DataBuffer.TYPE_BYTE, false); + return ImageTypeSpecifiers.createGrayscale(1, DataBuffer.TYPE_BYTE, false); case TGA.IMAGETYPE_TRUECOLOR: case TGA.IMAGETYPE_TRUECOLOR_RLE: ColorSpace sRGB = ColorSpace.getInstance(ColorSpace.CS_sRGB); switch (header.getPixelDepth()) { case 16: - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_USHORT_555_RGB); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_USHORT_555_RGB); case 24: - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); case 32: // 4BYTE_BGRA... - return ImageTypeSpecifier.createInterleaved(sRGB, new int[] {2, 1, 0, 3}, DataBuffer.TYPE_BYTE, true, false); + return ImageTypeSpecifiers.createInterleaved(sRGB, new int[] {2, 1, 0, 3}, DataBuffer.TYPE_BYTE, true, false); default: throw new IIOException("Unknown pixel depth for truecolor: " + header.getPixelDepth()); } @@ -162,7 +162,7 @@ public final class TGAImageReader extends ImageReaderBase { int imageType = header.getImageType(); // Wrap input if RLE encoded. - // NOTE: As early sepcs said it was ok to compress across boundaries, we need to support that. + // NOTE: As early specs said it was ok to compress across boundaries, we need to support that. DataInput input; if (imageType == TGA.IMAGETYPE_COLORMAPPED_RLE || imageType == TGA.IMAGETYPE_TRUECOLOR_RLE || imageType == TGA.IMAGETYPE_MONOCHROME_RLE) { input = new LittleEndianDataInputStream(new DecoderStream(IIOUtil.createStreamAdapter(imageInput), new RLEDecoder(header.getPixelDepth()))); diff --git a/imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageReader.java b/imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageReader.java index a2715793..8560feea 100755 --- a/imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageReader.java +++ b/imageio/imageio-tiff/src/main/java/com/twelvemonkeys/imageio/plugins/tiff/TIFFImageReader.java @@ -41,7 +41,7 @@ import com.twelvemonkeys.imageio.metadata.jpeg.JPEG; import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream; import com.twelvemonkeys.imageio.stream.SubImageInputStream; import com.twelvemonkeys.imageio.util.IIOUtil; -import com.twelvemonkeys.imageio.util.IndexedImageTypeSpecifier; +import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers; import com.twelvemonkeys.imageio.util.ProgressListenerBase; import com.twelvemonkeys.io.FastByteArrayOutputStream; import com.twelvemonkeys.io.LittleEndianDataInputStream; @@ -121,7 +121,7 @@ public class TIFFImageReader extends ImageReaderBase { // http://download.java.net/media/jai-imageio/javadoc/1.1/com/sun/media/imageio/plugins/tiff/package-summary.html#ImageMetadata // TODOs Extension support - // TODO: Support PlanarConfiguration 2 + // TODO: Support PlanarConfiguration 2, look at PCXImageReader // TODO: Auto-rotate based on Orientation // TODO: Support ICCProfile (fully) // TODO: Support Compression 3 & 4 (CCITT T.4 & T.6) @@ -266,10 +266,10 @@ public class TIFFImageReader extends ImageReaderBase { cs = profile == null ? ColorSpace.getInstance(ColorSpace.CS_GRAY) : ColorSpaces.createColorSpace(profile); if (cs == ColorSpace.getInstance(ColorSpace.CS_GRAY) && (bitsPerSample == 1 || bitsPerSample == 2 || bitsPerSample == 4 || bitsPerSample == 8 || bitsPerSample == 16)) { - return ImageTypeSpecifier.createGrayscale(bitsPerSample, dataType, false); + return ImageTypeSpecifiers.createGrayscale(bitsPerSample, dataType, false); } else if (bitsPerSample == 1 || bitsPerSample == 2 || bitsPerSample == 4 || bitsPerSample == 8 || bitsPerSample == 16 || bitsPerSample == 32) { - return ImageTypeSpecifier.createInterleaved(cs, new int[] {0}, dataType, false, false); + return ImageTypeSpecifiers.createInterleaved(cs, new int[] {0}, dataType, false, false); } default: // TODO: If ExtraSamples is used, PlanarConfiguration must be taken into account also for gray data @@ -291,34 +291,34 @@ public class TIFFImageReader extends ImageReaderBase { switch (samplesPerPixel) { case 3: - if (bitsPerSample == 8 || bitsPerSample == 16) { + if (bitsPerSample == 8 || bitsPerSample == 16 || bitsPerSample == 32) { switch (planarConfiguration) { case TIFFBaseline.PLANARCONFIG_CHUNKY: if (bitsPerSample == 8 && cs.isCS_sRGB()) { - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR); } - return ImageTypeSpecifier.createInterleaved(cs, new int[] {0, 1, 2}, dataType, false, false); + return ImageTypeSpecifiers.createInterleaved(cs, new int[] {0, 1, 2}, dataType, false, false); case TIFFExtension.PLANARCONFIG_PLANAR: - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2}, new int[] {0, 0, 0}, dataType, false, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2}, new int[] {0, 0, 0}, dataType, false, false); } } case 4: - if (bitsPerSample == 8 || bitsPerSample == 16) { + if (bitsPerSample == 8 || bitsPerSample == 16 || bitsPerSample == 32) { // ExtraSamples 0=unspecified, 1=associated (pre-multiplied), 2=unassociated (TODO: Support unspecified, not alpha) long[] extraSamples = getValueAsLongArray(TIFF.TAG_EXTRA_SAMPLES, "ExtraSamples", true); switch (planarConfiguration) { case TIFFBaseline.PLANARCONFIG_CHUNKY: if (bitsPerSample == 8 && cs.isCS_sRGB()) { - return ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR); + return ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_4BYTE_ABGR); } - return ImageTypeSpecifier.createInterleaved(cs, new int[] {0, 1, 2, 3}, dataType, true, extraSamples[0] == 1); + return ImageTypeSpecifiers.createInterleaved(cs, new int[]{ 0, 1, 2, 3}, dataType, true, extraSamples[0] == 1); case TIFFExtension.PLANARCONFIG_PLANAR: - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, dataType, true, extraSamples[0] == 1); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, dataType, true, extraSamples[0] == 1); } } // TODO: More samples might be ok, if multiple alpha or unknown samples @@ -342,7 +342,7 @@ public class TIFFImageReader extends ImageReaderBase { IndexColorModel icm = createIndexColorModel(bitsPerSample, dataType, (int[]) colorMap.getValue()); - return IndexedImageTypeSpecifier.createFromIndexColorModel(icm); + return ImageTypeSpecifiers.createFromIndexColorModel(icm); case TIFFExtension.PHOTOMETRIC_SEPARATED: // Separated (CMYK etc) @@ -369,9 +369,9 @@ public class TIFFImageReader extends ImageReaderBase { if (bitsPerSample == 8 || bitsPerSample == 16) { switch (planarConfiguration) { case TIFFBaseline.PLANARCONFIG_CHUNKY: - return ImageTypeSpecifier.createInterleaved(cs, new int[] {0, 1, 2, 3}, dataType, false, false); + return ImageTypeSpecifiers.createInterleaved(cs, new int[] {0, 1, 2, 3}, dataType, false, false); case TIFFExtension.PLANARCONFIG_PLANAR: - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, dataType, false, false); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3}, new int[] {0, 0, 0, 0}, dataType, false, false); } } case 5: @@ -381,9 +381,9 @@ public class TIFFImageReader extends ImageReaderBase { switch (planarConfiguration) { case TIFFBaseline.PLANARCONFIG_CHUNKY: - return ImageTypeSpecifier.createInterleaved(cs, new int[] {0, 1, 2, 3, 4}, dataType, true, extraSamples[0] == 1); + return ImageTypeSpecifiers.createInterleaved(cs, new int[] {0, 1, 2, 3, 4}, dataType, true, extraSamples[0] == 1); case TIFFExtension.PLANARCONFIG_PLANAR: - return ImageTypeSpecifier.createBanded(cs, new int[] {0, 1, 2, 3, 4}, new int[] {0, 0, 0, 0, 0}, dataType, true, extraSamples[0] == 1); + return ImageTypeSpecifiers.createBanded(cs, new int[] {0, 1, 2, 3, 4}, new int[] {0, 0, 0, 0, 0}, dataType, true, extraSamples[0] == 1); } } @@ -1443,7 +1443,7 @@ public class TIFFImageReader extends ImageReaderBase { new XMLSerializer(System.out, "UTF-8").serialize(metadata.getAsTree(metadata.getNativeMetadataFormatName()), false); } -// System.err.println("image: " + image); + System.err.println("image: " + image); // File tempFile = File.createTempFile("lzw-", ".bin"); // byte[] data = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();