Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

disabled 'reshape', 'copyTo' test

Browse Source
pull/2346/head
Ilya Lavrenov 11 years ago
parent 7ce2c3574a
commit 9b627a5e9f
5 changed files with 42 additions and 123 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 32
      modules/core/test/test_umat.cpp
  2. 4
      modules/ts/include/opencv2/ts/ocl_perf.hpp
  3. 89
      modules/ts/include/opencv2/ts/ocl_test.hpp
  4. 6
      modules/ts/src/ocl_perf.cpp
  5. 34
      modules/ts/src/ocl_test.cpp

32
modules/core/test/test_umat.cpp
Unescape View File

@ -82,7 +82,7 @@ PARAM_TEST_CASE(UMatBasicTests, int, int, Size, bool)
}
};
OCL_TEST_P(UMatBasicTests, createUMat)
TEST_P(UMatBasicTests, createUMat)
{
if(useRoi)
{
@ -112,7 +112,7 @@ OCL_TEST_P(UMatBasicTests, createUMat)
ASSERT_EQ( ua.dims, 2);
}
OCL_TEST_P(UMatBasicTests, swap)
TEST_P(UMatBasicTests, swap)
{
Mat b = randomMat(size, type, -100, 100);
UMat ub;
@ -128,7 +128,7 @@ OCL_TEST_P(UMatBasicTests, swap)
EXPECT_MAT_NEAR(ud, ua, 0);
}
OCL_TEST_P(UMatBasicTests, base)
TEST_P(UMatBasicTests, base)
{
if(useRoi)
{
@ -167,7 +167,7 @@ OCL_TEST_P(UMatBasicTests, base)
ASSERT_EQ(ub.total(), total);
}
OCL_TEST_P(UMatBasicTests, copyTo)
TEST_P(UMatBasicTests, DISABLED_copyTo)
{
UMat roi_ua;
Mat roi_a;
@ -224,7 +224,7 @@ OCL_TEST_P(UMatBasicTests, copyTo)
}
}
OCL_TEST_P(UMatBasicTests, DISABLED_GetUMat)
TEST_P(UMatBasicTests, DISABLED_GetUMat)
{
if(useRoi)
{
@ -253,7 +253,7 @@ OCL_TEST_P(UMatBasicTests, DISABLED_GetUMat)
}
}
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 ////////////////////////////////////////////////////////////////////////
@ -278,7 +278,7 @@ PARAM_TEST_CASE(UMatTestReshape, int, int, Size, bool)
}
};
OCL_TEST_P(UMatTestReshape, reshape)
TEST_P(UMatTestReshape, DISABLED_reshape)
{
a = randomMat(size,type, -100, 100);
a.copyTo(ua);
@ -342,7 +342,7 @@ OCL_TEST_P(UMatTestReshape, reshape)
}
}
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 ///////////////////////////////////////////////////////////////
@ -364,7 +364,7 @@ PARAM_TEST_CASE(UMatTestRoi, int, int, Size)
}
};
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);
@ -378,7 +378,7 @@ OCL_TEST_P(UMatTestRoi, createRoi)
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);
@ -396,7 +396,7 @@ OCL_TEST_P(UMatTestRoi, locateRoi)
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);
@ -417,7 +417,7 @@ OCL_TEST_P(UMatTestRoi, adjustRoi)
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 ////////////////////////////////////////////////////////////////////
@ -441,7 +441,7 @@ PARAM_TEST_CASE(UMatTestSizeOperations, int, int, Size, bool)
}
};
OCL_TEST_P(UMatTestSizeOperations, copySize)
TEST_P(UMatTestSizeOperations, copySize)
{
Size s = randomSize(1,300);
a = randomMat(size, type, -100, 100);
@ -466,7 +466,7 @@ OCL_TEST_P(UMatTestSizeOperations, copySize)
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 ////////////////////////////////////////////////////////////////////////////
@ -490,7 +490,7 @@ PARAM_TEST_CASE(UMatTestUMatOperations, int, int, Size, bool)
}
};
OCL_TEST_P(UMatTestUMatOperations, diag)
TEST_P(UMatTestUMatOperations, diag)
{
a = randomMat(size, type, -100, 100);
a.copyTo(ua);
@ -514,7 +514,7 @@ OCL_TEST_P(UMatTestUMatOperations, diag)
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 ////////////////////////////////////////////////////////////////////////////

4
modules/ts/include/opencv2/ts/ocl_perf.hpp
Unescape View File

@ -45,8 +45,6 @@
#include "ocl_test.hpp"
#include "ts_perf.hpp"
#ifdef HAVE_OPENCL
namespace cvtest {
namespace ocl {
@ -128,6 +126,4 @@ using namespace perf;
} // namespace cvtest::ocl
} // namespace cvtest
#endif // HAVE_OPENCL
#endif // __OPENCV_TS_OCL_PERF_HPP__

89
modules/ts/include/opencv2/ts/ocl_test.hpp
Unescape View File

@ -42,11 +42,8 @@
#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"
@ -60,38 +57,6 @@ namespace ocl {
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
@ -234,54 +199,22 @@ struct CV_EXPORTS TestUtils
// 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)));
}
};
@ -341,8 +274,6 @@ CV_ENUM(BorderType, BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT, BORDER_WR
#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__

6
modules/ts/src/ocl_perf.cpp
Unescape View File

@ -43,8 +43,6 @@
#include "opencv2/ts/ocl_perf.hpp"
#ifdef HAVE_OPENCL
namespace cvtest {
namespace ocl {
@ -82,6 +80,4 @@ void randu(InputOutputArray dst)
} // namespace perf
}} // namespace cvtest::ocl
#endif // HAVE_OPENCL
} } // namespace cvtest::ocl

34
modules/ts/src/ocl_test.cpp
Unescape View File

@ -43,8 +43,6 @@
#include "opencv2/ts/ocl_test.hpp"
#ifdef HAVE_OPENCL
namespace cvtest {
namespace ocl {
@ -197,41 +195,39 @@ Mat TestUtils::readImageType(const String &fname, int type)
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);
@ -251,7 +247,7 @@ double TestUtils::checkRectSimilarity(Size sz, std::vector<Rect>& ob1, std::vect
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;
@ -259,8 +255,10 @@ double TestUtils::checkRectSimilarity(Size sz, std::vector<Rect>& ob1, std::vect
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);
@ -288,6 +286,4 @@ void TestUtils::showDiff(const Mat& src, const Mat& gold, const Mat& actual, dou
}
}
}} // namespace cvtest::ocl
#endif // HAVE_OPENCL
} } // namespace cvtest::ocl

Write Preview
Loading…
Cancel
Save