图层混合算法(二)

于 2023-09-25 11:34:57 发布
阅读量133 收藏
点赞数
分类专栏： OpenCV 图像视频处理 文章标签： 算法 计算机视觉 opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hulinhulin/article/details/133266480
版权

混合后图像变亮

变亮模式（lighten）

        变亮模式跟变暗模式是相对的，它是通过混合色与基色的相关数值进行比较，选择较大的数值作为结果色。因此结果色会更亮，同时颜色也会变化。（位置互换不发生变化）

void layerblend_lightness(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++)
                d3[cw + c] = d1[cw + c] > d2[cw + c] ? d1[cw + c] : d2[cw + c];
        }
    }
}

滤色模式(screen)

        滤色模式与正片叠底模式相对。它的计算公式是：255 - 混合色的补色 * 基色补色 / 255。得到的数据会比混合及基色更大，因此结果色会更亮。从计算公式也可以看出基色或混合色任何一项为255也就是白色，结果色数值就是255为白色。任何一项数值为0，也就是为黑色的话，结果色就跟数值不为0的一致。

void layerblend_screen(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++)
                d3[cw + c] = 255 - (255.0f - d1[cw + c]) * (255.0f - d2[cw + c]) / 255;
        }
    }
}

颜色减淡(color light)

        颜色减淡是通过混合色及基色的各通道颜色值进行对比，减少二者的对比度使基色的变亮来反映混合色。它的计算公式：结果色 = 基色 + (混合色 * 基色) / (255 - 混合色)。混合色为黑色，结果色就等于基色，混合色为白色结果色就为白色。基色为黑色结果色就为黑色.

void layerblend_color_light(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++){
                 int res = 0;
                 if (d2[cw + c] == 0)
                     res = 255;
                 else
                     res = d1[cw + c] + (1.0f * d1[cw + c] * d2[cw + c]) / (255.0f - d2[cw + c]);

                 d3[cw + c] = saturate_cast<uchar>(res);
            }
        }
    }
}

颜色线性减淡(color linear light)

        颜色线性减淡是通过查看每个通道的颜色信息，并通过增加亮度使基色变亮以反映混合色。它的计算公式：结果色 = 基色 + 混合色，其中基色与混合色的数值大于255，系统就默认为最大值也就是255。由公式可以分析出混合色为黑色结果色就等于基色，混合色为白色结果色就为白色。基色也一样。我们颠倒混合色及基色的位置，结果色也不会变化。（位置互换不发生变化）

void layerblend_color_linear_light(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++){
                 d3[cw + c] = saturate_cast<uchar>(d1[cw + c] + d2[cw + c]);
            }
        }
    }
}

浅色模式

        浅色模式比较好理解：它是通过计算混合色与基色所有通道的数值总和，哪个数值大就选为结果色。因此结果色只能在混合色与基色中选择，不会产生第三种颜色。与深色模式刚好相反。

叠加模式(overlay)

        叠加模式比较特别，它是通过分析基色个通道的数值，对颜色进行正片叠加或滤色混合，结果色保留基色的明暗对比，因此结果色以基色为主导。
计算公式：
基色 < = 128：结果色 = 混合色 * 基色 / 128；基色 > 128：结果色 = 255 - （255 - 混合色）* (255 - 基色) / 128。

void layerblend_overlay(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++){
                 int res = 0;
                 res = ((d1[cw + c]  <= 128) ? (1.0f * d2[cw + c] * d1[cw + c]  / 128):(255 - (255.0f - d2[cw + c]) * (255.0f - d1[cw + c]) / 128));
                 d3[cw + c] = saturate_cast<uchar>(res);
            }
        }
    }
}

柔光模式(soft light)

        柔光模式是较为常用的模式，它是根据混合色的通道数值选择不同的公式计算混合色。数值大于128的时候，结果色就比基色稍亮；数值小于或等于128，结果色就比基色稍暗。柔光模式是以基色为主导，混合色只相应改变局部明暗。其中混合色为黑色，结果色不会为黑色，只比结果色稍暗，混合色为中性色，结果色跟基色一样。
