OpenCV3历程（5）——裂缝的检测与测量_opencv识别裂缝时,一条裂缝断开重新连接

作者：Li_阴宅 | 2024-07-14 16:41:33

踩

opencv识别裂缝时,一条裂缝断开重新连接

一、开始先介绍几个即将用到的函数及知识点

1、LUT函数

函数简介：


void LUT(
  InputArray src,         //原始图像的地址；
  InputArray lut,         //查找表的地址，对于多通道图像的查找，它可以有一个通道，也可以与原始图像有相同的通道；
  OutputArray dst         //输出图像的地址。
)

函数介绍（单通道为例）：

对于8位单通道图片，其像素灰度为0-255，假如我们想将图像某一灰度值换成其他灰度值，用查找就很好用。

例如：我们想将一张图片灰度为0-100的像素的灰度变成0,101-200的变成100,201-255的变成255。我们就可已建立如下的一张表格；

当把此表格应用到图片时，图片0-100灰度的像素灰度就变成0，101-200的变成100,201-255的就变成255。映射表差不多就是这个意思。

典型用法(借助图像取反示例说明)是：

（虽然手动遍历可以达到同样效果，但尽量使用 OpenCV 内置函数。调用LUT 函数可以获得最快的速度，这是因为OpenCV库可以通过英特尔线程架构启用多线程。）


    //建立查找表
    Mat lookUpTable(1, 256, CV_8U);
    uchar *p = lookUpTable.data;
    for(int i=0; i<256; i++)
        p[i]=255-i;
    //通过LUT函数实现图像取反
    LUT(img1,lookUpTable,img1);

2、saturate_cast防止数据溢出

在OpenCV学习中经常看见saturate_cast的使用，为什么函数会用到saturate_cast呢，因为无论是加是减，乘除，都会超出一个像素灰度值的范围（0～255）所以，所以当运算完之后，结果为负，则转为0，结果超出255，则为255。另外在梯度锐化的函数里，也会涉及到saturate_cast。示例如下：

代码来自：https://blog.csdn.net/mjlsuccess/article/details/12401839


//使用图像混合例子中的C语言版本演示
for (int i=0; i<src1.rows; i++)
{
	const uchar* src1_ptr = src1.ptr<uchar>(i);
	const uchar* src2_ptr = src2.ptr<uchar>(i);
	uchar* dst_ptr  = dst.ptr<uchar>(i);
	for (int j=0; j<src1.cols*nChannels; j++)
	{
    //加溢出保护
	dst_ptr[j] = saturate_cast<uchar>(src1_ptr[j]*alpha + src2_ptr[j]*beta + gama);//gama = -100, alpha = beta = 0.5
    //不加溢出保护
    //	dst_ptr[j] = (src1_ptr[j]*alpha + src2_ptr[j]*beta + gama);
	}
}
imshow("output",dst);

大致的原理应该如下：


if(data<0)
        data=0;
else if(data>255)
	data=255;

3、std::stack 基本操作

C++ Stack（堆栈）是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。

c++ stl栈stack的头文件为:

#include <stack>

c++ stl栈stack的成员函数介绍


//操作 比较和分配堆栈
 
empty() //堆栈为空则返回真
 
pop()   //移除栈顶元素
 
push()  //在栈顶增加元素
 
size()  //返回栈中元素数目
 
top()   //返回栈顶元素

4、C++中在一个类中定义另一个只有带参数构造函数的类的对象

此处参考网址：https://www.cnblogs.com/rednodel/p/5148156.html


#include<iostream>
using namespace std;
 
class A
{
public:    
　　A( int i ){}
};
 
class B {
public:    
　　B():a(1){}   
//或：B( int i ):a( i ){ }。对a提供参数一定要按这种形式，在冒号后，不能在花括号里面！
private:    
　　A a;
};
 
void main()
{    
　　B b;
}

5、为什么要定义Mat_类

