mirror of
https://github.com/haraldk/TwelveMonkeys.git
synced 2026-04-30 00:00:01 -04:00
TMI-81: Support for 32 bit unsigned int color model.
Bonus: Cleaned up creation of ImageTypeSpecifiers and added tests.
This commit is contained in:
Harald Kuhr
+106
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
+583
@@ -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;
|
||||
}
|
||||
}
|
||||
imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/IndexedImageTypeSpecifierTest.java
Executable
+82
@@ -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 <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
|
||||
* @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());
|
||||
}
|
||||
}
|
||||
-28
@@ -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 <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
|
||||
* @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));
|
||||
}
|
||||
}
|
||||
+199
@@ -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());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user