Photoshop如何将两个图像融合在一起？[关闭]

84

有人可以解释一下Photoshop如何将两个图像融合在一起，以便在应用程序中重现相同的效果。

c++  c  math  image-processing  photoshop 
— 内森·莫因瓦济里（Nathan Moinvaziri）
source
3
这绝对不是关于通用计算硬件或软件的问题。它与算法，C ++和图像处理有关。这种类型的问题被明确允许并积极鼓励
— 帕纳约蒂斯Kanavos
经过8年的点击次数，现在才算是主题吗？
— 内森·莫因瓦济里
它需要的是至少有3000名代表的5票赞成票。很明显，SO社区不认为这个问题是题外话
— Panagiotis Kanavos
附言：4名不愿投票的人可能已有8岁。上周有人可能在关闭队列中遇到了这个问题，并投票决定关闭。因此，现在有这么多问题，很难再对问题进行适当的关注了。编辑历史表明，原来的问题需要编辑过的一点
— 帕纳约蒂斯Kanavos
也许恢复到修订版3或类似的内容，将使审阅者更有可能重新打开该修订版。在当前状态下，很容易将这个问题误认为是“我如何使用Photoshop”问题，并且由于没有显示任何研究成果而将其驳回。
— 亚当·米勒奇奇

Answers:

210

通过在图像A中的每个像素上对图像B中的对应像素执行混合操作，Photoshop将两个图像混合在一起。每个像素是一种由多个通道组成的颜色。假设我们正在处理RGB像素，则每个像素中的通道将是红色，绿色和蓝色。要混合两个像素，我们混合它们各自的通道。

可以在以下宏中总结针对Photoshop中每种混合模式发生的混合操作：

#define ChannelBlend_Normal(A,B)     ((uint8)(A))
#define ChannelBlend_Lighten(A,B)    ((uint8)((B > A) ? B:A))
#define ChannelBlend_Darken(A,B)     ((uint8)((B > A) ? A:B))
#define ChannelBlend_Multiply(A,B)   ((uint8)((A * B) / 255))
#define ChannelBlend_Average(A,B)    ((uint8)((A + B) / 2))
#define ChannelBlend_Add(A,B)        ((uint8)(min(255, (A + B))))
#define ChannelBlend_Subtract(A,B)   ((uint8)((A + B < 255) ? 0:(A + B - 255)))
#define ChannelBlend_Difference(A,B) ((uint8)(abs(A - B)))
#define ChannelBlend_Negation(A,B)   ((uint8)(255 - abs(255 - A - B)))
#define ChannelBlend_Screen(A,B)     ((uint8)(255 - (((255 - A) * (255 - B)) >> 8)))
#define ChannelBlend_Exclusion(A,B)  ((uint8)(A + B - 2 * A * B / 255))
#define ChannelBlend_Overlay(A,B)    ((uint8)((B < 128) ? (2 * A * B / 255):(255 - 2 * (255 - A) * (255 - B) / 255)))
#define ChannelBlend_SoftLight(A,B)  ((uint8)((B < 128)?(2*((A>>1)+64))*((float)B/255):(255-(2*(255-((A>>1)+64))*(float)(255-B)/255))))
#define ChannelBlend_HardLight(A,B)  (ChannelBlend_Overlay(B,A))
#define ChannelBlend_ColorDodge(A,B) ((uint8)((B == 255) ? B:min(255, ((A << 8 ) / (255 - B)))))
#define ChannelBlend_ColorBurn(A,B)  ((uint8)((B == 0) ? B:max(0, (255 - ((255 - A) << 8 ) / B))))
#define ChannelBlend_LinearDodge(A,B)(ChannelBlend_Add(A,B))
#define ChannelBlend_LinearBurn(A,B) (ChannelBlend_Subtract(A,B))
#define ChannelBlend_LinearLight(A,B)((uint8)(B < 128)?ChannelBlend_LinearBurn(A,(2 * B)):ChannelBlend_LinearDodge(A,(2 * (B - 128))))
#define ChannelBlend_VividLight(A,B) ((uint8)(B < 128)?ChannelBlend_ColorBurn(A,(2 * B)):ChannelBlend_ColorDodge(A,(2 * (B - 128))))
#define ChannelBlend_PinLight(A,B)   ((uint8)(B < 128)?ChannelBlend_Darken(A,(2 * B)):ChannelBlend_Lighten(A,(2 * (B - 128))))
#define ChannelBlend_HardMix(A,B)    ((uint8)((ChannelBlend_VividLight(A,B) < 128) ? 0:255))
#define ChannelBlend_Reflect(A,B)    ((uint8)((B == 255) ? B:min(255, (A * A / (255 - B)))))
#define ChannelBlend_Glow(A,B)       (ChannelBlend_Reflect(B,A))
#define ChannelBlend_Phoenix(A,B)    ((uint8)(min(A,B) - max(A,B) + 255))
#define ChannelBlend_Alpha(A,B,O)    ((uint8)(O * A + (1 - O) * B))
#define ChannelBlend_AlphaF(A,B,F,O) (ChannelBlend_Alpha(F(A,B),A,O))

