generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ocl: update filter tests

Browse Source
This commit is contained in:
Alexander Alekhin 2013-10-26 11:37:02 +04:00
parent 766a3511c6
commit cb6ea8bfa1
2 changed files with 140 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

231
modules/ocl/test/test_filters.cpp
View File

@ -59,10 +59,15 @@ using namespace cv;
PARAM_TEST_CASE(FilterTestBase, MatType, PARAM_TEST_CASE(FilterTestBase, MatType,
int, // kernel size int, // kernel size
Size, // dx, dy Size, // dx, dy
int, // border type, or iteration int, // border type
double, // optional parameter
bool) // roi or not bool) // roi or not
{ {
bool isFP;
int type, borderType, ksize; int type, borderType, ksize;
Size size;
double param;
bool useRoi; bool useRoi;
Mat src, dst_whole, src_roi, dst_roi; Mat src, dst_whole, src_roi, dst_roi;
@ -72,32 +77,54 @@ PARAM_TEST_CASE(FilterTestBase, MatType,
{ {
type = GET_PARAM(0); type = GET_PARAM(0);
ksize = GET_PARAM(1); ksize = GET_PARAM(1);
size = GET_PARAM(2);
borderType = GET_PARAM(3); borderType = GET_PARAM(3);
useRoi = GET_PARAM(4); param = GET_PARAM(4);
useRoi = GET_PARAM(5);
isFP = (CV_MAT_DEPTH(type) == CV_32F || CV_MAT_DEPTH(type) == CV_64F);
} }
void random_roi() void random_roi(int minSize = 1)
{ {
Size roiSize = randomSize(1, MAX_VALUE); if (minSize == 0)
minSize = ksize;
Size roiSize = randomSize(minSize, MAX_VALUE);
Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0);
randomSubMat(src, src_roi, roiSize, srcBorder, type, 5, 256); randomSubMat(src, src_roi, roiSize, srcBorder, type, isFP ? 0 : 5, isFP ? 1 : 256);
Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0);
randomSubMat(dst_whole, dst_roi, roiSize, dstBorder, type, 5, 16); randomSubMat(dst_whole, dst_roi, roiSize, dstBorder, type, isFP ? 0.20 : 60, isFP ? 0.25 : 70);
generateOclMat(gsrc_whole, gsrc_roi, src, roiSize, srcBorder); generateOclMat(gsrc_whole, gsrc_roi, src, roiSize, srcBorder);
generateOclMat(gdst_whole, gdst_roi, dst_whole, roiSize, dstBorder); generateOclMat(gdst_whole, gdst_roi, dst_whole, roiSize, dstBorder);
} }
void Near(double threshold = 0.0) void Near()
{
if (isFP)
Near(1e-6, true);
else
Near(1, false);
}
void Near(double threshold, bool relative)
{ {
Mat roi, whole; Mat roi, whole;
gdst_whole.download(whole); gdst_whole.download(whole);
gdst_roi.download(roi); gdst_roi.download(roi);
if (relative)
{
EXPECT_MAT_NEAR_RELATIVE(dst_whole, whole, threshold);
EXPECT_MAT_NEAR_RELATIVE(dst_roi, roi, threshold);
}
else
{
EXPECT_MAT_NEAR(dst_whole, whole, threshold); EXPECT_MAT_NEAR(dst_whole, whole, threshold);
EXPECT_MAT_NEAR(dst_roi, roi, threshold); EXPECT_MAT_NEAR(dst_roi, roi, threshold);
} }
}
}; };
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
@ -111,12 +138,12 @@ OCL_TEST_P(Blur, Mat)
for (int j = 0; j < LOOP_TIMES; j++) for (int j = 0; j < LOOP_TIMES; j++)
{ {
random_roi(); random_roi(0); // TODO NOTE: min value for size is kernel size (temporary bypass border issues in CPU implementation)
blur(src_roi, dst_roi, kernelSize, Point(-1, -1), borderType); blur(src_roi, dst_roi, kernelSize, Point(-1, -1), borderType);
ocl::blur(gsrc_roi, gdst_roi, kernelSize, Point(-1, -1), borderType); // TODO anchor ocl::blur(gsrc_roi, gdst_roi, kernelSize, Point(-1, -1), borderType); // TODO anchor
Near(1.0); Near();
} }
} }
@ -127,64 +154,51 @@ typedef FilterTestBase LaplacianTest;
OCL_TEST_P(LaplacianTest, Accuracy) OCL_TEST_P(LaplacianTest, Accuracy)
{ {
double scale = param;
for (int j = 0; j < LOOP_TIMES; j++) for (int j = 0; j < LOOP_TIMES; j++)
{ {
random_roi(); random_roi();
// border type is used as a scale factor for the Laplacian kernel Laplacian(src_roi, dst_roi, -1, ksize, scale); // TODO FIXIT , 0, borderType);
double scale = static_cast<double>(borderType); ocl::Laplacian(gsrc_roi, gdst_roi, -1, ksize, scale); // TODO FIXIT , 0, borderType);
Laplacian(src_roi, dst_roi, -1, ksize, scale); Near();
ocl::Laplacian(gsrc_roi, gdst_roi, -1, ksize, scale);
Near(1e-5);
} }
} }
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// erode & dilate // erode & dilate
struct ErodeDilate : typedef FilterTestBase Erode;
public FilterTestBase
{
int iterations;
virtual void SetUp()
{
type = GET_PARAM(0);
ksize = GET_PARAM(1);
iterations = GET_PARAM(3);
useRoi = GET_PARAM(4);
}
};
typedef ErodeDilate Erode;
OCL_TEST_P(Erode, Mat) OCL_TEST_P(Erode, Mat)
{ {
// erode or dilate kernel // erode or dilate kernel
Size kernelSize(ksize, ksize); Size kernelSize(ksize, ksize);
Mat kernel; Mat kernel;
int iterations = (int)param;
for (int j = 0; j < LOOP_TIMES; j++) for (int j = 0; j < LOOP_TIMES; j++)
{ {
kernel = randomMat(kernelSize, CV_8UC1, 0, 3);
random_roi(); random_roi();
cv::erode(src_roi, dst_roi, kernel, Point(-1, -1), iterations); kernel = randomMat(kernelSize, CV_8UC1, 0, 3);
ocl::erode(gsrc_roi, gdst_roi, kernel, Point(-1, -1), iterations); // TODO iterations, borderType
Near(1e-5); cv::erode(src_roi, dst_roi, kernel, Point(-1, -1), iterations);//, borderType);
ocl::erode(gsrc_roi, gdst_roi, kernel, Point(-1, -1), iterations);//, borderType);
Near();
} }
} }
typedef ErodeDilate Dilate; typedef FilterTestBase Dilate;
OCL_TEST_P(Dilate, Mat) OCL_TEST_P(Dilate, Mat)
{ {
// erode or dilate kernel // erode or dilate kernel
Mat kernel; Mat kernel;
int iterations = (int)param;
for (int j = 0; j < LOOP_TIMES; j++) for (int j = 0; j < LOOP_TIMES; j++)
{ {
@ -195,79 +209,56 @@ OCL_TEST_P(Dilate, Mat)
cv::dilate(src_roi, dst_roi, kernel, Point(-1, -1), iterations); cv::dilate(src_roi, dst_roi, kernel, Point(-1, -1), iterations);
ocl::dilate(gsrc_roi, gdst_roi, kernel, Point(-1, -1), iterations); // TODO iterations, borderType ocl::dilate(gsrc_roi, gdst_roi, kernel, Point(-1, -1), iterations); // TODO iterations, borderType
Near(1e-5); Near();
} }
} }
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// Sobel // Sobel
struct SobelTest : typedef FilterTestBase SobelTest;
public FilterTestBase
{
int dx, dy;
virtual void SetUp()
{
type = GET_PARAM(0);
ksize = GET_PARAM(1);
borderType = GET_PARAM(3);
useRoi = GET_PARAM(4);
Size d = GET_PARAM(2);
dx = d.width, dy = d.height;
}
};
OCL_TEST_P(SobelTest, Mat) OCL_TEST_P(SobelTest, Mat)
{ {
int dx = size.width, dy = size.height;
double scale = param;
for (int j = 0; j < LOOP_TIMES; j++) for (int j = 0; j < LOOP_TIMES; j++)
{ {
random_roi(); random_roi();
Sobel(src_roi, dst_roi, -1, dx, dy, ksize, /* scale */ 0.00001, /* delta */0, borderType); Sobel(src_roi, dst_roi, -1, dx, dy, ksize, scale, /* delta */0, borderType);
ocl::Sobel(gsrc_roi, gdst_roi, -1, dx, dy, ksize, /* scale */ 0.00001, /* delta */ 0, borderType); ocl::Sobel(gsrc_roi, gdst_roi, -1, dx, dy, ksize, scale, /* delta */0, borderType);
Near(1); Near();
} }
} }
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// Scharr // Scharr
typedef SobelTest ScharrTest; typedef FilterTestBase ScharrTest;
OCL_TEST_P(ScharrTest, Mat) OCL_TEST_P(ScharrTest, Mat)
{ {
int dx = size.width, dy = size.height;
double scale = param;
for (int j = 0; j < LOOP_TIMES; j++) for (int j = 0; j < LOOP_TIMES; j++)
{ {
random_roi(); random_roi();
Scharr(src_roi, dst_roi, -1, dx, dy, /* scale */ 1, /* delta */ 0, borderType); Scharr(src_roi, dst_roi, -1, dx, dy, scale, /* delta */ 0, borderType);
ocl::Scharr(gsrc_roi, gdst_roi, -1, dx, dy, /* scale */ 1, /* delta */ 0, borderType); ocl::Scharr(gsrc_roi, gdst_roi, -1, dx, dy, scale, /* delta */ 0, borderType);
Near(1); Near();
} }
} }
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// GaussianBlur // GaussianBlur
struct GaussianBlurTest : typedef FilterTestBase GaussianBlurTest;
public FilterTestBase
{
double sigma1, sigma2;
virtual void SetUp()
{
type = GET_PARAM(0);
ksize = GET_PARAM(1);
borderType = GET_PARAM(3);
sigma1 = rng.uniform(0.1, 1.0);
sigma2 = rng.uniform(0.1, 1.0);
}
};
OCL_TEST_P(GaussianBlurTest, Mat) OCL_TEST_P(GaussianBlurTest, Mat)
{ {
@ -275,10 +266,13 @@ OCL_TEST_P(GaussianBlurTest, Mat)
{ {
random_roi(); random_roi();
double sigma1 = rng.uniform(0.1, 1.0);
double sigma2 = rng.uniform(0.1, 1.0);
GaussianBlur(src_roi, dst_roi, Size(ksize, ksize), sigma1, sigma2, borderType); GaussianBlur(src_roi, dst_roi, Size(ksize, ksize), sigma1, sigma2, borderType);
ocl::GaussianBlur(gsrc_roi, gdst_roi, Size(ksize, ksize), sigma1, sigma2, borderType); ocl::GaussianBlur(gsrc_roi, gdst_roi, Size(ksize, ksize), sigma1, sigma2, borderType);
Near(1); Near();
} }
} }
@ -289,19 +283,24 @@ typedef FilterTestBase Filter2D;
OCL_TEST_P(Filter2D, Mat) OCL_TEST_P(Filter2D, Mat)
{ {
const Size kernelSize(ksize, ksize);
Mat kernel;
for (int j = 0; j < LOOP_TIMES; j++) for (int j = 0; j < LOOP_TIMES; j++)
{ {
kernel = randomMat(kernelSize, CV_32FC1, 0.0, 1.0);
random_roi(); random_roi();
cv::filter2D(src_roi, dst_roi, -1, kernel, Point(-1, -1), 0.0, borderType); // TODO anchor Point anchor(-1, -1);
ocl::filter2D(gsrc_roi, gdst_roi, -1, kernel, Point(-1, -1), borderType); if (size.width >= 0)
anchor.x = size.width % ksize;
if (size.height >= 0)
anchor.y = size.height % ksize;
Near(1); const Size kernelSize(ksize, ksize);
Mat kernel = randomMat(kernelSize, CV_32FC1, 0, 1.0);
kernel *= 1.0 / (double)(ksize * ksize);
cv::filter2D(src_roi, dst_roi, -1, kernel, anchor, 0.0, borderType);
ocl::filter2D(gsrc_roi, gdst_roi, -1, kernel, anchor, /* TODO FIXIT 0.0,*/ borderType);
Near();
} }
} }
@ -322,7 +321,7 @@ OCL_TEST_P(Bilateral, Mat)
cv::bilateralFilter(src_roi, dst_roi, ksize, sigmacolor, sigmaspace, borderType); cv::bilateralFilter(src_roi, dst_roi, ksize, sigmacolor, sigmaspace, borderType);
ocl::bilateralFilter(gsrc_roi, gdst_roi, ksize, sigmacolor, sigmaspace, borderType); ocl::bilateralFilter(gsrc_roi, gdst_roi, ksize, sigmacolor, sigmaspace, borderType);
Near(1); Near();
} }
} }
@ -342,7 +341,7 @@ OCL_TEST_P(AdaptiveBilateral, Mat)
adaptiveBilateralFilter(src_roi, dst_roi, kernelSize, 5, Point(-1, -1), borderType); // TODO anchor adaptiveBilateralFilter(src_roi, dst_roi, kernelSize, 5, Point(-1, -1), borderType); // TODO anchor
ocl::adaptiveBilateralFilter(gsrc_roi, gdst_roi, kernelSize, 5, Point(-1, -1), borderType); ocl::adaptiveBilateralFilter(gsrc_roi, gdst_roi, kernelSize, 5, Point(-1, -1), borderType);
Near(1); Near();
} }
} }
@ -366,80 +365,97 @@ OCL_TEST_P(MedianFilter, Mat)
////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define FILTER_BORDER_SET_NO_ISOLATED \
Values((int)BORDER_CONSTANT, (int)BORDER_REPLICATE, (int)BORDER_REFLECT, (int)BORDER_WRAP, (int)BORDER_REFLECT_101/*, \
(int)BORDER_CONSTANT|BORDER_ISOLATED, (int)BORDER_REPLICATE|BORDER_ISOLATED, \
(int)BORDER_REFLECT|BORDER_ISOLATED, (int)BORDER_WRAP|BORDER_ISOLATED, \
(int)BORDER_REFLECT_101|BORDER_ISOLATED*/) // WRAP and ISOLATED are not supported by cv:: version
#define FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED \
Values((int)BORDER_CONSTANT, (int)BORDER_REPLICATE, (int)BORDER_REFLECT, /*(int)BORDER_WRAP,*/ (int)BORDER_REFLECT_101/*, \
(int)BORDER_CONSTANT|BORDER_ISOLATED, (int)BORDER_REPLICATE|BORDER_ISOLATED, \
(int)BORDER_REFLECT|BORDER_ISOLATED, (int)BORDER_WRAP|BORDER_ISOLATED, \
(int)BORDER_REFLECT_101|BORDER_ISOLATED*/) // WRAP and ISOLATED are not supported by cv:: version
INSTANTIATE_TEST_CASE_P(Filter, Blur, Combine( INSTANTIATE_TEST_CASE_P(Filter, Blur, Combine(
Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4), Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4),
Values(3, 5, 7), Values(3, 5, 7),
Values(Size(0, 0)), // not used Values(Size(0, 0)), // not used
Values((int)BORDER_CONSTANT, (int)BORDER_REPLICATE, (int)BORDER_REFLECT, (int)BORDER_REFLECT_101), FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED,
Values(0.0), // not used
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, LaplacianTest, Combine( INSTANTIATE_TEST_CASE_P(Filter, LaplacianTest, Combine(
Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
Values(1, 3), Values(1, 3),
Values(Size(0, 0)), // not used Values(Size(0, 0)), // not used
Values(1, 2), // value is used as scale factor for kernel FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED,
Values(1.0, 0.2, 3.0), // scalar
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, Erode, Combine( INSTANTIATE_TEST_CASE_P(Filter, Erode, Combine(
Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
Values(3, 5, 7), Values(3, 5, 7),
Values(Size(0, 0)), // not used Values(Size(0, 0)), // not used
testing::Range(1, 4), Values(0), // not used
Values(1.0, 2.0, 3.0),
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, Dilate, Combine( INSTANTIATE_TEST_CASE_P(Filter, Dilate, Combine(
Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
Values(3, 5, 7), Values(3, 5, 7),
Values(Size(0, 0)), // not used Values(Size(0, 0)), // not used
testing::Range(1, 4), Values(0), // not used
Values(1.0, 2.0, 3.0),
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, SobelTest, Combine( INSTANTIATE_TEST_CASE_P(Filter, SobelTest, Combine(
Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
Values(3, 5), Values(3, 5),
Values(Size(1, 0), Size(1, 1), Size(2, 0), Size(2, 1)), Values(Size(1, 0), Size(1, 1), Size(2, 0), Size(2, 1)), // dx, dy
Values((int)BORDER_CONSTANT, (int)BORDER_REFLECT101, FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED,
(int)BORDER_REPLICATE, (int)BORDER_REFLECT), Values(0.0), // not used
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, ScharrTest, Combine( INSTANTIATE_TEST_CASE_P(Filter, ScharrTest, Combine(
Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4), Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
Values(0), // not used Values(1),
Values(Size(0, 1), Size(1, 0)), Values(Size(0, 1), Size(1, 0)), // dx, dy
Values((int)BORDER_CONSTANT, (int)BORDER_REFLECT101, FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED,
(int)BORDER_REPLICATE, (int)BORDER_REFLECT), Values(1.0, 0.2), // scalar
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, GaussianBlurTest, Combine( INSTANTIATE_TEST_CASE_P(Filter, GaussianBlurTest, Combine(
Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4), Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC4),
Values(3, 5), Values(3, 5),
Values(Size(0, 0)), // not used Values(Size(0, 0)), // not used
Values((int)BORDER_CONSTANT, (int)BORDER_REFLECT101, FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED,
(int)BORDER_REPLICATE, (int)BORDER_REFLECT), Values(0.0), // not used
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, Filter2D, testing::Combine( INSTANTIATE_TEST_CASE_P(Filter, Filter2D, testing::Combine(
Values(CV_8UC1, CV_32FC1, CV_32FC4), Values(CV_8UC1, CV_32FC1, CV_32FC4),
Values(3, 15, 25), Values(3, 15), // TODO 25: CPU implementation has some issues
Values(Size(0, 0)), // not used Values(Size(-1, -1), Size(0, 0), Size(2, 1)), // anchor
Values((int)BORDER_CONSTANT, (int)BORDER_REFLECT101, FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED,
(int)BORDER_REPLICATE, (int)BORDER_REFLECT), Values(0.0), // not used
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, Bilateral, Combine( INSTANTIATE_TEST_CASE_P(Filter, Bilateral, Combine(
Values(CV_8UC1, CV_8UC3), Values(CV_8UC1, CV_8UC3),
Values(5, 9), Values(5, 9),
Values(Size(0, 0)), // not used Values(Size(0, 0)), // not used
Values((int)BORDER_CONSTANT, (int)BORDER_REPLICATE, FILTER_BORDER_SET_NO_ISOLATED,
(int)BORDER_REFLECT, (int)BORDER_WRAP, (int)BORDER_REFLECT_101), Values(0.0), // not used
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, AdaptiveBilateral, Combine( INSTANTIATE_TEST_CASE_P(Filter, AdaptiveBilateral, Combine(
Values(CV_8UC1, CV_8UC3), Values(CV_8UC1, CV_8UC3),
Values(5, 9), Values(5, 9),
Values(Size(0, 0)), // not used Values(Size(0, 0)), // not used
Values((int)BORDER_CONSTANT, (int)BORDER_REPLICATE, FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED,
(int)BORDER_REFLECT, (int)BORDER_REFLECT_101), Values(0.0), // not used
Bool())); Bool()));
INSTANTIATE_TEST_CASE_P(Filter, MedianFilter, Combine( INSTANTIATE_TEST_CASE_P(Filter, MedianFilter, Combine(
@ -447,6 +463,7 @@ INSTANTIATE_TEST_CASE_P(Filter, MedianFilter, Combine(
Values(3, 5), Values(3, 5),
Values(Size(0, 0)), // not used Values(Size(0, 0)), // not used
Values(0), // not used Values(0), // not used
Values(0.0), // not used
Bool())); Bool()));
#endif // HAVE_OPENCL #endif // HAVE_OPENCL

14
modules/ocl/test/utility.hpp
View File

@ -72,6 +72,13 @@ double checkNorm(const cv::Mat &m);
double checkNorm(const cv::Mat &m1, const cv::Mat &m2); double checkNorm(const cv::Mat &m1, const cv::Mat &m2);
double checkSimilarity(const cv::Mat &m1, const cv::Mat &m2); double checkSimilarity(const cv::Mat &m1, const cv::Mat &m2);
inline double checkNormRelative(const Mat &m1, const Mat &m2)
{
return cv::norm(m1, m2, cv::NORM_INF) /
std::max((double)std::numeric_limits<float>::epsilon(),
(double)std::max(cv::norm(m1, cv::NORM_INF), norm(m2, cv::NORM_INF)));
}
#define EXPECT_MAT_NORM(mat, eps) \ #define EXPECT_MAT_NORM(mat, eps) \
{ \ { \
EXPECT_LE(checkNorm(cv::Mat(mat)), eps) \ EXPECT_LE(checkNorm(cv::Mat(mat)), eps) \
@ -84,6 +91,13 @@ double checkSimilarity(const cv::Mat &m1, const cv::Mat &m2);
EXPECT_LE(checkNorm(cv::Mat(mat1), cv::Mat(mat2)), eps); \ EXPECT_LE(checkNorm(cv::Mat(mat1), cv::Mat(mat2)), eps); \
} }
#define EXPECT_MAT_NEAR_RELATIVE(mat1, mat2, eps) \
{ \
ASSERT_EQ(mat1.type(), mat2.type()); \
ASSERT_EQ(mat1.size(), mat2.size()); \
EXPECT_LE(checkNormRelative(cv::Mat(mat1), cv::Mat(mat2)), eps); \
}
#define EXPECT_MAT_SIMILAR(mat1, mat2, eps) \ #define EXPECT_MAT_SIMILAR(mat1, mat2, eps) \
{ \ { \
ASSERT_EQ(mat1.type(), mat2.type()); \ ASSERT_EQ(mat1.type(), mat2.type()); \