计算机视觉 || 图像分割进行A4纸矫正

最新推荐文章于 2023-12-30 02:22:12 发布
最新推荐文章于 2023-12-30 02:22:12 发布
阅读量1.1k 收藏 8
点赞数 2
分类专栏： c++ CImg 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/perry0528/article/details/85150803
版权
c++ 同时被 3 个专栏收录
39 篇文章 1 订阅
订阅专栏
CImg
17 篇文章 2 订阅
订阅专栏
计算机视觉
8 篇文章 1 订阅
订阅专栏

图像分割进行A4纸矫正

(1) 将图像从rgb空间转为灰度空间

void ImageSegmentation::rgb2gray() {
	grayImg.resize(Img._width, Img._height, 1, 1, 0);
	cimg_forXY(grayImg, x, y) {
		double R = Img(x,y,0);
		double G = Img(x,y,1);
		double B = Img(x,y,2);
		double Gray = (R * 299 + G * 587 + B * 114 + 500) / 1000;
		grayImg(x,y) = Gray;
	}
}

(2) 高斯滤波

void ImageSegmentation::Gauss_blur() {
	blurImg = grayImg.get_blur(guassian_blur);
}

(3) 求阈值

1. 迭代法求阈值
//迭代法求阈值
void ImageSegmentation::get_thres_iteration() {
	CImg<int> image = blurImg;
	CImg<int> hist = image.histogram(256, 0, 255);
	int size = blurImg.size();
	cimg_forX(hist, i) {
		threshold += i*hist(i);
	}
	threshold /= size;
	int threshold_new;
	while (true) {
		int t1 = 0, t2 = 0;
		int num1 = 0, num2 = 0;
		// 计算小于等于阈值threshold的灰度平均值t1以及大于阈值的t2
		cimg_forX(hist, i) {
			if (i <= threshold) {
				t1 += i * hist(i);
				num1 += hist(i);
			}
			else {
				t2 += i * hist(i);
				num2 += hist(i);
			}
		}
		if (num1 == 0 || num2 == 0)
			continue;
		t1 /= num1;
		t2 /= num2;
		threshold_new = (t1 + t2) / 2;
		// 若两个阈值相等，则返回阈值threshold，否则更新阈值继续循环
		if (threshold == threshold_new) break;
		else threshold = threshold_new;
	}
	cout << "threshold = " << threshold << endl;
}
2.OSTU法求阈值
//OSTU法求阈值
void ImageSegmentation::get_thres_ostu() {
	//定义类间方差
	double variance = 0.0;
	CImg<int> image = blurImg;
	CImg<int> hist = image.histogram(256, 0, 255);
	int size = blurImg.size();
	for (int i = 0; i < 256; i++) {
		//定义前景图，背景图的像素点所占比例以及平均灰度
		double p1 = 0.0, p2 = 0.0, g1 = 0.0, g2 = 0.0;
		cimg_forX(hist, j) {
			if (j <= i) {
				p1 += hist(j);
				g1 += j*hist(j);
			}
			else {
				p2 += hist(j);
				g2 += j*hist(j);
			}
		}
		if (p1 == 0 || p2 == 0)
			continue;
		g1 /= p1;
		p1 /= size;
		g2 /= p2;
		p2 /= size;
		double temp_variance = p1 * p2 * (g1 - g2) * (g1 - g2);
		if (variance < temp_variance) {
			variance = temp_variance;
			threshold = i;
		}
	}
	cout << "threshold = " << threshold << endl;
}

(4)按阈值进行图像分割

void ImageSegmentation::Segmentation() {
	segImg.resize(Img._width, Img._height, 1, 1, 0);
	cimg_forXY(blurImg, x, y) {
		if (blurImg(x,y) > threshold) {
			segImg(x,y) = 0;
		}
		else
			segImg(x,y) = 255;
	}
	//segImg.display();
}

(5) 对分割后的图像进行梯度检测

PS:如果此时直接进行矫正或者膨胀后膨胀效果不好，所以我们检测一步梯度（采用sobel算子）

