* The translation from pixel values to color/alpha components for * display or processing purposes is a one-to-one correspondence of * samples to components. * A {@code PackedColorModel} is typically used with image data * that uses masks to define packed samples. For example, a * {@code PackedColorModel} can be used in conjunction with a * {@link SinglePixelPackedSampleModel} to construct a * {@link BufferedImage}. Normally the masks used by the * {@link SampleModel} and the {@code ColorModel} would be the same. * However, if they are different, the color interpretation of pixel data is * done according to the masks of the {@code ColorModel}. *
* A single {@code int} pixel representation is valid for all objects * of this class since it is always possible to represent pixel values * used with this class in a single {@code int}. Therefore, methods * that use this representation do not throw an * {@code IllegalArgumentException} due to an invalid pixel value. *
* A subclass of {@code PackedColorModel} is {@link DirectColorModel}, * which is similar to an X11 TrueColor visual. * * @see DirectColorModel * @see SinglePixelPackedSampleModel * @see BufferedImage */ public abstract class PackedColorModel extends ColorModel { int[] maskArray; int[] maskOffsets; float[] scaleFactors; /** * Constructs a {@code PackedColorModel} from a color mask array, * which specifies which bits in an {@code int} pixel representation * contain each of the color samples, and an alpha mask. Color * components are in the specified {@code ColorSpace}. The length of * {@code colorMaskArray} should be the number of components in * the {@code ColorSpace}. All of the bits in each mask * must be contiguous and fit in the specified number of least significant * bits of an {@code int} pixel representation. If the * {@code alphaMask} is 0, there is no alpha. If there is alpha, * the {@code boolean isAlphaPremultiplied} specifies * how to interpret color and alpha samples in pixel values. If the * {@code boolean} is {@code true}, color samples are assumed * to have been multiplied by the alpha sample. The transparency, * {@code trans}, specifies what alpha values can be represented * by this color model. The transfer type is the type of primitive * array used to represent pixel values. * @param space the specified {@code ColorSpace} * @param bits the number of bits in the pixel values * @param colorMaskArray array that specifies the masks representing * the bits of the pixel values that represent the color * components * @param alphaMask specifies the mask representing * the bits of the pixel values that represent the alpha * component * @param isAlphaPremultiplied {@code true} if color samples are * premultiplied by the alpha sample; {@code false} otherwise * @param trans specifies the alpha value that can be represented by * this color model * @param transferType the type of array used to represent pixel values * @throws IllegalArgumentException if {@code bits} is less than * 1 or greater than 32 */ public PackedColorModel (ColorSpace space, int bits, int[] colorMaskArray, int alphaMask, boolean isAlphaPremultiplied, int trans, int transferType) { super(bits, PackedColorModel.createBitsArray(colorMaskArray, alphaMask), space, (alphaMask == 0 ? false : true), isAlphaPremultiplied, trans, transferType); if (bits < 1 || bits > 32) { throw new IllegalArgumentException("Number of bits must be between" +" 1 and 32."); } maskArray = new int[numComponents]; maskOffsets = new int[numComponents]; scaleFactors = new float[numComponents]; for (int i=0; i < numColorComponents; i++) { // Get the mask offset and #bits DecomposeMask(colorMaskArray[i], i, space.getName(i)); } if (alphaMask != 0) { DecomposeMask(alphaMask, numColorComponents, "alpha"); if (nBits[numComponents-1] == 1) { transparency = Transparency.BITMASK; } } } /** * Constructs a {@code PackedColorModel} from the specified * masks which indicate which bits in an {@code int} pixel * representation contain the alpha, red, green and blue color samples. * Color components are in the specified {@code ColorSpace}, which * must be of type ColorSpace.TYPE_RGB. All of the bits in each * mask must be contiguous and fit in the specified number of * least significant bits of an {@code int} pixel representation. If * {@code amask} is 0, there is no alpha. If there is alpha, * the {@code boolean isAlphaPremultiplied} * specifies how to interpret color and alpha samples * in pixel values. If the {@code boolean} is {@code true}, * color samples are assumed to have been multiplied by the alpha sample. * The transparency, {@code trans}, specifies what alpha values * can be represented by this color model. * The transfer type is the type of primitive array used to represent * pixel values. * @param space the specified {@code ColorSpace} * @param bits the number of bits in the pixel values * @param rmask specifies the mask representing * the bits of the pixel values that represent the red * color component * @param gmask specifies the mask representing * the bits of the pixel values that represent the green * color component * @param bmask specifies the mask representing * the bits of the pixel values that represent * the blue color component * @param amask specifies the mask representing * the bits of the pixel values that represent * the alpha component * @param isAlphaPremultiplied {@code true} if color samples are * premultiplied by the alpha sample; {@code false} otherwise * @param trans specifies the alpha value that can be represented by * this color model * @param transferType the type of array used to represent pixel values * @throws IllegalArgumentException if {@code space} is not a * TYPE_RGB space * @see ColorSpace */ public PackedColorModel(ColorSpace space, int bits, int rmask, int gmask, int bmask, int amask, boolean isAlphaPremultiplied, int trans, int transferType) { super (bits, PackedColorModel.createBitsArray(rmask, gmask, bmask, amask), space, (amask == 0 ? false : true), isAlphaPremultiplied, trans, transferType); if (space.getType() != ColorSpace.TYPE_RGB) { throw new IllegalArgumentException("ColorSpace must be TYPE_RGB."); } maskArray = new int[numComponents]; maskOffsets = new int[numComponents]; scaleFactors = new float[numComponents]; DecomposeMask(rmask, 0, "red"); DecomposeMask(gmask, 1, "green"); DecomposeMask(bmask, 2, "blue"); if (amask != 0) { DecomposeMask(amask, 3, "alpha"); if (nBits[3] == 1) { transparency = Transparency.BITMASK; } } } /** * Returns the mask indicating which bits in a pixel * contain the specified color/alpha sample. For color * samples, {@code index} corresponds to the placement of color * sample names in the color space. Thus, an {@code index} * equal to 0 for a CMYK ColorSpace would correspond to * Cyan and an {@code index} equal to 1 would correspond to * Magenta. If there is alpha, the alpha {@code index} would be: *
* alphaIndex = numComponents() - 1;
*
* @param index the specified color or alpha sample
* @return the mask, which indicates which bits of the {@code int}
* pixel representation contain the color or alpha sample specified
* by {@code index}.
* @throws ArrayIndexOutOfBoundsException if {@code index} is
* greater than the number of components minus 1 in this
* {@code PackedColorModel} or if {@code index} is
* less than zero
*/
public final int getMask(int index) {
return maskArray[index];
}
/**
* Returns a mask array indicating which bits in a pixel
* contain the color and alpha samples.
* @return the mask array , which indicates which bits of the
* {@code int} pixel
* representation contain the color or alpha samples.
*/
public final int[] getMasks() {
return maskArray.clone();
}
/*
* A utility function to compute the mask offset and scalefactor,
* store these and the mask in instance arrays, and verify that
* the mask fits in the specified pixel size.
*/
private void DecomposeMask(int mask, int idx, String componentName) {
int off = 0;
int count = nBits[idx];
// Store the mask
maskArray[idx] = mask;
// Now find the shift
if (mask != 0) {
while ((mask & 1) == 0) {
mask >>>= 1;
off++;
}
}
if (off + count > pixel_bits) {
throw new IllegalArgumentException(componentName + " mask "+
Integer.toHexString(maskArray[idx])+
" overflows pixel (expecting "+
pixel_bits+" bits");
}
maskOffsets[idx] = off;
if (count == 0) {
// High enough to scale any 0-ff value down to 0.0, but not
// high enough to get Infinity when scaling back to pixel bits
scaleFactors[idx] = 256.0f;
} else {
scaleFactors[idx] = 255.0f / ((1 << count) - 1);
}
}
/**
* Creates a {@code SampleModel} with the specified width and
* height that has a data layout compatible with this
* {@code ColorModel}.
* @param w the width (in pixels) of the region of the image data
* described
* @param h the height (in pixels) of the region of the image data
* described
* @return the newly created {@code SampleModel}.
* @throws IllegalArgumentException if {@code w} or
* {@code h} is not greater than 0
* @see SampleModel
*/
public SampleModel createCompatibleSampleModel(int w, int h) {
return new SinglePixelPackedSampleModel(transferType, w, h,
maskArray);
}
/**
* Checks if the specified {@code SampleModel} is compatible
* with this {@code ColorModel}. If {@code sm} is
* {@code null}, this method returns {@code false}.
* @param sm the specified {@code SampleModel},
* or {@code null}
* @return {@code true} if the specified {@code SampleModel}
* is compatible with this {@code ColorModel};
* {@code false} otherwise.
* @see SampleModel
*/
public boolean isCompatibleSampleModel(SampleModel sm) {
if (! (sm instanceof SinglePixelPackedSampleModel)) {
return false;
}
// Must have the same number of components
if (numComponents != sm.getNumBands()) {
return false;
}
// Transfer type must be the same
if (sm.getTransferType() != transferType) {
return false;
}
SinglePixelPackedSampleModel sppsm = (SinglePixelPackedSampleModel) sm;
// Now compare the specific masks
int[] bitMasks = sppsm.getBitMasks();
if (bitMasks.length != maskArray.length) {
return false;
}
/* compare 'effective' masks only, i.e. only part of the mask
* which fits the capacity of the transfer type.
*/
int maxMask = (int)((1L << DataBuffer.getDataTypeSize(transferType)) - 1);
for (int i=0; i < bitMasks.length; i++) {
if ((maxMask & bitMasks[i]) != (maxMask & maskArray[i])) {
return false;
}
}
return true;
}
/**
* Returns a {@link WritableRaster} representing the alpha channel of
* an image, extracted from the input {@code WritableRaster}.
* This method assumes that {@code WritableRaster} objects
* associated with this {@code ColorModel} store the alpha band,
* if present, as the last band of image data. Returns {@code null}
* if there is no separate spatial alpha channel associated with this
* {@code ColorModel}. This method creates a new
* {@code WritableRaster}, but shares the data array.
* @param raster a {@code WritableRaster} containing an image
* @return a {@code WritableRaster} that represents the alpha
* channel of the image contained in {@code raster}.
*/
public WritableRaster getAlphaRaster(WritableRaster raster) {
if (hasAlpha() == false) {
return null;
}
int x = raster.getMinX();
int y = raster.getMinY();
int[] band = new int[1];
band[0] = raster.getNumBands() - 1;
return raster.createWritableChild(x, y, raster.getWidth(),
raster.getHeight(), x, y,
band);
}
/**
* Tests if the specified {@code Object} is an instance
* of {@code PackedColorModel} and equals this
* {@code PackedColorModel}.
* @param obj the {@code Object} to test for equality
* @return {@code true} if the specified {@code Object}
* is an instance of {@code PackedColorModel} and equals this
* {@code PackedColorModel}; {@code false} otherwise.
*/
@Override
public boolean equals(Object obj) {
PackedColorModel cm = (PackedColorModel) obj;
if (this == cm) {
return true;
}
if (!super.equals(obj)) {
return false;
}
int numC = cm.getNumComponents();
for(int i=0; i < numC; i++) {
if (maskArray[i] != cm.getMask(i)) {
return false;
}
}
return true;
}
/**
* Returns the hash code for this PackedColorModel.
*
* @return a hash code for this PackedColorModel.
*/
@Override
public int hashCode() {
int hash = 3;
hash = 89 * hash + super.hashCode();
hash = 89 * hash + Arrays.hashCode(this.maskArray);
return hash;
}
private static final int[] createBitsArray(int[]colorMaskArray,
int alphaMask) {
int numColors = colorMaskArray.length;
int numAlpha = (alphaMask == 0 ? 0 : 1);
int[] arr = new int[numColors+numAlpha];
for (int i=0; i < numColors; i++) {
arr[i] = countBits(colorMaskArray[i]);
if (arr[i] < 0) {
throw new IllegalArgumentException("Noncontiguous color mask ("
+ Integer.toHexString(colorMaskArray[i])+
"at index "+i);
}
}
if (alphaMask != 0) {
arr[numColors] = countBits(alphaMask);
if (arr[numColors] < 0) {
throw new IllegalArgumentException("Noncontiguous alpha mask ("
+ Integer.toHexString(alphaMask));
}
}
return arr;
}
private static final int[] createBitsArray(int rmask, int gmask, int bmask,
int amask) {
int[] arr = new int[3 + (amask == 0 ? 0 : 1)];
arr[0] = countBits(rmask);
arr[1] = countBits(gmask);
arr[2] = countBits(bmask);
if (arr[0] < 0) {
throw new IllegalArgumentException("Noncontiguous red mask ("
+ Integer.toHexString(rmask));
}
else if (arr[1] < 0) {
throw new IllegalArgumentException("Noncontiguous green mask ("
+ Integer.toHexString(gmask));
}
else if (arr[2] < 0) {
throw new IllegalArgumentException("Noncontiguous blue mask ("
+ Integer.toHexString(bmask));
}
if (amask != 0) {
arr[3] = countBits(amask);
if (arr[3] < 0) {
throw new IllegalArgumentException("Noncontiguous alpha mask ("
+ Integer.toHexString(amask));
}
}
return arr;
}
private static final int countBits(int mask) {
int count = 0;
if (mask != 0) {
while ((mask & 1) == 0) {
mask >>>= 1;
}
while ((mask & 1) == 1) {
mask >>>= 1;
count++;
}
}
if (mask != 0) {
return -1;
}
return count;
}
}