目标

对于裂缝，在通过YOLO确定其大致位置的基础上，描出大概位置，计算出一系列的裂缝参数，如长度，面积，周长等。

处理思路

读取框选中的图像；
转为单通道灰度图；
自适应二值化；
此时发现图像（坝壁）会有局部噪声，这不是我们想要的，对图像开运算；
目前初步得到了二值化的裂缝图像，但还是远远不够的。
处理一：对二值图Canny后找轮廓，用最小矩形框选，判断该矩形中心是否在轮廓内。若是，则纳入“种子点”；
处理二：对二值图进行连通域搜索，判断连通域的中心是否为白色（即裂缝）。若是，则纳入“种子点”；
根据得到的种子点，在灰度图上进行漫灌，差值选定为常规值30；
漫灌后的图进行常规的二值化运算，阈值需要根据现场效果来调。此时得到的二值化图效果就比较好了，对白色点统计像素值就能得到面积，找轮廓就能得到周长。
对于长度计算，我采取的方法是尝试找出图像的中心线并标记出来。这里用到的是图像细化的实现，由于opencv的API在contrib包里，我就只能在网上找一种实现方法，下面是用到的两个函数，具体实现见代码。
cv::Mat thinImage(const cv::Mat& src, const int maxIterations)
void filterOver(cv::Mat thinSrc)
如此就能描出中线。
描出中线后，对中线点进行统计并计算各点之间的距离。（这个目前的方法不是很好）
目前我的处理方式是：对横向裂缝，先对列遍历、再对行遍历。对纵向裂缝则相反。如果两个点之间的横坐标或者纵坐标大于一个阈值，则不计算这两点之间的这段距离，避免比如 分叉、割断 带来的误差。【暂时没想到更好的方法】据此给出面积。

image.png

处理效果

image.png
image.png
image.png
image.png
image.png
image.png

存在问题

存在的问题在于裂缝长度的计算上。
比如横向的这种分叉的情况，应该怎么计算某一个分支的长度？
A07C46FD28B50E5E21BD50BB77D69102.png
怎么将一个分支下的点相连呢？

