450 lines
17 KiB
450 lines
17 KiB
/*
|
|
* Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
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 + 2*X*a00 + a00^2 + Y^2 + 2*Y*a10 + a10^2
|
|
* = (X^2+Y^2) + 2*(X*a00+Y*a10) + (a00^2+a10^2)
|
|
* = gRel + 2*(X*a00+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+2*a00)^2 + (Y+2*a10)^2
|
|
* = X^2 + 4*X*a00 + 4*a00^2 + Y^2 + 4*Y*a10 + 4*a10^2
|
|
* = (X^2+Y^2) + 4*(X*a00+Y*a10) + 4*(a00^2+a10^2)
|
|
* = gRel + 4*DP + 4*SD
|
|
* = gRel' + 2*DP + 3*SD
|
|
* The increment changed by:
|
|
* (gRel'' - gRel') - (gRel' - gRel)
|
|
* = (2*DP + 3*SD) - (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 = (a00*x) + (a01*y) + constA;
|
|
float rowY = (a10*x) + (a11*y) + 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 = (a00*x) + (a01*y) + a02;
|
|
final float constY = (a10*x) + (a11*y) + 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
|
|
}
|
|
}
|