/*
* Copyright (c) 2006, 2013, 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.color.
ColorSpace;
import java.awt.geom.
AffineTransform;
import java.awt.geom.
NoninvertibleTransformException;
import java.awt.geom.
Rectangle2D;
import java.awt.image.
ColorModel;
import java.awt.image.
DataBuffer;
import java.awt.image.
DataBufferInt;
import java.awt.image.
DirectColorModel;
import java.awt.image.
Raster;
import java.awt.image.
SinglePixelPackedSampleModel;
import java.awt.image.
WritableRaster;
import java.lang.ref.
SoftReference;
import java.lang.ref.
WeakReference;
import java.util.
Arrays;
/**
* This is the superclass for all PaintContexts which use a multiple color
* gradient to fill in their raster. It provides the actual color
* interpolation functionality. Subclasses only have to deal with using
* the gradient to fill pixels in a raster.
*
* @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans
*/
abstract class
MultipleGradientPaintContext implements
PaintContext {
/**
* The PaintContext's ColorModel. This is ARGB if colors are not all
* opaque, otherwise it is RGB.
*/
protected
ColorModel model;
/** Color model used if gradient colors are all opaque. */
private static
ColorModel xrgbmodel =
new
DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff);
/** The cached ColorModel. */
protected static
ColorModel cachedModel;
/** The cached raster, which is reusable among instances. */
protected static
WeakReference<
Raster>
cached;
/** Raster is reused whenever possible. */
protected
Raster saved;
/** The method to use when painting out of the gradient bounds. */
protected
CycleMethod cycleMethod;
/** The ColorSpace in which to perform the interpolation */
protected
ColorSpaceType colorSpace;
/** Elements of the inverse transform matrix. */
protected float
a00,
a01,
a10,
a11,
a02,
a12;
/**
* This boolean specifies whether we are in simple lookup mode, where an
* input value between 0 and 1 may be used to directly index into a single
* array of gradient colors. If this boolean value is false, then we have
* to use a 2-step process where we have to determine which gradient array
* we fall into, then determine the index into that array.
*/
protected boolean
isSimpleLookup;
/**
* Size of gradients array for scaling the 0-1 index when looking up
* colors the fast way.
*/
protected int
fastGradientArraySize;
/**
* Array which contains the interpolated color values for each interval,
* used by calculateSingleArrayGradient(). It is protected for possible
* direct access by subclasses.
*/
protected int[]
gradient;
/**
* Array of gradient arrays, one array for each interval. Used by
* calculateMultipleArrayGradient().
*/
private int[][]
gradients;
/** Normalized intervals array. */
private float[]
normalizedIntervals;
/** Fractions array. */
private float[]
fractions;
/** Used to determine if gradient colors are all opaque. */
private int
transparencyTest;
/** Color space conversion lookup tables. */
private static final int
SRGBtoLinearRGB[] = new int[256];
private static final int
LinearRGBtoSRGB[] = new int[256];
static {
// build the tables
for (int
k = 0;
k < 256;
k++) {
SRGBtoLinearRGB[
k] =
convertSRGBtoLinearRGB(
k);
LinearRGBtoSRGB[
k] =
convertLinearRGBtoSRGB(
k);
}
}
/**
* Constant number of max colors between any 2 arbitrary colors.
* Used for creating and indexing gradients arrays.
*/
protected static final int
GRADIENT_SIZE = 256;
protected static final int
GRADIENT_SIZE_INDEX =
GRADIENT_SIZE -1;
/**
* Maximum length of the fast single-array. If the estimated array size
* is greater than this, switch over to the slow lookup method.
* No particular reason for choosing this number, but it seems to provide
* satisfactory performance for the common case (fast lookup).
*/
private static final int
MAX_GRADIENT_ARRAY_SIZE = 5000;
/**
* Constructor for MultipleGradientPaintContext superclass.
*/
protected
MultipleGradientPaintContext(
MultipleGradientPaint mgp,
ColorModel cm,
Rectangle deviceBounds,
Rectangle2D userBounds,
AffineTransform t,
RenderingHints hints,
float[]
fractions,
Color[]
colors,
CycleMethod cycleMethod,
ColorSpaceType colorSpace)
{
if (
deviceBounds == null) {
throw new
NullPointerException("Device bounds cannot be null");
}
if (
userBounds == null) {
throw new
NullPointerException("User bounds cannot be null");
}
if (
t == null) {
throw new
NullPointerException("Transform cannot be null");
}
if (
hints == null) {
throw new
NullPointerException("RenderingHints cannot be null");
}
// The inverse transform is needed to go from device to user space.
// Get all the components of the inverse transform matrix.
AffineTransform tInv;
try {
// the following assumes that the caller has copied the incoming
// transform and is not concerned about it being modified
t.
invert();
tInv =
t;
} catch (
NoninvertibleTransformException e) {
// just use identity transform in this case; better to show
// (incorrect) results than to throw an exception and/or no-op
tInv = new
AffineTransform();
}
double
m[] = new double[6];
tInv.
getMatrix(
m);
a00 = (float)
m[0];
a10 = (float)
m[1];
a01 = (float)
m[2];
a11 = (float)
m[3];
a02 = (float)
m[4];
a12 = (float)
m[5];
// copy some flags
this.
cycleMethod =
cycleMethod;
this.
colorSpace =
colorSpace;
// we can avoid copying this array since we do not modify its values
this.
fractions =
fractions;
// note that only one of these values can ever be non-null (we either
// store the fast gradient array or the slow one, but never both
// at the same time)
int[]
gradient =
(
mgp.
gradient != null) ?
mgp.
gradient.
get() : null;
int[][]
gradients =
(
mgp.
gradients != null) ?
mgp.
gradients.
get() : null;
if (
gradient == null &&
gradients == null) {
// we need to (re)create the appropriate values
calculateLookupData(
colors);
// now cache the calculated values in the
// MultipleGradientPaint instance for future use
mgp.
model = this.
model;
mgp.
normalizedIntervals = this.
normalizedIntervals;
mgp.
isSimpleLookup = this.
isSimpleLookup;
if (
isSimpleLookup) {
// only cache the fast array
mgp.
fastGradientArraySize = this.
fastGradientArraySize;
mgp.
gradient = new
SoftReference<int[]>(this.
gradient);
} else {
// only cache the slow array
mgp.
gradients = new
SoftReference<int[][]>(this.
gradients);
}
} else {
// use the values cached in the MultipleGradientPaint instance
this.
model =
mgp.
model;
this.
normalizedIntervals =
mgp.
normalizedIntervals;
this.
isSimpleLookup =
mgp.
isSimpleLookup;
this.
gradient =
gradient;
this.
fastGradientArraySize =
mgp.
fastGradientArraySize;
this.
gradients =
gradients;
}
}
/**
* This function is the meat of this class. It calculates an array of
* gradient colors based on an array of fractions and color values at
* those fractions.
*/
private void
calculateLookupData(
Color[]
colors) {
Color[]
normalizedColors;
if (
colorSpace ==
ColorSpaceType.
LINEAR_RGB) {
// create a new colors array
normalizedColors = new
Color[
colors.length];
// convert the colors using the lookup table
for (int
i = 0;
i <
colors.length;
i++) {
int
argb =
colors[
i].
getRGB();
int
a =
argb >>> 24;
int
r =
SRGBtoLinearRGB[(
argb >> 16) & 0xff];
int
g =
SRGBtoLinearRGB[(
argb >> 8) & 0xff];
int
b =
SRGBtoLinearRGB[(
argb ) & 0xff];
normalizedColors[
i] = new
Color(
r,
g,
b,
a);
}
} else {
// we can just use this array by reference since we do not
// modify its values in the case of SRGB
normalizedColors =
colors;
}
// this will store the intervals (distances) between gradient stops
normalizedIntervals = new float[
fractions.length-1];
// convert from fractions into intervals
for (int
i = 0;
i <
normalizedIntervals.length;
i++) {
// interval distance is equal to the difference in positions
normalizedIntervals[
i] = this.
fractions[
i+1] - this.
fractions[
i];
}
// initialize to be fully opaque for ANDing with colors
transparencyTest = 0xff000000;
// array of interpolation arrays
gradients = new int[
normalizedIntervals.length][];
// find smallest interval
float
Imin = 1;
for (int
i = 0;
i <
normalizedIntervals.length;
i++) {
Imin = (
Imin >
normalizedIntervals[
i]) ?
normalizedIntervals[
i] :
Imin;
}
// Estimate the size of the entire gradients array.
// This is to prevent a tiny interval from causing the size of array
// to explode. If the estimated size is too large, break to using
// separate arrays for each interval, and using an indexing scheme at
// look-up time.
int
estimatedSize = 0;
for (int
i = 0;
i <
normalizedIntervals.length;
i++) {
estimatedSize += (
normalizedIntervals[
i]/
Imin) *
GRADIENT_SIZE;
}
if (
estimatedSize >
MAX_GRADIENT_ARRAY_SIZE) {
// slow method
calculateMultipleArrayGradient(
normalizedColors);
} else {
// fast method
calculateSingleArrayGradient(
normalizedColors,
Imin);
}
// use the most "economical" model
if ((
transparencyTest >>> 24) == 0xff) {
model =
xrgbmodel;
} else {
model =
ColorModel.
getRGBdefault();
}
}
/**
* FAST LOOKUP METHOD
*
* This method calculates the gradient color values and places them in a
* single int array, gradient[]. It does this by allocating space for
* each interval based on its size relative to the smallest interval in
* the array. The smallest interval is allocated 255 interpolated values
* (the maximum number of unique in-between colors in a 24 bit color
* system), and all other intervals are allocated
* size = (255 * the ratio of their size to the smallest interval).
*
* This scheme expedites a speedy retrieval because the colors are
* distributed along the array according to their user-specified
* distribution. All that is needed is a relative index from 0 to 1.
*
* The only problem with this method is that the possibility exists for
* the array size to balloon in the case where there is a
* disproportionately small gradient interval. In this case the other
* intervals will be allocated huge space, but much of that data is
* redundant. We thus need to use the space conserving scheme below.
*
* @param Imin the size of the smallest interval
*/
private void
calculateSingleArrayGradient(
Color[]
colors, float
Imin) {
// set the flag so we know later it is a simple (fast) lookup
isSimpleLookup = true;
// 2 colors to interpolate
int
rgb1,
rgb2;
//the eventual size of the single array
int
gradientsTot = 1;
// for every interval (transition between 2 colors)
for (int
i = 0;
i <
gradients.length;
i++) {
// create an array whose size is based on the ratio to the
// smallest interval
int
nGradients = (int)((
normalizedIntervals[
i]/
Imin)*255f);
gradientsTot +=
nGradients;
gradients[
i] = new int[
nGradients];
// the 2 colors (keyframes) to interpolate between
rgb1 =
colors[
i].
getRGB();
rgb2 =
colors[
i+1].
getRGB();
// fill this array with the colors in between rgb1 and rgb2
interpolate(
rgb1,
rgb2,
gradients[
i]);
// if the colors are opaque, transparency should still
// be 0xff000000
transparencyTest &=
rgb1;
transparencyTest &=
rgb2;
}
// put all gradients in a single array
gradient = new int[
gradientsTot];
int
curOffset = 0;
for (int
i = 0;
i <
gradients.length;
i++){
System.
arraycopy(
gradients[
i], 0,
gradient,
curOffset,
gradients[
i].length);
curOffset +=
gradients[
i].length;
}
gradient[
gradient.length-1] =
colors[
colors.length-1].
getRGB();
// if interpolation occurred in Linear RGB space, convert the
// gradients back to sRGB using the lookup table
if (
colorSpace ==
ColorSpaceType.
LINEAR_RGB) {
for (int
i = 0;
i <
gradient.length;
i++) {
gradient[
i] =
convertEntireColorLinearRGBtoSRGB(
gradient[
i]);
}
}
fastGradientArraySize =
gradient.length - 1;
}
/**
* SLOW LOOKUP METHOD
*
* This method calculates the gradient color values for each interval and
* places each into its own 255 size array. The arrays are stored in
* gradients[][]. (255 is used because this is the maximum number of
* unique colors between 2 arbitrary colors in a 24 bit color system.)
*
* This method uses the minimum amount of space (only 255 * number of
* intervals), but it aggravates the lookup procedure, because now we
* have to find out which interval to select, then calculate the index
* within that interval. This causes a significant performance hit,
* because it requires this calculation be done for every point in
* the rendering loop.
*
* For those of you who are interested, this is a classic example of the
* time-space tradeoff.
*/
private void
calculateMultipleArrayGradient(
Color[]
colors) {
// set the flag so we know later it is a non-simple lookup
isSimpleLookup = false;
// 2 colors to interpolate
int
rgb1,
rgb2;
// for every interval (transition between 2 colors)
for (int
i = 0;
i <
gradients.length;
i++){
// create an array of the maximum theoretical size for
// each interval
gradients[
i] = new int[
GRADIENT_SIZE];
// get the the 2 colors
rgb1 =
colors[
i].
getRGB();
rgb2 =
colors[
i+1].
getRGB();
// fill this array with the colors in between rgb1 and rgb2
interpolate(
rgb1,
rgb2,
gradients[
i]);
// if the colors are opaque, transparency should still
// be 0xff000000
transparencyTest &=
rgb1;
transparencyTest &=
rgb2;
}
// if interpolation occurred in Linear RGB space, convert the
// gradients back to SRGB using the lookup table
if (
colorSpace ==
ColorSpaceType.
LINEAR_RGB) {
for (int
j = 0;
j <
gradients.length;
j++) {
for (int
i = 0;
i <
gradients[
j].length;
i++) {
gradients[
j][
i] =
convertEntireColorLinearRGBtoSRGB(
gradients[
j][
i]);
}
}
}
}
/**
* Yet another helper function. This one linearly interpolates between
* 2 colors, filling up the output array.
*
* @param rgb1 the start color
* @param rgb2 the end color
* @param output the output array of colors; must not be null
*/
private void
interpolate(int
rgb1, int
rgb2, int[]
output) {
// color components
int
a1,
r1,
g1,
b1,
da,
dr,
dg,
db;
// step between interpolated values
float
stepSize = 1.0f /
output.length;
// extract color components from packed integer
a1 = (
rgb1 >> 24) & 0xff;
r1 = (
rgb1 >> 16) & 0xff;
g1 = (
rgb1 >> 8) & 0xff;
b1 = (
rgb1 ) & 0xff;
// calculate the total change in alpha, red, green, blue
da = ((
rgb2 >> 24) & 0xff) -
a1;
dr = ((
rgb2 >> 16) & 0xff) -
r1;
dg = ((
rgb2 >> 8) & 0xff) -
g1;
db = ((
rgb2 ) & 0xff) -
b1;
// for each step in the interval calculate the in-between color by
// multiplying the normalized current position by the total color
// change (0.5 is added to prevent truncation round-off error)
for (int
i = 0;
i <
output.length;
i++) {
output[
i] =
(((int) ((
a1 +
i *
da *
stepSize) + 0.5) << 24)) |
(((int) ((
r1 +
i *
dr *
stepSize) + 0.5) << 16)) |
(((int) ((
g1 +
i *
dg *
stepSize) + 0.5) << 8)) |
(((int) ((
b1 +
i *
db *
stepSize) + 0.5) ));
}
}
/**
* Yet another helper function. This one extracts the color components
* of an integer RGB triple, converts them from LinearRGB to SRGB, then
* recompacts them into an int.
*/
private int
convertEntireColorLinearRGBtoSRGB(int
rgb) {
// color components
int
a1,
r1,
g1,
b1;
// extract red, green, blue components
a1 = (
rgb >> 24) & 0xff;
r1 = (
rgb >> 16) & 0xff;
g1 = (
rgb >> 8) & 0xff;
b1 = (
rgb ) & 0xff;
// use the lookup table
r1 =
LinearRGBtoSRGB[
r1];
g1 =
LinearRGBtoSRGB[
g1];
b1 =
LinearRGBtoSRGB[
b1];
// re-compact the components
return ((
a1 << 24) |
(
r1 << 16) |
(
g1 << 8) |
(
b1 ));
}
/**
* Helper function to index into the gradients array. This is necessary
* because each interval has an array of colors with uniform size 255.
* However, the color intervals are not necessarily of uniform length, so
* a conversion is required.
*
* @param position the unmanipulated position, which will be mapped
* into the range 0 to 1
* @returns integer color to display
*/
protected final int
indexIntoGradientsArrays(float
position) {
// first, manipulate position value depending on the cycle method
if (
cycleMethod ==
CycleMethod.
NO_CYCLE) {
if (
position > 1) {
// upper bound is 1
position = 1;
} else if (
position < 0) {
// lower bound is 0
position = 0;
}
} else if (
cycleMethod ==
CycleMethod.
REPEAT) {
// get the fractional part
// (modulo behavior discards integer component)
position =
position - (int)
position;
//position should now be between -1 and 1
if (
position < 0) {
// force it to be in the range 0-1
position =
position + 1;
}
} else { // cycleMethod == CycleMethod.REFLECT
if (
position < 0) {
// take absolute value
position = -
position;
}
// get the integer part
int
part = (int)
position;
// get the fractional part
position =
position -
part;
if ((
part & 1) == 1) {
// integer part is odd, get reflected color instead
position = 1 -
position;
}
}
// now, get the color based on this 0-1 position...
if (
isSimpleLookup) {
// easy to compute: just scale index by array size
return
gradient[(int)(
position *
fastGradientArraySize)];
} else {
// more complicated computation, to save space
// for all the gradient interval arrays
for (int
i = 0;
i <
gradients.length;
i++) {
if (
position <
fractions[
i+1]) {
// this is the array we want
float
delta =
position -
fractions[
i];
// this is the interval we want
int
index = (int)((
delta /
normalizedIntervals[
i])
* (
GRADIENT_SIZE_INDEX));
return
gradients[
i][
index];
}
}
}
return
gradients[
gradients.length - 1][
GRADIENT_SIZE_INDEX];
}
/**
* Helper function to convert a color component in sRGB space to linear
* RGB space. Used to build a static lookup table.
*/
private static int
convertSRGBtoLinearRGB(int
color) {
float
input,
output;
input =
color / 255.0f;
if (
input <= 0.04045f) {
output =
input / 12.92f;
} else {
output = (float)
Math.
pow((
input + 0.055) / 1.055, 2.4);
}
return
Math.
round(
output * 255.0f);
}
/**
* Helper function to convert a color component in linear RGB space to
* SRGB space. Used to build a static lookup table.
*/
private static int
convertLinearRGBtoSRGB(int
color) {
float
input,
output;
input =
color/255.0f;
if (
input <= 0.0031308) {
output =
input * 12.92f;
} else {
output = (1.055f *
((float)
Math.
pow(
input, (1.0 / 2.4)))) - 0.055f;
}
return
Math.
round(
output * 255.0f);
}
/**
* {@inheritDoc}
*/
public final
Raster getRaster(int
x, int
y, int
w, int
h) {
// If working raster is big enough, reuse it. Otherwise,
// build a large enough new one.
Raster raster =
saved;
if (
raster == null ||
raster.
getWidth() <
w ||
raster.
getHeight() <
h)
{
raster =
getCachedRaster(
model,
w,
h);
saved =
raster;
}
// Access raster internal int array. Because we use a DirectColorModel,
// we know the DataBuffer is of type DataBufferInt and the SampleModel
// is SinglePixelPackedSampleModel.
// Adjust for initial offset in DataBuffer and also for the scanline
// stride.
// These calls make the DataBuffer non-acceleratable, but the
// Raster is never Stable long enough to accelerate anyway...
DataBufferInt rasterDB = (
DataBufferInt)
raster.
getDataBuffer();
int[]
pixels =
rasterDB.
getData(0);
int
off =
rasterDB.
getOffset();
int
scanlineStride = ((
SinglePixelPackedSampleModel)
raster.
getSampleModel()).
getScanlineStride();
int
adjust =
scanlineStride -
w;
fillRaster(
pixels,
off,
adjust,
x,
y,
w,
h); // delegate to subclass
return
raster;
}
protected abstract void
fillRaster(int
pixels[], int
off, int
adjust,
int
x, int
y, int
w, int
h);
/**
* Took this cacheRaster code from GradientPaint. It appears to recycle
* rasters for use by any other instance, as long as they are sufficiently
* large.
*/
private static synchronized
Raster getCachedRaster(
ColorModel cm,
int
w, int
h)
{
if (
cm ==
cachedModel) {
if (
cached != null) {
Raster ras = (
Raster)
cached.
get();
if (
ras != null &&
ras.
getWidth() >=
w &&
ras.
getHeight() >=
h)
{
cached = null;
return
ras;
}
}
}
return
cm.
createCompatibleWritableRaster(
w,
h);
}
/**
* Took this cacheRaster code from GradientPaint. It appears to recycle
* rasters for use by any other instance, as long as they are sufficiently
* large.
*/
private static synchronized void
putCachedRaster(
ColorModel cm,
Raster ras)
{
if (
cached != null) {
Raster cras = (
Raster)
cached.
get();
if (
cras != null) {
int
cw =
cras.
getWidth();
int
ch =
cras.
getHeight();
int
iw =
ras.
getWidth();
int
ih =
ras.
getHeight();
if (
cw >=
iw &&
ch >=
ih) {
return;
}
if (
cw *
ch >=
iw *
ih) {
return;
}
}
}
cachedModel =
cm;
cached = new
WeakReference<
Raster>(
ras);
}
/**
* {@inheritDoc}
*/
public final void
dispose() {
if (
saved != null) {
putCachedRaster(
model,
saved);
saved = null;
}
}
/**
* {@inheritDoc}
*/
public final
ColorModel getColorModel() {
return
model;
}
}