}
};
-OCL_TEST_P(UMatBasicTests, createUMat)
+TEST_P(UMatBasicTests, createUMat)
{
if(useRoi)
{
ASSERT_EQ( ua.dims, 2);
}
-OCL_TEST_P(UMatBasicTests, swap)
+TEST_P(UMatBasicTests, swap)
{
Mat b = randomMat(size, type, -100, 100);
UMat ub;
EXPECT_MAT_NEAR(ud, ua, 0);
}
-OCL_TEST_P(UMatBasicTests, base)
+TEST_P(UMatBasicTests, base)
{
if(useRoi)
{
ASSERT_EQ(ub.total(), total);
}
-OCL_TEST_P(UMatBasicTests, copyTo)
+TEST_P(UMatBasicTests, DISABLED_copyTo)
{
UMat roi_ua;
Mat roi_a;
}
}
-OCL_TEST_P(UMatBasicTests, DISABLED_GetUMat)
+TEST_P(UMatBasicTests, DISABLED_GetUMat)
{
if(useRoi)
{
}
}
-OCL_INSTANTIATE_TEST_CASE_P(UMat, UMatBasicTests, Combine(testing::Values(CV_8U), testing::Values(1, 2),
+INSTANTIATE_TEST_CASE_P(UMat, UMatBasicTests, Combine(testing::Values(CV_8U), testing::Values(1, 2),
testing::Values(cv::Size(1, 1), cv::Size(1, 128), cv::Size(128, 1), cv::Size(128, 128), cv::Size(640, 480)), Bool()));
//////////////////////////////////////////////////////////////// Reshape ////////////////////////////////////////////////////////////////////////
}
};
-OCL_TEST_P(UMatTestReshape, reshape)
+TEST_P(UMatTestReshape, DISABLED_reshape)
{
a = randomMat(size,type, -100, 100);
a.copyTo(ua);
}
}
-OCL_INSTANTIATE_TEST_CASE_P(UMat, UMatTestReshape, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, UMAT_TEST_SIZES, Bool() ));
+INSTANTIATE_TEST_CASE_P(UMat, UMatTestReshape, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, UMAT_TEST_SIZES, Bool() ));
////////////////////////////////////////////////////////////////// ROI testing ///////////////////////////////////////////////////////////////
}
};
-OCL_TEST_P(UMatTestRoi, createRoi)
+TEST_P(UMatTestRoi, createRoi)
{
int roi_shift_x = randomInt(0, size.width-1);
int roi_shift_y = randomInt(0, size.height-1);
EXPECT_MAT_NEAR(roi_a, roi_ua, 0);
}
-OCL_TEST_P(UMatTestRoi, locateRoi)
+TEST_P(UMatTestRoi, locateRoi)
{
int roi_shift_x = randomInt(0, size.width-1);
int roi_shift_y = randomInt(0, size.height-1);
ASSERT_EQ(p, up);
}
-OCL_TEST_P(UMatTestRoi, adjustRoi)
+TEST_P(UMatTestRoi, adjustRoi)
{
int roi_shift_x = randomInt(0, size.width-1);
int roi_shift_y = randomInt(0, size.height-1);
EXPECT_MAT_NEAR(roi_ua, test_roi, 0);
}
-OCL_INSTANTIATE_TEST_CASE_P(UMat, UMatTestRoi, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, UMAT_TEST_SIZES ));
+INSTANTIATE_TEST_CASE_P(UMat, UMatTestRoi, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, UMAT_TEST_SIZES ));
/////////////////////////////////////////////////////////////// Size ////////////////////////////////////////////////////////////////////
}
};
-OCL_TEST_P(UMatTestSizeOperations, copySize)
+TEST_P(UMatTestSizeOperations, copySize)
{
Size s = randomSize(1,300);
a = randomMat(size, type, -100, 100);
ASSERT_EQ(ua.size, ub.size);
}
-OCL_INSTANTIATE_TEST_CASE_P(UMat, UMatTestSizeOperations, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, UMAT_TEST_SIZES, Bool() ));
+INSTANTIATE_TEST_CASE_P(UMat, UMatTestSizeOperations, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, UMAT_TEST_SIZES, Bool() ));
///////////////////////////////////////////////////////////////// UMat operations ////////////////////////////////////////////////////////////////////////////
}
};
-OCL_TEST_P(UMatTestUMatOperations, diag)
+TEST_P(UMatTestUMatOperations, diag)
{
a = randomMat(size, type, -100, 100);
a.copyTo(ua);
EXPECT_MAT_NEAR(ua.diag(), new_diag.t(), 0);
}
-OCL_INSTANTIATE_TEST_CASE_P(UMat, UMatTestUMatOperations, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, UMAT_TEST_SIZES, Bool()));
+INSTANTIATE_TEST_CASE_P(UMat, UMatTestUMatOperations, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, UMAT_TEST_SIZES, Bool()));
///////////////////////////////////////////////////////////////// OpenCL ////////////////////////////////////////////////////////////////////////////
#include "ocl_test.hpp"
#include "ts_perf.hpp"
-#ifdef HAVE_OPENCL
-
namespace cvtest {
namespace ocl {
} // namespace cvtest::ocl
} // namespace cvtest
-#endif // HAVE_OPENCL
-
#endif // __OPENCV_TS_OCL_PERF_HPP__
#ifndef __OPENCV_TS_OCL_TEST_HPP__
#define __OPENCV_TS_OCL_TEST_HPP__
-#include "cvconfig.h" // to get definition of HAVE_OPENCL
#include "opencv2/opencv_modules.hpp"
-#ifdef HAVE_OPENCL
-
#include "opencv2/ts.hpp"
#include "opencv2/highgui.hpp"
using namespace cv;
using namespace testing;
-namespace traits {
-
-template <typename T>
-struct GetMatForRead
-{
-};
-template <>
-struct GetMatForRead<Mat>
-{
- static const Mat get(const Mat& m) { return m; }
-};
-
-template <>
-struct GetMatForRead<UMat>
-{
- static const Mat get(const UMat& m) { return m.getMat(ACCESS_READ); }
-};
-
-template <>
-struct GetMatForRead<MatExpr>
-{
- static const Mat get(const MatExpr& m) { return m; }
-};
-
-} // namespace traits
-
-template <typename T>
-const Mat getMatForRead(const T& mat)
-{
- return traits::GetMatForRead<T>::get(mat);
-}
-
extern int test_loop_times;
#define MAX_VALUE 357
// If the two vectors are not equal, it will return the difference in vector size
// Else it will return (total diff of each 1 and 2 rects covered pixels)/(total 1 rects covered pixels)
// The smaller, the better matched
- static double checkRectSimilarity(cv::Size sz, std::vector<cv::Rect>& ob1, std::vector<cv::Rect>& ob2);
+ static double checkRectSimilarity(const cv::Size & sz, std::vector<cv::Rect>& ob1, std::vector<cv::Rect>& ob2);
//! read image from testdata folder.
-
static cv::Mat readImage(const String &fileName, int flags = cv::IMREAD_COLOR);
static cv::Mat readImageType(const String &fname, int type);
- static double checkNorm(const cv::Mat &m);
- static double checkNorm(const cv::Mat &m1, const cv::Mat &m2);
- static double checkSimilarity(const cv::Mat &m1, const cv::Mat &m2);
- static 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)));
- }
- static void showDiff(const Mat& src, const Mat& gold, const Mat& actual, double eps, bool alwaysShow = false);
+ static double checkNorm(InputArray m);
+ static double checkNorm(InputArray m1, InputArray m2);
+ static double checkSimilarity(InputArray m1, InputArray m2);
+ static void showDiff(InputArray _src, InputArray _gold, InputArray _actual, double eps, bool alwaysShow);
- template <typename T1>
- static double checkNorm(const T1& m)
- {
- return checkNorm(getMatForRead(m));
- }
- template <typename T1, typename T2>
- static double checkNorm(const T1& m1, const T2& m2)
+ static inline double checkNormRelative(InputArray m1, InputArray m2)
{
- return checkNorm(getMatForRead(m1), getMatForRead(m2));
- }
- template <typename T1, typename T2>
- static double checkSimilarity(const T1& m1, const T2& m2)
- {
- return checkSimilarity(getMatForRead(m1), getMatForRead(m2));
- }
- template <typename T1, typename T2>
- static inline double checkNormRelative(const T1& m1, const T2& m2)
- {
- const Mat _m1 = getMatForRead(m1);
- const Mat _m2 = getMatForRead(m2);
- return checkNormRelative(_m1, _m2);
- }
-
- template <typename T1, typename T2, typename T3>
- static void showDiff(const T1& src, const T2& gold, const T3& actual, double eps, bool alwaysShow = false)
- {
- const Mat _src = getMatForRead(src);
- const Mat _gold = getMatForRead(gold);
- const Mat _actual = getMatForRead(actual);
- showDiff(_src, _gold, _actual, eps, alwaysShow);
+ return cv::norm(m1.getMat(), m2.getMat(), cv::NORM_INF) /
+ std::max((double)std::numeric_limits<float>::epsilon(),
+ (double)std::max(cv::norm(m1.getMat(), cv::NORM_INF), norm(m2.getMat(), cv::NORM_INF)));
}
};
#define OCL_INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \
INSTANTIATE_TEST_CASE_P(OCL_ ## prefix, test_case_name, generator)
-}} // namespace cvtest::ocl
-
-#endif // HAVE_OPENCL
+} } // namespace cvtest::ocl
#endif // __OPENCV_TS_OCL_TEST_HPP__
#include "opencv2/ts/ocl_perf.hpp"
-#ifdef HAVE_OPENCL
-
namespace cvtest {
namespace ocl {
} // namespace perf
-}} // namespace cvtest::ocl
-
-#endif // HAVE_OPENCL
+} } // namespace cvtest::ocl
#include "opencv2/ts/ocl_test.hpp"
-#ifdef HAVE_OPENCL
-
namespace cvtest {
namespace ocl {
return src;
}
-double TestUtils::checkNorm(const Mat &m)
+double TestUtils::checkNorm(InputArray m)
{
- return norm(m, NORM_INF);
+ return norm(m.getMat(), NORM_INF);
}
-double TestUtils::checkNorm(const Mat &m1, const Mat &m2)
+double TestUtils::checkNorm(InputArray m1, InputArray m2)
{
- return norm(m1, m2, NORM_INF);
+ return norm(m1.getMat(), m2.getMat(), NORM_INF);
}
-double TestUtils::checkSimilarity(const Mat &m1, const Mat &m2)
+double TestUtils::checkSimilarity(InputArray m1, InputArray m2)
{
Mat diff;
- matchTemplate(m1, m2, diff, CV_TM_CCORR_NORMED);
+ matchTemplate(m1.getMat(), m2.getMat(), diff, CV_TM_CCORR_NORMED);
return std::abs(diff.at<float>(0, 0) - 1.f);
}
-double TestUtils::checkRectSimilarity(Size sz, std::vector<Rect>& ob1, std::vector<Rect>& ob2)
+double TestUtils::checkRectSimilarity(const Size & sz, std::vector<Rect>& ob1, std::vector<Rect>& ob2)
{
double final_test_result = 0.0;
size_t sz1 = ob1.size();
size_t sz2 = ob2.size();
- if(sz1 != sz2)
- {
+ if (sz1 != sz2)
return sz1 > sz2 ? (double)(sz1 - sz2) : (double)(sz2 - sz1);
- }
else
{
- if(sz1==0 && sz2==0)
+ if (sz1 == 0 && sz2 == 0)
return 0;
cv::Mat cpu_result(sz, CV_8UC1);
cpu_result.setTo(0);
- for(vector<Rect>::const_iterator r = ob1.begin(); r != ob1.end(); r++)
+ for (vector<Rect>::const_iterator r = ob1.begin(); r != ob1.end(); r++)
{
cv::Mat cpu_result_roi(cpu_result, *r);
cpu_result_roi.setTo(1);
cv::Mat result_;
multiply(cpu_result, gpu_result, result_);
int result = cv::countNonZero(result_ > 0);
- if(cpu_area!=0 && result!=0)
+ if (cpu_area!=0 && result!=0)
final_test_result = 1.0 - (double)result/(double)cpu_area;
else if(cpu_area==0 && result!=0)
final_test_result = -1;
return final_test_result;
}
-void TestUtils::showDiff(const Mat& src, const Mat& gold, const Mat& actual, double eps, bool alwaysShow)
+void TestUtils::showDiff(InputArray _src, InputArray _gold, InputArray _actual, double eps, bool alwaysShow)
{
+ Mat src = _src.getMat(), actual = _actual.getMat(), gold = _gold.getMat();
+
Mat diff, diff_thresh;
absdiff(gold, actual, diff);
diff.convertTo(diff, CV_32F);
}
}
-}} // namespace cvtest::ocl
-
-#endif // HAVE_OPENCL
+} } // namespace cvtest::ocl