[OpenCV]自动计算坐标进行透视变换矫正

最新推荐文章于 2024-04-28 09:36:30 发布
最新推荐文章于 2024-04-28 09:36:30 发布
阅读量1k 收藏 2
点赞数
文章标签： 人工智能 python c#
原文链接：http://www.cnblogs.com/lx17746071609/p/11103205.html
版权

　　

头文件：DegreeTransform.h
//
// Created by leoxae on 19-6-24.
//

#ifndef OPENCVDEMO_DEGREETRANSFORM_H
#define OPENCVDEMO_DEGREETRANSFORM_H

#include <opencv2/opencv.hpp>
#include <iostream>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/imgproc.hpp>

using namespace std;
using namespace cv;


class DegreeTransform{

public:

    static bool sort_corners(std::vector<cv::Point2f>& corners) ;

    static Point2f computeIntersect(cv::Vec4i a, cv::Vec4i b) ;

    static bool IsBadLine(int a, int b) ;

    static bool x_sort(const Point2f & m1, const Point2f & m2) ;

    static void sortCorners(std::vector<cv::Point2f>& corners,
                     cv::Point2f center) ;

    static void CalcDstSize(const vector<cv::Point2f>& corners) ;


public:
    static int correct(Mat src) ; //string path
};

#endif //OPENCVDEMO_DEGREETRANSFORM_H

 

源码文件：DegreeTransform.cpp
//
// Created by leoxae on 19-6-24.
//

#include "DegreeTransform.h"
cv::Point2f center(0, 0);
/**
 * 角点坐标计算及其排序
 * @param corners
 * @return
 */
bool DegreeTransform::sort_corners(std::vector<cv::Point2f>& corners)
{
    std::vector<cv::Point2f> top, bot;
    cv::Point2f tmp_pt;
    std::vector<cv::Point2f> olddata = corners;

    if (corners.size() != 4)
    {
        return false;
    }

    for (size_t i = 0; i < corners.size(); i++)
    {
        for (size_t j = i + 1; j<corners.size(); j++)
        {
            if (corners[i].y < corners[j].y)
            {
                tmp_pt = corners[i];
                corners[i] = corners[j];
                corners[j] = tmp_pt;
            }
        }
    }
    top.push_back(corners[0]);
    top.push_back(corners[1]);
    bot.push_back(corners[2]);
    bot.push_back(corners[3]);
    if (top.size() == 2 && bot.size() == 2) {
        corners.clear();
        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.push_back(tl);
        corners.push_back(tr);
        corners.push_back(br);
        corners.push_back(bl);
        return true;
    }
    else
    {
        corners = olddata;
        return false;
    }
}

/**
 * 计算相交
 * @param a
 * @param b
 * @return
 */
cv::Point2f DegreeTransform::computeIntersect(cv::Vec4i a, cv::Vec4i b)
{
    int x1 = a[0], y1 = a[1], x2 = a[2], y2 = a[3];
    int 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);
}


/**
 * 判断检测的线段是否找错
 * @param a
 * @param b
 * @return
 */
