导航：首页 > 开发技术 >

OpenCV如何实现背景分离

发表于：2025-01-16 作者：千家信息网编辑

千家信息网最后更新 2025年01月16日，这篇文章主要为大家展示了"OpenCV如何实现背景分离"，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下"OpenCV如何实现背景分离"这篇文章吧。实现原理图像

千家信息网最后更新 2025年01月16日OpenCV如何实现背景分离

这篇文章主要为大家展示了"OpenCV如何实现背景分离"，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下"OpenCV如何实现背景分离"这篇文章吧。

实现原理

图像背景分离是常见的图像处理方法之一，属于图像分割范畴。如何较优地提取背景区域，难点在于两个：

背景和前景的分割。针对该难点，通过人机交互等方法获取背景色作为参考值，结合差值均方根设定合理阈值，实现前景的提取，PS上称为蒙版；提取过程中，可能会遇到前景像素丢失的情况，对此可通过开闭运算或者提取外部轮廓线的方式，将前景内部填充完毕。
前景边缘轮廓区域的融合。如果不能很好地融合，就能看出明显的抠图痕迹，所以融合是很关键的一步。首先，对蒙版区（掩膜）进行均值滤波，其边缘区会生成介于0-255之间的缓存区；其次，通过比例分配的方式对缓存区的像素点上色，我固定的比例为前景0.3背景0.7，因为背景为单色区，背景比例高，可以使得缓存区颜色倾向于背景区，且实现较好地过渡；最后，蒙版为0的区域上背景色，蒙版为255的区域不变。

至此，图像实现了分割，完成背景分离。C++实现代码如下。

功能函数代码

// 背景分离cv::Mat BackgroundSeparation(cv::Mat src, Inputparama input){        cv::Mat bgra, mask;        // 转化为BGRA格式，带透明度，4通道        cvtColor(src, bgra, COLOR_BGR2BGRA);        mask = cv::Mat::zeros(bgra.size(), CV_8UC1);        int row = src.rows;        int col = src.cols;         // 异常数值修正        input.p.x = max(0, min(col, input.p.x));        input.p.y = max(0, min(row, input.p.y));        input.thresh = max(5, min(100, input.thresh));        input.transparency = max(0, min(255, input.transparency));        input.size = max(0, min(30, input.size));         // 确定背景色        uchar ref_b = src.at(input.p.y, input.p.x)[0];        uchar ref_g = src.at(input.p.y, input.p.x)[1];        uchar ref_r = src.at(input.p.y, input.p.x)[2];         // 计算蒙版区域（掩膜）        for (int i = 0; i < row; ++i)        {                uchar *m = mask.ptr(i);                uchar *b = src.ptr(i);                for (int j = 0; j < col; ++j)                {                        if ((geiDiff(b[3*j],b[3*j+1],b[3*j+2],ref_b,ref_g,ref_r)) >input.thresh)                        {                                m[j] = 255;                        }                }        }         // 寻找轮廓，作用是填充轮廓内黑洞        vector> contour;        vector hierarchy;        // RETR_TREE以网状结构提取所有轮廓，CHAIN_APPROX_NONE获取轮廓的每个像素        findContours(mask, contour, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_NONE);        drawContours(mask, contour, -1, Scalar(255), FILLED,4);         // 闭运算        cv::Mat element = getStructuringElement(MORPH_ELLIPSE, Size(5, 5));        cv::morphologyEx(mask, mask, MORPH_CLOSE, element);         // 掩膜滤波，是为了边缘虚化        cv::blur(mask, mask, Size(2 * input.size+1, 2 * input.size + 1));         // 改色        for (int i = 0; i < row; ++i)        {                uchar *r = bgra.ptr(i);                uchar *m = mask.ptr(i);                for (int j = 0; j < col; ++j)                {                        // 蒙版为0的区域就是标准背景区                        if (m[j] == 0)                        {                                r[4 * j] = uchar(input.color[0]);                                r[4 * j + 1] = uchar(input.color[1]);                                r[4 * j + 2] = uchar(input.color[2]);                                r[4 * j + 3] = uchar(input.transparency);                        }                        // 不为0且不为255的区域是轮廓区域（边缘区），需要虚化处理                        else if (m[j] != 255)                        {                                // 边缘处按比例上色                                int newb = (r[4 * j] * m[j] * 0.3 + input.color[0] * (255 - m[j])*0.7) / ((255 - m[j])*0.7+ m[j] * 0.3);                                int newg = (r[4 * j+1] * m[j] * 0.3 + input.color[1] * (255 - m[j])*0.7) / ((255 - m[j])*0.7 + m[j] * 0.3);                                int newr = (r[4 * j + 2] * m[j] * 0.3 + input.color[2] * (255 - m[j])*0.7) / ((255 - m[j])*0.7 + m[j] * 0.3);                                int newt = (r[4 * j + 3] * m[j] * 0.3 + input.transparency * (255 - m[j])*0.7) / ((255 - m[j])*0.7 + m[j] * 0.3);                                newb = max(0, min(255, newb));                                newg = max(0, min(255, newg));                                newr = max(0, min(255, newr));                                newt = max(0, min(255, newt));                                r[4 * j] = newb;                                r[4 * j + 1] = newg;                                r[4 * j + 2] = newr;                                r[4 * j + 3] = newt;                        }                }        }        return bgra;}

