基于距离变换和分水岭算法的图像分割

阳光穿透心脏的1/2处 2022-03-21 08:15 407阅读 0赞

## 原理 ##

--------------------

## 代码 ##

#include <opencv2/opencv.hpp>
    #include <iostream>
    
    
    using namespace cv;
    using namespace std;
    
    double maxVal, minVal;
    
    int main(void)
    { 
    	
        Mat src = imread("../res/cards.png");
        if(src.empty())
        { 
    	cout << "can't load the image" << endl;
    	return -1;
        }
    
        imshow("Source Image", src);
        
        for(int i=0; i<src.rows; i++)
        { 
    	for(int j=0; j<src.cols; j++)
    	{ 
    	    if(src.at<Vec3b>(i,j) == Vec3b(255,255,255))
    	    { 
    		src.at<Vec3b>(i,j) = Vec3b(0,0,0);
    	    }
    	}
        }
        imshow("Black Background Image", src);
    	
    
        Mat kernel = (Mat_<float>(3,3) << 1, 1, 1,
    				      1,-8, 1,
    				      1, 1, 1);
    
        Mat imgLaplacian;
        filter2D(src, imgLaplacian, CV_32F, kernel);
        Mat sharp;
        src.convertTo(sharp, CV_32F);
        Mat imgResult = sharp - imgLaplacian;
    
        imgResult.convertTo(imgResult, CV_8UC3);
        imgLaplacian.convertTo(imgLaplacian, CV_8UC3);
        imshow("New Sharped Image", imgResult);
    
    
        Mat bw;
        cvtColor(imgResult, bw, COLOR_BGR2GRAY);
        threshold(bw, bw, 40, 255,  THRESH_BINARY|THRESH_OTSU);
        imshow("Binary Image", bw);
    
        Mat dist;
        cv::distanceTransform(bw, dist, DIST_L2, 3);
        normalize(dist, dist, 0, 1.0, NORM_MINMAX);
        imshow("Distance Transform Image", dist);
    
        threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
        Mat kernel1 = Mat::ones(3,3,CV_8U);
        dilate(dist, dist, kernel1);
        imshow("Peaks", dist);
    
        Mat dist_8u;
        dist.convertTo(dist_8u, CV_8U);
    
        vector<vector<Point>> contours;
        cv::findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
        // Mat drawing(dist_8u.size(), CV_8UC3, Scalar(0,0,0));
        // cv::drawContours(drawing, contours, -1, Scalar(255,0,0), 2);
        // imshow("drawing", drawing);
        Mat markers = Mat::zeros(dist.size(), CV_32S);
        for(int i=0; i<contours.size(); i++)
        { 
    	drawContours(markers, contours, i, Scalar(i+1), -1);
        }
        circle(markers, Point(5,5), 3, Scalar(255), -1);
        // imshow("Markers", markers);
        
    
    
    
        watershed(imgResult, markers);
    
        Mat mark;
        markers.convertTo(mark, CV_8U);
        bitwise_not(mark, mark);
    
    
        vector<Vec3b> colors;
        for(int i=0; i<contours.size(); i++)
        { 
    	int b = theRNG().uniform(0,256);
    	int g = theRNG().uniform(0,256);
    	int r = theRNG().uniform(0,256);
    
    	colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
    	
        }
    
    
        Mat dst = Mat::zeros(markers.size(), CV_8UC3);
        for(int i=0; i<markers.rows; i++)
        { 
    	for(int j=0; j<markers.cols; j++)
    	{ 
    	    int index = markers.at<int>(i,j);
    	    if(index>0 && index <= static_cast<int>(contours.size()))
    	    { 
    		dst.at<Vec3b>(i,j) = colors[index-1];
    	    }
    	}
        }
    
        imshow("Final Result", dst);
        
    
        waitKey();
    
    	return 0;
    };

代码分析：

1.  读入原始图像，

Mat src = imread("../res/cards.png");
        if(src.empty())
        { 
    	cout << "can't load the image" << endl;
    	return -1;
        }
    
        imshow("Source Image", src);

![在这里插入图片描述][20190201131550441.png_pic_center]

1.  然后将背景白色部分改成黑色（有助于后期处理）

for(int i=0; i<src.rows; i++)
        { 
    	for(int j=0; j<src.cols; j++)
    	{ 
    	    if(src.at<Vec3b>(i,j) == Vec3b(255,255,255))
    	    { 
    		src.at<Vec3b>(i,j) = Vec3b(0,0,0);
    	    }
    	}
        }
        imshow("Black Background Image", src);

![在这里插入图片描述][20190201131813693.png_pic_center]

1.  锐化图片

Mat kernel = (Mat_<float>(3,3) << 1, 1, 1,
    				                      1,-8, 1,
    				                      1, 1, 1); // 近似二阶导数
    
        Mat imgLaplacian;
        filter2D(src, imgLaplacian, CV_32F, kernel);   //进行laplacian filtering ,因为可能有负值，所以深度是32F
        Mat sharp;
        src.convertTo(sharp, CV_32F);
        Mat imgResult = sharp - imgLaplacian;     //负值消除
    
        imgResult.convertTo(imgResult, CV_8UC3);
        imgLaplacian.convertTo(imgLaplacian, CV_8UC3);
        imshow("Laplas", imgLaplacian);
        imshow("New Sharped Image", imgResult);

![在这里插入图片描述][20190201133848496.png_pic_center]  
![在这里插入图片描述][20190201132145621.png_pic_center]

1.  二值化图像

