mirror of
https://github.com/opencv/opencv.git
synced 2024-11-29 05:29:54 +08:00
Merge pull request #1735 from KonstantinMatskevich:umat_tests
This commit is contained in:
Andrey Pavlenko
OpenCV Buildbot
commit
d68c688f22
@ -15,4 +15,127 @@
|
||||
|
||||
#include "opencv2/core/private.hpp"
|
||||
|
||||
#define MWIDTH 256
|
||||
#define MHEIGHT 256
|
||||
|
||||
#define MIN_VALUE 171
|
||||
#define MAX_VALUE 357
|
||||
|
||||
#define RNG_SEED 123456
|
||||
|
||||
template <typename T>
|
||||
struct TSTestWithParam : public ::testing::TestWithParam<T>
|
||||
{
|
||||
cv::RNG rng;
|
||||
|
||||
TSTestWithParam()
|
||||
{
|
||||
rng = cv::RNG(RNG_SEED);
|
||||
}
|
||||
|
||||
int randomInt(int minVal, int maxVal)
|
||||
{
|
||||
return rng.uniform(minVal, maxVal);
|
||||
}
|
||||
|
||||
double randomDouble(double minVal, double maxVal)
|
||||
{
|
||||
return rng.uniform(minVal, maxVal);
|
||||
}
|
||||
|
||||
double randomDoubleLog(double minVal, double maxVal)
|
||||
{
|
||||
double logMin = log((double)minVal + 1);
|
||||
double logMax = log((double)maxVal + 1);
|
||||
double pow = rng.uniform(logMin, logMax);
|
||||
double v = exp(pow) - 1;
|
||||
CV_Assert(v >= minVal && (v < maxVal || (v == minVal && v == maxVal)));
|
||||
return v;
|
||||
}
|
||||
|
||||
cv::Size randomSize(int minVal, int maxVal)
|
||||
{
|
||||
#if 1
|
||||
return cv::Size((int)randomDoubleLog(minVal, maxVal), (int)randomDoubleLog(minVal, maxVal));
|
||||
#else
|
||||
return cv::Size(randomInt(minVal, maxVal), randomInt(minVal, maxVal));
|
||||
#endif
|
||||
}
|
||||
|
||||
cv::Size randomSize(int minValX, int maxValX, int minValY, int maxValY)
|
||||
{
|
||||
#if 1
|
||||
return cv::Size(randomDoubleLog(minValX, maxValX), randomDoubleLog(minValY, maxValY));
|
||||
#else
|
||||
return cv::Size(randomInt(minVal, maxVal), randomInt(minVal, maxVal));
|
||||
#endif
|
||||
}
|
||||
|
||||
cv::Scalar randomScalar(double minVal, double maxVal)
|
||||
{
|
||||
return cv::Scalar(randomDouble(minVal, maxVal), randomDouble(minVal, maxVal), randomDouble(minVal, maxVal), randomDouble(minVal, maxVal));
|
||||
}
|
||||
|
||||
cv::Mat randomMat(cv::Size size, int type, double minVal, double maxVal, bool useRoi = false)
|
||||
{
|
||||
cv::RNG dataRng(rng.next());
|
||||
return cvtest::randomMat(dataRng, size, type, minVal, maxVal, useRoi);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#define PARAM_TEST_CASE(name, ...) struct name : public TSTestWithParam< std::tr1::tuple< __VA_ARGS__ > >
|
||||
|
||||
#define GET_PARAM(k) std::tr1::get< k >(GetParam())
|
||||
|
||||
#define UMAT_TEST_CHANNELS testing::Values(1, 2, 3, 4)
|
||||
|
||||
#define UMAT_TEST_SIZES testing::Values(cv::Size(1,1), cv::Size(1,128), cv::Size(128,1), cv::Size(128, 128), cv::Size(640,480), cv::Size(751,373), cv::Size(1200, 1200))
|
||||
|
||||
#define UMAT_TEST_DEPTH testing::Values(CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F)
|
||||
|
||||
# define CORE_TEST_P(test_case_name, test_name) \
|
||||
class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : \
|
||||
public test_case_name { \
|
||||
public: \
|
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() { } \
|
||||
virtual void TestBody(); \
|
||||
void CoreTestBody(); \
|
||||
private: \
|
||||
static int AddToRegistry() \
|
||||
{ \
|
||||
::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
|
||||
GetTestCasePatternHolder<test_case_name>(\
|
||||
#test_case_name, __FILE__, __LINE__)->AddTestPattern(\
|
||||
#test_case_name, \
|
||||
#test_name, \
|
||||
new ::testing::internal::TestMetaFactory< \
|
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
|
||||
return 0; \
|
||||
} \
|
||||
\
|
||||
static int gtest_registering_dummy_; \
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(\
|
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
|
||||
}; \
|
||||
\
|
||||
int GTEST_TEST_CLASS_NAME_(test_case_name, \
|
||||
test_name)::gtest_registering_dummy_ = \
|
||||
GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
|
||||
\
|
||||
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() \
|
||||
{ \
|
||||
try \
|
||||
{ \
|
||||
CoreTestBody(); \
|
||||
} \
|
||||
catch (...) \
|
||||
{ \
|
||||
std::cout << "Something wrong in CoreTestBody running" << std::endl; \
|
||||
throw; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::CoreTestBody()
|
||||
|
||||
#endif
|
||||
|
||||
@ -40,258 +40,484 @@
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include "opencv2/core/ocl.hpp"
|
||||
|
||||
using namespace cvtest;
|
||||
using namespace testing;
|
||||
using namespace cv;
|
||||
using namespace std;
|
||||
|
||||
class CV_UMatTest :
|
||||
public cvtest::BaseTest
|
||||
#define EXPECT_MAT_NEAR(mat1, mat2, eps) \
|
||||
{ \
|
||||
ASSERT_EQ(mat1.type(), mat2.type()); \
|
||||
ASSERT_EQ(mat1.size(), mat2.size()); \
|
||||
EXPECT_LE(cv::norm(mat1, mat2), eps); \
|
||||
}\
|
||||
|
||||
////////////////////////////////////////////////////////////// Basic Tests /////////////////////////////////////////////////////////////////////
|
||||
|
||||
PARAM_TEST_CASE(UMatBasicTests, int, int, Size, bool)
|
||||
{
|
||||
public:
|
||||
CV_UMatTest() {}
|
||||
~CV_UMatTest() {}
|
||||
protected:
|
||||
void run(int);
|
||||
|
||||
struct test_excep
|
||||
Mat a;
|
||||
UMat ua;
|
||||
int type;
|
||||
int depth;
|
||||
int cn;
|
||||
Size size;
|
||||
bool useRoi;
|
||||
Size roi_size;
|
||||
Rect roi;
|
||||
virtual void SetUp()
|
||||
{
|
||||
test_excep(const string& _s=string("")) : s(_s) { }
|
||||
string s;
|
||||
};
|
||||
|
||||
bool TestUMat();
|
||||
|
||||
void checkDiff(const Mat& m1, const Mat& m2, const string& s)
|
||||
{
|
||||
if (norm(m1, m2, NORM_INF) != 0)
|
||||
throw test_excep(s);
|
||||
}
|
||||
void checkDiffF(const Mat& m1, const Mat& m2, const string& s)
|
||||
{
|
||||
if (norm(m1, m2, NORM_INF) > 1e-5)
|
||||
throw test_excep(s);
|
||||
depth = GET_PARAM(0);
|
||||
cn = GET_PARAM(1);
|
||||
size = GET_PARAM(2);
|
||||
useRoi = GET_PARAM(3);
|
||||
type = CV_MAKE_TYPE(depth, cn);
|
||||
a = randomMat(size, type, -100, 100);
|
||||
a.copyTo(ua);
|
||||
int roi_shift_x = randomInt(0, size.width-1);
|
||||
int roi_shift_y = randomInt(0, size.height-1);
|
||||
roi_size = Size(size.width - roi_shift_x, size.height - roi_shift_y);
|
||||
roi = Rect(roi_shift_x, roi_shift_y, roi_size.width, roi_size.height);
|
||||
}
|
||||
};
|
||||
|
||||
#define STR(a) STR2(a)
|
||||
#define STR2(a) #a
|
||||
|
||||
#define CHECK_DIFF(a, b) checkDiff(a, b, "(" #a ") != (" #b ") at l." STR(__LINE__))
|
||||
#define CHECK_DIFF_FLT(a, b) checkDiffF(a, b, "(" #a ") !=(eps) (" #b ") at l." STR(__LINE__))
|
||||
|
||||
|
||||
bool CV_UMatTest::TestUMat()
|
||||
CORE_TEST_P(UMatBasicTests, createUMat)
|
||||
{
|
||||
try
|
||||
if(useRoi)
|
||||
{
|
||||
Mat a(100, 100, CV_16SC2), b, c;
|
||||
randu(a, Scalar::all(-100), Scalar::all(100));
|
||||
Rect roi(1, 3, 5, 4);
|
||||
Mat ra(a, roi), rb, rc, rc0;
|
||||
UMat ua, ura, ub, urb, uc, urc;
|
||||
a.copyTo(ua);
|
||||
ua.copyTo(b);
|
||||
CHECK_DIFF(a, b);
|
||||
|
||||
ura = ua(roi);
|
||||
ura.copyTo(rb);
|
||||
|
||||
CHECK_DIFF(ra, rb);
|
||||
|
||||
ra += Scalar::all(1.f);
|
||||
{
|
||||
Mat temp = ura.getMat(ACCESS_RW);
|
||||
temp += Scalar::all(1.f);
|
||||
}
|
||||
ra.copyTo(rb);
|
||||
CHECK_DIFF(ra, rb);
|
||||
|
||||
b = a.clone();
|
||||
ra = a(roi);
|
||||
rb = b(roi);
|
||||
randu(b, Scalar::all(-100), Scalar::all(100));
|
||||
b.copyTo(ub);
|
||||
urb = ub(roi);
|
||||
|
||||
/*std::cout << "==============================================\nbefore op (CPU):\n";
|
||||
std::cout << "ra: " << ra << std::endl;
|
||||
std::cout << "rb: " << rb << std::endl;*/
|
||||
|
||||
ra.copyTo(ura);
|
||||
rb.copyTo(urb);
|
||||
ra.release();
|
||||
rb.release();
|
||||
ura.copyTo(ra);
|
||||
urb.copyTo(rb);
|
||||
|
||||
/*std::cout << "==============================================\nbefore op (GPU):\n";
|
||||
std::cout << "ra: " << ra << std::endl;
|
||||
std::cout << "rb: " << rb << std::endl;*/
|
||||
|
||||
cv::max(ra, rb, rc);
|
||||
cv::max(ura, urb, urc);
|
||||
urc.copyTo(rc0);
|
||||
|
||||
/*std::cout << "==============================================\nafter op:\n";
|
||||
std::cout << "rc: " << rc << std::endl;
|
||||
std::cout << "rc0: " << rc0 << std::endl;*/
|
||||
|
||||
CHECK_DIFF(rc0, rc);
|
||||
|
||||
{
|
||||
UMat tmp = rc0.getUMat(ACCESS_WRITE);
|
||||
cv::max(ura, urb, tmp);
|
||||
}
|
||||
CHECK_DIFF(rc0, rc);
|
||||
|
||||
ura.copyTo(urc);
|
||||
cv::max(urc, urb, urc);
|
||||
urc.copyTo(rc0);
|
||||
CHECK_DIFF(rc0, rc);
|
||||
|
||||
rc = ra ^ rb;
|
||||
cv::bitwise_xor(ura, urb, urc);
|
||||
urc.copyTo(rc0);
|
||||
|
||||
/*std::cout << "==============================================\nafter op:\n";
|
||||
std::cout << "ra: " << rc0 << std::endl;
|
||||
std::cout << "rc: " << rc << std::endl;*/
|
||||
|
||||
CHECK_DIFF(rc0, rc);
|
||||
|
||||
rc = ra + rb;
|
||||
cv::add(ura, urb, urc);
|
||||
urc.copyTo(rc0);
|
||||
|
||||
CHECK_DIFF(rc0, rc);
|
||||
|
||||
cv::subtract(ra, Scalar::all(5), rc);
|
||||
cv::subtract(ura, Scalar::all(5), urc);
|
||||
urc.copyTo(rc0);
|
||||
|
||||
CHECK_DIFF(rc0, rc);
|
||||
ua = UMat(ua, roi);
|
||||
}
|
||||
catch (const test_excep& e)
|
||||
int dims = randomInt(2,6);
|
||||
int _sz[CV_MAX_DIM];
|
||||
for( int i = 0; i<dims; i++)
|
||||
{
|
||||
ts->printf(cvtest::TS::LOG, "%s\n", e.s.c_str());
|
||||
ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
|
||||
return false;
|
||||
_sz[i] = randomInt(1,50);
|
||||
}
|
||||
return true;
|
||||
int *sz = _sz;
|
||||
int new_depth = randomInt(CV_8S, CV_64F);
|
||||
int new_cn = randomInt(1,4);
|
||||
ua.create(dims, sz, CV_MAKE_TYPE(new_depth, new_cn));
|
||||
|
||||
for(int i = 0; i<dims; i++)
|
||||
{
|
||||
ASSERT_EQ(ua.size[i], sz[i]);
|
||||
}
|
||||
ASSERT_EQ(ua.dims, dims);
|
||||
ASSERT_EQ(ua.type(), CV_MAKE_TYPE(new_depth, new_cn) );
|
||||
Size new_size = randomSize(1, 1000);
|
||||
ua.create(new_size, CV_MAKE_TYPE(new_depth, new_cn) );
|
||||
ASSERT_EQ( ua.size(), new_size);
|
||||
ASSERT_EQ(ua.type(), CV_MAKE_TYPE(new_depth, new_cn) );
|
||||
ASSERT_EQ( ua.dims, 2);
|
||||
}
|
||||
|
||||
void CV_UMatTest::run( int /* start_from */)
|
||||
CORE_TEST_P(UMatBasicTests, swap)
|
||||
{
|
||||
printf("Use OpenCL: %s\nHave OpenCL: %s\n",
|
||||
ocl::useOpenCL() ? "TRUE" : "FALSE",
|
||||
ocl::haveOpenCL() ? "TRUE" : "FALSE" );
|
||||
|
||||
if (!TestUMat())
|
||||
return;
|
||||
|
||||
ts->set_failed_test_info(cvtest::TS::OK);
|
||||
Mat b = randomMat(size, type, -100, 100);
|
||||
UMat ub;
|
||||
b.copyTo(ub);
|
||||
if(useRoi)
|
||||
{
|
||||
ua = UMat(ua,roi);
|
||||
ub = UMat(ub,roi);
|
||||
}
|
||||
UMat uc = ua, ud = ub;
|
||||
swap(ua,ub);
|
||||
EXPECT_MAT_NEAR(ub,uc, 0);
|
||||
EXPECT_MAT_NEAR(ud, ua, 0);
|
||||
}
|
||||
|
||||
TEST(Core_UMat, base) { CV_UMatTest test; test.safe_run(); }
|
||||
|
||||
TEST(Core_UMat, getUMat)
|
||||
CORE_TEST_P(UMatBasicTests, base)
|
||||
{
|
||||
if(useRoi)
|
||||
{
|
||||
int a[3] = { 1, 2, 3 };
|
||||
Mat m = Mat(1, 1, CV_32SC3, a);
|
||||
UMat u = m.getUMat(ACCESS_READ);
|
||||
EXPECT_NE((void*)NULL, u.u);
|
||||
ua = UMat(ua,roi);
|
||||
}
|
||||
UMat ub = ua.clone();
|
||||
EXPECT_MAT_NEAR(ub,ua,0);
|
||||
|
||||
ASSERT_EQ(ua.channels(), cn);
|
||||
ASSERT_EQ(ua.depth(), depth);
|
||||
ASSERT_EQ(ua.type(), type);
|
||||
ASSERT_EQ(ua.elemSize(), a.elemSize());
|
||||
ASSERT_EQ(ua.elemSize1(), a.elemSize1());
|
||||
ASSERT_EQ(ub.empty(), ub.cols*ub.rows == 0);
|
||||
ub.release();
|
||||
ASSERT_TRUE( ub.empty() );
|
||||
if(useRoi && a.size() != ua.size())
|
||||
{
|
||||
ASSERT_EQ(ua.isSubmatrix(), true);
|
||||
}
|
||||
else
|
||||
{
|
||||
ASSERT_EQ(ua.isSubmatrix(), false);
|
||||
}
|
||||
|
||||
int dims = randomInt(2,6);
|
||||
int sz[CV_MAX_DIM];
|
||||
size_t total = 1;
|
||||
for(int i = 0; i<dims; i++)
|
||||
{
|
||||
Mat m(10, 10, CV_8UC1), ref;
|
||||
for (int y = 0; y < m.rows; ++y)
|
||||
{
|
||||
uchar * const ptr = m.ptr<uchar>(y);
|
||||
for (int x = 0; x < m.cols; ++x)
|
||||
ptr[x] = (uchar)(x + y * 2);
|
||||
}
|
||||
sz[i] = randomInt(1,45);
|
||||
total *= (size_t)sz[i];
|
||||
}
|
||||
int new_type = CV_MAKE_TYPE(randomInt(CV_8S,CV_64F),randomInt(1,4));
|
||||
ub = UMat(dims, sz, new_type);
|
||||
ASSERT_EQ(ub.total(), total);
|
||||
}
|
||||
|
||||
ref = m.clone();
|
||||
Rect r(1, 1, 8, 8);
|
||||
ref(r).setTo(17);
|
||||
|
||||
{
|
||||
UMat um = m(r).getUMat(ACCESS_WRITE);
|
||||
um.setTo(17);
|
||||
}
|
||||
|
||||
double err = norm(m, ref, NORM_INF);
|
||||
if (err > 0)
|
||||
{
|
||||
std::cout << "m: " << std::endl << m << std::endl;
|
||||
std::cout << "ref: " << std::endl << ref << std::endl;
|
||||
}
|
||||
EXPECT_EQ(0., err);
|
||||
CORE_TEST_P(UMatBasicTests, copyTo)
|
||||
{
|
||||
UMat roi_ua;
|
||||
Mat roi_a;
|
||||
int i;
|
||||
if(useRoi)
|
||||
{
|
||||
roi_ua = UMat(ua, roi);
|
||||
roi_a = Mat(a, roi);
|
||||
roi_a.copyTo(roi_ua);
|
||||
EXPECT_MAT_NEAR(roi_a, roi_ua, 0);
|
||||
roi_ua.copyTo(roi_a);
|
||||
EXPECT_MAT_NEAR(roi_ua, roi_a, 0);
|
||||
roi_ua.copyTo(ua);
|
||||
EXPECT_MAT_NEAR(roi_ua, ua, 0);
|
||||
ua.copyTo(a);
|
||||
EXPECT_MAT_NEAR(ua, a, 0);
|
||||
}
|
||||
{
|
||||
UMat ub;
|
||||
ua.copyTo(ub);
|
||||
EXPECT_MAT_NEAR(ua, ub, 0);
|
||||
}
|
||||
{
|
||||
UMat ub;
|
||||
i = randomInt(0, ua.cols-1);
|
||||
a.col(i).copyTo(ub);
|
||||
EXPECT_MAT_NEAR(a.col(i), ub, 0);
|
||||
}
|
||||
{
|
||||
UMat ub;
|
||||
ua.col(i).copyTo(ub);
|
||||
EXPECT_MAT_NEAR(ua.col(i), ub, 0);
|
||||
}
|
||||
{
|
||||
Mat b;
|
||||
ua.col(i).copyTo(b);
|
||||
EXPECT_MAT_NEAR(ua.col(i), b, 0);
|
||||
}
|
||||
{
|
||||
UMat ub;
|
||||
i = randomInt(0, a.rows-1);
|
||||
ua.row(i).copyTo(ub);
|
||||
EXPECT_MAT_NEAR(ua.row(i), ub, 0);
|
||||
}
|
||||
{
|
||||
UMat ub;
|
||||
a.row(i).copyTo(ub);
|
||||
EXPECT_MAT_NEAR(a.row(i), ub, 0);
|
||||
}
|
||||
{
|
||||
Mat b;
|
||||
ua.row(i).copyTo(b);
|
||||
EXPECT_MAT_NEAR(ua.row(i), b, 0);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(UMat, Sync)
|
||||
CORE_TEST_P(UMatBasicTests, DISABLED_GetUMat)
|
||||
{
|
||||
UMat um(10, 10, CV_8UC1);
|
||||
|
||||
if(useRoi)
|
||||
{
|
||||
Mat m = um.getMat(ACCESS_WRITE);
|
||||
m.setTo(cv::Scalar::all(17));
|
||||
a = Mat(a, roi);
|
||||
ua = UMat(ua,roi);
|
||||
}
|
||||
{
|
||||
UMat ub;
|
||||
ub = a.getUMat(ACCESS_RW);
|
||||
EXPECT_MAT_NEAR(ub, ua, 0);
|
||||
}
|
||||
{
|
||||
Mat b;
|
||||
b = a.getUMat(ACCESS_RW).getMat(ACCESS_RW);
|
||||
EXPECT_MAT_NEAR(b, a, 0);
|
||||
}
|
||||
{
|
||||
Mat b;
|
||||
b = ua.getMat(ACCESS_RW);
|
||||
EXPECT_MAT_NEAR(b, a, 0);
|
||||
}
|
||||
{
|
||||
UMat ub;
|
||||
ub = ua.getMat(ACCESS_RW).getUMat(ACCESS_RW);
|
||||
EXPECT_MAT_NEAR(ub, ua, 0);
|
||||
}
|
||||
}
|
||||
|
||||
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 ////////////////////////////////////////////////////////////////////////
|
||||
|
||||
PARAM_TEST_CASE(UMatTestReshape, int, int, Size, bool)
|
||||
{
|
||||
Mat a;
|
||||
UMat ua, ub;
|
||||
int type;
|
||||
int depth;
|
||||
int cn;
|
||||
Size size;
|
||||
bool useRoi;
|
||||
Size roi_size;
|
||||
virtual void SetUp()
|
||||
{
|
||||
depth = GET_PARAM(0);
|
||||
cn = GET_PARAM(1);
|
||||
size = GET_PARAM(2);
|
||||
useRoi = GET_PARAM(3);
|
||||
type = CV_MAKE_TYPE(depth, cn);
|
||||
}
|
||||
};
|
||||
|
||||
CORE_TEST_P(UMatTestReshape, reshape)
|
||||
{
|
||||
a = randomMat(size,type, -100, 100);
|
||||
a.copyTo(ua);
|
||||
if(useRoi)
|
||||
{
|
||||
int roi_shift_x = randomInt(0, size.width-1);
|
||||
int roi_shift_y = randomInt(0, size.height-1);
|
||||
roi_size = Size(size.width - roi_shift_x, size.height - roi_shift_y);
|
||||
Rect roi(roi_shift_x, roi_shift_y, roi_size.width, roi_size.height);
|
||||
ua = UMat(ua, roi).clone();
|
||||
a = Mat(a, roi).clone();
|
||||
}
|
||||
|
||||
um.setTo(cv::Scalar::all(19));
|
||||
int nChannels = randomInt(1,4);
|
||||
|
||||
EXPECT_EQ(0, cv::norm(um.getMat(ACCESS_READ), cv::Mat(um.size(), um.type(), 19), NORM_INF));
|
||||
if ((ua.cols*ua.channels()*ua.rows)%nChannels != 0)
|
||||
{
|
||||
EXPECT_ANY_THROW(ua.reshape(nChannels));
|
||||
}
|
||||
else
|
||||
{
|
||||
ub = ua.reshape(nChannels);
|
||||
ASSERT_EQ(ub.channels(),nChannels);
|
||||
ASSERT_EQ(ub.channels()*ub.cols*ub.rows, ua.channels()*ua.cols*ua.rows);
|
||||
|
||||
EXPECT_MAT_NEAR(ua.reshape(nChannels), a.reshape(nChannels), 0);
|
||||
|
||||
int new_rows = randomInt(1, INT_MAX);
|
||||
if ( ((int)ua.total()*ua.channels())%(new_rows*nChannels) != 0)
|
||||
{
|
||||
EXPECT_ANY_THROW (ua.reshape(nChannels, new_rows) );
|
||||
}
|
||||
else
|
||||
{
|
||||
EXPECT_NO_THROW ( ub = ua.reshape(nChannels, new_rows) );
|
||||
ASSERT_EQ(ub.channels(),nChannels);
|
||||
ASSERT_EQ(ub.rows, new_rows);
|
||||
ASSERT_EQ(ub.channels()*ub.cols*ub.rows, ua.channels()*ua.cols*ua.rows);
|
||||
|
||||
EXPECT_MAT_NEAR(ua.reshape(nChannels,new_rows), a.reshape(nChannels,new_rows), 0);
|
||||
}
|
||||
|
||||
new_rows = (int)ua.total()*ua.channels()/(nChannels*randomInt(1, size.width*size.height));
|
||||
if (new_rows == 0) new_rows = 1;
|
||||
int new_cols = (int)ua.total()*ua.channels()/(new_rows*nChannels);
|
||||
int sz[] = {new_rows, new_cols};
|
||||
if( ((int)ua.total()*ua.channels()) % (new_rows*new_cols) != 0 )
|
||||
{
|
||||
EXPECT_ANY_THROW( ua.reshape(nChannels, ua.dims, sz) );
|
||||
}
|
||||
else
|
||||
{
|
||||
EXPECT_NO_THROW ( ub = ua.reshape(nChannels, ua.dims, sz) );
|
||||
ASSERT_EQ(ub.channels(),nChannels);
|
||||
ASSERT_EQ(ub.rows, new_rows);
|
||||
ASSERT_EQ(ub.cols, new_cols);
|
||||
ASSERT_EQ(ub.channels()*ub.cols*ub.rows, ua.channels()*ua.cols*ua.rows);
|
||||
|
||||
EXPECT_MAT_NEAR(ua.reshape(nChannels, ua.dims, sz), a.reshape(nChannels, a.dims, sz), 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#define EXPECT_MAT_NEAR(m1, m2) ASSERT_EQ(0, cv::norm(m1, m1, cv::NORM_INF))
|
||||
INSTANTIATE_TEST_CASE_P(UMat, UMatTestReshape, Combine(UMAT_TEST_DEPTH, UMAT_TEST_CHANNELS, UMAT_TEST_SIZES, Bool() ));
|
||||
|
||||
TEST(UMat, setOpenCL)
|
||||
////////////////////////////////////////////////////////////////// ROI testing ///////////////////////////////////////////////////////////////
|
||||
|
||||
PARAM_TEST_CASE(UMatTestRoi, int, int, Size)
|
||||
{
|
||||
// save the current state
|
||||
bool useOCL = ocl::useOpenCL();
|
||||
Mat a, roi_a;
|
||||
UMat ua, roi_ua;
|
||||
int type;
|
||||
int depth;
|
||||
int cn;
|
||||
Size size;
|
||||
Size roi_size;
|
||||
virtual void SetUp()
|
||||
{
|
||||
depth = GET_PARAM(0);
|
||||
cn = GET_PARAM(1);
|
||||
size = GET_PARAM(2);
|
||||
type = CV_MAKE_TYPE(depth, cn);
|
||||
}
|
||||
};
|
||||
|
||||
Mat m = (Mat_<uchar>(3,3)<<0,1,2,3,4,5,6,7,8);
|
||||
CORE_TEST_P(UMatTestRoi, createRoi)
|
||||
{
|
||||
int roi_shift_x = randomInt(0, size.width-1);
|
||||
int roi_shift_y = randomInt(0, size.height-1);
|
||||
roi_size = Size(size.width - roi_shift_x, size.height - roi_shift_y);
|
||||
a = randomMat(size, type, -100, 100);
|
||||
Rect roi(roi_shift_x, roi_shift_y, roi_size.width, roi_size.height);
|
||||
roi_a = Mat(a, roi);
|
||||
a.copyTo(ua);
|
||||
roi_ua = UMat(ua, roi);
|
||||
|
||||
ocl::setUseOpenCL(true);
|
||||
UMat um1;
|
||||
m.copyTo(um1);
|
||||
|
||||
ocl::setUseOpenCL(false);
|
||||
UMat um2;
|
||||
m.copyTo(um2);
|
||||
|
||||
ocl::setUseOpenCL(true);
|
||||
countNonZero(um1);
|
||||
countNonZero(um2);
|
||||
|
||||
um1.copyTo(um2);
|
||||
EXPECT_MAT_NEAR(um1, um2);
|
||||
EXPECT_MAT_NEAR(um1, m);
|
||||
um2.copyTo(um1);
|
||||
EXPECT_MAT_NEAR(um1, m);
|
||||
EXPECT_MAT_NEAR(um1, um2);
|
||||
|
||||
ocl::setUseOpenCL(false);
|
||||
countNonZero(um1);
|
||||
countNonZero(um2);
|
||||
|
||||
um1.copyTo(um2);
|
||||
EXPECT_MAT_NEAR(um1, um2);
|
||||
EXPECT_MAT_NEAR(um1, m);
|
||||
um2.copyTo(um1);
|
||||
EXPECT_MAT_NEAR(um1, um2);
|
||||
EXPECT_MAT_NEAR(um1, m);
|
||||
|
||||
// reset state to the previous one
|
||||
ocl::setUseOpenCL(useOCL);
|
||||
EXPECT_MAT_NEAR(roi_a, roi_ua, 0);
|
||||
}
|
||||
|
||||
CORE_TEST_P(UMatTestRoi, locateRoi)
|
||||
{
|
||||
int roi_shift_x = randomInt(0, size.width-1);
|
||||
int roi_shift_y = randomInt(0, size.height-1);
|
||||
roi_size = Size(size.width - roi_shift_x, size.height - roi_shift_y);
|
||||
a = randomMat(size, type, -100, 100);
|
||||
Rect roi(roi_shift_x, roi_shift_y, roi_size.width, roi_size.height);
|
||||
roi_a = Mat(a, roi);
|
||||
a.copyTo(ua);
|
||||
roi_ua = UMat(ua,roi);
|
||||
Size sz, usz;
|
||||
Point p, up;
|
||||
roi_a.locateROI(sz, p);
|
||||
roi_ua.locateROI(usz, up);
|
||||
ASSERT_EQ(sz, usz);
|
||||
ASSERT_EQ(p, up);
|
||||
}
|
||||
|
||||
CORE_TEST_P(UMatTestRoi, adjustRoi)
|
||||
{
|
||||
int roi_shift_x = randomInt(0, size.width-1);
|
||||
int roi_shift_y = randomInt(0, size.height-1);
|
||||
roi_size = Size(size.width - roi_shift_x, size.height - roi_shift_y);
|
||||
a = randomMat(size, type, -100, 100);
|
||||
Rect roi(roi_shift_x, roi_shift_y, roi_size.width, roi_size.height);
|
||||
a.copyTo(ua);
|
||||
roi_ua = UMat( ua, roi);
|
||||
int adjLeft = randomInt(-(roi_ua.cols/2), (size.width-1)/2);
|
||||
int adjRight = randomInt(-(roi_ua.cols/2), (size.width-1)/2);
|
||||
int adjTop = randomInt(-(roi_ua.rows/2), (size.height-1)/2);
|
||||
int adjBot = randomInt(-(roi_ua.rows/2), (size.height-1)/2);
|
||||
roi_ua.adjustROI(adjTop, adjBot, adjLeft, adjRight);
|
||||
roi_shift_x = max(0, roi.x-adjLeft);
|
||||
roi_shift_y = max(0, roi.y-adjTop);
|
||||
Rect new_roi( roi_shift_x, roi_shift_y, min(roi.width+adjRight+adjLeft, size.width-roi_shift_x), min(roi.height+adjBot+adjTop, size.height-roi_shift_y) );
|
||||
UMat test_roi = UMat(ua, new_roi);
|
||||
EXPECT_MAT_NEAR(roi_ua, test_roi, 0);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(UMat, UMatTestRoi, Combine(UMAT_TEST_DEPTH, UMAT_TEST_CHANNELS, UMAT_TEST_SIZES ));
|
||||
|
||||
/////////////////////////////////////////////////////////////// Size ////////////////////////////////////////////////////////////////////
|
||||
|
||||
PARAM_TEST_CASE(UMatTestSizeOperations, int, int, Size, bool)
|
||||
{
|
||||
Mat a, b, roi_a, roi_b;
|
||||
UMat ua, ub, roi_ua, roi_ub;
|
||||
int type;
|
||||
int depth;
|
||||
int cn;
|
||||
Size size;
|
||||
Size roi_size;
|
||||
bool useRoi;
|
||||
virtual void SetUp()
|
||||
{
|
||||
depth = GET_PARAM(0);
|
||||
cn = GET_PARAM(1);
|
||||
size = GET_PARAM(2);
|
||||
useRoi = GET_PARAM(3);
|
||||
type = CV_MAKE_TYPE(depth, cn);
|
||||
}
|
||||
};
|
||||
|
||||
CORE_TEST_P(UMatTestSizeOperations, copySize)
|
||||
{
|
||||
Size s = randomSize(1,300);
|
||||
a = randomMat(size, type, -100, 100);
|
||||
b = randomMat(s, type, -100, 100);
|
||||
a.copyTo(ua);
|
||||
b.copyTo(ub);
|
||||
if(useRoi)
|
||||
{
|
||||
int roi_shift_x = randomInt(0, size.width-1);
|
||||
int roi_shift_y = randomInt(0, size.height-1);
|
||||
roi_size = Size(size.width - roi_shift_x, size.height - roi_shift_y);
|
||||
Rect roi(roi_shift_x, roi_shift_y, roi_size.width, roi_size.height);
|
||||
ua = UMat(ua,roi);
|
||||
|
||||
roi_shift_x = randomInt(0, s.width-1);
|
||||
roi_shift_y = randomInt(0, s.height-1);
|
||||
roi_size = Size(s.width - roi_shift_x, s.height - roi_shift_y);
|
||||
roi = Rect(roi_shift_x, roi_shift_y, roi_size.width, roi_size.height);
|
||||
ub = UMat(ub, roi);
|
||||
}
|
||||
ua.copySize(ub);
|
||||
ASSERT_EQ(ua.size, ub.size);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(UMat, UMatTestSizeOperations, Combine(UMAT_TEST_DEPTH, UMAT_TEST_CHANNELS, UMAT_TEST_SIZES, Bool() ));
|
||||
|
||||
///////////////////////////////////////////////////////////////// UMat operations ////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
PARAM_TEST_CASE(UMatTestUMatOperations, int, int, Size, bool)
|
||||
{
|
||||
Mat a, b;
|
||||
UMat ua, ub;
|
||||
int type;
|
||||
int depth;
|
||||
int cn;
|
||||
Size size;
|
||||
Size roi_size;
|
||||
bool useRoi;
|
||||
virtual void SetUp()
|
||||
{
|
||||
depth = GET_PARAM(0);
|
||||
cn = GET_PARAM(1);
|
||||
size = GET_PARAM(2);
|
||||
useRoi = GET_PARAM(3);
|
||||
type = CV_MAKE_TYPE(depth, cn);
|
||||
}
|
||||
};
|
||||
|
||||
CORE_TEST_P(UMatTestUMatOperations, diag)
|
||||
{
|
||||
a = randomMat(size, type, -100, 100);
|
||||
a.copyTo(ua);
|
||||
Mat new_diag;
|
||||
if(useRoi)
|
||||
{
|
||||
int roi_shift_x = randomInt(0, size.width-1);
|
||||
int roi_shift_y = randomInt(0, size.height-1);
|
||||
roi_size = Size(size.width - roi_shift_x, size.height - roi_shift_y);
|
||||
Rect roi(roi_shift_x, roi_shift_y, roi_size.width, roi_size.height);
|
||||
ua = UMat(ua,roi);
|
||||
a = Mat(a, roi);
|
||||
}
|
||||
int n = randomInt(0, ua.cols-1);
|
||||
ub = ua.diag(n);
|
||||
b = a.diag(n);
|
||||
EXPECT_MAT_NEAR(b, ub, 0);
|
||||
new_diag = randomMat(Size(ua.rows, 1), type, -100, 100);
|
||||
new_diag.copyTo(ub);
|
||||
ua = cv::UMat::diag(ub);
|
||||
EXPECT_MAT_NEAR(ua.diag(), new_diag.t(), 0);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(UMat, UMatTestUMatOperations, Combine(UMAT_TEST_DEPTH, UMAT_TEST_CHANNELS, UMAT_TEST_SIZES, Bool() ));
|
||||
|
||||
///////////////////////////////////////////////////////////////// OpenCL ////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
TEST(UMat, BufferPoolGrowing)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
@ -300,7 +526,7 @@ TEST(UMat, BufferPoolGrowing)
|
||||
const int ITERATIONS = 200;
|
||||
#endif
|
||||
const Size sz(1920, 1080);
|
||||
BufferPoolController* c = ocl::getOpenCLAllocator()->getBufferPoolController();
|
||||
BufferPoolController* c = cv::ocl::getOpenCLAllocator()->getBufferPoolController();
|
||||
if (c)
|
||||
{
|
||||
size_t oldMaxReservedSize = c->getMaxReservedSize();
|
||||
@ -319,3 +545,44 @@ TEST(UMat, BufferPoolGrowing)
|
||||
std::cout << "Skipped, no OpenCL" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
TEST(UMat, setOpenCL)
|
||||
{
|
||||
// save the current state
|
||||
bool useOCL = cv::ocl::useOpenCL();
|
||||
|
||||
Mat m = (Mat_<uchar>(3,3)<<0,1,2,3,4,5,6,7,8);
|
||||
|
||||
cv::ocl::setUseOpenCL(true);
|
||||
UMat um1;
|
||||
m.copyTo(um1);
|
||||
|
||||
cv::ocl::setUseOpenCL(false);
|
||||
UMat um2;
|
||||
m.copyTo(um2);
|
||||
|
||||
cv::ocl::setUseOpenCL(true);
|
||||
countNonZero(um1);
|
||||
countNonZero(um2);
|
||||
|
||||
um1.copyTo(um2);
|
||||
EXPECT_MAT_NEAR(um1, um2, 0);
|
||||
EXPECT_MAT_NEAR(um1, m, 0);
|
||||
um2.copyTo(um1);
|
||||
EXPECT_MAT_NEAR(um1, m, 0);
|
||||
EXPECT_MAT_NEAR(um1, um2, 0);
|
||||
|
||||
cv::ocl::setUseOpenCL(false);
|
||||
countNonZero(um1);
|
||||
countNonZero(um2);
|
||||
|
||||
um1.copyTo(um2);
|
||||
EXPECT_MAT_NEAR(um1, um2, 0);
|
||||
EXPECT_MAT_NEAR(um1, m, 0);
|
||||
um2.copyTo(um1);
|
||||
EXPECT_MAT_NEAR(um1, um2, 0);
|
||||
EXPECT_MAT_NEAR(um1, m, 0);
|
||||
|
||||
// reset state to the previous one
|
||||
cv::ocl::setUseOpenCL(useOCL);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user