Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Added implementation and test for the GPU version of flip, resize, sum, minMax, copyConstBorder, setTo, based on NPP.

Browse Source
pull/13383/head
Vladislav Vinogradov 15 years ago
parent 3d9c78f4aa
commit b5c92a7dc0
4 changed files with 469 additions and 13 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. 21
      modules/gpu/include/opencv2/gpu/gpu.hpp
  2. 158
      modules/gpu/src/arithm.cpp
  3. 44
      modules/gpu/src/matrix_operations.cpp
  4. 259
      tests/gpu/src/npp_image_arithm.cpp

21
modules/gpu/include/opencv2/gpu/gpu.hpp
Unescape View File

@ -45,6 +45,7 @@
#include <vector>
#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/gpu/devmem2d.hpp"
namespace cv
@ -372,9 +373,29 @@ namespace cv
//! computes mean value and standard deviation of all or selected array elements
CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
//! computes norm of array
//! Supports NORM_INF, NORM_L1, NORM_L2
CV_EXPORTS double norm(const GpuMat& src1, int normType=NORM_L2);
//! computes norm of the difference between two arrays
//! Supports NORM_INF, NORM_L1, NORM_L2
CV_EXPORTS double norm(const GpuMat& src1, const GpuMat& src2, int normType=NORM_L2);
//! reverses the order of the rows, columns or both in a matrix
CV_EXPORTS void flip(const GpuMat& a, GpuMat& b, int flipCode);
//! resizes the image
//! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_LANCZOS4
CV_EXPORTS void resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR);
//! computes sum of array elements
CV_EXPORTS Scalar sum(const GpuMat& m);
//! finds global minimum and maximum array elements and returns their values
CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal = 0);
//! copies 2D array to a larger destination array and pads borders with user-specifiable constant
CV_EXPORTS void copyConstBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value = Scalar());
////////////////////////////// Image processing //////////////////////////////
// DST[x,y] = SRC[xmap[x,y],ymap[x,y]] with bilinear interpolation.
// xymap.type() == xymap.type() == CV_32FC1

158
modules/gpu/src/arithm.cpp
Unescape View File

