找到一个最大的轮廓（四边形）

图片中有很多四边形和数字，我想只找到一个最大的四边形（或较大的），并得到他的顶点，然后进行透视变换，将图片变正，这是今天的程序暂存，目前对于一些函数还是不是很熟悉，明天再说。（在 drawContours(drawing, hull[hull_flag], i, color, 3);这里报错：
最大数为:41596.000000OpenCV Error: Assertion failed (0 <= contourIdx && contourIdx < (int)last) in cv::drawContours, file D:\opencv\opencv-3.3.0\modules\imgproc\src\drawing.cpp, line 2495
）

//透视变换，检测四边形，有时候容易检测不出
//但目前效果最好的就是该程序

#include "core/core.hpp"  
#include <opencv2/imgproc/imgproc.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <iostream>  
#include <set>
#include <opencv.hpp>  
#include <iostream>  
#include<time.h>

using namespace cv;
using namespace std;

RNG rng(12345);

float* num;

cv::Point2f center(0, 0);

//求四个顶点的坐标 
// 类函数，Point2f为一个类对象
cv::Point2f computeIntersect(cv::Vec4i a, cv::Vec4i b)
{
    int x1 = a[0], y1 = a[1], x2 = a[2], y2 = a[3], x3 = b[0], y3 = b[1], x4 = b[2], y4 = b[3];

    if (float d = ((float)(x1 - x2)*(y3 - y4) - (y1 - y2)*(x3 - x4)))
    {
        cv::Point2f pt;
        pt.x = ((x1*y2 - y1 * x2)*(x3 - x4) - (x1 - x2)*(x3*y4 - y3 * x4)) / d;
        pt.y = ((x1*y2 - y1 * x2)*(y3 - y4) - (y1 - y2)*(x3*y4 - y3 * x4)) / d;
        return pt;
    }
    else
        return cv::Point2f(-1, -1);
}
//确定四个点的中心线
void sortCorners(std::vector<cv::Point2f>& corners, cv::Point2f center)
{
    std::vector<cv::Point2f> top, bot;

    for (unsigned int i = 0; i< corners.size(); i++)
    {
        if (corners[i].y<center.y)
        {
            top.push_back(corners[i]);
        }
        else
        {
            bot.push_back(corners[i]);
        }
    }

    cv::Point2f tl = top[0].x > top[1].x ? top[1] : top[0];
    cv::Point2f tr = top[0].x > top[1].x ? top[0] : top[1];
    cv::Point2f bl = bot[0].x > bot[1].x ? bot[1] : bot[0];
    cv::Point2f br = bot[0].x > bot[1].x ? bot[0] : bot[1];

    corners.clear();
    //注意以下存放顺序是顺时针，当时这里出错了，如果想任意顺序下文开辟的四边形矩阵注意对应  
    corners.push_back(tl);
    corners.push_back(tr);
    corners.push_back(br);
    corners.push_back(bl);

}







// 算法流程：先彩色转灰度，然后模糊求canny边缘，再用hough检测直线，
// 求出四线交点，利用opencv自带的求透视矩阵的函数求出透视矩阵，
// 然后利用透视矩阵转换源图像所需的四边形，效果图后续见图片：

