《图像处理实例》 之 透视变换

目的：将以下的图片转正显示

opencv自带的函数“透视变换”，但是有一点，四个交点的值我们是不知道的，有几种办法：

　　　　　　　　　　　　　　　　　　1.直接用鼠标去Image watch去查看四个交点的值。

　　　　　　　　　　　　　　　　　　2.用角点检测算法。。。我现在还没学到。

　　　　　　　　　　　　　　　　　　3.使用数学知识，求四条直线然后进行求取。

第一种很简单，分分钟实现了。第二种等以后学到再用。本文主要介绍第三种。

第一种方法实现：

Point p1; // 左上角
    p1.x = 13;
    p1.y = 65;
    Point p2; // 右上角
    p2.x = 474;
    p2.y = 58;
    Point p3; // 左下角
    p3.x = 48;
    p3.y = 310;
    Point p4; // 右下角
    p4.x = 461;
    p4.y = 317;

    // 透视变换
    vector<Point2f> src_corners(4);
    src_corners[0] = p1;
    src_corners[1] = p2;
    src_corners[2] = p3;
    src_corners[3] = p4;
    int width, height;
    width = SourseImage.cols;
    height = SourseImage.rows;

    vector<Point2f> dst_corners(4);
    dst_corners[0] = Point(0, 0);
    dst_corners[1] = Point(width, 0);
    dst_corners[2] = Point(0, height);
    dst_corners[3] = Point(width, height);

    // 获取透视变换矩阵
    Mat warpmatrix = getPerspectiveTransform(src_corners, dst_corners);
    warpPerspective(SourseImage, OutputImage, warpmatrix, SourseImage.size(), INTER_LINEAR);
    imshow("123", SourseImage);

 效果图如下：就是手工输入有点牵强~~

第三种方法实现：

                             高斯滤波-->>灰度-->>二值化

形态学计算-->>反转

边缘检测：

 

 直线检测：（这个参数得适当的调整，不然效果很差）

 

数学方法求直线交点：

透视变换：

 

 代码：

