blendx

package
v1.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 20, 2023 License: MIT Imports: 6 Imported by: 0

Documentation

Overview

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-26. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Package blendx Created by xuzhuoxi on 2019-05-25. @author xuzhuoxi

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func BlendAddColor 

func BlendAddColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendAddColor 增加模式 是将原始图像及混合图像的对应像素取出来并加在一起； R = Min(1, S+D)) R = Min(255, S+D) R = Min(65535, S+D)

func BlendAddRGBA 

func BlendAddRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendAddRGBA 增加模式 是将原始图像及混合图像的对应像素取出来并加在一起； R = Min(1, S+D)) R = Min(255, S+D) R = Min(65535, S+D)

func BlendBehindColor 

func BlendBehindColor(S, D color.Color, _ float64, _ bool) color.Color

BlendBehindColor 背后模式 最终色和绘图色相同。当在有透明区域的图层上操作时背后模式才会出现，可将绘制的线条放在图层中图像的后面。 这模式被用来在一个图层内透明的部分进行涂画；但当图层里的“保持透明区域”选中时就不可用了。 它只可以在你用涂画工具（画笔，喷枪，图章，历史记录画笔，油漆桶）或是填充命令在图层内的一个对象之后画上阴影或色彩。 当在有透明区域的图层上操作时背后模式才会出现

func BlendBehindRGBA 

func BlendBehindRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, _ bool) (R, G, B, A uint32)

BlendBehindRGBA 背后模式 最终色和绘图色相同。当在有透明区域的图层上操作时背后模式才会出现，可将绘制的线条放在图层中图像的后面。 这模式被用来在一个图层内透明的部分进行涂画；但当图层里的“保持透明区域”选中时就不可用了。 它只可以在你用涂画工具（画笔，喷枪，图章，历史记录画笔，油漆桶）或是填充命令在图层内的一个对象之后画上阴影或色彩。 当在有透明区域的图层上操作时背后模式才会出现

func BlendClearColor 

func BlendClearColor(S, D color.Color, _ float64, _ bool) color.Color

BlendClearColor 清除模式 同背后模式一样，当在图层上操作时，清除模式才会出现。利用清除模式可将图层中有像素的部分清除掉。当有图层时，利用清除模式，使用喷漆桶工具可以将图层中的颜色相近的区域清除掉。 可在喷漆桶工具的选项栏中设定“预值”以确定喷漆桶工具所清除的范围。工具选项栏中的“用于所有图层”选项在清除模式下无效。 R = 0

func BlendClearRGBA 

func BlendClearRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, _ bool) (R, G, B, A uint32)

BlendClearRGBA 清除模式 同背后模式一样，当在图层上操作时，清除模式才会出现。利用清除模式可将图层中有像素的部分清除掉。当有图层时，利用清除模式，使用喷漆桶工具可以将图层中的颜色相近的区域清除掉。 可在喷漆桶工具的选项栏中设定“预值”以确定喷漆桶工具所清除的范围。工具选项栏中的“用于所有图层”选项在清除模式下无效。 R = 0

func BlendColorBurnColor 

func BlendColorBurnColor(S, D color.Color, factor float64, destinationAlpha bool) color.Color

BlendColorBurnColor 颜色加深模式 查看每个通道的颜色信息，通过增加“对比度”使底色的颜色变暗来反映绘图色，和白色混合没变化。 除了背景上的较淡区域消失，且图像区域呈现尖锐的边缘特性之外，这种Color Burn模式创建的效果类似于由MuItiply模式创建的效果。 R = S - (1-S) * (1-D) / D R = S - (255-S) * (255-D) / D R = S - (65535-S) * (65535-D) / D (64位图像)

func BlendColorBurnRGBA 

func BlendColorBurnRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendColorBurnRGBA 颜色加深模式 查看每个通道的颜色信息，通过增加“对比度”使底色的颜色变暗来反映绘图色，和白色混合没变化。 除了背景上的较淡区域消失，且图像区域呈现尖锐的边缘特性之外，这种Color Burn模式创建的效果类似于由MuItiply模式创建的效果。 R = S - (1-S) * (1-D) / D R = S - (255-S) * (255-D) / D R = S - (65535-S) * (65535-D) / D (64位图像)

func BlendColorColor 

func BlendColorColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendColorColor 颜色模式 是采用底色的亮度以及绘图色的色相、饱和度来创建最终色。它可保护原图的灰阶层次，对于图像的色彩微调、给单色和彩色图像着色都非常有用。 HSV = Dh, Ds, Sv

func BlendColorDodgeColor 

func BlendColorDodgeColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendColorDodgeColor 颜色减淡模式 查看每个通道的颜色信息，通过降低“对比度”使底色的颜色变亮来反映绘图色，和黑色混合没变化。 除了指定在这个模式的层上边缘区域更尖锐，以及在这个模式下着色的笔画之外， Color Dodge模式类似于Screen模式创建的效果。另外，不管何时定义color Dodge模式混合 前景与背景像素，背景图像上的暗区域都将会消失。 R = S + S*D/(1-D) R = S + S*D/(255-D) (32位) R = S + S*D/(65535-D) (64位)

func BlendColorDodgeRGBA 

func BlendColorDodgeRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendColorDodgeRGBA 颜色减淡模式 查看每个通道的颜色信息，通过降低“对比度”使底色的颜色变亮来反映绘图色，和黑色混合没变化。 除了指定在这个模式的层上边缘区域更尖锐，以及在这个模式下着色的笔画之外， Color Dodge模式类似于Screen模式创建的效果。另外，不管何时定义color Dodge模式混合 前景与背景像素，背景图像上的暗区域都将会消失。 R = S + S*D/(1-D) R = S + S*D/(255-D) (32位) R = S + S*D/(65535-D) (64位)

func BlendColorRGBA 

