阅读 158

OpenCV实现背景分离(证件照背景替换)

本文主要介绍了OpenCV实现背景分离(证件照背景替换)，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下


目录

  • 实现原理

  • 功能函数代码

  • C++测试代码

  • 完整改进代码

本文主要介绍了OpenCV实现背景分离(证件照背景替换)，具有一定的参考价值，感兴趣的可以了解一下


实现原理

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

  • 背景和前景的分割。针对该难点，通过人机交互等方法获取背景色作为参考值，结合差值均方根设定合理阈值，实现前景的提取，PS上称为蒙版；提取过程中，可能会遇到前景像素丢失的情况，对此可通过开闭运算或者提取外部轮廓线的方式，将前景内部填充完毕。

  • 前景边缘轮廓区域的融合。如果不能很好地融合，就能看出明显的抠图痕迹，所以融合是很关键的一步。首先，对蒙版区（掩膜）进行均值滤波，其边缘区会生成介于0-255之间的缓存区；其次，通过比例分配的方式对缓存区的像素点上色，我固定的比例为前景0.3背景0.7，因为背景为单色区，背景比例高，可以使得缓存区颜色倾向于背景区，且实现较好地过渡；最后，蒙版为0的区域上背景色，蒙版为255的区域不变。

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


功能函数代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
// 背景分离
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<Vec3b>(input.p.y, input.p.x)[0];
    uchar ref_g = src.at<Vec3b>(input.p.y, input.p.x)[1];
    uchar ref_r = src.at<Vec3b>(input.p.y, input.p.x)[2];
  
    // 计算蒙版区域（掩膜）
    for (int i = 0; i < row; ++i)
    {
        uchar *m = mask.ptr<uchar>(i);
        uchar *b = src.ptr<uchar>(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<vector<Point>> contour;
    vector<Vec4i> 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<uchar>(i);
        uchar *m = mask.ptr<uchar>(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++测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include <opencv2/opencv.hpp>
#include <iostream>
#include <algorithm>
#include <time.h>
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<Vec3b>(input.p.y, input.p.x)[0];
    uchar ref_g = src.at<Vec3b>(input.p.y, input.p.x)[1];
    uchar ref_r = src.at<Vec3b>(input.p.y, input.p.x)[2];
  
    // 计算蒙版区域（掩膜）
    for (int i = 0; i < row; ++i)
    {
        uchar *m = mask.ptr<uchar>(i);
        uchar *b = src.ptr<uchar>(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<vector<Point>> contour;
    vector<Vec4i> 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<uchar>(i);
        uchar *m = mask.ptr<uchar>(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，这样做的好处是令轮廓的识别更精准和清晰，并且避免了头顶处因贴近图像边缘，而导致的过度膨胀现象。

1
2
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.jb51.net/article/221904.htm）

 

图6 清除小面积连通区

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

1
2
3
4
5
6
7
8
9
10
11
// 黑帽运算获取同背景色类似的区域，识别后填充
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 完整轮廓图


完整改进代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
#include <opencv2/opencv.hpp>
#include <iostream>
#include <algorithm>
#include <time.h>
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<Vec3b>(input.p.y, input.p.x)[0];
    uchar ref_g = src.at<Vec3b>(input.p.y, input.p.x)[1];
    uchar ref_r = src.at<Vec3b>(input.p.y, input.p.x)[2];
  
    // 计算蒙版区域（掩膜）
    for (int i = 0; i < row; ++i)
    {
        uchar *m = mask.ptr<uchar>(i);
        uchar *b = src.ptr<uchar>(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<vector<Point>> contour;
    vector<Vec4i> 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<uchar>(i);
        uchar *m = mask.ptr<uchar>(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<std::vector<cv::Point> > contours;  // 创建轮廓容器
    std::vector<cv::Vec4i>    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<std::vector<cv::Point> >::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<uchar>(i);
                    for (int j = rect.x; j < rect.x + rect.width; j++)
                    {
                        // 将连通区的值置0
                        if (output_data[j] == 255)
                        {
                            output_data[j] = 0;
                        }
                    }
                }
            }
            itc++;
        }
    }
}

改进效果

图8 原图与红底对比图



图9 原图与蓝底对比图



图10 原图与透明底对比图

到此这篇关于OpenCV实现背景分离(证件照背景替换)的文章就介绍到这了


服务器评测 http://www.cncsto.com/ 

服务器测评 http://www.cncsto.com/ 

站长资源 https://www.cscnn.com/ 

小鱼创业 https://www.237fa.com/ 


文章分类
后端
文章标签
背景
opencv
证件
版权声明：本站是系统测试站点，无实际运营。本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 XXXXXXo@163.com 举报，一经查实，本站将立刻删除。
相关推荐