Class CompositeRule

  • All Implemented Interfaces:
    java.io.Serializable

    public final class CompositeRule
    extends java.lang.Object
    implements java.io.Serializable
    This is a typesafe enumeration of the standard Composite rules for the CompositeRable operation. (over, in, out, atop, xor, arith)
    See Also:
    Serialized Form
    • Field Detail

      • RULE_OVER

        public static final int RULE_OVER
        Porter-Duff src over rule, also used for feBlend normal.
        See Also:
        Constant Field Values
      • RULE_ATOP

        public static final int RULE_ATOP
        Porter-Duff src atop rule.
        See Also:
        Constant Field Values
      • RULE_ARITHMETIC

        public static final int RULE_ARITHMETIC
        Arithmatic rule 'out = k1*i1*i2 + k2*i1 + k3*i2 + k4'.
        See Also:
        Constant Field Values
      • RULE_MULTIPLY

        public static final int RULE_MULTIPLY
        SVG feBlend Multiply rule
        See Also:
        Constant Field Values
      • RULE_SCREEN

        public static final int RULE_SCREEN
        SVG feBlend Screen rule
        See Also:
        Constant Field Values
      • RULE_DARKEN

        public static final int RULE_DARKEN
        SVG feBlend Darken rule
        See Also:
        Constant Field Values
      • RULE_LIGHTEN

        public static final int RULE_LIGHTEN
        SVG feBlend Lighten rule
        See Also:
        Constant Field Values
      • OVER

        public static final CompositeRule OVER
        Porter-Duff Source Over Destination rule. The source is composited over the destination.
        
          Fs = 1 and Fd = (1-As), thus:
        
                Cd = Cs + Cd*(1-As)
                Ad = As + Ad*(1-As)
         
      • IN

        public static final CompositeRule IN
        Porter-Duff Source In Destination rule. The part of the source lying inside of the destination replaces the destination.
        
          Fs = Ad and Fd = 0, thus:
        
                Cd = Cs*Ad
                Ad = As*Ad
         
      • OUT

        public static final CompositeRule OUT
        Porter-Duff Source Out Destination rule. The part of the source lying outside of the destination replaces the destination.
        
          Fs = (1-Ad) and Fd = 0, thus:
        
                Cd = Cs*(1-Ad)
                Ad = As*(1-Ad)
         
      • ATOP

        public static final CompositeRule ATOP
        Porter-Duff Source Atop Destination rule. The part of the source lying inside of the destination replaces the destination, destination remains outside of source.
        
          Fs = Ad and Fd = (1-As), thus:
        
                Cd = Cs*Ad + Cd*(1-As)
                Ad = As*Ad + Ad*(1-As)
         
      • XOR

        public static final CompositeRule XOR
        Xor rule. The source and destination are Xor'ed togeather.
        
          Fs = (1-Ad) and Fd = (1-As), thus:
        
                Cd = Cs*(1-Ad) + Cd*(1-As)
                Ad = As*(1-Ad) + Ad*(1-As)
         
      • MULTIPLY

        public static final CompositeRule MULTIPLY
        FeBlend Multiply rule.
        
                Cd = Cs*(1-Ad) + Cd*(1-As) + Cs*Cd
                Ad = 1 - (1-Ad)*(1-As)
         
      • SCREEN

        public static final CompositeRule SCREEN
        FeBlend Screen rule.
        
                Cd = Cs + Cd - Cs*Cd
                Ad = 1 - (1-Ad)*(1-As)
         
      • DARKEN

        public static final CompositeRule DARKEN
        FeBlend Darken rule.
        
                Cd = Min(Cs*(1-Ad) + Cd,
                         Cd*(1-As) + Cs)
                Ad = 1 - (1-Ad)*(1-As)
         
      • LIGHTEN

        public static final CompositeRule LIGHTEN
        FeBlend Lighten rule.
        
                Cd = Max(Cs*(1-Ad) + Cd,
                         Cd*(1-As) + Cs)
                Ad = 1 - (1-Ad)*(1-As)
         
    • Method Detail

      • ARITHMETIC

        public static CompositeRule ARITHMETIC​(float k1,
                                               float k2,
                                               float k3,
                                               float k4)
        Factory to create artithmatic CompositeRules. 'out = k1*i1*i2 + k2*i1 + k3*i2 + k4' Note that arithmatic CompositeRules are not singletons.
      • getRule

        public int getRule()
        Returns the type of this composite rule
      • getCoefficients

        public float[] getCoefficients()
      • toString

        public java.lang.String toString()
        This is called by the serialization code before it returns an unserialized object. To provide for unicity of instances, the instance that was read is replaced by its static equivalent. See the serialiazation specification for further details on this method's logic.
        Overrides:
        toString in class java.lang.Object