《图像处理实例》 之 精确寻找一个圆

以下是素材照片，就是寻找中间那个圆就可以了，说起来很简单，做起来不那么容易：

代码很简单，主要是预处理，下面会基体说明！

 处理过程的例子：

处理结果：

---

首先说明一下怎么寻找一个圆？（本来都忘记这篇博文没写完了，还是一个同志发邮件给我才想起来）

A.寻找圆的大方向

预处理好的话，下面哪种方法都可以得到精确的圆！

1.霍夫圆检测

　　  小伙伴们是不是有这种感觉，刚开始用霍夫的时候很兴奋，调调参数就能找到圆，但是随着你要求找的圆越来越复杂，是不是发现霍夫没用了？

　　真的不是霍夫没用了，是你预处理没做好，看看霍夫的原理（极坐标的转换方式，我另一篇博文有说http://www.cnblogs.com/wjy-lulu/p/6677280.html）

　　一句话你处理的越好检测的就越好！！

2.拟合圆

　　利用圆的函数去拟合，当然这里分为两种方案：

　　　　　　a.点在圆的边缘，这个需要圆的函数拟合。

　　　　　　b.点在圆内，这个需要圆的面积+函数拟合。

3.最小外接圆

　　注意这不是和方法2相同！！这个方法是找到一个圆然后使得圆面积最小且包含所有点，算法实现应该有很多了，我个人认为用k-means寻找质心然后再找最小圆。

4.分水岭算法

　　这个方法在另一篇博文实现，不在阐述：http://www.cnblogs.com/wjy-lulu/p/7056466.html

B.预处理

--------->>>>>感觉没多大意义，貌似任何算法的基础都是预处理，具体问题具体对待

---

 

上代码：

 （代码写到一半就没写了，原因不想说了，后面也不想改进了，其实针对具体问题还有很多改进的地方，精确寻找圆不是很困难的事）

#include<iostream>
#include <opencv2/opencv.hpp>
#include <math.h>
using namespace cv;
using namespace std;

int Threshold_Value = 176;
const int Threshold_Max_value = 255;
const int Threshold_type_value = 3;

Mat input_image, threshold_image, output_image, Middle_image;

void Threshold_Image_Bar(int, void *);

int main(int argc, char**argv)
{
    input_image = imread("b.jpg");
    if (input_image.data == NULL) {
        return -1; cout << "can't open image.../";
    }
    imshow("Sourse Image", input_image);
    blur(input_image, Middle_image, Size(3, 3), Point(-1, -1), 4);
    cvtColor(Middle_image, Middle_image, COLOR_RGB2GRAY);
    const float init_pointx =  saturate_cast<float>(Middle_image.cols / 7);
    const float init_pointy =  saturate_cast<float>(Middle_image.rows / 7);
    Rect roi_rect = Rect(Point2f(2 * init_pointx, 2 * init_pointy), Point2f(6 * init_pointx, 6 * init_pointy));
    Mat  roi_Image = Middle_image(roi_rect);
    Middle_image = roi_Image;
    threshold(Middle_image, threshold_image, 0, 255, THRESH_BINARY_INV | THRESH_OTSU);
    Mat kernel_rect   = getStructuringElement(MORPH_ELLIPSE, Size(30, 30), Point(-1, -1));
    Mat kernel_circle = getStructuringElement(MORPH_ELLIPSE, Size(10, 10), Point(-1, -1));
    morphologyEx(threshold_image, threshold_image, MORPH_CLOSE, kernel_circle);
    Mat RedImage = threshold_image.clone();
    morphologyEx(RedImage, threshold_image, MORPH_OPEN, kernel_rect);
    for (size_t i = 0; i < threshold_image.rows; i++)
    {
        for (size_t j = 0; j < threshold_image.cols; j++)
        {
            RedImage.at<uchar>(i, j) = saturate_cast<uchar>(RedImage.at<uchar>(i, j) - threshold_image.at<uchar>(i, j));
        }
    }
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    Mat showImage = Mat::zeros(RedImage.size(), CV_8UC1);
    findContours(RedImage, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(-1, -1));
    for (size_t i = 0; i < contours.size(); i++)
    {
        if (minAreaRect(contours[i]).size.area() > 10000 && minAreaRect(contours[i]).size.height > 80 && minAreaRect(contours[i]).size.width > 80)//这个参数大概就可以
        {
            drawContours(showImage, contours, static_cast<int>(i), Scalar(255, 255, 255), 1);
        }
    }
    vector<Point> points;
    for (int i = 0; i < showImage.rows; i++)
    {
        for (int j = 0; j < showImage.cols; j++)
        {
            if (showImage.at<uchar>(i, j) == 255)
            {
                points.push_back(Point(j, i));
            }
        }
    }
    Point2f center;
    float radius;
    if (points.data() == 0)
    {
        printf("Don't detecte point");
        return -1;
    }
    minEnclosingCircle(points, center, radius);
    center.x += 2 * init_pointx;
    center.y += 2 * init_pointy;
    Mat result = Mat::zeros(RedImage.size(), CV_8UC3);
    circle(input_image, center, radius, Scalar(0, 0, 255), 2);
    waitKey(0);
    return 0;
}
void Threshold_Image_Bar(int, void *)
{
    threshold(Middle_image, threshold_image, 65, 255,THRESH_BINARY_INV);//110,65
    imshow("Threshold Image", threshold_image);
    Mat kernel = getStructuringElement(MORPH_RECT, Size(50, 50), Point(-1, -1));
    Mat RedImage = threshold_image.clone();
    morphologyEx(RedImage, threshold_image, MORPH_OPEN, kernel);
    for (size_t i = 0; i < threshold_image.rows; i++)
    {
        for (size_t j = 0; j < threshold_image.cols; j++)
        {
            RedImage.at<uchar>(i, j) = saturate_cast<uchar>(RedImage.at<uchar>(i, j) - threshold_image.at<uchar>(i, j));
        }
    }
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    Mat showImage = Mat::zeros(RedImage.size(), CV_8UC1);
    findContours(RedImage, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(-1, -1));
    for (size_t i = 0; i < contours.size(); i++)
    {
        if (boundingRect(contours[i]).area() > 20000)
        {
            drawContours(showImage, contours, static_cast<int>(i), Scalar(255, 255, 255), 1);
        }
    }
    vector<Point> points;
    for (int i = 0; i < showImage.rows; i++)
    {
        for (int j = 0; j < showImage.cols; j++)
        {
            if (showImage.at<uchar>(i, j) == 255)
            {
                points.push_back(Point(j, i));
            }
        }
    }
    Point2f center;
    float radius;
    minEnclosingCircle(points, center, radius);
    Mat result = Mat::zeros(RedImage.size(), CV_8UC3);
    circle(input_image, center, radius, Scalar(0, 0, 255), 2);
}