void ImageSegmentation::gradDection() {
	gradImg.resize(segImg._width, segImg._height, 1, 1, 0);
	CImg_3x3(I, double);
	cimg_for3x3(segImg, x, y, 0, 0, I, double) {
		const double ix = (Inn + 2 * Icn + Ipn) - (Ipp + 2 * Icp + Inp);
		const double iy = (Inp + 2 * Inc + Inn) - (Ipp + 2 * Ipc + Ipn);
		double grad = sqrt(ix * ix + iy * iy);
		if (grad > 255) grad = 255;
		if (grad < 0 ) grad = 0;
		gradImg(x, y) = grad;
	}
	gradImg.display();
}

(6) 霍夫变换

1. 统计霍夫空间点
void ImageSegmentation::Hough_Statistics() {
	//double maxDistance = sqrt(Img._width*Img._width + Img._height*Img._height);
	double w = Img._width;
	double h = Img._height;
	double center_x = w/2;
	double center_y = h/2;
	double hough_h = ((sqrt(2.0) * (double)(h>w?h:w)) / 2.0);
	houghImg.resize(180, hough_h * 2, 1, 1, 0);
	cimg_forXY(gradImg, x, y) {
		if (gradImg(x,y) != 0) {
			cimg_forX(houghImg, angle) {
				double _angle = (double)PI*angle / 180.0f;
				int polar = (int)((((double)x - center_x)*cos(_angle) + ((double)y - center_y)*sin(_angle)) + hough_h);
				//cout << polar << endl;
				houghImg(angle, polar) += 1;
			}
		}
	}
	//houghImg.display();
}
2. 获取对应检测出的直线
void ImageSegmentation::GetLine() {
	resultImg = Img;
	//剔除掉可能出现的重合线，方法是取9x9空间内的霍夫最大值
	int hough_h = houghImg._height;
	//int hough_w = houghImg._width;
	int img_h = Img._height;
	int img_w = Img._width;
	const int y_min = 0;
	const int y_max = Img._height - 1;
	const int x_min = 0;
	const int x_max = Img._width - 1;
	cimg_forXY(houghImg, angle, polar) {
		if (houghImg(angle, polar) >= Min_thres) {
			int max = houghImg(angle, polar);
			for(int ly=-DIFF;ly<=DIFF;ly++) {
				for(int lx=-DIFF;lx<=DIFF;lx++) {
					if( (ly+polar>=0 && ly+polar<houghImg._height) && (lx+angle>=0 && lx+angle<houghImg._width) ) {
						if( (int)houghImg(angle + lx, polar + ly ) > max ) {
							max = houghImg(angle + lx, polar + ly );
							ly = lx = DIFF + 1;
						}
					}
				}
			}
			if (max > (int)houghImg(angle, polar) )
				continue;
			peaks.push_back(pair< pair<int, int>, int >(pair<int, int>(angle, polar), houghImg(angle, polar)));
		}
	}
	sort(peaks.begin(), peaks.end(), [](const pair< pair<int, int>, int > &a, const pair< pair<int, int>, int > &b) -> int {return a.second > b.second ;});
	for (int i = 0; lines.size() != 4; i++) {
		int angle = peaks[i].first.first;
		int polar = peaks[i].first.second;
		//cout << angle << endl << polar << endl;
		int x1, y1, x2, y2;
		x1 = y1 = x2 = y2 = 0;
		double _angle = (double)PI*angle / 180.0f;
		if(angle >= 45 && angle <= 135) {
			x1 = 0;
			y1 = ((double)(polar-(hough_h/2)) - ((x1 - (img_w/2) ) * cos(_angle))) / sin(_angle) + (img_h / 2);
			x2 = img_w;
			y2 = ((double)(polar-(hough_h/2)) - ((x2 - (img_w/2) ) * cos(_angle))) / sin(_angle) + (img_h / 2);
		}
		else {
			y1 = 0;
			x1 = ((double)(polar-(hough_h/2)) - ((y1 - (img_h/2) ) * sin(_angle))) / cos(_angle) + (img_w / 2);
			y2 = img_h;
			x2 = ((double)(polar-(hough_h/2)) - ((y2 - (img_h/2) ) * sin(_angle))) / cos(_angle) + (img_w / 2);
		}
		//if
		bool flag = true;
		for (int k = 0; k < lines.size(); k++) {
			if (distance(lines[k].first.first - x1, lines[k].first.second - y1) < 100 && distance(lines[k].second.first - x2, lines[k].second.second - y2) < 100) {
				flag = false;
				break;
			}
		}
		if (flag == true) {
			lines.push_back(pair< pair<int, int>, pair<int, int> >(pair<int, int>(x1, y1), pair<int, int>(x2, y2)));
		}
	}
	for (int i = 0; i < lines.size(); i++) {
		cout << lines[i].first.first << ", " << lines[i].first.second << "  ..  " << lines[i].second.first << ", " << lines[i].second.second << endl;
		resultImg.draw_line(lines[i].first.first, lines[i].first.second, lines[i].second.first, lines[i].second.second, Red);
	}
	//resultImg.draw_line(200, 3458, 2500, 3459, Red);
	//resultImg.display();
}
3. 获得四个角点
void ImageSegmentation::GetVertexs() {
	for (int i = 0; i < lines.size(); i++) {
		double k0, b0;
		if (lines[i].first.first == lines[i].second.first) {
			k0 = DBL_MAX;
			b0 = lines[i].first.first;
		}
		else {
			k0 = (double) (lines[i].first.second - lines[i].second.second) / (lines[i].first.first - lines[i].second.first);
			b0 = (double) (lines[i].first.second * lines[i].second.first - lines[i].second.second * lines[i].first.first) / (lines[i].second.first - lines[i].first.first);
		}
		for (int j = i + 1; j < lines.size(); j++) {
			double k1, b1;
			if (lines[j].first.first == lines[j].second.first) {
				k1 = DBL_MAX;
				b1 = lines[j].first.first;
			}
			else {
				k1 = (double) (lines[j].first.second - lines[j].second.second) / (lines[j].first.first - lines[j].second.first);
				b1 = (double) (lines[j].first.second * lines[j].second.first - lines[j].second.second * lines[j].first.first) / (lines[j].second.first - lines[j].first.first);
			}
			if (k0 == k1)
				continue;
			if (k0 == DBL_MAX) {
				int _x = b0, _y = k1 * b0 + b1;
				if (_x >= 0 && _x < Img._width && _y >= 0 && _y < Img._height)
					vertex.push_back(make_pair(_x, _y));
				continue;
			}
			if (k1 == DBL_MAX) {
				int _x = b1, _y = k0 * b1 + b0;
				if (_x >= 0 && _x < Img._width && _y >= 0 && _y < Img._height)
					vertex.push_back(make_pair(_x, _y));
				continue;
			}
			int _x = (b0 - b1) / (k1 - k0);
			int _y = (k0 * b1 - k1 * b0) / (k0 - k1);
			if (_x >= 0 && _x < Img._width && _y >= 0 && _y < Img._height)
				vertex.push_back(make_pair(_x, _y));
		}
	}
	for (int i = 0; i < vertex.size(); i++) {
		cout << vertex[i].first << "  ...  " << vertex[i].second << endl;
		resultImg.draw_circle(vertex[i].first, vertex[i].second, 50, Red);
	}
	resultImg.display();
	resultImg.save("result_a.bmp");
}

