OpenCV-实现背景分离(可用于更改证件照底色)

作者:翟天保Steven
版权声明:著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处

实现原理

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

  1. 背景和前景的分割。针对该难点,通过人机交互等方法获取背景色作为参考值,结合差值均方根设定合理阈值,实现前景的提取,PS上称为蒙版;提取过程中,可能会遇到前景像素丢失的情况,对此可通过开闭运算或者提取外部轮廓线的方式,将前景内部填充完毕。
  2. 前景边缘轮廓区域的融合。如果不能很好地融合,就能看出明显的抠图痕迹,所以融合是很关键的一步。首先,对蒙版区(掩膜)进行均值滤波,其边缘区会生成介于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<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++测试代码

#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项,其说明如下:

  1. thresh为背景识别阈值,该值范围为5-100,用来区分背景区和前景区,合理设置,不然可能出现前景区大片面积丢失的情况。
  2. p为背景色采样点,可通过人机交互的方式人为选中背景区颜色,默认为图像原点的颜色。
  3. color为重绘背景色。
  4. transparency为重绘背景色的透明度,255为实色,0为全透明。
  5. 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。

(该函数介绍见:OpenCV-清除小面积连通域_翟天保的博客-CSDN博客

图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 <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 原图与透明底对比图

       如果函数有什么可以改进完善的地方,非常欢迎大家指出,一同进步何乐而不为呢~

       如果文章帮助到你了,可以点个赞让我知道,我会很快乐~加油!

© 版权声明
THE END
喜欢就支持一下吧
点赞86 分享
评论 抢沙发
头像
欢迎您留下宝贵的见解!
提交
头像

昵称

取消
昵称表情代码图片

    暂无评论内容