class that works with pixel values consisting of a
single sample that is an index into a fixed colormap in the default
sRGB color space. The colormap specifies red, green, blue, and
optional alpha components corresponding to each index. All components
are represented in the colormap as 8-bit unsigned integral values.
Some constructors allow the caller to specify "holes" in the colormap
by indicating which colormap entries are valid and which represent
unusable colors via the bits set in a
Some constructors provide a means to specify an alpha component
for each pixel in the colormap, while others either provide no
such means or, in some cases, a flag to indicate whether the
colormap data contains alpha values. If no alpha is supplied to
the constructor, an opaque alpha component (alpha = 1.0) is
assumed for each entry.
An optional transparent pixel value can be supplied that indicates a
pixel to be made completely transparent, regardless of any alpha
component supplied or assumed for that pixel value.
Note that the color components in the colormap of an
IndexColorModel objects are never pre-multiplied with
the alpha components.
| Constructor: |
|---|
 public IndexColorModel(int bits,
int size,
byte[] r,
byte[] g,
byte[] b) {
super(bits, opaqueBits,
ColorSpace.getInstance(ColorSpace.CS_sRGB),
false, false, OPAQUE,
ColorModel.getDefaultTransferType(bits));
if (bits < 1 || bits > 16) {
throw new IllegalArgumentException("Number of bits must be between"
+" 1 and 16.");
}
setRGBs(size, r, g, b, null);
calculatePixelMask();
}
Constructs an IndexColorModel from the specified
arrays of red, green, and blue components. Pixels described
by this color model all have alpha components of 255
unnormalized (1.0 normalized), which means they
are fully opaque. All of the arrays specifying the color
components must have at least the specified number of entries.
The ColorSpace is the default sRGB space.
Since there is no alpha information in any of the arguments
to this constructor, the transparency value is always
Transparency.OPAQUE.
The transfer type is the smallest of DataBuffer.TYPE_BYTE
or DataBuffer.TYPE_USHORT that can hold a single pixel. Parameters:
bits - the number of bits each pixel occupies
size - the size of the color component arrays
r - the array of red color components
g - the array of green color components
b - the array of blue color components
IllegalArgumentException - if bits is less
than 1 or greater than 16
IllegalArgumentException - if size is less
than 1
|
public IndexColorModel(int bits,
int size,
byte[] cmap,
int start,
boolean hasalpha) {
this(bits, size, cmap, start, hasalpha, -1);
if (bits < 1 || bits > 16) {
throw new IllegalArgumentException("Number of bits must be between"
+" 1 and 16.");
}
} Constructs an IndexColorModel from a single
array of interleaved red, green, blue and optional alpha
components. The array must have enough values in it to
fill all of the needed component arrays of the specified
size. The ColorSpace is the default sRGB space.
The transparency value may be any of Transparency.OPAQUE,
Transparency.BITMASK,
or Transparency.TRANSLUCENT
depending on the arguments, as specified
in the class description above.
The transfer type is the smallest of
DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT
that can hold a single pixel. Parameters:
bits - the number of bits each pixel occupies
size - the size of the color component arrays
cmap - the array of color components
start - the starting offset of the first color component
hasalpha - indicates whether alpha values are contained in
the cmap array
IllegalArgumentException - if bits is less
than 1 or greater than 16
IllegalArgumentException - if size is less
than 1
|
public IndexColorModel(int bits,
int size,
byte[] r,
byte[] g,
byte[] b,
int trans) {
super(bits, opaqueBits,
ColorSpace.getInstance(ColorSpace.CS_sRGB),
false, false, OPAQUE,
ColorModel.getDefaultTransferType(bits));
if (bits < 1 || bits > 16) {
throw new IllegalArgumentException("Number of bits must be between"
+" 1 and 16.");
}
setRGBs(size, r, g, b, null);
setTransparentPixel(trans);
calculatePixelMask();
} Constructs an IndexColorModel from the given arrays
of red, green, and blue components. Pixels described by this color
model all have alpha components of 255 unnormalized
(1.0 normalized), which means they are fully opaque, except
for the indicated pixel to be made transparent. All of the arrays
specifying the color components must have at least the specified
number of entries.
The ColorSpace is the default sRGB space.
The transparency value may be Transparency.OPAQUE or
Transparency.BITMASK depending on the arguments, as
specified in the class description above.
The transfer type is the smallest of DataBuffer.TYPE_BYTE
or DataBuffer.TYPE_USHORT that can hold a
single pixel. Parameters:
bits - the number of bits each pixel occupies
size - the size of the color component arrays
r - the array of red color components
g - the array of green color components
b - the array of blue color components
trans - the index of the transparent pixel
IllegalArgumentException - if bits is less than
1 or greater than 16
IllegalArgumentException - if size is less than
1
|
public IndexColorModel(int bits,
int size,
byte[] r,
byte[] g,
byte[] b,
byte[] a) {
super (bits, alphaBits,
ColorSpace.getInstance(ColorSpace.CS_sRGB),
true, false, TRANSLUCENT,
ColorModel.getDefaultTransferType(bits));
if (bits < 1 || bits > 16) {
throw new IllegalArgumentException("Number of bits must be between"
+" 1 and 16.");
}
setRGBs (size, r, g, b, a);
calculatePixelMask();
} Constructs an IndexColorModel from the given
arrays of red, green, blue and alpha components. All of the
arrays specifying the components must have at least the specified
number of entries.
The ColorSpace is the default sRGB space.
The transparency value may be any of Transparency.OPAQUE,
Transparency.BITMASK,
or Transparency.TRANSLUCENT
depending on the arguments, as specified
in the class description above.
The transfer type is the smallest of DataBuffer.TYPE_BYTE
or DataBuffer.TYPE_USHORT that can hold a single pixel. Parameters:
bits - the number of bits each pixel occupies
size - the size of the color component arrays
r - the array of red color components
g - the array of green color components
b - the array of blue color components
a - the array of alpha value components
IllegalArgumentException - if bits is less
than 1 or greater than 16
IllegalArgumentException - if size is less
than 1
|
public IndexColorModel(int bits,
int size,
byte[] cmap,
int start,
boolean hasalpha,
int trans) {
// REMIND: This assumes the ordering: RGB[A]
super(bits, opaqueBits,
ColorSpace.getInstance(ColorSpace.CS_sRGB),
false, false, OPAQUE,
ColorModel.getDefaultTransferType(bits));
if (bits < 1 || bits > 16) {
throw new IllegalArgumentException("Number of bits must be between"
+" 1 and 16.");
}
if (size < 1) {
throw new IllegalArgumentException("Map size ("+size+
") must be >= 1");
}
map_size = size;
rgb = new int[calcRealMapSize(bits, size)];
int j = start;
int alpha = 0xff;
boolean allgray = true;
int transparency = OPAQUE;
for (int i = 0; i < size; i++) {
int r = cmap[j++] & 0xff;
int g = cmap[j++] & 0xff;
int b = cmap[j++] & 0xff;
allgray = allgray && (r == g) && (g == b);
if (hasalpha) {
alpha = cmap[j++] & 0xff;
if (alpha != 0xff) {
if (alpha == 0x00) {
if (transparency == OPAQUE) {
transparency = BITMASK;
}
if (transparent_index < 0) {
transparent_index = i;
}
} else {
transparency = TRANSLUCENT;
}
allgray = false;
}
}
rgb[i] = (alpha < < 24) | (r < < 16) | (g < < 8) | b;
}
this.allgrayopaque = allgray;
setTransparency(transparency);
setTransparentPixel(trans);
calculatePixelMask();
} Constructs an IndexColorModel from a single array of
interleaved red, green, blue and optional alpha components. The
specified transparent index represents a pixel that is made
entirely transparent regardless of any alpha value specified
for it. The array must have enough values in it to fill all
of the needed component arrays of the specified size.
The ColorSpace is the default sRGB space.
The transparency value may be any of Transparency.OPAQUE,
Transparency.BITMASK,
or Transparency.TRANSLUCENT
depending on the arguments, as specified
in the class description above.
The transfer type is the smallest of
DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT
that can hold a single pixel. Parameters:
bits - the number of bits each pixel occupies
size - the size of the color component arrays
cmap - the array of color components
start - the starting offset of the first color component
hasalpha - indicates whether alpha values are contained in
the cmap array
trans - the index of the fully transparent pixel
IllegalArgumentException - if bits is less than
1 or greater than 16
IllegalArgumentException - if size is less than
1
|
public IndexColorModel(int bits,
int size,
int[] cmap,
int start,
int transferType,
BigInteger validBits) {
super (bits, alphaBits,
ColorSpace.getInstance(ColorSpace.CS_sRGB),
true, false, TRANSLUCENT,
transferType);
if (bits < 1 || bits > 16) {
throw new IllegalArgumentException("Number of bits must be between"
+" 1 and 16.");
}
if (size < 1) {
throw new IllegalArgumentException("Map size ("+size+
") must be >= 1");
}
if ((transferType != DataBuffer.TYPE_BYTE) &&
(transferType != DataBuffer.TYPE_USHORT)) {
throw new IllegalArgumentException("transferType must be either" +
"DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT");
}
if (validBits != null) {
// Check to see if it is all valid
for (int i=0; i < size; i++) {
if (!validBits.testBit(i)) {
this.validBits = validBits;
break;
}
}
}
setRGBs(size, cmap, start, true);
calculatePixelMask();
} Constructs an IndexColorModel from an
int array where each int is
comprised of red, green, blue, and alpha
components in the default RGB color model format.
The array must have enough values in it to fill all
of the needed component arrays of the specified size.
The ColorSpace is the default sRGB space.
The transparency value may be any of Transparency.OPAQUE,
Transparency.BITMASK,
or Transparency.TRANSLUCENT
depending on the arguments, as specified
in the class description above.
The transfer type must be one of DataBuffer.TYPE_BYTE
DataBuffer.TYPE_USHORT.
The BigInteger object specifies the valid/invalid pixels
in the cmap array. A pixel is valid if the
BigInteger value at that index is set, and is invalid
if the BigInteger bit at that index is not set. Parameters:
bits - the number of bits each pixel occupies
size - the size of the color component array
cmap - the array of color components
start - the starting offset of the first color component
transferType - the specified data type
validBits - a BigInteger object. If a bit is
set in the BigInteger, the pixel at that index is valid.
If a bit is not set, the pixel at that index
is considered invalid. If null, all pixels are valid.
Only bits from 0 to the map size are considered.
IllegalArgumentException - if bits is less
than 1 or greater than 16
IllegalArgumentException - if size is less
than 1
IllegalArgumentException - if transferType is not
one of DataBuffer.TYPE_BYTE or
DataBuffer.TYPE_USHORT
- since:
1.3 -
|
public IndexColorModel(int bits,
int size,
int[] cmap,
int start,
boolean hasalpha,
int trans,
int transferType) {
// REMIND: This assumes the ordering: RGB[A]
super(bits, opaqueBits,
ColorSpace.getInstance(ColorSpace.CS_sRGB),
false, false, OPAQUE,
transferType);
if (bits < 1 || bits > 16) {
throw new IllegalArgumentException("Number of bits must be between"
+" 1 and 16.");
}
if (size < 1) {
throw new IllegalArgumentException("Map size ("+size+
") must be >= 1");
}
if ((transferType != DataBuffer.TYPE_BYTE) &&
(transferType != DataBuffer.TYPE_USHORT)) {
throw new IllegalArgumentException("transferType must be either" +
"DataBuffer.TYPE_BYTE or DataBuffer.TYPE_USHORT");
}
setRGBs(size, cmap, start, hasalpha);
setTransparentPixel(trans);
calculatePixelMask();
} Constructs an IndexColorModel from an array of
ints where each int is comprised of red, green, blue, and
optional alpha components in the default RGB color model format.
The specified transparent index represents a pixel that is made
entirely transparent regardless of any alpha value specified
for it. The array must have enough values in it to fill all
of the needed component arrays of the specified size.
The ColorSpace is the default sRGB space.
The transparency value may be any of Transparency.OPAQUE,
Transparency.BITMASK,
or Transparency.TRANSLUCENT
depending on the arguments, as specified
in the class description above. Parameters:
bits - the number of bits each pixel occupies
size - the size of the color component arrays
cmap - the array of color components
start - the starting offset of the first color component
hasalpha - indicates whether alpha values are contained in
the cmap array
trans - the index of the fully transparent pixel
transferType - the data type of the array used to represent
pixel values. The data type must be either
DataBuffer.TYPE_BYTE or
DataBuffer.TYPE_USHORT.
IllegalArgumentException - if bits is less
than 1 or greater than 16
IllegalArgumentException - if size is less
than 1
IllegalArgumentException - if transferType is not
one of DataBuffer.TYPE_BYTE or
DataBuffer.TYPE_USHORT
|
| Method from java.awt.image.IndexColorModel Detail: |
|---|
public BufferedImage convertToIntDiscrete(Raster raster,
boolean forceARGB) {
ColorModel cm;
if (!isCompatibleRaster(raster)) {
throw new IllegalArgumentException("This raster is not compatible" +
"with this IndexColorModel.");
}
if (forceARGB || transparency == TRANSLUCENT) {
cm = ColorModel.getRGBdefault();
}
else if (transparency == BITMASK) {
cm = new DirectColorModel(25, 0xff0000, 0x00ff00, 0x0000ff,
0x1000000);
}
else {
cm = new DirectColorModel(24, 0xff0000, 0x00ff00, 0x0000ff);
}
int w = raster.getWidth();
int h = raster.getHeight();
WritableRaster discreteRaster =
cm.createCompatibleWritableRaster(w, h);
Object obj = null;
int[] data = null;
int rX = raster.getMinX();
int rY = raster.getMinY();
for (int y=0; y < h; y++, rY++) {
obj = raster.getDataElements(rX, rY, w, 1, obj);
if (obj instanceof int[]) {
data = (int[])obj;
} else {
data = DataBuffer.toIntArray(obj);
}
for (int x=0; x < w; x++) {
data[x] = rgb[data[x] & pixel_mask];
}
discreteRaster.setDataElements(0, y, w, 1, data);
}
return new BufferedImage(cm, discreteRaster, false, null);
} Returns a new BufferedImage of TYPE_INT_ARGB or
TYPE_INT_RGB that has a Raster with pixel data
computed by expanding the indices in the source Raster
using the color/alpha component arrays of this ColorModel.
Only the lower n bits of each index value in the source
Raster, as specified in the
class description above, are used to
compute the color/alpha values in the returned image.
If forceARGB is true, a TYPE_INT_ARGB image is
returned regardless of whether or not this ColorModel
has an alpha component array or a transparent pixel. |
public SampleModel createCompatibleSampleModel(int w,
int h) {
int[] off = new int[1];
off[0] = 0;
if (pixel_bits == 1 || pixel_bits == 2 || pixel_bits == 4) {
return new MultiPixelPackedSampleModel(transferType, w, h,
pixel_bits);
}
else {
return new ComponentSampleModel(transferType, w, h, 1, w,
off);
}
} Creates a SampleModel with the specified
width and height that has a data layout compatible with
this ColorModel. |
public WritableRaster createCompatibleWritableRaster(int w,
int h) {
WritableRaster raster;
if (pixel_bits == 1 || pixel_bits == 2 || pixel_bits == 4) {
// TYPE_BINARY
raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE,
w, h, 1, pixel_bits, null);
}
else if (pixel_bits < = 8) {
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
w,h,1,null);
}
else if (pixel_bits < = 16) {
raster = Raster.createInterleavedRaster(DataBuffer.TYPE_USHORT,
w,h,1,null);
}
else {
throw new
UnsupportedOperationException("This method is not supported "+
" for pixel bits > 16.");
}
return raster;
} Creates a WritableRaster with the specified width
and height that has a data layout (SampleModel)
compatible with this ColorModel. This method
only works for color models with 16 or fewer bits per pixel.
Since IndexColorModel can be subclassed, any
subclass that supports greater than 16 bits per pixel must
override this method. |
public void finalize() {
} Disposes of system resources associated with this
ColorModel once this ColorModel is no
longer referenced. |
public final int getAlpha(int pixel) {
return (rgb[pixel & pixel_mask] > > 24) & 0xff;
} Returns the alpha component for the specified pixel, scaled
from 0 to 255. The pixel value is specified as an int.
Only the lower n bits of the pixel value, as specified in the
class description above, are used to
calculate the returned value. |
public final void getAlphas(byte[] a) {
for (int i = 0; i < map_size; i++) {
a[i] = (byte) (rgb[i] > > 24);
}
} Copies the array of alpha transparency components into the
specified array. Only the initial entries of the array as specified
by getMapSize are written. |
public final int getBlue(int pixel) {
return rgb[pixel & pixel_mask] & 0xff;
} Returns the blue color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. The pixel value
is specified as an int.
Only the lower n bits of the pixel value, as specified in the
class description above, are used to
calculate the returned value.
The returned value is a non pre-multiplied value. |
public final void getBlues(byte[] b) {
for (int i = 0; i < map_size; i++) {
b[i] = (byte) rgb[i];
}
} Copies the array of blue color components into the specified array.
Only the initial entries of the array as specified by
getMapSize are written. |
public int[] getComponentSize() {
if (nBits == null) {
if (supportsAlpha) {
nBits = new int[4];
nBits[3] = 8;
}
else {
nBits = new int[3];
}
nBits[0] = nBits[1] = nBits[2] = 8;
}
return nBits.clone();
} Returns an array of the number of bits for each color/alpha component.
The array contains the color components in the order red, green,
blue, followed by the alpha component, if present. |
public int[] getComponents(int pixel,
int[] components,
int offset) {
if (components == null) {
components = new int[offset+numComponents];
}
// REMIND: Needs to change if different color space
components[offset+0] = getRed(pixel);
components[offset+1] = getGreen(pixel);
components[offset+2] = getBlue(pixel);
if (supportsAlpha && (components.length-offset) > 3) {
components[offset+3] = getAlpha(pixel);
}
return components;
} Returns an array of unnormalized color/alpha components for a
specified pixel in this ColorModel. The pixel value
is specified as an int. If the components array is null,
a new array is allocated that contains
offset + getNumComponents() elements.
The components array is returned,
with the alpha component included
only if hasAlpha returns true.
Color/alpha components are stored in the components array starting
at offset even if the array is allocated by this method.
An ArrayIndexOutOfBoundsException
is thrown if the components array is not null and is
not large enough to hold all the color and alpha components
starting at offset. |
public int[] getComponents(Object pixel,
int[] components,
int offset) {
int intpixel;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte bdata[] = (byte[])pixel;
intpixel = bdata[0] & 0xff;
break;
case DataBuffer.TYPE_USHORT:
short sdata[] = (short[])pixel;
intpixel = sdata[0] & 0xffff;
break;
case DataBuffer.TYPE_INT:
int idata[] = (int[])pixel;
intpixel = idata[0];
break;
default:
throw new UnsupportedOperationException("This method has not been "+
"implemented for transferType " + transferType);
}
return getComponents(intpixel, components, offset);
} Returns an array of unnormalized color/alpha components for
a specified pixel in this ColorModel. The pixel
value is specified by an array of data elements of type
transferType passed in as an object reference.
If pixel is not a primitive array of type
transferType, a ClassCastException
is thrown. An ArrayIndexOutOfBoundsException
is thrown if pixel is not large enough to hold
a pixel value for this ColorModel. If the
components array is null, a new array
is allocated that contains
offset + getNumComponents() elements.
The components array is returned,
with the alpha component included
only if hasAlpha returns true.
Color/alpha components are stored in the components
array starting at offset even if the array is
allocated by this method. An
ArrayIndexOutOfBoundsException is also
thrown if the components array is not
null and is not large enough to hold all the color
and alpha components starting at offset.
Since IndexColorModel can be subclassed, subclasses
inherit the implementation of this method and if they don't
override it then they throw an exception if they use an
unsupported transferType. |
public int getDataElement(int[] components,
int offset) {
int rgb = (components[offset+0]< < 16)
| (components[offset+1]< < 8) | (components[offset+2]);
if (supportsAlpha) {
rgb |= (components[offset+3]< < 24);
}
else {
rgb |= 0xff000000;
}
Object inData = getDataElements(rgb, null);
int pixel;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
byte bdata[] = (byte[])inData;
pixel = bdata[0] & 0xff;
break;
case DataBuffer.TYPE_USHORT:
short sdata[] = (short[])inData;
pixel = sdata[0];
break;
case DataBuffer.TYPE_INT:
int idata[] = (int[])inData;
pixel = idata[0];
break;
default:
throw new UnsupportedOperationException("This method has not been "+
"implemented for transferType " + transferType);
}
return pixel;
} Returns a pixel value represented as an int in this
ColorModel given an array of unnormalized
color/alpha components. An
ArrayIndexOutOfBoundsException
is thrown if the components array is not large
enough to hold all of the color and alpha components starting
at offset. Since
ColorModel can be subclassed, subclasses inherit the
implementation of this method and if they don't override it then
they throw an exception if they use an unsupported transferType. |
public synchronized Object getDataElements(int rgb,
Object pixel) {
int red = (rgb > >16) & 0xff;
int green = (rgb > >8) & 0xff;
int blue = rgb & 0xff;
int alpha = (rgb > > >24);
int pix = 0;
// Note that pixels are stored at lookupcache[2*i]
// and the rgb that was searched is stored at
// lookupcache[2*i+1]. Also, the pixel is first
// inverted using the unary complement operator
// before storing in the cache so it can never be 0.
for (int i = CACHESIZE - 2; i >= 0; i -= 2) {
if ((pix = lookupcache[i]) == 0) {
break;
}
if (rgb == lookupcache[i+1]) {
return installpixel(pixel, ~pix);
}
}
if (allgrayopaque) {
// IndexColorModel objects are all tagged as
// non-premultiplied so ignore the alpha value
// of the incoming color, convert the
// non-premultiplied color components to a
// grayscale value and search for the closest
// gray value in the palette. Since all colors
// in the palette are gray, we only need compare
// to one of the color components for a match
// using a simple linear distance formula.
int minDist = 256;
int d;
int gray = (int) (red*77 + green*150 + blue*29 + 128)/256;
for (int i = 0; i < map_size; i++) {
if (this.rgb[i] == 0x0) {
// For allgrayopaque colormaps, entries are 0
// iff they are an invalid color and should be
// ignored during color searches.
continue;
}
d = (this.rgb[i] & 0xff) - gray;
if (d < 0) d = -d;
if (d < minDist) {
pix = i;
if (d == 0) {
break;
}
minDist = d;
}
}
} else if (transparency == OPAQUE) {
// IndexColorModel objects are all tagged as
// non-premultiplied so ignore the alpha value
// of the incoming color and search for closest
// color match independently using a 3 component
// Euclidean distance formula.
// For opaque colormaps, palette entries are 0
// iff they are an invalid color and should be
// ignored during color searches.
// As an optimization, exact color searches are
// likely to be fairly common in opaque colormaps
// so first we will do a quick search for an
// exact match.
int smallestError = Integer.MAX_VALUE;
int lut[] = this.rgb;
int lutrgb;
for (int i=0; i < map_size; i++) {
lutrgb = lut[i];
if (lutrgb == rgb && lutrgb != 0) {
pix = i;
smallestError = 0;
break;
}
}
if (smallestError != 0) {
for (int i=0; i < map_size; i++) {
lutrgb = lut[i];
if (lutrgb == 0) {
continue;
}
int tmp = ((lutrgb > > 16) & 0xff) - red;
int currentError = tmp*tmp;
if (currentError < smallestError) {
tmp = ((lutrgb > > 8) & 0xff) - green;
currentError += tmp * tmp;
if (currentError < smallestError) {
tmp = (lutrgb & 0xff) - blue;
currentError += tmp * tmp;
if (currentError < smallestError) {
pix = i;
smallestError = currentError;
}
}
}
}
}
} else if (alpha == 0 && transparent_index >= 0) {
// Special case - transparent color maps to the
// specified transparent pixel, if there is one
pix = transparent_index;
} else {
// IndexColorModel objects are all tagged as
// non-premultiplied so use non-premultiplied
// color components in the distance calculations.
// Look for closest match using a 4 component
// Euclidean distance formula.
int smallestError = Integer.MAX_VALUE;
int lut[] = this.rgb;
for (int i=0; i < map_size; i++) {
int lutrgb = lut[i];
if (lutrgb == rgb) {
if (validBits != null && !validBits.testBit(i)) {
continue;
}
pix = i;
break;
}
int tmp = ((lutrgb > > 16) & 0xff) - red;
int currentError = tmp*tmp;
if (currentError < smallestError) {
tmp = ((lutrgb > > 8) & 0xff) - green;
currentError += tmp * tmp;
if (currentError < smallestError) {
tmp = (lutrgb & 0xff) - blue;
currentError += tmp * tmp;
if (currentError < smallestError) {
tmp = (lutrgb > > > 24) - alpha;
currentError += tmp * tmp;
if (currentError < smallestError &&
(validBits == null || validBits.testBit(i)))
{
pix = i;
smallestError = currentError;
}
}
}
}
}
}
System.arraycopy(lookupcache, 2, lookupcache, 0, CACHESIZE - 2);
lookupcache[CACHESIZE - 1] = rgb;
lookupcache[CACHESIZE - 2] = ~pix;
return installpixel(pixel, pix);
} Returns a data element array representation of a pixel in this
ColorModel, given an integer pixel representation in the
default RGB color model. This array can then be passed to the
setDataElements
method of a WritableRaster object. If the pixel variable is
null, a new array is allocated. If pixel
is not null, it must be
a primitive array of type transferType; otherwise, a
ClassCastException is thrown. An
ArrayIndexOutOfBoundsException is
thrown if pixel is not large enough to hold a pixel
value for this ColorModel. The pixel array is returned.
Since IndexColorModel can be subclassed, subclasses
inherit the implementation of this method and if they don't
override it then they throw an exception if they use an
unsupported transferType. |
public Object getDataElements(int[] components,
int offset,
Object pixel) {
int rgb = (components[offset+0]< < 16) | (components[offset+1]< < 8)
| (components[offset+2]);
if (supportsAlpha) {
rgb |= (components[offset+3]< < 24);
}
else {
rgb &= 0xff000000;
}
return getDataElements(rgb, pixel);
} Returns a data element array representation of a pixel in this
ColorModel given an array of unnormalized color/alpha
components. This array can then be passed to the
setDataElements method of a WritableRaster
object. An ArrayIndexOutOfBoundsException is
thrown if the
components array is not large enough to hold all of the
color and alpha components starting at offset.
If the pixel variable is null, a new array
is allocated. If pixel is not null,
it must be a primitive array of type transferType;
otherwise, a ClassCastException is thrown.
An ArrayIndexOutOfBoundsException is thrown if pixel
is not large enough to hold a pixel value for this
ColorModel.
Since IndexColorModel can be subclassed, subclasses
inherit the implementation of this method and if they don't
override it then they throw an exception if they use an
unsupported transferType |
public final int getGreen(int pixel) {
return (rgb[pixel & pixel_mask] > > 8) & 0xff;
} Returns the green color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. The pixel value
is specified as an int.
Only the lower n bits of the pixel value, as specified in the
class description above, are used to
calculate the returned value.
The returned value is a non pre-multiplied value. |
public final void getGreens(byte[] g) {
for (int i = 0; i < map_size; i++) {
g[i] = (byte) (rgb[i] > > 8);
}
} Copies the array of green color components into the specified array.
Only the initial entries of the array as specified by
getMapSize are written. |
public final int getMapSize() {
return map_size;
} Returns the size of the color/alpha component arrays in this
IndexColorModel. |
public final int getRGB(int pixel) {
return rgb[pixel & pixel_mask];
} Returns the color/alpha components of the pixel in the default
RGB color model format. The pixel value is specified as an int.
Only the lower n bits of the pixel value, as specified in the
class description above, are used to
calculate the returned value.
The returned value is in a non pre-multiplied format. |
public final void getRGBs(int[] rgb) {
System.arraycopy(this.rgb, 0, rgb, 0, map_size);
} Converts data for each index from the color and alpha component
arrays to an int in the default RGB ColorModel format and copies
the resulting 32-bit ARGB values into the specified array. Only
the initial entries of the array as specified by
getMapSize are
written. |
public final int getRed(int pixel) {
return (rgb[pixel & pixel_mask] > > 16) & 0xff;
} Returns the red color component for the specified pixel, scaled
from 0 to 255 in the default RGB ColorSpace, sRGB. The pixel value
is specified as an int.
Only the lower n bits of the pixel value, as specified in the
class description above, are used to
calculate the returned value.
The returned value is a non pre-multiplied value. |
public final void getReds(byte[] r) {
for (int i = 0; i < map_size; i++) {
r[i] = (byte) (rgb[i] > > 16);
}
} Copies the array of red color components into the specified array.
Only the initial entries of the array as specified by
getMapSize are written. |
public int getTransparency() {
return transparency;
} Returns the transparency. Returns either OPAQUE, BITMASK,
or TRANSLUCENT |
public final int getTransparentPixel() {
return transparent_index;
} Returns the index of a transparent pixel in this
IndexColorModel or -1 if there is no pixel
with an alpha value of 0. If a transparent pixel was
explicitly specified in one of the constructors by its
index, then that index will be preferred, otherwise,
the index of any pixel which happens to be fully transparent
may be returned. |
public BigInteger getValidPixels() {
if (validBits == null) {
return getAllValid();
}
else {
return validBits;
}
} Returns a BigInteger that indicates the valid/invalid
pixels in the colormap. A bit is valid if the
BigInteger value at that index is set, and is invalid
if the BigInteger value at that index is not set.
The only valid ranges to query in the BigInteger are
between 0 and the map size. |
public boolean isCompatibleRaster(Raster raster) {
int size = raster.getSampleModel().getSampleSize(0);
return ((raster.getTransferType() == transferType) &&
(raster.getNumBands() == 1) && ((1 < < size) >= map_size));
} Returns true if raster is compatible
with this ColorModel or false if it
is not compatible with this ColorModel. |
public boolean isCompatibleSampleModel(SampleModel sm) {
// fix 4238629
if (! (sm instanceof ComponentSampleModel) &&
! (sm instanceof MultiPixelPackedSampleModel) ) {
return false;
}
// Transfer type must be the same
if (sm.getTransferType() != transferType) {
return false;
}
if (sm.getNumBands() != 1) {
return false;
}
return true;
} Checks if the specified SampleModel is compatible
with this ColorModel. If sm is
null, this method returns false. |
public boolean isValid() {
return (validBits == null);
} Returns whether or not all of the pixels are valid. |
public boolean isValid(int pixel) {
return ((pixel >= 0 && pixel < map_size) &&
(validBits == null || validBits.testBit(pixel)));
} Returns whether or not the pixel is valid. |
public String toString() {
return new String("IndexColorModel: #pixelBits = "+pixel_bits
+ " numComponents = "+numComponents
+ " color space = "+colorSpace
+ " transparency = "+transparency
+ " transIndex = "+transparent_index
+ " has alpha = "+supportsAlpha
+ " isAlphaPre = "+isAlphaPremultiplied
);
} Returns the String representation of the contents of
this ColorModelobject. |
java.awt.image.ColorModel