要混合单个RGB像素，请执行以下操作：

ImageTColorR = ChannelBlend_Glow(ImageAColorR, ImageBColorR); 
ImageTColorB = ChannelBlend_Glow(ImageAColorB, ImageBColorB);
ImageTColorG = ChannelBlend_Glow(ImageAColorG, ImageBColorG);

ImageTColor = RGB(ImageTColorR, ImageTColorB, ImageTColorG);

如果我们要执行具有特定不透明度的混合操作，请说50％：

ImageTColorR = ChannelBlend_AlphaF(ImageAColorR, ImageBColorR, Blend_Subtract, 0.5F);

如果您有指向图像A，B和T（我们的目标）的图像数据的指针，我们可以使用此宏简化所有三个通道的混合：

#define ColorBlend_Buffer(T,A,B,M)      (T)[0] = ChannelBlend_##M((A)[0], (B)[0]),
                                        (T)[1] = ChannelBlend_##M((A)[1], (B)[1]),
                                        (T)[2] = ChannelBlend_##M((A)[2], (B)[2])

并可以派生以下RGB颜色混合宏：

#define ColorBlend_Normal(T,A,B)        (ColorBlend_Buffer(T,A,B,Normal))
#define ColorBlend_Lighten(T,A,B)       (ColorBlend_Buffer(T,A,B,Lighten))
#define ColorBlend_Darken(T,A,B)        (ColorBlend_Buffer(T,A,B,Darken))
#define ColorBlend_Multiply(T,A,B)      (ColorBlend_Buffer(T,A,B,Multiply))
#define ColorBlend_Average(T,A,B)       (ColorBlend_Buffer(T,A,B,Average))
#define ColorBlend_Add(T,A,B)           (ColorBlend_Buffer(T,A,B,Add))
#define ColorBlend_Subtract(T,A,B)      (ColorBlend_Buffer(T,A,B,Subtract))
#define ColorBlend_Difference(T,A,B)    (ColorBlend_Buffer(T,A,B,Difference))
#define ColorBlend_Negation(T,A,B)      (ColorBlend_Buffer(T,A,B,Negation))
#define ColorBlend_Screen(T,A,B)        (ColorBlend_Buffer(T,A,B,Screen))
#define ColorBlend_Exclusion(T,A,B)     (ColorBlend_Buffer(T,A,B,Exclusion))
#define ColorBlend_Overlay(T,A,B)       (ColorBlend_Buffer(T,A,B,Overlay))
#define ColorBlend_SoftLight(T,A,B)     (ColorBlend_Buffer(T,A,B,SoftLight))
#define ColorBlend_HardLight(T,A,B)     (ColorBlend_Buffer(T,A,B,HardLight))
#define ColorBlend_ColorDodge(T,A,B)    (ColorBlend_Buffer(T,A,B,ColorDodge))
#define ColorBlend_ColorBurn(T,A,B)     (ColorBlend_Buffer(T,A,B,ColorBurn))
#define ColorBlend_LinearDodge(T,A,B)   (ColorBlend_Buffer(T,A,B,LinearDodge))
#define ColorBlend_LinearBurn(T,A,B)    (ColorBlend_Buffer(T,A,B,LinearBurn))
#define ColorBlend_LinearLight(T,A,B)   (ColorBlend_Buffer(T,A,B,LinearLight))
#define ColorBlend_VividLight(T,A,B)    (ColorBlend_Buffer(T,A,B,VividLight))
#define ColorBlend_PinLight(T,A,B)      (ColorBlend_Buffer(T,A,B,PinLight))
#define ColorBlend_HardMix(T,A,B)       (ColorBlend_Buffer(T,A,B,HardMix))
#define ColorBlend_Reflect(T,A,B)       (ColorBlend_Buffer(T,A,B,Reflect))
#define ColorBlend_Glow(T,A,B)          (ColorBlend_Buffer(T,A,B,Glow))
#define ColorBlend_Phoenix(T,A,B)       (ColorBlend_Buffer(T,A,B,Phoenix))

例子是：

ColorBlend_Glow(TargetPtr, ImageAPtr, ImageBPtr);