func BlendColorRGBA(Sr, Sg, Sb, _ uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendColorRGBA 颜色模式 是采用底色的亮度以及绘图色的色相、饱和度来创建最终色。它可保护原图的灰阶层次，对于图像的色彩微调、给单色和彩色图像着色都非常有用。 HSV = Dh, Ds, Sv

func BlendCopyColor 

func BlendCopyColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendCopyColor 覆盖模式 R = S

func BlendCopyRGBA 

func BlendCopyRGBA(Sr, Sg, Sb, Sa uint32, _, _, _, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendCopyRGBA 覆盖模式 R = S

func BlendDarkenColor 

func BlendDarkenColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendDarkenColor 变暗模式 与Lighten相反，将两个图像中更暗的那个被选来作为结果。 用于查找各颜色通道内的颜色信息，并按照像素对比底色和绘图色，那个更暗，便以这种颜色作为此图像最终的颜色，也就是取两个颜色中的暗色作为最终色。亮于底色的颜色被替换，暗于底色的颜色保持不变。 R = min(S, D)

func BlendDarkenRGBA 

func BlendDarkenRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendDarkenRGBA 变暗模式 与Lighten相反，将两个图像中更暗的那个被选来作为结果。 用于查找各颜色通道内的颜色信息，并按照像素对比底色和绘图色，那个更暗，便以这种颜色作为此图像最终的颜色，也就是取两个颜色中的暗色作为最终色。亮于底色的颜色被替换，暗于底色的颜色保持不变。 R = min(S, D)

func BlendDarkerColorColor 

func BlendDarkerColorColor(S, D color.Color, _ float64, _ bool) color.Color

BlendDarkerColorColor 深色模式 公式：Dr+Dg+Db>=Sr+Sg+Sb 则 R=S 比较混合色和基色的所有通道值的总和并显示值较小的颜色。“深色”不会生成第三种颜色（可以通过“变暗”混合获得），因为它将从基色和混合色中选取最小的通道值来创建结果色。

func BlendDarkerColorRGBA 

func BlendDarkerColorRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, _ bool) (R, G, B, A uint32)

BlendDarkerColorRGBA 深色模式 公式：Dr+Dg+Db>=Sr+Sg+Sb 则 R=S 比较混合色和基色的所有通道值的总和并显示值较小的颜色。“深色”不会生成第三种颜色（可以通过“变暗”混合获得），因为它将从基色和混合色中选取最小的通道值来创建结果色。

func BlendDestinationAtopColor 

func BlendDestinationAtopColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendDestinationAtopColor R = S*(1 - Da) + D*Sa R = (S*(255 - Da) + D*Sa) / 255 R = (S*(65535 - Da) + D*Sa) / 65535

func BlendDestinationAtopRGBA 

func BlendDestinationAtopRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendDestinationAtopRGBA R = S*(1 - Da) + D*Sa R = (S*(255 - Da) + D*Sa) / 255 R = (S*(65535 - Da) + D*Sa) / 65535

func BlendDestinationInColor 

func BlendDestinationInColor(foreColor, backColor color.Color, _ float64, destinationAlpha bool) color.Color

BlendDestinationInColor R = D*Sa [0,1] R = D*Sa/255 [0,255] R = D*Sa/65535 [0,65535]

func BlendDestinationInRGBA 

func BlendDestinationInRGBA(_, _, _, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendDestinationInRGBA R = D*Sa [0,1] R = D*Sa/255 [0,255] R = D*Sa/65535 [0,65535]

func BlendDestinationOutColor 

func BlendDestinationOutColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendDestinationOutColor R = D*(1 - Sa) [0,1] R = D*(255 - Sa)/255 [0,255] R = D*(65535 - Sa)/65535 [0,65535]

func BlendDestinationOutRGBA 

func BlendDestinationOutRGBA(_, _, _, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendDestinationOutRGBA R = D*(1 - Sa) [0,1] R = D*(255 - Sa)/255 [0,255] R = D*(65535 - Sa)/65535 [0,65535]

func BlendDestinationOverColor 

func BlendDestinationOverColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendDestinationOverColor R = S*(1 - Da) + D R = S*(255 - Da)/255 + D R = S*(65535 - Da)/65535 + D

func BlendDestinationOverRGBA 

func BlendDestinationOverRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendDestinationOverRGBA R = S*(1 - Da) + D R = S*(255 - Da)/255 + D R = S*(65535 - Da)/65535 + D

func BlendDifferenceColor 

func BlendDifferenceColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendDifferenceColor 差值模式 查看每个通道中的颜色信息，比较底色和绘图色，用较亮的像素点的像素值减去较暗的像素点的像素值。与白色混合将使底色反相；与黑色混合则不产生变化。 R = |S - D|

func BlendDifferenceRGBA 

func BlendDifferenceRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendDifferenceRGBA 差值模式 查看每个通道中的颜色信息，比较底色和绘图色，用较亮的像素点的像素值减去较暗的像素点的像素值。与白色混合将使底色反相；与黑色混合则不产生变化。 R = |S - D|

func BlendDissolveColor 

func BlendDissolveColor(S, D color.Color, factor float64, destinationAlpha bool) color.Color

BlendDissolveColor 溶解模式 最终色和绘图色相同，只是根据每个像素点所在的位置的透明度的不同，可随机以绘图色和底色取代。透明度越大，溶解效果就越明显。 使用这种模式，像素仿佛是整个的来自一幅图像或是另一幅，看不出有什么混合的迹象， 如果你想在两幅图像之间达到看不出混合迹象的效果，而又能比使用溶解模式拥有更多的对图案的控制，那么可以在最上面图层上建一个图层蒙版并用纯白色填充它。 这种效果对模拟破损纸的边缘或原图的 “泼溅”类型是重要的。 随机选择一个色

func BlendDissolveRGBA 

func BlendDissolveRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, factor float64, _ bool) (R, G, B, A uint32)

BlendDissolveRGBA 溶解模式 最终色和绘图色相同，只是根据每个像素点所在的位置的透明度的不同，可随机以绘图色和底色取代。透明度越大，溶解效果就越明显。 使用这种模式，像素仿佛是整个的来自一幅图像或是另一幅，看不出有什么混合的迹象， 如果你想在两幅图像之间达到看不出混合迹象的效果，而又能比使用溶解模式拥有更多的对图案的控制，那么可以在最上面图层上建一个图层蒙版并用纯白色填充它。 这种效果对模拟破损纸的边缘或原图的 “泼溅”类型是重要的。 随机选择一个色

func BlendDivideColor 

func BlendDivideColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendDivideColor 划分模式 假设上面图层选择划分，那么所看到的图像是，下面的可见图层根据上面这个图层颜色的纯度，相应减去了同等纯度的该颜色，同时上面颜色的明暗度不同，被减去区域图像明度也不同，上面图层颜色的亮，图像亮度变化就会越小，上面图层越暗，被减区域图像就会越亮。 也就是说，如果上面图层是白色，那么也不会减去颜色也不会提高明度，如果上面图层是黑色，那么所有不纯的颜色都会被减去，只留着最纯的光的三原色，及其混合色，青品黄与白色。 R = S / D [0, 1] R = 255 * S / D [0, 255] R = 65535 * S / D [0, 65535]

func BlendDivideRGBA 

func BlendDivideRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendDivideRGBA 划分模式 假设上面图层选择划分，那么所看到的图像是，下面的可见图层根据上面这个图层颜色的纯度，相应减去了同等纯度的该颜色，同时上面颜色的明暗度不同，被减去区域图像明度也不同，上面图层颜色的亮，图像亮度变化就会越小，上面图层越暗，被减区域图像就会越亮。 也就是说，如果上面图层是白色，那么也不会减去颜色也不会提高明度，如果上面图层是黑色，那么所有不纯的颜色都会被减去，只留着最纯的光的三原色，及其混合色，青品黄与白色。 R = S / D [0, 1] R = 255 * S / D [0, 255] R = 65535 * S / D [0, 65535]

func BlendExclusionColor 

func BlendExclusionColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendExclusionColor 排除模式 可生成和差值模式相似的效果，但比差值模式生成的颜色对比度较小，因而颜色较柔和。与白色混合将使底色反相；与黑色混合则不产生变化。 R = S + D - 2*S*D [0,1] R = S + D - S*D/128 [0,255] R = S + D - S*D/32768 [0,65535]

func BlendExclusionRGBA 

func BlendExclusionRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendExclusionRGBA 排除模式 可生成和差值模式相似的效果，但比差值模式生成的颜色对比度较小，因而颜色较柔和。与白色混合将使底色反相；与黑色混合则不产生变化。 R = S + D - 2*S*D [0,1] R = S + D - S*D/128 [0,255] R = S + D - S*D/32768 [0,65535]

func BlendHardLightColor 

func BlendHardLightColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendHardLightColor 强光模式 根据绘图色来决定是执行“正片叠底”还是“滤色”模式。当绘图色比50%的灰要亮时，则底色变亮，就执行“滤色”模式一样，这对增加图像的高光非常有帮助； 当绘图色比50%的灰要暗时，则底色变暗，就执行“正片叠底”模式一样，可增加图像的暗部。当绘图色是纯白色或黑色时得到的是纯白色和黑色。此效果与耀眼的聚光灯照在图像上相似。像亮则更亮，暗则更暗。 这种模式实质上同Soft Light模式是一样的。它的效果要比Soft Light模式更强烈一些，同Overlay一样，这种模式 也可以在背景对象的表面模拟图案或文本。 (D<=0.5): R = 2*S*D (D>0.5) : R = 1 - 2*(1-S) * (1-D) 

------------

(D<=128): R = S * D / 128 (D >128): R = 255 - (255-S)*(255-D)/128 

------------

(D<=128): R = S * D / 32768 (D>128) : R = 65535 - (65535-S)*(65535-D)/32768

func BlendHardLightRGBA 

func BlendHardLightRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendHardLightRGBA 强光模式 根据绘图色来决定是执行“正片叠底”还是“滤色”模式。当绘图色比50%的灰要亮时，则底色变亮，就执行“滤色”模式一样，这对增加图像的高光非常有帮助； 当绘图色比50%的灰要暗时，则底色变暗，就执行“正片叠底”模式一样，可增加图像的暗部。当绘图色是纯白色或黑色时得到的是纯白色和黑色。此效果与耀眼的聚光灯照在图像上相似。像亮则更亮，暗则更暗。 这种模式实质上同Soft Light模式是一样的。它的效果要比Soft Light模式更强烈一些，同Overlay一样，这种模式 也可以在背景对象的表面模拟图案或文本。 (D<=0.5): R = 2*S*D (D>0.5) : R = 1 - 2*(1-S) * (1-D) 

------------

(D<=128): R = S * D / 128 (D >128): R = 255 - (255-S)*(255-D)/128 

------------

(D<=128): R = S * D / 32768 (D>128) : R = 65535 - (65535-S)*(65535-D)/32768

func BlendHardMixColor 

func BlendHardMixColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendHardMixColor 实色混合模式 根据绘图颜色与底图颜色的颜色数值相加，当相加的颜色数值大于该颜色模式颜色数值的最大值，混合颜色为最大值； 当相加的颜色数值小于该颜色模式颜色数值的最大值，混合颜色为0； 当相加的颜色数值等于该颜色模式颜色数值的最大值，混合颜色由底图颜色决定，底图颜色值比绘图颜色的颜色值大，则混合颜色为最大值，相反则为0.实色混合能产生颜色较少、边缘较硬的图像效果。 R = S+D>=1 ? 1 : 0 R = S+D>=255 ? 255 : 0 R = S+D>=65535 ? 65535 : 0

func BlendHardMixRGBA 

func BlendHardMixRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendHardMixRGBA 实色混合模式 根据绘图颜色与底图颜色的颜色数值相加，当相加的颜色数值大于该颜色模式颜色数值的最大值，混合颜色为最大值； 当相加的颜色数值小于该颜色模式颜色数值的最大值，混合颜色为0； 当相加的颜色数值等于该颜色模式颜色数值的最大值，混合颜色由底图颜色决定，底图颜色值比绘图颜色的颜色值大，则混合颜色为最大值，相反则为0.实色混合能产生颜色较少、边缘较硬的图像效果。 R = S+D>=1 ? 1 : 0 R = S+D>=255 ? 255 : 0 R = S+D>=65535 ? 65535 : 0

func BlendHueColor 

func BlendHueColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendHueColor 色相模式 是采用底色的亮度、饱和度以及绘图色的色相来创建最终色。 HSV = Dh, Ss, Sv

func BlendHueRGBA 

func BlendHueRGBA(Sr, Sg, Sb, _ uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendHueRGBA 色相模式 是采用底色的亮度、饱和度以及绘图色的色相来创建最终色。 HSV = Dh, Ss, Sv

func BlendLightenColor 

func BlendLightenColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendLightenColor 变亮模式 与Darken相反，取两个像素中更亮的作为结果。 查看每个通道的颜色信息，并按照像素对比两个颜色，那个更亮，便以这种颜色作为此像素最终的颜色，也就是取两个颜色中的亮色作为最终色。绘图色中亮于底色的颜色被保留，暗于底色的颜色被替换。 R = Max(S, D)

func BlendLightenRGBA 

func BlendLightenRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendLightenRGBA 变亮模式 与Darken相反，取两个像素中更亮的作为结果。 查看每个通道的颜色信息，并按照像素对比两个颜色，那个更亮，便以这种颜色作为此像素最终的颜色，也就是取两个颜色中的亮色作为最终色。绘图色中亮于底色的颜色被保留，暗于底色的颜色被替换。 R = Max(S, D)

func BlendLighterColor 

func BlendLighterColor(foreColor, backColor color.Color, _ float64, _ bool) color.Color

BlendLighterColor 浅色模式 公式：Dr+Dg+Db+Da >= Sr+Sg+Sb+Sa 则 R=D 比较混合色和基色的所有通道值的总和并显示值较大的颜色。“浅色”不会生成第三种颜色（可以通过“变亮”混合获得），因为它将从基色和混合色中选取最大的通道值来创建结果色。

func BlendLighterColorRGBA 

func BlendLighterColorRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, _ bool) (R, G, B, A uint32)

BlendLighterColorRGBA 浅色模式 公式：Dr+Dg+Db+Da >= Sr+Sg+Sb+Sa 则 R=D 比较混合色和基色的所有通道值的总和并显示值较大的颜色。“浅色”不会生成第三种颜色（可以通过“变亮”混合获得），因为它将从基色和混合色中选取最大的通道值来创建结果色。

func BlendLinearBurnColor 

func BlendLinearBurnColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendLinearBurnColor 线性加深模式 查看每个通道的颜色信息，通过降低“亮度”使底色的颜色变暗来反映绘图色，和白色混合没变化。 R = S + D - 1 R = S + D - 255 R = S + D - 65535

func BlendLinearBurnRGBA 

func BlendLinearBurnRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendLinearBurnRGBA 线性加深模式 查看每个通道的颜色信息，通过降低“亮度”使底色的颜色变暗来反映绘图色，和白色混合没变化。 R = S + D - 1 R = S + D - 255 R = S + D - 65535

func BlendLinearDodgeColor 

func BlendLinearDodgeColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendLinearDodgeColor 线性减淡模式 查看每个通道的颜色信息，通过增加“亮度”使底色的颜色变亮来反映绘图色，和黑色混合没变化。 R = S + D

func BlendLinearDodgeRGBA 

func BlendLinearDodgeRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendLinearDodgeRGBA 线性减淡模式 查看每个通道的颜色信息，通过增加“亮度”使底色的颜色变亮来反映绘图色，和黑色混合没变化。 R = S + D

func BlendLinearLightColor 

func BlendLinearLightColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendLinearLightColor 线性光模式 根据绘图色通过增加或降低“亮度”，加深或减淡颜色。如果绘图色比50%的灰亮，图像通过增加亮度被照亮，如果绘图色比50%的灰暗，图像通过降低亮度变暗。 R = S + 2*D - 1 R = S + 2*D - 255 R = S + 2*D - 65535

func BlendLinearLightRGBA 

func BlendLinearLightRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendLinearLightRGBA 线性光模式 根据绘图色通过增加或降低“亮度”，加深或减淡颜色。如果绘图色比50%的灰亮，图像通过增加亮度被照亮，如果绘图色比50%的灰暗，图像通过降低亮度变暗。 R = S + 2*D - 1 R = S + 2*D - 255 R = S + 2*D - 65535

func BlendLuminosityColor 

func BlendLuminosityColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendLuminosityColor 亮度模式 是采用底色的色相和饱和度以及绘图色的亮度来创建最终色。此模式创建于颜色模式相反效果。 注： “差值”、“排除”、“色相”、“饱和度”、“颜色”和“明度”模式都不能与专色相混合，而且对于多数混合模式而言，指定为 100% K 的黑色会挖空下方图层中的颜色。请不要使用 100% 黑色，应改为使用 CMYK 值来指定复色黑。 HSV = Sh, Ss, Dv

func BlendLuminosityRGBA 

func BlendLuminosityRGBA(Sr, Sg, Sb, _ uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendLuminosityRGBA 亮度模式 是采用底色的色相和饱和度以及绘图色的亮度来创建最终色。此模式创建于颜色模式相反效果。 注： “差值”、“排除”、“色相”、“饱和度”、“颜色”和“明度”模式都不能与专色相混合，而且对于多数混合模式而言，指定为 100% K 的黑色会挖空下方图层中的颜色。请不要使用 100% 黑色，应改为使用 CMYK 值来指定复色黑。 HSV = Sh, Ss, Dv

func BlendMultiplyColor 

func BlendMultiplyColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendMultiplyColor 正片叠底 此模式就象是将两副透明的图像重叠夹在一起放在一张发光的桌子上。 将两个颜色的像素值相乘，然后除以255得到的结果就是最终色的像素值。通常执行正片叠底模式后的颜色比原来两种颜色都深。 任何颜色和黑色正片叠底得到的仍然是黑色，任何颜色和白色执行正片叠底则保持原来的颜色不变，而与其他颜色执行此模式会产生暗室中以此种颜色照明的效果。 在Multiply模式 中应用较淡的颜色对图像的最终像素颜色没有影响。 MuItiply模式模拟阴影是很捧的。现实 中的阴影从来也不会描绘出比源材料（阴影）或背景（获得阴影的区域）更淡的颜色或色调的 特征。用户将在本章中使用MuItiply模式在恢复的图像中对Lee加入一个下拉阴影。 在RGB模式下，每一个像素点的色阶范围是0-255(或0-65535)，纯黑色的色阶值是0，纯白色的色阶值是255。 R = S*D [0,1] R = S*D/255 [0,255] R = S*D/65535 [0,65535]

func BlendMultiplyRGBA 

func BlendMultiplyRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendMultiplyRGBA 正片叠底 此模式就象是将两副透明的图像重叠夹在一起放在一张发光的桌子上。 将两个颜色的像素值相乘，然后除以255得到的结果就是最终色的像素值。通常执行正片叠底模式后的颜色比原来两种颜色都深。 任何颜色和黑色正片叠底得到的仍然是黑色，任何颜色和白色执行正片叠底则保持原来的颜色不变，而与其他颜色执行此模式会产生暗室中以此种颜色照明的效果。 在Multiply模式 中应用较淡的颜色对图像的最终像素颜色没有影响。 MuItiply模式模拟阴影是很捧的。现实 中的阴影从来也不会描绘出比源材料（阴影）或背景（获得阴影的区域）更淡的颜色或色调的 特征。用户将在本章中使用MuItiply模式在恢复的图像中对Lee加入一个下拉阴影。 在RGB模式下，每一个像素点的色阶范围是0-255(或0-65535)，纯黑色的色阶值是0，纯白色的色阶值是255。 R = S*D [0,1] R = S*D/255 [0,255] R = S*D/65535 [0,65535]

func BlendNormalColor 

func BlendNormalColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendNormalColor 正常模式 是默认的状态，其最终色和绘图色相同。可通过改变画笔工具选项栏中的“不透明度”来设定不同的透明度。当图像的颜色模式是“位图”或“索引颜色”时，“正常”模式就变成“阈值”模式。 在基色存在透明度a%时，混合的运算方式是：最终色=基色*a% + 混合色*（1-a%）。 R = S*(1-Da) + D*Da

func BlendNormalRGBA 

func BlendNormalRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendNormalRGBA 正常模式 是默认的状态，其最终色和绘图色相同。可通过改变画笔工具选项栏中的“不透明度”来设定不同的透明度。当图像的颜色模式是“位图”或“索引颜色”时，“正常”模式就变成“阈值”模式。 在基色存在透明度a%时，混合的运算方式是：最终色=基色*a% + 混合色*（1-a%）。 R = S*(1-Da) + D*Da

func BlendNormalThresholdColor 

func BlendNormalThresholdColor(S, D color.Color, factor float64, destinationAlpha bool) color.Color

BlendNormalThresholdColor 阈值模式 是默认的状态，其最终色和绘图色相同。可通过改变画笔工具选项栏中的“不透明度”来设定不同的透明度。当图像的颜色模式是“位图”或“索引颜色”时，“正常”模式就变成“阈值”模式。 在基色存在透明度a%时，混合的运算方式是：最终色=基色*a% + 混合色*（1-a%）。 R = S*(1-factor) + D*factor

func BlendNormalThresholdRGBA 

func BlendNormalThresholdRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, factor float64, destinationAlpha bool) (R, G, B, A uint32)

BlendNormalThresholdRGBA 阈值模式 是默认的状态，其最终色和绘图色相同。可通过改变画笔工具选项栏中的“不透明度”来设定不同的透明度。当图像的颜色模式是“位图”或“索引颜色”时，“正常”模式就变成“阈值”模式。 在基色存在透明度a%时，混合的运算方式是：最终色=基色*a% + 混合色*（1-a%）。 R = S*(1-factor) + D*factor

func BlendOverlayColor 

func BlendOverlayColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendOverlayColor 叠加模式 在保留底色明暗变化的基础上使用“正片叠底”或“滤色”模式，绘图的颜色被叠加到底色上，但保留底色的高光和阴影部分。底色的颜色没有被取代，而是和绘图色混合来体现原图的亮部和暗部。 使用此模式可使底色的图像的饱和度及对比度得到相应的提高，使图像看起来更加鲜亮。 这种模式以一种非艺术逻辑的方式把放置或应用到一个层上的颜色同背景色进行混 合，然而，却能得到有趣的效果。背景图像中的纯黑色或纯白色区域无法在Overlay模式下 显示层上的Overlay着色或图像区域。 背景区域上落在黑色和白色之间的亮度值同0verlay 材料的颜色混合在一起，产生最终的合成颜色。为了使背景图像看上去好像是同设计或文本 一起拍摄的，Overlay可用来在背景图像上画上一个设计或文本。 R = S<=0.5 ? 2*S*D : 1-2*(1-S)*(1-D) R = S<=128 ? S*D/128 : 255-(255-S)*(255-d)/128 R = S<=32768 ? S*D/32768 : 65535-(65535-S)*(65534-D)/32768

func BlendOverlayRGBA 

func BlendOverlayRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendOverlayRGBA 叠加模式 在保留底色明暗变化的基础上使用“正片叠底”或“滤色”模式，绘图的颜色被叠加到底色上，但保留底色的高光和阴影部分。底色的颜色没有被取代，而是和绘图色混合来体现原图的亮部和暗部。 使用此模式可使底色的图像的饱和度及对比度得到相应的提高，使图像看起来更加鲜亮。 这种模式以一种非艺术逻辑的方式把放置或应用到一个层上的颜色同背景色进行混 合，然而，却能得到有趣的效果。背景图像中的纯黑色或纯白色区域无法在Overlay模式下 显示层上的Overlay着色或图像区域。 背景区域上落在黑色和白色之间的亮度值同0verlay 材料的颜色混合在一起，产生最终的合成颜色。为了使背景图像看上去好像是同设计或文本 一起拍摄的，Overlay可用来在背景图像上画上一个设计或文本。 R = S<=0.5 ? 2*S*D : 1-2*(1-S)*(1-D) R = S<=128 ? S*D/128 : 255-(255-S)*(255-d)/128 R = S<=32768 ? S*D/32768 : 65535-(65535-S)*(65534-D)/32768

func BlendPinLightColor 

func BlendPinLightColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendPinLightColor 点光模式 根据绘图色替换颜色。如果绘图色比50%的灰要亮，绘图色被替换，比绘图色亮的像素不变化。如果绘图色比50%的灰要暗比绘图色亮的像素被替换，比绘图色暗的像素不变化，点光模式对图像增加特殊效果非常有用。 R = D>0.5 ? Min(S, 2*D-1) : S R = D>128 ? Min(S, 2*D-255) : S R = D>32768 ? Min(S, 2*D-65535) : S

func BlendPinLightRGBA 

func BlendPinLightRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendPinLightRGBA 点光模式 根据绘图色替换颜色。如果绘图色比50%的灰要亮，绘图色被替换，比绘图色亮的像素不变化。如果绘图色比50%的灰要暗比绘图色亮的像素被替换，比绘图色暗的像素不变化，点光模式对图像增加特殊效果非常有用。 R = D>0.5 ? Min(S, 2*D-1) : S R = D>128 ? Min(S, 2*D-255) : S R = D>32768 ? Min(S, 2*D-65535) : S

func BlendPlusDarkerColor 

func BlendPlusDarkerColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendPlusDarkerColor R = MAX(0, (1 - D) + (1 - S)) [0,1] R = MAX(0, (255-D) + (255-S)) [0,255] R = MAX(0, (65535-D) + (65535-S)) [0,65535]

func BlendPlusDarkerRGBA 

func BlendPlusDarkerRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendPlusDarkerRGBA R = MAX(0, (1 - D) + (1 - S)) [0,1] R = MAX(0, (255-D) + (255-S)) [0,255] R = MAX(0, (65535-D) + (65535-S)) [0,65535]

func BlendPlusLighterColor 

func BlendPlusLighterColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendPlusLighterColor R = MIN(1, S + D) [0,1] R = MIN(255, S + D) [0,255] R = MIN(65535, S + D) [0,65535]

func BlendPlusLighterRGBA 

func BlendPlusLighterRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendPlusLighterRGBA R = MIN(1, S + D) [0,1] R = MIN(255, S + D) [0,255] R = MIN(65535, S + D) [0,65535]

func BlendSaturationColor 

func BlendSaturationColor(foreColor, backColor color.Color, _ float64, destinationAlpha bool) color.Color

BlendSaturationColor 饱和度模式 是采用底色的亮度、色相以及绘图色的饱和度来创建最终色。如果绘图色的饱和度为0，则原图没有变化。 在把纯蓝色应用到一个灰暗的背景图像中时，显出了背景中 的原始纯色，但蓝色并未加入到合成图像中。如果选择一种中性颜色（一种并不显示主流色 度的颜色），对背景图像不发生任何变化。 Saturation模式可用来显出图像中颜色强度已经由 于岁月变得灰暗的底层颜色。 HSV = Sh, Ds, Sv

func BlendSaturationRGBA 

func BlendSaturationRGBA(Sr, Sg, Sb, _ uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendSaturationRGBA 饱和度模式 是采用底色的亮度、色相以及绘图色的饱和度来创建最终色。如果绘图色的饱和度为0，则原图没有变化。 在把纯蓝色应用到一个灰暗的背景图像中时，显出了背景中 的原始纯色，但蓝色并未加入到合成图像中。如果选择一种中性颜色（一种并不显示主流色 度的颜色），对背景图像不发生任何变化。 Saturation模式可用来显出图像中颜色强度已经由 于岁月变得灰暗的底层颜色。 HSV = Sh, Ds, Sv

func BlendScreenColor 

func BlendScreenColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendScreenColor 滤色模式 作用结果和正片叠底刚好相反，它是将两个颜色的互补色的像素值相乘，然后除以255得到的最终色的像素值。通常执行滤色模式后的颜色都较浅。任何颜色和黑色执行滤色，原色不受影响;任何颜色和白色执行滤色得到的是白色；而与其他颜色执行滤色会产生漂白的效果。 此屏幕模式对于在图像中创建霓虹辉光效果是有用的。如果在层上围绕背景对象的边缘涂了白色（或任何淡颜色），然后指定层Screen模式，通过调节层的opacity设置就能 获得饱满或稀薄的辉光效果。 （附：在Screen和Multiply运算中的重点是----两幅图做Screen运算会加强亮的部分；做Multipy运算则会加强两幅图中暗的部分） R = 1 - (1 - S)*(1 - D) R = 255 - (255-S)*(255-D) / 255 R = 65535 - (65535-S)*(65535-D) / 65535

func BlendScreenRGBA 

func BlendScreenRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendScreenRGBA 滤色模式 作用结果和正片叠底刚好相反，它是将两个颜色的互补色的像素值相乘，然后除以255得到的最终色的像素值。通常执行滤色模式后的颜色都较浅。任何颜色和黑色执行滤色，原色不受影响;任何颜色和白色执行滤色得到的是白色；而与其他颜色执行滤色会产生漂白的效果。 此屏幕模式对于在图像中创建霓虹辉光效果是有用的。如果在层上围绕背景对象的边缘涂了白色（或任何淡颜色），然后指定层Screen模式，通过调节层的opacity设置就能 获得饱满或稀薄的辉光效果。 （附：在Screen和Multiply运算中的重点是----两幅图做Screen运算会加强亮的部分；做Multipy运算则会加强两幅图中暗的部分） R = 1 - (1 - S)*(1 - D) R = 255 - (255-S)*(255-D) / 255 R = 65535 - (65535-S)*(65535-D) / 65535

func BlendSoftLightColor 

func BlendSoftLightColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendSoftLightColor 柔光模式 根据绘图色的明暗程度来决定最终色是变亮还是变暗，当绘图色比50%的灰要亮时，则底色图像变亮。当绘图色比50%的灰要暗时，则底色图像就变暗。如果绘图色有纯黑色或纯白色，最终色不是黑色或白色，而是稍微变暗或变亮。 如果底色是纯白色或纯黑色，不产生任何效果。此效果与发散的聚光灯照在图像上相似。 (F<=0.5): R = 2*S*D + S*S*(1-2*D) (F>0.5) : R = 2*S*(1-D) + (2*D - 1)*√S

(D<=128): R = S*D/128 + (255-2*D)*S*S/65025 (D>128) : R = S*(255-D)/128 + (2*D-255)*√(S/255)

(D<=128): R = S*D/32768 + (65535-2*D)*S*S/4294836225 (D>128) : R = S*(65535-D)/32768 + (2*D-65535)*√(S/65535)

func BlendSoftLightRGBA 

func BlendSoftLightRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendSoftLightRGBA 柔光模式 根据绘图色的明暗程度来决定最终色是变亮还是变暗，当绘图色比50%的灰要亮时，则底色图像变亮。当绘图色比50%的灰要暗时，则底色图像就变暗。如果绘图色有纯黑色或纯白色，最终色不是黑色或白色，而是稍微变暗或变亮。 如果底色是纯白色或纯黑色，不产生任何效果。此效果与发散的聚光灯照在图像上相似。 (F<=0.5): R = 2*S*D + S*S*(1-2*D) (F>0.5) : R = 2*S*(1-D) + (2*D - 1)*√S

(D<=128): R = S*D/128 + (255-2*D)*S*S/65025 (D>128) : R = S*(255-D)/128 + (2*D-255)*√(S/255)

(D<=128): R = S*D/32768 + (65535-2*D)*S*S/4294836225 (D>128) : R = S*(65535-D)/32768 + (2*D-65535)*√(S/65535)

func BlendSourceAtopColor 

func BlendSourceAtopColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendSourceAtopColor R = S*Da + D*(1 - Sa) R = (S*Da + D*(255 - Sa))/255 R = (S*Da + D*(65535 - Sa))/65535

func BlendSourceAtopRGBA 

func BlendSourceAtopRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendSourceAtopRGBA R = S*Da + D*(1 - Sa) R = (S*Da + D*(255 - Sa))/255 R = (S*Da + D*(65535 - Sa))/65535

func BlendSourceInColor 

func BlendSourceInColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendSourceInColor R = S*Da R = S*Da/255 R = S*Da/65535

func BlendSourceInRGBA 

func BlendSourceInRGBA(Sr, Sg, Sb, Sa uint32, _, _, _, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendSourceInRGBA R = S*Da R = S*Da/255 R = S*Da/65535

func BlendSourceOutColor 

func BlendSourceOutColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendSourceOutColor R = S*(1 - Da) R = S*(255 - Da)/255 R = S*(65535 - Da)/65535

func BlendSourceOutRGBA 

func BlendSourceOutRGBA(Sr, Sg, Sb, Sa uint32, _, _, _, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendSourceOutRGBA R = S*(1 - Da) R = S*(255 - Da)/255 R = S*(65535 - Da)/65535

func BlendSourceOverColor 

func BlendSourceOverColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendSourceOverColor R = D*(1 - Sa) + S R = D*(1 - Sa)/255 + S R = D*(1 - Sa)/65535 + S

func BlendSourceOverRGBA 

func BlendSourceOverRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendSourceOverRGBA R = D*(1 - Sa) + S R = D*(1 - Sa)/255 + S R = D*(1 - Sa)/65535 + S

func BlendSubtractColor 

func BlendSubtractColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendSubtractColor 减去模式 是将原始图像与混合图像相对应的像素提取出来并将它们相减。 C = Max(0,S-D)

func BlendSubtractRGBA 

func BlendSubtractRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendSubtractRGBA 减去模式 是将原始图像与混合图像相对应的像素提取出来并将它们相减。 C = Max(0,S-D)

func BlendVividLightColor 

func BlendVividLightColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendVividLightColor 亮光模式 根据绘图色通过增加或降低“对比度”，加深或减淡颜色。如果绘图色比50%的灰亮，图像通过降低对比度被照亮，如果绘图色比50%的灰暗，图像通过增加对比度变暗。 (D<=128): R = S - (255-S)*(255-2*D) / (2*D) (D>128): R = S + S*(2*D-255)/(2*(255-D))

(D<=32768): R = S - (65535-S)*(65535-2*D) / (2*D) (D>32768): R = S + S*(2*D-65535)/(2*(6553-D))

func BlendVividLightRGBA 

func BlendVividLightRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendVividLightRGBA 亮光模式 根据绘图色通过增加或降低“对比度”，加深或减淡颜色。如果绘图色比50%的灰亮，图像通过降低对比度被照亮，如果绘图色比50%的灰暗，图像通过增加对比度变暗。 (D<=128): R = S - (255-S)*(255-2*D) / (2*D) (D>128): R = S + S*(2*D-255)/(2*(255-D))

(D<=32768): R = S - (65535-S)*(65535-2*D) / (2*D) (D>32768): R = S + S*(2*D-65535)/(2*(6553-D))

func BlendXorColor 

func BlendXorColor(S, D color.Color, _ float64, destinationAlpha bool) color.Color

BlendXorColor 异或模式 R = S*(1 - Da) + D*(1 - Sa) R = (S*(255 - Da) + D*(255 - Sa))/255 R = (S*(65535 - Da) + D*(65535 - Sa))/65535 Note that the Porter-Duff "XOR" mode is only titularly related to the classical bitmap XOR operation (which is unsupported by CoreGraphics)

func BlendXorRGBA 

func BlendXorRGBA(Sr, Sg, Sb, Sa uint32, Dr, Dg, Db, Da uint32, _ float64, destinationAlpha bool) (R, G, B, A uint32)

BlendXorRGBA 异或模式 R = S*(1 - Da) + D*(1 - Sa) R = (S*(255 - Da) + D*(255 - Sa))/255 R = (S*(65535 - Da) + D*(65535 - Sa))/65535 Note that the Porter-Duff "XOR" mode is only titularly related to the classical bitmap XOR operation (which is unsupported by CoreGraphics)

func RegisterBlendFunc 

func RegisterBlendFunc(blendMode BlendMode, funcBlendColor FuncBlendColor, funcBlendRGBA FuncBlendRGBA)

Types

type BlendMode 

type BlendMode int
const (
	// None 无
	None BlendMode = iota

	// Normal 正常模式(已实现)
	Normal
	// NormalThreshold 阈值模式(已实现)
	NormalThreshold
	// Dissolve 溶解模式(已实现)
	Dissolve
	// Behind 背后模式(已实现)
	Behind
	// Clear 清除模式(已实现)
	Clear
	// Copy 覆盖模式(已实现)
	Copy

	// Darken 变暗模式(已实现)
	Darken
	// Multiply 正片叠底(已实现)
	Multiply
	// ColorBurn 颜色加深模式(已实现)
	ColorBurn
	// LinearBurn 线性加深模式(已实现)
	LinearBurn
	// DarkerColor 深色模式----------------------------------------
	DarkerColor

	// Add 增加模式(已实现)
	Add
	// Lighten 变亮模式(已实现)
	Lighten
	// Screen 滤色模式(已实现)
	Screen
	// ColorDodge 颜色减淡模式(已实现)
	ColorDodge
	// LinearDodge 线性减淡模式(已实现)
	LinearDodge
	// LighterColor 浅色模式----------------------------------
	LighterColor

	// Overlay 叠加模式(已实现)
	Overlay
	// SoftLight 柔光模式(已实现)
	SoftLight
	// HardLight 强光模式(已实现)
	HardLight
	// VividLight 亮光模式(已实现)
	VividLight
	// LinearLight 线性光模式(已实现)
	LinearLight
	// PinLight 点光模式(已实现)
	PinLight
	// HardMix 实色混合模式(已实现)
	HardMix

	// Difference 差值模式(已实现)
	Difference
	// Exclusion 排除模式(已实现)
	Exclusion
	// Subtract 减去模式(已实现)
	Subtract
	// Divide 划分模式(已实现)
	Divide

	// Hue 色相模式
	Hue
	// Saturation 饱和度模式
	Saturation
	// Color 颜色模式
	Color
	// Luminosity 亮度模式
	Luminosity

	// DestinationAtop (已实现)
	DestinationAtop
	// DestinationIn (已实现)
	DestinationIn
	// DestinationOut (已实现)
	DestinationOut
	// DestinationOver (已实现)
	DestinationOver
	// PlusDarker 高级深色(已实现)
	PlusDarker
	// PlusLighter 高级浅色(已实现)
	PlusLighter
	// SourceAtop (已实现)
	SourceAtop
	// SourceIn (已实现)
	SourceIn
	// SourceOut (已实现)
	SourceOut
	// SourceOver (已实现)
	SourceOver
	// Xor 异或模式(已实现)
	Xor
)

func (BlendMode) BlendColor 

func (m BlendMode) BlendColor(source, destination color.Color, factor float64, destinationAlpha bool) (c color.Color, err error)

func (BlendMode) BlendRGBA 

func (m BlendMode) BlendRGBA(sourceR, sourceG, sourceB, sourceA uint32, destinationR, destinationG, destinationB, destinationA uint32,
	factor float64, destinationAlpha bool) (R, G, B, A uint32, err error)

type FuncBlendColor 

type FuncBlendColor func(source, destination color.Color, factor float64, destinationAlpha bool) (resultColor color.Color)

FuncBlendColor resultColor : 结果色 sourceColor : 源颜色/背景色/混合色(ps概念) destinationColor ：目标色/前景色/基色(ps概念)

type FuncBlendRGBA 

type FuncBlendRGBA func(sourceR, sourceG, sourceB, sourceA uint32, destinationR, destinationG, destinationB, destinationA uint32,
	factor float64, destinationAlpha bool) (R, G, B, A uint32)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.