@ -66,6 +66,16 @@ void cv::gpu::meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev) { thro
double cv::gpu::norm(const GpuMat& src1, int normType) { throw_nogpu(); return 0.0; }
double cv::gpu::norm(const GpuMat& src1, const GpuMat& src2, int normType) { throw_nogpu(); return 0.0; }
void cv::gpu::flip(const GpuMat& a, GpuMat& b, int flipCode) { throw_nogpu(); }
void cv::gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx, double fy, int interpolation) { throw_nogpu(); }
Scalar cv::gpu::sum(const GpuMat& m) { throw_nogpu(); return Scalar(); }
void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal) { throw_nogpu(); }
void cv::gpu::copyConstBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value) { throw_nogpu(); }
#else /* !defined (HAVE_CUDA) */
namespace
@ -247,13 +257,157 @@ double cv::gpu::norm(const GpuMat& src1, const GpuMat& src2, int normType)
sz.height = src1.rows;
int funcIdx = normType >> 1;
Npp64f retVal[3];
Scalar retVal;
npp_norm_diff_func[funcIdx]((const Npp8u*)src1.ptr<char>(), src1.step,
(const Npp8u*)src2.ptr<char>(), src2.step,
sz, retVal);
sz, retVal.val);
return retVal[0];
}
void cv::gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode)
{
CV_Assert(src.type() == CV_8UC1 || src.type() == CV_8UC4);
dst.create( src.size(), src.type() );
NppiSize sz;
sz.width = src.cols;
sz.height = src.rows;
if (src.channels() == 1)
{
nppiMirror_8u_C1R((const Npp8u*)src.ptr<char>(), src.step,
(Npp8u*)dst.ptr<char>(), dst.step, sz,
(flipCode == 0 ? NPP_HORIZONTAL_AXIS : (flipCode > 0 ? NPP_VERTICAL_AXIS : NPP_BOTH_AXIS)));
}
else
{
nppiMirror_8u_C4R((const Npp8u*)src.ptr<char>(), src.step,
(Npp8u*)dst.ptr<char>(), dst.step, sz,
(flipCode == 0 ? NPP_HORIZONTAL_AXIS : (flipCode > 0 ? NPP_VERTICAL_AXIS : NPP_BOTH_AXIS)));
}
}
void cv::gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx, double fy, int interpolation)
{
static const int npp_inter[] = {NPPI_INTER_NN, NPPI_INTER_LINEAR, NPPI_INTER_CUBIC, 0, NPPI_INTER_LANCZOS};
CV_Assert((src.type() == CV_8UC1 || src.type() == CV_8UC4) &&
(interpolation == INTER_NEAREST || interpolation == INTER_LINEAR || interpolation == INTER_CUBIC || interpolation == INTER_LANCZOS4));
CV_Assert( src.size().area() > 0 );
CV_Assert( !(dsize == Size()) || (fx > 0 && fy > 0) );
if( dsize == Size() )
{
dsize = Size(saturate_cast<int>(src.cols * fx), saturate_cast<int>(src.rows * fy));
}
else
{
fx = (double)dsize.width / src.cols;
fy = (double)dsize.height / src.rows;
}
dst.create(dsize, src.type());
NppiSize srcsz;
srcsz.width = src.cols;
srcsz.height = src.rows;
NppiRect srcrect;
srcrect.x = srcrect.y = 0;
srcrect.width = src.cols;
srcrect.height = src.rows;
NppiSize dstsz;
dstsz.width = dst.cols;
dstsz.height = dst.rows;
if (src.channels() == 1)
{
nppiResize_8u_C1R((const Npp8u*)src.ptr<char>(), srcsz, src.step, srcrect,
(Npp8u*)dst.ptr<char>(), dst.step, dstsz, fx, fy, npp_inter[interpolation]);
}
else
{
nppiResize_8u_C4R((const Npp8u*)src.ptr<char>(), srcsz, src.step, srcrect,
(Npp8u*)dst.ptr<char>(), dst.step, dstsz, fx, fy, npp_inter[interpolation]);
}
}
Scalar cv::gpu::sum(const GpuMat& src)
{
CV_Assert(src.type() == CV_8UC1 || src.type() == CV_8UC4);
Scalar res;
NppiSize sz;
sz.width = src.cols;
sz.height = src.rows;
if (src.channels() == 1)
{
nppiSum_8u_C1R((const Npp8u*)src.ptr<char>(), src.step, sz, res.val);
}
else
{
nppiSum_8u_C4R((const Npp8u*)src.ptr<char>(), src.step, sz, res.val);
}
return res;
}
void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal)
{
CV_Assert(src.type() == CV_8UC1);
NppiSize sz;
sz.width = src.cols;
sz.height = src.rows;
Npp8u min_res, max_res;
nppiMinMax_8u_C1R((const Npp8u*)src.ptr<char>(), src.step, sz, &min_res, &max_res);
if (minVal)
*minVal = min_res;
if (maxVal)
*maxVal = max_res;
}
void cv::gpu::copyConstBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value)
{
CV_Assert(src.type() == CV_8UC1 || src.type() == CV_8UC4 || src.type() == CV_32SC1);
dst.create(src.rows + top + bottom, src.cols + left + right, src.type());
NppiSize srcsz;
srcsz.width = src.cols;
srcsz.height = src.rows;
NppiSize dstsz;
dstsz.width = dst.cols;
dstsz.height = dst.rows;
if (src.depth() == CV_8U)
{
if (src.channels() == 1)
{
Npp8u nVal = (Npp8u)value[0];
nppiCopyConstBorder_8u_C1R((const Npp8u*)src.ptr<char>(), src.step, srcsz,
(Npp8u*)dst.ptr<char>(), dst.step, dstsz, top, left, nVal);
}
else
{
Npp8u nVal[] = {(Npp8u)value[0], (Npp8u)value[1], (Npp8u)value[2], (Npp8u)value[3]};
nppiCopyConstBorder_8u_C4R((const Npp8u*)src.ptr<char>(), src.step, srcsz,
(Npp8u*)dst.ptr<char>(), dst.step, dstsz, top, left, nVal);
}
}
else //if (src.depth() == CV_32S)
{
Npp32s nVal = (Npp32s)value[0];
nppiCopyConstBorder_32s_C1R((const Npp32s*)src.ptr<char>(), src.step, srcsz,
(Npp32s*)dst.ptr<char>(), dst.step, dstsz, top, left, nVal);
}
}
#endif /* !defined (HAVE_CUDA) */

44
modules/gpu/src/matrix_operations.cpp
Unescape View File