C++测试代码

#include #include #include #include using namespace cv;using namespace std; // 输入参数struct Inputparama {        int thresh = 30;                               // 背景识别阈值，该值越小，则识别非背景区面积越大，需有合适范围，目前为5-60        int transparency = 255;                        // 背景替换色透明度，255为实，0为透明        int size = 7;                                  // 非背景区边缘虚化参数，该值越大，则边缘虚化程度越明显        cv::Point p = cv::Point(0, 0);                 // 背景色采样点，可通过人机交互获取，也可用默认(0,0)点颜色作为背景色        cv::Scalar color = cv::Scalar(255, 255, 255);  // 背景色}; cv::Mat BackgroundSeparation(cv::Mat src, Inputparama input); // 计算差值均方根int geiDiff(uchar b,uchar g,uchar r,uchar tb,uchar tg,uchar tr){               return  int(sqrt(((b - tb)*(b - tb) + (g - tg)*(g - tg) + (r - tr)*(r - tr))/3));} int main(){        cv::Mat src = imread("111.jpg");        Inputparama input;        input.thresh = 100;        input.transparency = 255;        input.size = 6;        input.color = cv::Scalar(0, 0, 255);         clock_t s, e;        s = clock();        cv::Mat result = BackgroundSeparation(src, input);        e = clock();        double dif = e - s;        cout << "time:" << dif << endl;         imshow("original", src);        imshow("result", result);        imwrite("result1.png", result);        waitKey(0);        return 0;} // 背景分离cv::Mat BackgroundSeparation(cv::Mat src, Inputparama input){        cv::Mat bgra, mask;        // 转化为BGRA格式，带透明度，4通道        cvtColor(src, bgra, COLOR_BGR2BGRA);        mask = cv::Mat::zeros(bgra.size(), CV_8UC1);        int row = src.rows;        int col = src.cols;         // 异常数值修正        input.p.x = max(0, min(col, input.p.x));        input.p.y = max(0, min(row, input.p.y));        input.thresh = max(5, min(100, input.thresh));        input.transparency = max(0, min(255, input.transparency));        input.size = max(0, min(30, input.size));         // 确定背景色        uchar ref_b = src.at(input.p.y, input.p.x)[0];        uchar ref_g = src.at(input.p.y, input.p.x)[1];        uchar ref_r = src.at(input.p.y, input.p.x)[2];         // 计算蒙版区域（掩膜）        for (int i = 0; i < row; ++i)        {                uchar *m = mask.ptr(i);                uchar *b = src.ptr(i);                for (int j = 0; j < col; ++j)                {                        if ((geiDiff(b[3*j],b[3*j+1],b[3*j+2],ref_b,ref_g,ref_r)) >input.thresh)                        {                                m[j] = 255;                        }                }        }         // 寻找轮廓，作用是填充轮廓内黑洞        vector> contour;        vector hierarchy;        // RETR_TREE以网状结构提取所有轮廓，CHAIN_APPROX_NONE获取轮廓的每个像素        findContours(mask, contour, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_NONE);        drawContours(mask, contour, -1, Scalar(255), FILLED,4);         // 闭运算        cv::Mat element = getStructuringElement(MORPH_ELLIPSE, Size(5, 5));        cv::morphologyEx(mask, mask, MORPH_CLOSE, element);         // 掩膜滤波，是为了边缘虚化        cv::blur(mask, mask, Size(2 * input.size+1, 2 * input.size + 1));         // 改色        for (int i = 0; i < row; ++i)        {                uchar *r = bgra.ptr(i);                uchar *m = mask.ptr(i);                for (int j = 0; j < col; ++j)                {                        // 蒙版为0的区域就是标准背景区                        if (m[j] == 0)                        {                                r[4 * j] = uchar(input.color[0]);                                r[4 * j + 1] = uchar(input.color[1]);                                r[4 * j + 2] = uchar(input.color[2]);                                r[4 * j + 3] = uchar(input.transparency);                        }                        // 不为0且不为255的区域是轮廓区域（边缘区），需要虚化处理                        else if (m[j] != 255)                        {                                // 边缘处按比例上色                                int newb = (r[4 * j] * m[j] * 0.3 + input.color[0] * (255 - m[j])*0.7) / ((255 - m[j])*0.7+ m[j] * 0.3);                                int newg = (r[4 * j+1] * m[j] * 0.3 + input.color[1] * (255 - m[j])*0.7) / ((255 - m[j])*0.7 + m[j] * 0.3);                                int newr = (r[4 * j + 2] * m[j] * 0.3 + input.color[2] * (255 - m[j])*0.7) / ((255 - m[j])*0.7 + m[j] * 0.3);                                int newt = (r[4 * j + 3] * m[j] * 0.3 + input.transparency * (255 - m[j])*0.7) / ((255 - m[j])*0.7 + m[j] * 0.3);                                newb = max(0, min(255, newb));                                newg = max(0, min(255, newg));                                newr = max(0, min(255, newr));                                newt = max(0, min(255, newt));                                r[4 * j] = newb;                                r[4 * j + 1] = newg;                                r[4 * j + 2] = newr;                                r[4 * j + 3] = newt;                        }                }        }        return bgra;}

