Back to index...

	/*
	* Copyright (c) 2006, 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;

	import java.awt.MultipleGradientPaint.CycleMethod;
	import java.awt.MultipleGradientPaint.ColorSpaceType;
	import java.awt.geom.AffineTransform;
	import java.awt.geom.Rectangle2D;
	import java.awt.image.ColorModel;

	/**
	* Provides the actual implementation for the RadialGradientPaint.
	* This is where the pixel processing is done. A RadialGradienPaint
	* only supports circular gradients, but it should be possible to scale
	* the circle to look approximately elliptical, by means of a
	* gradient transform passed into the RadialGradientPaint constructor.
	*
	* @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans
	*/
	final class RadialGradientPaintContext extends MultipleGradientPaintContext {

	/** True when (focus == center). */
	private boolean isSimpleFocus = false;

	/** True when (cycleMethod == NO_CYCLE). */
	private boolean isNonCyclic = false;

	/** Radius of the outermost circle defining the 100% gradient stop. */
	private float radius;

	/** Variables representing center and focus points. */
	private float centerX, centerY, focusX, focusY;

	/** Radius of the gradient circle squared. */
	private float radiusSq;

	/** Constant part of X, Y user space coordinates. */
	private float constA, constB;

	/** Constant second order delta for simple loop. */
	private float gDeltaDelta;

	/**
	* This value represents the solution when focusX == X. It is called
	* trivial because it is easier to calculate than the general case.
	*/
	private float trivial;

	/** Amount for offset when clamping focus. */
	private static final float SCALEBACK = .99f;

	/**
	* Constructor for RadialGradientPaintContext.
	*
	* @param paint the {@code RadialGradientPaint} from which this context
	* is created
	* @param cm the {@code ColorModel} that receives
	* the {@code Paint} data (this is used only as a hint)
	* @param deviceBounds the device space bounding box of the
	* graphics primitive being rendered
	* @param userBounds the user space bounding box of the
	* graphics primitive being rendered
	* @param t the {@code AffineTransform} from user
	* space into device space (gradientTransform should be
	* concatenated with this)
	* @param hints the hints that the context object uses to choose
	* between rendering alternatives
	* @param cx the center X coordinate in user space of the circle defining
	* the gradient. The last color of the gradient is mapped to
	* the perimeter of this circle.
	* @param cy the center Y coordinate in user space of the circle defining
	* the gradient. The last color of the gradient is mapped to
	* the perimeter of this circle.
	* @param r the radius of the circle defining the extents of the
	* color gradient
	* @param fx the X coordinate in user space to which the first color
	* is mapped
	* @param fy the Y coordinate in user space to which the first color
	* is mapped
	* @param fractions the fractions specifying the gradient distribution
	* @param colors the gradient colors
	* @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
	* @param colorSpace which colorspace to use for interpolation,
	* either SRGB or LINEAR_RGB
	*/
	RadialGradientPaintContext(RadialGradientPaint paint,
	ColorModel cm,
	Rectangle deviceBounds,
	Rectangle2D userBounds,
	AffineTransform t,
	RenderingHints hints,
	float cx, float cy,
	float r,
	float fx, float fy,
	float[] fractions,
	Color[] colors,
	CycleMethod cycleMethod,
	ColorSpaceType colorSpace)
	{
	super(paint, cm, deviceBounds, userBounds, t, hints,
	fractions, colors, cycleMethod, colorSpace);

	// copy some parameters
	centerX = cx;
	centerY = cy;
	focusX = fx;
	focusY = fy;
	radius = r;

	this.isSimpleFocus = (focusX == centerX) && (focusY == centerY);
	this.isNonCyclic = (cycleMethod == CycleMethod.NO_CYCLE);

	// for use in the quadractic equation
	radiusSq = radius * radius;

	float dX = focusX - centerX;
	float dY = focusY - centerY;

	double distSq = (dX * dX) + (dY * dY);

	// test if distance from focus to center is greater than the radius
	if (distSq > radiusSq * SCALEBACK) {
	// clamp focus to radius
	float scalefactor = (float)Math.sqrt(radiusSq * SCALEBACK / distSq);
	dX = dX * scalefactor;
	dY = dY * scalefactor;
	focusX = centerX + dX;
	focusY = centerY + dY;
	}

	// calculate the solution to be used in the case where X == focusX
	// in cyclicCircularGradientFillRaster()
	trivial = (float)Math.sqrt(radiusSq - (dX * dX));

	// constant parts of X, Y user space coordinates
	constA = a02 - centerX;
	constB = a12 - centerY;

	// constant second order delta for simple loop
	gDeltaDelta = 2 * ( a00 * a00 + a10 * a10) / radiusSq;
	}

	/**
	* Return a Raster containing the colors generated for the graphics
	* operation.
	*
	* @param x,y,w,h the area in device space for which colors are
	* generated.
	*/
	protected void fillRaster(int pixels[], int off, int adjust,
	int x, int y, int w, int h)
	{
	if (isSimpleFocus && isNonCyclic && isSimpleLookup) {
	simpleNonCyclicFillRaster(pixels, off, adjust, x, y, w, h);
	} else {
	cyclicCircularGradientFillRaster(pixels, off, adjust, x, y, w, h);
	}
	}

	/**
	* This code works in the simplest of cases, where the focus == center
	* point, the gradient is noncyclic, and the gradient lookup method is
	* fast (single array index, no conversion necessary).
	*/
	private void simpleNonCyclicFillRaster(int pixels[], int off, int adjust,
	int x, int y, int w, int h)
	{
	/* We calculate sqrt(X^2 + Y^2) relative to the radius
	* size to get the fraction for the color to use.
	*
	* Each step along the scanline adds (a00, a10) to (X, Y).
	* If we precalculate:
	* gRel = X^2+Y^2
	* for the start of the row, then for each step we need to
	* calculate:
	* gRel' = (X+a00)^2 + (Y+a10)^2
	* = X^2 + 2Xa00 + a00^2 + Y^2 + 2Ya10 + a10^2
	* = (X^2+Y^2) + 2(Xa00+Y*a10) + (a00^2+a10^2)
	* = gRel + 2(Xa00+Y*a10) + (a00^2+a10^2)
	* = gRel + 2*DP + SD
	* (where DP = dot product between X,Y and a00,a10
	* and SD = dot product square of the delta vector)
	* For the step after that we get:
	* gRel'' = (X+2a00)^2 + (Y+2a10)^2
	* = X^2 + 4Xa00 + 4a00^2 + Y^2 + 4Ya10 + 4a10^2
	* = (X^2+Y^2) + 4(Xa00+Ya10) + 4(a00^2+a10^2)
	* = gRel + 4DP + 4SD
	* = gRel' + 2DP + 3SD
	* The increment changed by:
	* (gRel'' - gRel') - (gRel' - gRel)
	* = (2DP + 3SD) - (2*DP + SD)
	* = 2*SD
	* Note that this value depends only on the (inverse of the)
	* transformation matrix and so is a constant for the loop.
	* To make this all relative to the unit circle, we need to
	* divide all values as follows:
	* [XY] /= radius
	* gRel /= radiusSq
	* DP /= radiusSq
	* SD /= radiusSq
	*/
	// coordinates of UL corner in "user space" relative to center
	float rowX = (a00x) + (a01y) + constA;
	float rowY = (a10x) + (a11y) + constB;

	// second order delta calculated in constructor
	float gDeltaDelta = this.gDeltaDelta;

	// adjust is (scan-w) of pixels array, we need (scan)
	adjust += w;

	// rgb of the 1.0 color used when the distance exceeds gradient radius
	int rgbclip = gradient[fastGradientArraySize];

	for (int j = 0; j < h; j++) {
	// these values depend on the coordinates of the start of the row
	float gRel = (rowX * rowX + rowY * rowY) / radiusSq;
	float gDelta = (2 * ( a00 * rowX + a10 * rowY) / radiusSq +
	gDeltaDelta/2);

	/* Use optimized loops for any cases where gRel >= 1.
	* We do not need to calculate sqrt(gRel) for these
	* values since sqrt(N>=1) == (M>=1).
	* Note that gRel follows a parabola which can only be < 1
	* for a small region around the center on each scanline. In
	* particular:
	* gDeltaDelta is always positive
	* gDelta is <0 until it crosses the midpoint, then >0
	* To the left and right of that region, it will always be
	* >=1 out to infinity, so we can process the line in 3
	* regions:
	* out to the left - quick fill until gRel < 1, updating gRel
	* in the heart - slow fraction=sqrt fill while gRel < 1
	* out to the right - quick fill rest of scanline, ignore gRel
	*/
	int i = 0;
	// Quick fill for "out to the left"
	while (i < w && gRel >= 1.0f) {
	pixels[off + i] = rgbclip;
	gRel += gDelta;
	gDelta += gDeltaDelta;
	i++;
	}
	// Slow fill for "in the heart"
	while (i < w && gRel < 1.0f) {
	int gIndex;

	if (gRel <= 0) {
	gIndex = 0;
	} else {
	float fIndex = gRel * SQRT_LUT_SIZE;
	int iIndex = (int) (fIndex);
	float s0 = sqrtLut[iIndex];
	float s1 = sqrtLut[iIndex+1] - s0;
	fIndex = s0 + (fIndex - iIndex) * s1;
	gIndex = (int) (fIndex * fastGradientArraySize);
	}

	// store the color at this point
	pixels[off + i] = gradient[gIndex];

	// incremental calculation
	gRel += gDelta;
	gDelta += gDeltaDelta;
	i++;
	}
	// Quick fill to end of line for "out to the right"
	while (i < w) {
	pixels[off + i] = rgbclip;
	i++;
	}

	off += adjust;
	rowX += a01;
	rowY += a11;
	}
	}

	// SQRT_LUT_SIZE must be a power of 2 for the test above to work.
	private static final int SQRT_LUT_SIZE = (1 << 11);
	private static float sqrtLut[] = new float[SQRT_LUT_SIZE+1];
	static {
	for (int i = 0; i < sqrtLut.length; i++) {
	sqrtLut[i] = (float) Math.sqrt(i / ((float) SQRT_LUT_SIZE));
	}
	}

	/**
	* Fill the raster, cycling the gradient colors when a point falls outside
	* of the perimeter of the 100% stop circle.
	*
	* This calculation first computes the intersection point of the line
	* from the focus through the current point in the raster, and the
	* perimeter of the gradient circle.
	*
	* Then it determines the percentage distance of the current point along
	* that line (focus is 0%, perimeter is 100%).
	*
	* Equation of a circle centered at (a,b) with radius r:
	* (x-a)^2 + (y-b)^2 = r^2
	* Equation of a line with slope m and y-intercept b:
	* y = mx + b
	* Replacing y in the circle equation and solving using the quadratic
	* formula produces the following set of equations. Constant factors have
	* been extracted out of the inner loop.
	*/
	private void cyclicCircularGradientFillRaster(int pixels[], int off,
	int adjust,
	int x, int y,
	int w, int h)
	{
	// constant part of the C factor of the quadratic equation
	final double constC =
	-radiusSq + (centerX * centerX) + (centerY * centerY);

	// coefficients of the quadratic equation (Ax^2 + Bx + C = 0)
	double A, B, C;

	// slope and y-intercept of the focus-perimeter line
	double slope, yintcpt;

	// intersection with circle X,Y coordinate
	double solutionX, solutionY;

	// constant parts of X, Y coordinates
	final float constX = (a00x) + (a01y) + a02;
	final float constY = (a10x) + (a11y) + a12;

	// constants in inner loop quadratic formula
	final float precalc2 = 2 * centerY;
	final float precalc3 = -2 * centerX;

	// value between 0 and 1 specifying position in the gradient
	float g;

	// determinant of quadratic formula (should always be > 0)
	float det;

	// sq distance from the current point to focus
	float currentToFocusSq;

	// sq distance from the intersect point to focus
	float intersectToFocusSq;

	// temp variables for change in X,Y squared
	float deltaXSq, deltaYSq;

	// used to index pixels array
	int indexer = off;

	// incremental index change for pixels array
	int pixInc = w+adjust;

	// for every row
	for (int j = 0; j < h; j++) {

	// user space point; these are constant from column to column
	float X = (a01*j) + constX;
	float Y = (a11*j) + constY;

	// for every column (inner loop begins here)
	for (int i = 0; i < w; i++) {

	if (X == focusX) {
	// special case to avoid divide by zero
	solutionX = focusX;
	solutionY = centerY;
	solutionY += (Y > focusY) ? trivial : -trivial;
	} else {
	// slope and y-intercept of the focus-perimeter line
	slope = (Y - focusY) / (X - focusX);
	yintcpt = Y - (slope * X);

	// use the quadratic formula to calculate the
	// intersection point
	A = (slope * slope) + 1;
	B = precalc3 + (-2 * slope * (centerY - yintcpt));
	C = constC + (yintcpt* (yintcpt - precalc2));

	det = (float)Math.sqrt((B * B) - (4 * A * C));
	solutionX = -B;

	// choose the positive or negative root depending
	// on where the X coord lies with respect to the focus
	solutionX += (X < focusX)? -det : det;
	solutionX = solutionX / (2 * A); // divisor
	solutionY = (slope * solutionX) + yintcpt;
	}

	// Calculate the square of the distance from the current point
	// to the focus and the square of the distance from the
	// intersection point to the focus. Want the squares so we can
	// do 1 square root after division instead of 2 before.

	deltaXSq = X - focusX;
	deltaXSq = deltaXSq * deltaXSq;

	deltaYSq = Y - focusY;
	deltaYSq = deltaYSq * deltaYSq;

	currentToFocusSq = deltaXSq + deltaYSq;

	deltaXSq = (float)solutionX - focusX;
	deltaXSq = deltaXSq * deltaXSq;

	deltaYSq = (float)solutionY - focusY;
	deltaYSq = deltaYSq * deltaYSq;

	intersectToFocusSq = deltaXSq + deltaYSq;

	// get the percentage (0-1) of the current point along the
	// focus-circumference line
	g = (float)Math.sqrt(currentToFocusSq / intersectToFocusSq);

	// store the color at this point
	pixels[indexer + i] = indexIntoGradientsArrays(g);

	// incremental change in X, Y
	X += a00;
	Y += a10;
	} //end inner loop

	indexer += pixInc;
	} //end outer loop
	}
	}

Back to index...