其余的Photoshop混合模式涉及将RGB转换为HLS，然后再次转换。 

#define ColorBlend_Hue(T,A,B)            ColorBlend_Hls(T,A,B,HueB,LuminationA,SaturationA)
#define ColorBlend_Saturation(T,A,B)     ColorBlend_Hls(T,A,B,HueA,LuminationA,SaturationB)
#define ColorBlend_Color(T,A,B)          ColorBlend_Hls(T,A,B,HueB,LuminationA,SaturationB)
#define ColorBlend_Luminosity(T,A,B)     ColorBlend_Hls(T,A,B,HueA,LuminationB,SaturationA)

#define ColorBlend_Hls(T,A,B,O1,O2,O3) {
    float64 HueA, LuminationA, SaturationA;
    float64 HueB, LuminationB, SaturationL;
    Color_RgbToHls((A)[2],(A)[1],(A)[0], &HueA, &LuminationA, &SaturationA);
    Color_RgbToHls((B)[2],(B)[1],(B)[0], &HueB, &LuminationB, &SaturationB);
    Color_HlsToRgb(O1,O2,O3,&(T)[2],&(T)[1],&(T)[0]);
    }

这些功能将有助于将RGB转换为HLS。

int32 Color_HueToRgb(float64 M1, float64 M2, float64 Hue, float64 *Channel)
{
    if (Hue < 0.0)
        Hue += 1.0;
    else if (Hue > 1.0)
        Hue -= 1.0;

    if ((6.0 * Hue) < 1.0)
        *Channel = (M1 + (M2 - M1) * Hue * 6.0);
    else if ((2.0 * Hue) < 1.0)
        *Channel = (M2);
    else if ((3.0 * Hue) < 2.0)
        *Channel = (M1 + (M2 - M1) * ((2.0F / 3.0F) - Hue) * 6.0);
    else
        *Channel = (M1);

    return TRUE;
}

int32 Color_RgbToHls(uint8 Red, uint8 Green, uint8 Blue, float64 *Hue, float64 *Lumination, float64 *Saturation)
{
    float64 Delta;
    float64 Max, Min;
    float64 Redf, Greenf, Bluef;

    Redf    = ((float64)Red   / 255.0F);
    Greenf  = ((float64)Green / 255.0F);
    Bluef   = ((float64)Blue  / 255.0F); 

    Max     = max(max(Redf, Greenf), Bluef);
    Min     = min(min(Redf, Greenf), Bluef);

    *Hue        = 0;
    *Lumination = (Max + Min) / 2.0F;
    *Saturation = 0;

    if (Max == Min)
        return TRUE;

    Delta = (Max - Min);

    if (*Lumination < 0.5)
        *Saturation = Delta / (Max + Min);
    else
        *Saturation = Delta / (2.0 - Max - Min);

    if (Redf == Max)
        *Hue = (Greenf - Bluef) / Delta;
    else if (Greenf == Max)
        *Hue = 2.0 + (Bluef - Redf) / Delta;
    else
        *Hue = 4.0 + (Redf - Greenf) / Delta;

    *Hue /= 6.0; 

    if (*Hue < 0.0)
        *Hue += 1.0;       

    return TRUE;
}

int32 Color_HlsToRgb(float64 Hue, float64 Lumination, float64 Saturation, uint8 *Red, uint8 *Green, uint8 *Blue)
{
    float64 M1, M2;
    float64 Redf, Greenf, Bluef;

    if (Saturation == 0)
        {
        Redf    = Lumination;
        Greenf  = Lumination;
        Bluef   = Lumination;
        }
    else
        {
        if (Lumination <= 0.5)
            M2 = Lumination * (1.0 + Saturation);
        else
            M2 = Lumination + Saturation - Lumination * Saturation;

        M1 = (2.0 * Lumination - M2);

        Color_HueToRgb(M1, M2, Hue + (1.0F / 3.0F), &Redf);
        Color_HueToRgb(M1, M2, Hue, &Greenf);
        Color_HueToRgb(M1, M2, Hue - (1.0F / 3.0F), &Bluef);
        }

    *Red    = (uint8)(Redf * 255);
    *Blue   = (uint8)(Bluef * 255);
    *Green  = (uint8)(Greenf * 255);

    return TRUE;
}

关于此主题的资源更多，主要是：

  1. PegTop混合模式
  2. 法医Photoshop
  3. 深入了解Photoshop 7.0混合模式
  4. SF-基础-混合模式
  5. 完成混合模式
  6. 罗姆兹博客
  7. ReactOS RGB-HLS转换功能
