Back to index...

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

Back to index...