Raster to 2D coordinates
* in the destination image or Raster.
* The type of interpolation that is used is specified through a constructor,
* either by a RenderingHints object or by one of the integer
* interpolation types defined in this class.
*
* If a RenderingHints object is specified in the constructor, the
* interpolation hint and the rendering quality hint are used to set
* the interpolation type for this operation. The color rendering hint
* and the dithering hint can be used when color conversion is required.
*
* Note that the following constraints have to be met: *
Raster objects, the number of bands in the source must
* be equal to the number of bands in the destination.
* AffineTransformOp given an affine transform.
* The interpolation type is determined from the
* RenderingHints object. If the interpolation hint is
* defined, it will be used. Otherwise, if the rendering quality hint is
* defined, the interpolation type is determined from its value. If no
* hints are specified (hints is null),
* the interpolation type is {@link #TYPE_NEAREST_NEIGHBOR
* TYPE_NEAREST_NEIGHBOR}.
*
* @param xform The AffineTransform to use for the
* operation.
*
* @param hints The RenderingHints object used to specify
* the interpolation type for the operation.
*
* @throws ImagingOpException if the transform is non-invertible.
* @see java.awt.RenderingHints#KEY_INTERPOLATION
* @see java.awt.RenderingHints#KEY_RENDERING
*/
public AffineTransformOp(AffineTransform xform, RenderingHints hints){
validateTransform(xform);
this.xform = (AffineTransform) xform.clone();
this.hints = hints;
if (hints != null) {
Object value = hints.get(RenderingHints.KEY_INTERPOLATION);
if (value == null) {
value = hints.get(RenderingHints.KEY_RENDERING);
if (value == RenderingHints.VALUE_RENDER_SPEED) {
interpolationType = TYPE_NEAREST_NEIGHBOR;
}
else if (value == RenderingHints.VALUE_RENDER_QUALITY) {
interpolationType = TYPE_BILINEAR;
}
}
else if (value == RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR) {
interpolationType = TYPE_NEAREST_NEIGHBOR;
}
else if (value == RenderingHints.VALUE_INTERPOLATION_BILINEAR) {
interpolationType = TYPE_BILINEAR;
}
else if (value == RenderingHints.VALUE_INTERPOLATION_BICUBIC) {
interpolationType = TYPE_BICUBIC;
}
}
else {
interpolationType = TYPE_NEAREST_NEIGHBOR;
}
}
/**
* Constructs an AffineTransformOp given an affine transform
* and the interpolation type.
*
* @param xform The AffineTransform to use for the operation.
* @param interpolationType One of the integer
* interpolation type constants defined by this class:
* {@link #TYPE_NEAREST_NEIGHBOR TYPE_NEAREST_NEIGHBOR},
* {@link #TYPE_BILINEAR TYPE_BILINEAR},
* {@link #TYPE_BICUBIC TYPE_BICUBIC}.
* @throws ImagingOpException if the transform is non-invertible.
*/
public AffineTransformOp(AffineTransform xform, int interpolationType) {
validateTransform(xform);
this.xform = (AffineTransform)xform.clone();
switch(interpolationType) {
case TYPE_NEAREST_NEIGHBOR:
case TYPE_BILINEAR:
case TYPE_BICUBIC:
break;
default:
throw new IllegalArgumentException("Unknown interpolation type: "+
interpolationType);
}
this.interpolationType = interpolationType;
}
/**
* Returns the interpolation type used by this op.
* @return the interpolation type.
* @see #TYPE_NEAREST_NEIGHBOR
* @see #TYPE_BILINEAR
* @see #TYPE_BICUBIC
*/
public final int getInterpolationType() {
return interpolationType;
}
/**
* Transforms the source BufferedImage and stores the results
* in the destination BufferedImage.
* If the color models for the two images do not match, a color
* conversion into the destination color model is performed.
* If the destination image is null,
* a BufferedImage is created with the source
* ColorModel.
*
* The coordinates of the rectangle returned by
* getBounds2D(BufferedImage)
* are not necessarily the same as the coordinates of the
* BufferedImage returned by this method. If the
* upper-left corner coordinates of the rectangle are
* negative then this part of the rectangle is not drawn. If the
* upper-left corner coordinates of the rectangle are positive
* then the filtered image is drawn at that position in the
* destination BufferedImage.
*
* An IllegalArgumentException is thrown if the source is
* the same as the destination.
*
* @param src The BufferedImage to transform.
* @param dst The BufferedImage in which to store the results
* of the transformation.
*
* @return The filtered BufferedImage.
* @throws IllegalArgumentException if src and
* dst are the same
* @throws ImagingOpException if the image cannot be transformed
* because of a data-processing error that might be
* caused by an invalid image format, tile format, or
* image-processing operation, or any other unsupported
* operation.
*/
public final BufferedImage filter(BufferedImage src, BufferedImage dst) {
if (src == null) {
throw new NullPointerException("src image is null");
}
if (src == dst) {
throw new IllegalArgumentException("src image cannot be the "+
"same as the dst image");
}
boolean needToConvert = false;
ColorModel srcCM = src.getColorModel();
ColorModel dstCM;
BufferedImage origDst = dst;
if (dst == null) {
dst = createCompatibleDestImage(src, null);
dstCM = srcCM;
origDst = dst;
}
else {
dstCM = dst.getColorModel();
if (srcCM.getColorSpace().getType() !=
dstCM.getColorSpace().getType())
{
int type = xform.getType();
boolean needTrans = ((type&
(AffineTransform.TYPE_MASK_ROTATION|
AffineTransform.TYPE_GENERAL_TRANSFORM))
!= 0);
if (! needTrans &&
type != AffineTransform.TYPE_TRANSLATION &&
type != AffineTransform.TYPE_IDENTITY)
{
double[] mtx = new double[4];
xform.getMatrix(mtx);
// Check out the matrix. A non-integral scale will force ARGB
// since the edge conditions can't be guaranteed.
needTrans = (mtx[0] != (int)mtx[0] || mtx[3] != (int)mtx[3]);
}
if (needTrans &&
srcCM.getTransparency() == Transparency.OPAQUE)
{
// Need to convert first
ColorConvertOp ccop = new ColorConvertOp(hints);
BufferedImage tmpSrc = null;
int sw = src.getWidth();
int sh = src.getHeight();
if (dstCM.getTransparency() == Transparency.OPAQUE) {
tmpSrc = new BufferedImage(sw, sh,
BufferedImage.TYPE_INT_ARGB);
}
else {
WritableRaster r =
dstCM.createCompatibleWritableRaster(sw, sh);
tmpSrc = new BufferedImage(dstCM, r,
dstCM.isAlphaPremultiplied(),
null);
}
src = ccop.filter(src, tmpSrc);
}
else {
needToConvert = true;
dst = createCompatibleDestImage(src, null);
}
}
}
if (interpolationType != TYPE_NEAREST_NEIGHBOR &&
dst.getColorModel() instanceof IndexColorModel) {
dst = new BufferedImage(dst.getWidth(), dst.getHeight(),
BufferedImage.TYPE_INT_ARGB);
}
if (ImagingLib.filter(this, src, dst) == null) {
throw new ImagingOpException ("Unable to transform src image");
}
if (needToConvert) {
ColorConvertOp ccop = new ColorConvertOp(hints);
ccop.filter(dst, origDst);
}
else if (origDst != dst) {
java.awt.Graphics2D g = origDst.createGraphics();
try {
g.setComposite(AlphaComposite.Src);
g.drawImage(dst, 0, 0, null);
} finally {
g.dispose();
}
}
return origDst;
}
/**
* Transforms the source Raster and stores the results in
* the destination Raster. This operation performs the
* transform band by band.
*
* If the destination Raster is null, a new
* Raster is created.
* An IllegalArgumentException may be thrown if the source is
* the same as the destination or if the number of bands in
* the source is not equal to the number of bands in the
* destination.
*
* The coordinates of the rectangle returned by
* getBounds2D(Raster)
* are not necessarily the same as the coordinates of the
* WritableRaster returned by this method. If the
* upper-left corner coordinates of rectangle are negative then
* this part of the rectangle is not drawn. If the coordinates
* of the rectangle are positive then the filtered image is drawn at
* that position in the destination Raster.
*
* @param src The Raster to transform.
* @param dst The Raster in which to store the results of the
* transformation.
*
* @return The transformed Raster.
*
* @throws ImagingOpException if the raster cannot be transformed
* because of a data-processing error that might be
* caused by an invalid image format, tile format, or
* image-processing operation, or any other unsupported
* operation.
*/
public final WritableRaster filter(Raster src, WritableRaster dst) {
if (src == null) {
throw new NullPointerException("src image is null");
}
if (dst == null) {
dst = createCompatibleDestRaster(src);
}
if (src == dst) {
throw new IllegalArgumentException("src image cannot be the "+
"same as the dst image");
}
if (src.getNumBands() != dst.getNumBands()) {
throw new IllegalArgumentException("Number of src bands ("+
src.getNumBands()+
") does not match number of "+
" dst bands ("+
dst.getNumBands()+")");
}
if (ImagingLib.filter(this, src, dst) == null) {
throw new ImagingOpException ("Unable to transform src image");
}
return dst;
}
/**
* Returns the bounding box of the transformed destination. The
* rectangle returned is the actual bounding box of the
* transformed points. The coordinates of the upper-left corner
* of the returned rectangle might not be (0, 0).
*
* @param src The BufferedImage to be transformed.
*
* @return The Rectangle2D representing the destination's
* bounding box.
*/
public final Rectangle2D getBounds2D (BufferedImage src) {
return getBounds2D(src.getRaster());
}
/**
* Returns the bounding box of the transformed destination. The
* rectangle returned will be the actual bounding box of the
* transformed points. The coordinates of the upper-left corner
* of the returned rectangle might not be (0, 0).
*
* @param src The Raster to be transformed.
*
* @return The Rectangle2D representing the destination's
* bounding box.
*/
public final Rectangle2D getBounds2D (Raster src) {
int w = src.getWidth();
int h = src.getHeight();
// Get the bounding box of the src and transform the corners
float[] pts = {0, 0, w, 0, w, h, 0, h};
xform.transform(pts, 0, pts, 0, 4);
// Get the min, max of the dst
float fmaxX = pts[0];
float fmaxY = pts[1];
float fminX = pts[0];
float fminY = pts[1];
for (int i=2; i < 8; i+=2) {
if (pts[i] > fmaxX) {
fmaxX = pts[i];
}
else if (pts[i] < fminX) {
fminX = pts[i];
}
if (pts[i+1] > fmaxY) {
fmaxY = pts[i+1];
}
else if (pts[i+1] < fminY) {
fminY = pts[i+1];
}
}
return new Rectangle2D.Float(fminX, fminY, fmaxX-fminX, fmaxY-fminY);
}
/**
* Creates a zeroed destination image with the correct size and number of
* bands. A RasterFormatException may be thrown if the
* transformed width or height is equal to 0.
*
* If destCM is null,
* an appropriate ColorModel is used; this
* ColorModel may have
* an alpha channel even if the source ColorModel is opaque.
*
* @param src The BufferedImage to be transformed.
* @param destCM ColorModel of the destination. If null,
* an appropriate ColorModel is used.
*
* @return The zeroed destination image.
*/
public BufferedImage createCompatibleDestImage (BufferedImage src,
ColorModel destCM) {
BufferedImage image;
Rectangle r = getBounds2D(src).getBounds();
// If r.x (or r.y) is < 0, then we want to only create an image
// that is in the positive range.
// If r.x (or r.y) is > 0, then we need to create an image that
// includes the translation.
int w = r.x + r.width;
int h = r.y + r.height;
if (w <= 0) {
throw new RasterFormatException("Transformed width ("+w+
") is less than or equal to 0.");
}
if (h <= 0) {
throw new RasterFormatException("Transformed height ("+h+
") is less than or equal to 0.");
}
if (destCM == null) {
ColorModel cm = src.getColorModel();
if (interpolationType != TYPE_NEAREST_NEIGHBOR &&
(cm instanceof IndexColorModel ||
cm.getTransparency() == Transparency.OPAQUE))
{
image = new BufferedImage(w, h,
BufferedImage.TYPE_INT_ARGB);
}
else {
image = new BufferedImage(cm,
src.getRaster().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. A RasterFormatException may be thrown
* if the transformed width or height is equal to 0.
*
* @param src The Raster to be transformed.
*
* @return The zeroed destination Raster.
*/
public WritableRaster createCompatibleDestRaster (Raster src) {
Rectangle2D r = getBounds2D(src);
return src.createCompatibleWritableRaster((int)r.getX(),
(int)r.getY(),
(int)r.getWidth(),
(int)r.getHeight());
}
/**
* Returns the location of the corresponding destination point given a
* point in the source. If dstPt is specified, it
* is used to hold the return value.
*
* @param srcPt The Point2D that represents the source
* point.
* @param dstPt The Point2D in which to store the result.
*
* @return The Point2D in the destination that corresponds to
* the specified point in the source.
*/
public final Point2D getPoint2D (Point2D srcPt, Point2D dstPt) {
return xform.transform (srcPt, dstPt);
}
/**
* Returns the affine transform used by this transform operation.
*
* @return The AffineTransform associated with this op.
*/
public final AffineTransform getTransform() {
return (AffineTransform) xform.clone();
}
/**
* Returns the rendering hints used by this transform operation.
*
* @return The RenderingHints object associated with this op.
*/
public final RenderingHints getRenderingHints() {
if (hints == null) {
Object val;
switch(interpolationType) {
case TYPE_NEAREST_NEIGHBOR:
val = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
break;
case TYPE_BILINEAR:
val = RenderingHints.VALUE_INTERPOLATION_BILINEAR;
break;
case TYPE_BICUBIC:
val = RenderingHints.VALUE_INTERPOLATION_BICUBIC;
break;
default:
// Should never get here
throw new InternalError("Unknown interpolation type "+
interpolationType);
}
hints = new RenderingHints(RenderingHints.KEY_INTERPOLATION, val);
}
return hints;
}
// We need to be able to invert the transform if we want to
// transform the image. If the determinant of the matrix is 0,
// then we can't invert the transform.
void validateTransform(AffineTransform xform) {
if (Math.abs(xform.getDeterminant()) <= Double.MIN_VALUE) {
throw new ImagingOpException("Unable to invert transform "+xform);
}
}
}