测试效果

图1 原图和红底色效果图对比

图2 原图和蓝底色效果图对比

图3 原图和透明底色效果图对比

如源码所示，函数输入参数共有5项，其说明如下：

thresh为背景识别阈值，该值范围为5-100，用来区分背景区和前景区，合理设置，不然可能出现前景区大片面积丢失的情况。
p为背景色采样点，可通过人机交互的方式人为选中背景区颜色，默认为图像原点的颜色。
color为重绘背景色。
transparency为重绘背景色的透明度，255为实色，0为全透明。
size为边缘虚化参数，控制均值滤波的窗口尺寸，范围为0-30。

我对比了百度搜索证件照一键改色网站的效果，基本一致，它们处理一次4块钱，我们这是免费的，授人以鱼不如授人以渔对吧，学到就是赚到。当然人家的功能肯定更强大，估计集成了深度学习一类的框架，我们还需要调参。美中不足的地方就由兄弟们一起改进了。

细心的biliy发现了我贴图的问题，如图1图2图3所示，领口处被当做背景色了，这样当然不行，接下来开始改进功能。

1）首先分析原因，之所以领口被当做背景色，是因为领口为白色，同背景色一致，且连接图像边缘处，进行轮廓分析时，错将这个领口识别为轮廓外，如图4所示。

图4 识别失败

2）正如图4所示，仅仅用闭运算是无法有效补偿的，如果将窗口尺寸加大还可能使其他位置过度填充，接下来考虑如何只填充这类大洞。先将处理图像的宽高各扩展50个pixel，这样做的好处是令轮廓的识别更精准和清晰，并且避免了头顶处因贴近图像边缘，而导致的过度膨胀现象。

cv::Mat tmask = cv::Mat::zeros(row + 50, col + 50, CV_8UC1);mask.copyTo(tmask(cv::Range(25, 25 + mask.rows), cv::Range(25, 25 + mask.cols)));

