:param P: New camera matrix (3x3) or new projection matrix (3x4)
- :param new_size: New size
-
- :param balance: Balance.
-
- :param fov_scale: Field of View scale.
-
Fisheye::stereoRectify
------------------------------
Stereo rectification for fisheye camera model
OutputArray out, OutputArray inliers,
double ransacThreshold=3, double confidence=0.99);
-
class Fisheye
{
public:
- //Definitions:
- // Let P be a point in 3D of coordinates X in the world reference frame (stored in the matrix X)
- // The coordinate vector of P in the camera reference frame is: Xc = R*X + T
- // where R is the rotation matrix corresponding to the rotation vector om: R = rodrigues(om);
- // call x, y and z the 3 coordinates of Xc: x = Xc(1); y = Xc(2); z = Xc(3);
- // The pinehole projection coordinates of P is [a;b] where a=x/z and b=y/z.
- // call r^2 = a^2 + b^2,
- // call theta = atan(r),
- //
- // Fisheye distortion -> theta_d = theta * (1 + k(1)*theta^2 + k(2)*theta^4 + k(3)*theta^6 + k(4)*theta^8)
- //
- // The distorted point coordinates are: xd = [xx;yy] where:
- //
- // xx = (theta_d / r) * x
- // yy = (theta_d / r) * y
- //
- // Finally, convertion into pixel coordinates: The final pixel coordinates vector xp=[xxp;yyp] where:
- //
- // xxp = f(1)*(xx + alpha*yy) + c(1)
- // yyp = f(2)*yy + c(2)
-
enum{
CALIB_USE_INTRINSIC_GUESS = 1,
CALIB_RECOMPUTE_EXTRINSIC = 2,
double balance = 0.0, double fov_scale = 1.0);
};
-
-
-namespace internal {
-
-struct IntrinsicParams
-{
- Vec2d f;
- Vec2d c;
- Vec4d k;
- double alpha;
- std::vector<int> isEstimate;
-
- IntrinsicParams();
- IntrinsicParams(Vec2d f, Vec2d c, Vec4d k, double alpha = 0);
- IntrinsicParams operator+(const Mat& a);
- IntrinsicParams& operator =(const Mat& a);
- void Init(const cv::Vec2d& f, const cv::Vec2d& c, const cv::Vec4d& k = Vec4d(0,0,0,0), const double& alpha = 0);
-};
-
-void projectPoints(cv::InputArray objectPoints, cv::OutputArray imagePoints,
- cv::InputArray _rvec,cv::InputArray _tvec,
- const IntrinsicParams& param, cv::OutputArray jacobian);
-
-void ComputeExtrinsicRefine(const Mat& imagePoints, const Mat& objectPoints, Mat& rvec,
- Mat& tvec, Mat& J, const int MaxIter,
- const IntrinsicParams& param, const double thresh_cond);
-Mat ComputeHomography(Mat m, Mat M);
-
-Mat NormalizePixels(const Mat& imagePoints, const IntrinsicParams& param);
-
-void InitExtrinsics(const Mat& _imagePoints, const Mat& _objectPoints, const IntrinsicParams& param, Mat& omckk, Mat& Tckk);
-
-void CalibrateExtrinsics(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
- const IntrinsicParams& param, const int check_cond,
- const double thresh_cond, InputOutputArray omc, InputOutputArray Tc);
-
-void ComputeJacobians(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
- const IntrinsicParams& param, InputArray omc, InputArray Tc,
- const int& check_cond, const double& thresh_cond, Mat& JJ2_inv, Mat& ex3);
-
-void EstimateUncertainties(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
- const IntrinsicParams& params, InputArray omc, InputArray Tc,
- IntrinsicParams& errors, Vec2d& std_err, double thresh_cond, int check_cond, double& rms);
-
-}
}
#endif
-
#endif
#include "opencv2/opencv.hpp"
#include "opencv2/core/affine.hpp"
#include "opencv2/core/affine.hpp"
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::projectPoints
+#include "fisheye.hpp"
namespace cv { namespace
{
};
}}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/// cv::Fisheye::projectPoints
+
void cv::Fisheye::projectPoints(InputArray objectPoints, OutputArray imagePoints, const Affine3d& affine,
InputArray K, InputArray D, double alpha, OutputArray jacobian)
{
--- /dev/null
+#ifndef FISHEYE_INTERNAL_H
+#define FISHEYE_INTERNAL_H
+
+namespace cv { namespace internal {
+
+struct IntrinsicParams
+{
+ Vec2d f;
+ Vec2d c;
+ Vec4d k;
+ double alpha;
+ std::vector<int> isEstimate;
+
+ IntrinsicParams();
+ IntrinsicParams(Vec2d f, Vec2d c, Vec4d k, double alpha = 0);
+ IntrinsicParams operator+(const Mat& a);
+ IntrinsicParams& operator =(const Mat& a);
+ void Init(const cv::Vec2d& f, const cv::Vec2d& c, const cv::Vec4d& k = Vec4d(0,0,0,0), const double& alpha = 0);
+};
+
+void projectPoints(cv::InputArray objectPoints, cv::OutputArray imagePoints,
+ cv::InputArray _rvec,cv::InputArray _tvec,
+ const IntrinsicParams& param, cv::OutputArray jacobian);
+
+void ComputeExtrinsicRefine(const Mat& imagePoints, const Mat& objectPoints, Mat& rvec,
+ Mat& tvec, Mat& J, const int MaxIter,
+ const IntrinsicParams& param, const double thresh_cond);
+Mat ComputeHomography(Mat m, Mat M);
+
+Mat NormalizePixels(const Mat& imagePoints, const IntrinsicParams& param);
+
+void InitExtrinsics(const Mat& _imagePoints, const Mat& _objectPoints, const IntrinsicParams& param, Mat& omckk, Mat& Tckk);
+
+void CalibrateExtrinsics(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
+ const IntrinsicParams& param, const int check_cond,
+ const double thresh_cond, InputOutputArray omc, InputOutputArray Tc);
+
+void ComputeJacobians(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
+ const IntrinsicParams& param, InputArray omc, InputArray Tc,
+ const int& check_cond, const double& thresh_cond, Mat& JJ2_inv, Mat& ex3);
+
+void EstimateUncertainties(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
+ const IntrinsicParams& params, InputArray omc, InputArray Tc,
+ IntrinsicParams& errors, Vec2d& std_err, double thresh_cond, int check_cond, double& rms);
+
+}}
+
+#endif
#include "test_precomp.hpp"
-#include<fstream>
+#include <fstream>
#include <opencv2/ts/gpu_test.hpp>
+#include "../src/fisheye.hpp"
class FisheyeTest : public ::testing::Test {
std::string combine_format(const std::string& item1, const std::string& item2, ...);
- void readPoins(std::vector<std::vector<cv::Point3d> >& objectPoints,
+ void readPoints(std::vector<std::vector<cv::Point3d> >& objectPoints,
std::vector<std::vector<cv::Point2d> >& imagePoints,
- const std::string& path, const int n_images, const int n_points);
+ const std::string& path, const int n_images);
void readExtrinsics(const std::string& file, cv::OutputArray _R, cv::OutputArray _T, cv::OutputArray _R1, cv::OutputArray _R2,
cv::OutputArray _P1, cv::OutputArray _P2, cv::OutputArray _Q);
else
EXPECT_MAT_NEAR(correct, undistorted, 1e-10);
}
-
- cv::waitKey();
}
TEST_F(FisheyeTest, jacobians)
TEST_F(FisheyeTest, Calibration)
{
const int n_images = 34;
- const int n_points = 48;
- cv::Size imageSize = cv::Size(1280, 800);
std::vector<std::vector<cv::Point2d> > imagePoints;
std::vector<std::vector<cv::Point3d> > objectPoints;
- readPoins(objectPoints, imagePoints, combine(datasets_repository_path, "calib-3_stereo_from_JY/left"), n_images, n_points);
+ readPoints(objectPoints, imagePoints, combine(datasets_repository_path, "calib-3_stereo_from_JY/left"), n_images);
int flag = 0;
flag |= cv::Fisheye::CALIB_RECOMPUTE_EXTRINSIC;
TEST_F(FisheyeTest, Homography)
{
const int n_images = 1;
- const int n_points = 48;
- cv::Size imageSize = cv::Size(1280, 800);
std::vector<std::vector<cv::Point2d> > imagePoints;
std::vector<std::vector<cv::Point3d> > objectPoints;
- readPoins(objectPoints, imagePoints, combine(datasets_repository_path, "calib-3_stereo_from_JY/left"), n_images, n_points);
+ readPoints(objectPoints, imagePoints, combine(datasets_repository_path, "calib-3_stereo_from_JY/left"), n_images);
cv::internal::IntrinsicParams param;
param.Init(cv::Vec2d(cv::max(imageSize.width, imageSize.height) / CV_PI, cv::max(imageSize.width, imageSize.height) / CV_PI),
cv::Vec2d(imageSize.width / 2.0 - 0.5, imageSize.height / 2.0 - 0.5));
TEST_F(FisheyeTest, EtimateUncertainties)
{
const int n_images = 34;
- const int n_points = 48;
- cv::Size imageSize = cv::Size(1280, 800);
std::vector<std::vector<cv::Point2d> > imagePoints;
std::vector<std::vector<cv::Point3d> > objectPoints;
- readPoins(objectPoints, imagePoints, combine(datasets_repository_path, "calib-3_stereo_from_JY/left"), n_images, n_points);
+ readPoints(objectPoints, imagePoints, combine(datasets_repository_path, "calib-3_stereo_from_JY/left"), n_images);
int flag = 0;
flag |= cv::Fisheye::CALIB_RECOMPUTE_EXTRINSIC;
EXPECT_MAT_NEAR(err_std, cv::Vec2d(0.187475975266883, 0.185678953263995), 1e-10);
CV_Assert(abs(rms - 0.263782587133546) < 1e-10);
CV_Assert(errors.alpha == 0);
- }
+}
TEST_F(FisheyeTest, rectify)
{
}
}
-
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FisheyeTest::
const cv::Vec3d FisheyeTest::T(-9.9217369356044638e-02, 3.1741831972356663e-03, 1.8551007952921010e-04);
-
std::string FisheyeTest::combine(const std::string& _item1, const std::string& _item2)
{
std::string item1 = _item1, item2 = _item2;
return std::string(buffer);
}
-void FisheyeTest::readPoins(std::vector<std::vector<cv::Point3d> >& objectPoints,
+void FisheyeTest::readPoints(std::vector<std::vector<cv::Point3d> >& objectPoints,
std::vector<std::vector<cv::Point2d> >& imagePoints,
- const std::string& path, const int n_images, const int n_points)
+ const std::string& path, const int n_images)
{
objectPoints.resize(n_images);
imagePoints.resize(n_images);
- std::vector<cv::Point2d> image(n_points);
- std::vector<cv::Point3d> object(n_points);
-
- std::ifstream ipStream;
- std::ifstream opStream;
-
- for (int image_idx = 0; image_idx < n_images; image_idx++)
+ cv::FileStorage fs1(combine(path, "objectPoints.xml"), cv::FileStorage::READ);
+ CV_Assert(fs1.isOpened());
+ for (size_t i = 0; i < objectPoints.size(); ++i)
{
- std::stringstream ss;
- ss << image_idx;
- std::string idxStr = ss.str();
-
- ipStream.open(combine(path, std::string(std::string("x_") + idxStr + std::string(".csv"))).c_str(), std::ifstream::in);
- opStream.open(combine(path, std::string(std::string("X_") + idxStr + std::string(".csv"))).c_str(), std::ifstream::in);
- CV_Assert(ipStream.is_open() && opStream.is_open());
-
- for (int point_idx = 0; point_idx < n_points; point_idx++)
- {
- double x, y, z;
- char delim;
- ipStream >> x >> delim >> y;
- image[point_idx] = cv::Point2d(x, y);
- opStream >> x >> delim >> y >> delim >> z;
- object[point_idx] = cv::Point3d(x, y, z);
- }
- ipStream.close();
- opStream.close();
+ fs1[cv::format("image_%d", i)] >> objectPoints[i];
+ }
+ fs1.release();
- imagePoints[image_idx] = image;
- objectPoints[image_idx] = object;
+ cv::FileStorage fs2(combine(path, "imagePoints.xml"), cv::FileStorage::READ);
+ CV_Assert(fs2.isOpened());
+ for (size_t i = 0; i < imagePoints.size(); ++i)
+ {
+ fs2[cv::format("image_%d", i)] >> imagePoints[i];
}
+ fs2.release();
}
void FisheyeTest::readExtrinsics(const std::string& file, cv::OutputArray _R, cv::OutputArray _T, cv::OutputArray _R1, cv::OutputArray _R2,
projects / platform / upstream / opencv.git / commitdiff