java.lang.Object
- java.awt.AlphaComposite

实现的所有接口

Composite
```
public final class AlphaComposite
extends Object
implements Composite
```
AlphaComposite类实现了基本的alpha合成规则，用于组合源颜色和目标颜色，以实现图形和图像的混合和透明效果。该类实现的具体规则是T.Porter和T.Duff，“Compositing Digital Images”，SIGGRAPH 84,253-259中描述的基本12条规则。本文档的其余部分假定您熟悉该文章中概述的定义和概念。
该类扩展了Porter和Duff定义的标准方程，以包括一个附加因子。 AlphaComposite类的实例可以包含一个alpha值，该值用于在混合方程中使用之前修改每个源像素的不透明度或覆盖率。

重要的是要注意由波特和达夫纸定义的方程都被定义为对由其相应的α分量预乘的颜色分量进行操作。由于ColorModel和Raster类允许以预乘或非预乘形式存储像素数据，因此在应用方程之前，所有输入数据必须归一化为预乘形式，并且所有结果可能需要调整回目标所需的形式在存储像素值之前。

另请注意，此类仅定义纯粹数学意义上的颜色和alpha值组合的公式。其方程的准确应用取决于从其来源检索数据并存储在其目的地中的方式。有关详细信息，请参阅Implementation Caveats 。

在Porter和Duff论文中对混合方程的描述中使用了以下因子：
Factors Factor Definition A_s the alpha component of the source pixel C_s a color component of the source pixel in premultiplied form A_d the alpha component of the destination pixel C_d a color component of the destination pixel in premultiplied form F_s the fraction of the source pixel that contributes to the output F_d the fraction of the destination pixel that contributes to the output A_r the alpha component of the result C_r a color component of the result in premultiplied form

使用这些因素，Porter和Duff定义了12种选择混合因子F _s和F _{d的方法，}以产生12种理想的视觉效果。用于确定F _s和F _d的等式在指定视觉效果的12个静态场的描述中给出。例如， SRC_OVER的描述指定F _s = 1且F _d =（1- A _s ）。一旦确定了用于确定混合因子的一组方程，则可以将它们应用于每个像素以使用以下方程组产生结果：
```
  F_s = f(A_d)
      F_d = f(A_s)
      A_r = A_s*F_s + A_d*F_d
      C_r = C_s*F_s + C_d*F_d 
```
以下因素将用于讨论我们在Porter和Duff论文中对混合方程的扩展：
Factors Factor Definition C_sr one of the raw color components of the source pixel C_dr one of the raw color components of the destination pixel A_ac the "extra" alpha component from the AlphaComposite instance A_sr the raw alpha component of the source pixel A_dr the raw alpha component of the destination pixel A_df the final alpha component stored in the destination C_df the final raw color component stored in the destination

准备输入

AlphaComposite类定义了应用于源alpha的附加Alpha值。应用此值，就好像首先将隐式SRC_IN规则应用于具有指示alpha的像素的源像素，方法是将原始源alpha和原始源颜色乘以AlphaComposite中的AlphaComposite 。这导致以下等式用于产生在Porter和Duff混合方程中使用的α：
```
  A_s = A_sr * A_ac 
```
所有原始颜色分量都需要乘以AlphaComposite实例中的alpha。另外，如果源不是预乘形式，则颜色分量也需要乘以源alpha。因此，用于产生Porter和Duff方程的源颜色分量的等式取决于源像素是否被预乘：
```
  C_s = C_sr * A_sr * A_ac     (if source is not premultiplied)
      C_s = C_sr * A_ac           (if source is premultiplied) 
```
无需对目标alpha进行调整：
```
  A_d = A_dr 
```
仅当目标颜色组件不是预乘形式时，才需要调整目标颜色组件：
```
  C_d = C_dr * A_d    (if destination is not premultiplied)
      C_d = C_dr         (if destination is premultiplied) 
```
应用混合方程

调整后的A _s ， A _d ， C _s和C _d用于标准Porter和Duff方程中，以计算混合因子F _s和F _d ，然后计算得到的预乘分量A _r和C _r 。

准备结果