在读取矩阵元素是，以获取矩阵某行的地址时，需要指定数据类型。这样首先需要不停地写“<uchar>”，让人感觉很繁琐，在繁琐和烦躁中容易犯错，如下面代码中的错误，用at（）获取矩阵元素时错误的使用了double类型。这种错误不是语法错误，因此在编译时编译器不会提醒。在程序运行时，at（）函数获取到的不是期望的（i,j）位置处的元素，数据已经越界，但是运行时也未必会报错。这样的错误使得你的程序忽而看上去正常，忽而弹出“段错误”，特别是在代码规模很大时，难以查错。

如果使用Mat_类，那么就可以在变量声明时确定元素的类型，访问元素时不再需要制定元素类型，即使得代码简洁，又减少了出错的可能性。上面代码可以用Mat_实现，实现代码如下面例程里的第二个双重for循环。


#include <iostream>
#include "opencv2/opencv.hpp"
#include<stdio.h>
 
using namespace std;
using namespace cv;
 
int main(int argc,char* argv[])
{
   Mat M(600,800,CV_8UC1);
   for(int i=0;i<M.rows;++i){
   //获取指针时需要指定类型
       uchar *p=M.ptr<uchar>(i);
    for(int j=0;j<M.cols;++j){
         double d1=(double)((i+j)%255);
   //用at读像素时，需要指定类型
         M.at<uchar>(i,j)=d1;
         double d2=M.at<uchar>(i,j);
       }
   }
 
 
   //在变量声明时，指定矩阵元素类型
   Mat_<uchar> M1=(Mat_<uchar>&)M;
   for(int i=0;i<M1.rows;++i)
   {
   //不需要指定元素类型，语言简洁
   uchar *p=M1.ptr(i);
 
 
       for(int j=0;j<M1.cols;++j){
       double d1=(double)((i+j)%255);
   //直接使用matlab风格的矩阵元素读写，简洁
        M1(i,j)=d1;
        double d2=M1(i,j);
     }
   }
   return 0;
}

二、实例裂缝检测源码

这里的代码来自（表示感谢）：https://blog.csdn.net/FunnyWhiteCat/article/details/81387561

首先看原图：

处理流程思路：

图像灰度化
增加对比度
Canny边缘检测
用形态学连接临近裂缝
找出所有连通域，删除非裂缝噪点区域
对每个连通域提取骨架，测量长度和宽度

源码：


#include <opencv2\opencv.hpp>
#include <iostream>
#include <stack>
 
using namespace cv;
using namespace std;
 
//c++中在一个类中定义另一个只有带参数构造函数的类的对象
class CrackInfo
{
   public:
	   CrackInfo(Point& position, long length, float width) {};
};
 
/* 增加对比度 */
void addContrast(Mat & srcImg);
/* 交换两个Mat */
void swapMat(Mat & srcImg, Mat & dstImg);
/* 二值化图像。0->0,非0->255 */
void binaryzation(Mat & srcImg);
/* 检测连通域，并删除不符合条件的连通域 */
void findConnectedDomain(Mat & srcImg, vector<vector<Point>>& connectedDomains, int area, int WHRatio);
/* 提取连通域的骨架 */
void thinImage(Mat & srcImg);
/* 获取图像中白点的数量 */
void getWhitePoints(Mat &srcImg, vector<Point>& domain);
/* 计算宽高信息的放置位置 */
Point calInfoPosition(int imgRows, int imgCols, int padding, const std::vector<cv::Point>& domain);
 
