模块  java.desktop
软件包  java.awt

Class AlphaComposite

  • 实现的所有接口
    Composite

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

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

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

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

    在Porter和Duff论文中对混合方程的描述中使用了以下因子:

    Factors Factor Definition As the alpha component of the source pixel Cs a color component of the source pixel in premultiplied form Ad the alpha component of the destination pixel Cd a color component of the destination pixel in premultiplied form Fs the fraction of the source pixel that contributes to the output Fd the fraction of the destination pixel that contributes to the output Ar the alpha component of the result Cr a color component of the result in premultiplied form

    使用这些因素,Porter和Duff定义了12种选择混合因子F sF d的方法,以产生12种理想的视觉效果。 用于确定F sF d的等式在指定视觉效果的12个静态场的描述中给出。 例如, SRC_OVER的描述指定F s = 1且F d =(1- A s )。 一旦确定了用于确定混合因子的一组方程,则可以将它们应用于每个像素以使用以下方程组产生结果:

      Fs = f(Ad)      Fd = f(As)      Ar = As*Fs + Ad*Fd      Cr = Cs*Fs + Cd*Fd 

    以下因素将用于讨论我们在Porter和Duff论文中对混合方程的扩展:

    Factors Factor Definition Csr one of the raw color components of the source pixel Cdr one of the raw color components of the destination pixel Aac the "extra" alpha component from the AlphaComposite instance Asr the raw alpha component of the source pixel Adr the raw alpha component of the destination pixel Adf the final alpha component stored in the destination Cdf the final raw color component stored in the destination

    准备输入

    AlphaComposite类定义了应用于源alpha的附加Alpha值。 应用此值,就好像首先将隐式SRC_IN规则应用于具有指示alpha的像素的源像素,方法是将原始源alpha和原始源颜色乘以AlphaComposite中的AlphaComposite 这导致以下等式用于产生在Porter和Duff混合方程中使用的α:

      As = Asr * Aac 
    所有原始颜色分量都需要乘以AlphaComposite实例中的alpha。 另外,如果源不是预乘形式,则颜色分量也需要乘以源alpha。 因此,用于产生Porter和Duff方程的源颜色分量的等式取决于源像素是否被预乘:
      Cs = Csr * Asr * Aac     (if source is not premultiplied)      Cs = Csr * Aac           (if source is premultiplied) 
    无需对目标alpha进行调整:
      Ad = Adr 

    仅当目标颜色组件不是预乘形式时,才需要调整目标颜色组件:

      Cd = Cdr * Ad    (if destination is not premultiplied)      Cd = Cdr         (if destination is premultiplied) 

    应用混合方程

    调整后的A sA dC sC d用于标准Porter和Duff方程中,以计算混合因子F sF d ,然后计算得到的预乘分量A rC r

    准备结果

    如果要将结果存储回保存未预乘的数据的目标缓冲区,则只需调整结果,使用以下等式:

      Adf = Ar      Cdf = Cr                 (if dest is premultiplied)      Cdf = Cr / Ar            (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基本上使得生成的颜色分量无关紧要,因此不应该期望在这种情况下的精确行为。
    另请参见:
    CompositeCompositeContext
    • 字段汇总

      字段  
      变量和类型 字段 描述
      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目标规则)组合在一起。
    • 字段详细信息

      • CLEAR

        @Nativepublic static final int CLEAR
        目的地的颜色和阿尔法都被清除(Porter-Duff清除规则)。 源和目标都不用作输入。

        F s = 0且F d = 0,因此:

          Ar = 0  Cr = 0 
        另请参见:
        常数字段值
      • SRC

        @Nativepublic static final int SRC
        源被复制到目标(Porter-Duff源规则)。 目的地不用作输入。

        F s = 1且F d = 0,因此:

          Ar = As  Cr = Cs 
        另请参见:
        常数字段值
      • DST

        @Nativepublic static final int DST
        目的地保持不变(Porter-Duff目的地规则)。

        F s = 0且F d = 1,因此:

          Ar = Ad  Cr = Cd 
        从以下版本开始:
        1.4
        另请参见:
        常数字段值
      • SRC_OVER

        @Nativepublic static final int SRC_OVER
        源在目标上合成(Porter-Duff Source Over Destination规则)。

        F s = 1且F d =(1- A s ),因此:

          Ar = As + Ad*(1-As)  Cr = Cs + Cd*(1-As) 
        另请参见:
        常数字段值
      • DST_OVER

        @Nativepublic static final int DST_OVER
        目标是在源上合成的,结果将替换目标(Porter-Duff Destination Over Source规则)。

        F s =(1- A d )且F d = 1,因此:

          Ar = As*(1-Ad) + Ad  Cr = Cs*(1-Ad) + Cd 
        另请参见:
        常数字段值
      • SRC_IN

        @Nativepublic static final int SRC_IN
        位于目标内部的源部分将替换目标(Porter-Duff Source In Destination规则)。

        F s = A dF d = 0,因此:

          Ar = As*Ad  Cr = Cs*Ad 
        另请参见:
        常数字段值
      • DST_IN

        @Nativepublic static final int DST_IN
        位于源内的目标部分将替换目标(Porter-Duff Destination In Source规则)。

        F s = 0且F d = A s ,因此:

          Ar = Ad*As  Cr = Cd*As 
        另请参见:
        常数字段值
      • SRC_OUT

        @Nativepublic static final int SRC_OUT
        位于目的地之外的源部分将替换目标(Porter-Duff Source Held Out By Destination规则)。

        F s =(1- A d )且F d = 0,因此:

          Ar = As*(1-Ad)  Cr = Cs*(1-Ad) 
        另请参见:
        常数字段值
      • DST_OUT

        @Nativepublic static final int DST_OUT
        位于源外部的目的地部分将替换目标(Porter-Duff Destination Held Out By Source规则)。

        F s = 0且F d =(1- A s ),因此:

          Ar = Ad*(1-As)  Cr = Cd*(1-As) 
        另请参见:
        常数字段值
      • SRC_ATOP

        @Nativepublic static final int SRC_ATOP
        位于目的地内部的源的部分被合成到目的地(Porter-Duff Source Atop Destination规则)。

        F s = A dF d =(1- A s ),因此:

          Ar = As*Ad + Ad*(1-As) = Ad  Cr = Cs*Ad + Cd*(1-As) 
        从以下版本开始:
        1.4
        另请参见:
        常数字段值
      • DST_ATOP

        @Nativepublic static final int DST_ATOP
        位于源内部的目标部分在源上合成并替换目标(Porter-Duff Destination Atop Source规则)。

        F s =(1- A d )且F d = A s ,因此:

          Ar = As*(1-Ad) + Ad*As = As  Cr = Cs*(1-Ad) + Cd*As 
        从以下版本开始:
        1.4
        另请参见:
        常数字段值
      • XOR

        @Nativepublic static final int XOR
        位于目标之外的源部分与位于源之外的目标部分(Porter-Duff源Xor目标规则)组合在一起。

        F s =(1- A d ), F d =(1- A s ),因此:

          Ar = As*(1-Ad) + Ad*(1-As)  Cr = Cs*(1-Ad) + Cd*(1-As) 
        从以下版本开始:
        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,                                         float alpha)
        使用指定的规则创建一个AlphaComposite对象,并使用常量alpha与源的alpha相乘。 在与目标合成之前,源将与指定的alpha相乘。
        参数
        rule - 合成规则
        alpha - 要与源的alpha相乘的常量alpha。 alpha必须是包含范围[ alpha中的浮点数。
        结果
        创建了 AlphaComposite对象
        异常
        IllegalArgumentException -如果 alpha大于1.0小于0.0或更大,或者如果 rule不是以下之一: CLEARSRCDSTSRC_OVERDST_OVERSRC_INDST_INSRC_OUTDST_OUTSRC_ATOPDST_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​(float alpha)
        返回使用指定alpha值的类似AlphaComposite对象。 如果此对象已具有指定的alpha值,则返回此对象。
        参数
        alpha - 要与源的alpha相乘的常量alpha。 alpha必须是包含范围[ alpha中的浮点数。
        结果
        AlphaComposite对象派生的 AlphaComposite对象,它使用指定的alpha值。
        异常
        IllegalArgumentException - 如果 alpha小于0.0或大于1.0
        从以下版本开始:
        1.6
      • equals

        public boolean equals​(Object obj)
        确定指定的对象是否等于此AlphaComposite

        当且仅当参数不是null并且是具有与此对象相同的合成规则和alpha值的AlphaComposite对象时,结果为true

        重写:
        equals在类 Object
        参数
        obj - 测试平等的 Object
        结果
        true如果obj等于该AlphaComposite ; 否则为false
        另请参见:
        Object.hashCode()HashMap