计算公式：
混合色 <=128：结果色 = 基色 + (2 * 混合色 - 255) * (基色 - 基色 * 基色 / 255) / 255；
混合色 >128： 结果色 = 基色 + (2 * 混合色 - 255) * (Sqrt(基色/255)*255 - 基色)/255。

如果基色=混合色，则可优化为256的表smoothlight,公式变形如下：

res = x + (2x-255)*(x-x*x/255)/255;

res = x+(2x-255)*(255*sqrt(x/255)-x)/255;

void layerblend_soft_light(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++){
                int res = 0,temp1,temp2;
                temp1 = ((int)((float)d1[cw + c]+((float)d2[cw + c]+(float)d2[cw + c]-255.0f)*((sqrt((float)d1[cw + c]/255.0f))*255.0f-(float)d1[cw + c])/255.0f));
                temp2 = ((int)((float)d1[cw + c]+((float)d2[cw + c]+(float)d2[cw + c]-255.0f)*((float)d1[cw + c]-(float)d1[cw + c]*(float)d1[cw + c]/255.0f)/255.0f));
                res = d2[cw + c] > 128 ? temp1 : temp2;
                d3[cw + c] = saturate_cast<uchar>(res);
            }
        }
    }
}

强光模式(strong light)

        强光模式跟叠加模式十分类似，只是在计算的时候需要通过混合色来控制，混合色的数值小于或等于128的时候，颜色会变暗；混合色的数值大于128的时候，颜色会变亮。混合色为白色，结果色就为白色；混合色为黑色，结果为黑色。混合色起到主导作用。
计算公式：
混合色 <= 128：结果色 = 混合色 * 基色 / 128；
混合色 > 128 ：结果色 = 255 - （255 - 混合色） * (255 - 基色) / 128.

void layerblend_strong_light(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++){
                int res = 0;

                res = d2[cw + c] <= 128.0f ? ((float)d2[cw + c] * d1[cw + c] / 128.0f):(255.0f - (255.0f - d2[cw + c]) * (255.0f - d1[cw + c]) / 128.0f);

                d3[cw + c] = saturate_cast<uchar>(res);
            }
        }
    }
}

亮光模式(hight light)

        亮光模式是通过增加或减少对比度是颜色变暗或变亮，具体取决于混合色的数值。混合色比中性灰色暗，结果色就相应的变暗，混合色比中性灰色亮，结果色就相应的变亮。有点类似颜色加深或颜色减淡。
计算公式：

A---基色；B—混合色

C=A-(255-A)*(255-2B)/2B 当混合色>128时 

C=A+[A*(2B-255)]/[255-(2B-255)

void layerblend_hight_light(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++){
                int res = 0;

                if (d2[cw + c] <= 128)
                    res = d2[cw + c] == 0 ? d1[cw + c] : (d1[cw + c] - (255.0f - d1[cw + c])*(255.0f -2.0f * d2[cw + c]) / (2.0f * d2[cw + c]));
                else
                    res = d2[cw + c] == 255 ? d1[cw + c] : d1[cw + c]+ (d1[cw + c]*(2.0f * d2[cw + c]-255.0f))/(255.0f - (2.0f * d2[cw + c] - 255.0f));

                d3[cw + c] = saturate_cast<uchar>(res);
            }
        }
    }
}

线性光(linear light)

        线性光：通过减少或增加亮度，来使颜色加深或减淡。具体取决于混合色的数值。混合色数值比中性灰色暗的时候进行相应的加深混合；混合色的数值比中性灰色亮的时候进行减淡混合。这里的加深及减淡时线性加深或线性减淡。
计算公式：结果色 = 2 * 混合色 + 基色 -255。数值大于255取255。