(7) 对获得的角点进行排序：

void ImageSegmentation::orderVertexs() {
	sort(vertex.begin(), vertex.end(), [](const pair<int, int> &a, const pair<int, int> &b)-> int {return distance(a.first, a.second) < distance(b.first, b.second);});
	double w = distance(vertex[0].first - vertex[1].first, vertex[0].second - vertex[1].second);
	double h = distance(vertex[0].first - vertex[2].first, vertex[0].second - vertex[2].second);
	//纸张是横向的
	if (vertex[1].first < vertex[2].first && h > w) {
		swap(vertex[1], vertex[2]);
		swap(vertex[2], vertex[3]);
		vertex.push_back(vertex[0]);
		vertex.erase(vertex.begin());
	}
	//纸张是竖向的
	else {
		swap(vertex[2], vertex[3]);
	}
}

(8) 得到用于矫正A4纸的特征矩阵

void ImageSegmentation::calcMatrix() {
  double x0 = vertex[0].first, x1 = vertex[1].first, x2 = vertex[2].first, x3 = vertex[3].first;
  double y0 = vertex[0].second, y1 = vertex[1].second, y2 = vertex[2].second, y3 = vertex[3].second;
  double dx3 = x0 - x1 + x2 - x3;
  double dy3 = y0 - y1 + y2 - y3;
  if (fabs(dx3) < 10e-5 && fabs(dy3) < 10e-5) {
    M[0] = x1 - x0, M[1] = y1 - y0, M[2] = 0;
    M[3] = x2 - x1, M[4] = y2 - y1, M[5] = 0;
    M[6] = x0, M[7] = y0, M[8] = 1;
  }
  else {
    double dx1 = x1 - x2, dx2 = x3 - x2, dy1 = y1 - y2, dy2 = y3 - y2;
    double det = dx1 * dy2 - dx2 * dy1;
    double a13 = (dx3 * dy2 - dx2 * dy3) / det;
    double a23 = (dx1 * dy3 - dx3 * dy1) / det;
    M[0] = x1 - x0 + a13 * x1, M[1] = y1 - y0 + a13 * y1, M[2] = a13;
    M[3] = x3 - x0 + a23 * x3, M[4] = y3 - y0 + a23 * y3, M[5] = a23;
    M[6] = x0, M[7] = y0, M[8] = 1;
  }
}