@ -162,7 +162,49 @@ GpuMat& GpuMat::setTo(const Scalar& s, const GpuMat& mask)
CV_DbgAssert(!this->empty());
if (mask.empty())
matrix_operations::set_to_without_mask( *this, depth(), s.val, channels());
{
switch (type())
{
case CV_8UC1:
{
NppiSize sz;
sz.width = cols;
sz.height = rows;
Npp8u nVal = (Npp8u)s[0];
nppiSet_8u_C1R(nVal, (Npp8u*)ptr<char>(), step, sz);
break;
}
case CV_8UC4:
{
NppiSize sz;
sz.width = cols;
sz.height = rows;
Npp8u nVal[] = {(Npp8u)s[0], (Npp8u)s[1], (Npp8u)s[2], (Npp8u)s[3]};
nppiSet_8u_C4R(nVal, (Npp8u*)ptr<char>(), step, sz);
break;
}
case CV_32SC1:
{
NppiSize sz;
sz.width = cols;
sz.height = rows;
Npp32s nVal = (Npp32s)s[0];
nppiSet_32s_C1R(nVal, (Npp32s*)ptr<char>(), step, sz);
break;
}
case CV_32FC1:
{
NppiSize sz;
sz.width = cols;
sz.height = rows;
Npp32f nVal = (Npp32f)s[0];
nppiSet_32f_C1R(nVal, (Npp32f*)ptr<char>(), step, sz);
break;
}
default:
matrix_operations::set_to_without_mask( *this, depth(), s.val, channels());
}
}
else
matrix_operations::set_to_with_mask( *this, depth(), s.val, mask, channels());

259
tests/gpu/src/npp_image_arithm.cpp
Unescape View File