Mat bw;
        cvtColor(imgResult, bw, COLOR_BGR2GRAY);
        threshold(bw, bw, 40, 255,  THRESH_BINARY|THRESH_OTSU); //超多40->255 否则就是0
        imshow("Binary Image", bw);

![在这里插入图片描述][20190201135237728.png_pic_center]

1.  对二值化的图像进行距离变换

Mat dist;
        cv::distanceTransform(bw, dist, DIST_L2, 3);//计算图像中每个点到 **最近像素为0的点** 的距离
        normalize(dist, dist, 0, 1.0, NORM_MINMAX); //将结果归一化到0-1之间，这样可以显示
        imshow("Distance Transform Image", dist);

![在这里插入图片描述][20190201135701120.png_pic_center]

1.  对距离图像进行阈值处理，提取局部最大值，提取前景对象

threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
        Mat kernel1 = Mat::ones(3,3,CV_8U);
        dilate(dist, dist, kernel1);  //进行膨胀
        imshow("Peaks", dist);

![在这里插入图片描述][20190201140723839.png_pic_center]

1.  对于每个物体，我们创建marker，为分水岭算法做准备

Mat dist_8u;
        dist.convertTo(dist_8u, CV_8U);
    
        vector<vector<Point>> contours;
        cv::findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE); //检测轮廓
        
        Mat markers = Mat::zeros(dist.size(), CV_32S);
        for(int i=0; i<contours.size(); i++)
        { 
    	drawContours(markers, contours, i, Scalar(i+1), -1);  //填充式画出轮廓，每个轮廓值由小到大（i+1），每个轮廓就是一个marker
        }
        circle(markers, Point(5,5), 3, Scalar(255), -1); //背景的marker
        //Mat xx;
        // markers.converTo(xx, CV_8UC3);
        // imshow("Markers", xx*30); //为了显示图×30，否则基本黑的

![在这里插入图片描述][20190201143242962.png_pic_center]

1.  最后进行分水岭算法，再显示结果

watershed(imgResult, markers);
    
      // Mat mark;
        //markers.convertTo(mark, CV_8U);
      // bitwise_not(mark, mark);
    
    
    //随机创建颜色
        vector<Vec3b> colors;
        for(int i=0; i<contours.size(); i++)
        { 
    	int b = theRNG().uniform(0,256);
    	int g = theRNG().uniform(0,256);
    	int r = theRNG().uniform(0,256);
    
    	colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
    	
        }
    
    
        Mat dst = Mat::zeros(markers.size(), CV_8UC3); //创建最后显示结果的图像
        for(int i=0; i<markers.rows; i++)
        { 
    	for(int j=0; j<markers.cols; j++)
    	{ 
    	    int index = markers.at<int>(i,j);   //在markers里面，对每个物体所包含的部分，值都是index，
    	    if(index>0 && index <= static_cast<int>(contours.size())) //保证index在正常的范围内
    	    { 
    		dst.at<Vec3b>(i,j) = colors[index-1];  //对于每个物体标记不同的颜色
    	    }
    	}
        }
    
        imshow("Final Result", dst);

![在这里插入图片描述][20190201141049928.png_pic_center]

--------------------

## OpenCV API ##

1.  计算图像中每个点到 **最近像素为0的点** 的距离

[void cv::distanceTransform][void cv_distanceTransform]

( 	
            InputArray  	src,      // 8-bit, single-channel (binary) source image. 
    		OutputArray  	dst,      // 输出的距离图像，8UC1 or 32FC1 ,same size as src. 
    		int  	distanceType,     // Type of distance, 如下图
    		int  	maskSize,         // size of the distance transform mask， DIST_L1 or DIST_C 类型必须是3，
    		int  	dstType = CV_32F  // 输出图像类型，CV_8U or CV_32F
    )

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6eWN6enlj_size_16_color_FFFFFF_t_70]

1.  使用基于mark的图像分割分水岭算法

[void cv::watershed][void cv_watershed]

( 	    InputArray  	    image,    // Input 8-bit 3-channel image.
    		InputOutputArray  	markers   // 输入、输出图像。same size as image， 32-bit single-channel image (map) of markers
    )

[20190201131550441.png_pic_center]: /images/20220321/4367d8d164ba4f03a04d6f038ccc4be8.png
[20190201131813693.png_pic_center]: /images/20220321/63e6865ed2364ec59705054a36948542.png
[20190201133848496.png_pic_center]: /images/20220321/a2c461579386434c9f649cb0fc6f9be6.png
[20190201132145621.png_pic_center]: /images/20220321/6984753af1954e67ae68281fc32edc44.png
[20190201135237728.png_pic_center]: /images/20220321/6a947d35133d4740b5004afcb142c165.png
[20190201135701120.png_pic_center]: /images/20220321/50defadf37214c2bbb61a57651bf5012.png
[20190201140723839.png_pic_center]: /images/20220321/d91411b1c0944268b740a857950b537d.png
[20190201143242962.png_pic_center]: /images/20220321/7088e6674fb44e08a34adcd7e04e7b7c.png
[20190201141049928.png_pic_center]: /images/20220321/eb7df4ffe4cf44df90e7383f419b2f93.png
[void cv_distanceTransform]: https://docs.opencv.org/master/d7/d1b/group__imgproc__misc.html#ga8a0b7fdfcb7a13dde018988ba3a43042
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6eWN6enlj_size_16_color_FFFFFF_t_70]: /images/20220321/b3281d18c4614f5d847ffbb58c16e6d0.png
[void cv_watershed]: https://docs.opencv.org/4.0.1/d7/d1b/group__imgproc__misc.html#ga3267243e4d3f95165d55a618c65ac6e1