* For Rasters, the lookup operates on bands. The number of * lookup arrays may be one, in which case the same array is * applied to all bands, or it must equal the number of Source * Raster bands. *
* For BufferedImages, the lookup operates on color and alpha components. * The number of lookup arrays may be one, in which case the * same array is applied to all color (but not alpha) components. * Otherwise, the number of lookup arrays may * equal the number of Source color components, in which case no * lookup of the alpha component (if present) is performed. * If neither of these cases apply, the number of lookup arrays * must equal the number of Source color components plus alpha components, * in which case lookup is performed for all color and alpha components. * This allows non-uniform rescaling of multi-band BufferedImages. *
* BufferedImage sources with premultiplied alpha data are treated in the same * manner as non-premultiplied images for purposes of the lookup. That is, * the lookup is done per band on the raw data of the BufferedImage source * without regard to whether the data is premultiplied. If a color conversion * is required to the destination ColorModel, the premultiplied state of * both source and destination will be taken into account for this step. *
* Images with an IndexColorModel cannot be used. *
* If a RenderingHints object is specified in the constructor, the * color rendering hint and the dithering hint may be used when color * conversion is required. *
* This class allows the Source to be the same as the Destination.
*
* @see LookupTable
* @see java.awt.RenderingHints#KEY_COLOR_RENDERING
* @see java.awt.RenderingHints#KEY_DITHERING
*/
public class LookupOp implements BufferedImageOp, RasterOp {
private LookupTable ltable;
private int numComponents;
RenderingHints hints;
/**
* Constructs a LookupOp object given the lookup
* table and a RenderingHints object, which might
* be null.
* @param lookup the specified LookupTable
* @param hints the specified RenderingHints,
* or null
*/
public LookupOp(LookupTable lookup, RenderingHints hints) {
this.ltable = lookup;
this.hints = hints;
numComponents = ltable.getNumComponents();
}
/**
* Returns the LookupTable.
* @return the LookupTable of this
* LookupOp.
*/
public final LookupTable getTable() {
return ltable;
}
/**
* Performs a lookup operation on a BufferedImage.
* If the color model in the source image is not the same as that
* in the destination image, the pixels will be converted
* in the destination. If the destination image is null,
* a BufferedImage will be created with an appropriate
* ColorModel. An IllegalArgumentException
* might be thrown if the number of arrays in the
* LookupTable does not meet the restrictions
* stated in the class comment above, or if the source image
* has an IndexColorModel.
* @param src the BufferedImage to be filtered
* @param dst the BufferedImage in which to
* store the results of the filter operation
* @return the filtered BufferedImage.
* @throws IllegalArgumentException if the number of arrays in the
* LookupTable does not meet the restrictions
* described in the class comments, or if the source image
* has an IndexColorModel.
*/
public final BufferedImage filter(BufferedImage src, BufferedImage dst) {
ColorModel srcCM = src.getColorModel();
int numBands = srcCM.getNumColorComponents();
ColorModel dstCM;
if (srcCM instanceof IndexColorModel) {
throw new
IllegalArgumentException("LookupOp cannot be "+
"performed on an indexed image");
}
int numComponents = ltable.getNumComponents();
if (numComponents != 1 &&
numComponents != srcCM.getNumComponents() &&
numComponents != srcCM.getNumColorComponents())
{
throw new IllegalArgumentException("Number of arrays in the "+
" lookup table ("+
numComponents+
" is not compatible with the "+
" src image: "+src);
}
boolean needToConvert = false;
int width = src.getWidth();
int height = src.getHeight();
if (dst == null) {
dst = createCompatibleDestImage(src, null);
dstCM = srcCM;
}
else {
if (width != dst.getWidth()) {
throw new
IllegalArgumentException("Src width ("+width+
") not equal to dst width ("+
dst.getWidth()+")");
}
if (height != dst.getHeight()) {
throw new
IllegalArgumentException("Src height ("+height+
") not equal to dst height ("+
dst.getHeight()+")");
}
dstCM = dst.getColorModel();
if (srcCM.getColorSpace().getType() !=
dstCM.getColorSpace().getType())
{
needToConvert = true;
dst = createCompatibleDestImage(src, null);
}
}
BufferedImage origDst = dst;
if (ImagingLib.filter(this, src, dst) == null) {
// Do it the slow way
WritableRaster srcRaster = src.getRaster();
WritableRaster dstRaster = dst.getRaster();
if (srcCM.hasAlpha()) {
if (numBands-1 == numComponents || numComponents == 1) {
int minx = srcRaster.getMinX();
int miny = srcRaster.getMinY();
int[] bands = new int[numBands-1];
for (int i=0; i < numBands-1; i++) {
bands[i] = i;
}
srcRaster =
srcRaster.createWritableChild(minx, miny,
srcRaster.getWidth(),
srcRaster.getHeight(),
minx, miny,
bands);
}
}
if (dstCM.hasAlpha()) {
int dstNumBands = dstRaster.getNumBands();
if (dstNumBands-1 == numComponents || numComponents == 1) {
int minx = dstRaster.getMinX();
int miny = dstRaster.getMinY();
int[] bands = new int[numBands-1];
for (int i=0; i < numBands-1; i++) {
bands[i] = i;
}
dstRaster =
dstRaster.createWritableChild(minx, miny,
dstRaster.getWidth(),
dstRaster.getHeight(),
minx, miny,
bands);
}
}
filter(srcRaster, dstRaster);
}
if (needToConvert) {
// ColorModels are not the same
ColorConvertOp ccop = new ColorConvertOp(hints);
ccop.filter(dst, origDst);
}
return origDst;
}
/**
* Performs a lookup operation on a Raster.
* If the destination Raster is null,
* a new Raster will be created.
* The IllegalArgumentException might be thrown
* if the source Raster and the destination
* Raster do not have the same
* number of bands or if the number of arrays in the
* LookupTable does not meet the
* restrictions stated in the class comment above.
* @param src the source Raster to filter
* @param dst the destination WritableRaster for the
* filtered src
* @return the filtered WritableRaster.
* @throws IllegalArgumentException if the source and destinations
* rasters do not have the same number of bands, or the
* number of arrays in the LookupTable does
* not meet the restrictions described in the class comments.
*
*/
public final WritableRaster filter (Raster src, WritableRaster dst) {
int numBands = src.getNumBands();
int dstLength = dst.getNumBands();
int height = src.getHeight();
int width = src.getWidth();
int srcPix[] = new int[numBands];
// Create a new destination Raster, if needed
if (dst == null) {
dst = createCompatibleDestRaster(src);
}
else if (height != dst.getHeight() || width != dst.getWidth()) {
throw new
IllegalArgumentException ("Width or height of Rasters do not "+
"match");
}
dstLength = dst.getNumBands();
if (numBands != dstLength) {
throw new
IllegalArgumentException ("Number of channels in the src ("
+ numBands +
") does not match number of channels"
+ " in the destination ("
+ dstLength + ")");
}
int numComponents = ltable.getNumComponents();
if (numComponents != 1 && numComponents != src.getNumBands()) {
throw new IllegalArgumentException("Number of arrays in the "+
" lookup table ("+
numComponents+
" is not compatible with the "+
" src Raster: "+src);
}
if (ImagingLib.filter(this, src, dst) != null) {
return dst;
}
// Optimize for cases we know about
if (ltable instanceof ByteLookupTable) {
byteFilter ((ByteLookupTable) ltable, src, dst,
width, height, numBands);
}
else if (ltable instanceof ShortLookupTable) {
shortFilter ((ShortLookupTable) ltable, src, dst, width,
height, numBands);
}
else {
// Not one we recognize so do it slowly
int sminX = src.getMinX();
int sY = src.getMinY();
int dminX = dst.getMinX();
int dY = dst.getMinY();
for (int y=0; y < height; y++, sY++, dY++) {
int sX = sminX;
int dX = dminX;
for (int x=0; x < width; x++, sX++, dX++) {
// Find data for all bands at this x,y position
src.getPixel(sX, sY, srcPix);
// Lookup the data for all bands at this x,y position
ltable.lookupPixel(srcPix, srcPix);
// Put it back for all bands
dst.setPixel(dX, dY, srcPix);
}
}
}
return dst;
}
/**
* Returns the bounding box of the filtered destination image. Since
* this is not a geometric operation, the bounding box does not
* change.
* @param src the BufferedImage to be filtered
* @return the bounds of the filtered definition image.
*/
public final Rectangle2D getBounds2D (BufferedImage src) {
return getBounds2D(src.getRaster());
}
/**
* Returns the bounding box of the filtered destination Raster. Since
* this is not a geometric operation, the bounding box does not
* change.
* @param src the Raster to be filtered
* @return the bounds of the filtered definition Raster.
*/
public final Rectangle2D getBounds2D (Raster src) {
return src.getBounds();
}
/**
* Creates a zeroed destination image with the correct size and number of
* bands. If destCM is null, an appropriate
* ColorModel will be used.
* @param src Source image for the filter operation.
* @param destCM the destination's ColorModel, which
* can be null.
* @return a filtered destination BufferedImage.
*/
public BufferedImage createCompatibleDestImage (BufferedImage src,
ColorModel destCM) {
BufferedImage image;
int w = src.getWidth();
int h = src.getHeight();
int transferType = DataBuffer.TYPE_BYTE;
if (destCM == null) {
ColorModel cm = src.getColorModel();
Raster raster = src.getRaster();
if (cm instanceof ComponentColorModel) {
DataBuffer db = raster.getDataBuffer();
boolean hasAlpha = cm.hasAlpha();
boolean isPre = cm.isAlphaPremultiplied();
int trans = cm.getTransparency();
int[] nbits = null;
if (ltable instanceof ByteLookupTable) {
if (db.getDataType() == DataBuffer.TYPE_USHORT) {
// Dst raster should be of type byte
if (hasAlpha) {
nbits = new int[2];
if (trans == java.awt.Transparency.BITMASK) {
nbits[1] = 1;
}
else {
nbits[1] = 8;
}
}
else {
nbits = new int[1];
}
nbits[0] = 8;
}
// For byte, no need to change the cm
}
else if (ltable instanceof ShortLookupTable) {
transferType = DataBuffer.TYPE_USHORT;
if (db.getDataType() == DataBuffer.TYPE_BYTE) {
if (hasAlpha) {
nbits = new int[2];
if (trans == java.awt.Transparency.BITMASK) {
nbits[1] = 1;
}
else {
nbits[1] = 16;
}
}
else {
nbits = new int[1];
}
nbits[0] = 16;
}
}
if (nbits != null) {
cm = new ComponentColorModel(cm.getColorSpace(),
nbits, hasAlpha, isPre,
trans, transferType);
}
}
image = new BufferedImage(cm,
cm.createCompatibleWritableRaster(w, h),
cm.isAlphaPremultiplied(),
null);
}
else {
image = new BufferedImage(destCM,
destCM.createCompatibleWritableRaster(w,
h),
destCM.isAlphaPremultiplied(),
null);
}
return image;
}
/**
* Creates a zeroed-destination Raster with the
* correct size and number of bands, given this source.
* @param src the Raster to be transformed
* @return the zeroed-destination Raster.
*/
public WritableRaster createCompatibleDestRaster (Raster src) {
return src.createCompatibleWritableRaster();
}
/**
* Returns the location of the destination point given a
* point in the source. If dstPt is not
* null, it will be used to hold the return value.
* Since this is not a geometric operation, the srcPt
* will equal the dstPt.
* @param srcPt a Point2D that represents a point
* in the source image
* @param dstPt a Point2Dthat represents the location
* in the destination
* @return the Point2D in the destination that
* corresponds to the specified point in the source.
*/
public final Point2D getPoint2D (Point2D srcPt, Point2D dstPt) {
if (dstPt == null) {
dstPt = new Point2D.Float();
}
dstPt.setLocation(srcPt.getX(), srcPt.getY());
return dstPt;
}
/**
* Returns the rendering hints for this op.
* @return the RenderingHints object associated
* with this op.
*/
public final RenderingHints getRenderingHints() {
return hints;
}
private final void byteFilter(ByteLookupTable lookup, Raster src,
WritableRaster dst,
int width, int height, int numBands) {
int[] srcPix = null;
// Find the ref to the table and the offset
byte[][] table = lookup.getTable();
int offset = lookup.getOffset();
int tidx;
int step=1;
// Check if it is one lookup applied to all bands
if (table.length == 1) {
step=0;
}
int x;
int y;
int band;
int len = table[0].length;
// Loop through the data
for ( y=0; y < height; y++) {
tidx = 0;
for ( band=0; band < numBands; band++, tidx+=step) {
// Find data for this band, scanline
srcPix = src.getSamples(0, y, width, 1, band, srcPix);
for ( x=0; x < width; x++) {
int index = srcPix[x]-offset;
if (index < 0 || index > len) {
throw new
IllegalArgumentException("index ("+index+
"(out of range: "+
" srcPix["+x+
"]="+ srcPix[x]+
" offset="+ offset);
}
// Do the lookup
srcPix[x] = table[tidx][index];
}
// Put it back
dst.setSamples(0, y, width, 1, band, srcPix);
}
}
}
private final void shortFilter(ShortLookupTable lookup, Raster src,
WritableRaster dst,
int width, int height, int numBands) {
int band;
int[] srcPix = null;
// Find the ref to the table and the offset
short[][] table = lookup.getTable();
int offset = lookup.getOffset();
int tidx;
int step=1;
// Check if it is one lookup applied to all bands
if (table.length == 1) {
step=0;
}
int x = 0;
int y = 0;
int index;
int maxShort = (1<<16)-1;
// Loop through the data
for (y=0; y < height; y++) {
tidx = 0;
for ( band=0; band < numBands; band++, tidx+=step) {
// Find data for this band, scanline
srcPix = src.getSamples(0, y, width, 1, band, srcPix);
for ( x=0; x < width; x++) {
index = srcPix[x]-offset;
if (index < 0 || index > maxShort) {
throw new
IllegalArgumentException("index out of range "+
index+" x is "+x+
"srcPix[x]="+srcPix[x]
+" offset="+ offset);
}
// Do the lookup
srcPix[x] = table[tidx][index];
}
// Put it back
dst.setSamples(0, y, width, 1, band, srcPix);
}
}
}
}