void layerblend_linear_light(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++){
                int res = 2 * d2[cw + c] + d1[cw + c] - 255;
                d3[cw + c] = saturate_cast<uchar>(res);
            }
        }
    }
}

点光(point light)

        点光模式：它会根据混合色的颜色数值替换相应的颜色。如果混合色数值小于中性灰色，那么就替换比混合色亮的像素；相反混合色的数值大于中性灰色，则替换比混合色暗的像素，因此混合出来的颜色对比较大。
计算公式：
基色 < 2 * 混合色 - 255：结果色 = 2 * 混合色 - 255；
2 * 混合色 - 255 < 基色 < 2 * 混合色 ：结果色 = 基色；
基色 > 2 * 混合色：结果色 = 2 * 混合色。

视图猿人
关注
专栏目录
Python 图层混合算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-06 371
常见的图层混合算法有透明度混合、正片叠底混合、叠加混合等。正片叠底混合（Multiply Blending）：正片叠底混合算法通过将每个像素的颜色值分别与对应位置的图层颜色值进行乘法混合来实现。正片叠底混合（Multiply Blending）：正片叠底混合算法通过将每个像素的颜色值分别与对应位置的图层颜色值进行乘法混合来实现。正片叠底混合（Multiply Blending）：正片叠底混合算法通过将每个像素的颜色值分别与对应位置的图层颜色值进行乘法混合来实现。
Python实现图层混合算法
ByteHackerX的博客
09-06 154
然后，根据混合模式选择不同的图层混合算法。最后，我们将混合后的像素值限制在0到255之间，并将其转换为8位无符号整数类型。图层混合是图像处理中常用的技术，用于将多个图层的像素值进行混合，以创建出不同效果的图像。在本文中，我们将使用Python实现一个简单的图层混合算法。通过使用不同的图层混合模式，你可以创建出各种有趣的图像效果。接下来，我们将定义一个函数来实现图层混合算法，该函数将接受两个输入图像和一个混合模式作为参数，并返回混合后的图像。你可以根据需要尝试不同的混合模式，例如乘法或屏幕等。
图层混合算法(一)
最新发布
hulinhulin的专栏
09-24 168
图像的图层混合模式--结果变暗
OpenCV——PS 图层混合算法（一）
weixin_30273763的博客
07-11 452
具体的算法原理可以参考 PS图层混合算法之一（不透明度，正片叠底，颜色加深，颜色减淡） // PS_Algorithm.h #ifndef PS_ALGORITHM_H_INCLUDED #define PS_ALGORITHM_H_INCLUDED #include <iostream> #include <string> #incl...
Photoshop图层混合算法
studyeboy的专栏
01-22 1756
Photoshop中图层面板右上角的混合模式，及分类。 基色：图像中原稿颜色，对应Photoshop中 当前图层下方的颜色。文中用A表示。 混合色：通过绘图或编辑工具应用的颜色，对应Photoshop中当前图层的颜色。文中用B表示，文中混合色值均为（128，128, 128）。 结果色：混合后得到的颜色，对应Photoshop中使用模式之后出现的混合图层的颜色。文中用C表示。 图层的透明度： 蒙版图层中给定位置图层的亮度（d=颜色值/255），文中用d表示。 基础模式 利用图层的不透明度及图像填充值来
photoshop图层混合模式详解及算法实现详解
05-01
图示讲解photoshop图层混合模式详解及算法实现详解 变暗混合模式 正片叠底 线型加深混合模式 线型减淡混合模式 差值混合模式 图层混合选项
Photoshop图层混合(Layer Blending)模式的算法实现
zylxadz的专栏
08-20 2251
转自：http://avnpc.com/pages/photoshop-layer-blending-algorithm Photoshop的图层混合(Layer Blending)是实现各种特效的基础之一，在Photoshop新版中已经提供了接近30种图层混合模式，而运用这些图层混合模式则可以将两个图层叠加并且通过一些算法使叠加后的图层呈现新的效果，比如可以通过“变暗”、“正片叠底”使底层
PS算法-图层混合.zip_图层_图层混合_图层的
09-24
通过编程，我们可以模拟PS的图层混合算法，理解其背后的数学原理，例如色彩空间的转换、像素级别的操作以及混合模式的计算方法。这不仅有助于扩展VS的图像处理能力，也为开发者提供了更深层次的定制可能性。 对于...
Python:实现图层混合算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-01 294
Python:实现图层混合算法(附完整源码)
Photoshop图层混合模式的计算公式
痞子龙3D编程
11-30 3810
Photoshop中，图层混合模式和图层不透明度都是被广泛应用的功能之一。这篇PS教程提供了各种图层混合模式以及图层不透明度的数学计算公式，了解这些公式，可以更好的掌握这些功能。   文章来源于网络，向作者致敬。     注释： 1.混合模式的数学计算公式，另外还介绍了不透明度。 2.这些公式仅适用于RGB图像，对于Lab颜色图像而
PS图层混合算法之三（滤色， 叠加， 柔光， 强光）
weixin_30273931的博客
04-03 956
滤色模式： 作用结果和正片叠底刚好相反，它是将两个颜色的互补色的像素值相乘，然后除以255得到的最终色的像素值。通常执行滤色模式后的颜色都较浅。任何颜色和黑色执行滤色，原色不受影响;任何颜色和白色执行滤色得到的是白色；而与其他颜色执行滤色会产生漂白的效果。 Screen 滤色 C=1-(1-A)*(1-B)也可以写成 1-C=(1-A)*(1-B) 该模式和上...
图像算法 -- 最全混合图层算法(附源码)
热门推荐
bravebean的博客
05-13 1万+
最全图层混合算法，附带源码和demo，希望大家喜欢。
PS图层混合算法之六（差值，溶解， 排除）
weixin_30414245的博客
04-09 345
差值模式： 查看每个通道中的颜色信息，比较底色和绘图色，用较亮的像素点的像素值减去较暗的像素点的像素值。与白色混合将使底色反相；与黑色混合则不产生变化。 排除模式可生成和差值模式相似的效果，但比差值模式生成的颜色对比度较小，因而颜色较柔和。与白色混合将使底色反相；与黑色混合则不产生变化。 Difference 差值 C=|A-B| 上下层色调的绝对值。该模式...
PS图层混合算法之二（线性加深，线性减淡，变亮，变暗）
weixin_30616969的博客
03-30 603
线性加深模式： 查看每个通道的颜色信息，通过降低“亮度”使底色的颜色变暗来反映绘图色，和白色混合没变化。 Linear Burn 线形加深 C=A+B-1 如果上下层的像素值之和小于255，输出结果将会是纯黑色。如果将上层反相，结果将是纯粹的数学减。 线性减淡模式： 查看每个通道的颜色信息，通过增加“亮度”使底色的颜色变亮来反映绘图色，和黑色混合没变化。 Li...
Python: PS 图层混合算法汇总
weixin_30670151的博客
05-24 663
本文用 Python 实现了PS 中的图层混合算法，把很多常见的图层混合算法都汇总到了一起，比起以前写的算法，就是用矩阵运算代替了很耗时的for 循环，运行效率有所提升。具体的代码如下： import matplotlib.pyplot as plt from skimage import io import math import numpy as np ...
PS|基础原理之‘图层混合模式’
算法与编程之美
05-01 2631
欢迎点击「算法与编程之美」↑关注我们！本文首发于微信公众号："算法与编程之美"，欢迎关注，及时了解更多此系列文章。欢迎加入团队圈子！与作者面对面！直接点击！说到PS，就免...
PS图层混合技术在vs中的实现与分析
6. 对比差异：由于Photoshop是图像处理领域的专业软件，资源描述中提到对比两者差异，可能意味着开发者需要分析Photoshop的图层混合算法和VS实现的算法在性能、效果以及用户体验上的不同，并提供详细的对比报告。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

视图猿人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值