OutputArray out, OutputArray inliers,
double ransacThreshold=3, double confidence=0.99);
-class CV_EXPORTS Fisheye
+namespace fisheye
{
-public:
-
enum{
CALIB_USE_INTRINSIC_GUESS = 1,
CALIB_RECOMPUTE_EXTRINSIC = 2,
};
//! projects 3D points using fisheye model
- static void projectPoints(InputArray objectPoints, OutputArray imagePoints, const Affine3d& affine,
+ CV_EXPORTS void projectPoints(InputArray objectPoints, OutputArray imagePoints, const Affine3d& affine,
InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());
//! projects points using fisheye model
- static void projectPoints(InputArray objectPoints, OutputArray imagePoints, InputArray rvec, InputArray tvec,
+ CV_EXPORTS void projectPoints(InputArray objectPoints, OutputArray imagePoints, InputArray rvec, InputArray tvec,
InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());
//! distorts 2D points using fisheye model
- static void distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha = 0);
+ CV_EXPORTS void distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha = 0);
//! undistorts 2D points using fisheye model
- static void undistortPoints(InputArray distorted, OutputArray undistorted,
+ CV_EXPORTS void undistortPoints(InputArray distorted, OutputArray undistorted,
InputArray K, InputArray D, InputArray R = noArray(), InputArray P = noArray());
//! computing undistortion and rectification maps for image transform by cv::remap()
//! If D is empty zero distortion is used, if R or P is empty identity matrixes are used
- static void initUndistortRectifyMap(InputArray K, InputArray D, InputArray R, InputArray P,
+ CV_EXPORTS void initUndistortRectifyMap(InputArray K, InputArray D, InputArray R, InputArray P,
const cv::Size& size, int m1type, OutputArray map1, OutputArray map2);
//! undistorts image, optionally changes resolution and camera matrix. If Knew zero identity matrix is used
- static void undistortImage(InputArray distorted, OutputArray undistorted,
+ CV_EXPORTS void undistortImage(InputArray distorted, OutputArray undistorted,
InputArray K, InputArray D, InputArray Knew = cv::noArray(), const Size& new_size = Size());
//! estimates new camera matrix for undistortion or rectification
- static void estimateNewCameraMatrixForUndistortRectify(InputArray K, InputArray D, const Size &image_size, InputArray R,
+ CV_EXPORTS void estimateNewCameraMatrixForUndistortRectify(InputArray K, InputArray D, const Size &image_size, InputArray R,
OutputArray P, double balance = 0.0, const Size& new_size = Size(), double fov_scale = 1.0);
//! performs camera calibaration
- static double calibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, const Size& image_size,
+ CV_EXPORTS double calibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, const Size& image_size,
InputOutputArray K, InputOutputArray D, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags = 0,
TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
//! stereo rectification estimation
- static void stereoRectify(InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size &imageSize, InputArray R, InputArray tvec,
+ CV_EXPORTS void stereoRectify(InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size &imageSize, InputArray R, InputArray tvec,
OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags, const Size &newImageSize = Size(),
double balance = 0.0, double fov_scale = 1.0);
//! performs stereo calibaration
- static double stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+ CV_EXPORTS double stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
InputOutputArray K1, InputOutputArray D1, InputOutputArray K2, InputOutputArray D2, Size imageSize,
OutputArray R, OutputArray T, int flags = CALIB_FIX_INTRINSIC,
TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
-};
+}
}
}}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::projectPoints
+/// cv::fisheye::projectPoints
-void cv::Fisheye::projectPoints(InputArray objectPoints, OutputArray imagePoints, const Affine3d& affine,
+void cv::fisheye::projectPoints(InputArray objectPoints, OutputArray imagePoints, const Affine3d& affine,
InputArray K, InputArray D, double alpha, OutputArray jacobian)
{
projectPoints(objectPoints, imagePoints, affine.rvec(), affine.translation(), K, D, alpha, jacobian);
}
-void cv::Fisheye::projectPoints(InputArray objectPoints, OutputArray imagePoints, InputArray _rvec,
+void cv::fisheye::projectPoints(InputArray objectPoints, OutputArray imagePoints, InputArray _rvec,
InputArray _tvec, InputArray _K, InputArray _D, double alpha, OutputArray jacobian)
{
// will support only 3-channel data now for points
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::distortPoints
+/// cv::fisheye::distortPoints
-void cv::Fisheye::distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha)
+void cv::fisheye::distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha)
{
// will support only 2-channel data now for points
CV_Assert(undistorted.type() == CV_32FC2 || undistorted.type() == CV_64FC2);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::undistortPoints
+/// cv::fisheye::undistortPoints
-void cv::Fisheye::undistortPoints( InputArray distorted, OutputArray undistorted, InputArray _K, InputArray _D, InputArray _R, InputArray _P)
+void cv::fisheye::undistortPoints( InputArray distorted, OutputArray undistorted, InputArray _K, InputArray _D, InputArray _R, InputArray _P)
{
// will support only 2-channel data now for points
CV_Assert(distorted.type() == CV_32FC2 || distorted.type() == CV_64FC2);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::undistortPoints
+/// cv::fisheye::undistortPoints
-void cv::Fisheye::initUndistortRectifyMap( InputArray _K, InputArray _D, InputArray _R, InputArray _P,
+void cv::fisheye::initUndistortRectifyMap( InputArray _K, InputArray _D, InputArray _R, InputArray _P,
const cv::Size& size, int m1type, OutputArray map1, OutputArray map2 )
{
CV_Assert( m1type == CV_16SC2 || m1type == CV_32F || m1type <=0 );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::undistortImage
+/// cv::fisheye::undistortImage
-void cv::Fisheye::undistortImage(InputArray distorted, OutputArray undistorted,
+void cv::fisheye::undistortImage(InputArray distorted, OutputArray undistorted,
InputArray K, InputArray D, InputArray Knew, const Size& new_size)
{
Size size = new_size.area() != 0 ? new_size : distorted.size();
cv::Mat map1, map2;
- initUndistortRectifyMap(K, D, cv::Matx33d::eye(), Knew, size, CV_16SC2, map1, map2 );
+ fisheye::initUndistortRectifyMap(K, D, cv::Matx33d::eye(), Knew, size, CV_16SC2, map1, map2 );
cv::remap(distorted, undistorted, map1, map2, INTER_LINEAR, BORDER_CONSTANT);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::estimateNewCameraMatrixForUndistortRectify
+/// cv::fisheye::estimateNewCameraMatrixForUndistortRectify
-void cv::Fisheye::estimateNewCameraMatrixForUndistortRectify(InputArray K, InputArray D, const Size &image_size, InputArray R,
+void cv::fisheye::estimateNewCameraMatrixForUndistortRectify(InputArray K, InputArray D, const Size &image_size, InputArray R,
OutputArray P, double balance, const Size& new_size, double fov_scale)
{
CV_Assert( K.size() == Size(3, 3) && (K.depth() == CV_32F || K.depth() == CV_64F));
}
#endif
- undistortPoints(points, points, K, D, R);
+ fisheye::undistortPoints(points, points, K, D, R);
cv::Scalar center_mass = mean(points);
cv::Vec2d cn(center_mass.val);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::stereoRectify
+/// cv::fisheye::stereoRectify
-void cv::Fisheye::stereoRectify( InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size& imageSize,
+void cv::fisheye::stereoRectify( InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size& imageSize,
InputArray _R, InputArray _tvec, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2,
OutputArray Q, int flags, const Size& newImageSize, double balance, double fov_scale)
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::calibrate
+/// cv::fisheye::calibrate
-double cv::Fisheye::calibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, const Size& image_size,
+double cv::fisheye::calibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, const Size& image_size,
InputOutputArray K, InputOutputArray D, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
int flags , cv::TermCriteria criteria)
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// cv::Fisheye::stereoCalibrate
+/// cv::fisheye::stereoCalibrate
-double cv::Fisheye::stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+double cv::fisheye::stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
InputOutputArray K1, InputOutputArray D1, InputOutputArray K2, InputOutputArray D2, Size imageSize,
OutputArray R, OutputArray T, int flags, TermCriteria criteria)
{
Matx33d K(param.f[0], param.f[0] * param.alpha, param.c[0],
0, param.f[1], param.c[1],
0, 0, 1);
- Fisheye::projectPoints(objectPoints, imagePoints, _rvec, _tvec, K, param.k, param.alpha, jacobian);
+ fisheye::projectPoints(objectPoints, imagePoints, _rvec, _tvec, K, param.k, param.alpha, jacobian);
}
void cv::internal::ComputeExtrinsicRefine(const Mat& imagePoints, const Mat& objectPoints, Mat& rvec,
ptr_d[i] = (ptr[i] - param.c).mul(Vec2d(1.0 / param.f[0], 1.0 / param.f[1]));
ptr_d[i][0] = ptr_d[i][0] - param.alpha * ptr_d[i][1];
}
- cv::Fisheye::undistortPoints(distorted, undistorted, Matx33d::eye(), param.k);
+ cv::fisheye::undistortPoints(distorted, undistorted, Matx33d::eye(), param.k);
return undistorted;
}
#include <opencv2/ts/gpu_test.hpp>
#include "../src/fisheye.hpp"
-class FisheyeTest : public ::testing::Test {
+class fisheyeTest : public ::testing::Test {
protected:
const static cv::Size imageSize;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TESTS::
-TEST_F(FisheyeTest, projectPoints)
+TEST_F(fisheyeTest, projectPoints)
{
double cols = this->imageSize.width,
rows = this->imageSize.height;
pts[k++] = (point - c) * 0.85 + c;
}
- cv::Fisheye::undistortPoints(distorted0, undist1, this->K, this->D);
+ cv::fisheye::undistortPoints(distorted0, undist1, this->K, this->D);
cv::Vec2d* u1 = undist1.ptr<cv::Vec2d>();
cv::Vec3d* u2 = undist2.ptr<cv::Vec3d>();
for(int i = 0; i < (int)distorted0.total(); ++i)
u2[i] = cv::Vec3d(u1[i][0], u1[i][1], 1.0);
- cv::Fisheye::distortPoints(undist1, distorted1, this->K, this->D);
- cv::Fisheye::projectPoints(undist2, distorted2, cv::Vec3d::all(0), cv::Vec3d::all(0), this->K, this->D);
+ cv::fisheye::distortPoints(undist1, distorted1, this->K, this->D);
+ cv::fisheye::projectPoints(undist2, distorted2, cv::Vec3d::all(0), cv::Vec3d::all(0), this->K, this->D);
EXPECT_MAT_NEAR(distorted0, distorted1, 1e-10);
EXPECT_MAT_NEAR(distorted0, distorted2, 1e-10);
}
-TEST_F(FisheyeTest, undistortImage)
+TEST_F(fisheyeTest, undistortImage)
{
cv::Matx33d K = this->K;
cv::Mat D = cv::Mat(this->D);
{
newK(0, 0) = 100;
newK(1, 1) = 100;
- cv::Fisheye::undistortImage(distorted, undistorted, K, D, newK);
+ cv::fisheye::undistortImage(distorted, undistorted, K, D, newK);
cv::Mat correct = cv::imread(combine(datasets_repository_path, "new_f_100.png"));
if (correct.empty())
CV_Assert(cv::imwrite(combine(datasets_repository_path, "new_f_100.png"), undistorted));
}
{
double balance = 1.0;
- cv::Fisheye::estimateNewCameraMatrixForUndistortRectify(K, D, distorted.size(), cv::noArray(), newK, balance);
- cv::Fisheye::undistortImage(distorted, undistorted, K, D, newK);
+ cv::fisheye::estimateNewCameraMatrixForUndistortRectify(K, D, distorted.size(), cv::noArray(), newK, balance);
+ cv::fisheye::undistortImage(distorted, undistorted, K, D, newK);
cv::Mat correct = cv::imread(combine(datasets_repository_path, "balance_1.0.png"));
if (correct.empty())
CV_Assert(cv::imwrite(combine(datasets_repository_path, "balance_1.0.png"), undistorted));
{
double balance = 0.0;
- cv::Fisheye::estimateNewCameraMatrixForUndistortRectify(K, D, distorted.size(), cv::noArray(), newK, balance);
- cv::Fisheye::undistortImage(distorted, undistorted, K, D, newK);
+ cv::fisheye::estimateNewCameraMatrixForUndistortRectify(K, D, distorted.size(), cv::noArray(), newK, balance);
+ cv::fisheye::undistortImage(distorted, undistorted, K, D, newK);
cv::Mat correct = cv::imread(combine(datasets_repository_path, "balance_0.0.png"));
if (correct.empty())
CV_Assert(cv::imwrite(combine(datasets_repository_path, "balance_0.0.png"), undistorted));
}
}
-TEST_F(FisheyeTest, jacobians)
+TEST_F(fisheyeTest, jacobians)
{
int n = 10;
cv::Mat X(1, n, CV_64FC3);
0, 0, 1);
cv::Mat jacobians;
- cv::Fisheye::projectPoints(X, x1, om, T, K, k, alpha, jacobians);
+ cv::fisheye::projectPoints(X, x1, om, T, K, k, alpha, jacobians);
//test on T:
cv::Mat dT(3, 1, CV_64FC1);
r.fill(dT, cv::RNG::NORMAL, 0, 1);
dT *= 1e-9*cv::norm(T);
cv::Mat T2 = T + dT;
- cv::Fisheye::projectPoints(X, x2, om, T2, K, k, alpha, cv::noArray());
+ cv::fisheye::projectPoints(X, x2, om, T2, K, k, alpha, cv::noArray());
xpred = x1 + cv::Mat(jacobians.colRange(11,14) * dT).reshape(2, 1);
CV_Assert (cv::norm(x2 - xpred) < 1e-10);
r.fill(dom, cv::RNG::NORMAL, 0, 1);
dom *= 1e-9*cv::norm(om);
cv::Mat om2 = om + dom;
- cv::Fisheye::projectPoints(X, x2, om2, T, K, k, alpha, cv::noArray());
+ cv::fisheye::projectPoints(X, x2, om2, T, K, k, alpha, cv::noArray());
xpred = x1 + cv::Mat(jacobians.colRange(8,11) * dom).reshape(2, 1);
CV_Assert (cv::norm(x2 - xpred) < 1e-10);
r.fill(df, cv::RNG::NORMAL, 0, 1);
df *= 1e-9*cv::norm(f);
cv::Matx33d K2 = K + cv::Matx33d(df.at<double>(0), df.at<double>(0) * alpha, 0, 0, df.at<double>(1), 0, 0, 0, 0);
- cv::Fisheye::projectPoints(X, x2, om, T, K2, k, alpha, cv::noArray());
+ cv::fisheye::projectPoints(X, x2, om, T, K2, k, alpha, cv::noArray());
xpred = x1 + cv::Mat(jacobians.colRange(0,2) * df).reshape(2, 1);
CV_Assert (cv::norm(x2 - xpred) < 1e-10);
r.fill(dc, cv::RNG::NORMAL, 0, 1);
dc *= 1e-9*cv::norm(c);
K2 = K + cv::Matx33d(0, 0, dc.at<double>(0), 0, 0, dc.at<double>(1), 0, 0, 0);
- cv::Fisheye::projectPoints(X, x2, om, T, K2, k, alpha, cv::noArray());
+ cv::fisheye::projectPoints(X, x2, om, T, K2, k, alpha, cv::noArray());
xpred = x1 + cv::Mat(jacobians.colRange(2,4) * dc).reshape(2, 1);
CV_Assert (cv::norm(x2 - xpred) < 1e-10);
r.fill(dk, cv::RNG::NORMAL, 0, 1);
dk *= 1e-9*cv::norm(k);
cv::Mat k2 = k + dk;
- cv::Fisheye::projectPoints(X, x2, om, T, K, k2, alpha, cv::noArray());
+ cv::fisheye::projectPoints(X, x2, om, T, K, k2, alpha, cv::noArray());
xpred = x1 + cv::Mat(jacobians.colRange(4,8) * dk).reshape(2, 1);
CV_Assert (cv::norm(x2 - xpred) < 1e-10);
dalpha *= 1e-9*cv::norm(f);
double alpha2 = alpha + dalpha.at<double>(0);
K2 = K + cv::Matx33d(0, f.at<double>(0) * dalpha.at<double>(0), 0, 0, 0, 0, 0, 0, 0);
- cv::Fisheye::projectPoints(X, x2, om, T, K, k, alpha2, cv::noArray());
+ cv::fisheye::projectPoints(X, x2, om, T, K, k, alpha2, cv::noArray());
xpred = x1 + cv::Mat(jacobians.col(14) * dalpha).reshape(2, 1);
CV_Assert (cv::norm(x2 - xpred) < 1e-10);
}
-TEST_F(FisheyeTest, Calibration)
+TEST_F(fisheyeTest, Calibration)
{
const int n_images = 34;
fs_object.release();
int flag = 0;
- flag |= cv::Fisheye::CALIB_RECOMPUTE_EXTRINSIC;
- flag |= cv::Fisheye::CALIB_CHECK_COND;
- flag |= cv::Fisheye::CALIB_FIX_SKEW;
+ flag |= cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC;
+ flag |= cv::fisheye::CALIB_CHECK_COND;
+ flag |= cv::fisheye::CALIB_FIX_SKEW;
cv::Matx33d K;
cv::Vec4d D;
- cv::Fisheye::calibrate(objectPoints, imagePoints, imageSize, K, D,
+ cv::fisheye::calibrate(objectPoints, imagePoints, imageSize, K, D,
cv::noArray(), cv::noArray(), flag, cv::TermCriteria(3, 20, 1e-6));
EXPECT_MAT_NEAR(K, this->K, 1e-10);
EXPECT_MAT_NEAR(D, this->D, 1e-10);
}
-TEST_F(FisheyeTest, Homography)
+TEST_F(fisheyeTest, Homography)
{
const int n_images = 1;
EXPECT_MAT_NEAR(std_err, correct_std_err, 1e-12);
}
-TEST_F(FisheyeTest, EtimateUncertainties)
+TEST_F(fisheyeTest, EtimateUncertainties)
{
const int n_images = 34;
fs_object.release();
int flag = 0;
- flag |= cv::Fisheye::CALIB_RECOMPUTE_EXTRINSIC;
- flag |= cv::Fisheye::CALIB_CHECK_COND;
- flag |= cv::Fisheye::CALIB_FIX_SKEW;
+ flag |= cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC;
+ flag |= cv::fisheye::CALIB_CHECK_COND;
+ flag |= cv::fisheye::CALIB_FIX_SKEW;
cv::Matx33d K;
cv::Vec4d D;
std::vector<cv::Vec3d> rvec;
std::vector<cv::Vec3d> tvec;
- cv::Fisheye::calibrate(objectPoints, imagePoints, imageSize, K, D,
+ cv::fisheye::calibrate(objectPoints, imagePoints, imageSize, K, D,
rvec, tvec, flag, cv::TermCriteria(3, 20, 1e-6));
cv::internal::IntrinsicParams param, errors;
CV_Assert(errors.alpha == 0);
}
-TEST_F(FisheyeTest, rectify)
+TEST_F(fisheyeTest, rectify)
{
const std::string folder =combine(datasets_repository_path, "calib-3_stereo_from_JY");
double balance = 0.0, fov_scale = 1.1;
cv::Mat R1, R2, P1, P2, Q;
- cv::Fisheye::stereoRectify(K1, D1, K2, D2, calibration_size, R, T, R1, R2, P1, P2, Q,
+ cv::fisheye::stereoRectify(K1, D1, K2, D2, calibration_size, R, T, R1, R2, P1, P2, Q,
cv::CALIB_ZERO_DISPARITY, requested_size, balance, fov_scale);
cv::Mat lmapx, lmapy, rmapx, rmapy;
//rewrite for fisheye
- cv::Fisheye::initUndistortRectifyMap(K1, D1, R1, P1, requested_size, CV_32F, lmapx, lmapy);
- cv::Fisheye::initUndistortRectifyMap(K2, D2, R2, P2, requested_size, CV_32F, rmapx, rmapy);
+ cv::fisheye::initUndistortRectifyMap(K1, D1, R1, P1, requested_size, CV_32F, lmapx, lmapy);
+ cv::fisheye::initUndistortRectifyMap(K2, D2, R2, P2, requested_size, CV_32F, rmapx, rmapy);
cv::Mat l, r, lundist, rundist;
cv::VideoCapture lcap(combine(folder, "left/stereo_pair_%03d.jpg")),
}
}
-TEST_F(FisheyeTest, stereoCalibrate)
+TEST_F(fisheyeTest, stereoCalibrate)
{
const int n_images = 34;
cv::Vec4d D1, D2;
int flag = 0;
- flag |= cv::Fisheye::CALIB_RECOMPUTE_EXTRINSIC;
- flag |= cv::Fisheye::CALIB_CHECK_COND;
- flag |= cv::Fisheye::CALIB_FIX_SKEW;
- // flag |= cv::Fisheye::CALIB_FIX_INTRINSIC;
+ flag |= cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC;
+ flag |= cv::fisheye::CALIB_CHECK_COND;
+ flag |= cv::fisheye::CALIB_FIX_SKEW;
+ // flag |= cv::fisheye::CALIB_FIX_INTRINSIC;
- cv::Fisheye::stereoCalibrate(objectPoints, leftPoints, rightPoints,
+ cv::fisheye::stereoCalibrate(objectPoints, leftPoints, rightPoints,
K1, D1, K2, D2, imageSize, R, T, flag,
cv::TermCriteria(3, 12, 0));
}
-TEST_F(FisheyeTest, stereoCalibrateFixIntrinsic)
+TEST_F(fisheyeTest, stereoCalibrateFixIntrinsic)
{
const int n_images = 34;
cv::Vec3d T;
int flag = 0;
- flag |= cv::Fisheye::CALIB_RECOMPUTE_EXTRINSIC;
- flag |= cv::Fisheye::CALIB_CHECK_COND;
- flag |= cv::Fisheye::CALIB_FIX_SKEW;
- flag |= cv::Fisheye::CALIB_FIX_INTRINSIC;
+ flag |= cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC;
+ flag |= cv::fisheye::CALIB_CHECK_COND;
+ flag |= cv::fisheye::CALIB_FIX_SKEW;
+ flag |= cv::fisheye::CALIB_FIX_INTRINSIC;
cv::Matx33d K1 (561.195925927249, 0, 621.282400272412,
0, 562.849402029712, 380.555455380889,
cv::Vec4d D1 (-7.44253716539556e-05, -0.00702662033932424, 0.00737569823650885, -0.00342230256441771);
cv::Vec4d D2 (-0.0130785435677431, 0.0284434505383497, -0.0360333869900506, 0.0144724062347222);
- cv::Fisheye::stereoCalibrate(objectPoints, leftPoints, rightPoints,
+ cv::fisheye::stereoCalibrate(objectPoints, leftPoints, rightPoints,
K1, D1, K2, D2, imageSize, R, T, flag,
cv::TermCriteria(3, 12, 0));
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/// FisheyeTest::
+/// fisheyeTest::
-const cv::Size FisheyeTest::imageSize(1280, 800);
+const cv::Size fisheyeTest::imageSize(1280, 800);
-const cv::Matx33d FisheyeTest::K(558.478087865323, 0, 620.458515360843,
+const cv::Matx33d fisheyeTest::K(558.478087865323, 0, 620.458515360843,
0, 560.506767351568, 381.939424848348,
0, 0, 1);
-const cv::Vec4d FisheyeTest::D(-0.0014613319981768, -0.00329861110580401, 0.00605760088590183, -0.00374209380722371);
+const cv::Vec4d fisheyeTest::D(-0.0014613319981768, -0.00329861110580401, 0.00605760088590183, -0.00374209380722371);
-const cv::Matx33d FisheyeTest::R ( 9.9756700084424932e-01, 6.9698277640183867e-02, 1.4929569991321144e-03,
+const cv::Matx33d fisheyeTest::R ( 9.9756700084424932e-01, 6.9698277640183867e-02, 1.4929569991321144e-03,
-6.9711825162322980e-02, 9.9748249845531767e-01, 1.2997180766418455e-02,
-5.8331736398316541e-04,-1.3069635393884985e-02, 9.9991441852366736e-01);
-const cv::Vec3d FisheyeTest::T(-9.9217369356044638e-02, 3.1741831972356663e-03, 1.8551007952921010e-04);
+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 fisheyeTest::combine(const std::string& _item1, const std::string& _item2)
{
std::string item1 = _item1, item2 = _item2;
std::replace(item1.begin(), item1.end(), '\\', '/');
return item1 + (last != '/' ? "/" : "") + item2;
}
-std::string FisheyeTest::combine_format(const std::string& item1, const std::string& item2, ...)
+std::string fisheyeTest::combine_format(const std::string& item1, const std::string& item2, ...)
{
std::string fmt = combine(item1, item2);
char buffer[1 << 16];
return std::string(buffer);
}
-cv::Mat FisheyeTest::mergeRectification(const cv::Mat& l, const cv::Mat& r)
+cv::Mat fisheyeTest::mergeRectification(const cv::Mat& l, const cv::Mat& r)
{
CV_Assert(l.type() == r.type() && l.size() == r.size());
cv::Mat merged(l.rows, l.cols * 2, l.type());