— 内森·莫因瓦济里（Nathan Moinvaziri）
source
1
是的，很好的答案，谢谢！我想知道是否有人知道在Photoshop中如何完成图层不透明度？即我想使用混合变暗功能，但仅使用50％...我在photoshop中检查了值，但似乎只取混合图像的50％的值就足够了
— Maecky
2
给出的Alpha公式不完整-仅适用于背景完全不透明的情况。如果背景是透明的，则绘制后的结果可以是透明的。对于这种更一般的情况，您需要应用Wikipedia中所述的alpha混合。
— thenickdude
2
Alpha通道怎么样？我是否也应该对其应用功能？
— akhy 2013年
好答案！！反射和发光被切换。否则：太好了！（尽管缺少alpha合成。）
— TaW
C＃用于alpha压缩的解决方案：静态颜色alphaComposite（Color c1，Color c2，Color cb，float op）{float a1，a2，ab，ar = 1; ar = v [c1.A] + v [c2.A] * op-（v [c1.A] * v [c2.A] * op）；float asr = v [c2.A] * op / ar; a1 = 1-asr; a2 = asr *（1-v [c1.A]）; ab = asr * v [c1.A]; 字节r =（字节）（c1.R * a1 + c2.R * a2 + cb.R * ab）; 字节g =（字节）（c1.G * a1 + c2.G * a2 + cb.G * ab）; 字节b =（字节）（c1.B * a1 + c2.B * a2 + cb.B * ab）; 返回Color.FromArgb（（byte）（ar * 255），r，g，b）; }
— TaW 2016年
7

此答案中的“色相”，“颜色”，“饱和度”混合模式是错误的。没有Adobe产品转换为HSB，它们直接对RGB值进行操作。

例如，这是用于设置亮度的GLSL：

float lum(vec4 color)
{
    return ((0.3 * color.r) + (0.59 * color.g) + (0.11 * color.b));
}

vec4 clipColor(vec4 color)
{
    vec4 newColor=color;
    float l=lum(color);
    float n=min(min(color.r,color.g),color.b);
    float x=max(max(color.r,color.g),color.b);

    newColor.r=(n<0.0) ? l+(((color.r-l)*l)/(l-n)) : color.r;
    newColor.r=(x>1.0) ? l+(((color.r-l)*(1.0-l))/(x-l)) : color.r;

    newColor.g=(n<0.0) ? l+(((color.g-l)*l)/(l-n)) : color.g;
    newColor.g=(x>1.0) ? l+(((color.g-l)*(1.0-l))/(x-l)) : color.g;

    newColor.b=(n<0.0) ? l+(((color.b-l)*l)/(l-n)) : color.b;
    newColor.b=(x>1.0) ? l+(((color.b-l)*(1.0-l))/(x-l)) : color.b;

    return clamp(newColor,0.0,1.0);
}

vec4 setlum(vec4 color, float l)
{
    float d=l-lum(color);
    color.r+=d;
    color.g+=d;
    color.b+=d;

    return clipColor(color);    
}

kernel vec4 blendLuminosity(sampler topimage, sampler bottomimage)
{
    vec4 base=sample(bottomimage, samplerCoord(bottomimage));
    vec4 blend=sample(topimage, samplerCoord(topimage));

    float bl=lum(blend);
    return setlum(base,bl);
}

CIKernels中不支持if .. else语句，因此使用三元运算符。

— 乔恩·吉尔基森
source
4

普遍的答案是正确的99.9％，但是正如Greyfriars所说的那样，由于Adobe不会在混合中随时使用HLS，因此不会得到确切的结果。

但是您无需在Adobe工作即可...遵循Adobe的本文档中的所有规则，您可以实现完全相同的混合：

基本上是第4章和第7章： http : //partners.adobe.com/public/developer/en/pdf/PDFReference.pdf

然后，您将获得与Adobe一样的准确结果！逐像素！

— 瓦格纳·帕特里奥塔
source
i.imgur.com/G5MbHOH.png表示链接中使用了HSL（我在这里关注，因为该链接对我来说是断开的：adobe.com/content/dam/acom/en/devnet/pdf/pdfs/…）
— eri0o18年
0

尽管流行的答案大部分是正确的，但以下说法是错误的。“其余的Photoshop混合模式涉及将RGB转换为HLS并再次转换。” 不，Photoshop（并且只有Photoshop）使用Chroma和Luma代替HLS。

因此，对于“色相”，“颜色”，“光度”和“饱和度”模式，不能使用简单的算法。要在这些情况下匹配Photoshop的方法，您需要使用Adobe。

— 格雷弗里亚尔·鲍比（Greyfriars Bobby）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.