图层混合算法(二)

最新推荐文章于 2024-04-23 14:26:21 发布
最新推荐文章于 2024-04-23 14:26:21 发布
阅读量102 收藏
点赞数
分类专栏： 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 * 混合色。

视图猿人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python:实现图层混合算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-01 258
Python:实现图层混合算法(附完整源码)
视频质量评价 BRISQUE算法详细介绍
小金牛来了
04-21 60
视频质量评价 BRISQUE算法详细介绍
Photoshop图层混合算法
studyeboy的专栏
01-22 1452
Photoshop中图层面板右上角的混合模式，及分类。 基色：图像中原稿颜色，对应Photoshop中 当前图层下方的颜色。文中用A表示。 混合色：通过绘图或编辑工具应用的颜色，对应Photoshop中当前图层的颜色。文中用B表示，文中混合色值均为（128，128, 128）。 结果色：混合后得到的颜色，对应Photoshop中使用模式之后出现的混合图层的颜色。文中用C表示。 图层的透明度： 蒙版图层中给定位置图层的亮度（d=颜色值/255），文中用d表示。 基础模式 利用图层的不透明度及图像填充值来
Python: PS 图层混合算法汇总
Matrix-11
05-24 8092
本文用 Python 实现了PS 中的图层混合算法，把很多常见的图层混合算法都汇总到了一起，比起以前写的算法，就是用矩阵运算代替了很耗时的for 循环，运行效率有所提升。具体的代码如下： import matplotlib.pyplot as plt from skimage import io import math import numpy as np # image fusion fi
OpenCV——PS 图层混合算法（一）
Matrix-11
07-11 6245
定义  #ifndef PS_ALGORITHM_H_INCLUDED #define PS_ALGORITHM_H_INCLUDED #include #include #include #include "Public_Function.h" #include "cv.h" #include "highgui.h" #include "cxmat.hpp" #incl
alpha blend图层混合算法
Ruilin
11-06 3091
想象一下，多个半透明的图层叠在一起，我们从上往下能够透过半透明看到下面的多个图层的图像，并且下面图层的清晰度的随着上面图层的透明度降低而减少的。如果我们把这多个图层合并为一个图层，这个图层的图像就应该是我们从上往下看这多个图层叠在一起是一样的。 实现将带alpha通道的多个图层合并生成新的图像的原理：仅从两层来看，其关键因素在于上面图层的alpha值，下面图层的alpha值是由1-上面图层的alpha值决定的。
PS算法-图层混合.zip_图层_图层混合_图层的
09-24
利用vs软件，实现ps图层混合的功能，对比两者的差异
photoshop图层混合模式详解及算法实现详解
05-01
图示讲解photoshop图层混合模式详解及算法实现详解 变暗混合模式 正片叠底 线型加深混合模式 线型减淡混合模式 差值混合模式 图层混合选项
基本函数处理库，包含photoshop所有图层混合处理算法，以及常用图像处理函数库
09-27
zphotoengine是一个基本的PC版图像处理dll库，里面包含了动态库和静态库供大家调用。 调用库包含了PS所有图层混合处理算法，以及常用图像处理函数库。
Opencv实现图层混合 油画 素描效果
10-04
里面有十几种图层混合的计算方法，油画是我自己按照别人的算法写的，很繁杂也很慢，不过还是可以借鉴下的
详解图层混合模式计算公式
05-16
详解图层混合模式计算公式 photoshop 混合特效内部算法
Leetcode 41. 缺失的第一个正数和Leetcode 155. 最小栈
2301_79614379的博客
04-20 1071
定义一个结构体，数组 data 用于存放推进的数据，数组 min 用于存放最小值，变量 top 存放最后进入的数在 data 的下标，变量 mintop 记录最小值在 min 中的下标。循环遍历数组 nums ，如果该位置的值大于 0 并且不小于数组长度，让哈希表 table 在该值的位置自加。获取堆栈中的最小元素时，根据 mintop 的值返回数组 miin 中的元素。返回栈顶元素时，根据 top 的值返回数组 data 中的元素。--> 返回 -3.输入：nums = [3,4,-1,1]
力扣---从中序与后序遍历序列构造二叉树
m0_71536793的博客
04-20 458
力扣 中序遍历 后序遍历 建树
算法刷题-16
qq_45773834的博客
04-21 670
学习来源： leetcode，牛客 https://programmercarl.com https://www.yuque.com/taxing-qarr6/hxitgt/dedugmp09knerdi1
力扣HOT100 - 543. 二叉树的直径
最新发布
qq_61504864的博客
04-23 161
【代码】力扣HOT100 - 543. 二叉树的直径。
【算法学习】线段树基础版
weixin_55939638的博客
04-23 485
根结点维护的是区间1 到 4，结点权值是该区间的和，再将区间一份为二，其左儿子维护的是 1 - 2，右儿子维护的是 3 - 4 ，以此类推，直到结点维护的区间长度为1。线段树可以理解为一个二叉树，如果是利用线段树求区间的和，那么每个结点的权值维护的是结点所维护区间的和，再将该区间一分为二，分别交由左右儿子维护。从根节点开始，目标区间和左子树有交集，递归左子树，目标区间和右子树有交集 ，递归右子树；从根节点开始，目标区间和左子树有交集，递归左子树，目标区间和右子树有交集 ，递归右子树；
c语言-快速排序
ls3614140的博客
04-19 461
【代码】c语言-快速排序。
【Leetcode每日一题】 分治 - 数组中的第K个最大元素（难度⭐⭐）（63）
m0_73150338的博客
04-23 435
分治 - 数组中的第K个最大元素
代码随想录算法训练营DAY32|C++贪心算法Part.2|122.买卖股票的最佳时机II、55.跳跃游戏、45.跳跃游戏II
糖炒栗子
04-23 933
从上文可以看出，我们要比较当前范围下能扩充的最终范围。
psode混合算法代码
12-04
PSO算法的混合算法版本可以具体根据问题的特点进行定制，例如引入局部搜索算法、变异操作等。在代码实现中，可以根据问题的具体要求选择适当的方式进行修改和扩展。 总之，通过不断迭代更新粒子的位置和速度，PSO...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

视图猿人

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

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

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

打赏作者

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

抵扣说明：

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

余额充值