如果要将结果存储回保存未预乘的数据的目标缓冲区，则只需调整结果，使用以下等式：
```
  A_df = A_r
      C_df = C_r                 (if dest is premultiplied)
      C_df = C_r / A_r            (if dest is not premultiplied) 
```
请注意，由于如果得到的alpha为零，则除法未定义，则省略该情况下的除法以避免“除以零”并且颜色分量保留为全零。
性能注意事项

出于性能原因，最好将Raster对象传递给由AlphaComposite类创建的CompositeContext对象的compose方法具有预乘数据。但是，如果源Raster或目标Raster未预乘，则在合成操作之前和之后执行适当的转换。

Implementation Caveats
- 许多源（例如BufferedImage类中列出的某些不透明图像类型）不会为其像素存储Alpha值。这些源为其所有像素提供1.0的alpha值。
- 许多目的地也没有地方存储由此类执行的混合计算产生的alpha值。这样的目的地因此隐含地丢弃该类产生的结果α值。建议此类目的地应将其存储的颜色值视为非预乘，并在存储颜色值并丢弃Alpha值之前将得到的颜色值除以得到的alpha值。
- 结果的准确性取决于像素存储在目的地的方式。每种颜色和alpha分量提供至少8位存储的图像格式至少足以用作几个到十几个合成操作的序列的目的地。在舍入误差支配结果之前，每个组件具有少于8位存储的图像格式仅用于一次或两次合成操作。不单独存储颜色分量的图像格式不适合任何类型的半透明混合。例如， BufferedImage.TYPE_BYTE_INDEXED不应该用作混合操作的目标，因为每个操作都会引入大的错误，因为需要从有限的调色板中选择一个像素以匹配混合方程的结果。
- 几乎所有格式都将像素存储为离散整数，而不是上面参考方程中使用的浮点值。该实现可以将整数像素值缩放到0.0到1.0范围内的浮点值，或者使用完全在整数域中操作的方程的略微修改版本，然后产生与参考方程类似的结果。
  通常，整数值与浮点值相关，其方式是整数0等于浮点值0.0和整数2 ^ n -1（其中n是表示中的位数）等于1.0。对于8位表示，这意味着0x00表示0.0，0xff表示1.0。
- 内部实现可以近似某些方程式，也可以消除一些步骤以避免不必要的操作。例如，考虑具有非预乘alpha值的离散整数图像，每个组件使用8位进行存储。几乎透明的暗红色的存储值可能是：
```
  (A, R, G, B) = (0x01, 0xb0, 0x00, 0x00) 
```
  如果正在使用整数数学并且该值在SRC模式下合成而没有额外的alpha，那么数学将表明结果是（整数格式）：
```
  (A, R, G, B) = (0x01, 0x01, 0x00, 0x00) 
```
  请注意，中间值始终采用预乘形式，只允许整数红色分量为0x00或0x01。当我们尝试将此结果存储回未预乘的目标时，除去alpha将使我们很少选择非预乘的红色值。在这种情况下，在没有快捷方式的情况下在整数空间中执行数学运算的实现很可能最终得到以下最终像素值：
```
  (A, R, G, B) = (0x01, 0xff, 0x00, 0x00) 
```
  （注意，0x01除以0x01会得到1.0，相当于8位存储格式中的值0xff。）
  或者，使用浮点数学运算的实现可能会产生更准确的结果，并最终返回到原始像素值，几乎没有任何舍入误差。或者，使用整数数学的实现可能决定，如果在浮点空间中执行，则方程式可归结为颜色值上的虚拟NOP，它可以将未经处理的像素传输到目标并完全避免所有数学运算。
  这些实现都试图遵循相同的方程，但使用整数和浮点数学以及简化或完整方程的不同权衡。为了解释这种差异，最好只期望结果的预乘形式在实现和图像格式之间匹配。在这种情况下，以预乘形式表示的两个答案等同于：
```
  (A, R, G, B) = (0x01, 0x01, 0x00, 0x00) 
```
  因此他们都会匹配。