(9) 进行A4纸矫正

void ImageSegmentation::warping() {
	resultImg = Img;
	double P[3];
  	resultImg.resize(1050, 1485);  // 标准A4纸比例
  	double width = resultImg.width(), height = resultImg.height();
	cimg_forXY(resultImg, x, y) {
		double _x = x / width, _y = y / height;
		double denominator = M[2] * _x + M[5] * _y + M[8];
		double tx = (M[0] * _x + M[3] * _y + M[6]) / denominator;
		double ty = (M[1] * _x + M[4] * _y + M[7]) / denominator;
		/*Interpolation(Img, tx, ty, P);
		resultImg(x,y,0) = P[0];
		resultImg(x,y,1) = P[1];
		resultImg(x,y,2) = P[2];
		//cout << P[0] << endl;	*/
		cimg_forC(resultImg, c) {
			resultImg(x,y,c) = Img((int)tx, (int)ty, c);
		}
  	}
  	resultImg.display();
  	resultImg.save("result_b.bmp");
}

(10) 封装成类

class ImageSegmentation
{

private:
	//源图
	CImg<double> Img;
	//灰度图
	CImg<double> grayImg;
	//高斯平滑后的图像
	CImg<double> blurImg;
	//用于图像分割的阈值
	int threshold;
	//图像分割后的图片
	CImg<double> segImg;
	//梯度图像
	CImg<double> gradImg;
	//霍夫空间图像
	CImg<double> houghImg;
	CImg<double> resultImg;
	vector< pair< pair<int, int>, int > > peaks;
	//直线点集
	vector< pair< pair<int, int>, pair<int, int> > > lines;
	//四个角点
	vector< pair<int, int > > vertex;
	double M[9];

private:
	void rgb2gray();
	void Gauss_blur();
	//迭代法求阈值
	void get_thres_iteration();
	//OSTU法求阈值
	void get_thres_ostu();
	void get_thres(string type_c);
	void Segmentation();
	void gradDection();
	void Hough_Statistics();
	void GetLine();
	void GetVertexs();
	void orderVertexs();
	void calcMatrix();
	void warping();

public:
	ImageSegmentation();
	ImageSegmentation(const char* filename);
	~ImageSegmentation();
	void correct_process(string type_c);
};

(11) 效果展示：

1.jpg