int main(int argc, char** argv) {
	Mat srcImg = imread("./image/20180803215201452.jpg");
	Mat dstImg, dstImg2;
	//灰度化
	cvtColor(srcImg, dstImg, CV_BGR2GRAY, 1);
	//增加对比度
	addContrast(dstImg);
	//图像交换
	swapMat(srcImg, dstImg);
	//边缘检测
	Canny(srcImg, dstImg, 50, 150);
	//形态学变换
	Mat kernel = getStructuringElement(MORPH_ELLIPSE, Size(3, 3));
	dilate(dstImg, dstImg, kernel);//膨胀
	morphologyEx(dstImg, dstImg, CV_MOP_CLOSE, kernel, Point(-1, -1), 3);
	morphologyEx(dstImg, dstImg, CV_MOP_CLOSE, kernel);
	//寻找连通域
	vector<vector<Point>> connectedDomains;
	findConnectedDomain(dstImg, connectedDomains, 20, 3);
	kernel = getStructuringElement(MORPH_ELLIPSE, Size(7, 7));
	morphologyEx(dstImg, dstImg, CV_MOP_CLOSE, kernel, Point(-1, -1), 5);
 
	connectedDomains.clear();
	findConnectedDomain(dstImg, connectedDomains, 20, 3);
	kernel = getStructuringElement(MORPH_CROSS, Size(3, 3));
	morphologyEx(dstImg, dstImg, CV_MOP_OPEN, kernel);
 
	kernel = getStructuringElement(MORPH_ELLIPSE, Size(3, 3));
	erode(dstImg, dstImg, kernel);
 
	connectedDomains.clear();
	findConnectedDomain(dstImg, connectedDomains, 20, 3);
 
	cout << "开始测量" << endl;
	cout << "连通域数量：" << connectedDomains.size() << endl;
	Mat lookUpTable(1, 256, CV_8U, Scalar(0));
	vector<CrackInfo> crackInfos;
	for (auto domain_it = connectedDomains.begin(); domain_it != connectedDomains.end(); ++domain_it) {
		LUT(dstImg, lookUpTable, dstImg);
		for (auto point_it = domain_it->cbegin(); point_it != domain_it->cend(); ++point_it) {
			dstImg.ptr<uchar>(point_it->y)[point_it->x] = 255;
		}
		double area = (double)domain_it->size();
		thinImage(dstImg);
		getWhitePoints(dstImg, *domain_it);
		long length = (long)domain_it->size();
		Point position = calInfoPosition(dstImg.rows, dstImg.cols, 50, *domain_it);
		crackInfos.push_back(CrackInfo(position, length, (float)(area / length)));
	}
 
	cout << "开始绘制信息" << endl;
	cout << "信息数量：" << crackInfos.size() << endl;
 
	LUT(dstImg, lookUpTable, dstImg);
	for (auto domain_it = connectedDomains.cbegin(); domain_it != connectedDomains.cend(); ++domain_it) {
		for (auto point_it = domain_it->cbegin(); point_it != domain_it->cend(); ++point_it) {
			dstImg.ptr<uchar>(point_it->y)[point_it->x] = 255;
		}
	}
 
	//ostringstream info;
	//for (auto it = crackInfos.cbegin(); it != crackInfos.cend(); ++it) {
	//	info.str("");
	//	info << *it;
	//	putText(dstImg, info.str(), it->Position, FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255));
	//}
 
	imwrite("result1.png", dstImg);
	cout << "保存图像完成" << endl;
	return 0;
}
 