- 由于简化用于计算效率的等式的技术，当在非预乘目的地上遇到0.0的结果α值时，一些实现可能执行不同。请注意，如果分母（alpha）为0，则在SRC规则的情况下，通过alpha去除除法的简化在技术上是无效的。但是，由于结果只能在预乘形式下查看时才能准确，因此结果alpha的0基本上使得生成的颜色分量无关紧要，因此不应该期望在这种情况下的精确行为。
另请参见：

Composite ， CompositeContext

字段汇总

字段
变量和类型	字段	描述
`static AlphaComposite`	`Clear`	`AlphaComposite`对象，它实现了不透明的CLEAR规则，其alpha值为1.0f。
`static int`	`CLEAR`	目的地的颜色和阿尔法都被清除（Porter-Duff清除规则）。
`static AlphaComposite`	`Dst`	`AlphaComposite`实现不透明DST规则且alpha为1.0f的对象。
`static int`	`DST`	目的地保持不变（Porter-Duff目的地规则）。
`static int`	`DST_ATOP`	位于源内部的目标部分在源上合成并替换目标（Porter-Duff Destination Atop Source规则）。
`static int`	`DST_IN`	位于源内的目标部分将替换目标（Porter-Duff Destination In Source规则）。
`static int`	`DST_OUT`	位于源外部的目的地部分将替换目标（Porter-Duff Destination Held Out By Source规则）。
`static int`	`DST_OVER`	目标是在源上合成的，结果将替换目标（Porter-Duff Destination Over Source规则）。
`static AlphaComposite`	`DstAtop`	`AlphaComposite`实现不透明DST_ATOP规则且alpha为1.0f的对象。
`static AlphaComposite`	`DstIn`	`AlphaComposite`实现不透明DST_IN规则且alpha为1.0f的对象。
`static AlphaComposite`	`DstOut`	`AlphaComposite`实现不透明DST_OUT规则且alpha为1.0f的对象。
`static AlphaComposite`	`DstOver`	`AlphaComposite`实现不透明DST_OVER规则且alpha为1.0f的对象。
`static AlphaComposite`	`Src`	`AlphaComposite`实现不透明SRC规则且alpha为1.0f的对象。
`static int`	`SRC`	源被复制到目标（Porter-Duff源规则）。
`static int`	`SRC_ATOP`	位于目的地内部的源的部分被合成到目的地（Porter-Duff Source Atop Destination规则）。
`static int`	`SRC_IN`	位于目标内部的源部分将替换目标（Porter-Duff Source In Destination规则）。
`static int`	`SRC_OUT`	位于目的地之外的源部分将替换目标（Porter-Duff Source Held Out By Destination规则）。
`static int`	`SRC_OVER`	源在目标上合成（Porter-Duff Source Over Destination规则）。
`static AlphaComposite`	`SrcAtop`	`AlphaComposite`实现不透明SRC_ATOP规则且alpha为1.0f的对象。
`static AlphaComposite`	`SrcIn`	`AlphaComposite`实现不透明SRC_IN规则且alpha为1.0f的对象。
`static AlphaComposite`	`SrcOut`	`AlphaComposite`实现不透明SRC_OUT规则且alpha为1.0f的对象。
`static AlphaComposite`	`SrcOver`	`AlphaComposite`实现不透明SRC_OVER规则且alpha为1.0f的对象。
`static AlphaComposite`	`Xor`	`AlphaComposite`实现不透明XOR规则且alpha为1.0f的对象。
`static int`	`XOR`	位于目标之外的源部分与位于源之外的目标部分（Porter-Duff源Xor目标规则）组合在一起。

方法摘要

所有方法静态方法实例方法具体的方法
变量和类型	方法	描述
`CompositeContext`	`createContext(ColorModel srcColorModel, ColorModel dstColorModel, RenderingHints hints)`	为合成操作创建上下文。
`AlphaComposite`	`derive(float alpha)`	返回使用指定alpha值的类似 `AlphaComposite`对象。
`AlphaComposite`	`derive(int rule)`	返回使用指定合成规则的类似 `AlphaComposite`对象。
`boolean`	`equals(Object obj)`	确定指定的对象是否等于此 `AlphaComposite` 。
`float`	`getAlpha()`	返回此 `AlphaComposite`的alpha值。
`static AlphaComposite`	`getInstance(int rule)`	使用指定的规则创建 `AlphaComposite`对象。
`static AlphaComposite`	`getInstance(int rule, float alpha)`	使用指定的规则创建一个 `AlphaComposite`对象，并使用常量alpha与源的alpha相乘。
`int`	`getRule()`	返回此 `AlphaComposite`的合成规则。
`int`	`hashCode()`	返回此组合的哈希码。