在这里插入图片描述
在这里插入图片描述

2.jpg

在这里插入图片描述
在这里插入图片描述

3.jpg

在这里插入图片描述
在这里插入图片描述

4.jpg

在这里插入图片描述
在这里插入图片描述

5.jpg

在这里插入图片描述
在这里插入图片描述

6.jpg

在这里插入图片描述
在这里插入图片描述
完整代码参见：
https://github.com/WangPerryWPY/Computer-Version/tree/master/Exp7/code/work1

perry0528
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OCR如何读取皱巴巴的文件？深度学习在文档图像形变矫正的应用详解
阿里技术
09-25 6921
阿里妹导读：OCR作为智能审核的重要环节，其识别准确率影响着最终审核效果的好坏，而来自扫描仪、智能手机的文档图像多存在卷曲、折叠。本文旨在利用深度学习算法对文档图像的形变...
OpenCV图片校正
嵌入式与人工智能
08-20 2193
图片校正
图像处理--图像分割算法介绍
热门推荐
yangleo1987的博客
11-15 4万+
图像分割的主要算法： 1.基于阈值的分割方法 2.基于边缘的分割方法 3.基于区域的分割方法 4.基于聚类分析的图像分割方法 5.基于小波变换的分割方法 6.基于数学形态学的分割方法 7.基于人工神经网络的分割方法 基于阈值的分割方法 阈值分割方法作为一种常见的区域并行技术，就是用一个或几个阈值将图像的灰度直方图分成几个类，认为图像中灰度值
【计算机毕设】基于机器视觉的图像矫正 (以车牌识别为例) - 图像畸变校正
fawubio的博客
12-13 1514
今天学长向大家介绍一个机器视觉项目基于机器视觉的图像矫正 (以车牌识别为例)目前车牌识别系统在各小区门口随处可见，识别效果貌似都还可以。查阅资料后，发现整个过程又可以细化为车牌定位、畸变校正、车牌分割和内容识别四部分。本篇随笔主要介绍车牌定位及畸变校正两部分，在python环境下通过opencv实现。🧿。
图像矫正与增强：计算机视觉的前期处理
禅与计算机程序设计艺术
12-30 881
1.背景介绍 图像矫正与增强是计算机视觉系统的一个重要环节，它可以提高图像的质量，使得后续的图像处理和分析更加准确和高效。图像矫正主要包括几何矫正和光学矫正，而图像增强则包括直方图均衡化、锐化、对比度增强等。在这篇文章中，我们将深入探讨图像矫正与增强的核心概念、算法原理和实现，并讨论其未来发展趋势和挑战。 2.核心概念与联系 2.1 图像矫正 图像矫正是指通过计算机算法对图像进行变换，以去...
A4纸的矫正
06-12
总的来说，"A4纸的矫正"是一个涉及计算机视觉基础理论和实际编程技能的综合性任务，通过Hough变换识别边缘，Wraping方法进行图像矫正，以及利用CImg这样的库进行高效实现，能够帮助我们把拍摄的歪斜A4纸照片转换成...
基于角点坐标进行图像视觉矫正+含代码操作演示视频
05-16
基于角点坐标进行图像视觉矫正+含代码操作演示视频 运行注意事项：使用matlab2021a或者更高版本测试，运行里面的Runme.m文件，不要直接运行子函数文件。运行时注意matlab左侧的当前文件夹窗口必须是当前工程所在...
项目实战1：LabVIEW机器视觉系统图像畸变、校准和矫正
04-27
4、在进行计算时，它需要包含圆点的二值图像、点阵中各点在真实世界坐标中的间隔(由Grid Descriptor簇提供)、校准点阵的源灰度图像（用于调整计算结果）和点阵的大小Grid Size作为输入。 项目可直接运行~
基于opencv、pythonFlask框架的计算机视觉可视化网站源代码，含伽马矫正、灰度处理、图像翻转等多种图像处理功能
最新发布
04-17
基于opencv、pythonFlask框架的计算机视觉可视化网站。包括但不限于伽马矫正、灰度处理、图像翻转等二十多种图像处理功能 内置功能 基础功能 用户管理：用户是系统操作者，该功能主要完成系统用户配置。 权限管理...
基于计算机视觉算法的图像处理技术的研究.pdf
02-07
总结来说，计算机视觉算法在图像处理技术中的应用，尤其是在真三维显示图像畸变矫正方面，展示了强大的潜力和优越性。通过科学的模型建立和先进的CNN模型，能够有效地校正图像畸变，提升三维显示的视觉体验。这种...
perspective-correction:使用 Canny 检测器和带有 opencv-python 的霍夫变换对 A4 纸的照片进行自动透视校正
06-10
依赖关系 这些脚本需要 python 2.7+ 和以下库才能工作： 枕头（~2.8.1） numpy(~1.9.0) python-opencv(~2.4.11) 安装所有这些的最简单方法是安装 。 如果不能安装python(x,y)，可以分别安装python、numpy和python-opencv，然后安装pip和pillow。 安装Python。 只需使用的安装程序 安装 numpy。 只需使用的安装程序。 （你不需要 scipy 来运行这个项目，所以你可以单独安装 numpy）。 安装 python-opencv。 下载该版本。 （根据您的操作系统选择版本，然后选择版本 2.4.11）。 可执行文件只是一个存档。 解压文件，然后将cv2.pyd复制到 python 安装路径上的lib/site-packages文件夹。 安装点子。 下载，打开 cmd（Linux/Ma
c#图像处理源代码（包含边缘检测，灰度，霍夫等各种变换。。。。）
03-26
最新c#图像处理源代码（包含边缘检测，灰度，霍夫等各种变换等各种算法源代码实例。。。）对初学和已有研究者都很有帮助，值得收藏。
基于区域的图像分割python源代码
04-16
使用python对基于区域生长的图像分割算法进行解决，有什么问题欢迎一同交流。
计算机视觉算法的图像处理技术研究.pdf
09-28
图像处理技术是计算机视觉的基础，它利用计算机对图像信息进行处理，包括图像复原、数字化、分割、识别和编码等步骤。这些技术可以对图像的几何形状、色彩等元素进行存储、重组、拆分和调整，以优化图像质量和效果。...
基于计算机视觉的自动矫正数控系统.pdf
09-28
【基于计算机视觉的自动矫正数控系统】是一种利用计算机视觉技术来提高数控系统加工精度的方法。该系统主要由工业相机和三轴雕刻机构成，通过OpenCV计算机视觉开源库进行开发，用于解决PCB（印制电路板）在装夹过程...
[计算机视觉] A4纸边缘检测
MokHoYin的博客
03-25 7582
这次作业真的是……虽然最后写出的代码没多少行，但是很烧脑，需要用到很多高中的几何数学知识（差不多忘光了_(:зゝ∠)_）和一些算法。然后最后写完发现有些方法挺巧妙的，所以在这里分享一下。 先把作业要求放上来吧： 输入图分辨率：3120*4208 （输入图像的红色部分仅为马赛克处理哈，原输入图像不存在） 好，那接下来po一下做出的效果图： （边缘有点细_(:
计算机视觉-A4纸边缘检测
cswingman的博客
07-29 934
转载：https://blog.csdn.net/qq_33000225/article/details/65934830
【实例分割系列：三】Mask Scoring R-CNN
鹿鹿的博客
09-23 1948
2019 CVPR Oral Mask Scoring R-CNN https://github.com/zjhuang22/maskscoring_rcnn [PyTorch] Mask Scoring R-CNNIntroductionMask RCNNNetworkMaskIoU head问题网络是如何训练的？网络是如何 inference ？References Introductio...
"图像分割与A4纸矫正实验报告：迭代法和OSTU法求阈值
本实验报告主要介绍了计算机视觉中的图像分割技术，并以A4纸矫正为例进行实验。实验方法包括迭代法和OSTU法求阈值，以及统计霍夫空间点和获取对应检测出的直线。报告中给出了具体的代码实现，并说明了每个步骤的目的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值