/*利用查找表(Look-up table)增加图像对比度*/
void addContrast(Mat & srcImg) {
	Mat lookUpTable(1, 256, CV_8U);
	double temp = pow(1.1, 5);
	uchar* p = lookUpTable.data;
	for (int i = 0; i < 256; ++i)
		p[i] = saturate_cast<uchar>(i * temp);
	LUT(srcImg, lookUpTable, srcImg);
}
/*图像交换*/
void swapMat(Mat & srcImg, Mat & dstImg) {
	Mat tempImg = srcImg;
	srcImg = dstImg;
	dstImg = tempImg;
}
/* 检测连通域，并删除不符合条件的连通域 */
void findConnectedDomain(Mat & srcImg, vector<vector<Point>>& connectedDomains, int area, int WHRatio) {
	Mat_<uchar> tempImg = (Mat_<uchar> &)srcImg;
 
	for (int i = 0; i < tempImg.rows; ++i) {
		uchar* row = tempImg.ptr(i);    调取存储图像内存的第i行的指针
		for (int j = 0; j < tempImg.cols; ++j) {
			if (row[j] == 255) {
				stack<Point> connectedPoints;
				vector<Point> domain;
				connectedPoints.push(Point(j, i));
				while (!connectedPoints.empty()) {
					Point currentPoint = connectedPoints.top();
					domain.push_back(currentPoint);
 
					int colNum = currentPoint.x;
					int rowNum = currentPoint.y;
 
					tempImg.ptr(rowNum)[colNum] = 0;
					connectedPoints.pop();
 
					if (rowNum - 1 >= 0 && colNum - 1 >= 0 && tempImg.ptr(rowNum - 1)[colNum - 1] == 255) {
						tempImg.ptr(rowNum - 1)[colNum - 1] = 0;
						connectedPoints.push(Point(colNum - 1, rowNum - 1));
					}
					if (rowNum - 1 >= 0 && tempImg.ptr(rowNum - 1)[colNum] == 255) {
						tempImg.ptr(rowNum - 1)[colNum] = 0;
						connectedPoints.push(Point(colNum, rowNum - 1));
					}
					if (rowNum - 1 >= 0 && colNum + 1 < tempImg.cols && tempImg.ptr(rowNum - 1)[colNum + 1] == 255) {
						tempImg.ptr(rowNum - 1)[colNum + 1] = 0;
						connectedPoints.push(Point(colNum + 1, rowNum - 1));
					}
					if (colNum - 1 >= 0 && tempImg.ptr(rowNum)[colNum - 1] == 255) {
						tempImg.ptr(rowNum)[colNum - 1] = 0;
						connectedPoints.push(Point(colNum - 1, rowNum));
					}
					if (colNum + 1 < tempImg.cols && tempImg.ptr(rowNum)[colNum + 1] == 255) {
						tempImg.ptr(rowNum)[colNum + 1] = 0;
						connectedPoints.push(Point(colNum + 1, rowNum));
					}
					if (rowNum + 1 < tempImg.rows && colNum - 1 > 0 && tempImg.ptr(rowNum + 1)[colNum - 1] == 255) {
						tempImg.ptr(rowNum + 1)[colNum - 1] = 0;
						connectedPoints.push(Point(colNum - 1, rowNum + 1));
					}
					if (rowNum + 1 < tempImg.rows && tempImg.ptr(rowNum + 1)[colNum] == 255) {
						tempImg.ptr(rowNum + 1)[colNum] = 0;
						connectedPoints.push(Point(colNum, rowNum + 1));
					}
					if (rowNum + 1 < tempImg.rows && colNum + 1 < tempImg.cols && tempImg.ptr(rowNum + 1)[colNum + 1] == 255) {
						tempImg.ptr(rowNum + 1)[colNum + 1] = 0;
						connectedPoints.push(Point(colNum + 1, rowNum + 1));
					}
				}
				if (domain.size() > area) {
					RotatedRect rect = minAreaRect(domain);
					float width = rect.size.width;
					float height = rect.size.height;
					if (width < height) {
						float temp = width;
						width = height;
						height = temp;
					}
					if (width > height * WHRatio && width > 50) {
						for (auto cit = domain.begin(); cit != domain.end(); ++cit) {
							tempImg.ptr(cit->y)[cit->x] = 250;
						}
						connectedDomains.push_back(domain);
					}
				}
			}
		}
	}
 
	binaryzation(srcImg);
}
/* 二值化图像。0->0,非0->255 */
void binaryzation(Mat & srcImg) {
	Mat lookUpTable(1, 256, CV_8U, Scalar(255));
	lookUpTable.data[0] = 0;
	LUT(srcImg, lookUpTable, srcImg);
}
/* 提取连通域的骨架 */
void thinImage(Mat & srcImg) {
	vector<Point> deleteList;
	int neighbourhood[9];
	int nl = srcImg.rows;
	int nc = srcImg.cols;
	bool inOddIterations = true;
	while (true) {
		for (int j = 1; j < (nl - 1); j++) {
			uchar* data_last = srcImg.ptr<uchar>(j - 1);
			uchar* data = srcImg.ptr<uchar>(j);
			uchar* data_next = srcImg.ptr<uchar>(j + 1);
			for (int i = 1; i < (nc - 1); i++) {
				if (data[i] == 255) {
					int whitePointCount = 0;
					neighbourhood[0] = 1;
					if (data_last[i] == 255) neighbourhood[1] = 1;
					else  neighbourhood[1] = 0;
					if (data_last[i + 1] == 255) neighbourhood[2] = 1;
					else  neighbourhood[2] = 0;
					if (data[i + 1] == 255) neighbourhood[3] = 1;
					else  neighbourhood[3] = 0;
					if (data_next[i + 1] == 255) neighbourhood[4] = 1;
					else  neighbourhood[4] = 0;
					if (data_next[i] == 255) neighbourhood[5] = 1;
					else  neighbourhood[5] = 0;
					if (data_next[i - 1] == 255) neighbourhood[6] = 1;
					else  neighbourhood[6] = 0;
					if (data[i - 1] == 255) neighbourhood[7] = 1;
					else  neighbourhood[7] = 0;
					if (data_last[i - 1] == 255) neighbourhood[8] = 1;
					else  neighbourhood[8] = 0;
					for (int k = 1; k < 9; k++) {
						whitePointCount = whitePointCount + neighbourhood[k];
					}
					if ((whitePointCount >= 2) && (whitePointCount <= 6)) {
						int ap = 0;
						if ((neighbourhood[1] == 0) && (neighbourhood[2] == 1)) ap++;
						if ((neighbourhood[2] == 0) && (neighbourhood[3] == 1)) ap++;
						if ((neighbourhood[3] == 0) && (neighbourhood[4] == 1)) ap++;
						if ((neighbourhood[4] == 0) && (neighbourhood[5] == 1)) ap++;
						if ((neighbourhood[5] == 0) && (neighbourhood[6] == 1)) ap++;
						if ((neighbourhood[6] == 0) && (neighbourhood[7] == 1)) ap++;
						if ((neighbourhood[7] == 0) && (neighbourhood[8] == 1)) ap++;
						if ((neighbourhood[8] == 0) && (neighbourhood[1] == 1)) ap++;
						if (ap == 1) {
							if (inOddIterations && (neighbourhood[3] * neighbourhood[5] * neighbourhood[7] == 0)
								&& (neighbourhood[1] * neighbourhood[3] * neighbourhood[5] == 0)) {
								deleteList.push_back(Point(i, j));
							}
							else if (!inOddIterations && (neighbourhood[1] * neighbourhood[5] * neighbourhood[7] == 0)
								&& (neighbourhood[1] * neighbourhood[3] * neighbourhood[7] == 0)) {
								deleteList.push_back(Point(i, j));
							}
						}
					}
				}
			}
		}
		if (deleteList.size() == 0)
			break;
		for (size_t i = 0; i < deleteList.size(); i++) {
			Point tem;
			tem = deleteList[i];
			uchar* data = srcImg.ptr<uchar>(tem.y);
			data[tem.x] = 0;
		}
		deleteList.clear();
 
		inOddIterations = !inOddIterations;
	}
}
/* 获取图像中白点的数量 */
void getWhitePoints(Mat &srcImg, vector<Point>& domain) {
	domain.clear();
	Mat_<uchar> tempImg = (Mat_<uchar> &)srcImg;
	for (int i = 0; i < tempImg.rows; i++) {
		uchar * row = tempImg.ptr<uchar>(i);
		for (int j = 0; j < tempImg.cols; ++j) {
			if (row[j] != 0)
				domain.push_back(Point(j, i));
		}
	}
}
/* 计算宽高信息的放置位置 */
Point calInfoPosition(int imgRows, int imgCols, int padding, const std::vector<cv::Point>& domain) {
	long xSum = 0;
	long ySum = 0;
	for (auto it = domain.cbegin(); it != domain.cend(); ++it) {
		xSum += it->x;
		ySum += it->y;
	}
	int x = 0;
	int y = 0;
	x = (int)(xSum / domain.size());
	y = (int)(ySum / domain.size());
	if (x < padding)
		x = padding;
	if (x > imgCols - padding)
		x = imgCols - padding;
	if (y < padding)
		y = padding;
	if (y > imgRows - padding)
		y = imgRows - padding;
 
	return cv::Point(x, y);
}

处理结果：

重叠结果

待优化......

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/825592