You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
800 lines
30 KiB
800 lines
30 KiB
/*
|
|
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package java.awt;
|
|
|
|
import java.awt.image.ColorModel;
|
|
import java.lang.annotation.Native;
|
|
import sun.java2d.SunCompositeContext;
|
|
|
|
/**
|
|
* The <code>AlphaComposite</code> class implements basic alpha
|
|
* compositing rules for combining source and destination colors
|
|
* to achieve blending and transparency effects with graphics and
|
|
* images.
|
|
* The specific rules implemented by this class are the basic set
|
|
* of 12 rules described in
|
|
* T. Porter and T. Duff, "Compositing Digital Images", SIGGRAPH 84,
|
|
* 253-259.
|
|
* The rest of this documentation assumes some familiarity with the
|
|
* definitions and concepts outlined in that paper.
|
|
*
|
|
* <p>
|
|
* This class extends the standard equations defined by Porter and
|
|
* Duff to include one additional factor.
|
|
* An instance of the <code>AlphaComposite</code> class can contain
|
|
* an alpha value that is used to modify the opacity or coverage of
|
|
* every source pixel before it is used in the blending equations.
|
|
*
|
|
* <p>
|
|
* It is important to note that the equations defined by the Porter
|
|
* and Duff paper are all defined to operate on color components
|
|
* that are premultiplied by their corresponding alpha components.
|
|
* Since the <code>ColorModel</code> and <code>Raster</code> classes
|
|
* allow the storage of pixel data in either premultiplied or
|
|
* non-premultiplied form, all input data must be normalized into
|
|
* premultiplied form before applying the equations and all results
|
|
* might need to be adjusted back to the form required by the destination
|
|
* before the pixel values are stored.
|
|
*
|
|
* <p>
|
|
* Also note that this class defines only the equations
|
|
* for combining color and alpha values in a purely mathematical
|
|
* sense. The accurate application of its equations depends
|
|
* on the way the data is retrieved from its sources and stored
|
|
* in its destinations.
|
|
* See <a href="#caveats">Implementation Caveats</a>
|
|
* for further information.
|
|
*
|
|
* <p>
|
|
* The following factors are used in the description of the blending
|
|
* equation in the Porter and Duff paper:
|
|
*
|
|
* <blockquote>
|
|
* <table summary="layout">
|
|
* <tr><th align=left>Factor <th align=left>Definition
|
|
* <tr><td><em>A<sub>s</sub></em><td>the alpha component of the source pixel
|
|
* <tr><td><em>C<sub>s</sub></em><td>a color component of the source pixel in premultiplied form
|
|
* <tr><td><em>A<sub>d</sub></em><td>the alpha component of the destination pixel
|
|
* <tr><td><em>C<sub>d</sub></em><td>a color component of the destination pixel in premultiplied form
|
|
* <tr><td><em>F<sub>s</sub></em><td>the fraction of the source pixel that contributes to the output
|
|
* <tr><td><em>F<sub>d</sub></em><td>the fraction of the destination pixel that contributes
|
|
* to the output
|
|
* <tr><td><em>A<sub>r</sub></em><td>the alpha component of the result
|
|
* <tr><td><em>C<sub>r</sub></em><td>a color component of the result in premultiplied form
|
|
* </table>
|
|
* </blockquote>
|
|
*
|
|
* <p>
|
|
* Using these factors, Porter and Duff define 12 ways of choosing
|
|
* the blending factors <em>F<sub>s</sub></em> and <em>F<sub>d</sub></em> to
|
|
* produce each of 12 desirable visual effects.
|
|
* The equations for determining <em>F<sub>s</sub></em> and <em>F<sub>d</sub></em>
|
|
* are given in the descriptions of the 12 static fields
|
|
* that specify visual effects.
|
|
* For example,
|
|
* the description for
|
|
* <a href="#SRC_OVER"><code>SRC_OVER</code></a>
|
|
* specifies that <em>F<sub>s</sub></em> = 1 and <em>F<sub>d</sub></em> = (1-<em>A<sub>s</sub></em>).
|
|
* Once a set of equations for determining the blending factors is
|
|
* known they can then be applied to each pixel to produce a result
|
|
* using the following set of equations:
|
|
*
|
|
* <pre>
|
|
* <em>F<sub>s</sub></em> = <em>f</em>(<em>A<sub>d</sub></em>)
|
|
* <em>F<sub>d</sub></em> = <em>f</em>(<em>A<sub>s</sub></em>)
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>s</sub></em>*<em>F<sub>s</sub></em> + <em>A<sub>d</sub></em>*<em>F<sub>d</sub></em>
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>s</sub></em>*<em>F<sub>s</sub></em> + <em>C<sub>d</sub></em>*<em>F<sub>d</sub></em></pre>
|
|
*
|
|
* <p>
|
|
* The following factors will be used to discuss our extensions to
|
|
* the blending equation in the Porter and Duff paper:
|
|
*
|
|
* <blockquote>
|
|
* <table summary="layout">
|
|
* <tr><th align=left>Factor <th align=left>Definition
|
|
* <tr><td><em>C<sub>sr</sub></em> <td>one of the raw color components of the source pixel
|
|
* <tr><td><em>C<sub>dr</sub></em> <td>one of the raw color components of the destination pixel
|
|
* <tr><td><em>A<sub>ac</sub></em> <td>the "extra" alpha component from the AlphaComposite instance
|
|
* <tr><td><em>A<sub>sr</sub></em> <td>the raw alpha component of the source pixel
|
|
* <tr><td><em>A<sub>dr</sub></em><td>the raw alpha component of the destination pixel
|
|
* <tr><td><em>A<sub>df</sub></em> <td>the final alpha component stored in the destination
|
|
* <tr><td><em>C<sub>df</sub></em> <td>the final raw color component stored in the destination
|
|
* </table>
|
|
*</blockquote>
|
|
*
|
|
* <h3>Preparing Inputs</h3>
|
|
*
|
|
* <p>
|
|
* The <code>AlphaComposite</code> class defines an additional alpha
|
|
* value that is applied to the source alpha.
|
|
* This value is applied as if an implicit SRC_IN rule were first
|
|
* applied to the source pixel against a pixel with the indicated
|
|
* alpha by multiplying both the raw source alpha and the raw
|
|
* source colors by the alpha in the <code>AlphaComposite</code>.
|
|
* This leads to the following equation for producing the alpha
|
|
* used in the Porter and Duff blending equation:
|
|
*
|
|
* <pre>
|
|
* <em>A<sub>s</sub></em> = <em>A<sub>sr</sub></em> * <em>A<sub>ac</sub></em> </pre>
|
|
*
|
|
* All of the raw source color components need to be multiplied
|
|
* by the alpha in the <code>AlphaComposite</code> instance.
|
|
* Additionally, if the source was not in premultiplied form
|
|
* then the color components also need to be multiplied by the
|
|
* source alpha.
|
|
* Thus, the equation for producing the source color components
|
|
* for the Porter and Duff equation depends on whether the source
|
|
* pixels are premultiplied or not:
|
|
*
|
|
* <pre>
|
|
* <em>C<sub>s</sub></em> = <em>C<sub>sr</sub></em> * <em>A<sub>sr</sub></em> * <em>A<sub>ac</sub></em> (if source is not premultiplied)
|
|
* <em>C<sub>s</sub></em> = <em>C<sub>sr</sub></em> * <em>A<sub>ac</sub></em> (if source is premultiplied) </pre>
|
|
*
|
|
* No adjustment needs to be made to the destination alpha:
|
|
*
|
|
* <pre>
|
|
* <em>A<sub>d</sub></em> = <em>A<sub>dr</sub></em> </pre>
|
|
*
|
|
* <p>
|
|
* The destination color components need to be adjusted only if
|
|
* they are not in premultiplied form:
|
|
*
|
|
* <pre>
|
|
* <em>C<sub>d</sub></em> = <em>C<sub>dr</sub></em> * <em>A<sub>d</sub></em> (if destination is not premultiplied)
|
|
* <em>C<sub>d</sub></em> = <em>C<sub>dr</sub></em> (if destination is premultiplied) </pre>
|
|
*
|
|
* <h3>Applying the Blending Equation</h3>
|
|
*
|
|
* <p>
|
|
* The adjusted <em>A<sub>s</sub></em>, <em>A<sub>d</sub></em>,
|
|
* <em>C<sub>s</sub></em>, and <em>C<sub>d</sub></em> are used in the standard
|
|
* Porter and Duff equations to calculate the blending factors
|
|
* <em>F<sub>s</sub></em> and <em>F<sub>d</sub></em> and then the resulting
|
|
* premultiplied components <em>A<sub>r</sub></em> and <em>C<sub>r</sub></em>.
|
|
*
|
|
* <h3>Preparing Results</h3>
|
|
*
|
|
* <p>
|
|
* The results only need to be adjusted if they are to be stored
|
|
* back into a destination buffer that holds data that is not
|
|
* premultiplied, using the following equations:
|
|
*
|
|
* <pre>
|
|
* <em>A<sub>df</sub></em> = <em>A<sub>r</sub></em>
|
|
* <em>C<sub>df</sub></em> = <em>C<sub>r</sub></em> (if dest is premultiplied)
|
|
* <em>C<sub>df</sub></em> = <em>C<sub>r</sub></em> / <em>A<sub>r</sub></em> (if dest is not premultiplied) </pre>
|
|
*
|
|
* Note that since the division is undefined if the resulting alpha
|
|
* is zero, the division in that case is omitted to avoid the "divide
|
|
* by zero" and the color components are left as
|
|
* all zeros.
|
|
*
|
|
* <h3>Performance Considerations</h3>
|
|
*
|
|
* <p>
|
|
* For performance reasons, it is preferable that
|
|
* <code>Raster</code> objects passed to the <code>compose</code>
|
|
* method of a {@link CompositeContext} object created by the
|
|
* <code>AlphaComposite</code> class have premultiplied data.
|
|
* If either the source <code>Raster</code>
|
|
* or the destination <code>Raster</code>
|
|
* is not premultiplied, however,
|
|
* appropriate conversions are performed before and after the compositing
|
|
* operation.
|
|
*
|
|
* <h3><a name="caveats">Implementation Caveats</a></h3>
|
|
*
|
|
* <ul>
|
|
* <li>
|
|
* Many sources, such as some of the opaque image types listed
|
|
* in the <code>BufferedImage</code> class, do not store alpha values
|
|
* for their pixels. Such sources supply an alpha of 1.0 for
|
|
* all of their pixels.
|
|
*
|
|
* <li>
|
|
* Many destinations also have no place to store the alpha values
|
|
* that result from the blending calculations performed by this class.
|
|
* Such destinations thus implicitly discard the resulting
|
|
* alpha values that this class produces.
|
|
* It is recommended that such destinations should treat their stored
|
|
* color values as non-premultiplied and divide the resulting color
|
|
* values by the resulting alpha value before storing the color
|
|
* values and discarding the alpha value.
|
|
*
|
|
* <li>
|
|
* The accuracy of the results depends on the manner in which pixels
|
|
* are stored in the destination.
|
|
* An image format that provides at least 8 bits of storage per color
|
|
* and alpha component is at least adequate for use as a destination
|
|
* for a sequence of a few to a dozen compositing operations.
|
|
* An image format with fewer than 8 bits of storage per component
|
|
* is of limited use for just one or two compositing operations
|
|
* before the rounding errors dominate the results.
|
|
* An image format
|
|
* that does not separately store
|
|
* color components is not a
|
|
* good candidate for any type of translucent blending.
|
|
* For example, <code>BufferedImage.TYPE_BYTE_INDEXED</code>
|
|
* should not be used as a destination for a blending operation
|
|
* because every operation
|
|
* can introduce large errors, due to
|
|
* the need to choose a pixel from a limited palette to match the
|
|
* results of the blending equations.
|
|
*
|
|
* <li>
|
|
* Nearly all formats store pixels as discrete integers rather than
|
|
* the floating point values used in the reference equations above.
|
|
* The implementation can either scale the integer pixel
|
|
* values into floating point values in the range 0.0 to 1.0 or
|
|
* use slightly modified versions of the equations
|
|
* that operate entirely in the integer domain and yet produce
|
|
* analogous results to the reference equations.
|
|
*
|
|
* <p>
|
|
* Typically the integer values are related to the floating point
|
|
* values in such a way that the integer 0 is equated
|
|
* to the floating point value 0.0 and the integer
|
|
* 2^<em>n</em>-1 (where <em>n</em> is the number of bits
|
|
* in the representation) is equated to 1.0.
|
|
* For 8-bit representations, this means that 0x00
|
|
* represents 0.0 and 0xff represents
|
|
* 1.0.
|
|
*
|
|
* <li>
|
|
* The internal implementation can approximate some of the equations
|
|
* and it can also eliminate some steps to avoid unnecessary operations.
|
|
* For example, consider a discrete integer image with non-premultiplied
|
|
* alpha values that uses 8 bits per component for storage.
|
|
* The stored values for a
|
|
* nearly transparent darkened red might be:
|
|
*
|
|
* <pre>
|
|
* (A, R, G, B) = (0x01, 0xb0, 0x00, 0x00)</pre>
|
|
*
|
|
* <p>
|
|
* If integer math were being used and this value were being
|
|
* composited in
|
|
* <a href="#SRC"><code>SRC</code></a>
|
|
* mode with no extra alpha, then the math would
|
|
* indicate that the results were (in integer format):
|
|
*
|
|
* <pre>
|
|
* (A, R, G, B) = (0x01, 0x01, 0x00, 0x00)</pre>
|
|
*
|
|
* <p>
|
|
* Note that the intermediate values, which are always in premultiplied
|
|
* form, would only allow the integer red component to be either 0x00
|
|
* or 0x01. When we try to store this result back into a destination
|
|
* that is not premultiplied, dividing out the alpha will give us
|
|
* very few choices for the non-premultiplied red value.
|
|
* In this case an implementation that performs the math in integer
|
|
* space without shortcuts is likely to end up with the final pixel
|
|
* values of:
|
|
*
|
|
* <pre>
|
|
* (A, R, G, B) = (0x01, 0xff, 0x00, 0x00)</pre>
|
|
*
|
|
* <p>
|
|
* (Note that 0x01 divided by 0x01 gives you 1.0, which is equivalent
|
|
* to the value 0xff in an 8-bit storage format.)
|
|
*
|
|
* <p>
|
|
* Alternately, an implementation that uses floating point math
|
|
* might produce more accurate results and end up returning to the
|
|
* original pixel value with little, if any, roundoff error.
|
|
* Or, an implementation using integer math might decide that since
|
|
* the equations boil down to a virtual NOP on the color values
|
|
* if performed in a floating point space, it can transfer the
|
|
* pixel untouched to the destination and avoid all the math entirely.
|
|
*
|
|
* <p>
|
|
* These implementations all attempt to honor the
|
|
* same equations, but use different tradeoffs of integer and
|
|
* floating point math and reduced or full equations.
|
|
* To account for such differences, it is probably best to
|
|
* expect only that the premultiplied form of the results to
|
|
* match between implementations and image formats. In this
|
|
* case both answers, expressed in premultiplied form would
|
|
* equate to:
|
|
*
|
|
* <pre>
|
|
* (A, R, G, B) = (0x01, 0x01, 0x00, 0x00)</pre>
|
|
*
|
|
* <p>
|
|
* and thus they would all match.
|
|
*
|
|
* <li>
|
|
* Because of the technique of simplifying the equations for
|
|
* calculation efficiency, some implementations might perform
|
|
* differently when encountering result alpha values of 0.0
|
|
* on a non-premultiplied destination.
|
|
* Note that the simplification of removing the divide by alpha
|
|
* in the case of the SRC rule is technically not valid if the
|
|
* denominator (alpha) is 0.
|
|
* But, since the results should only be expected to be accurate
|
|
* when viewed in premultiplied form, a resulting alpha of 0
|
|
* essentially renders the resulting color components irrelevant
|
|
* and so exact behavior in this case should not be expected.
|
|
* </ul>
|
|
* @see Composite
|
|
* @see CompositeContext
|
|
*/
|
|
|
|
public final class AlphaComposite implements Composite {
|
|
/**
|
|
* Both the color and the alpha of the destination are cleared
|
|
* (Porter-Duff Clear rule).
|
|
* Neither the source nor the destination is used as input.
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = 0 and <em>F<sub>d</sub></em> = 0, thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = 0
|
|
* <em>C<sub>r</sub></em> = 0
|
|
*</pre>
|
|
*/
|
|
@Native public static final int CLEAR = 1;
|
|
|
|
/**
|
|
* The source is copied to the destination
|
|
* (Porter-Duff Source rule).
|
|
* The destination is not used as input.
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = 1 and <em>F<sub>d</sub></em> = 0, thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>s</sub></em>
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>s</sub></em>
|
|
*</pre>
|
|
*/
|
|
@Native public static final int SRC = 2;
|
|
|
|
/**
|
|
* The destination is left untouched
|
|
* (Porter-Duff Destination rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = 0 and <em>F<sub>d</sub></em> = 1, thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>d</sub></em>
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>d</sub></em>
|
|
*</pre>
|
|
* @since 1.4
|
|
*/
|
|
@Native public static final int DST = 9;
|
|
// Note that DST was added in 1.4 so it is numbered out of order...
|
|
|
|
/**
|
|
* The source is composited over the destination
|
|
* (Porter-Duff Source Over Destination rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = 1 and <em>F<sub>d</sub></em> = (1-<em>A<sub>s</sub></em>), thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>s</sub></em> + <em>A<sub>d</sub></em>*(1-<em>A<sub>s</sub></em>)
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>s</sub></em> + <em>C<sub>d</sub></em>*(1-<em>A<sub>s</sub></em>)
|
|
*</pre>
|
|
*/
|
|
@Native public static final int SRC_OVER = 3;
|
|
|
|
/**
|
|
* The destination is composited over the source and
|
|
* the result replaces the destination
|
|
* (Porter-Duff Destination Over Source rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = (1-<em>A<sub>d</sub></em>) and <em>F<sub>d</sub></em> = 1, thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>s</sub></em>*(1-<em>A<sub>d</sub></em>) + <em>A<sub>d</sub></em>
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>s</sub></em>*(1-<em>A<sub>d</sub></em>) + <em>C<sub>d</sub></em>
|
|
*</pre>
|
|
*/
|
|
@Native public static final int DST_OVER = 4;
|
|
|
|
/**
|
|
* The part of the source lying inside of the destination replaces
|
|
* the destination
|
|
* (Porter-Duff Source In Destination rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = <em>A<sub>d</sub></em> and <em>F<sub>d</sub></em> = 0, thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>s</sub></em>*<em>A<sub>d</sub></em>
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>s</sub></em>*<em>A<sub>d</sub></em>
|
|
*</pre>
|
|
*/
|
|
@Native public static final int SRC_IN = 5;
|
|
|
|
/**
|
|
* The part of the destination lying inside of the source
|
|
* replaces the destination
|
|
* (Porter-Duff Destination In Source rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = 0 and <em>F<sub>d</sub></em> = <em>A<sub>s</sub></em>, thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>d</sub></em>*<em>A<sub>s</sub></em>
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>d</sub></em>*<em>A<sub>s</sub></em>
|
|
*</pre>
|
|
*/
|
|
@Native public static final int DST_IN = 6;
|
|
|
|
/**
|
|
* The part of the source lying outside of the destination
|
|
* replaces the destination
|
|
* (Porter-Duff Source Held Out By Destination rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = (1-<em>A<sub>d</sub></em>) and <em>F<sub>d</sub></em> = 0, thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>s</sub></em>*(1-<em>A<sub>d</sub></em>)
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>s</sub></em>*(1-<em>A<sub>d</sub></em>)
|
|
*</pre>
|
|
*/
|
|
@Native public static final int SRC_OUT = 7;
|
|
|
|
/**
|
|
* The part of the destination lying outside of the source
|
|
* replaces the destination
|
|
* (Porter-Duff Destination Held Out By Source rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = 0 and <em>F<sub>d</sub></em> = (1-<em>A<sub>s</sub></em>), thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>d</sub></em>*(1-<em>A<sub>s</sub></em>)
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>d</sub></em>*(1-<em>A<sub>s</sub></em>)
|
|
*</pre>
|
|
*/
|
|
@Native public static final int DST_OUT = 8;
|
|
|
|
// Rule 9 is DST which is defined above where it fits into the
|
|
// list logically, rather than numerically
|
|
//
|
|
// public static final int DST = 9;
|
|
|
|
/**
|
|
* The part of the source lying inside of the destination
|
|
* is composited onto the destination
|
|
* (Porter-Duff Source Atop Destination rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = <em>A<sub>d</sub></em> and <em>F<sub>d</sub></em> = (1-<em>A<sub>s</sub></em>), thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>s</sub></em>*<em>A<sub>d</sub></em> + <em>A<sub>d</sub></em>*(1-<em>A<sub>s</sub></em>) = <em>A<sub>d</sub></em>
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>s</sub></em>*<em>A<sub>d</sub></em> + <em>C<sub>d</sub></em>*(1-<em>A<sub>s</sub></em>)
|
|
*</pre>
|
|
* @since 1.4
|
|
*/
|
|
@Native public static final int SRC_ATOP = 10;
|
|
|
|
/**
|
|
* The part of the destination lying inside of the source
|
|
* is composited over the source and replaces the destination
|
|
* (Porter-Duff Destination Atop Source rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = (1-<em>A<sub>d</sub></em>) and <em>F<sub>d</sub></em> = <em>A<sub>s</sub></em>, thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>s</sub></em>*(1-<em>A<sub>d</sub></em>) + <em>A<sub>d</sub></em>*<em>A<sub>s</sub></em> = <em>A<sub>s</sub></em>
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>s</sub></em>*(1-<em>A<sub>d</sub></em>) + <em>C<sub>d</sub></em>*<em>A<sub>s</sub></em>
|
|
*</pre>
|
|
* @since 1.4
|
|
*/
|
|
@Native public static final int DST_ATOP = 11;
|
|
|
|
/**
|
|
* The part of the source that lies outside of the destination
|
|
* is combined with the part of the destination that lies outside
|
|
* of the source
|
|
* (Porter-Duff Source Xor Destination rule).
|
|
*<p>
|
|
* <em>F<sub>s</sub></em> = (1-<em>A<sub>d</sub></em>) and <em>F<sub>d</sub></em> = (1-<em>A<sub>s</sub></em>), thus:
|
|
*<pre>
|
|
* <em>A<sub>r</sub></em> = <em>A<sub>s</sub></em>*(1-<em>A<sub>d</sub></em>) + <em>A<sub>d</sub></em>*(1-<em>A<sub>s</sub></em>)
|
|
* <em>C<sub>r</sub></em> = <em>C<sub>s</sub></em>*(1-<em>A<sub>d</sub></em>) + <em>C<sub>d</sub></em>*(1-<em>A<sub>s</sub></em>)
|
|
*</pre>
|
|
* @since 1.4
|
|
*/
|
|
@Native public static final int XOR = 12;
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque CLEAR rule
|
|
* with an alpha of 1.0f.
|
|
* @see #CLEAR
|
|
*/
|
|
public static final AlphaComposite Clear = new AlphaComposite(CLEAR);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque SRC rule
|
|
* with an alpha of 1.0f.
|
|
* @see #SRC
|
|
*/
|
|
public static final AlphaComposite Src = new AlphaComposite(SRC);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque DST rule
|
|
* with an alpha of 1.0f.
|
|
* @see #DST
|
|
* @since 1.4
|
|
*/
|
|
public static final AlphaComposite Dst = new AlphaComposite(DST);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque SRC_OVER rule
|
|
* with an alpha of 1.0f.
|
|
* @see #SRC_OVER
|
|
*/
|
|
public static final AlphaComposite SrcOver = new AlphaComposite(SRC_OVER);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque DST_OVER rule
|
|
* with an alpha of 1.0f.
|
|
* @see #DST_OVER
|
|
*/
|
|
public static final AlphaComposite DstOver = new AlphaComposite(DST_OVER);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque SRC_IN rule
|
|
* with an alpha of 1.0f.
|
|
* @see #SRC_IN
|
|
*/
|
|
public static final AlphaComposite SrcIn = new AlphaComposite(SRC_IN);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque DST_IN rule
|
|
* with an alpha of 1.0f.
|
|
* @see #DST_IN
|
|
*/
|
|
public static final AlphaComposite DstIn = new AlphaComposite(DST_IN);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque SRC_OUT rule
|
|
* with an alpha of 1.0f.
|
|
* @see #SRC_OUT
|
|
*/
|
|
public static final AlphaComposite SrcOut = new AlphaComposite(SRC_OUT);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque DST_OUT rule
|
|
* with an alpha of 1.0f.
|
|
* @see #DST_OUT
|
|
*/
|
|
public static final AlphaComposite DstOut = new AlphaComposite(DST_OUT);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque SRC_ATOP rule
|
|
* with an alpha of 1.0f.
|
|
* @see #SRC_ATOP
|
|
* @since 1.4
|
|
*/
|
|
public static final AlphaComposite SrcAtop = new AlphaComposite(SRC_ATOP);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque DST_ATOP rule
|
|
* with an alpha of 1.0f.
|
|
* @see #DST_ATOP
|
|
* @since 1.4
|
|
*/
|
|
public static final AlphaComposite DstAtop = new AlphaComposite(DST_ATOP);
|
|
|
|
/**
|
|
* <code>AlphaComposite</code> object that implements the opaque XOR rule
|
|
* with an alpha of 1.0f.
|
|
* @see #XOR
|
|
* @since 1.4
|
|
*/
|
|
public static final AlphaComposite Xor = new AlphaComposite(XOR);
|
|
|
|
@Native private static final int MIN_RULE = CLEAR;
|
|
@Native private static final int MAX_RULE = XOR;
|
|
|
|
float extraAlpha;
|
|
int rule;
|
|
|
|
private AlphaComposite(int rule) {
|
|
this(rule, 1.0f);
|
|
}
|
|
|
|
private AlphaComposite(int rule, float alpha) {
|
|
if (rule < MIN_RULE || rule > MAX_RULE) {
|
|
throw new IllegalArgumentException("unknown composite rule");
|
|
}
|
|
if (alpha >= 0.0f && alpha <= 1.0f) {
|
|
this.rule = rule;
|
|
this.extraAlpha = alpha;
|
|
} else {
|
|
throw new IllegalArgumentException("alpha value out of range");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an <code>AlphaComposite</code> object with the specified rule.
|
|
* @param rule the compositing rule
|
|
* @throws IllegalArgumentException if <code>rule</code> is not one of
|
|
* the following: {@link #CLEAR}, {@link #SRC}, {@link #DST},
|
|
* {@link #SRC_OVER}, {@link #DST_OVER}, {@link #SRC_IN},
|
|
* {@link #DST_IN}, {@link #SRC_OUT}, {@link #DST_OUT},
|
|
* {@link #SRC_ATOP}, {@link #DST_ATOP}, or {@link #XOR}
|
|
*/
|
|
public static AlphaComposite getInstance(int rule) {
|
|
switch (rule) {
|
|
case CLEAR:
|
|
return Clear;
|
|
case SRC:
|
|
return Src;
|
|
case DST:
|
|
return Dst;
|
|
case SRC_OVER:
|
|
return SrcOver;
|
|
case DST_OVER:
|
|
return DstOver;
|
|
case SRC_IN:
|
|
return SrcIn;
|
|
case DST_IN:
|
|
return DstIn;
|
|
case SRC_OUT:
|
|
return SrcOut;
|
|
case DST_OUT:
|
|
return DstOut;
|
|
case SRC_ATOP:
|
|
return SrcAtop;
|
|
case DST_ATOP:
|
|
return DstAtop;
|
|
case XOR:
|
|
return Xor;
|
|
default:
|
|
throw new IllegalArgumentException("unknown composite rule");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an <code>AlphaComposite</code> object with the specified rule and
|
|
* the constant alpha to multiply with the alpha of the source.
|
|
* The source is multiplied with the specified alpha before being composited
|
|
* with the destination.
|
|
* @param rule the compositing rule
|
|
* @param alpha the constant alpha to be multiplied with the alpha of
|
|
* the source. <code>alpha</code> must be a floating point number in the
|
|
* inclusive range [0.0, 1.0].
|
|
* @throws IllegalArgumentException if
|
|
* <code>alpha</code> is less than 0.0 or greater than 1.0, or if
|
|
* <code>rule</code> is not one of
|
|
* the following: {@link #CLEAR}, {@link #SRC}, {@link #DST},
|
|
* {@link #SRC_OVER}, {@link #DST_OVER}, {@link #SRC_IN},
|
|
* {@link #DST_IN}, {@link #SRC_OUT}, {@link #DST_OUT},
|
|
* {@link #SRC_ATOP}, {@link #DST_ATOP}, or {@link #XOR}
|
|
*/
|
|
public static AlphaComposite getInstance(int rule, float alpha) {
|
|
if (alpha == 1.0f) {
|
|
return getInstance(rule);
|
|
}
|
|
return new AlphaComposite(rule, alpha);
|
|
}
|
|
|
|
/**
|
|
* Creates a context for the compositing operation.
|
|
* The context contains state that is used in performing
|
|
* the compositing operation.
|
|
* @param srcColorModel the {@link ColorModel} of the source
|
|
* @param dstColorModel the <code>ColorModel</code> of the destination
|
|
* @return the <code>CompositeContext</code> object to be used to perform
|
|
* compositing operations.
|
|
*/
|
|
public CompositeContext createContext(ColorModel srcColorModel,
|
|
ColorModel dstColorModel,
|
|
RenderingHints hints) {
|
|
return new SunCompositeContext(this, srcColorModel, dstColorModel);
|
|
}
|
|
|
|
/**
|
|
* Returns the alpha value of this <code>AlphaComposite</code>. If this
|
|
* <code>AlphaComposite</code> does not have an alpha value, 1.0 is returned.
|
|
* @return the alpha value of this <code>AlphaComposite</code>.
|
|
*/
|
|
public float getAlpha() {
|
|
return extraAlpha;
|
|
}
|
|
|
|
/**
|
|
* Returns the compositing rule of this <code>AlphaComposite</code>.
|
|
* @return the compositing rule of this <code>AlphaComposite</code>.
|
|
*/
|
|
public int getRule() {
|
|
return rule;
|
|
}
|
|
|
|
/**
|
|
* Returns a similar <code>AlphaComposite</code> object that uses
|
|
* the specified compositing rule.
|
|
* If this object already uses the specified compositing rule,
|
|
* this object is returned.
|
|
* @return an <code>AlphaComposite</code> object derived from
|
|
* this object that uses the specified compositing rule.
|
|
* @param rule the compositing rule
|
|
* @throws IllegalArgumentException if
|
|
* <code>rule</code> is not one of
|
|
* the following: {@link #CLEAR}, {@link #SRC}, {@link #DST},
|
|
* {@link #SRC_OVER}, {@link #DST_OVER}, {@link #SRC_IN},
|
|
* {@link #DST_IN}, {@link #SRC_OUT}, {@link #DST_OUT},
|
|
* {@link #SRC_ATOP}, {@link #DST_ATOP}, or {@link #XOR}
|
|
* @since 1.6
|
|
*/
|
|
public AlphaComposite derive(int rule) {
|
|
return (this.rule == rule)
|
|
? this
|
|
: getInstance(rule, this.extraAlpha);
|
|
}
|
|
|
|
/**
|
|
* Returns a similar <code>AlphaComposite</code> object that uses
|
|
* the specified alpha value.
|
|
* If this object already has the specified alpha value,
|
|
* this object is returned.
|
|
* @return an <code>AlphaComposite</code> object derived from
|
|
* this object that uses the specified alpha value.
|
|
* @param alpha the constant alpha to be multiplied with the alpha of
|
|
* the source. <code>alpha</code> must be a floating point number in the
|
|
* inclusive range [0.0, 1.0].
|
|
* @throws IllegalArgumentException if
|
|
* <code>alpha</code> is less than 0.0 or greater than 1.0
|
|
* @since 1.6
|
|
*/
|
|
public AlphaComposite derive(float alpha) {
|
|
return (this.extraAlpha == alpha)
|
|
? this
|
|
: getInstance(this.rule, alpha);
|
|
}
|
|
|
|
/**
|
|
* Returns the hashcode for this composite.
|
|
* @return a hash code for this composite.
|
|
*/
|
|
public int hashCode() {
|
|
return (Float.floatToIntBits(extraAlpha) * 31 + rule);
|
|
}
|
|
|
|
/**
|
|
* Determines whether the specified object is equal to this
|
|
* <code>AlphaComposite</code>.
|
|
* <p>
|
|
* The result is <code>true</code> if and only if
|
|
* the argument is not <code>null</code> and is an
|
|
* <code>AlphaComposite</code> object that has the same
|
|
* compositing rule and alpha value as this object.
|
|
*
|
|
* @param obj the <code>Object</code> to test for equality
|
|
* @return <code>true</code> if <code>obj</code> equals this
|
|
* <code>AlphaComposite</code>; <code>false</code> otherwise.
|
|
*/
|
|
public boolean equals(Object obj) {
|
|
if (!(obj instanceof AlphaComposite)) {
|
|
return false;
|
|
}
|
|
|
|
AlphaComposite ac = (AlphaComposite) obj;
|
|
|
|
if (rule != ac.rule) {
|
|
return false;
|
|
}
|
|
|
|
if (extraAlpha != ac.extraAlpha) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
}
|