（31）基于距离变换与分水岭的图像分割

/*
*基于距离变换与分水岭的图像分割
*什么是图像分割(Image Segmentation)
   1：图像分割(Image Segmentation)是图像处理最重要的处理手段之一
   2：图像分割的目标是将图像中像素根据一定的规则分为若干(N)个cluster集合，每个集合包含一类像素。
   3：根据算法分为监督学习方法和无监督学习方法，图像分割的算法多数都是无监督学习方法 - KMeans
*距离变换与分水岭介绍
    距离变换常见算法有两种
            - 不断膨胀/ 腐蚀得到
            - 基于倒角距离
    分水岭变换常见的算法
            - 基于浸泡理论实现
*相关API
        cv::distanceTransform(
                InputArray  src, 
                OutputArray dst,   dst输出8位或者32位的浮点数，单一通道，大小与输入图像一致
                OutputArray  labels, //距离变换出来之后有多少个labels，相同距离的分为同一个label，labels离散维诺图输出,
                int  distanceType,  //距离的类型 distanceType = DIST_L1/DIST_L2,
                int maskSize,  //距离变换的时候结构元素，距离不断的腐蚀的话结构元素是什么，maskSize = 3x3,最新的支持5x5，推荐3x3、
                int labelType = DIST_LABEL_CCOMP
        )
        
        cv::watershed(
                InputArray image, 
                InputOutputArray  markers //输出是分水岭的markers，markers就是分水岭的标线，根据那个把图像分割
        )
*步骤 一定要对图像处理有一个整体的概念，图像处理并不是call一个算法立刻出结果
        1.将白色背景变成黑色-目的是为后面的变换做准备
        2. 使用filter2D与拉普拉斯算子实现图像对比度提高，sharp
        3. 转为二值图像通过threshold
        4. 距离变换
        5. 对距离变换结果进行归一化到[0~1]之间
        6. 使用阈值，再次二值化，得到标记，标记就是哪一个山头是最高的，但是那些山头有可能是连在一起的，有的山头两个山头之间还
            挺高的还是黏糊在一起的，对那个的话我们就要进行一个腐蚀，腐蚀的话就是让它连在一起的一定要分开，腐蚀一般都用矩形的
           结构元素，多少乘多少的要看图像的粘连情况，腐蚀之后我们就得到另外一个结果，对这个结果我们进行发现轮廓
        7. 腐蚀得到每个Peak - erode 
        8.发现轮廓 – findContours
        9. 绘制轮廓- drawContours
        10.分水岭变换 watershed 根据轮廓再进行分水岭变换，我们把图形分割得到真正的结果了，通过分水岭它就从那些最高的点进行
            浸水漫泡的算法开始执行了，执行之后我们就得到最终的一个区域分水结果
        11. 对每个分割区域着色输出结果 我们对输出的区域岭着色，得到最终的结果
*/