声明方法的类 java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- 字段详细信息
  - CLEAR
```
@Native
public static final int CLEAR
```
    目的地的颜色和阿尔法都被清除（Porter-Duff清除规则）。源和目标都不用作输入。
    F _s = 0且F _d = 0，因此：
    
    A_r = 0 C_r = 0
    另请参见：
    
    常数字段值
  - SRC
```
@Native
public static final int SRC
```
    源被复制到目标（Porter-Duff源规则）。目的地不用作输入。
    F _s = 1且F _d = 0，因此：
    
    A_r = A_s C_r = C_s
    另请参见：
    
    常数字段值
  - DST
```
@Native
public static final int DST
```
    目的地保持不变（Porter-Duff目的地规则）。
    F _s = 0且F _d = 1，因此：
    
    A_r = A_d C_r = C_d
    从以下版本开始：
    
    1.4
    
    另请参见：
    
    常数字段值
  - SRC_OVER
```
@Native
public static final int SRC_OVER
```
    源在目标上合成（Porter-Duff Source Over Destination规则）。
    F _s = 1且F _d =（1- A _s ），因此：
    
    A_r = A_s + A_d*(1-A_s) C_r = C_s + C_d*(1-A_s)
    另请参见：
    
    常数字段值
  - DST_OVER
```
@Native
public static final int DST_OVER
```
    目标是在源上合成的，结果将替换目标（Porter-Duff Destination Over Source规则）。
    F _s =（1- A _d ）且F _d = 1，因此：
    
    A_r = A_s*(1-A_d) + A_d C_r = C_s*(1-A_d) + C_d
    另请参见：
    
    常数字段值
  - SRC_IN
```
@Native
public static final int SRC_IN
```
    位于目标内部的源部分将替换目标（Porter-Duff Source In Destination规则）。
    F _s = A _d且F _d = 0，因此：
    
    A_r = A_s*A_d C_r = C_s*A_d
    另请参见：
    
    常数字段值
  - DST_IN
```
@Native
public static final int DST_IN
```
    位于源内的目标部分将替换目标（Porter-Duff Destination In Source规则）。
    F _s = 0且F _d = A _s ，因此：
    
    A_r = A_d*A_s C_r = C_d*A_s
    另请参见：
    
    常数字段值
  - SRC_OUT
```
@Native
public static final int SRC_OUT
```
    位于目的地之外的源部分将替换目标（Porter-Duff Source Held Out By Destination规则）。
    F _s =（1- A _d ）且F _d = 0，因此：
    
    A_r = A_s*(1-A_d) C_r = C_s*(1-A_d)
    另请参见：
    
    常数字段值
  - DST_OUT
```
@Native
public static final int DST_OUT
```
    位于源外部的目的地部分将替换目标（Porter-Duff Destination Held Out By Source规则）。
    F _s = 0且F _d =（1- A _s ），因此：
    
    A_r = A_d*(1-A_s) C_r = C_d*(1-A_s)
    另请参见：
    
    常数字段值
  - SRC_ATOP
```
@Native
public static final int SRC_ATOP
```
    位于目的地内部的源的部分被合成到目的地（Porter-Duff Source Atop Destination规则）。
    F _s = A _d且F _d =（1- A _s ），因此：
    
    A_r = A_s*A_d + A_d*(1-A_s) = A_d C_r = C_s*A_d + C_d*(1-A_s)
    从以下版本开始：
    
    1.4
    
    另请参见：
    
    常数字段值
  - DST_ATOP