bool DegreeTransform::IsBadLine(int a, int b)
{
    if (a * a + b * b < 100)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//子排序
bool DegreeTransform::x_sort(const Point2f & m1, const Point2f & m2)
{
    return m1.x > m2.x; //return m1.x < m2.x;
}

/**
 * 确定四个点的中心线
 * @param corners
 * @param center
 */
void DegreeTransform::sortCorners(std::vector<cv::Point2f>& corners,
                 cv::Point2f center)
{
    std::vector<cv::Point2f> top, bot;
    vector<Point2f> backup = corners;

    //先按x的大小给四个点排序
    sort(corners.begin(),corners.end(), x_sort);

    for (int i = 0; i < corners.size(); i++)
    {
        //为了避免三个顶点都在top的情况
        if (corners[i].y < center.y && top.size() < 2)
            top.push_back(corners[i]);
        else
            bot.push_back(corners[i]);
    }
    corners.clear();

    if (top.size() == 2 && bot.size() == 2)
    {
        cout << "log" << endl;
        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.push_back(tl);
        corners.push_back(tr);
        corners.push_back(br);
        corners.push_back(bl);
    }
    else
    {
        corners = backup;
    }
}

int g_dst_hight;  //最终图像的高度
int g_dst_width; //最终图像的宽度
/**
 * 计算效果图尺寸大小
 * @param corners
 */
void DegreeTransform::CalcDstSize(const vector<cv::Point2f>& corners)
{
    int h1 = sqrt((corners[0].x - corners[3].x)*(corners[0].x - corners[3].x) + (corners[0].y - corners[3].y)*(corners[0].y - corners[3].y));
    int h2 = sqrt((corners[1].x - corners[2].x)*(corners[1].x - corners[2].x) + (corners[1].y - corners[2].y)*(corners[1].y - corners[2].y));
    g_dst_hight = MAX(h1, h2);

    int w1 = sqrt((corners[0].x - corners[1].x)*(corners[0].x - corners[1].x) + (corners[0].y - corners[1].y)*(corners[0].y - corners[1].y));
    int w2 = sqrt((corners[2].x - corners[3].x)*(corners[2].x - corners[3].x) + (corners[2].y - corners[3].y)*(corners[2].y - corners[3].y));
    g_dst_width = MAX(w1, w2);
}

int DegreeTransform::correct(Mat src)//string path
{

//    Mat src = imread(path);
    imshow("src img", src);

    ///预处理 二值化+高斯滤波+膨胀+canny边缘提取
    Mat source = src.clone();
    Mat bkup = src.clone();

    ///LUT映射表
//    Mat gray ;
//    cvtColor(src, gray, COLOR_RGB2GRAY);   //二值化
//    imshow("gray", gray);
//
//    uchar lutData[256];
//    for (int i = 0; i<256; i++)
//    {
//        if(i<=100)
//            lutData[i] = 0;
//        if (i > 100 && i <= 200)
//            lutData[i] = 100;
//        if (i > 200)
//            lutData[i] = 255;
//    }
//    Mat lut(1, 256, CV_8UC1, lutData);
//    Mat d_lut;
//
//    namedWindow("anjis", WINDOW_AUTOSIZE);
//    namedWindow("anjis1", WINDOW_AUTOSIZE);
//    imshow("anjis",gray);
//    LUT(gray, lut, d_lut);
//    imshow("anjis1", d_lut);
//
//    Mat canny ;
//    Canny(d_lut,canny,30,90,3) ;
//    imshow("canny",canny) ;


    Mat gray ;
    cvtColor(src, gray, COLOR_RGB2GRAY);   //二值化
//    imshow("gray", gray);

    Mat equal ;
    equalizeHist(gray, equal);
//    imshow("equal", equal);

    Mat gauss ;
    GaussianBlur(equal, gauss, Size(5, 5), 0, 0);  //高斯滤波
    //定义自定义核
    Mat element = getStructuringElement(MORPH_RECT, Size(3, 3)); //MORPH_RECT表示矩形卷积核
    //膨胀操作
    Mat dila ;
    dilate(gauss, dila, element);
//    imshow("dilate", img);
    //边缘提取
    Mat canny ;
    Canny(dila, canny, 30, 120, 3);
    imshow("get contour", canny);


    ///轮廓查找并筛选
    vector<vector<Point>> contours;
    vector<vector<Point>> f_contours;
    std::vector<cv::Point> approx2;
    //查找轮廓，RETR_EXTERNAL只要检索外框
    findContours(canny, f_contours, RETR_EXTERNAL, CHAIN_APPROX_NONE); //������

    //获得面积最大的轮廓
    int max_area = 0;
    int index;

    for (int i = 0; i < f_contours.size(); i++)
    {
        double tmparea = fabs(contourArea(f_contours[i]));
        if (tmparea > max_area)
        {
            index = i;
            max_area = tmparea;
        }
    }


    contours.push_back(f_contours[index]);

    cout << "轮廓数量：" << contours.size() << endl;  //因为是找出最外层轮廓，因此理论上轮廓只有一个

    vector<Point> tmp = contours[0];

    for (int line_type = 1; line_type <= 3; line_type++)
    {
        cout << "line_type: " << line_type << endl;
        Mat black = canny.clone();
        black.setTo(0);
        drawContours(black, contours, 0, Scalar(255), line_type);
        imshow("show contour", black);


        std::vector<Vec4i> lines;
        std::vector<cv::Point2f> corners;
        std::vector<cv::Point2f> approx;
        int para = 10;
        int flag = 0;
        int round = 0;
        for (; para < 300; para++)
        {
            cout << "round: " << ++round << endl;
            lines.clear();
            corners.clear();
            approx.clear();
            center = Point2f(0, 0);

            cv::HoughLinesP(black, lines, 1, CV_PI / 180, para, 30, 10); //gai


            //过滤距离太近的直线
            std::set<int> ErasePt;
            for (int i = 0; i < lines.size(); i++)
            {
                for (int j = i + 1; j < lines.size(); j++)
                {
                    if (IsBadLine(abs(lines[i][0] - lines[j][0]), abs(lines[i][1] - lines[j][1])) && (IsBadLine(abs(lines[i][2] - lines[j][2]), abs(lines[i][3] - lines[j][3]))))
                    {
                        ErasePt.insert(j);//将找错的线加入集合
                    }
                }
            }

            int Num = lines.size();
            while (Num != 0)
            {
                std::set<int>::iterator j = ErasePt.find(Num);
                if (j != ErasePt.end())
                {
                    lines.erase(lines.begin() + Num - 1);
                }
                Num--;
            }
            if (lines.size() != 4)
            {
                continue;
            }

            //计算直线的交点，保存在图像范围内的部分
            for (int i = 0; i < lines.size(); i++)
            {
                for (int j = i + 1; j < lines.size(); j++)
                {
                    cv::Point2f pt = computeIntersect(lines[i], lines[j]);
                    //保证交点在图像的范围之内
                    if (pt.x >= 0 && pt.y >= 0 && pt.x <= src.cols && pt.y <= src.rows)
                        corners.push_back(pt);
                        cout << "pt:" << pt << endl ;
                }
            }
            if (corners.size() != 4)
            {
                continue;
            }
#if 1
            bool IsGoodPoints = true;

            //保证点与点的距离足够大以排除错误点
            for (int i = 0; i < corners.size(); i++)
            {
                for (int j = i + 1; j < corners.size(); j++)
                {
                    int distance = sqrt((corners[i].x - corners[j].x)*(corners[i].x - corners[j].x) + (corners[i].y - corners[j].y)*(corners[i].y - corners[j].y));
                    if (distance < 5)
                    {
                        IsGoodPoints = false;
                    }
                }
            }

            if (!IsGoodPoints) continue;
#endif
            cv::approxPolyDP(cv::Mat(corners), approx, cv::arcLength(cv::Mat(corners), true) * 0.02, true);

            if (lines.size() == 4 && corners.size() == 4 && approx.size() == 4)
            {
                flag = 1;
                break;
            }
        }

        // 取得中心 Get mass center
        for (int i = 0; i < corners.size(); i++)
            center += corners[i];
        center *= (1. / corners.size());

        if (flag)
        {
            cout << "we found it!" << endl;
            cv::circle(bkup, corners[0], 3, CV_RGB(255, 0, 0), -1);
            cv::circle(bkup, corners[1], 3, CV_RGB(0, 255, 0), -1);
            cv::circle(bkup, corners[2], 3, CV_RGB(0, 0, 255), -1);
            cv::circle(bkup, corners[3], 3, CV_RGB(255, 255, 255), -1);
            cv::circle(bkup, center, 3, CV_RGB(255, 0, 255), -1);
            imshow("backup", bkup);
            cout << "corners size" << corners.size() << endl;


             bool sort_flag = sort_corners(corners); //
             if (!sort_flag) cout << "fail to sort" << endl;  //

            sortCorners(corners, center);
            cout << "corners size" << corners.size() << endl;
            cout << "tl:" << corners[0] << endl;
            cout << "tr:" << corners[1] << endl;
            cout << "br:" << corners[2] << endl;
            cout << "bl:" << corners[3] << endl;

            //计算效果图尺寸大小
            CalcDstSize(corners);

            cv::Mat quad = cv::Mat::zeros(g_dst_hight, g_dst_width, CV_8UC3);
            std::vector<cv::Point2f> quad_pts;

            //目的坐标矩阵的构造
            quad_pts.push_back(cv::Point2f(0, 0));
            quad_pts.push_back(cv::Point2f(quad.cols, 0));
            quad_pts.push_back(cv::Point2f(quad.cols, quad.rows));
            quad_pts.push_back(cv::Point2f(0, quad.rows));

            cv::Mat transmtx = cv::getPerspectiveTransform(corners, quad_pts);
            cv::warpPerspective(source, quad, transmtx, quad.size());


            imshow("find", bkup);
            cv::imshow("dst1", quad);

            cv::waitKey(0);
            return 0;
        }
    }
    cout << "can not transform!" << endl;
    waitKey(0);
}

 

主函数：main()

#include "DegreeTransform.h"

using namespace std;
using namespace cv;

#define CLOCKS_PER_SEC ((clock_t)1000)

int main() {
    //计算时间
    clock_t start_time, end_time;
    start_time = clock();

     string path = "/home/leoxae/KeekoRobot/TestPic/编程贴纸/bc12.jpg" ;//home/leoxae/KeekoRobot/TestPic/20190614/大班/内外倾斜/2.jpg
    //home/leoxae/KeekoRobot/TestPic/编程贴纸/bc24.jpg
    Mat src = imread(path) ;
    DegreeTransform::correct(src) ;
    
 　　end_time = clock();
    cout << "运行时间==" << ((end_time - start_time) / CLOCKS_PER_SEC) << "ms" << endl;

    return 0;

 

运行效果图：

                                                          （原图）

                                                       （canny检测）

 

                                           （显示最大矩形轮廓）

 

                                    （在ROI上找到角点坐标并标记）

 

 　　　　                    （效果图）

 

转载于:https://www.cnblogs.com/lx17746071609/p/11103205.html

weixin_30432007
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OpenCV图像几何变换之透视变换
01-01
本文实例为大家分享了OpenCV图像几何变换之透视变换的具体代码，供大家参考，具体内容如下 1. 基本原理  透视变换（Perspective Transformation）的本质是将图像投影到一个新的视平面，其通用变换公式为： （u，v...
opencv 反透视变换矫正畸变
05-04
* 采用的是opencv3.X版本 * 针对不同的图片，需要自己手动修改阈值`g_threshVal, g_threshMax` * 程序是根据[`这一篇博客`](https://blog.csdn.net/rrrfff/article/details/77340641#commentBox)写的，只是自己调通...
OpenCV 实现透视变换
qq_53545309的博客
11-13 1713
通常，在2D平面中，仿射变换的应用较多，而在3D平面中，透视变换又有了自己的一席之地。应用透视变换矩阵：利用计算得到的透视变换矩阵，对原始图像进行变换操作。通过在原始图像上的每个像素点应用透视变换矩阵，计算出对应的目标图像中的位置。确定变换前后的四个对应点：选择变换前图像中的四个关键点，分别对应变换后图像中的四个点。计算透视变换矩阵：通过选定的对应点，利用线性代数的方法计算出透视变换矩阵。可选的后处理：根据需要，可以对变换后的图像进行一些额外的后处理操作，比如插值、边缘平滑等，以获得更好的视觉效果。
OpenCV进阶--图像变换（三）
qq_54922862的博客
10-06 464
继上文： 五、图像透视变换 首先透视变换是按照物体成像投影规律进行变换，即将物体重新投影到新的成像平面。在透视变换中，透视前的图像和透视后的图像之间的变换关系可以用一个3*3的变换矩阵表示，该矩阵可以通过两幅图像中4个对应点的坐标求取，因此透视变换又称作“四点变换”。在OpenCV中提供了根据4个对应点求取变换矩阵的getPerspectiveTransform()函数和透视变换的warpPerspective()函数。 getPerspectiveTransform()函数原型： ...
opencv warpPerspective透视变换实现原理与过程
叶子的博客
03-18 1892
opencv warpPerspective透视变换实现原理与过程
【opencv】：图像的透视变换
weixin_44322778的博客
04-06 4742
函数cv2.warpAffine()函数以cv2.getAffineTransform(src, dst)获得的转换矩阵M为参数，将src中的点仿射到dst中，函数cv2.getAffineTransform(src, dst)对指定的点完成映射之后，将所有其他点的映射关系按照指定点的关系确定。在目标图像上选四个坐标点，分别为B： (X’0,Y’0),(X’1,Y’1),(X’2,Y’2),(X’3,Y’3)在源图像上选四个坐标点，分别为A： （x0,y0),(x1,y1),(x2,y2),(x3,y3)
OpenCV-透视变换及对二维点求透视变换之后的坐标
leonardohaig的博客
02-17 1万+
OpenCV-透视变换及对二维点求透视变换之后的坐标 微信公众号：幼儿园的学霸 个人的学习笔记，关于OpenCV,关于机器学习, …。问题或建议，请公众号留言; 目录 前言 基本原理 OpenCV透视变换函数代码 前言   在做车道线检测中用到了透视变换的一点内容，用于将相机拍摄的图像转换到道路平行的视角下，即鸟瞰图，然后在鸟瞰图中进行车道线检测。   如图1、图2所示分别为相机...
OpenCV中二维点求取进行仿射和透视变换之后的坐标点方法
huangli19870217的专栏
09-14 6774
我使用的是OpenCV 2.2版本。得到了一个透视矩阵，想把屏幕上的一个二维点经过这个透视矩阵进行变换，本身很简单的一个事情，却颇费了一番周折。原因是刚接触OpenCV，而且使用了OpenCV新添加的C++部分的矩阵类Mat，使用起来还真有点不顺手，因为OpenCV中没有向量的说法。一个矩阵变换一个向量就让我找了半天。 最终得以解决，还是使用了CvMat类而不是Mat类。代码如下：
使用OpenCV透视变换技术实现坐标变换实践
肖永威的专栏
01-17 3985
在局部空间（无GPS定位）视频监控过程中，把视频识别到物体位置，使用OpenCV透视变换技术，和坐标变换投射到空间平面坐标系中，获取物体在局部空间的平面坐标。
检测图片矩形的四个顶点并进行透视变换
weixin_44361396的博客
09-24 2536
检测图片矩形的四个顶点并进行透视变换前言一、代码参考 前言 学习检测图片中的矩形，得到四个顶点的坐标，之后进行透视变换，透视变换所需的变换后的坐标是手动输入的，代码中重复的地方是因为要处理两幅图像，所以需要手动输入两遍。 一、代码 代码如下： #include <iostream> #include <opencv2/opencv.hpp> using namespace std; using namespace cv; int main() { Mat srcPic =
OpenCV中的透视变换介绍
小白学视觉
06-23 5525
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达 本文转自：opencv学堂透视变换原理透视变换是将图像从一个视平面投影到另外一个视平面的过程，所...
OpenCV4.1.0透视变换的基本操作
LankyBin的博客
08-27 397
C++：透视变换，代码如下： void contrast() { VideoCapture capture(0); Mat frame; int cap_w = capture.get(CV_CAP_PROP_FRAME_WIDTH); int cap_h = capture.get(CV_CAP_PROP_FRAME_HEIGHT); int cx = 531, cy = 125, dx = 531, dy = 389, ax = 95, ay = 120, bx = 85, by = 38
【OpenCV3】透视变换——cv::getPerspectiveTransform()与cv::warpPerspective()详解
热门推荐
guduruyu的专栏
05-19 7万+
透视变换(Perspective Transformation)是将成像投影到一个新的视平面(Viewing Plane)，也称作投影映射(Projective Mapping)。
Python在OpenCV里实现极坐标变换功能
09-18
主要介绍了在OpenCV里实现极坐标变换功能，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
Perfectly Clear Workbench for mac/win：让图像清晰不再是难题
2401_82627223的博客
04-27 323
Perfectly Clear Workbench是一款功能强大、操作简便的图像清晰处理软件。它不仅能够满足专业摄影师的高标准需求，也能让业余爱好者轻松提升作品质量。
【炼金术士】BatchSize对网络训练的影响
kabuto_hui的博客
04-25 1288
首先我们设置一个非常小的初始学习率，比如1e-5，然后在每个batch之后都更新网络，同时增加学习率，统计每个batch计算出的loss。最后我们可以描绘出学习的变化曲线和loss的变化曲线，从中就能够发现最好的学习率。针对BatchSize越大，网络训练速度快这条很好理解，在相同的单位时间内，一次训练的数据越多，网络训练的速度也就越快。初始的学习率肯定是有一个最优值的，过大则导致模型不收敛，过小则导致模型收敛特别慢或者无法学习，下图展示了不同大小的学习率下模型收敛情况的可能性。
linux 编译opencv遇到问题
123
04-26 628
linux 编译opencv遇到问题
铝型材表面瑕疵识别-Are you OK?队-1-解决方案
最新发布
gangyikeji的博客
04-28 990
本次大赛分为初赛、复赛和决赛三个阶段（9月17日-11月22日），初赛是分类任务，复赛是检测任务，决赛是现场答辩。经过2个多月的算法角逐和决赛答辩，我们团队（Are you OK?这里着重介绍下复赛的答辩方案，对初赛感兴趣的同学可以参照我们的开源代码。[初赛开源代码1](https://github.com/herbert-chen/tianchi_lvcai)[初赛开源代码2](https://github.com/OdingdongO/pytorch_classification)
TR6 - Transformer实战 单词预测
Loser
04-26 1290
实验做的还是比较简单的，Transformer模型中的编码器直接使用的是pytorch框架预定义好的模块，但是对于理解整个模型的训练过程还是非常有帮助的。在实验的过程中，发现torchtext模块也已经不在维护了，和计算机视觉不同，自然语言处理的模型的输入格式灵活多变，经常需要自己写代码调整，比如上面的data_process函数。
opencv图像矫正透视变换
09-24
通过使用OpenCV库中的函数，你可以进行图像矫正和透视变换。在你提供的代码中，可以看到以下几个关键步骤： 1. 将图像转换为灰度图像，以便进行单通道计算。 2. 使用Canny边缘检测函数，提取图像中的边缘。 3. 定义...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值