Class BlendModeComposite

java.lang.Object
com.github.weisj.jsvg.nodes.filter.AbstractBlendComposite
com.github.weisj.jsvg.nodes.filter.BlendModeComposite
All Implemented Interfaces:
Composite

public final class BlendModeComposite extends AbstractBlendComposite
  • Nested Class Summary

    Nested classes/interfaces inherited from class com.github.weisj.jsvg.nodes.filter.AbstractBlendComposite

    AbstractBlendComposite.Blender
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    private final @NotNull AbstractBlendComposite.Blender
     
  • Constructor Summary

    Constructors
    Modifier
    Constructor
    Description
    private
     
  • Method Summary

    Modifier and Type
    Method
    Description
    private static void
    blendColor(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    invalid input: '<'/pre
    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) invalid input: '<'/pre
    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)) invalid input: '<'/pre
    private static void
    blendDarken(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    B(Cb, Cs) = min(Cb, Cs) invalid input: '<'/pre
    private static void
    blendDifference(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    B(Cb, Cs) = | Cb - Cs | invalid input: '<'/pre
     
    private static void
    blendExclusion(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    B(Cb, Cs) = Cb + Cs - 2 x Cb x Cs invalid input: '<'/pre
    private static void
    blendHardLight(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    if(Cs invalid input: '<'= 0.5) B(Cb, Cs) = Multiply(Cb, 2 x Cs) else B(Cb, Cs) = Screen(Cb, 2 x Cs -1) invalid input: '<'/pre
    private static void
    blendHue(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    invalid input: '<'/pre
    private static void
    blendLighten(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    B(Cb, Cs) = max(Cb, Cs) invalid input: '<'/pre
    private static void
    blendLuminosity(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    invalid input: '<'/pre
    private static void
    blendMultiply(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    B(Cb, Cs) = Cb * Cs invalid input: '<'/pre
    private static void
    blendOverlay(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    B(Cb, Cs) = HardLight(Cs, Cb) if(Cb invalid input: '<'= 0.5) B(Cb, Cs) = Multiply(2 x Cb, Cs) else B(Cb, Cs) = Screen(2 x Cb - 1, Cs) invalid input: '<'/pre
    private static void
    blendSaturation(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    invalid input: '<'/pre
    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) invalid input: '<'/pre
    private static void
    blendSoftLight(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
    if(Cs invalid input: '<'= 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 invalid input: '<'= 0.25) D(Cb) = ((16 * Cb - 12) x Cb + 4) x Cb else D(Cb) = sqrt(Cb) invalid input: '<'/pre
    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 Composite
     
    private static @NotNull AbstractBlendComposite.Blender
    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 com.github.weisj.jsvg.nodes.filter.AbstractBlendComposite

    createContext, setConvertToLinearRGB

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Field Details

  • Constructor Details

    • BlendModeComposite

      private BlendModeComposite(BlendMode blendMode)
  • Method Details

    • create

      @NotNull public static @NotNull Composite create(BlendMode mode)
    • blender

      @NotNull protected @NotNull AbstractBlendComposite.Blender blender()
      Specified by:
      blender in class AbstractBlendComposite
    • 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
       invalid input: '<'/pre
    • 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)
       invalid input: '<'/pre
    • blendOverlay

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

      private static void blendDarken(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
           B(Cb, Cs) = min(Cb, Cs)
       invalid input: '<'/pre
    • blendLighten

      private static void blendLighten(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
           B(Cb, Cs) = max(Cb, Cs)
       invalid input: '<'/pre
    • 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))
       invalid input: '<'/pre
    • 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)
       invalid input: '<'/pre
    • 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 invalid input: '<'= 0.5)
                B(Cb, Cs) = Multiply(Cb, 2 x Cs)
            else
                B(Cb, Cs) = Screen(Cb, 2 x Cs -1)
       invalid input: '<'/pre
    • blendSoftLight

      private static void blendSoftLight(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
            if(Cs invalid input: '<'= 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 invalid input: '<'= 0.25)
                D(Cb) = ((16 * Cb - 12) x Cb + 4) x Cb
            else
                D(Cb) = sqrt(Cb)
       invalid input: '<'/pre
    • 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 |
       invalid input: '<'/pre
    • blendExclusion

      private static void blendExclusion(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
           B(Cb, Cs) = Cb + Cs - 2 x Cb x Cs
       invalid input: '<'/pre
    • blendHue

      private static void blendHue(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
       invalid input: '<'/pre
    • blendSaturation

      private static void blendSaturation(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
       invalid input: '<'/pre
    • blendColor

      private static void blendColor(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
       invalid input: '<'/pre
    • blendLuminosity

      private static void blendLuminosity(int @NotNull [] src, int @NotNull [] dst, int @NotNull [] result)
       invalid input: '<'/pre