3）之后进行黑帽运算，即闭运算减原图，得到图5。

图5 黑帽运算

4）用Clear_MicroConnected_Area函数清除小面积连通区，得到图6。

（该函数介绍见：https://www.yisu.com/article/221904.htm）

图6 清除小面积连通区

5）黑帽运算结果加至原轮廓图，并截取实际图像尺寸。

// 黑帽运算获取同背景色类似的区域，识别后填充cv::Mat hat;cv::Mat element = getStructuringElement(MORPH_ELLIPSE, Size(31, 31));cv::morphologyEx(tmask, hat, MORPH_BLACKHAT, element);hat.setTo(255, hat > 0);cv::Mat hatd;// 清除小面积区域Clear_MicroConnected_Areas(hat, hatd, 450);tmask = tmask + hatd;// 截取实际尺寸mask = tmask(cv::Range(25, 25 + mask.rows), cv::Range(25, 25 + mask.cols)).clone();

6）至此，就得到完整的轮廓了，如图7所示，完整代码见后方。

图7 完整轮廓图

完整改进代码

#include #include #include #include using namespace cv;using namespace std; // 输入参数struct Inputparama {        int thresh = 30;                               // 背景识别阈值，该值越小，则识别非背景区面积越大，需有合适范围，目前为5-60        int transparency = 255;                        // 背景替换色透明度，255为实，0为透明        int size = 7;                                  // 非背景区边缘虚化参数，该值越大，则边缘虚化程度越明显        cv::Point p = cv::Point(0, 0);                 // 背景色采样点，可通过人机交互获取，也可用默认(0,0)点颜色作为背景色        cv::Scalar color = cv::Scalar(255, 255, 255);  // 背景色}; cv::Mat BackgroundSeparation(cv::Mat src, Inputparama input);void Clear_MicroConnected_Areas(cv::Mat src, cv::Mat &dst, double min_area); // 计算差值均方根int geiDiff(uchar b,uchar g,uchar r,uchar tb,uchar tg,uchar tr){               return  int(sqrt(((b - tb)*(b - tb) + (g - tg)*(g - tg) + (r - tr)*(r - tr))/3));} int main(){        cv::Mat src = imread("111.jpg");        Inputparama input;        input.thresh = 100;        input.transparency = 255;        input.size = 6;        input.color = cv::Scalar(0, 0, 255);         clock_t s, e;        s = clock();        cv::Mat result = BackgroundSeparation(src, input);        e = clock();        double dif = e - s;        cout << "time:" << dif << endl;         imshow("original", src);        imshow("result", result);        imwrite("result1.png", result);        waitKey(0);        return 0;} // 背景分离cv::Mat BackgroundSeparation(cv::Mat src, Inputparama input){        cv::Mat bgra, mask;        // 转化为BGRA格式，带透明度，4通道        cvtColor(src, bgra, COLOR_BGR2BGRA);        mask = cv::Mat::zeros(bgra.size(), CV_8UC1);        int row = src.rows;        int col = src.cols;         // 异常数值修正        input.p.x = max(0, min(col, input.p.x));        input.p.y = max(0, min(row, input.p.y));        input.thresh = max(5, min(200, input.thresh));        input.transparency = max(0, min(255, input.transparency));        input.size = max(0, min(30, input.size));         // 确定背景色        uchar ref_b = src.at(input.p.y, input.p.x)[0];        uchar ref_g = src.at(input.p.y, input.p.x)[1];        uchar ref_r = src.at(input.p.y, input.p.x)[2];         // 计算蒙版区域（掩膜）        for (int i = 0; i < row; ++i)        {                uchar *m = mask.ptr(i);                uchar *b = src.ptr(i);                for (int j = 0; j < col; ++j)                {                        if ((geiDiff(b[3*j],b[3*j+1],b[3*j+2],ref_b,ref_g,ref_r)) >input.thresh)                        {                                m[j] = 255;                        }                }        }         cv::Mat tmask = cv::Mat::zeros(row + 50, col + 50, CV_8UC1);        mask.copyTo(tmask(cv::Range(25, 25 + mask.rows), cv::Range(25, 25 + mask.cols)));         // 寻找轮廓，作用是填充轮廓内黑洞        vector> contour;        vector hierarchy;        // RETR_TREE以网状结构提取所有轮廓，CHAIN_APPROX_NONE获取轮廓的每个像素        findContours(tmask, contour, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_NONE);        drawContours(tmask, contour, -1, Scalar(255), FILLED,16);         // 黑帽运算获取同背景色类似的区域，识别后填充        cv::Mat hat;        cv::Mat element = getStructuringElement(MORPH_ELLIPSE, Size(31, 31));        cv::morphologyEx(tmask, hat, MORPH_BLACKHAT, element);        hat.setTo(255, hat > 0);        cv::Mat hatd;        Clear_MicroConnected_Areas(hat, hatd, 450);        tmask = tmask + hatd;        mask = tmask(cv::Range(25, 25 + mask.rows), cv::Range(25, 25 + mask.cols)).clone();         // 掩膜滤波，是为了边缘虚化        cv::blur(mask, mask, Size(2 * input.size+1, 2 * input.size + 1));         // 改色        for (int i = 0; i < row; ++i)        {                uchar *r = bgra.ptr(i);                uchar *m = mask.ptr(i);                for (int j = 0; j < col; ++j)                {                        // 蒙版为0的区域就是标准背景区                        if (m[j] == 0)                        {                                r[4 * j] = uchar(input.color[0]);                                r[4 * j + 1] = uchar(input.color[1]);                                r[4 * j + 2] = uchar(input.color[2]);                                r[4 * j + 3] = uchar(input.transparency);                        }                        // 不为0且不为255的区域是轮廓区域（边缘区），需要虚化处理                        else if (m[j] != 255)                        {                                // 边缘处按比例上色                                int newb = (r[4 * j] * m[j] * 0.3 + input.color[0] * (255 - m[j])*0.7) / ((255 - m[j])*0.7+ m[j] * 0.3);                                int newg = (r[4 * j+1] * m[j] * 0.3 + input.color[1] * (255 - m[j])*0.7) / ((255 - m[j])*0.7 + m[j] * 0.3);                                int newr = (r[4 * j + 2] * m[j] * 0.3 + input.color[2] * (255 - m[j])*0.7) / ((255 - m[j])*0.7 + m[j] * 0.3);                                int newt = (r[4 * j + 3] * m[j] * 0.3 + input.transparency * (255 - m[j])*0.7) / ((255 - m[j])*0.7 + m[j] * 0.3);                                newb = max(0, min(255, newb));                                newg = max(0, min(255, newg));                                newr = max(0, min(255, newr));                                newt = max(0, min(255, newt));                                r[4 * j] = newb;                                r[4 * j + 1] = newg;                                r[4 * j + 2] = newr;                                r[4 * j + 3] = newt;                        }                }        }        return bgra;} void Clear_MicroConnected_Areas(cv::Mat src, cv::Mat &dst, double min_area){        // 备份复制        dst = src.clone();        std::vector > contours;  // 创建轮廓容器        std::vector       hierarchy;         // 寻找轮廓的函数        // 第四个参数CV_RETR_EXTERNAL，表示寻找最外围轮廓        // 第五个参数CV_CHAIN_APPROX_NONE，表示保存物体边界上所有连续的轮廓点到contours向量内        cv::findContours(src, contours, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE, cv::Point());         if (!contours.empty() && !hierarchy.empty())        {                std::vector >::const_iterator itc = contours.begin();                // 遍历所有轮廓                while (itc != contours.end())                {                        // 定位当前轮廓所在位置                        cv::Rect rect = cv::boundingRect(cv::Mat(*itc));                        // contourArea函数计算连通区面积                        double area = contourArea(*itc);                        // 若面积小于设置的阈值                        if (area < min_area)                        {                                // 遍历轮廓所在位置所有像素点                                for (int i = rect.y; i < rect.y + rect.height; i++)                                {                                        uchar *output_data = dst.ptr(i);                                        for (int j = rect.x; j < rect.x + rect.width; j++)                                        {                                                // 将连通区的值置0                                                if (output_data[j] == 255)                                                {                                                        output_data[j] = 0;                                                }                                        }                                }                        }                        itc++;                }        }}