samples/cpp/warpPerspective_demo.cpp

此示例程序展示了如何使用 cv::getPerspectiveTransform 和 cv::warpPerspective 进行图像扭曲

 
#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
 
using namespace std;
using namespace cv;
 
static void help(char** argv)
{
    // 打印欢迎消息和 OpenCV 版本
cout << "\n这是一个演示程序，展示了如何将透视变换应用于图像，\n"
         "使用 OpenCV 版本 " << CV_VERSION << endl;
 
cout << "\n用法:\n" << argv[0] << " [image_name -- 默认 right.jpg]\n" << endl;
 
cout << "\n热键:\n"
         "\tESC, q - 退出程序\n"
         "\tr - 更改点的顺序以旋转变换\n"
         "\tc - 删除选定的点\n"
         "\ti - 更改点的顺序以进行逆变换\n"
         "\n使用鼠标选择一个点并移动它以查看变换的变化" << endl;
}
 
static void onMouse(int event, int x, int y, int, void*);
Mat warping(Mat image, Size warped_image_size, vector< Point2f> srcPoints, vector< Point2f> dstPoints);
 
String windowTitle = "透视变换演示";
String labels[4] = { "TL","TR","BR","BL" };
vector< Point2f> roi_corners;
vector< Point2f> midpoints(4);
vector< Point2f> dst_corners(4);
int roiIndex = 0;
bool dragging;
int selected_corner_index = 0;
bool validation_needed = true;
 
int main(int argc, char** argv)
{
help(argv);
    CommandLineParser parser(argc, argv, "{@input| right.jpg |}");
 
    string filename = samples::findFile(parser.get<string>("@input"));
    Mat original_image = imread( filename );
    Mat image;
 
    float original_image_cols = (float)original_image.cols;
    float original_image_rows = (float)original_image.rows;
roi_corners.push_back(Point2f( (float)(original_image_cols / 1.70), (float)(original_image_rows / 4.20) ));
roi_corners.push_back(Point2f( (float)(original_image.cols / 1.15), (float)(original_image.rows / 3.32) ));
roi_corners.push_back(Point2f( (float)(original_image.cols / 1.33), (float)(original_image.rows / 1.10) ));
roi_corners.push_back(Point2f( (float)(original_image.cols / 1.93), (float)(original_image.rows / 1.36) ));
 
    namedWindow(windowTitle, WINDOW_NORMAL);
    namedWindow("扭曲的图像", WINDOW_AUTOSIZE);
    moveWindow("扭曲的图像", 20, 20);
    moveWindow(windowTitle, 330, 20);
 
    setMouseCallback(windowTitle, onMouse, 0);
 
    bool endProgram = false;
    while (!endProgram)
    {
        if ( validation_needed & (roi_corners.size() < 4) )
        {
validation_needed = false;
image = original_image.clone();
 
            for (size_t i = 0; i < roi_corners.size(); ++i)
            {
                circle( image, roi_corners[i], 5, Scalar(0, 255, 0), 3 );
 
                if( i > 0 )
                {
                    line(image, roi_corners[i-1], roi_corners[(i)], Scalar(0, 0, 255), 2);
                    circle(image, roi_corners[i], 5, Scalar(0, 255, 0), 3);
                    putText(image, labels[i].c_str(), roi_corners[i], FONT_HERSHEY_SIMPLEX, 0.8, Scalar(255, 0, 0), 2);
                }
            }
            imshow( windowTitle, image );
        }
 
        if ( validation_needed & ( roi_corners.size() == 4 ))
        {
image = original_image.clone();
            for ( int i = 0; i < 4; ++i )
            {
                line(image, roi_corners[i], roi_corners[(i + 1) % 4], Scalar(0, 0, 255), 2);
                circle(image, roi_corners[i], 5, Scalar(0, 255, 0), 3);
                putText(image, labels[i].c_str(), roi_corners[i], FONT_HERSHEY_SIMPLEX, 0.8, Scalar(255, 0, 0), 2);
            }
 
            imshow( windowTitle, image );
 
midpoints[0] = (roi_corners[0] + roi_corners[1]) / 2;
midpoints[1] = (roi_corners[1] + roi_corners[2]) / 2;
midpoints[2] = (roi_corners[2] + roi_corners[3]) / 2;
midpoints[3] = (roi_corners[3] + roi_corners[0]) / 2;
 
dst_corners[0].x = 0;
dst_corners[0].y = 0;
dst_corners[1].x = (float)norm(midpoints[1] - midpoints[3]);
dst_corners[1].y = 0;
dst_corners[2].x = dst_corners[1].x;
dst_corners[2].y = (float)norm(midpoints[0] - midpoints[2]);
dst_corners[3].x = 0;
dst_corners[3].y = dst_corners[2].y;
 
            Size warped_image_size = Size(cvRound(dst_corners[2].x), cvRound(dst_corners[2].y));
 
            Mat M = getPerspectiveTransform(roi_corners, dst_corners);
 
            Mat warped_image;
            warpPerspective(original_image, warped_image, M, warped_image_size); // 进行透视变换
 
            imshow("扭曲的图像", warped_image);
        }
 
        char c = (char)waitKey( 10 );
 
        if ((c == 'q') | (c == 'Q') | (c == 27))
        {
endProgram = true;
        }
 
        if ((c == 'c') | (c == 'C'))
        {
roi_corners.clear();
        }
 
        if ((c == 'r') | (c == 'R'))
        {
roi_corners.push_back(roi_corners[0]);
roi_corners.erase(roi_corners.begin());
        }
 
        if ((c == 'i') | (c == 'I'))
        {
            swap(roi_corners[0], roi_corners[1]);
            swap(roi_corners[2], roi_corners[3]);
        }
    }
    return 0;
}
 
static void onMouse(int event, int x, int y, int, void*)
{
    // 当左键按下时执行的操作
    if (roi_corners.size() == 4)
    {
        for (int i = 0; i < 4; ++i)
        {
            if ((event == EVENT_LBUTTONDOWN) && ((abs(roi_corners[i].x - x) < 10)) && (abs(roi_corners[i].y - y) < 10))
            {
selected_corner_index = i;
dragging = true;
            }
        }
    }
    else if ( event == EVENT_LBUTTONDOWN )
    {
roi_corners.push_back( Point2f( (float) x, (float) y ) );
validation_needed = true;
    }
 
    // 当左键释放时执行的操作
    if (event == EVENT_LBUTTONUP)
    {
dragging = false;
    }
 
    // 当左键按下且鼠标在窗口内移动时执行的操作
    if ((event == EVENT_MOUSEMOVE) && dragging)
    {
roi_corners[selected_corner_index].x = (float) x;
roi_corners[selected_corner_index].y = (float) y;
validation_needed = true;
    }
}