实现代码

  1. #pragma once
  2. #include<opencv2\opencv.hpp>
  3. #include<opencv2\dnn.hpp>
  4. #include<fstream>
  5. #include<iostream>
  6. #include "functions.h"
  7. //#include <opencv2\ximgproc.hpp>  //细化函数thining所在的头文件
  9. using namespace std;
  10. using namespace cv;
  11. using namespace cv::dnn;
  13. #define path "D:/C_C++_Space/opencv4_xwl/cracktest3.jpg"
  14. #define pixdistance 1
  18. int main()
  19. {
  20.     //---------------------------------------加载类别---------------------------------------
  21.     bool crackflag = 1;
  22.     if (!crackflag)
  23.     {
  24.         return -1;
  25.     }
  26.     Mat src = imread(path);//后期改成在YOLO框选范围内搜索
  27.     imshow("原图", src);
  28.     Mat grayImg, binImg,openImg,curve;
  29.     if (src.empty())
  30.     {
  31.         return -1;
  32.     }
  33.     //imshow("src", src);
  34.     if (src.channels() == 3)
  35.     {
  36.         cvtColor(src, grayImg, COLOR_BGR2GRAY);
  37.     }
  38.     //imshow("gray", grayImg);
  39.     RNG rng(10086);
  41.     ////设置操作标志flags
  42.     int connectivity = 4;  //连通邻域方式
  43.     int maskVal = 255;  //掩码图像的数值
  44.     int flags = connectivity | (maskVal << 8) | FLOODFILL_FIXED_RANGE;
  45.     //设置与选中像素点的差值
  46.     Scalar loDiff = Scalar(30, 30, 30);
  47.     Scalar upDiff = Scalar(30, 30, 30);
  49.     ////声明掩模矩阵变量
  50.     Mat mask = Mat::zeros(src.rows + 2, src.cols + 2, CV_8UC1);
  53.     int blockSize = 27;
  54.     int constValue = 22;
  56.     adaptiveThreshold(grayImg, binImg, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY_INV, blockSize, constValue);
  57.     Mat element = getStructuringElement(MORPH_ELLIPSE, Size(5, 5));
  58.     morphologyEx(binImg, binImg, MORPH_OPEN, element);
  61.     //imshow("binary", binImg);
  63.     Canny(binImg, curve, 80, 200);
  64.     vector<vector<Point>> contours;
  65.     findContours(curve, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);
  66.     /*drawContours(src, contours, -1, Scalar(0, 0, 255), 2);*/
  68.     Point2f rect[4];
  69.     vector<Rect> boundRect(contours.size());  //定义外接矩形集合
  70.     vector<RotatedRect> box(contours.size()); //定义最小外接矩形集合
  71.     vector<Point> floodseed;
  72.     for (int i = 0; i < contours.size(); i++)
  73.     {
  74.         box[i] = minAreaRect(Mat(contours[i]));  //计算每个轮廓最小外接矩形
  75.         box[i].points(rect);  //把最小外接矩形四个端点复制给rect数组
  77.         //for (int i = 0; i < 4; i++)
  78.         //    line(src, rect[i], rect[(i + 1) % 4], Scalar(0, 255, 0));
  79.         /*circle(src, box[i].center, 2, Scalar(0, 255, 0), 2);*/
  80.         //double a1 = pointPolygonTest(contours[i], box[i].center, true);//true表示点到轮廓的距离
  81.         double b1 = pointPolygonTest(contours[i], box[i].center, false);//false表示计算点与轮廓的位置关系-1表示外部，0在轮廓上，1在轮廓内
  82.         Scalar newVal = Scalar(0,0,0);
  83.         if (b1==1)
  84.         {
  86.             floodseed.push_back(box[i].center);
  87.         }
  88.     }
  89.     //imshow("src", src);
  90.     //imshow("flood", grayImg);
  93.     Mat out, stats, centroids;
  94.     int number = connectedComponentsWithStats(binImg, out, stats, centroids, 8, CV_16U);
  96.     Mat result = Mat::zeros(src.size(), src.type());
  97.     int w = result.cols;
  98.     int h = result.rows;
  99.     for (int i = 1; i < number; i++)
  100.     {
  102.         int center_x = centroids.at<double>(i, 0);
  103.         int center_y = centroids.at<double>(i, 1);
  105.         int binvalue = binImg.at<uchar>(center_y, center_x);
  106.         if (binvalue==255)
  107.         {
  108.             floodseed.push_back(Point(center_x, center_y));
  109.         }
  111.     }
  113.     for (int i=0;i<floodseed.size();i++)
  114.     {
  115.         floodFill(grayImg, mask, floodseed[i], Scalar(0,255,0), 0, loDiff, upDiff, flags);
  116.     }
  118.     //imshow("漫灌后", grayImg);
  119.     //图像信息统计
  120.     Mat finalImg;
  121.     threshold(grayImg, finalImg, 85, 255, THRESH_BINARY_INV);//阈值这里取85
  122.     ////开运算
  123.     //Mat newelement = getStructuringElement(MORPH_ELLIPSE, Size(5, 5));
  124.     //morphologyEx(finalImg, finalImg, MORPH_OPEN, newelement);
  125.     medianBlur(finalImg, finalImg, 7);
  126.     //查找白色像素点个数
  127.     int counter = 0;
  128.     Mat_<uchar>::iterator it = finalImg.begin<uchar>();
  129.     Mat_<uchar>::iterator itend = finalImg.end<uchar>();
  130.     for (; it != itend; ++it)
  131.     {
  132.         if ((*it) > 0) counter += 1;//二值化后，像素点是0或者255
  133.     }
  135.     cout << "area = " << counter* pixdistance* pixdistance << endl;
  136.     imshow("处理后的图", finalImg);
  138.     Mat normalImg = finalImg / 255;//归一化，用于图像细化操作
  139.     Mat bond = thinImage(normalImg);
  140.     filterOver(bond);
  142.     bond *= 255;//还原为细化后的灰度图
  144.     imshow("细化后", bond);
  145.     //查找白色像素点,但没想清楚如何计算裂缝的长度
  146.     vector<Point> pwhite;
  147.     if (bond.cols >= bond.rows)//横向裂缝
  148.     {
  149.         for (int j = 0; j < bond.cols; j++)
  150.         {
  151.             for (int i = 0; i < bond.rows; i++)
  152.             {
  153.                 if (bond.at<uchar>(i, j) > 0)
  154.                     pwhite.push_back(Point(j, i));
  155.             }
  156.         }
  157.     }
  158.     else//纵向裂缝
  159.     {
  160.         for (int i = 0; i < bond.rows; i++)
  161.         {
  162.             for (int j = 0; j < bond.cols; j++)
  163.             {
  164.                 if (bond.at<uchar>(i, j) > 0)
  165.                     pwhite.push_back(Point(j, i));
  166.             }
  167.         }
  168.     }
  170.     double length = 0;
  171.     int xthreshold = src.cols * 0.1;
  172.     int ythreshold = src.rows * 0.1;
  173.     for (int i = 0; i < pwhite.size()-1; i++)
  174.     {
  175.         int xdiff = abs(pwhite[i].x - pwhite[i + 1].x);
  176.         int ydiff = abs(pwhite[i].y - pwhite[i + 1].y);
  177.         if (xdiff > xthreshold || ydiff > ythreshold) continue;
  178.         length += getDistance(pwhite[i], pwhite[i + 1]);
  180.         src.at<Vec3b>(pwhite[i])[0] = 0;
  181.         src.at<Vec3b>(pwhite[i])[1] = 0;
  182.         src.at<Vec3b>(pwhite[i])[2] = 255;
  184.         /*circle(src, pwhite[i], 2, Scalar(0, 0, 255), 1);*/
  185.     }
  186.     src.at<Vec3b>(pwhite[pwhite.size()-1])[0] = 0;
  187.     src.at<Vec3b>(pwhite[pwhite.size()-1])[1] = 0;
  188.     src.at<Vec3b>(pwhite[pwhite.size()-1])[2] = 255;
  190.     cout << "length = "<<length * pixdistance << endl;
  192.     imshow("src", src);
  194.     waitKey(0);
  196.     return 0;
  198. }
  2. //图像细化的鼻祖代码
  3. cv::Mat thinImage(const cv::Mat& src, const int maxIterations)
  4. {
  5.     assert(src.type() == CV_8UC1);
  6.     cv::Mat dst;
  7.     int width = src.cols;
  8.     int height = src.rows;
  9.     src.copyTo(dst);
  10.     int count = 0;  //记录迭代次数  
  11.     while (true)
  12.     {
  13.         count++;
  14.         if (maxIterations != -1 && count > maxIterations) //限制次数并且迭代次数到达  
  15.             break;
  16.         std::vector<uchar*> mFlag; //用于标记需要删除的点  
  17.         //对点标记  
  18.         for (int i = 0; i < height; ++i)
  19.         {
  20.             uchar* p = dst.ptr<uchar>(i);
  21.             for (int j = 0; j < width; ++j)
  22.             {
  23.                 //如果满足四个条件，进行标记  
  24.                 //  p9 p2 p3  
  25.                 //  p8 p1 p4  
  26.                 //  p7 p6 p5  
  27.                 uchar p1 = p[j];
  28.                 if (p1 != 1) continue;
  29.                 uchar p4 = (j == width - 1) ? 0 : *(p + j + 1);
  30.                 uchar p8 = (j == 0) ? 0 : *(p + j - 1);
  31.                 uchar p2 = (i == 0) ? 0 : *(p - dst.step + j);
  32.                 uchar p3 = (i == 0 || j == width - 1) ? 0 : *(p - dst.step + j + 1);
  33.                 uchar p9 = (i == 0 || j == 0) ? 0 : *(p - dst.step + j - 1);
  34.                 uchar p6 = (i == height - 1) ? 0 : *(p + dst.step + j);
  35.                 uchar p5 = (i == height - 1 || j == width - 1) ? 0 : *(p + dst.step + j + 1);
  36.                 uchar p7 = (i == height - 1 || j == 0) ? 0 : *(p + dst.step + j - 1);
  37.                 if ((p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) >= 2 && (p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) <= 6)
  38.                 {
  39.                     int ap = 0;
  40.                     if (p2 == 0 && p3 == 1) ++ap;
  41.                     if (p3 == 0 && p4 == 1) ++ap;
  42.                     if (p4 == 0 && p5 == 1) ++ap;
  43.                     if (p5 == 0 && p6 == 1) ++ap;
  44.                     if (p6 == 0 && p7 == 1) ++ap;
  45.                     if (p7 == 0 && p8 == 1) ++ap;
  46.                     if (p8 == 0 && p9 == 1) ++ap;
  47.                     if (p9 == 0 && p2 == 1) ++ap;
  49.                     if (ap == 1 && p2 * p4 * p6 == 0 && p4 * p6 * p8 == 0)
  50.                     {
  51.                         //标记  
  52.                         mFlag.push_back(p + j);
  53.                     }
  54.                 }
  55.             }
  56.         }
  58.         //将标记的点删除  
  59.         for (std::vector<uchar*>::iterator i = mFlag.begin(); i != mFlag.end(); ++i)
  60.         {
  61.             **i = 0;
  62.         }
  64.         //直到没有点满足，算法结束  
  65.         if (mFlag.empty())
  66.         {
  67.             break;
  68.         }
  69.         else
  70.         {
  71.             mFlag.clear();//将mFlag清空  
  72.         }
  74.         //对点标记  
  75.         for (int i = 0; i < height; ++i)
  76.         {
  77.             uchar* p = dst.ptr<uchar>(i);
  78.             for (int j = 0; j < width; ++j)
  79.             {
  80.                 //如果满足四个条件，进行标记  
  81.                 //  p9 p2 p3  
  82.                 //  p8 p1 p4  
  83.                 //  p7 p6 p5  
  84.                 uchar p1 = p[j];
  85.                 if (p1 != 1) continue;
  86.                 uchar p4 = (j == width - 1) ? 0 : *(p + j + 1);
  87.                 uchar p8 = (j == 0) ? 0 : *(p + j - 1);
  88.                 uchar p2 = (i == 0) ? 0 : *(p - dst.step + j);
  89.                 uchar p3 = (i == 0 || j == width - 1) ? 0 : *(p - dst.step + j + 1);
  90.                 uchar p9 = (i == 0 || j == 0) ? 0 : *(p - dst.step + j - 1);
  91.                 uchar p6 = (i == height - 1) ? 0 : *(p + dst.step + j);
  92.                 uchar p5 = (i == height - 1 || j == width - 1) ? 0 : *(p + dst.step + j + 1);
  93.                 uchar p7 = (i == height - 1 || j == 0) ? 0 : *(p + dst.step + j - 1);
  95.                 if ((p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) >= 2 && (p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9) <= 6)
  96.                 {
  97.                     int ap = 0;
  98.                     if (p2 == 0 && p3 == 1) ++ap;
  99.                     if (p3 == 0 && p4 == 1) ++ap;
  100.                     if (p4 == 0 && p5 == 1) ++ap;
  101.                     if (p5 == 0 && p6 == 1) ++ap;
  102.                     if (p6 == 0 && p7 == 1) ++ap;
  103.                     if (p7 == 0 && p8 == 1) ++ap;
  104.                     if (p8 == 0 && p9 == 1) ++ap;
  105.                     if (p9 == 0 && p2 == 1) ++ap;
  107.                     if (ap == 1 && p2 * p4 * p8 == 0 && p2 * p6 * p8 == 0)
  108.                     {
  109.                         //标记  
  110.                         mFlag.push_back(p + j);
  111.                     }
  112.                 }
  113.             }
  114.         }
  116.         //将标记的点删除  
  117.         for (std::vector<uchar*>::iterator i = mFlag.begin(); i != mFlag.end(); ++i)
  118.         {
  119.             **i = 0;
  120.         }
  122.         //直到没有点满足，算法结束  
  123.         if (mFlag.empty())
  124.         {
  125.             break;
  126.         }
  127.         else
  128.         {
  129.             mFlag.clear();//将mFlag清空  
  130.         }
  131.     }
  132.     return dst;
  133. }
  135. /**
  136. * @brief 对骨骼化图数据进行过滤，实现两个点之间至少隔一个空白像素
  137. * @param thinSrc为输入的骨骼化图像,8位灰度图像格式，元素中只有0与1,1代表有元素，0代表为空白
  138. */
  139. void filterOver(cv::Mat thinSrc)
  140. {
  141.     assert(thinSrc.type() == CV_8UC1);
  142.     int width = thinSrc.cols;
  143.     int height = thinSrc.rows;
  144.     for (int i = 0; i < height; ++i)
  145.     {
  146.         uchar* p = thinSrc.ptr<uchar>(i);
  147.         for (int j = 0; j < width; ++j)
  148.         {
  149.             // 实现两个点之间至少隔一个像素
  150.             //  p9 p2 p3  
  151.             //  p8 p1 p4  
  152.             //  p7 p6 p5  
  153.             uchar p1 = p[j];
  154.             if (p1 != 1) continue;
  155.             uchar p4 = (j == width - 1) ? 0 : *(p + j + 1);
  156.             uchar p8 = (j == 0) ? 0 : *(p + j - 1);
  157.             uchar p2 = (i == 0) ? 0 : *(p - thinSrc.step + j);
  158.             uchar p3 = (i == 0 || j == width - 1) ? 0 : *(p - thinSrc.step + j + 1);
  159.             uchar p9 = (i == 0 || j == 0) ? 0 : *(p - thinSrc.step + j - 1);
  160.             uchar p6 = (i == height - 1) ? 0 : *(p + thinSrc.step + j);
  161.             uchar p5 = (i == height - 1 || j == width - 1) ? 0 : *(p + thinSrc.step + j + 1);
  162.             uchar p7 = (i == height - 1 || j == 0) ? 0 : *(p + thinSrc.step + j - 1);
  163.             if (p2 + p3 + p8 + p9 >= 1)
  164.             {
  165.                 p[j] = 0;
  166.             }
  167.         }
  168.     }
  169. }
  171. /**
  172. * @brief 从过滤后的骨骼化图像中寻找端点和交叉点
  173. * @param thinSrc为输入的过滤后骨骼化图像,8位灰度图像格式，元素中只有0与1,1代表有元素，0代表为空白
  174. * @param raudis卷积半径，以当前像素点位圆心，在圆范围内判断点是否为端点或交叉点
  175. * @param thresholdMax交叉点阈值，大于这个值为交叉点
  176. * @param thresholdMin端点阈值，小于这个值为端点
  177. * @return 为对src细化后的输出图像,格式与src格式相同，元素中只有0与1,1代表有元素，0代表为空白
  178. */
  179. std::vector<cv::Point> getPoints(const cv::Mat& thinSrc, unsigned int raudis, unsigned int thresholdMax, unsigned int thresholdMin )
  180. {
  181.     assert(thinSrc.type() == CV_8UC1);
  182.     int width = thinSrc.cols;
  183.     int height = thinSrc.rows;
  184.     cv::Mat tmp;
  185.     thinSrc.copyTo(tmp);
  186.     std::vector<cv::Point> points;
  187.     for (int i = 0; i < height; ++i)
  188.     {
  189.         for (int j = 0; j < width; ++j)
  190.         {
  191.             if (*(tmp.data + tmp.step * i + j) == 0)
  192.             {
  193.                 continue;
  194.             }
  195.             int count = 0;
  196.             for (int k = i - raudis; k < i + raudis + 1; k++)
  197.             {
  198.                 for (int l = j - raudis; l < j + raudis + 1; l++)
  199.                 {
  200.                     if (k < 0 || l < 0 || k>height - 1 || l>width - 1)
  201.                     {
  202.                         continue;
  204.                     }
  205.                     else if (*(tmp.data + tmp.step * k + l) == 1)
  206.                     {
  207.                         count++;
  208.                     }
  209.                 }
  210.             }
  212.             if (count > thresholdMax || count < thresholdMin)
  213.             {
  214.                 Point point(j, i);
  215.                 points.push_back(point);
  216.             }
  217.         }
  218.     }
  219.     return points;
  220. }
  222. /***************************************************************
  223.     FunctionName:    getDistance
  224.     Purpose:        计算点之间的距离
  225.     Parameter:        两个point
  226.     Return:            两点之间的距离
  227. ****************************************************************/
  228. double getDistance(Point pointO, Point pointA)
  229. {
  230.     double distance;
  231.     distance = powf((pointO.x - pointA.x), 2) + powf((pointO.y - pointA.y), 2);
  232.     distance = sqrtf(distance);
  233.     return distance;
  234. }
  1. Mat thinImage(const cv::Mat& src, const int maxIterations = -1);
  2. void filterOver(cv::Mat thinSrc);
  3. vector<cv::Point> getPoints(const cv::Mat& thinSrc, unsigned int raudis = 4, unsigned int thresholdMax = 6, unsigned int thresholdMin = 4);
  4. double getDistance(Point pointO, Point pointA);