Back to index...

	/*
	* Copyright (c) 1997, 2005, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.awt.image;

	import java.awt.GraphicsEnvironment;
	import java.awt.color.ICC_Profile;
	import java.awt.geom.Rectangle2D;
	import java.awt.Rectangle;
	import java.awt.geom.Point2D;
	import java.awt.RenderingHints;
	import sun.awt.image.ImagingLib;
	import java.util.Arrays;

	/**
	* This class performs an arbitrary linear combination of the bands
	* in a <CODE>Raster</CODE>, using a specified matrix.
	* <p>
	* The width of the matrix must be equal to the number of bands in the
	* source <CODE>Raster</CODE>, optionally plus one. If there is one more
	* column in the matrix than the number of bands, there is an implied 1 at the
	* end of the vector of band samples representing a pixel. The height
	* of the matrix must be equal to the number of bands in the destination.
	* <p>
	* For example, a 3-banded <CODE>Raster</CODE> might have the following
	* transformation applied to each pixel in order to invert the second band of
	* the <CODE>Raster</CODE>.
	* <pre>
	* [ 1.0 0.0 0.0 0.0 ] [ b1 ]
	* [ 0.0 -1.0 0.0 255.0 ] x [ b2 ]
	* [ 0.0 0.0 1.0 0.0 ] [ b3 ]
	* [ 1 ]
	* </pre>
	*
	* <p>
	* Note that the source and destination can be the same object.
	*/
	public class BandCombineOp implements RasterOp {
	float[][] matrix;
	int nrows = 0;
	int ncols = 0;
	RenderingHints hints;

	/**
	* Constructs a <CODE>BandCombineOp</CODE> with the specified matrix.
	* The width of the matrix must be equal to the number of bands in
	* the source <CODE>Raster</CODE>, optionally plus one. If there is one
	* more column in the matrix than the number of bands, there is an implied
	* 1 at the end of the vector of band samples representing a pixel. The
	* height of the matrix must be equal to the number of bands in the
	* destination.
	* <p>
	* The first subscript is the row index and the second
	* is the column index. This operation uses none of the currently
	* defined rendering hints; the <CODE>RenderingHints</CODE> argument can be
	* null.
	*
	* @param matrix The matrix to use for the band combine operation.
	* @param hints The <CODE>RenderingHints</CODE> object for this operation.
	* Not currently used so it can be null.
	*/
	public BandCombineOp (float[][] matrix, RenderingHints hints) {
	nrows = matrix.length;
	ncols = matrix[0].length;
	this.matrix = new float[nrows][];
	for (int i=0; i < nrows; i++) {
	/* Arrays.copyOf is forgiving of the source array being
	* too short, but it is also faster than other cloning
	* methods, so we provide our own protection for short
	* matrix rows.
	*/
	if (ncols > matrix[i].length) {
	throw new IndexOutOfBoundsException("row "+i+" too short");
	}
	this.matrix[i] = Arrays.copyOf(matrix[i], ncols);
	}
	this.hints = hints;
	}

	/**
	* Returns a copy of the linear combination matrix.
	*
	* @return The matrix associated with this band combine operation.
	*/
	public final float[][] getMatrix() {
	float[][] ret = new float[nrows][];
	for (int i = 0; i < nrows; i++) {
	ret[i] = Arrays.copyOf(matrix[i], ncols);
	}
	return ret;
	}

	/**
	* Transforms the <CODE>Raster</CODE> using the matrix specified in the
	* constructor. An <CODE>IllegalArgumentException</CODE> may be thrown if
	* the number of bands in the source or destination is incompatible with
	* the matrix. See the class comments for more details.
	* <p>
	* If the destination is null, it will be created with a number of bands
	* equalling the number of rows in the matrix. No exception is thrown
	* if the operation causes a data overflow.
	*
	* @param src The <CODE>Raster</CODE> to be filtered.
	* @param dst The <CODE>Raster</CODE> in which to store the results
	* of the filter operation.
	*
	* @return The filtered <CODE>Raster</CODE>.
	*
	* @throws IllegalArgumentException If the number of bands in the
	* source or destination is incompatible with the matrix.
	*/
	public WritableRaster filter(Raster src, WritableRaster dst) {
	int nBands = src.getNumBands();
	if (ncols != nBands && ncols != (nBands+1)) {
	throw new IllegalArgumentException("Number of columns in the "+
	"matrix ("+ncols+
	") must be equal to the number"+
	" of bands ([+1]) in src ("+
	nBands+").");
	}
	if (dst == null) {
	dst = createCompatibleDestRaster(src);
	}
	else if (nrows != dst.getNumBands()) {
	throw new IllegalArgumentException("Number of rows in the "+
	"matrix ("+nrows+
	") must be equal to the number"+
	" of bands ([+1]) in dst ("+
	nBands+").");
	}

	if (ImagingLib.filter(this, src, dst) != null) {
	return dst;
	}

	int[] pixel = null;
	int[] dstPixel = new int[dst.getNumBands()];
	float accum;
	int sminX = src.getMinX();
	int sY = src.getMinY();
	int dminX = dst.getMinX();
	int dY = dst.getMinY();
	int sX;
	int dX;
	if (ncols == nBands) {
	for (int y=0; y < src.getHeight(); y++, sY++, dY++) {
	dX = dminX;
	sX = sminX;
	for (int x=0; x < src.getWidth(); x++, sX++, dX++) {
	pixel = src.getPixel(sX, sY, pixel);
	for (int r=0; r < nrows; r++) {
	accum = 0.f;
	for (int c=0; c < ncols; c++) {
	accum += matrix[r][c]*pixel[c];
	}
	dstPixel[r] = (int) accum;
	}
	dst.setPixel(dX, dY, dstPixel);
	}
	}
	}
	else {
	// Need to add constant
	for (int y=0; y < src.getHeight(); y++, sY++, dY++) {
	dX = dminX;
	sX = sminX;
	for (int x=0; x < src.getWidth(); x++, sX++, dX++) {
	pixel = src.getPixel(sX, sY, pixel);
	for (int r=0; r < nrows; r++) {
	accum = 0.f;
	for (int c=0; c < nBands; c++) {
	accum += matrix[r][c]*pixel[c];
	}
	dstPixel[r] = (int) (accum+matrix[r][nBands]);
	}
	dst.setPixel(dX, dY, dstPixel);
	}
	}
	}

	return dst;
	}

	/**
	* Returns the bounding box of the transformed destination. Since
	* this is not a geometric operation, the bounding box is the same for
	* the source and destination.
	* An <CODE>IllegalArgumentException</CODE> may be thrown if the number of
	* bands in the source is incompatible with the matrix. See
	* the class comments for more details.
	*
	* @param src The <CODE>Raster</CODE> to be filtered.
	*
	* @return The <CODE>Rectangle2D</CODE> representing the destination
	* image's bounding box.
	*
	* @throws IllegalArgumentException If the number of bands in the source
	* is incompatible with the matrix.
	*/
	public final Rectangle2D getBounds2D (Raster src) {
	return src.getBounds();
	}


	/**
	* Creates a zeroed destination <CODE>Raster</CODE> with the correct size
	* and number of bands.
	* An <CODE>IllegalArgumentException</CODE> may be thrown if the number of
	* bands in the source is incompatible with the matrix. See
	* the class comments for more details.
	*
	* @param src The <CODE>Raster</CODE> to be filtered.
	*
	* @return The zeroed destination <CODE>Raster</CODE>.
	*/
	public WritableRaster createCompatibleDestRaster (Raster src) {
	int nBands = src.getNumBands();
	if ((ncols != nBands) && (ncols != (nBands+1))) {
	throw new IllegalArgumentException("Number of columns in the "+
	"matrix ("+ncols+
	") must be equal to the number"+
	" of bands ([+1]) in src ("+
	nBands+").");
	}
	if (src.getNumBands() == nrows) {
	return src.createCompatibleWritableRaster();
	}
	else {
	throw new IllegalArgumentException("Don't know how to create a "+
	" compatible Raster with "+
	nrows+" bands.");
	}
	}

	/**
	* Returns the location of the corresponding destination point given a
	* point in the source <CODE>Raster</CODE>. If <CODE>dstPt</CODE> is
	* specified, it is used to hold the return value.
	* Since this is not a geometric operation, the point returned
	* is the same as the specified <CODE>srcPt</CODE>.
	*
	* @param srcPt The <code>Point2D</code> that represents the point in
	* the source <code>Raster</code>
	* @param dstPt The <CODE>Point2D</CODE> in which to store the result.
	*
	* @return The <CODE>Point2D</CODE> in the destination image that
	* corresponds to the specified point in the source image.
	*/
	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 operation.
	*
	* @return The <CODE>RenderingHints</CODE> object associated with this
	* operation. Returns null if no hints have been set.
	*/
	public final RenderingHints getRenderingHints() {
	return hints;
	}
	}

Back to index...