int main(int argc, char** argv)
{
    SourseImage = imread("1.png");
    if (SourseImage.empty()) return -1;
    imshow("sourse", SourseImage);
    //-------------------预处理----------------------//
    GaussianBlur(SourseImage, MiddleImage, Size(3, 3), 3, 3);
    cvtColor(MiddleImage, MiddleImage, CV_BGR2GRAY);
    threshold(MiddleImage, MiddleImage, 0, 255, THRESH_BINARY | THRESH_OTSU);
    imshow("threImage", MiddleImage);
    //-------------------形态学操作-----------------//
    Mat kernel = getStructuringElement(MORPH_RECT, Size(27, 27));
    morphologyEx(MiddleImage, MiddleImage, MORPH_OPEN, kernel);
    morphologyEx(MiddleImage, MiddleImage, MORPH_OPEN, kernel);
    bitwise_not(MiddleImage, MiddleImage, Mat());
    imshow("morphology", MiddleImage);
    //----------------------边缘检测-----------------------------//
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    Mat testImage = Mat::zeros(MiddleImage.size(), MiddleImage.type());
    findContours(MiddleImage, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE);
    for (size_t i = 0; i < contours.size(); i++)
    {
        drawContours(testImage, contours, i, Scalar(255, 255, 255), 1);
    }
    imshow("contours", testImage);

    int width = SourseImage.cols;
    int height = SourseImage.rows;
    //--------------------------霍夫直线检测------------------------//
    vector<Vec4i> lines;
    int accu = min(width*0.3, height*0.3);
    HoughLinesP(testImage, lines, 1, CV_PI / 360, accu, accu, 40);//参数最好用图片的长宽变换来的，容易移植
    Mat lineImage = Mat::zeros(MiddleImage.size(), MiddleImage.type());
    for (size_t i = 0; i < lines.size(); i++)
    {
        line(lineImage, Point(lines[i][0], lines[i][1]), Point(lines[i][2], lines[i][3]), Scalar(255, 255, 255), 1, 8, 0);
    }
    imshow("lines", lineImage);
    //-----------------查找线段对应的矩形边界------------------//
    Vec4i topline, bottomline, leftline, rightline;
    for (size_t i = 0; i < lines.size(); i++)
    {
        double roti = abs(lines[i][3] - lines[i][1]);
        //判断是平行X轴还是平行Y轴-->>|y2-y1|
        if (roti < SourseImage.cols / 3)//平行X轴（上下两条边）
        {
            if (lines[i][1] < SourseImage.rows / 2 && lines[i][3] < SourseImage.rows / 2) topline = lines[i];
            else bottomline = lines[i];
        }
        else//左右两条边
        {
            if (lines[i][0] < SourseImage.cols / 2 && lines[i][2] < SourseImage.cols / 2) leftline = lines[i];
            else rightline = lines[i];
        }
    }
    //--------------------计算四条线段的交点-----------------------//
    double b_top, b_bot, b_rit, b_lef;
    double k_top, k_bot, k_rit, k_lef;
    Point lef_top, rit_top, lef_bot, rit_bot;
    //直线斜率
    k_top = (topline[3] - topline[1]) / (topline[2] - topline[0]);
    k_bot = (bottomline[3] - bottomline[1]) / (bottomline[2] - bottomline[0]);
    k_rit = (rightline[3] - rightline[1]) / (rightline[2] - rightline[0]);
    k_lef = (leftline[3] - leftline[1]) / (leftline[2] - leftline[0]);
    //直线表达式因子，推到一遍就知道了
    b_top = topline[3] - k_top*topline[2];
    b_bot = bottomline[3] - k_bot*bottomline[2];
    b_rit = rightline[3] - k_rit*rightline[2];
    b_lef = leftline[3] - k_lef*leftline[2];
    //计算交点值
    lef_top.x = abs((b_top - b_lef) / (k_top - k_lef));
    rit_top.x = abs((b_top - b_rit) / (k_top - k_rit));
    lef_bot.x = abs((b_bot - b_lef) / (k_bot - k_lef));
    rit_bot.x = abs((b_bot - b_rit) / (k_bot - k_rit));

    lef_top.y = abs(k_top*lef_top.x + b_top);
    rit_top.y = abs(k_top*rit_top.x + b_top);
    lef_bot.y = abs(k_bot*lef_bot.x + b_bot);
    rit_bot.y = abs(k_bot*rit_bot.x + b_bot);
    //画出交点
    Mat lastImage = Mat::zeros(MiddleImage.size(), CV_8UC3);
    circle(lastImage, lef_top, 5, Scalar(0, 0, 255));
    circle(lastImage, rit_top, 5, Scalar(0, 0, 255));
    circle(lastImage, lef_bot, 5, Scalar(0, 0, 255));
    circle(lastImage, rit_bot, 5, Scalar(0, 0, 255));
    imshow("circle", lastImage);
    //-------------------------透视变换------------------------//
    //存储需要变换的四点
    vector<Point2f> srcPoint(4), dstPoint(4);
    srcPoint[0] = lef_top;
    srcPoint[1] = rit_top;
    srcPoint[2] = lef_bot;
    srcPoint[3] = rit_bot;

    dstPoint[0] = Point2f(0, 0);
    dstPoint[1] = Point2f(SourseImage.cols, 0);
    dstPoint[2] = Point2f(0, SourseImage.rows);
    dstPoint[3] = Point2f(SourseImage.cols, SourseImage.rows);

    Mat Change = getPerspectiveTransform(srcPoint,dstPoint);
    warpPerspective(SourseImage, OutputImage, Change, OutputImage.size());
    imshow("test",OutputImage);
    waitKey(0);
    return 0;
}

其实那个阈值化也可以自己手动去调节：

g_Value =95；

void on_AdaptThreshold(int, void*)
{
　　int k = 2 * g_Value + 1;
　　adaptiveThreshold(MiddleImage, OutputImage, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, k, 0);
　　imshow("AdaptThreshold", OutputImage);
}

 

 

参考：贾志刚opencv系列