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 PackedColorModel from a color mask array, which specifies which bits in an int pixel representation contain each of the color samples, and an alpha mask. Color components are in the specified ColorSpace. The length of colorMaskArray should be the number of components in the ColorSpace. All of the bits in each mask must be contiguous and fit in the specified number of least significant bits of an int pixel representation. If the alphaMask is 0, there is no alpha. If there is alpha, the boolean isAlphaPremultiplied specifies how to interpret color and alpha samples in pixel values. If the boolean is true, color samples are assumed to have been multiplied by the alpha sample. The transparency, 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.

Parameters:

space - the specified ColorSpace

bits - the number of bits in the pixel values

colorMaskArray - array that specifies the masks representing the bits of the pixel values that represent the color components

alphaMask - specifies the mask representing the bits of the pixel values that represent the alpha component

isAlphaPremultiplied - true if color samples are premultiplied by the alpha sample; false otherwise

trans - specifies the alpha value that can be represented by this color model

transferType - the type of array used to represent pixel values

Throws:

IllegalArgumentException - if bits is less than 1 or greater than 32

 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;
            }
        }
}

Constructs a PackedColorModel from the specified masks which indicate which bits in an int pixel representation contain the alpha, red, green and blue color samples. Color components are in the specified 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 int pixel representation. If amask is 0, there is no alpha. If there is alpha, the boolean isAlphaPremultiplied specifies how to interpret color and alpha samples in pixel values. If the boolean is true, color samples are assumed to have been multiplied by the alpha sample. The transparency, 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.

Parameters:

space - the specified ColorSpace

bits - the number of bits in the pixel values

rmask - specifies the mask representing the bits of the pixel values that represent the red color component

gmask - specifies the mask representing the bits of the pixel values that represent the green color component

bmask - specifies the mask representing the bits of the pixel values that represent the blue color component

amask - specifies the mask representing the bits of the pixel values that represent the alpha component

isAlphaPremultiplied - true if color samples are premultiplied by the alpha sample; false otherwise

trans - specifies the alpha value that can be represented by this color model

transferType - the type of array used to represent pixel values

Throws:

IllegalArgumentException - if space is not a TYPE_RGB space

Also see:

ColorSpace

 public SampleModel createCompatibleSampleModel(int w,
    int h) 
{
        return new SinglePixelPackedSampleModel(transferType, w, h,
                                                maskArray);
}

Creates a SampleModel with the specified width and height that has a data layout compatible with this ColorModel.

 public boolean equals(Object obj) 
{
        if (!(obj instanceof PackedColorModel)) {
            return false;
        }
        if (!super.equals(obj)) {
            return false;
        }
        PackedColorModel cm = (PackedColorModel) obj;
        int numC = cm.getNumComponents();
        if (numC != numComponents) {
            return false;
        }
        for(int i=0; i <  numC; i++) {
            if (maskArray[i] != cm.getMask(i)) {
                return false;
            }
        }
        return true;
}

Tests if the specified Object is an instance of PackedColorModel and equals this PackedColorModel.

 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);
}

Returns a WritableRaster representing the alpha channel of an image, extracted from the input WritableRaster. This method assumes that WritableRaster objects associated with this ColorModel store the alpha band, if present, as the last band of image data. Returns null if there is no separate spatial alpha channel associated with this ColorModel. This method creates a new WritableRaster, but shares the data array.

 public final int getMask(int index) 
{
        return maskArray[index];
}

Returns the mask indicating which bits in a pixel contain the specified color/alpha sample. For color samples, index corresponds to the placement of color sample names in the color space. Thus, an index equal to 0 for a CMYK ColorSpace would correspond to Cyan and an index equal to 1 would correspond to Magenta. If there is alpha, the alpha index would be:

alphaIndex = numComponents() - 1;

 public final int[] getMasks() 
{
        return (int[]) maskArray.clone();
}

Returns a mask array indicating which bits in a pixel contain the color and alpha samples.

 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;
        }
        for (int i=0; i <  bitMasks.length; i++) {
            if (bitMasks[i] != maskArray[i]) {
                return false;
            }
        }
        return true;
}

Checks if the specified SampleModel is compatible with this ColorModel. If sm is null, this method returns false.