public ConvolveOp(Kernel kernel) 
{
        this.kernel   = kernel;
        this.edgeHint = EDGE_ZERO_FILL;
}

Constructs a ConvolveOp given a Kernel. The edge condition will be EDGE_ZERO_FILL.

Parameters:

kernel - the specified Kernel

Also see:

Kernel
EDGE_ZERO_FILL

 public ConvolveOp(Kernel kernel,
    int edgeCondition,
    RenderingHints hints) 
{
                                                   
        this.kernel   = kernel;
        this.edgeHint = edgeCondition;
        this.hints    = hints;
}

Constructs a ConvolveOp given a Kernel, an edge condition, and a RenderingHints object (which may be null).

Parameters:

kernel - the specified Kernel

edgeCondition - the specified edge condition

hints - the specified RenderingHints object

Also see:

Kernel
EDGE_NO_OP
EDGE_ZERO_FILL
java.awt.RenderingHints

 public BufferedImage createCompatibleDestImage(BufferedImage src,
    ColorModel destCM) 
{
        BufferedImage image;
        int w = src.getWidth();
        int h = src.getHeight();
        WritableRaster wr = null;
        if (destCM == null) {
            destCM = src.getColorModel();
            // Not much support for ICM
            if (destCM instanceof IndexColorModel) {
                destCM = ColorModel.getRGBdefault();
            } else {
                /* Create destination image as similar to the source
                 *  as it possible...
                 */
                wr = src.getData().createCompatibleWritableRaster(w, h);
            }
        }
        if (wr == null) {
            /* This is the case when destination color model
             * was explicitly specified (and it may be not compatible
             * with source raster structure) or source is indexed image.
             * We should use destination color model to create compatible
             * destination raster here.
             */
            wr = destCM.createCompatibleWritableRaster(w, h);
        }
        image = new BufferedImage (destCM, wr,
                                   destCM.isAlphaPremultiplied(), null);
        return image;
}

Creates a zeroed destination image with the correct size and number of bands. If destCM is null, an appropriate ColorModel will be used.

 public WritableRaster createCompatibleDestRaster(Raster src) 
{
        return src.createCompatibleWritableRaster();
}

Creates a zeroed destination Raster with the correct size and number of bands, given this source.

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

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.

 public final WritableRaster filter(Raster src,
    WritableRaster dst) 
{
        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;
}

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.

 public final Rectangle2D getBounds2D(BufferedImage src) 
{
        return getBounds2D(src.getRaster());
}

Returns the bounding box of the filtered destination image. Since this is not a geometric operation, the bounding box does not change.

 public final Rectangle2D getBounds2D(Raster src) 
{
        return src.getBounds();
}

Returns the bounding box of the filtered destination Raster. Since this is not a geometric operation, the bounding box does not change.

 public int getEdgeCondition() 
{
        return edgeHint;
}

Returns the edge condition.

 public final Kernel getKernel() 
{
        return (Kernel) kernel.clone();
}

Returns the Kernel.

 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 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.

 public final RenderingHints getRenderingHints() 
{
        return hints;
}

Returns the rendering hints for this op.