```
@Native
public static final int DST_ATOP
```
    位于源内部的目标部分在源上合成并替换目标（Porter-Duff Destination Atop Source规则）。
    F _s =（1- A _d ）且F _d = A _s ，因此：
    
    A_r = A_s*(1-A_d) + A_d*A_s = A_s C_r = C_s*(1-A_d) + C_d*A_s
    从以下版本开始：
    
    1.4
    
    另请参见：
    
    常数字段值
  - XOR
```
@Native
public static final int XOR
```
    位于目标之外的源部分与位于源之外的目标部分（Porter-Duff源Xor目标规则）组合在一起。
    F _s =（1- A _d ）， F _d =（1- A _s ），因此：
    
    A_r = A_s*(1-A_d) + A_d*(1-A_s) C_r = C_s*(1-A_d) + C_d*(1-A_s)
    从以下版本开始：
    
    1.4
    
    另请参见：
    
    常数字段值
  - Clear
```
public static final AlphaComposite Clear
```
    AlphaComposite实现不透明CLEAR规则且alpha为1.0f的对象。
    
    另请参见：
    
    CLEAR
  - Src
```
public static final AlphaComposite Src
```
    AlphaComposite实现不透明SRC规则且alpha为1.0f的对象。
    
    另请参见：
    
    SRC
  - Dst
```
public static final AlphaComposite Dst
```
    AlphaComposite实现不透明DST规则且alpha为1.0f的对象。
    
    从以下版本开始：
    
    1.4
    
    另请参见：
    
    DST
  - SrcOver
```
public static final AlphaComposite SrcOver
```
    AlphaComposite实现不透明SRC_OVER规则且alpha为1.0f的对象。
    
    另请参见：
    
    SRC_OVER
  - DstOver
```
public static final AlphaComposite DstOver
```
    AlphaComposite实现不透明DST_OVER规则且alpha为1.0f的对象。
    
    另请参见：
    
    DST_OVER
  - SrcIn
```
public static final AlphaComposite SrcIn
```
    AlphaComposite实现不透明SRC_IN规则且alpha为1.0f的对象。
    
    另请参见：
    
    SRC_IN
  - DstIn
```
public static final AlphaComposite DstIn
```
    AlphaComposite实现不透明DST_IN规则且alpha为1.0f的对象。
    
    另请参见：
    
    DST_IN
  - SrcOut
```
public static final AlphaComposite SrcOut
```
    AlphaComposite实现不透明SRC_OUT规则且alpha为1.0f的对象。
    
    另请参见：
    
    SRC_OUT
  - DstOut
```
public static final AlphaComposite DstOut
```
    AlphaComposite实现不透明DST_OUT规则且alpha为1.0f的对象。
    
    另请参见：
    
    DST_OUT
  - SrcAtop
```
public static final AlphaComposite SrcAtop
```
    AlphaComposite实现不透明SRC_ATOP规则且alpha为1.0f的对象。
    
    从以下版本开始：
    
    1.4
    
    另请参见：
    
    SRC_ATOP
  - DstAtop
```
public static final AlphaComposite DstAtop
```
    AlphaComposite实现不透明DST_ATOP规则且alpha为1.0f的对象。
    
    从以下版本开始：
    
    1.4
    
    另请参见：
    
    DST_ATOP
  - Xor
```
public static final AlphaComposite Xor
```
    AlphaComposite实现不透明XOR规则且alpha为1.0f的对象。
    
    从以下版本开始：
    
    1.4
    
    另请参见：
    
    XOR
- 方法详细信息
  - getInstance
```
public static AlphaComposite getInstance(int rule)
```
    使用指定的规则创建 AlphaComposite对象。
    
    参数
    
    rule - 合成规则
    
    结果
    
    创建了 AlphaComposite对象
    
    异常
    
    IllegalArgumentException -如果 rule不是以下之一： CLEAR ， SRC ， DST ， SRC_OVER ， DST_OVER ， SRC_IN ， DST_IN ， SRC_OUT ， DST_OUT ， SRC_ATOP ， DST_ATOP ，或 XOR
  - getInstance
