java.lang.Object
- java.awt.AlphaComposite

All Implemented Interfaces:: Composite

public final class AlphaComposite
extends Object
implements Composite

AlphaComposite类实现了基本的alpha合成规则，用于组合源和目标颜色，以实现图形和图像的混合和透明效果。该类实施的具体规则是T.Porter和T.Duff在“Compositing Digital Images”，SIGGRAPH 84,253-259中描述的12个规则的基本集合。本文档的其余部分假定您熟悉该文章中概述的定义和概念。

该类扩展了由波特和达夫定义的标准方程，以包括一个附加因素。 AlphaComposite类的实例可以包含一个Alpha值，用于在混合方程中使用之前修改每个源像素的不透明度或覆盖率。

重要的是要注意，由波特和达夫纸定义的方程式都被定义为对由其对应的α分量预乘的颜色分量进行操作。由于ColorModel和Raster类允许以预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

以下因素将用于讨论我们在波特和达夫论文中对混合方程的扩展：

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和原始源颜色乘以AlphaComposite中的alpha来将其应用于具有指示的alpha的像素的源像素。这导致了用于生成波特和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传递给对象compose一个的方法CompositeContext由所创建的对象AlphaComposite类已经预乘数据。然而，如果源Raster或目的地Raster不是预乘，则在合成操作之前和之后执行适当的转换。

Implementation Caveats

许多来源，例如BufferedImage类中列出的一些不透明图像类型，不会为其像素存储alpha值。这些资源为其所有像素提供了一个1.0的alpha。
许多目的地也没有地方存储由这个类执行的混合计算产生的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。
内部实现可以近似一些方程，并且还可以消除一些步骤以避免不必要的操作。例如，考虑使用非预乘α值的离散整数图像，每个组件使用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的结果α值时，一些实现可能会不同。请注意，如果分母（α）为0，则在SRC规则的情况下，通过alpha删除除法的简化在技术上是无效的。但是，由于只有在以预乘方式查看结果时，才应该预期结果是准确的， α的α基本上使得所得到的颜色成分无关紧要，因此在这种情况下不应期待确切的行为。

另请参见：: Composite ， CompositeContext

Field Summary

Fields
Modifier and Type	Field	描述
`static AlphaComposite`	`Clear`	`AlphaComposite`对象实现不透明的CLEAR规则，其alpha为1.0f。
`static int`	`CLEAR`	目的地的颜色和alpha都被清除（Porter-Duff Clear规则）。
`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 rule）上。
`static int`	`SRC_IN`	位于目的地内部的源的部分替换目的地（目的地规则中的波特 - 达夫源）。
`static int`	`SRC_OUT`	位于目的地外部的源的部分取代了目的地（Porter-Duff Source Held Out By Destination规则）。
`static int`	`SRC_OVER`	源在目的地（Porter-Duff Source Over Destination规则）上合成。
`static AlphaComposite`	`SrcAtop`	`AlphaComposite`对象实现的alpha值为1.0f的不透明的SRC_ATOP规则。
`static AlphaComposite`	`SrcIn`	`AlphaComposite`对象实现了一个alpha为1.0f的不透明的SRC_IN规则。
`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 Source Xor Destination rule）组合。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	方法	描述
`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()`	返回此复合的哈希码。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- 字段详细信息
  - CLEAR
```
@Native
public static final int CLEAR
```
    目的地的颜色和alpha都被清除（Porter-Duff Clear规则）。源和目的地都不用作输入。
    F _s = 0， F _d = 0，因此：
    
    A_r = 0 C_r = 0
    另请参见：
    
    Constant Field Values
  - SRC
```
@Native
public static final int SRC
```
    源被复制到目的地（Porter-Duff源规则）。目的地不用作输入。
    F _s = 1， F _d = 0，因此：
    
    A_r = A_s C_r = C_s
    另请参见：
    
    Constant Field Values
  - 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
    
    另请参见：
    
    Constant Field Values
  - 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)
    另请参见：
    
    Constant Field Values
  - 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
    另请参见：
    
    Constant Field Values
  - SRC_IN
```
@Native
public static final int SRC_IN
```
    位于目的地内部的源的部分替换目的地（目的地规则中的波特 - 达夫源）。
    F _s = A _d ， F _d = 0，因此：
    
    A_r = A_s*A_d C_r = C_s*A_d
    另请参见：
    
    Constant Field Values
  - 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
    另请参见：
    
    Constant Field Values
  - 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)
    另请参见：
    
    Constant Field Values
  - 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)
    另请参见：
    
    Constant Field Values
  - SRC_ATOP
```
@Native
public static final int SRC_ATOP
```
    位于目的地内部的源的部分被合成到目的地（Porter-Duff Source Atop Destination rule）上。
    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
    
    另请参见：
    
    Constant Field Values
  - 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
    
    另请参见：
    
    Constant Field Values
  - XOR
```
@Native
public static final int XOR
```
    位于目的地外部的源的部分与位于源外的目标的部分（Porter-Duff Source Xor Destination rule）组合。
    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
    
    另请参见：
    
    Constant Field Values
  - 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对象实现的alpha值为1.0f的不透明SRC_OUT规则。
    
    另请参见：
    
    SRC_OUT
  - DstOut
```
public static final AlphaComposite DstOut
```
    AlphaComposite对象实现不透明的DST_OUT规则，alpha为1.0f。
    
    另请参见：
    
    DST_OUT
  - SrcAtop
```
public static final AlphaComposite SrcAtop
```
    AlphaComposite对象实现的alpha值为1.0f的不透明SRC_ATOP规则。
    
    从以下版本开始：
    
    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中的浮点数。
    
    结果
    
    创建了 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对象，该对象使用指定的合成规则。
    
    异常
    
    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中的浮点数。
    
    结果
    
    AlphaComposite对象派生的使用指定的Alpha值的对象的 AlphaComposite对象。
    
    异常
    
    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且是具有与AlphaComposite对象具有相同合成规则和alpha值的AlphaComposite对象时，结果为true 。
    
    重写：
    
    equals在 Object
    
    参数
    
    obj - Object测试相等
    
    结果
    
    true如果obj等于这AlphaComposite ; 否则为false 。
    
    另请参见：
    
    Object.hashCode() ， HashMap

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

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

Class AlphaComposite

准备输入

应用混合方程

准备结果

绩效注意事项

Implementation Caveats

Field Summary

方法摘要

Methods inherited from class 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