feat: 切换后端至PaddleOCR-NCNN，切换工程为CMake
1.项目后端整体迁移至PaddleOCR-NCNN算法，已通过基本的兼容性测试 2.工程改为使用CMake组织，后续为了更好地兼容第三方库，不再提供QMake工程 3.重整权利声明文件，重整代码工程，确保最小化侵权风险 Log: 切换后端至PaddleOCR-NCNN，切换工程为CMake Change-Id: I4d5d2c5d37505a4a24b389b1a4c5d12f17bfa38c
This commit is contained in:
wangzhengyang
98
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp
vendored
Normal file
98
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp
vendored
Normal file
@ -0,0 +1,98 @@
|
||||
#include <opencv2/features2d.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
const float inlier_threshold = 2.5f; // Distance threshold to identify inliers with homography check
|
||||
const float nn_match_ratio = 0.8f; // Nearest neighbor matching ratio
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
//! [load]
|
||||
CommandLineParser parser(argc, argv,
|
||||
"{@img1 | graf1.png | input image 1}"
|
||||
"{@img2 | graf3.png | input image 2}"
|
||||
"{@homography | H1to3p.xml | homography matrix}");
|
||||
Mat img1 = imread( samples::findFile( parser.get<String>("@img1") ), IMREAD_GRAYSCALE);
|
||||
Mat img2 = imread( samples::findFile( parser.get<String>("@img2") ), IMREAD_GRAYSCALE);
|
||||
|
||||
Mat homography;
|
||||
FileStorage fs( samples::findFile( parser.get<String>("@homography") ), FileStorage::READ);
|
||||
fs.getFirstTopLevelNode() >> homography;
|
||||
//! [load]
|
||||
|
||||
//! [AKAZE]
|
||||
vector<KeyPoint> kpts1, kpts2;
|
||||
Mat desc1, desc2;
|
||||
|
||||
Ptr<AKAZE> akaze = AKAZE::create();
|
||||
akaze->detectAndCompute(img1, noArray(), kpts1, desc1);
|
||||
akaze->detectAndCompute(img2, noArray(), kpts2, desc2);
|
||||
//! [AKAZE]
|
||||
|
||||
//! [2-nn matching]
|
||||
BFMatcher matcher(NORM_HAMMING);
|
||||
vector< vector<DMatch> > nn_matches;
|
||||
matcher.knnMatch(desc1, desc2, nn_matches, 2);
|
||||
//! [2-nn matching]
|
||||
|
||||
//! [ratio test filtering]
|
||||
vector<KeyPoint> matched1, matched2;
|
||||
for(size_t i = 0; i < nn_matches.size(); i++) {
|
||||
DMatch first = nn_matches[i][0];
|
||||
float dist1 = nn_matches[i][0].distance;
|
||||
float dist2 = nn_matches[i][1].distance;
|
||||
|
||||
if(dist1 < nn_match_ratio * dist2) {
|
||||
matched1.push_back(kpts1[first.queryIdx]);
|
||||
matched2.push_back(kpts2[first.trainIdx]);
|
||||
}
|
||||
}
|
||||
//! [ratio test filtering]
|
||||
|
||||
//! [homography check]
|
||||
vector<DMatch> good_matches;
|
||||
vector<KeyPoint> inliers1, inliers2;
|
||||
for(size_t i = 0; i < matched1.size(); i++) {
|
||||
Mat col = Mat::ones(3, 1, CV_64F);
|
||||
col.at<double>(0) = matched1[i].pt.x;
|
||||
col.at<double>(1) = matched1[i].pt.y;
|
||||
|
||||
col = homography * col;
|
||||
col /= col.at<double>(2);
|
||||
double dist = sqrt( pow(col.at<double>(0) - matched2[i].pt.x, 2) +
|
||||
pow(col.at<double>(1) - matched2[i].pt.y, 2));
|
||||
|
||||
if(dist < inlier_threshold) {
|
||||
int new_i = static_cast<int>(inliers1.size());
|
||||
inliers1.push_back(matched1[i]);
|
||||
inliers2.push_back(matched2[i]);
|
||||
good_matches.push_back(DMatch(new_i, new_i, 0));
|
||||
}
|
||||
}
|
||||
//! [homography check]
|
||||
|
||||
//! [draw final matches]
|
||||
Mat res;
|
||||
drawMatches(img1, inliers1, img2, inliers2, good_matches, res);
|
||||
imwrite("akaze_result.png", res);
|
||||
|
||||
double inlier_ratio = inliers1.size() / (double) matched1.size();
|
||||
cout << "A-KAZE Matching Results" << endl;
|
||||
cout << "*******************************" << endl;
|
||||
cout << "# Keypoints 1: \t" << kpts1.size() << endl;
|
||||
cout << "# Keypoints 2: \t" << kpts2.size() << endl;
|
||||
cout << "# Matches: \t" << matched1.size() << endl;
|
||||
cout << "# Inliers: \t" << inliers1.size() << endl;
|
||||
cout << "# Inliers Ratio: \t" << inlier_ratio << endl;
|
||||
cout << endl;
|
||||
|
||||
imshow("result", res);
|
||||
waitKey();
|
||||
//! [draw final matches]
|
||||
|
||||
return 0;
|
||||
}
|
||||
213
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/AKAZE_tracking/planar_tracking.cpp
vendored
Normal file
213
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/AKAZE_tracking/planar_tracking.cpp
vendored
Normal file
@ -0,0 +1,213 @@
|
||||
#include <opencv2/features2d.hpp>
|
||||
#include <opencv2/videoio.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/calib3d.hpp>
|
||||
#include <opencv2/highgui.hpp> //for imshow
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
|
||||
#include "stats.h" // Stats structure definition
|
||||
#include "utils.h" // Drawing and printing functions
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
const double akaze_thresh = 3e-4; // AKAZE detection threshold set to locate about 1000 keypoints
|
||||
const double ransac_thresh = 2.5f; // RANSAC inlier threshold
|
||||
const double nn_match_ratio = 0.8f; // Nearest-neighbour matching ratio
|
||||
const int bb_min_inliers = 100; // Minimal number of inliers to draw bounding box
|
||||
const int stats_update_period = 10; // On-screen statistics are updated every 10 frames
|
||||
|
||||
namespace example {
|
||||
class Tracker
|
||||
{
|
||||
public:
|
||||
Tracker(Ptr<Feature2D> _detector, Ptr<DescriptorMatcher> _matcher) :
|
||||
detector(_detector),
|
||||
matcher(_matcher)
|
||||
{}
|
||||
|
||||
void setFirstFrame(const Mat frame, vector<Point2f> bb, string title, Stats& stats);
|
||||
Mat process(const Mat frame, Stats& stats);
|
||||
Ptr<Feature2D> getDetector() {
|
||||
return detector;
|
||||
}
|
||||
protected:
|
||||
Ptr<Feature2D> detector;
|
||||
Ptr<DescriptorMatcher> matcher;
|
||||
Mat first_frame, first_desc;
|
||||
vector<KeyPoint> first_kp;
|
||||
vector<Point2f> object_bb;
|
||||
};
|
||||
|
||||
void Tracker::setFirstFrame(const Mat frame, vector<Point2f> bb, string title, Stats& stats)
|
||||
{
|
||||
cv::Point *ptMask = new cv::Point[bb.size()];
|
||||
const Point* ptContain = { &ptMask[0] };
|
||||
int iSize = static_cast<int>(bb.size());
|
||||
for (size_t i=0; i<bb.size(); i++) {
|
||||
ptMask[i].x = static_cast<int>(bb[i].x);
|
||||
ptMask[i].y = static_cast<int>(bb[i].y);
|
||||
}
|
||||
first_frame = frame.clone();
|
||||
cv::Mat matMask = cv::Mat::zeros(frame.size(), CV_8UC1);
|
||||
cv::fillPoly(matMask, &ptContain, &iSize, 1, cv::Scalar::all(255));
|
||||
detector->detectAndCompute(first_frame, matMask, first_kp, first_desc);
|
||||
stats.keypoints = (int)first_kp.size();
|
||||
drawBoundingBox(first_frame, bb);
|
||||
putText(first_frame, title, Point(0, 60), FONT_HERSHEY_PLAIN, 5, Scalar::all(0), 4);
|
||||
object_bb = bb;
|
||||
delete[] ptMask;
|
||||
}
|
||||
|
||||
Mat Tracker::process(const Mat frame, Stats& stats)
|
||||
{
|
||||
TickMeter tm;
|
||||
vector<KeyPoint> kp;
|
||||
Mat desc;
|
||||
|
||||
tm.start();
|
||||
detector->detectAndCompute(frame, noArray(), kp, desc);
|
||||
stats.keypoints = (int)kp.size();
|
||||
|
||||
vector< vector<DMatch> > matches;
|
||||
vector<KeyPoint> matched1, matched2;
|
||||
matcher->knnMatch(first_desc, desc, matches, 2);
|
||||
for(unsigned i = 0; i < matches.size(); i++) {
|
||||
if(matches[i][0].distance < nn_match_ratio * matches[i][1].distance) {
|
||||
matched1.push_back(first_kp[matches[i][0].queryIdx]);
|
||||
matched2.push_back( kp[matches[i][0].trainIdx]);
|
||||
}
|
||||
}
|
||||
stats.matches = (int)matched1.size();
|
||||
|
||||
Mat inlier_mask, homography;
|
||||
vector<KeyPoint> inliers1, inliers2;
|
||||
vector<DMatch> inlier_matches;
|
||||
if(matched1.size() >= 4) {
|
||||
homography = findHomography(Points(matched1), Points(matched2),
|
||||
RANSAC, ransac_thresh, inlier_mask);
|
||||
}
|
||||
tm.stop();
|
||||
stats.fps = 1. / tm.getTimeSec();
|
||||
|
||||
if(matched1.size() < 4 || homography.empty()) {
|
||||
Mat res;
|
||||
hconcat(first_frame, frame, res);
|
||||
stats.inliers = 0;
|
||||
stats.ratio = 0;
|
||||
return res;
|
||||
}
|
||||
for(unsigned i = 0; i < matched1.size(); i++) {
|
||||
if(inlier_mask.at<uchar>(i)) {
|
||||
int new_i = static_cast<int>(inliers1.size());
|
||||
inliers1.push_back(matched1[i]);
|
||||
inliers2.push_back(matched2[i]);
|
||||
inlier_matches.push_back(DMatch(new_i, new_i, 0));
|
||||
}
|
||||
}
|
||||
stats.inliers = (int)inliers1.size();
|
||||
stats.ratio = stats.inliers * 1.0 / stats.matches;
|
||||
|
||||
vector<Point2f> new_bb;
|
||||
perspectiveTransform(object_bb, new_bb, homography);
|
||||
Mat frame_with_bb = frame.clone();
|
||||
if(stats.inliers >= bb_min_inliers) {
|
||||
drawBoundingBox(frame_with_bb, new_bb);
|
||||
}
|
||||
Mat res;
|
||||
drawMatches(first_frame, inliers1, frame_with_bb, inliers2,
|
||||
inlier_matches, res,
|
||||
Scalar(255, 0, 0), Scalar(255, 0, 0));
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
CommandLineParser parser(argc, argv, "{@input_path |0|input path can be a camera id, like 0,1,2 or a video filename}");
|
||||
parser.printMessage();
|
||||
string input_path = parser.get<string>(0);
|
||||
string video_name = input_path;
|
||||
|
||||
VideoCapture video_in;
|
||||
|
||||
if ( ( isdigit(input_path[0]) && input_path.size() == 1 ) )
|
||||
{
|
||||
int camera_no = input_path[0] - '0';
|
||||
video_in.open( camera_no );
|
||||
}
|
||||
else {
|
||||
video_in.open(video_name);
|
||||
}
|
||||
|
||||
if(!video_in.isOpened()) {
|
||||
cerr << "Couldn't open " << video_name << endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
Stats stats, akaze_stats, orb_stats;
|
||||
Ptr<AKAZE> akaze = AKAZE::create();
|
||||
akaze->setThreshold(akaze_thresh);
|
||||
Ptr<ORB> orb = ORB::create();
|
||||
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming");
|
||||
example::Tracker akaze_tracker(akaze, matcher);
|
||||
example::Tracker orb_tracker(orb, matcher);
|
||||
|
||||
Mat frame;
|
||||
namedWindow(video_name, WINDOW_NORMAL);
|
||||
cout << "\nPress any key to stop the video and select a bounding box" << endl;
|
||||
|
||||
while ( waitKey(1) < 1 )
|
||||
{
|
||||
video_in >> frame;
|
||||
cv::resizeWindow(video_name, frame.size());
|
||||
imshow(video_name, frame);
|
||||
}
|
||||
|
||||
vector<Point2f> bb;
|
||||
cv::Rect uBox = cv::selectROI(video_name, frame);
|
||||
bb.push_back(cv::Point2f(static_cast<float>(uBox.x), static_cast<float>(uBox.y)));
|
||||
bb.push_back(cv::Point2f(static_cast<float>(uBox.x+uBox.width), static_cast<float>(uBox.y)));
|
||||
bb.push_back(cv::Point2f(static_cast<float>(uBox.x+uBox.width), static_cast<float>(uBox.y+uBox.height)));
|
||||
bb.push_back(cv::Point2f(static_cast<float>(uBox.x), static_cast<float>(uBox.y+uBox.height)));
|
||||
|
||||
akaze_tracker.setFirstFrame(frame, bb, "AKAZE", stats);
|
||||
orb_tracker.setFirstFrame(frame, bb, "ORB", stats);
|
||||
|
||||
Stats akaze_draw_stats, orb_draw_stats;
|
||||
Mat akaze_res, orb_res, res_frame;
|
||||
int i = 0;
|
||||
for(;;) {
|
||||
i++;
|
||||
bool update_stats = (i % stats_update_period == 0);
|
||||
video_in >> frame;
|
||||
// stop the program if no more images
|
||||
if(frame.empty()) break;
|
||||
|
||||
akaze_res = akaze_tracker.process(frame, stats);
|
||||
akaze_stats += stats;
|
||||
if(update_stats) {
|
||||
akaze_draw_stats = stats;
|
||||
}
|
||||
|
||||
orb->setMaxFeatures(stats.keypoints);
|
||||
orb_res = orb_tracker.process(frame, stats);
|
||||
orb_stats += stats;
|
||||
if(update_stats) {
|
||||
orb_draw_stats = stats;
|
||||
}
|
||||
|
||||
drawStatistics(akaze_res, akaze_draw_stats);
|
||||
drawStatistics(orb_res, orb_draw_stats);
|
||||
vconcat(akaze_res, orb_res, res_frame);
|
||||
cv::imshow(video_name, res_frame);
|
||||
if(waitKey(1)==27) break; //quit on ESC button
|
||||
}
|
||||
akaze_stats /= i - 1;
|
||||
orb_stats /= i - 1;
|
||||
printStatistics("AKAZE", akaze_stats);
|
||||
printStatistics("ORB", orb_stats);
|
||||
return 0;
|
||||
}
|
||||
38
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/AKAZE_tracking/stats.h
vendored
Normal file
38
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/AKAZE_tracking/stats.h
vendored
Normal file
@ -0,0 +1,38 @@
|
||||
#ifndef STATS_H
|
||||
#define STATS_H
|
||||
|
||||
struct Stats
|
||||
{
|
||||
int matches;
|
||||
int inliers;
|
||||
double ratio;
|
||||
int keypoints;
|
||||
double fps;
|
||||
|
||||
Stats() : matches(0),
|
||||
inliers(0),
|
||||
ratio(0),
|
||||
keypoints(0),
|
||||
fps(0.)
|
||||
{}
|
||||
|
||||
Stats& operator+=(const Stats& op) {
|
||||
matches += op.matches;
|
||||
inliers += op.inliers;
|
||||
ratio += op.ratio;
|
||||
keypoints += op.keypoints;
|
||||
fps += op.fps;
|
||||
return *this;
|
||||
}
|
||||
Stats& operator/=(int num)
|
||||
{
|
||||
matches /= num;
|
||||
inliers /= num;
|
||||
ratio /= num;
|
||||
keypoints /= num;
|
||||
fps /= num;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // STATS_H
|
||||
62
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/AKAZE_tracking/utils.h
vendored
Normal file
62
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/AKAZE_tracking/utils.h
vendored
Normal file
@ -0,0 +1,62 @@
|
||||
#ifndef UTILS_H
|
||||
#define UTILS_H
|
||||
|
||||
#include <opencv2/core.hpp>
|
||||
#include <vector>
|
||||
#include "stats.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
void drawBoundingBox(Mat image, vector<Point2f> bb);
|
||||
void drawStatistics(Mat image, const Stats& stats);
|
||||
void printStatistics(string name, Stats stats);
|
||||
vector<Point2f> Points(vector<KeyPoint> keypoints);
|
||||
Rect2d selectROI(const String &video_name, const Mat &frame);
|
||||
|
||||
void drawBoundingBox(Mat image, vector<Point2f> bb)
|
||||
{
|
||||
for(unsigned i = 0; i < bb.size() - 1; i++) {
|
||||
line(image, bb[i], bb[i + 1], Scalar(0, 0, 255), 2);
|
||||
}
|
||||
line(image, bb[bb.size() - 1], bb[0], Scalar(0, 0, 255), 2);
|
||||
}
|
||||
|
||||
void drawStatistics(Mat image, const Stats& stats)
|
||||
{
|
||||
static const int font = FONT_HERSHEY_PLAIN;
|
||||
stringstream str1, str2, str3, str4;
|
||||
|
||||
str1 << "Matches: " << stats.matches;
|
||||
str2 << "Inliers: " << stats.inliers;
|
||||
str3 << "Inlier ratio: " << setprecision(2) << stats.ratio;
|
||||
str4 << "FPS: " << std::fixed << setprecision(2) << stats.fps;
|
||||
|
||||
putText(image, str1.str(), Point(0, image.rows - 120), font, 2, Scalar::all(255), 3);
|
||||
putText(image, str2.str(), Point(0, image.rows - 90), font, 2, Scalar::all(255), 3);
|
||||
putText(image, str3.str(), Point(0, image.rows - 60), font, 2, Scalar::all(255), 3);
|
||||
putText(image, str4.str(), Point(0, image.rows - 30), font, 2, Scalar::all(255), 3);
|
||||
}
|
||||
|
||||
void printStatistics(string name, Stats stats)
|
||||
{
|
||||
cout << name << endl;
|
||||
cout << "----------" << endl;
|
||||
|
||||
cout << "Matches " << stats.matches << endl;
|
||||
cout << "Inliers " << stats.inliers << endl;
|
||||
cout << "Inlier ratio " << setprecision(2) << stats.ratio << endl;
|
||||
cout << "Keypoints " << stats.keypoints << endl;
|
||||
cout << "FPS " << std::fixed << setprecision(2) << stats.fps << endl;
|
||||
cout << endl;
|
||||
}
|
||||
|
||||
vector<Point2f> Points(vector<KeyPoint> keypoints)
|
||||
{
|
||||
vector<Point2f> res;
|
||||
for(unsigned i = 0; i < keypoints.size(); i++) {
|
||||
res.push_back(keypoints[i].pt);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
#endif // UTILS_H
|
||||
185
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp
vendored
Normal file
185
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp
vendored
Normal file
@ -0,0 +1,185 @@
|
||||
#include <iostream>
|
||||
#include <opencv2/core.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/calib3d.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace
|
||||
{
|
||||
enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
|
||||
|
||||
void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners, Pattern patternType = CHESSBOARD)
|
||||
{
|
||||
corners.resize(0);
|
||||
|
||||
switch (patternType) {
|
||||
case CHESSBOARD:
|
||||
case CIRCLES_GRID:
|
||||
for( int i = 0; i < boardSize.height; i++ )
|
||||
for( int j = 0; j < boardSize.width; j++ )
|
||||
corners.push_back(Point3f(float(j*squareSize),
|
||||
float(i*squareSize), 0));
|
||||
break;
|
||||
|
||||
case ASYMMETRIC_CIRCLES_GRID:
|
||||
for( int i = 0; i < boardSize.height; i++ )
|
||||
for( int j = 0; j < boardSize.width; j++ )
|
||||
corners.push_back(Point3f(float((2*j + i % 2)*squareSize),
|
||||
float(i*squareSize), 0));
|
||||
break;
|
||||
|
||||
default:
|
||||
CV_Error(Error::StsBadArg, "Unknown pattern type\n");
|
||||
}
|
||||
}
|
||||
|
||||
Mat computeHomography(const Mat &R_1to2, const Mat &tvec_1to2, const double d_inv, const Mat &normal)
|
||||
{
|
||||
Mat homography = R_1to2 + d_inv * tvec_1to2*normal.t();
|
||||
return homography;
|
||||
}
|
||||
|
||||
void computeC2MC1(const Mat &R1, const Mat &tvec1, const Mat &R2, const Mat &tvec2,
|
||||
Mat &R_1to2, Mat &tvec_1to2)
|
||||
{
|
||||
//c2Mc1 = c2Mo * oMc1 = c2Mo * c1Mo.inv()
|
||||
R_1to2 = R2 * R1.t();
|
||||
tvec_1to2 = R2 * (-R1.t()*tvec1) + tvec2;
|
||||
}
|
||||
|
||||
void decomposeHomography(const string &img1Path, const string &img2Path, const Size &patternSize,
|
||||
const float squareSize, const string &intrinsicsPath)
|
||||
{
|
||||
Mat img1 = imread( samples::findFile( img1Path) );
|
||||
Mat img2 = imread( samples::findFile( img2Path) );
|
||||
|
||||
vector<Point2f> corners1, corners2;
|
||||
bool found1 = findChessboardCorners(img1, patternSize, corners1);
|
||||
bool found2 = findChessboardCorners(img2, patternSize, corners2);
|
||||
|
||||
if (!found1 || !found2)
|
||||
{
|
||||
cout << "Error, cannot find the chessboard corners in both images." << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
//! [compute-poses]
|
||||
vector<Point3f> objectPoints;
|
||||
calcChessboardCorners(patternSize, squareSize, objectPoints);
|
||||
|
||||
FileStorage fs( samples::findFile( intrinsicsPath ), FileStorage::READ);
|
||||
Mat cameraMatrix, distCoeffs;
|
||||
fs["camera_matrix"] >> cameraMatrix;
|
||||
fs["distortion_coefficients"] >> distCoeffs;
|
||||
|
||||
Mat rvec1, tvec1;
|
||||
solvePnP(objectPoints, corners1, cameraMatrix, distCoeffs, rvec1, tvec1);
|
||||
Mat rvec2, tvec2;
|
||||
solvePnP(objectPoints, corners2, cameraMatrix, distCoeffs, rvec2, tvec2);
|
||||
//! [compute-poses]
|
||||
|
||||
//! [compute-camera-displacement]
|
||||
Mat R1, R2;
|
||||
Rodrigues(rvec1, R1);
|
||||
Rodrigues(rvec2, R2);
|
||||
|
||||
Mat R_1to2, t_1to2;
|
||||
computeC2MC1(R1, tvec1, R2, tvec2, R_1to2, t_1to2);
|
||||
Mat rvec_1to2;
|
||||
Rodrigues(R_1to2, rvec_1to2);
|
||||
//! [compute-camera-displacement]
|
||||
|
||||
//! [compute-plane-normal-at-camera-pose-1]
|
||||
Mat normal = (Mat_<double>(3,1) << 0, 0, 1);
|
||||
Mat normal1 = R1*normal;
|
||||
//! [compute-plane-normal-at-camera-pose-1]
|
||||
|
||||
//! [compute-plane-distance-to-the-camera-frame-1]
|
||||
Mat origin(3, 1, CV_64F, Scalar(0));
|
||||
Mat origin1 = R1*origin + tvec1;
|
||||
double d_inv1 = 1.0 / normal1.dot(origin1);
|
||||
//! [compute-plane-distance-to-the-camera-frame-1]
|
||||
|
||||
//! [compute-homography-from-camera-displacement]
|
||||
Mat homography_euclidean = computeHomography(R_1to2, t_1to2, d_inv1, normal1);
|
||||
Mat homography = cameraMatrix * homography_euclidean * cameraMatrix.inv();
|
||||
|
||||
homography /= homography.at<double>(2,2);
|
||||
homography_euclidean /= homography_euclidean.at<double>(2,2);
|
||||
//! [compute-homography-from-camera-displacement]
|
||||
|
||||
//! [decompose-homography-from-camera-displacement]
|
||||
vector<Mat> Rs_decomp, ts_decomp, normals_decomp;
|
||||
int solutions = decomposeHomographyMat(homography, cameraMatrix, Rs_decomp, ts_decomp, normals_decomp);
|
||||
cout << "Decompose homography matrix computed from the camera displacement:" << endl << endl;
|
||||
for (int i = 0; i < solutions; i++)
|
||||
{
|
||||
double factor_d1 = 1.0 / d_inv1;
|
||||
Mat rvec_decomp;
|
||||
Rodrigues(Rs_decomp[i], rvec_decomp);
|
||||
cout << "Solution " << i << ":" << endl;
|
||||
cout << "rvec from homography decomposition: " << rvec_decomp.t() << endl;
|
||||
cout << "rvec from camera displacement: " << rvec_1to2.t() << endl;
|
||||
cout << "tvec from homography decomposition: " << ts_decomp[i].t() << " and scaled by d: " << factor_d1 * ts_decomp[i].t() << endl;
|
||||
cout << "tvec from camera displacement: " << t_1to2.t() << endl;
|
||||
cout << "plane normal from homography decomposition: " << normals_decomp[i].t() << endl;
|
||||
cout << "plane normal at camera 1 pose: " << normal1.t() << endl << endl;
|
||||
}
|
||||
//! [decompose-homography-from-camera-displacement]
|
||||
|
||||
//! [estimate homography]
|
||||
Mat H = findHomography(corners1, corners2);
|
||||
//! [estimate homography]
|
||||
|
||||
//! [decompose-homography-estimated-by-findHomography]
|
||||
solutions = decomposeHomographyMat(H, cameraMatrix, Rs_decomp, ts_decomp, normals_decomp);
|
||||
cout << "Decompose homography matrix estimated by findHomography():" << endl << endl;
|
||||
for (int i = 0; i < solutions; i++)
|
||||
{
|
||||
double factor_d1 = 1.0 / d_inv1;
|
||||
Mat rvec_decomp;
|
||||
Rodrigues(Rs_decomp[i], rvec_decomp);
|
||||
cout << "Solution " << i << ":" << endl;
|
||||
cout << "rvec from homography decomposition: " << rvec_decomp.t() << endl;
|
||||
cout << "rvec from camera displacement: " << rvec_1to2.t() << endl;
|
||||
cout << "tvec from homography decomposition: " << ts_decomp[i].t() << " and scaled by d: " << factor_d1 * ts_decomp[i].t() << endl;
|
||||
cout << "tvec from camera displacement: " << t_1to2.t() << endl;
|
||||
cout << "plane normal from homography decomposition: " << normals_decomp[i].t() << endl;
|
||||
cout << "plane normal at camera 1 pose: " << normal1.t() << endl << endl;
|
||||
}
|
||||
//! [decompose-homography-estimated-by-findHomography]
|
||||
}
|
||||
|
||||
const char* params
|
||||
= "{ help h | | print usage }"
|
||||
"{ image1 | left02.jpg | path to the source chessboard image }"
|
||||
"{ image2 | left01.jpg | path to the desired chessboard image }"
|
||||
"{ intrinsics | left_intrinsics.yml | path to camera intrinsics }"
|
||||
"{ width bw | 9 | chessboard width }"
|
||||
"{ height bh | 6 | chessboard height }"
|
||||
"{ square_size | 0.025 | chessboard square size }";
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
CommandLineParser parser(argc, argv, params);
|
||||
|
||||
if ( parser.has("help") )
|
||||
{
|
||||
parser.about( "Code for homography tutorial.\n"
|
||||
"Example 4: decompose the homography matrix.\n" );
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Size patternSize(parser.get<int>("width"), parser.get<int>("height"));
|
||||
float squareSize = (float) parser.get<double>("square_size");
|
||||
decomposeHomography(parser.get<String>("image1"),
|
||||
parser.get<String>("image2"),
|
||||
patternSize, squareSize,
|
||||
parser.get<String>("intrinsics"));
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,201 @@
|
||||
#include <iostream>
|
||||
#include <opencv2/core.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/calib3d.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace
|
||||
{
|
||||
enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
|
||||
|
||||
void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners, Pattern patternType = CHESSBOARD)
|
||||
{
|
||||
corners.resize(0);
|
||||
|
||||
switch (patternType)
|
||||
{
|
||||
case CHESSBOARD:
|
||||
case CIRCLES_GRID:
|
||||
for( int i = 0; i < boardSize.height; i++ )
|
||||
for( int j = 0; j < boardSize.width; j++ )
|
||||
corners.push_back(Point3f(float(j*squareSize),
|
||||
float(i*squareSize), 0));
|
||||
break;
|
||||
|
||||
case ASYMMETRIC_CIRCLES_GRID:
|
||||
for( int i = 0; i < boardSize.height; i++ )
|
||||
for( int j = 0; j < boardSize.width; j++ )
|
||||
corners.push_back(Point3f(float((2*j + i % 2)*squareSize),
|
||||
float(i*squareSize), 0));
|
||||
break;
|
||||
|
||||
default:
|
||||
CV_Error(Error::StsBadArg, "Unknown pattern type\n");
|
||||
}
|
||||
}
|
||||
|
||||
//! [compute-homography]
|
||||
Mat computeHomography(const Mat &R_1to2, const Mat &tvec_1to2, const double d_inv, const Mat &normal)
|
||||
{
|
||||
Mat homography = R_1to2 + d_inv * tvec_1to2*normal.t();
|
||||
return homography;
|
||||
}
|
||||
//! [compute-homography]
|
||||
|
||||
Mat computeHomography(const Mat &R1, const Mat &tvec1, const Mat &R2, const Mat &tvec2,
|
||||
const double d_inv, const Mat &normal)
|
||||
{
|
||||
Mat homography = R2 * R1.t() + d_inv * (-R2 * R1.t() * tvec1 + tvec2) * normal.t();
|
||||
return homography;
|
||||
}
|
||||
|
||||
//! [compute-c2Mc1]
|
||||
void computeC2MC1(const Mat &R1, const Mat &tvec1, const Mat &R2, const Mat &tvec2,
|
||||
Mat &R_1to2, Mat &tvec_1to2)
|
||||
{
|
||||
//c2Mc1 = c2Mo * oMc1 = c2Mo * c1Mo.inv()
|
||||
R_1to2 = R2 * R1.t();
|
||||
tvec_1to2 = R2 * (-R1.t()*tvec1) + tvec2;
|
||||
}
|
||||
//! [compute-c2Mc1]
|
||||
|
||||
void homographyFromCameraDisplacement(const string &img1Path, const string &img2Path, const Size &patternSize,
|
||||
const float squareSize, const string &intrinsicsPath)
|
||||
{
|
||||
Mat img1 = imread( samples::findFile( img1Path ) );
|
||||
Mat img2 = imread( samples::findFile( img2Path ) );
|
||||
|
||||
//! [compute-poses]
|
||||
vector<Point2f> corners1, corners2;
|
||||
bool found1 = findChessboardCorners(img1, patternSize, corners1);
|
||||
bool found2 = findChessboardCorners(img2, patternSize, corners2);
|
||||
|
||||
if (!found1 || !found2)
|
||||
{
|
||||
cout << "Error, cannot find the chessboard corners in both images." << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
vector<Point3f> objectPoints;
|
||||
calcChessboardCorners(patternSize, squareSize, objectPoints);
|
||||
|
||||
FileStorage fs( samples::findFile( intrinsicsPath ), FileStorage::READ);
|
||||
Mat cameraMatrix, distCoeffs;
|
||||
fs["camera_matrix"] >> cameraMatrix;
|
||||
fs["distortion_coefficients"] >> distCoeffs;
|
||||
|
||||
Mat rvec1, tvec1;
|
||||
solvePnP(objectPoints, corners1, cameraMatrix, distCoeffs, rvec1, tvec1);
|
||||
Mat rvec2, tvec2;
|
||||
solvePnP(objectPoints, corners2, cameraMatrix, distCoeffs, rvec2, tvec2);
|
||||
//! [compute-poses]
|
||||
|
||||
Mat img1_copy_pose = img1.clone(), img2_copy_pose = img2.clone();
|
||||
Mat img_draw_poses;
|
||||
drawFrameAxes(img1_copy_pose, cameraMatrix, distCoeffs, rvec1, tvec1, 2*squareSize);
|
||||
drawFrameAxes(img2_copy_pose, cameraMatrix, distCoeffs, rvec2, tvec2, 2*squareSize);
|
||||
hconcat(img1_copy_pose, img2_copy_pose, img_draw_poses);
|
||||
imshow("Chessboard poses", img_draw_poses);
|
||||
|
||||
//! [compute-camera-displacement]
|
||||
Mat R1, R2;
|
||||
Rodrigues(rvec1, R1);
|
||||
Rodrigues(rvec2, R2);
|
||||
|
||||
Mat R_1to2, t_1to2;
|
||||
computeC2MC1(R1, tvec1, R2, tvec2, R_1to2, t_1to2);
|
||||
Mat rvec_1to2;
|
||||
Rodrigues(R_1to2, rvec_1to2);
|
||||
//! [compute-camera-displacement]
|
||||
|
||||
//! [compute-plane-normal-at-camera-pose-1]
|
||||
Mat normal = (Mat_<double>(3,1) << 0, 0, 1);
|
||||
Mat normal1 = R1*normal;
|
||||
//! [compute-plane-normal-at-camera-pose-1]
|
||||
|
||||
//! [compute-plane-distance-to-the-camera-frame-1]
|
||||
Mat origin(3, 1, CV_64F, Scalar(0));
|
||||
Mat origin1 = R1*origin + tvec1;
|
||||
double d_inv1 = 1.0 / normal1.dot(origin1);
|
||||
//! [compute-plane-distance-to-the-camera-frame-1]
|
||||
|
||||
//! [compute-homography-from-camera-displacement]
|
||||
Mat homography_euclidean = computeHomography(R_1to2, t_1to2, d_inv1, normal1);
|
||||
Mat homography = cameraMatrix * homography_euclidean * cameraMatrix.inv();
|
||||
|
||||
homography /= homography.at<double>(2,2);
|
||||
homography_euclidean /= homography_euclidean.at<double>(2,2);
|
||||
//! [compute-homography-from-camera-displacement]
|
||||
|
||||
//Same but using absolute camera poses instead of camera displacement, just for check
|
||||
Mat homography_euclidean2 = computeHomography(R1, tvec1, R2, tvec2, d_inv1, normal1);
|
||||
Mat homography2 = cameraMatrix * homography_euclidean2 * cameraMatrix.inv();
|
||||
|
||||
homography_euclidean2 /= homography_euclidean2.at<double>(2,2);
|
||||
homography2 /= homography2.at<double>(2,2);
|
||||
|
||||
cout << "\nEuclidean Homography:\n" << homography_euclidean << endl;
|
||||
cout << "Euclidean Homography 2:\n" << homography_euclidean2 << endl << endl;
|
||||
|
||||
//! [estimate-homography]
|
||||
Mat H = findHomography(corners1, corners2);
|
||||
cout << "\nfindHomography H:\n" << H << endl;
|
||||
//! [estimate-homography]
|
||||
|
||||
cout << "homography from camera displacement:\n" << homography << endl;
|
||||
cout << "homography from absolute camera poses:\n" << homography2 << endl << endl;
|
||||
|
||||
//! [warp-chessboard]
|
||||
Mat img1_warp;
|
||||
warpPerspective(img1, img1_warp, H, img1.size());
|
||||
//! [warp-chessboard]
|
||||
|
||||
Mat img1_warp_custom;
|
||||
warpPerspective(img1, img1_warp_custom, homography, img1.size());
|
||||
imshow("Warped image using homography computed from camera displacement", img1_warp_custom);
|
||||
|
||||
Mat img_draw_compare;
|
||||
hconcat(img1_warp, img1_warp_custom, img_draw_compare);
|
||||
imshow("Warped images comparison", img_draw_compare);
|
||||
|
||||
Mat img1_warp_custom2;
|
||||
warpPerspective(img1, img1_warp_custom2, homography2, img1.size());
|
||||
imshow("Warped image using homography computed from absolute camera poses", img1_warp_custom2);
|
||||
|
||||
waitKey();
|
||||
}
|
||||
|
||||
const char* params
|
||||
= "{ help h | | print usage }"
|
||||
"{ image1 | left02.jpg | path to the source chessboard image }"
|
||||
"{ image2 | left01.jpg | path to the desired chessboard image }"
|
||||
"{ intrinsics | left_intrinsics.yml | path to camera intrinsics }"
|
||||
"{ width bw | 9 | chessboard width }"
|
||||
"{ height bh | 6 | chessboard height }"
|
||||
"{ square_size | 0.025 | chessboard square size }";
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
CommandLineParser parser(argc, argv, params);
|
||||
|
||||
if (parser.has("help"))
|
||||
{
|
||||
parser.about("Code for homography tutorial.\n"
|
||||
"Example 3: homography from the camera displacement.\n");
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Size patternSize(parser.get<int>("width"), parser.get<int>("height"));
|
||||
float squareSize = (float) parser.get<double>("square_size");
|
||||
homographyFromCameraDisplacement(parser.get<String>("image1"),
|
||||
parser.get<String>("image2"),
|
||||
patternSize, squareSize,
|
||||
parser.get<String>("intrinsics"));
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,90 @@
|
||||
#include <iostream>
|
||||
#include <opencv2/core.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace
|
||||
{
|
||||
void basicPanoramaStitching(const string &img1Path, const string &img2Path)
|
||||
{
|
||||
Mat img1 = imread( samples::findFile( img1Path ) );
|
||||
Mat img2 = imread( samples::findFile( img2Path ) );
|
||||
|
||||
//! [camera-pose-from-Blender-at-location-1]
|
||||
Mat c1Mo = (Mat_<double>(4,4) << 0.9659258723258972, 0.2588190734386444, 0.0, 1.5529145002365112,
|
||||
0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443,
|
||||
-0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654,
|
||||
0, 0, 0, 1);
|
||||
//! [camera-pose-from-Blender-at-location-1]
|
||||
|
||||
//! [camera-pose-from-Blender-at-location-2]
|
||||
Mat c2Mo = (Mat_<double>(4,4) << 0.9659258723258972, -0.2588190734386444, 0.0, -1.5529145002365112,
|
||||
-0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443,
|
||||
0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654,
|
||||
0, 0, 0, 1);
|
||||
//! [camera-pose-from-Blender-at-location-2]
|
||||
|
||||
//! [camera-intrinsics-from-Blender]
|
||||
Mat cameraMatrix = (Mat_<double>(3,3) << 700.0, 0.0, 320.0,
|
||||
0.0, 700.0, 240.0,
|
||||
0, 0, 1);
|
||||
//! [camera-intrinsics-from-Blender]
|
||||
|
||||
//! [extract-rotation]
|
||||
Mat R1 = c1Mo(Range(0,3), Range(0,3));
|
||||
Mat R2 = c2Mo(Range(0,3), Range(0,3));
|
||||
//! [extract-rotation]
|
||||
|
||||
//! [compute-rotation-displacement]
|
||||
//c1Mo * oMc2
|
||||
Mat R_2to1 = R1*R2.t();
|
||||
//! [compute-rotation-displacement]
|
||||
|
||||
//! [compute-homography]
|
||||
Mat H = cameraMatrix * R_2to1 * cameraMatrix.inv();
|
||||
H /= H.at<double>(2,2);
|
||||
cout << "H:\n" << H << endl;
|
||||
//! [compute-homography]
|
||||
|
||||
//! [stitch]
|
||||
Mat img_stitch;
|
||||
warpPerspective(img2, img_stitch, H, Size(img2.cols*2, img2.rows));
|
||||
Mat half = img_stitch(Rect(0, 0, img1.cols, img1.rows));
|
||||
img1.copyTo(half);
|
||||
//! [stitch]
|
||||
|
||||
Mat img_compare;
|
||||
Mat img_space = Mat::zeros(Size(50, img1.rows), CV_8UC3);
|
||||
hconcat(img1, img_space, img_compare);
|
||||
hconcat(img_compare, img2, img_compare);
|
||||
imshow("Compare images", img_compare);
|
||||
|
||||
imshow("Panorama stitching", img_stitch);
|
||||
waitKey();
|
||||
}
|
||||
|
||||
const char* params
|
||||
= "{ help h | | print usage }"
|
||||
"{ image1 | Blender_Suzanne1.jpg | path to the first Blender image }"
|
||||
"{ image2 | Blender_Suzanne2.jpg | path to the second Blender image }";
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
CommandLineParser parser(argc, argv, params);
|
||||
|
||||
if (parser.has("help"))
|
||||
{
|
||||
parser.about( "Code for homography tutorial.\n"
|
||||
"Example 5: basic panorama stitching from a rotating camera.\n" );
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
basicPanoramaStitching(parser.get<String>("image1"), parser.get<String>("image2"));
|
||||
|
||||
return 0;
|
||||
}
|
||||
96
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/Homography/perspective_correction.cpp
vendored
Normal file
96
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/Homography/perspective_correction.cpp
vendored
Normal file
@ -0,0 +1,96 @@
|
||||
#include <iostream>
|
||||
#include <opencv2/core.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/calib3d.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace
|
||||
{
|
||||
enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
|
||||
|
||||
Scalar randomColor( RNG& rng )
|
||||
{
|
||||
int icolor = (unsigned int) rng;
|
||||
return Scalar( icolor & 255, (icolor >> 8) & 255, (icolor >> 16) & 255 );
|
||||
}
|
||||
|
||||
void perspectiveCorrection(const string &img1Path, const string &img2Path, const Size &patternSize, RNG &rng)
|
||||
{
|
||||
Mat img1 = imread( samples::findFile(img1Path) );
|
||||
Mat img2 = imread( samples::findFile(img2Path) );
|
||||
|
||||
//! [find-corners]
|
||||
vector<Point2f> corners1, corners2;
|
||||
bool found1 = findChessboardCorners(img1, patternSize, corners1);
|
||||
bool found2 = findChessboardCorners(img2, patternSize, corners2);
|
||||
//! [find-corners]
|
||||
|
||||
if (!found1 || !found2)
|
||||
{
|
||||
cout << "Error, cannot find the chessboard corners in both images." << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
//! [estimate-homography]
|
||||
Mat H = findHomography(corners1, corners2);
|
||||
cout << "H:\n" << H << endl;
|
||||
//! [estimate-homography]
|
||||
|
||||
//! [warp-chessboard]
|
||||
Mat img1_warp;
|
||||
warpPerspective(img1, img1_warp, H, img1.size());
|
||||
//! [warp-chessboard]
|
||||
|
||||
Mat img_draw_warp;
|
||||
hconcat(img2, img1_warp, img_draw_warp);
|
||||
imshow("Desired chessboard view / Warped source chessboard view", img_draw_warp);
|
||||
|
||||
//! [compute-transformed-corners]
|
||||
Mat img_draw_matches;
|
||||
hconcat(img1, img2, img_draw_matches);
|
||||
for (size_t i = 0; i < corners1.size(); i++)
|
||||
{
|
||||
Mat pt1 = (Mat_<double>(3,1) << corners1[i].x, corners1[i].y, 1);
|
||||
Mat pt2 = H * pt1;
|
||||
pt2 /= pt2.at<double>(2);
|
||||
|
||||
Point end( (int) (img1.cols + pt2.at<double>(0)), (int) pt2.at<double>(1) );
|
||||
line(img_draw_matches, corners1[i], end, randomColor(rng), 2);
|
||||
}
|
||||
|
||||
imshow("Draw matches", img_draw_matches);
|
||||
waitKey();
|
||||
//! [compute-transformed-corners]
|
||||
}
|
||||
|
||||
const char* params
|
||||
= "{ help h | | print usage }"
|
||||
"{ image1 | left02.jpg | path to the source chessboard image }"
|
||||
"{ image2 | left01.jpg | path to the desired chessboard image }"
|
||||
"{ width bw | 9 | chessboard width }"
|
||||
"{ height bh | 6 | chessboard height }";
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
cv::RNG rng( 0xFFFFFFFF );
|
||||
CommandLineParser parser(argc, argv, params);
|
||||
|
||||
if (parser.has("help"))
|
||||
{
|
||||
parser.about("Code for homography tutorial.\n"
|
||||
"Example 2: perspective correction.\n");
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Size patternSize(parser.get<int>("width"), parser.get<int>("height"));
|
||||
perspectiveCorrection(parser.get<String>("image1"),
|
||||
parser.get<String>("image2"),
|
||||
patternSize, rng);
|
||||
|
||||
return 0;
|
||||
}
|
||||
155
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp
vendored
Normal file
155
3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/features2D/Homography/pose_from_homography.cpp
vendored
Normal file
@ -0,0 +1,155 @@
|
||||
#include <iostream>
|
||||
#include <opencv2/core.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/calib3d.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace
|
||||
{
|
||||
enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
|
||||
|
||||
void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners, Pattern patternType = CHESSBOARD)
|
||||
{
|
||||
corners.resize(0);
|
||||
|
||||
switch (patternType)
|
||||
{
|
||||
case CHESSBOARD:
|
||||
case CIRCLES_GRID:
|
||||
//! [compute-chessboard-object-points]
|
||||
for( int i = 0; i < boardSize.height; i++ )
|
||||
for( int j = 0; j < boardSize.width; j++ )
|
||||
corners.push_back(Point3f(float(j*squareSize),
|
||||
float(i*squareSize), 0));
|
||||
//! [compute-chessboard-object-points]
|
||||
break;
|
||||
|
||||
case ASYMMETRIC_CIRCLES_GRID:
|
||||
for( int i = 0; i < boardSize.height; i++ )
|
||||
for( int j = 0; j < boardSize.width; j++ )
|
||||
corners.push_back(Point3f(float((2*j + i % 2)*squareSize),
|
||||
float(i*squareSize), 0));
|
||||
break;
|
||||
|
||||
default:
|
||||
CV_Error(Error::StsBadArg, "Unknown pattern type\n");
|
||||
}
|
||||
}
|
||||
|
||||
void poseEstimationFromCoplanarPoints(const string &imgPath, const string &intrinsicsPath, const Size &patternSize,
|
||||
const float squareSize)
|
||||
{
|
||||
Mat img = imread( samples::findFile( imgPath) );
|
||||
Mat img_corners = img.clone(), img_pose = img.clone();
|
||||
|
||||
//! [find-chessboard-corners]
|
||||
vector<Point2f> corners;
|
||||
bool found = findChessboardCorners(img, patternSize, corners);
|
||||
//! [find-chessboard-corners]
|
||||
|
||||
if (!found)
|
||||
{
|
||||
cout << "Cannot find chessboard corners." << endl;
|
||||
return;
|
||||
}
|
||||
drawChessboardCorners(img_corners, patternSize, corners, found);
|
||||
imshow("Chessboard corners detection", img_corners);
|
||||
|
||||
//! [compute-object-points]
|
||||
vector<Point3f> objectPoints;
|
||||
calcChessboardCorners(patternSize, squareSize, objectPoints);
|
||||
vector<Point2f> objectPointsPlanar;
|
||||
for (size_t i = 0; i < objectPoints.size(); i++)
|
||||
{
|
||||
objectPointsPlanar.push_back(Point2f(objectPoints[i].x, objectPoints[i].y));
|
||||
}
|
||||
//! [compute-object-points]
|
||||
|
||||
//! [load-intrinsics]
|
||||
FileStorage fs( samples::findFile( intrinsicsPath ), FileStorage::READ);
|
||||
Mat cameraMatrix, distCoeffs;
|
||||
fs["camera_matrix"] >> cameraMatrix;
|
||||
fs["distortion_coefficients"] >> distCoeffs;
|
||||
//! [load-intrinsics]
|
||||
|
||||
//! [compute-image-points]
|
||||
vector<Point2f> imagePoints;
|
||||
undistortPoints(corners, imagePoints, cameraMatrix, distCoeffs);
|
||||
//! [compute-image-points]
|
||||
|
||||
//! [estimate-homography]
|
||||
Mat H = findHomography(objectPointsPlanar, imagePoints);
|
||||
cout << "H:\n" << H << endl;
|
||||
//! [estimate-homography]
|
||||
|
||||
//! [pose-from-homography]
|
||||
// Normalization to ensure that ||c1|| = 1
|
||||
double norm = sqrt(H.at<double>(0,0)*H.at<double>(0,0) +
|
||||
H.at<double>(1,0)*H.at<double>(1,0) +
|
||||
H.at<double>(2,0)*H.at<double>(2,0));
|
||||
|
||||
H /= norm;
|
||||
Mat c1 = H.col(0);
|
||||
Mat c2 = H.col(1);
|
||||
Mat c3 = c1.cross(c2);
|
||||
|
||||
Mat tvec = H.col(2);
|
||||
Mat R(3, 3, CV_64F);
|
||||
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
R.at<double>(i,0) = c1.at<double>(i,0);
|
||||
R.at<double>(i,1) = c2.at<double>(i,0);
|
||||
R.at<double>(i,2) = c3.at<double>(i,0);
|
||||
}
|
||||
//! [pose-from-homography]
|
||||
|
||||
//! [polar-decomposition-of-the-rotation-matrix]
|
||||
cout << "R (before polar decomposition):\n" << R << "\ndet(R): " << determinant(R) << endl;
|
||||
Mat W, U, Vt;
|
||||
SVDecomp(R, W, U, Vt);
|
||||
R = U*Vt;
|
||||
cout << "R (after polar decomposition):\n" << R << "\ndet(R): " << determinant(R) << endl;
|
||||
//! [polar-decomposition-of-the-rotation-matrix]
|
||||
|
||||
//! [display-pose]
|
||||
Mat rvec;
|
||||
Rodrigues(R, rvec);
|
||||
drawFrameAxes(img_pose, cameraMatrix, distCoeffs, rvec, tvec, 2*squareSize);
|
||||
imshow("Pose from coplanar points", img_pose);
|
||||
waitKey();
|
||||
//! [display-pose]
|
||||
}
|
||||
|
||||
const char* params
|
||||
= "{ help h | | print usage }"
|
||||
"{ image | left04.jpg | path to a chessboard image }"
|
||||
"{ intrinsics | left_intrinsics.yml | path to camera intrinsics }"
|
||||
"{ width bw | 9 | chessboard width }"
|
||||
"{ height bh | 6 | chessboard height }"
|
||||
"{ square_size | 0.025 | chessboard square size }";
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
CommandLineParser parser(argc, argv, params);
|
||||
|
||||
if (parser.has("help"))
|
||||
{
|
||||
parser.about("Code for homography tutorial.\n"
|
||||
"Example 1: pose from homography with coplanar points.\n");
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Size patternSize(parser.get<int>("width"), parser.get<int>("height"));
|
||||
float squareSize = (float) parser.get<double>("square_size");
|
||||
poseEstimationFromCoplanarPoints(parser.get<String>("image"),
|
||||
parser.get<String>("intrinsics"),
|
||||
patternSize, squareSize);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,60 @@
|
||||
#include <iostream>
|
||||
#include "opencv2/core.hpp"
|
||||
#ifdef HAVE_OPENCV_XFEATURES2D
|
||||
#include "opencv2/highgui.hpp"
|
||||
#include "opencv2/features2d.hpp"
|
||||
#include "opencv2/xfeatures2d.hpp"
|
||||
|
||||
using namespace cv;
|
||||
using namespace cv::xfeatures2d;
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
|
||||
const char* keys =
|
||||
"{ help h | | Print help message. }"
|
||||
"{ input1 | box.png | Path to input image 1. }"
|
||||
"{ input2 | box_in_scene.png | Path to input image 2. }";
|
||||
|
||||
int main( int argc, char* argv[] )
|
||||
{
|
||||
CommandLineParser parser( argc, argv, keys );
|
||||
Mat img1 = imread( samples::findFile( parser.get<String>("input1") ), IMREAD_GRAYSCALE );
|
||||
Mat img2 = imread( samples::findFile( parser.get<String>("input2") ), IMREAD_GRAYSCALE );
|
||||
if ( img1.empty() || img2.empty() )
|
||||
{
|
||||
cout << "Could not open or find the image!\n" << endl;
|
||||
parser.printMessage();
|
||||
return -1;
|
||||
}
|
||||
|
||||
//-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
|
||||
int minHessian = 400;
|
||||
Ptr<SURF> detector = SURF::create( minHessian );
|
||||
std::vector<KeyPoint> keypoints1, keypoints2;
|
||||
Mat descriptors1, descriptors2;
|
||||
detector->detectAndCompute( img1, noArray(), keypoints1, descriptors1 );
|
||||
detector->detectAndCompute( img2, noArray(), keypoints2, descriptors2 );
|
||||
|
||||
//-- Step 2: Matching descriptor vectors with a brute force matcher
|
||||
// Since SURF is a floating-point descriptor NORM_L2 is used
|
||||
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::BRUTEFORCE);
|
||||
std::vector< DMatch > matches;
|
||||
matcher->match( descriptors1, descriptors2, matches );
|
||||
|
||||
//-- Draw matches
|
||||
Mat img_matches;
|
||||
drawMatches( img1, keypoints1, img2, keypoints2, matches, img_matches );
|
||||
|
||||
//-- Show detected matches
|
||||
imshow("Matches", img_matches );
|
||||
|
||||
waitKey();
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
int main()
|
||||
{
|
||||
std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,46 @@
|
||||
#include <iostream>
|
||||
#include "opencv2/core.hpp"
|
||||
#ifdef HAVE_OPENCV_XFEATURES2D
|
||||
#include "opencv2/highgui.hpp"
|
||||
#include "opencv2/features2d.hpp"
|
||||
#include "opencv2/xfeatures2d.hpp"
|
||||
|
||||
using namespace cv;
|
||||
using namespace cv::xfeatures2d;
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
|
||||
int main( int argc, char* argv[] )
|
||||
{
|
||||
CommandLineParser parser( argc, argv, "{@input | box.png | input image}" );
|
||||
Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_GRAYSCALE );
|
||||
if ( src.empty() )
|
||||
{
|
||||
cout << "Could not open or find the image!\n" << endl;
|
||||
cout << "Usage: " << argv[0] << " <Input image>" << endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
//-- Step 1: Detect the keypoints using SURF Detector
|
||||
int minHessian = 400;
|
||||
Ptr<SURF> detector = SURF::create( minHessian );
|
||||
std::vector<KeyPoint> keypoints;
|
||||
detector->detect( src, keypoints );
|
||||
|
||||
//-- Draw keypoints
|
||||
Mat img_keypoints;
|
||||
drawKeypoints( src, keypoints, img_keypoints );
|
||||
|
||||
//-- Show detected (drawn) keypoints
|
||||
imshow("SURF Keypoints", img_keypoints );
|
||||
|
||||
waitKey();
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
int main()
|
||||
{
|
||||
std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,72 @@
|
||||
#include <iostream>
|
||||
#include "opencv2/core.hpp"
|
||||
#ifdef HAVE_OPENCV_XFEATURES2D
|
||||
#include "opencv2/highgui.hpp"
|
||||
#include "opencv2/features2d.hpp"
|
||||
#include "opencv2/xfeatures2d.hpp"
|
||||
|
||||
using namespace cv;
|
||||
using namespace cv::xfeatures2d;
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
|
||||
const char* keys =
|
||||
"{ help h | | Print help message. }"
|
||||
"{ input1 | box.png | Path to input image 1. }"
|
||||
"{ input2 | box_in_scene.png | Path to input image 2. }";
|
||||
|
||||
int main( int argc, char* argv[] )
|
||||
{
|
||||
CommandLineParser parser( argc, argv, keys );
|
||||
Mat img1 = imread( samples::findFile( parser.get<String>("input1") ), IMREAD_GRAYSCALE );
|
||||
Mat img2 = imread( samples::findFile( parser.get<String>("input2") ), IMREAD_GRAYSCALE );
|
||||
if ( img1.empty() || img2.empty() )
|
||||
{
|
||||
cout << "Could not open or find the image!\n" << endl;
|
||||
parser.printMessage();
|
||||
return -1;
|
||||
}
|
||||
|
||||
//-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
|
||||
int minHessian = 400;
|
||||
Ptr<SURF> detector = SURF::create( minHessian );
|
||||
std::vector<KeyPoint> keypoints1, keypoints2;
|
||||
Mat descriptors1, descriptors2;
|
||||
detector->detectAndCompute( img1, noArray(), keypoints1, descriptors1 );
|
||||
detector->detectAndCompute( img2, noArray(), keypoints2, descriptors2 );
|
||||
|
||||
//-- Step 2: Matching descriptor vectors with a FLANN based matcher
|
||||
// Since SURF is a floating-point descriptor NORM_L2 is used
|
||||
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
|
||||
std::vector< std::vector<DMatch> > knn_matches;
|
||||
matcher->knnMatch( descriptors1, descriptors2, knn_matches, 2 );
|
||||
|
||||
//-- Filter matches using the Lowe's ratio test
|
||||
const float ratio_thresh = 0.7f;
|
||||
std::vector<DMatch> good_matches;
|
||||
for (size_t i = 0; i < knn_matches.size(); i++)
|
||||
{
|
||||
if (knn_matches[i][0].distance < ratio_thresh * knn_matches[i][1].distance)
|
||||
{
|
||||
good_matches.push_back(knn_matches[i][0]);
|
||||
}
|
||||
}
|
||||
|
||||
//-- Draw matches
|
||||
Mat img_matches;
|
||||
drawMatches( img1, keypoints1, img2, keypoints2, good_matches, img_matches, Scalar::all(-1),
|
||||
Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
|
||||
|
||||
//-- Show detected matches
|
||||
imshow("Good Matches", img_matches );
|
||||
|
||||
waitKey();
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
int main()
|
||||
{
|
||||
std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,107 @@
|
||||
#include <iostream>
|
||||
#include "opencv2/core.hpp"
|
||||
#ifdef HAVE_OPENCV_XFEATURES2D
|
||||
#include "opencv2/calib3d.hpp"
|
||||
#include "opencv2/highgui.hpp"
|
||||
#include "opencv2/imgproc.hpp"
|
||||
#include "opencv2/features2d.hpp"
|
||||
#include "opencv2/xfeatures2d.hpp"
|
||||
|
||||
using namespace cv;
|
||||
using namespace cv::xfeatures2d;
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
|
||||
const char* keys =
|
||||
"{ help h | | Print help message. }"
|
||||
"{ input1 | box.png | Path to input image 1. }"
|
||||
"{ input2 | box_in_scene.png | Path to input image 2. }";
|
||||
|
||||
int main( int argc, char* argv[] )
|
||||
{
|
||||
CommandLineParser parser( argc, argv, keys );
|
||||
Mat img_object = imread( samples::findFile( parser.get<String>("input1") ), IMREAD_GRAYSCALE );
|
||||
Mat img_scene = imread( samples::findFile( parser.get<String>("input2") ), IMREAD_GRAYSCALE );
|
||||
if ( img_object.empty() || img_scene.empty() )
|
||||
{
|
||||
cout << "Could not open or find the image!\n" << endl;
|
||||
parser.printMessage();
|
||||
return -1;
|
||||
}
|
||||
|
||||
//-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
|
||||
int minHessian = 400;
|
||||
Ptr<SURF> detector = SURF::create( minHessian );
|
||||
std::vector<KeyPoint> keypoints_object, keypoints_scene;
|
||||
Mat descriptors_object, descriptors_scene;
|
||||
detector->detectAndCompute( img_object, noArray(), keypoints_object, descriptors_object );
|
||||
detector->detectAndCompute( img_scene, noArray(), keypoints_scene, descriptors_scene );
|
||||
|
||||
//-- Step 2: Matching descriptor vectors with a FLANN based matcher
|
||||
// Since SURF is a floating-point descriptor NORM_L2 is used
|
||||
Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
|
||||
std::vector< std::vector<DMatch> > knn_matches;
|
||||
matcher->knnMatch( descriptors_object, descriptors_scene, knn_matches, 2 );
|
||||
|
||||
//-- Filter matches using the Lowe's ratio test
|
||||
const float ratio_thresh = 0.75f;
|
||||
std::vector<DMatch> good_matches;
|
||||
for (size_t i = 0; i < knn_matches.size(); i++)
|
||||
{
|
||||
if (knn_matches[i][0].distance < ratio_thresh * knn_matches[i][1].distance)
|
||||
{
|
||||
good_matches.push_back(knn_matches[i][0]);
|
||||
}
|
||||
}
|
||||
|
||||
//-- Draw matches
|
||||
Mat img_matches;
|
||||
drawMatches( img_object, keypoints_object, img_scene, keypoints_scene, good_matches, img_matches, Scalar::all(-1),
|
||||
Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
|
||||
|
||||
//-- Localize the object
|
||||
std::vector<Point2f> obj;
|
||||
std::vector<Point2f> scene;
|
||||
|
||||
for( size_t i = 0; i < good_matches.size(); i++ )
|
||||
{
|
||||
//-- Get the keypoints from the good matches
|
||||
obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt );
|
||||
scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt );
|
||||
}
|
||||
|
||||
Mat H = findHomography( obj, scene, RANSAC );
|
||||
|
||||
//-- Get the corners from the image_1 ( the object to be "detected" )
|
||||
std::vector<Point2f> obj_corners(4);
|
||||
obj_corners[0] = Point2f(0, 0);
|
||||
obj_corners[1] = Point2f( (float)img_object.cols, 0 );
|
||||
obj_corners[2] = Point2f( (float)img_object.cols, (float)img_object.rows );
|
||||
obj_corners[3] = Point2f( 0, (float)img_object.rows );
|
||||
std::vector<Point2f> scene_corners(4);
|
||||
|
||||
perspectiveTransform( obj_corners, scene_corners, H);
|
||||
|
||||
//-- Draw lines between the corners (the mapped object in the scene - image_2 )
|
||||
line( img_matches, scene_corners[0] + Point2f((float)img_object.cols, 0),
|
||||
scene_corners[1] + Point2f((float)img_object.cols, 0), Scalar(0, 255, 0), 4 );
|
||||
line( img_matches, scene_corners[1] + Point2f((float)img_object.cols, 0),
|
||||
scene_corners[2] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
|
||||
line( img_matches, scene_corners[2] + Point2f((float)img_object.cols, 0),
|
||||
scene_corners[3] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
|
||||
line( img_matches, scene_corners[3] + Point2f((float)img_object.cols, 0),
|
||||
scene_corners[0] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
|
||||
|
||||
//-- Show detected matches
|
||||
imshow("Good Matches & Object detection", img_matches );
|
||||
|
||||
waitKey();
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
int main()
|
||||
{
|
||||
std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user