#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main()
{
    Mat src = imread("D:/linuxkiss/images/leo.png");
    // Mat src = imread("D:/kuaidi.jpg");
    imshow("input", src);
    
    // 1. change background 去背景，把背景变成黑色 通过遍历每个像素
    for (int row = 0; row < src.rows; row++) 
    {
        for (int col = 0; col < src.cols; col++)
        {
            if (src.at<Vec3b>(row, col) == Vec3b(255, 255, 255))
            {
                src.at<Vec3b>(row, col)[0] = 0;
                src.at<Vec3b>(row, col)[1] = 0;
                src.at<Vec3b>(row, col)[2] = 0;
            }
        }
    }
    imshow("black background", src);
 
    
    // 2.sharpen 锐化 通过拉普拉斯得到拉普拉斯得到了它的边缘，然后用原图减去这些边缘的话它们之间的差值就更大了，
    //然后这些图像得到了锐化，为我们下一步做图像的二值变换做准备的，把锐化的结果转到8uc3上面显示出来
    Mat kernel = (Mat_<float>(3, 3) << 1, 1, 1, 1, -8, 1, 1, 1, 1);
    Mat imgLaplance; //拉普拉斯结果
    Mat sharpenImg = src;
    //      图像的深度： CV_32F，拉普拉斯会计算浮点数，浮点数它有正值有负值有可能超过0-255的范围
    filter2D(src, imgLaplance, CV_32F, kernel, Point(-1, -1), 0, BORDER_DEFAULT);
    src.convertTo(sharpenImg, CV_32F);
    Mat resultImg = sharpenImg - imgLaplance; 
    resultImg.convertTo(resultImg, CV_8UC3);
    imgLaplance.convertTo(imgLaplance, CV_8UC3);
    imshow("sharpen image", resultImg);
   
    src = resultImg; // copy back
 
    
    // convert to binary 转换成二值图像，然后对二值图像进行距离变换，距离变换之后我们要normalizetion把它变成一个0-1的一个图像
    Mat binaryImg; //定义一个二值图像
    cvtColor(src, resultImg, CV_BGR2GRAY); //从src获取二值图像，然后对二值图像进行距离变换
    threshold(resultImg, binaryImg, 40, 255, THRESH_BINARY | THRESH_OTSU);//不知道阈值是什么，所以寻找自动阈值会更准确一点
    imshow("binary image", binaryImg);
   
    //二值图形之后就要进行一个距离变换
    Mat distImg;
    distanceTransform(binaryImg, distImg, DIST_L1, 3, 5);
    normalize(distImg, distImg, 0, 1, NORM_MINMAX);
    imshow("distance result", distImg);
   
    // binary again 对距离变换之后的结果进行一个二值化
    threshold(distImg, distImg, 0.4, 1, THRESH_BINARY); //0.4即距离要大于某一个定数
    imshow("distance binary image", distImg);
    
    //通过二值的腐蚀把它变成一个一个分离出来，那个全连在一起了我们不需要，给它一个结构元素去腐蚀它
    Mat k1 = Mat::ones(13, 13, CV_8UC1); //结构元素
    erode(distImg, distImg, k1, Point(-1, -1));
    
    
    // markers 找它那个markers，就是一个一个把它标记，因为现在全部是一样的，那么给它编号12345，这个小
    //山头是12345，在编号之前进行一步处理就是说首先变成8位的图像然后findContours找到它的轮廓，然后create
    //一个maskers的图片，就是这些轮廓画到这个图片之上，
    //进行一个标记，然后再进行一个分水岭的变换，最后进行一个着色
    Mat dist_8u;
    distImg.convertTo(dist_8u, CV_8U);
    vector<vector<Point>> contours;
    findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE, Point(0, 0)); //根据findContours找到小山头
     
    // create makers
    Mat markers = Mat::zeros(src.size(), CV_32SC1);
    for (size_t i = 0; i < contours.size(); i++) 
    {          //         static_cast强制类型转换 画第i个contours   计数从0开始，0是背景，所以加1 最后一个-1代表填充
        drawContours(markers, contours, static_cast<int>(i), Scalar::all(static_cast<int>(i) + 1), -1); //对每一个它标记一个小山头，给它每一个不同的颜色
    }
    circle(markers, Point(5, 5), 3, Scalar(255, 255, 255), -1);
    imshow("my markers", markers*1000); //marker灰度级别很低，所以要乘1000，不然显示出来会感觉什么都没有
 
    
    // perform watershed，分水岭变换
    watershed(src, markers); //sharps之后的src，根据markers就是我们找到的那些山头，结果就输入到markers里面去了
    
    Mat mark = Mat::zeros(markers.size(), CV_8UC1); 
    markers.convertTo(mark, CV_8UC1); //把markers放到mark里面去
    bitwise_not(mark, mark, Mat()); //  取反
    imshow("watershed image", mark);
 
    // generate random color 把里面的值赋予随机的颜色，根据contours，轮廓有多少个我们就分配多少个
    //那个轮廓是距离变换之后通过形态学把它处理成一个一个单个点，然后把它放到这边去了
    vector<Vec3b> colors; 
    for (size_t i = 0; i < contours.size(); i++)
    {
        int r = theRNG().uniform(0, 255); //自带的函数 theRNG
        int g = theRNG().uniform(0, 255);
        int b = theRNG().uniform(0, 255);
        colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
    }
 
    // fill with color and display final result 
    Mat dst = Mat::zeros(markers.size(), CV_8UC3);
    for (int row = 0; row < markers.rows; row++) 
    {
        for (int col = 0; col < markers.cols; col++)
        {
            int index = markers.at<int>(row, col); //再从markers里面取值
            if (index > 0 && index <= static_cast<int>(contours.size())) 
            {
                dst.at<Vec3b>(row, col) = colors[index - 1]; //上面加1
            }
            else
            {
                dst.at<Vec3b>(row, col) = Vec3b(0, 0, 0);
            }
        }
    }
    imshow("Final Result", dst);
 
    waitKey(0);
    return 0;
}