TEST_F(fisheyeTest, Calibration) { const int n_images = 34; std::vector<std::vector<cv::Point2d> > imagePoints(n_images); std::vector<std::vector<cv::Point3d> > objectPoints(n_images); const std::string folder =combine(datasets_repository_path, "calib-3_stereo_from_JY"); cv::FileStorage fs_left(combine(folder, "left.xml"), cv::FileStorage::READ); CV_Assert(fs_left.isOpened()); for(int i = 0; i < n_images; ++i) fs_left[cv::format("image_%d", i )] >> imagePoints[i]; fs_left.release(); cv::FileStorage fs_object(combine(folder, "object.xml"), cv::FileStorage::READ); CV_Assert(fs_object.isOpened()); for(int i = 0; i < n_images; ++i) fs_object[cv::format("image_%d", i )] >> objectPoints[i]; fs_object.release(); int flag = 0; flag |= cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC; flag |= cv::fisheye::CALIB_CHECK_COND; flag |= cv::fisheye::CALIB_FIX_SKEW; cv::Matx33d theK; cv::Vec4d theD; cv::fisheye::calibrate(objectPoints, imagePoints, imageSize, theK, theD, cv::noArray(), cv::noArray(), flag, cv::TermCriteria(3, 20, 1e-6)); EXPECT_MAT_NEAR(theK, this->K, 1e-10); EXPECT_MAT_NEAR(theD, this->D, 1e-10); }
TEST_F(fisheyeTest, projectPoints) { double cols = this->imageSize.width, rows = this->imageSize.height; const int N = 20; cv::Mat distorted0(1, N*N, CV_64FC2), undist1, undist2, distorted1, distorted2; undist2.create(distorted0.size(), CV_MAKETYPE(distorted0.depth(), 3)); cv::Vec2d* pts = distorted0.ptr<cv::Vec2d>(); cv::Vec2d c(this->K(0, 2), this->K(1, 2)); for(int y = 0, k = 0; y < N; ++y) for(int x = 0; x < N; ++x) { cv::Vec2d point(x*cols/(N-1.f), y*rows/(N-1.f)); pts[k++] = (point - c) * 0.85 + c; } 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); EXPECT_MAT_NEAR(distorted0, distorted1, 1e-10); EXPECT_MAT_NEAR(distorted0, distorted2, 1e-10); }
TEST_F(fisheyeTest, EtimateUncertainties) { const int n_images = 34; std::vector<std::vector<cv::Point2d> > imagePoints(n_images); std::vector<std::vector<cv::Point3d> > objectPoints(n_images); const std::string folder =combine(datasets_repository_path, "calib-3_stereo_from_JY"); cv::FileStorage fs_left(combine(folder, "left.xml"), cv::FileStorage::READ); CV_Assert(fs_left.isOpened()); for(int i = 0; i < n_images; ++i) fs_left[cv::format("image_%d", i )] >> imagePoints[i]; fs_left.release(); cv::FileStorage fs_object(combine(folder, "object.xml"), cv::FileStorage::READ); CV_Assert(fs_object.isOpened()); for(int i = 0; i < n_images; ++i) fs_object[cv::format("image_%d", i )] >> objectPoints[i]; fs_object.release(); int flag = 0; flag |= cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC; flag |= cv::fisheye::CALIB_CHECK_COND; flag |= cv::fisheye::CALIB_FIX_SKEW; cv::Matx33d theK; cv::Vec4d theD; std::vector<cv::Vec3d> rvec; std::vector<cv::Vec3d> tvec; cv::fisheye::calibrate(objectPoints, imagePoints, imageSize, theK, theD, rvec, tvec, flag, cv::TermCriteria(3, 20, 1e-6)); cv::internal::IntrinsicParams param, errors; cv::Vec2d err_std; double thresh_cond = 1e6; int check_cond = 1; param.Init(cv::Vec2d(theK(0,0), theK(1,1)), cv::Vec2d(theK(0,2), theK(1, 2)), theD); param.isEstimate = std::vector<uchar>(9, 1); param.isEstimate[4] = 0; errors.isEstimate = param.isEstimate; double rms; cv::internal::EstimateUncertainties(objectPoints, imagePoints, param, rvec, tvec, errors, err_std, thresh_cond, check_cond, rms); EXPECT_MAT_NEAR(errors.f, cv::Vec2d(1.29837104202046, 1.31565641071524), 1e-10); EXPECT_MAT_NEAR(errors.c, cv::Vec2d(0.890439368129246, 0.816096854937896), 1e-10); EXPECT_MAT_NEAR(errors.k, cv::Vec4d(0.00516248605191506, 0.0168181467500934, 0.0213118690274604, 0.00916010877545648), 1e-10); EXPECT_MAT_NEAR(err_std, cv::Vec2d(0.187475975266883, 0.185678953263995), 1e-10); CV_Assert(fabs(rms - 0.263782587133546) < 1e-10); CV_Assert(errors.alpha == 0); }
void Near(double threshold = 0.0, bool relative = false) { if (relative) { EXPECT_MAT_NEAR_RELATIVE(dst, udst, threshold); EXPECT_MAT_NEAR_RELATIVE(dst_roi, udst_roi, threshold); } else { EXPECT_MAT_NEAR(dst, udst, threshold); EXPECT_MAT_NEAR(dst_roi, udst_roi, threshold); } }
TEST_F(fisheyeTest, Homography) { const int n_images = 1; std::vector<std::vector<cv::Point2d> > imagePoints(n_images); std::vector<std::vector<cv::Point3d> > objectPoints(n_images); const std::string folder =combine(datasets_repository_path, "calib-3_stereo_from_JY"); cv::FileStorage fs_left(combine(folder, "left.xml"), cv::FileStorage::READ); CV_Assert(fs_left.isOpened()); for(int i = 0; i < n_images; ++i) fs_left[cv::format("image_%d", i )] >> imagePoints[i]; fs_left.release(); cv::FileStorage fs_object(combine(folder, "object.xml"), cv::FileStorage::READ); CV_Assert(fs_object.isOpened()); for(int i = 0; i < n_images; ++i) fs_object[cv::format("image_%d", i )] >> objectPoints[i]; fs_object.release(); 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)); cv::Mat _imagePoints (imagePoints[0]); cv::Mat _objectPoints(objectPoints[0]); cv::Mat imagePointsNormalized = NormalizePixels(_imagePoints, param).reshape(1).t(); _objectPoints = _objectPoints.reshape(1).t(); cv::Mat objectPointsMean, covObjectPoints; int Np = imagePointsNormalized.cols; cv::calcCovarMatrix(_objectPoints, covObjectPoints, objectPointsMean, cv::COVAR_NORMAL | cv::COVAR_COLS); cv::SVD svd(covObjectPoints); cv::Mat theR(svd.vt); if (cv::norm(theR(cv::Rect(2, 0, 1, 2))) < 1e-6) theR = cv::Mat::eye(3,3, CV_64FC1); if (cv::determinant(theR) < 0) theR = -theR; cv::Mat theT = -theR * objectPointsMean; cv::Mat X_new = theR * _objectPoints + theT * cv::Mat::ones(1, Np, CV_64FC1); cv::Mat H = cv::internal::ComputeHomography(imagePointsNormalized, X_new.rowRange(0, 2)); cv::Mat M = cv::Mat::ones(3, X_new.cols, CV_64FC1); X_new.rowRange(0, 2).copyTo(M.rowRange(0, 2)); cv::Mat mrep = H * M; cv::divide(mrep, cv::Mat::ones(3,1, CV_64FC1) * mrep.row(2).clone(), mrep); cv::Mat merr = (mrep.rowRange(0, 2) - imagePointsNormalized).t(); cv::Vec2d std_err; cv::meanStdDev(merr.reshape(2), cv::noArray(), std_err); std_err *= sqrt((double)merr.reshape(2).total() / (merr.reshape(2).total() - 1)); cv::Vec2d correct_std_err(0.00516740156010384, 0.00644205331553901); EXPECT_MAT_NEAR(std_err, correct_std_err, 1e-12); }
virtual void test_by_pict() { Mat frame1 = readImage("optflow/RubberWhale1.png", IMREAD_GRAYSCALE); UMat usrc; frame1.copyTo(usrc); int histSize = randomInt(3, 29); float hue_range[] = { 0, 180 }; const float* ranges1 = { hue_range }; Mat hist1; //compute histogram calcHist(&frame1, 1, 0, Mat(), hist1, 1, &histSize, &ranges1, true, false); normalize(hist1, hist1, 0, 255, NORM_MINMAX, -1, Mat()); Mat dst1; UMat udst1, src, uhist1; hist1.copyTo(uhist1); std::vector<UMat> uims; uims.push_back(usrc); std::vector<float> urngs; urngs.push_back(0); urngs.push_back(180); std::vector<int> chs; chs.push_back(0); OCL_OFF(calcBackProject(&frame1, 1, 0, hist1, dst1, &ranges1, 1, true)); OCL_ON(calcBackProject(uims, chs, uhist1, udst1, urngs, 1.0)); EXPECT_MAT_NEAR(dst1, udst1, 0.0); }
TEST_P(HistEven, Accuracy) { cv::Mat img = readImage("stereobm/aloe-L.png"); ASSERT_FALSE(img.empty()); cv::Mat hsv; cv::cvtColor(img, hsv, CV_BGR2HSV); int hbins = 30; float hranges[] = {0.0f, 180.0f}; std::vector<cv::gpu::GpuMat> srcs; cv::gpu::split(loadMat(hsv), srcs); cv::gpu::GpuMat hist; cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]); cv::MatND histnd; int histSize[] = {hbins}; const float* ranges[] = {hranges}; int channels[] = {0}; cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges); cv::Mat hist_gold = histnd; hist_gold = hist_gold.t(); hist_gold.convertTo(hist_gold, CV_32S); EXPECT_MAT_NEAR(hist_gold, hist, 0.0); }
TEST_P(SetTo, Masked) { cv::Scalar val = randomScalar(0.0, 255.0); cv::Mat mat_gold = randomMat(size, type); cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0); if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { try { cv::gpu::GpuMat mat = createMat(size, type, useRoi); mat.setTo(val, loadMat(mask)); } catch (const cv::Exception& e) { ASSERT_EQ(CV_StsUnsupportedFormat, e.code); } } else { cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi); mat.setTo(val, loadMat(mask, useRoi)); mat_gold.setTo(val, mask); EXPECT_MAT_NEAR(mat_gold, mat, 0.0); } }
TEST_P(SetTo, Zero) { cv::Scalar zero = cv::Scalar::all(0); cv::gpu::GpuMat mat = createMat(size, type, useRoi); mat.setTo(zero); EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0); }
TEST_P(Integral, Accuracy) { cv::Mat src = randomMat(size, CV_8UC1); cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi); cv::gpu::integral(loadMat(src, useRoi), dst); cv::Mat dst_gold; cv::integral(src, dst_gold, CV_32S); EXPECT_MAT_NEAR(dst_gold, dst, 0.0); }
TEST_F(fisheyeTest, DISABLED_undistortImage) { cv::Matx33d theK = this->K; cv::Mat theD = cv::Mat(this->D); std::string file = combine(datasets_repository_path, "/calib-3_stereo_from_JY/left/stereo_pair_014.jpg"); cv::Matx33d newK = theK; cv::Mat distorted = cv::imread(file), undistorted; { newK(0, 0) = 100; newK(1, 1) = 100; cv::fisheye::undistortImage(distorted, undistorted, theK, theD, 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)); else EXPECT_MAT_NEAR(correct, undistorted, 1e-10); } { double balance = 1.0; cv::fisheye::estimateNewCameraMatrixForUndistortRectify(theK, theD, distorted.size(), cv::noArray(), newK, balance); cv::fisheye::undistortImage(distorted, undistorted, theK, theD, 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)); else EXPECT_MAT_NEAR(correct, undistorted, 1e-10); } { double balance = 0.0; cv::fisheye::estimateNewCameraMatrixForUndistortRectify(theK, theD, distorted.size(), cv::noArray(), newK, balance); cv::fisheye::undistortImage(distorted, undistorted, theK, theD, 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)); else EXPECT_MAT_NEAR(correct, undistorted, 1e-10); } }
TEST_P(ReprojectImageTo3D, Accuracy) { cv::Mat disp = randomMat(size, depth, 5.0, 30.0); cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0); cv::gpu::GpuMat dst; cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3); cv::Mat dst_gold; cv::reprojectImageTo3D(disp, dst_gold, Q, false); EXPECT_MAT_NEAR(dst_gold, dst, 1e-5); }
TEST_F(fisheyeTest, rectify) #endif { const std::string folder =combine(datasets_repository_path, "calib-3_stereo_from_JY"); cv::Size calibration_size = this->imageSize, requested_size = calibration_size; cv::Matx33d K1 = this->K, K2 = K1; cv::Mat D1 = cv::Mat(this->D), D2 = D1; cv::Vec3d theT = this->T; cv::Matx33d theR = this->R; double balance = 0.0, fov_scale = 1.1; cv::Mat R1, R2, P1, P2, Q; cv::fisheye::stereoRectify(K1, D1, K2, D2, calibration_size, theR, theT, 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::Mat l, r, lundist, rundist; cv::VideoCapture lcap(combine(folder, "left/stereo_pair_%03d.jpg")), rcap(combine(folder, "right/stereo_pair_%03d.jpg")); for(int i = 0;; ++i) { lcap >> l; rcap >> r; if (l.empty() || r.empty()) break; int ndisp = 128; cv::rectangle(l, cv::Rect(255, 0, 829, l.rows-1), cv::Scalar(0, 0, 255)); cv::rectangle(r, cv::Rect(255, 0, 829, l.rows-1), cv::Scalar(0, 0, 255)); cv::rectangle(r, cv::Rect(255-ndisp, 0, 829+ndisp ,l.rows-1), cv::Scalar(0, 0, 255)); cv::remap(l, lundist, lmapx, lmapy, cv::INTER_LINEAR); cv::remap(r, rundist, rmapx, rmapy, cv::INTER_LINEAR); cv::Mat rectification = mergeRectification(lundist, rundist); cv::Mat correct = cv::imread(combine(datasets_repository_path, cv::format("rectification_AB_%03d.png", i))); if (correct.empty()) cv::imwrite(combine(datasets_repository_path, cv::format("rectification_AB_%03d.png", i)), rectification); else EXPECT_MAT_NEAR(correct, rectification, 1e-10); } }
void test_by_pict() { Mat frame1 = readImage("optflow/RubberWhale1.png", IMREAD_GRAYSCALE); UMat usrc; frame1.copyTo(usrc); int histSize = randomInt(3, 29); float hue_range[] = { 0, 180 }; const float* ranges1 = { hue_range }; Mat hist1; //compute histogram calcHist(&frame1, 1, 0, Mat(), hist1, 1, &histSize, &ranges1, true, false); normalize(hist1, hist1, 0, 255, NORM_MINMAX, -1, Mat()); Mat dst1; UMat udst1, src, uhist1; hist1.copyTo(uhist1); std::vector<UMat> uims; uims.push_back(usrc); std::vector<float> urngs; urngs.push_back(0); urngs.push_back(180); std::vector<int> chs; chs.push_back(0); OCL_OFF(calcBackProject(&frame1, 1, 0, hist1, dst1, &ranges1, 1, true)); OCL_ON(calcBackProject(uims, chs, uhist1, udst1, urngs, 1.0)); if (cv::ocl::useOpenCL() && cv::ocl::Device::getDefault().isAMD()) { Size dstSize = dst1.size(); int nDiffs = (int)(0.03f*dstSize.height*dstSize.width); //check if the dst mats are the same except 3% difference EXPECT_MAT_N_DIFF(dst1, udst1, nDiffs); } else { EXPECT_MAT_NEAR(dst1, udst1, 0.0); } }
TEST_P(SetTo, SameVal) { cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0)); if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE)) { try { cv::gpu::GpuMat mat = createMat(size, type, useRoi); mat.setTo(val); } catch (const cv::Exception& e) { ASSERT_EQ(CV_StsUnsupportedFormat, e.code); } } else { cv::gpu::GpuMat mat = createMat(size, type, useRoi); mat.setTo(val); EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0); } }
TEST_P(BroxOpticalFlow, Regression) { cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1); ASSERT_FALSE(frame0.empty()); cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1); ASSERT_FALSE(frame1.empty()); cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, 10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/); cv::gpu::GpuMat u; cv::gpu::GpuMat v; brox(loadMat(frame0), loadMat(frame1), u, v); #ifndef DUMP std::string fname(cvtest::TS::ptr()->get_data_path()); if (devInfo.majorVersion() >= 2) fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20; else fname += BROX_OPTICAL_FLOW_DUMP_FILE; std::ifstream f(fname.c_str(), std::ios_base::binary); int rows, cols; f.read((char*)&rows, sizeof(rows)); f.read((char*)&cols, sizeof(cols)); cv::Mat u_gold(rows, cols, CV_32FC1); for (int i = 0; i < u_gold.rows; ++i) f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float)); cv::Mat v_gold(rows, cols, CV_32FC1); for (int i = 0; i < v_gold.rows; ++i) f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float)); EXPECT_MAT_NEAR(u_gold, u, 0); EXPECT_MAT_NEAR(v_gold, v, 0); #else std::string fname(cvtest::TS::ptr()->get_data_path()); if (devInfo.majorVersion() >= 2) fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20; else fname += BROX_OPTICAL_FLOW_DUMP_FILE; std::ofstream f(fname.c_str(), std::ios_base::binary); f.write((char*)&u.rows, sizeof(u.rows)); f.write((char*)&u.cols, sizeof(u.cols)); cv::Mat h_u(u); cv::Mat h_v(v); for (int i = 0; i < u.rows; ++i) f.write(h_u.ptr<char>(i), u.cols * sizeof(float)); for (int i = 0; i < v.rows; ++i) f.write(h_v.ptr<char>(i), v.cols * sizeof(float)); #endif }
TEST_F(fisheyeTest, stereoCalibrateFixIntrinsic) { const int n_images = 34; const std::string folder =combine(datasets_repository_path, "calib-3_stereo_from_JY"); std::vector<std::vector<cv::Point2d> > leftPoints(n_images); std::vector<std::vector<cv::Point2d> > rightPoints(n_images); std::vector<std::vector<cv::Point3d> > objectPoints(n_images); cv::FileStorage fs_left(combine(folder, "left.xml"), cv::FileStorage::READ); CV_Assert(fs_left.isOpened()); for(int i = 0; i < n_images; ++i) fs_left[cv::format("image_%d", i )] >> leftPoints[i]; fs_left.release(); cv::FileStorage fs_right(combine(folder, "right.xml"), cv::FileStorage::READ); CV_Assert(fs_right.isOpened()); for(int i = 0; i < n_images; ++i) fs_right[cv::format("image_%d", i )] >> rightPoints[i]; fs_right.release(); cv::FileStorage fs_object(combine(folder, "object.xml"), cv::FileStorage::READ); CV_Assert(fs_object.isOpened()); for(int i = 0; i < n_images; ++i) fs_object[cv::format("image_%d", i )] >> objectPoints[i]; fs_object.release(); cv::Matx33d theR; cv::Vec3d theT; 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; cv::Matx33d K1 (561.195925927249, 0, 621.282400272412, 0, 562.849402029712, 380.555455380889, 0, 0, 1); cv::Matx33d K2 (560.395452535348, 0, 678.971652040359, 0, 561.90171021422, 380.401340535339, 0, 0, 1); 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, K1, D1, K2, D2, imageSize, theR, theT, flag, cv::TermCriteria(3, 12, 0)); cv::Matx33d R_correct( 0.9975587205950972, 0.06953016383322372, 0.006492709911733523, -0.06956823121068059, 0.9975601387249519, 0.005833595226966235, -0.006071257768382089, -0.006271040135405457, 0.9999619062167968); cv::Vec3d T_correct(-0.099402724724121, 0.00270812139265413, 0.00129330292472699); EXPECT_MAT_NEAR(theR, R_correct, 1e-10); EXPECT_MAT_NEAR(theT, T_correct, 1e-10); }
void Near(double threshold = 0.) { EXPECT_MAT_NEAR(xmap, uxmap, threshold); EXPECT_MAT_NEAR(ymap, uymap, threshold); EXPECT_MAT_NEAR(dst, udst, threshold); }
void Near(double threshold = 0.0) { EXPECT_MAT_NEAR(dst_roi, udst_roi, threshold); EXPECT_MAT_NEAR(dst, udst, threshold); }
void Near1(double threshold = 0.) { EXPECT_MAT_NEAR(dst2, udst2, threshold); EXPECT_MAT_NEAR(dst2_roi, udst2_roi, threshold); }