```
public static AlphaComposite getInstance(int rule,
                                         float alpha)
```
    使用指定的规则创建一个AlphaComposite对象，并使用常量alpha与源的alpha相乘。在与目标合成之前，源将与指定的alpha相乘。
    
    参数
    
    rule - 合成规则
    
    alpha - 要与源的alpha相乘的常量alpha。 alpha必须是包含范围[ alpha中的浮点数。
    
    结果
    
    创建了 AlphaComposite对象
    
    异常
    
    IllegalArgumentException -如果 alpha大于1.0小于0.0或更大，或者如果 rule不是以下之一： CLEAR ， SRC ， DST ， SRC_OVER ， DST_OVER ， SRC_IN ， DST_IN ， SRC_OUT ， DST_OUT ， SRC_ATOP ， DST_ATOP ，或 XOR
  - createContext
```
public CompositeContext createContext(ColorModel srcColorModel,
                                      ColorModel dstColorModel,
                                      RenderingHints hints)
```
    为合成操作创建上下文。上下文包含用于执行合成操作的状态。
    
    Specified by:
    
    createContext在界面 Composite
    
    参数
    
    srcColorModel - 源码的ColorModel
    
    dstColorModel - 目的地的 ColorModel
    
    hints - 上下文对象用于在呈现替代项之间进行选择的提示
    
    结果
    
    用于执行合成操作的 CompositeContext对象。
  - getAlpha
```
public float getAlpha()
```
    返回此AlphaComposite的Alpha值。如果此AlphaComposite没有alpha值，则返回1.0。
    
    结果
    
    此 AlphaComposite的alpha值。
  - getRule
```
public int getRule()
```
    返回此 AlphaComposite的合成规则。
    
    结果
    
    这个 AlphaComposite的合成规则。
  - derive
```
public AlphaComposite derive(int rule)
```
    返回使用指定合成规则的类似AlphaComposite对象。如果此对象已使用指定的合成规则，则返回此对象。
    
    参数
    
    rule - 合成规则
    
    结果
    
    AlphaComposite对象派生的 AlphaComposite对象，它使用指定的合成规则。
    
    异常
    
    IllegalArgumentException -如果 rule不是以下之一： CLEAR ， SRC ， DST ， SRC_OVER ， DST_OVER ， SRC_IN ， DST_IN ， SRC_OUT ， DST_OUT ， SRC_ATOP ， DST_ATOP ，或 XOR
    
    从以下版本开始：
    
    1.6
  - derive
```
public AlphaComposite derive(float alpha)
```
    返回使用指定alpha值的类似AlphaComposite对象。如果此对象已具有指定的alpha值，则返回此对象。
    
    参数
    
    alpha - 要与源的alpha相乘的常量alpha。 alpha必须是包含范围[ alpha中的浮点数。
    
    结果
    
    AlphaComposite对象派生的 AlphaComposite对象，它使用指定的alpha值。
    
    异常
    
    IllegalArgumentException - 如果 alpha小于0.0或大于1.0
    
    从以下版本开始：
    
    1.6
  - hashCode
```
public int hashCode()
```
    返回此组合的哈希码。
    
    重写：
    
    hashCode在类 Object
    
    结果
    
    此组合的哈希码。
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - equals
```
public boolean equals(Object obj)
```
    确定指定的对象是否等于此AlphaComposite 。
    当且仅当参数不是null并且是具有与此对象相同的合成规则和alpha值的AlphaComposite对象时，结果为true 。
    
    重写：
    
    equals在类 Object
    
    参数
    
    obj - 测试平等的 Object
    
    结果
    
    true如果obj等于该AlphaComposite ; 否则为false 。
    
    另请参见：
    
    Object.hashCode() ， HashMap

Class AlphaComposite

准备输入

应用混合方程

准备结果

性能注意事项

Implementation Caveats

字段汇总

方法摘要

声明方法的类 java.lang.Object

字段详细信息

CLEAR

SRC

DST

SRC_OVER

DST_OVER

SRC_IN

DST_IN

SRC_OUT

DST_OUT

SRC_ATOP

DST_ATOP

XOR

Clear

Src

Dst

SrcOver

DstOver

SrcIn

DstIn

SrcOut

DstOut

SrcAtop

DstAtop

Xor

方法详细信息

getInstance

getInstance

createContext

getAlpha

getRule

derive

derive

hashCode

equals