Class BlendModeComposite

  • All Implemented Interfaces:
    java.awt.Composite

    public final class BlendModeComposite
    extends AbstractBlendComposite
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      private static void blendColor​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      private static void blendColorBurn​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      if(Cb == 1) B(Cb, Cs) = 1 else if(Cs == 0) B(Cb, Cs) = 0 else B(Cb, Cs) = 1 - min(1, (1 - Cb) / Cs)
      private static void blendColorDodge​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      if(Cb == 0) B(Cb, Cs) = 0 else if(Cs == 1) B(Cb, Cs) = 1 else B(Cb, Cs) = min(1, Cb / (1 - Cs))
      private static void blendDarken​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      B(Cb, Cs) = min(Cb, Cs)
      private static void blendDifference​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      B(Cb, Cs) = | Cb - Cs |
      protected @NotNull AbstractBlendComposite.Blender blender()  
      private static void blendExclusion​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      B(Cb, Cs) = Cb + Cs - 2 x Cb x Cs
      private static void blendHardLight​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      if(Cs <= 0.5) B(Cb, Cs) = Multiply(Cb, 2 x Cs) else B(Cb, Cs) = Screen(Cb, 2 x Cs -1)
      private static void blendHue​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      private static void blendLighten​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      B(Cb, Cs) = max(Cb, Cs)
      private static void blendLuminosity​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      private static void blendMultiply​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      B(Cb, Cs) = Cb * Cs
      private static void blendOverlay​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      B(Cb, Cs) = HardLight(Cs, Cb) if(Cb <= 0.5) B(Cb, Cs) = Multiply(2 x Cb, Cs) else B(Cb, Cs) = Screen(2 x Cb - 1, Cs)
      private static void blendSaturation​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      private static void blendScreen​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      B(Cb, Cs) = 1 - (1 - Cb) * (1 - Cs) = Cb + Cs - (Cb*Cs)
      private static void blendSoftLight​(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
      if(Cs <= 0.5) B(Cb, Cs) = Cb - (1 - 2 x Cs) x Cb x (1 - Cb) else B(Cb, Cs) = Cb + (2 x Cs - 1) x (D(Cb) - Cb) with if(Cb <= 0.25) D(Cb) = ((16 * Cb - 12) x Cb + 4) x Cb else D(Cb) = sqrt(Cb)
      private static int colorBurn​(int src, int dst, int srcM, int srcA, int dstM, int dstA)  
      private static int colorDodge​(int src, int dst, int srcM, int srcA, int dstM, int dstA)  
      static @NotNull java.awt.Composite create​(BlendMode mode)  
      private static @NotNull AbstractBlendComposite.Blender createBlender​(BlendMode blendMode)
      Small letters: Premultiplied values Capital letters: Non-premultiplied values Cx = cx / Ax Alpha Compositing: Ao = As + Ab - (As * Ab) co = (1-Ab)*cs + (1-As)*cb + As*Ab*B(Cb, Cs) = (1-Ab)*cs + (1-As)*cb + As*Ab*B(cb/Ab, cs/As)
      private static int softLight​(int src, int dst, int srcM, int srcA, int dstM, int dstA)  
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Constructor Detail

      • BlendModeComposite

        private BlendModeComposite​(BlendMode blendMode)
    • Method Detail

      • create

        @NotNull
        public static @NotNull java.awt.Composite create​(BlendMode mode)
      • createBlender

        @NotNull
        private static @NotNull AbstractBlendComposite.Blender createBlender​(BlendMode blendMode)
         Small letters: Premultiplied values
         Capital letters: Non-premultiplied values
        
         Cx = cx / Ax
        
         Alpha Compositing:
         Ao = As + Ab - (As * Ab)
         co = (1-Ab)*cs + (1-As)*cb + As*Ab*B(Cb, Cs)
            = (1-Ab)*cs + (1-As)*cb + As*Ab*B(cb/Ab, cs/As)
         
        Parameters:
        blendMode - the blend mode
      • blendMultiply

        private static void blendMultiply​(int @NotNull [] src,
                                          int @NotNull [] dst,
                                          int @NotNull [] result)
              B(Cb, Cs) = Cb * Cs
         
        
      • blendScreen

        private static void blendScreen​(int @NotNull [] src,
                                        int @NotNull [] dst,
                                        int @NotNull [] result)
             B(Cb, Cs) = 1 - (1 - Cb) * (1 - Cs) = Cb + Cs - (Cb*Cs)
         
        
      • blendOverlay

        private static void blendOverlay​(int @NotNull [] src,
                                         int @NotNull [] dst,
                                         int @NotNull [] result)
              B(Cb, Cs) = HardLight(Cs, Cb)
        
              if(Cb <= 0.5)
                  B(Cb, Cs) = Multiply(2 x Cb, Cs)
              else
                  B(Cb, Cs) = Screen(2 x Cb - 1, Cs)
         
        
      • blendDarken

        private static void blendDarken​(int @NotNull [] src,
                                        int @NotNull [] dst,
                                        int @NotNull [] result)
             B(Cb, Cs) = min(Cb, Cs)
         
        
      • blendLighten

        private static void blendLighten​(int @NotNull [] src,
                                         int @NotNull [] dst,
                                         int @NotNull [] result)
             B(Cb, Cs) = max(Cb, Cs)
         
        
      • blendColorDodge

        private static void blendColorDodge​(int @NotNull [] src,
                                            int @NotNull [] dst,
                                            int @NotNull [] result)
              if(Cb == 0)
                  B(Cb, Cs) = 0
              else if(Cs == 1)
                  B(Cb, Cs) = 1
              else
                  B(Cb, Cs) = min(1, Cb / (1 - Cs))
         
        
      • colorDodge

        private static int colorDodge​(int src,
                                      int dst,
                                      int srcM,
                                      int srcA,
                                      int dstM,
                                      int dstA)
      • blendColorBurn

        private static void blendColorBurn​(int @NotNull [] src,
                                           int @NotNull [] dst,
                                           int @NotNull [] result)
              if(Cb == 1)
                  B(Cb, Cs) = 1
              else if(Cs == 0)
                  B(Cb, Cs) = 0
              else
                  B(Cb, Cs) = 1 - min(1, (1 - Cb) / Cs)
         
        
      • colorBurn

        private static int colorBurn​(int src,
                                     int dst,
                                     int srcM,
                                     int srcA,
                                     int dstM,
                                     int dstA)
      • blendHardLight

        private static void blendHardLight​(int @NotNull [] src,
                                           int @NotNull [] dst,
                                           int @NotNull [] result)
              if(Cs <= 0.5)
                  B(Cb, Cs) = Multiply(Cb, 2 x Cs)
              else
                  B(Cb, Cs) = Screen(Cb, 2 x Cs -1)
         
        
      • blendSoftLight

        private static void blendSoftLight​(int @NotNull [] src,
                                           int @NotNull [] dst,
                                           int @NotNull [] result)
              if(Cs <= 0.5)
                  B(Cb, Cs) = Cb - (1 - 2 x Cs) x Cb x (1 - Cb)
              else
                  B(Cb, Cs) = Cb + (2 x Cs - 1) x (D(Cb) - Cb)
        
         with
        
              if(Cb <= 0.25)
                  D(Cb) = ((16 * Cb - 12) x Cb + 4) x Cb
              else
                  D(Cb) = sqrt(Cb)
         
        
      • softLight

        private static int softLight​(int src,
                                     int dst,
                                     int srcM,
                                     int srcA,
                                     int dstM,
                                     int dstA)
      • blendDifference

        private static void blendDifference​(int @NotNull [] src,
                                            int @NotNull [] dst,
                                            int @NotNull [] result)
             B(Cb, Cs) = | Cb - Cs |
         
        
      • blendExclusion

        private static void blendExclusion​(int @NotNull [] src,
                                           int @NotNull [] dst,
                                           int @NotNull [] result)
             B(Cb, Cs) = Cb + Cs - 2 x Cb x Cs
         
        
      • blendHue

        private static void blendHue​(int @NotNull [] src,
                                     int @NotNull [] dst,
                                     int @NotNull [] result)
         
        
      • blendSaturation

        private static void blendSaturation​(int @NotNull [] src,
                                            int @NotNull [] dst,
                                            int @NotNull [] result)
         
        
      • blendColor

        private static void blendColor​(int @NotNull [] src,
                                       int @NotNull [] dst,
                                       int @NotNull [] result)
         
        
      • blendLuminosity

        private static void blendLuminosity​(int @NotNull [] src,
                                            int @NotNull [] dst,
                                            int @NotNull [] result)