图像分割与边缘检测

OTSU

#include 
#include 
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/opencv.hpp"
using namespace std;
using namespace cv;

// OTSU函数实现
int OTSU(cv::Mat srcImage)
{
    int nCols = srcImage.cols;
    int nRows = srcImage.rows;
    int threshold = 0;
    // 初始化统计参数
    int nSumPix[256];
    float nProDis[256];
    for (int i = 0; i < 256; i++)
    {
        nSumPix[i] = 0;
        nProDis[i] = 0;
    }
    // 统计灰度级中每个像素在整幅图像中的个数
    for (int i = 0; i < nCols; i++)
    {
        for (int j = 0; j < nRows; j++)
        {
            nSumPix[(int)srcImage.at(i, j)]++;
        }
    }
    // 计算每个灰度级占图像中的概率分布
    for (int i = 0; i < 256; i++)
    {
        nProDis[i] = (float)nSumPix[i] / (nCols * nRows);
    }
    // 遍历灰度级[0,255],计算出最大类间方差下的阈值
    float w0, w1, u0_temp, u1_temp, u0, u1, delta_temp;
    double delta_max = 0.0;
    for (int i = 0; i < 256; i++)
    {
        // 初始化相关参数
        w0 = w1 = u0_temp = u1_temp = u0 = u1 = delta_temp = 0;
        for (int j = 0; j < 256; j++)
        {
            //背景部分
            if (j <= i)
            {
                // 当前i为分割阈值，第一类总的概率
                w0 += nProDis[j];
                u0_temp += j * nProDis[j];
            }
            //前景部分
            else
            {
                // 当前i为分割阈值，第一类总的概率
                w1 += nProDis[j];
                u1_temp += j * nProDis[j];
            }
        }
        // 分别计算各类的平均灰度
        u0 = u0_temp / w0;
        u1 = u1_temp / w1;
        delta_temp = (float)(w0 *w1* pow((u0 - u1), 2));
        // 依次找到最大类间方差下的阈值
        if (delta_temp > delta_max)
        {
            delta_max = delta_temp;
            threshold = i;
        }
    }
    return threshold;
}

int main()
{
    // 图像读取及判断
    cv::Mat srcImage = cv::imread("images/hand1.jpg");
    if (!srcImage.data)
        return 1;
    // 灰度转换
    cv::Mat srcGray;
    cv::cvtColor(srcImage, srcGray, CV_RGB2GRAY);
    cv::imshow("srcGray", srcGray);
    // 调用OTSU二值化算法得到阈值
    int  ostuThreshold = OTSU(srcGray);
    std::cout << ostuThreshold << std::endl;
    // 定义输出结果图像
    cv::Mat otsuResultImage =
        cv::Mat::zeros(srcGray.rows, srcGray.cols, CV_8UC1);
    // 利用得到的阈值实现二值化操作
    for (int i = 0; i < srcGray.rows; i++)
    {
        for (int j = 0; j < srcGray.cols; j++)
        {
            // 满足大于阈值ostuThreshold置255
            if (srcGray.at(i, j) > ostuThreshold)
                otsuResultImage.at(i, j) = 255;
            else
                otsuResultImage.at(i, j) = 0;
        }
    }
    cv::imshow("otsuResultImage", otsuResultImage);
    cv::waitKey(0);
    return 0;
}

霍夫变换

#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include 
using namespace cv;
using namespace std;

int main( )
{
  cv::Mat srcImage =
      cv::imread("images/Pic3_3.png", 0);
  if (!srcImage.data)
       return -1;
  cv::Mat edgeMat, houghMat;
  // Canny边缘检测 二值图像
  Canny(srcImage, edgeMat, 50, 200, 3);
  cvtColor(edgeMat, houghMat, CV_GRAY2BGR);
  #if 0
  // 标准的霍夫变换
  vector lines;
  HoughLines(edgeMat, lines, 1, CV_PI/180, 100, 0, 0 );
  for( size_t i = 0; i < lines.size(); i++ )
  {
     // 根据直线参数表达式绘制相应检测结果
     float rho = lines[i][0], theta = lines[i][1];
     Point pt1, pt2;
     double a = cos(theta), b = sin(theta);
     double x0 = a*rho, y0 = b*rho;
     pt1.x = cvRound(x0 + 1000*(-b));
     pt1.y = cvRound(y0 + 1000*(a));
     pt2.x = cvRound(x0 - 1000*(-b));
     pt2.y = cvRound(y0 - 1000*(a));
     line( houghMat, pt1, pt2, Scalar(0,0,255), 3, CV_AA);
  }
  #else
  // 统计概率的霍夫变换
  vector lines;
  HoughLinesP(edgeMat, lines, 1, CV_PI/180, 50, 50, 10 );
  for( size_t i = 0; i < lines.size(); i++ )
  {
    Vec4i l = lines[i];
    // 绘制线检测结果
    line( houghMat, Point(l[0], l[1]),
       Point(l[2], l[3]), Scalar(255,255,255), 3, CV_AA);
  }
  #endif
  cv::imshow("srcImage", srcImage);
  cv::imshow("houghMat", houghMat);
  cv::waitKey();
  return 0;
}