#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/nonfree/features2d.hpp>
#include <opencv2/features2d/features2d.hpp>
using namespace cv;
using namespace std;
void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst);
typedef struct
{
Point2f left_top;
Point2f left_bottom;
Point2f right_top;
Point2f right_bottom;
}four_corners_t;
four_corners_t corners;
void CalcCorners(const Mat& H, const Mat& src)
{
double v2[] = { 0, 0, 1 };//左上角
double v1[3];//变换后的坐标值
Mat V2 = Mat(3, 1, CV_64FC1, v2); //列向量
Mat V1 = Mat(3, 1, CV_64FC1, v1); //列向量
V1 = H * V2;
//左上角(0,0,1)
cout << "V2: " << V2 << endl;
cout << "V1: " << V1 << endl;
corners.left_top.x = v1[0] / v1[2];
corners.left_top.y = v1[1] / v1[2];
//左下角(0,src.rows,1)
v2[0] = 0;
v2[1] = src.rows;
v2[2] = 1;
V2 = Mat(3, 1, CV_64FC1, v2); //列向量
V1 = Mat(3, 1, CV_64FC1, v1); //列向量
V1 = H * V2;
corners.left_bottom.x = v1[0] / v1[2];
corners.left_bottom.y = v1[1] / v1[2];
//右上角(src.cols,0,1)
v2[0] = src.cols;
v2[1] = 0;
v2[2] = 1;
V2 = Mat(3, 1, CV_64FC1, v2); //列向量
V1 = Mat(3, 1, CV_64FC1, v1); //列向量
V1 = H * V2;
corners.right_top.x = v1[0] / v1[2];
corners.right_top.y = v1[1] / v1[2];
//右下角(src.cols,src.rows,1)
v2[0] = src.cols;
v2[1] = src.rows;
v2[2] = 1;
V2 = Mat(3, 1, CV_64FC1, v2); //列向量
V1 = Mat(3, 1, CV_64FC1, v1); //列向量
V1 = H * V2;
corners.right_bottom.x = v1[0] / v1[2];
corners.right_bottom.y = v1[1] / v1[2];
}
int main(int argc, char *argv[])
{
Mat image01 = imread("left1.jpg", 1); //右图
Mat image02 = imread("left2.jpg", 1); //左图
//灰度图转换
Mat image1, image2;
cvtColor(image01, image1, CV_RGB2GRAY);
cvtColor(image02, image2, CV_RGB2GRAY);
//提取特征点
OrbFeatureDetector Detector;
vector<KeyPoint> keyPoint1, keyPoint2;
Detector.detect(image1, keyPoint1);
Detector.detect(image2, keyPoint2);
cout << "kp1 = " <<keyPoint1.size() << " kp2 = " << keyPoint2.size() << endl;
//特征点描述,为下边的特征点匹配做准备
OrbDescriptorExtractor Descriptor;
Mat imageDesc1, imageDesc2;
Descriptor.compute(image1, keyPoint1, imageDesc1);
Descriptor.compute(image2, keyPoint2, imageDesc2);
cout << "kp1 = " <<imageDesc1.rows << " kp2 = " << imageDesc2.rows << endl;
//FlannBasedMatcher matcher;
//vector<vector<DMatch> > matchePoints;
vector<DMatch> GoodMatchePoints;
vector< DMatch > matchePoints;
BFMatcher matcher(NORM_L2);
matcher.match(imageDesc1,imageDesc2,matchePoints,Mat());
cout << "detector!" << endl;
// Lowe's algorithm,获取优秀匹配点
double max_dist = 0; double min_dist = 100;
//-- Quick calculation of max and min distances between keypoints
for( int i = 0; i < imageDesc1.rows; i++ )
{ double dist = matchePoints[i].distance;
if( dist < min_dist ) min_dist = dist;
if( dist > max_dist ) max_dist = dist;
}
printf("-- Max dist : %f \n", max_dist );
printf("-- Min dist : %f \n", min_dist );
//-- Draw only "good" matches (i.e. whose distance is less than 2*min_dist )
//-- PS.- radiusMatch can also be used here.
//std::vector< DMatch > good_matches;
for( int i = 0; i < imageDesc1.rows; i++ )
{ if( matchePoints[i].distance < 2*min_dist )
{ GoodMatchePoints.push_back( matchePoints[i]); }
}
if(GoodMatchePoints.size() <= 0)
{
cout << "point = 0" << endl;
return 0;
}
Mat first_match;
drawMatches(image01, keyPoint1, image02, keyPoint2, GoodMatchePoints, first_match);
imshow("first_match ", first_match);
waitKey(0);
vector<Point2f> imagePoints1, imagePoints2;
for (int i = 0; i<GoodMatchePoints.size(); i++)
{
imagePoints2.push_back(keyPoint2[GoodMatchePoints[i].trainIdx].pt);
imagePoints1.push_back(keyPoint1[GoodMatchePoints[i].queryIdx].pt);
}
//获取图像1到图像2的投影映射矩阵 尺寸为3*3
Mat homo = findHomography(imagePoints2, imagePoints1, CV_RANSAC);
也可以使用getPerspectiveTransform方法获得透视变换矩阵,不过要求只能有4个点,效果稍差
//Mat homo=getPerspectiveTransform(imagePoints1,imagePoints2);
cout << "变换矩阵为:\n" << homo << endl << endl; //输出映射矩阵
//计算配准图的四个顶点坐标
CalcCorners(homo, image02);
cout << "left_top:" << corners.left_top << endl;
cout << "left_bottom:" << corners.left_bottom << endl;
cout << "right_top:" << corners.right_top << endl;
cout << "right_bottom:" << corners.right_bottom << endl;
//图像配准
Mat imageTransform1, imageTransform2;
std::vector<Point2f> obj_corners(4);//image02
obj_corners[0] = Point(0,0); obj_corners[1] = Point( image02.cols, 0 );
obj_corners[2] = Point( image02.cols, image02.rows ); obj_corners[3] = Point( 0, image02.rows );
std::vector<Point2f> scene_corners(4);
perspectiveTransform( obj_corners, scene_corners, homo);
// warpPerspective(image02, imageTransform1, homo, Size(MAX(corners.right_top.x, corners.right_bottom.x), image01.rows));
warpPerspective(image02, imageTransform1, homo, Size(MAX(scene_corners[1].x, scene_corners[2].x), image01.rows));
imshow("直接经过透视矩阵变换", imageTransform1);
line( image01, scene_corners[0] , scene_corners[1] , Scalar(0, 255, 0), 4 );
line( image01, scene_corners[1] , scene_corners[2] , Scalar( 0, 255, 0), 4 );
line( image01, scene_corners[2] , scene_corners[3] , Scalar( 0, 255, 0), 4 );
line( image01, scene_corners[3] , scene_corners[0] , Scalar( 0, 255, 0), 4 );
imshow("p1", image01);
imshow("p2", image02);
// imwrite("trans1.jpg", imageTransform1);
// //创建拼接后的图,需提前计算图的大小
int dst_width = imageTransform1.cols; //取最右点的长度为拼接图的长度
int dst_height = image01.rows;
Mat dst(dst_height, dst_width, CV_8UC3);
dst.setTo(0);
imageTransform1.copyTo(dst(Rect(0, 0, imageTransform1.cols, imageTransform1.rows)));
image02.copyTo(dst(Rect(0, 0, image02.cols, image02.rows)));
imshow("b_dst", dst);
// OptimizeSeam(image02, imageTransform1, dst);
// imshow("dst", dst);
// imwrite("dst.jpg", dst);
waitKey(0);
return 0;
}
//优化两图的连接处,使得拼接自然
void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
{
int start = MIN(corners.left_top.x, corners.left_bottom.x);//开始位置,即重叠区域的左边界
double processWidth = img1.cols - start;//重叠区域的宽度
int rows = dst.rows;
int cols = img1.cols; //注意,是列数*通道数
double alpha = 1;//img1中像素的权重
for (int i = 0; i < rows; i++)
{
uchar* p = img1.ptr<uchar>(i); //获取第i行的首地址
uchar* t = trans.ptr<uchar>(i);
uchar* d = dst.ptr<uchar>(i);
for (int j = start; j < cols; j++)
{
//如果遇到图像trans中无像素的黑点,则完全拷贝img1中的数据
if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
{
alpha = 1;
}
else
{
//img1中像素的权重,与当前处理点距重叠区域左边界的距离成正比,实验证明,这种方法确实好
alpha = (processWidth - (j - start)) / processWidth;
}
d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);
}
}
}
透视变换,图像拼接
最新推荐文章于 2023-05-05 11:04:00 发布