@ -40,6 +40,8 @@
//M*/
#include <iostream>
#include <cmath>
#include <limits>
#include "gputest.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
@ -59,10 +61,13 @@ protected:
int test8UC1(const Mat& cpu1, const Mat& cpu2);
int test8UC4(const Mat& cpu1, const Mat& cpu2);
int test32SC1(const Mat& cpu1, const Mat& cpu2);
int test32FC1(const Mat& cpu1, const Mat& cpu2);
virtual int test(const Mat& cpu1, const Mat& cpu2) = 0;
int CheckNorm(const Mat& m1, const Mat& m2);
int CheckNorm(const Scalar& s1, const Scalar& s2);
int CheckNorm(double d1, double d2);
};
CV_GpuNppImageArithmTest::CV_GpuNppImageArithmTest(const char* test_name, const char* test_funcs): CvTest(test_name, test_funcs)
@ -91,6 +96,19 @@ int CV_GpuNppImageArithmTest::test8UC4(const Mat& cpu1, const Mat& cpu2)
return test(imgL_C4, imgR_C4);
}
int CV_GpuNppImageArithmTest::test32SC1( const Mat& cpu1, const Mat& cpu2 )
{
cv::Mat imgL_C1;
cv::Mat imgR_C1;
cvtColor(cpu1, imgL_C1, CV_BGR2GRAY);
cvtColor(cpu2, imgR_C1, CV_BGR2GRAY);
imgL_C1.convertTo(imgL_C1, CV_32S);
imgR_C1.convertTo(imgR_C1, CV_32S);
return test(imgL_C1, imgR_C1);
}
int CV_GpuNppImageArithmTest::test32FC1( const Mat& cpu1, const Mat& cpu2 )
{
cv::Mat imgL_C1;
@ -106,9 +124,31 @@ int CV_GpuNppImageArithmTest::test32FC1( const Mat& cpu1, const Mat& cpu2 )
int CV_GpuNppImageArithmTest::CheckNorm(const Mat& m1, const Mat& m2)
{
double ret = norm(m1, m2);
double ret = norm(m1, m2, NORM_INF);
if (ret < std::numeric_limits<double>::epsilon())
{
return CvTS::OK;
}
else
{
ts->printf(CvTS::LOG, "\nNorm: %f\n", ret);
return CvTS::FAIL_GENERIC;
}
}
int CV_GpuNppImageArithmTest::CheckNorm(const Scalar& s1, const Scalar& s2)
{
double ret0 = CheckNorm(s1[0], s2[0]), ret1 = CheckNorm(s1[1], s2[1]), ret2 = CheckNorm(s1[2], s2[2]), ret3 = CheckNorm(s1[3], s2[3]);
if (ret < 1.0)
return (ret0 == CvTS::OK && ret1 == CvTS::OK && ret2 == CvTS::OK && ret3 == CvTS::OK) ? CvTS::OK : CvTS::FAIL_GENERIC;
}
int CV_GpuNppImageArithmTest::CheckNorm(double d1, double d2)
{
double ret = ::fabs(d1 - d2);
if (ret < std::numeric_limits<double>::epsilon())
{
return CvTS::OK;
}
@ -122,8 +162,11 @@ int CV_GpuNppImageArithmTest::CheckNorm(const Mat& m1, const Mat& m2)
void CV_GpuNppImageArithmTest::run( int )
{
//load images
cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png");
cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-R.png");
//cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png");
//cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-R.png");
cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png");
cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-R.png");
if (img_l.empty() || img_r.empty())
{
@ -146,6 +189,13 @@ void CV_GpuNppImageArithmTest::run( int )
return;
}
testResult = test32SC1(img_l, img_r);
if (testResult != CvTS::OK)
{
ts->set_failed_test_info(testResult);
return;
}
testResult = test32FC1(img_l, img_r);
if (testResult != CvTS::OK)
{
@ -173,6 +223,9 @@ CV_GpuNppImageAddTest::CV_GpuNppImageAddTest(): CV_GpuNppImageArithmTest( "GPU-N
int CV_GpuNppImageAddTest::test( const Mat& cpu1, const Mat& cpu2 )
{
if (cpu1.type() != CV_8UC1 && cpu1.type() != CV_8UC4 && cpu1.type() != CV_32FC1)
return CvTS::OK;
cv::Mat cpuRes;
cv::add(cpu1, cpu2, cpuRes);
@ -203,6 +256,9 @@ CV_GpuNppImageSubtractTest::CV_GpuNppImageSubtractTest(): CV_GpuNppImageArithmTe
int CV_GpuNppImageSubtractTest::test( const Mat& cpu1, const Mat& cpu2 )
{
if (cpu1.type() != CV_8UC1 && cpu1.type() != CV_8UC4 && cpu1.type() != CV_32FC1)
return CvTS::OK;
cv::Mat cpuRes;
cv::subtract(cpu1, cpu2, cpuRes);
@ -233,6 +289,9 @@ CV_GpuNppImageMultiplyTest::CV_GpuNppImageMultiplyTest(): CV_GpuNppImageArithmTe
int CV_GpuNppImageMultiplyTest::test( const Mat& cpu1, const Mat& cpu2 )
{
if (cpu1.type() != CV_8UC1 && cpu1.type() != CV_8UC4 && cpu1.type() != CV_32FC1)
return CvTS::OK;
cv::Mat cpuRes;
cv::multiply(cpu1, cpu2, cpuRes);
@ -263,6 +322,9 @@ CV_GpuNppImageDivideTest::CV_GpuNppImageDivideTest(): CV_GpuNppImageArithmTest(
int CV_GpuNppImageDivideTest::test( const Mat& cpu1, const Mat& cpu2 )
{
if (cpu1.type() != CV_8UC1 && cpu1.type() != CV_8UC4 && cpu1.type() != CV_32FC1)
return CvTS::OK;
cv::Mat cpuRes;
cv::divide(cpu1, cpu2, cpuRes);
@ -293,7 +355,7 @@ CV_GpuNppImageTransposeTest::CV_GpuNppImageTransposeTest(): CV_GpuNppImageArithm
int CV_GpuNppImageTransposeTest::test( const Mat& cpu1, const Mat& )
{
if (!((cpu1.depth() == CV_8U) && cpu1.channels() == 1))
if (cpu1.type() != CV_8UC1)
return CvTS::OK;
cv::Mat cpuRes;
@ -325,7 +387,7 @@ CV_GpuNppImageAbsdiffTest::CV_GpuNppImageAbsdiffTest(): CV_GpuNppImageArithmTest
int CV_GpuNppImageAbsdiffTest::test( const Mat& cpu1, const Mat& cpu2 )
{
if (!((cpu1.depth() == CV_8U || cpu1.depth() == CV_32F) && cpu1.channels() == 1))
if (cpu1.type() != CV_8UC1 && cpu1.type() != CV_32FC1)
return CvTS::OK;
cv::Mat cpuRes;
@ -358,7 +420,7 @@ CV_GpuNppImageThresholdTest::CV_GpuNppImageThresholdTest(): CV_GpuNppImageArithm
int CV_GpuNppImageThresholdTest::test( const Mat& cpu1, const Mat& )
{
if (!((cpu1.depth() == CV_32F) && cpu1.channels() == 1))
if (cpu1.type() != CV_32FC1)
return CvTS::OK;
const double thresh = 0.5;
@ -438,7 +500,7 @@ int CV_GpuNppImageMeanStdDevTest::test( const Mat& cpu1, const Mat& )
Scalar gpustddev;
cv::gpu::meanStdDev(gpu1, gpumean, gpustddev);
return (cpumean == gpumean && cpustddev == gpustddev) ? CvTS::OK : CvTS::FAIL_GENERIC;
return (CheckNorm(cpumean, gpumean) == CvTS::OK && CheckNorm(cpustddev, gpustddev) == CvTS::OK) ? CvTS::OK : CvTS::FAIL_GENERIC;
}
CV_GpuNppImageMeanStdDevTest CV_GpuNppImageMeanStdDev_test;
@ -473,7 +535,184 @@ int CV_GpuNppImageNormTest::test( const Mat& cpu1, const Mat& cpu2 )
double gpu_norm_L1 = cv::gpu::norm(gpu1, gpu2, NORM_L1);
double gpu_norm_L2 = cv::gpu::norm(gpu1, gpu2, NORM_L2);
return (cpu_norm_inf == gpu_norm_inf && cpu_norm_L1 == gpu_norm_L1 && cpu_norm_L2 == gpu_norm_L2) ? CvTS::OK : CvTS::FAIL_GENERIC;
return (CheckNorm(cpu_norm_inf, gpu_norm_inf) == CvTS::OK
&& CheckNorm(cpu_norm_L1, gpu_norm_L1) == CvTS::OK
&& CheckNorm(cpu_norm_L2, gpu_norm_L2) == CvTS::OK) ? CvTS::OK : CvTS::FAIL_GENERIC;
}
CV_GpuNppImageNormTest CV_GpuNppImageNorm_test;
////////////////////////////////////////////////////////////////////////////////
// flip
class CV_GpuNppImageFlipTest : public CV_GpuNppImageArithmTest
{
public:
CV_GpuNppImageFlipTest();
protected:
virtual int test(const Mat& cpu1, const Mat& cpu2);
};
CV_GpuNppImageFlipTest::CV_GpuNppImageFlipTest(): CV_GpuNppImageArithmTest( "GPU-NppImageFlip", "flip" )
{
}
int CV_GpuNppImageFlipTest::test( const Mat& cpu1, const Mat& )
{
if (cpu1.type() != CV_8UC1 && cpu1.type() != CV_8UC4)
return CvTS::OK;
Mat cpux, cpuy, cpub;
cv::flip(cpu1, cpux, 0);
cv::flip(cpu1, cpuy, 1);
cv::flip(cpu1, cpub, -1);
GpuMat gpu1(cpu1);
GpuMat gpux, gpuy, gpub;
cv::gpu::flip(gpu1, gpux, 0);
cv::gpu::flip(gpu1, gpuy, 1);
cv::gpu::flip(gpu1, gpub, -1);
return (CheckNorm(cpux, gpux) == CvTS::OK &&
CheckNorm(cpuy, gpuy) == CvTS::OK &&
CheckNorm(cpub, gpub) == CvTS::OK) ? CvTS::OK : CvTS::FAIL_GENERIC;
}
CV_GpuNppImageFlipTest CV_GpuNppImageFlip_test;
////////////////////////////////////////////////////////////////////////////////
// resize
class CV_GpuNppImageResizeTest : public CV_GpuNppImageArithmTest
{
public:
CV_GpuNppImageResizeTest();
protected:
virtual int test(const Mat& cpu1, const Mat& cpu2);
};
CV_GpuNppImageResizeTest::CV_GpuNppImageResizeTest(): CV_GpuNppImageArithmTest( "GPU-NppImageResize", "resize" )
{
}
int CV_GpuNppImageResizeTest::test( const Mat& cpu1, const Mat& )
{
if (cpu1.type() != CV_8UC1 && cpu1.type() != CV_8UC4)
return CvTS::OK;
Mat cpunn, cpulin, cpucub, cpulanc;
cv::resize(cpu1, cpunn, Size(), 0.5, 0.5, INTER_NEAREST);
cv::resize(cpu1, cpulin, Size(), 0.5, 0.5, INTER_LINEAR);
cv::resize(cpu1, cpucub, Size(), 0.5, 0.5, INTER_CUBIC);
cv::resize(cpu1, cpulanc, Size(), 0.5, 0.5, INTER_LANCZOS4);
GpuMat gpu1(cpu1);
GpuMat gpunn, gpulin, gpucub, gpulanc;
cv::gpu::resize(gpu1, gpunn, Size(), 0.5, 0.5, INTER_NEAREST);
cv::gpu::resize(gpu1, gpulin, Size(), 0.5, 0.5, INTER_LINEAR);
cv::gpu::resize(gpu1, gpucub, Size(), 0.5, 0.5, INTER_CUBIC);
cv::gpu::resize(gpu1, gpulanc, Size(), 0.5, 0.5, INTER_LANCZOS4);
int nnres =CheckNorm(cpunn, gpunn);
int linres = CheckNorm(cpulin, gpulin);
int cubres = CheckNorm(cpucub, gpucub);
int lancres = CheckNorm(cpulanc, gpulanc);
return (nnres == CvTS::OK && linres == CvTS::OK && cubres == CvTS::OK && lancres == CvTS::OK) ? CvTS::OK : CvTS::FAIL_GENERIC;
}
CV_GpuNppImageResizeTest CV_GpuNppImageResize_test;
////////////////////////////////////////////////////////////////////////////////
// sum
class CV_GpuNppImageSumTest : public CV_GpuNppImageArithmTest
{
public:
CV_GpuNppImageSumTest();
protected:
virtual int test(const Mat& cpu1, const Mat& cpu2);
};
CV_GpuNppImageSumTest::CV_GpuNppImageSumTest(): CV_GpuNppImageArithmTest( "GPU-NppImageSum", "sum" )
{
}
int CV_GpuNppImageSumTest::test( const Mat& cpu1, const Mat& )
{
if (cpu1.type() != CV_8UC1 && cpu1.type() != CV_8UC4)
return CvTS::OK;
Scalar cpures = cv::sum(cpu1);
GpuMat gpu1(cpu1);
Scalar gpures = cv::gpu::sum(gpu1);
return CheckNorm(cpures, gpures);
}
CV_GpuNppImageSumTest CV_GpuNppImageSum_test;
////////////////////////////////////////////////////////////////////////////////
// minNax
class CV_GpuNppImageMinNaxTest : public CV_GpuNppImageArithmTest
{
public:
CV_GpuNppImageMinNaxTest();
protected:
virtual int test(const Mat& cpu1, const Mat& cpu2);
};
CV_GpuNppImageMinNaxTest::CV_GpuNppImageMinNaxTest(): CV_GpuNppImageArithmTest( "GPU-NppImageMinNax", "minNax" )
{
}
int CV_GpuNppImageMinNaxTest::test( const Mat& cpu1, const Mat& )
{
if (cpu1.type() != CV_8UC1)
return CvTS::OK;
double cpumin, cpumax;
cv::minMaxLoc(cpu1, &cpumin, &cpumax);
GpuMat gpu1(cpu1);
double gpumin, gpumax;
cv::gpu::minMax(gpu1, &gpumin, &gpumax);
return (CheckNorm(cpumin, gpumin) == CvTS::OK && CheckNorm(cpumax, gpumax) == CvTS::OK) ? CvTS::OK : CvTS::FAIL_GENERIC;
}
CV_GpuNppImageMinNaxTest CV_GpuNppImageMinNax_test;
////////////////////////////////////////////////////////////////////////////////
// copyConstBorder
class CV_GpuNppImageCopyConstBorderTest : public CV_GpuNppImageArithmTest
{
public:
CV_GpuNppImageCopyConstBorderTest();
protected:
virtual int test(const Mat& cpu1, const Mat& cpu2);
};
CV_GpuNppImageCopyConstBorderTest::CV_GpuNppImageCopyConstBorderTest(): CV_GpuNppImageArithmTest( "GPU-NppImageCopyConstBorder", "copyConstBorder" )
{
}
int CV_GpuNppImageCopyConstBorderTest::test( const Mat& cpu1, const Mat& )
{
if (cpu1.type() != CV_8UC1 && cpu1.type() != CV_8UC4 && cpu1.type() != CV_32SC1)
return CvTS::OK;
Mat cpudst;
cv::copyMakeBorder(cpu1, cpudst, 5, 5, 5, 5, BORDER_CONSTANT);
GpuMat gpu1(cpu1);
GpuMat gpudst;
cv::gpu::copyConstBorder(gpu1, gpudst, 5, 5, 5, 5);
return CheckNorm(cpudst, gpudst);
}
CV_GpuNppImageNormTest CV_GpuNppImageNorm_test;
CV_GpuNppImageCopyConstBorderTest CV_GpuNppImageCopyConstBorder_test;
Write Preview
Loading…
Cancel
Save