ConvolveOppublic class ConvolveOp extends Object implements BufferedImageOp, RasterOp| This class implements a convolution from the source
to the destination.
Convolution using a convolution kernel is a spatial operation that
computes the output pixel from an input pixel by multiplying the kernel
with the surround of the input pixel.
This allows the output pixel to be affected by the immediate neighborhood
in a way that can be mathematically specified with a kernel.
This class operates with BufferedImage data in which color components are
premultiplied with the alpha component. If the Source BufferedImage has
an alpha component, and the color components are not premultiplied with
the alpha component, then the data are premultiplied before being
convolved. If the Destination has color components which are not
premultiplied, then alpha is divided out before storing into the
Destination (if alpha is 0, the color components are set to 0). If the
Destination has no alpha component, then the resulting alpha is discarded
after first dividing it out of the color components.
Rasters are treated as having no alpha channel. If the above treatment
of the alpha channel in BufferedImages is not desired, it may be avoided
by getting the Raster of a source BufferedImage and using the filter method
of this class which works with Rasters.
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.
Note that the Source and the Destination may not be the same object. |
| Fields Summary |
|---|
| Kernel | kernel | | int | edgeHint | | RenderingHints | hints | | public static final int | EDGE_ZERO_FILLPixels at the edge of the destination image are set to zero. This
is the default. | | public static final int | EDGE_NO_OPPixels at the edge of the source image are copied to
the corresponding pixels in the destination without modification. |
| Constructors Summary |
|---|
public ConvolveOp(Kernel kernel, int edgeCondition, RenderingHints hints)Constructs a ConvolveOp given a Kernel, an edge condition, and a
RenderingHints object (which may be null).
this.kernel = kernel;
this.edgeHint = edgeCondition;
this.hints = hints;
| public ConvolveOp(Kernel kernel)Constructs a ConvolveOp given a Kernel. The edge condition
will be EDGE_ZERO_FILL.
this.kernel = kernel;
this.edgeHint = EDGE_ZERO_FILL;
|
| Methods Summary |
|---|
| public java.awt.image.BufferedImage | createCompatibleDestImage(java.awt.image.BufferedImage src, java.awt.image.ColorModel destCM)Creates a zeroed destination image with the correct size and number
of bands. If destCM is null, an appropriate ColorModel will be used.
BufferedImage image;
if (destCM == null) {
destCM = src.getColorModel();
// Not much support for ICM
if (destCM instanceof IndexColorModel) {
destCM = ColorModel.getRGBdefault();
}
}
int w = src.getWidth();
int h = src.getHeight();
image = new BufferedImage (destCM,
destCM.createCompatibleWritableRaster(w, h),
destCM.isAlphaPremultiplied(), null);
return image;
| | public java.awt.image.WritableRaster | createCompatibleDestRaster(java.awt.image.Raster src)Creates a zeroed destination Raster with the correct size and number
of bands, given this source.
return src.createCompatibleWritableRaster();
| | public final java.awt.image.BufferedImage | filter(java.awt.image.BufferedImage src, java.awt.image.BufferedImage dst)Performs a convolution on BufferedImages. Each component of the
source image will be convolved (including the alpha component, if
present).
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 the source ColorModel.
The IllegalArgumentException may be thrown if the source is the
same as the destination.
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;
// Can't convolve an IndexColorModel. Need to expand it
if (srcCM instanceof IndexColorModel) {
IndexColorModel icm = (IndexColorModel) srcCM;
src = icm.convertToIntDiscrete(src.getRaster(), false);
srcCM = src.getColorModel();
}
if (dst == null) {
dst = createCompatibleDestImage(src, null);
dstCM = srcCM;
origDst = dst;
}
else {
dstCM = dst.getColorModel();
if (srcCM.getColorSpace().getType() !=
dstCM.getColorSpace().getType())
{
needToConvert = true;
dst = createCompatibleDestImage(src, null);
dstCM = dst.getColorModel();
}
else if (dstCM instanceof IndexColorModel) {
dst = createCompatibleDestImage(src, null);
dstCM = dst.getColorModel();
}
}
if (ImagingLib.filter(this, src, dst) == null) {
throw new ImagingOpException ("Unable to convolve 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.drawImage(dst, 0, 0, null);
} finally {
g.dispose();
}
}
return origDst;
| | public final java.awt.image.WritableRaster | filter(java.awt.image.Raster src, java.awt.image.WritableRaster dst)Performs a convolution on Rasters. Each band of the source Raster
will be convolved.
The source and destination must have the same number of bands.
If the destination Raster is null, a new Raster will be created.
The IllegalArgumentException may be thrown if the source is
the same as the destination.
if (dst == null) {
dst = createCompatibleDestRaster(src);
}
else if (src == dst) {
throw new IllegalArgumentException("src image cannot be the "+
"same as the dst image");
}
else if (src.getNumBands() != dst.getNumBands()) {
throw new ImagingOpException("Different number of bands in src "+
" and dst Rasters");
}
if (ImagingLib.filter(this, src, dst) == null) {
throw new ImagingOpException ("Unable to convolve src image");
}
return dst;
| | public final java.awt.geom.Rectangle2D | getBounds2D(java.awt.image.Raster src)Returns the bounding box of the filtered destination Raster. Since
this is not a geometric operation, the bounding box does not
change.
return src.getBounds();
| | public final java.awt.geom.Rectangle2D | getBounds2D(java.awt.image.BufferedImage src)Returns the bounding box of the filtered destination image. Since
this is not a geometric operation, the bounding box does not
change.
return getBounds2D(src.getRaster());
| | public int | getEdgeCondition()Returns the edge condition.
return edgeHint;
| | public final java.awt.image.Kernel | getKernel()Returns the Kernel.
return (Kernel) kernel.clone();
| | public final java.awt.geom.Point2D | getPoint2D(java.awt.geom.Point2D srcPt, java.awt.geom.Point2D dstPt)Returns the location of the destination point given a
point in the source. If dstPt is non-null, it will
be used to hold the return value. Since this is not a geometric
operation, the srcPt will equal the dstPt.
if (dstPt == null) {
dstPt = new Point2D.Float();
}
dstPt.setLocation(srcPt.getX(), srcPt.getY());
return dstPt;
| | public final java.awt.RenderingHints | getRenderingHints()Returns the rendering hints for this op.
return hints;
|
|