int main()
{
    //cv::Mat src = cv::imread("4.jpg");
    //if (src.empty())
    //{
    //  return -1;
    //}

    //cv::Mat bw;
    彩色转灰度
    //cv::cvtColor(src, bw, CV_BGR2GRAY);

    //cv::namedWindow("gray_src", 0);
    //imshow("gray_src", bw);

    模糊
    //cv::blur(bw, bw, cv::Size(3, 3));

    //cv::namedWindow("blur", 0);
    //imshow("blur", bw);

    边缘检测
    //cv::Canny(bw, bw, 100, 100, 3);

    //cv::namedWindow("cannyblur", 0);
    //imshow("cannyblur", bw);

 /***********************寻找轮廓*****************************************************************************************/
    int hull_flag;//用于找最大面积那个凸包（矩形度后）

    Mat srcImage = Mat::zeros(600, 800, CV_8UC3);
    Mat srcImage0 = imread("2.jpg", 0);
    resize(srcImage0, srcImage, srcImage.size());
    srcImage = srcImage > 200;//二值化
    Mat element = getStructuringElement(MORPH_RECT, Size(5, 5));
    morphologyEx(srcImage, srcImage, MORPH_CLOSE, element);//闭运算滤波

    imshow("闭运算", srcImage);

    vector<vector<Point>> contours;
    findContours(srcImage, contours, CV_RETR_LIST, CV_CHAIN_APPROX_NONE);//找轮廓
    vector<vector<Point>> hull(contours.size());//用于存放凸包
    Mat drawing(srcImage.size(), CV_8UC1, cv::Scalar(0));
    int i = 0;
    vector<float> length(contours.size());
    vector<float> Area_contours(contours.size()), Area_hull(contours.size()), Area_ratio(contours.size());
    float max = 0.0;
    for (i = 0; i < contours.size(); i++)
    {      //把所有的轮廓画出来

        length[i] = arcLength(contours[i], true);
        if (length[i] >200 && length[i] <2000)
        {//滤除小轮廓
            convexHull(Mat(contours[i]), hull[i], false);//把凸包找出来
            Area_contours[i] = contourArea(contours[i]);//轮廓面积

            Area_hull[i] = contourArea(hull[i]); //最小外接矩形面积，这里用的凸包
            Area_ratio[i] = Area_contours[i] / Area_hull[i];//矩形度

        }
    }

    for (i = 0; i < contours.size(); i++)
    {
        if (Area_ratio[i]>0.9)
        {
            //drawContours(drawing, contours, i, Scalar(255, 255, 255), 1);

            if (max < Area_hull[i])
            {
                max = Area_hull[i];
                hull_flag = i;
            }
        }
    }
    printf("\n最大数为:%f", max);
    Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
    drawContours(drawing, hull[hull_flag], i, color, 3);


    imshow("轮廓", drawing);
/******************************************************************************************/






    //hough检测直线
    std::vector<cv::Vec4i> lines;
    cv::HoughLinesP(drawing, lines, 1, CV_PI / 180, 70, 30, 10);
    //1像素分辨能力  1度的角度分辨能力        >70可以检测成连线       30是最小线长  
    //在直线L上的点（且点与点之间距离小于maxLineGap=10的）连成线段，然后这些点全部删除，并且记录该线段的参数，就是起始点和终止点  



    needed for visualization only//这里是将检测的线调整到延长至全屏，即射线的效果，其实可以不必这么做  
    //for (unsigned int i = 0; i<lines.size(); i++)
    //{
    //  cv::Vec4i v = lines[i];
    //  lines[i][0] = 0;
    //  lines[i][1] = ((float)v[1] - v[3]) / (v[0] - v[2])* -v[0] + v[1];
    //  lines[i][2] = srcImage.cols;
    //  lines[i][3] = ((float)v[1] - v[3]) / (v[0] - v[2])*(srcImage.cols - v[2]) + v[3];

    //}

    std::vector<cv::Point2f> corners;//线的交点存储  
    for (unsigned int i = 0; i<lines.size(); i++)
    {
        for (unsigned int j = i + 1; j<lines.size(); j++)
        {
            cv::Point2f pt = computeIntersect(lines[i], lines[j]);
            if (pt.x >= 0 && pt.y >= 0)
            {
                corners.push_back(pt);
            }
        }
    }

    std::vector<cv::Point2f> approx;
    cv::approxPolyDP(cv::Mat(corners), approx, cv::arcLength(cv::Mat(corners), true)*0.02, true);


    //检测是否是四边形，很多图片检测不到
    //if (approx.size() != 4)
    //{
    //  std::cout << "The object is not quadrilateral（四边形）!" << std::endl;
    //  return -1;
    //}

    //get mass center  
    for (unsigned int i = 0; i < corners.size(); i++)
    {
        center += corners[i];
    }
    center *= (1. / corners.size());

    sortCorners(corners, center);//确定四个点的中心线

    cv::Mat dst = srcImage.clone();

    //Draw Lines  
    for (unsigned int i = 0; i<lines.size(); i++)
    {
        cv::Vec4i v = lines[i];
        cv::line(dst, cv::Point(v[0], v[1]), cv::Point(v[2], v[3]), CV_RGB(0, 255, 0));    //目标版块画绿线   
    }

    //draw corner points  
    cv::circle(dst, corners[0], 3, CV_RGB(255, 0, 0), 2);
    cv::circle(dst, corners[1], 3, CV_RGB(0, 255, 0), 2);
    cv::circle(dst, corners[2], 3, CV_RGB(0, 0, 255), 2);
    cv::circle(dst, corners[3], 3, CV_RGB(255, 255, 255), 2);

    //draw mass center  集合中心
    cv::circle(dst, center, 3, CV_RGB(255, 255, 0), 2);

    cv::Mat quad = cv::Mat::zeros(600, 800, CV_8UC3);//设定校正过的图片从320*240变为300*220  

    //corners of the destination image  
    std::vector<cv::Point2f> quad_pts;
    quad_pts.push_back(cv::Point2f(0, 0));
    quad_pts.push_back(cv::Point2f(quad.cols, 0));//(220,0)  
    quad_pts.push_back(cv::Point2f(quad.cols, quad.rows));//(220,300)  
    quad_pts.push_back(cv::Point2f(0, quad.rows));

    // Get transformation matrix  
    cv::Mat transmtx = cv::getPerspectiveTransform(corners, quad_pts);   //求源坐标系（已畸变的）与目标坐标系的转换矩阵  

    // Apply perspective transformation透视转换  
    cv::warpPerspective(srcImage, quad, transmtx, quad.size());

    /*cv::namedWindow("src", 0);
    cv::imshow("src", src);

    cv::namedWindow("image", 0);
    cv::imshow("image", dst);*/

    cv::namedWindow("透视变换后", 0);
    cv::imshow("透视变换后", quad);

    cv::waitKey();
    return 0;
}