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

replaced GPU -> CUDA

Browse Source
This commit is contained in:
Vladislav Vinogradov
2013-07-24 13:55:18 +04:00
parent 3c34b24f1f
commit fd88654b45
172 changed files with 2434 additions and 2436 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
modules/cuda/include/opencv2/cuda.hpp
View File

@@ -146,12 +146,12 @@ protected:
//////////////////////////// CascadeClassifier ////////////////////////////
// The cascade classifier class for object detection: supports old haar and new lbp xlm formats and nvbin for haar cascades olny.
class CV_EXPORTS CascadeClassifier_GPU
class CV_EXPORTS CascadeClassifier_CUDA
{
public:
CascadeClassifier_GPU();
CascadeClassifier_GPU(const String& filename);
~CascadeClassifier_GPU();
CascadeClassifier_CUDA();
CascadeClassifier_CUDA(const String& filename);
~CascadeClassifier_CUDA();
bool empty() const;
bool load(const String& filename);
@@ -171,7 +171,7 @@ private:
CascadeClassifierImpl* impl;
struct HaarCascade;
struct LbpCascade;
friend class CascadeClassifier_GPU_LBP;
friend class CascadeClassifier_CUDA_LBP;
};
//////////////////////////// Labeling ////////////////////////////

10
modules/cuda/perf/perf_calib3d.cpp
View File

@@ -63,14 +63,14 @@ PERF_TEST_P(Count, Calib3D_ProjectPoints,
const cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
const cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), dst);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{
@@ -118,12 +118,12 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac,
cv::Mat rvec;
cv::Mat tvec;
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
TEST_CYCLE() cv::cuda::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
GPU_SANITY_CHECK(rvec, 1e-3);
GPU_SANITY_CHECK(tvec, 1e-3);
CUDA_SANITY_CHECK(rvec, 1e-3);
CUDA_SANITY_CHECK(tvec, 1e-3);
}
else
{

8
modules/cuda/perf/perf_labeling.cpp
View File

@@ -149,14 +149,14 @@ PERF_TEST_P(Image, DISABLED_Labeling_ConnectivityMask,
const cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty());
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::cuda::GpuMat d_image(image);
cv::cuda::GpuMat mask;
TEST_CYCLE() cv::cuda::connectivityMask(d_image, mask, cv::Scalar::all(0), cv::Scalar::all(2));
GPU_SANITY_CHECK(mask);
CUDA_SANITY_CHECK(mask);
}
else
{
@@ -172,7 +172,7 @@ PERF_TEST_P(Image, DISABLED_Labeling_ConnectedComponents,
const cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(image.empty());
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::cuda::GpuMat d_mask;
cv::cuda::connectivityMask(cv::cuda::GpuMat(image), d_mask, cv::Scalar::all(0), cv::Scalar::all(2));
@@ -181,7 +181,7 @@ PERF_TEST_P(Image, DISABLED_Labeling_ConnectedComponents,
TEST_CYCLE() cv::cuda::labelComponents(d_mask, components);
GPU_SANITY_CHECK(components);
CUDA_SANITY_CHECK(components);
}
else
{

30
modules/cuda/perf/perf_matop.cpp
View File

@@ -50,9 +50,9 @@ using namespace perf;
// SetTo
PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U, CV_32F, CV_64F),
GPU_CHANNELS_1_3_4))
CUDA_CHANNELS_1_3_4))
{
const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1);
@@ -62,13 +62,13 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo,
const cv::Scalar val(1, 2, 3, 4);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::cuda::GpuMat dst(size, type);
TEST_CYCLE() dst.setTo(val);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{
@@ -84,9 +84,9 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo,
// SetToMasked
PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U, CV_32F, CV_64F),
GPU_CHANNELS_1_3_4))
CUDA_CHANNELS_1_3_4))
{
const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1);
@@ -100,14 +100,14 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked,
const cv::Scalar val(1, 2, 3, 4);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::cuda::GpuMat dst(src);
const cv::cuda::GpuMat d_mask(mask);
TEST_CYCLE() dst.setTo(val, d_mask);
GPU_SANITY_CHECK(dst, 1e-10);
CUDA_SANITY_CHECK(dst, 1e-10);
}
else
{
@@ -123,9 +123,9 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked,
// CopyToMasked
PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U, CV_32F, CV_64F),
GPU_CHANNELS_1_3_4))
CUDA_CHANNELS_1_3_4))
{
const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1);
@@ -137,7 +137,7 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked,
cv::Mat mask(size, CV_8UC1);
declare.in(src, mask, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
const cv::cuda::GpuMat d_mask(mask);
@@ -145,7 +145,7 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked,
TEST_CYCLE() d_src.copyTo(dst, d_mask);
GPU_SANITY_CHECK(dst, 1e-10);
CUDA_SANITY_CHECK(dst, 1e-10);
}
else
{
@@ -163,7 +163,7 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked,
DEF_PARAM_TEST(Sz_2Depth, cv::Size, MatDepth, MatDepth);
PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U, CV_32F, CV_64F),
Values(CV_8U, CV_16U, CV_32F, CV_64F)))
{
@@ -177,14 +177,14 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo,
const double a = 0.5;
const double b = 1.0;
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() d_src.convertTo(dst, depth2, a, b);
GPU_SANITY_CHECK(dst, 1e-10);
CUDA_SANITY_CHECK(dst, 1e-10);
}
else
{

10
modules/cuda/perf/perf_objdetect.cpp
View File

@@ -66,7 +66,7 @@ PERF_TEST_P(Image, ObjDetect_HOG,
const cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(img.empty());
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_img(img);
std::vector<cv::Rect> gpu_found_locations;
@@ -103,9 +103,9 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
const cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(img.empty());
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::cuda::CascadeClassifier_GPU d_cascade;
cv::cuda::CascadeClassifier_CUDA d_cascade;
ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
const cv::cuda::GpuMat d_img(img);
@@ -142,9 +142,9 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
const cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(img.empty());
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::cuda::CascadeClassifier_GPU d_cascade;
cv::cuda::CascadeClassifier_CUDA d_cascade;
ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
const cv::cuda::GpuMat d_img(img);

116
modules/cuda/src/cascadeclassifier.cpp
View File

@@ -48,19 +48,19 @@ using namespace cv::cuda;
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
cv::cuda::CascadeClassifier_GPU::CascadeClassifier_GPU() { throw_no_cuda(); }
cv::cuda::CascadeClassifier_GPU::CascadeClassifier_GPU(const String&) { throw_no_cuda(); }
cv::cuda::CascadeClassifier_GPU::~CascadeClassifier_GPU() { throw_no_cuda(); }
bool cv::cuda::CascadeClassifier_GPU::empty() const { throw_no_cuda(); return true; }
bool cv::cuda::CascadeClassifier_GPU::load(const String&) { throw_no_cuda(); return true; }
Size cv::cuda::CascadeClassifier_GPU::getClassifierSize() const { throw_no_cuda(); return Size();}
void cv::cuda::CascadeClassifier_GPU::release() { throw_no_cuda(); }
int cv::cuda::CascadeClassifier_GPU::detectMultiScale( const GpuMat&, GpuMat&, double, int, Size) {throw_no_cuda(); return -1;}
int cv::cuda::CascadeClassifier_GPU::detectMultiScale( const GpuMat&, GpuMat&, Size, Size, double, int) {throw_no_cuda(); return -1;}
cv::cuda::CascadeClassifier_CUDA::CascadeClassifier_CUDA() { throw_no_cuda(); }
cv::cuda::CascadeClassifier_CUDA::CascadeClassifier_CUDA(const String&) { throw_no_cuda(); }
cv::cuda::CascadeClassifier_CUDA::~CascadeClassifier_CUDA() { throw_no_cuda(); }
bool cv::cuda::CascadeClassifier_CUDA::empty() const { throw_no_cuda(); return true; }
bool cv::cuda::CascadeClassifier_CUDA::load(const String&) { throw_no_cuda(); return true; }
Size cv::cuda::CascadeClassifier_CUDA::getClassifierSize() const { throw_no_cuda(); return Size();}
void cv::cuda::CascadeClassifier_CUDA::release() { throw_no_cuda(); }
int cv::cuda::CascadeClassifier_CUDA::detectMultiScale( const GpuMat&, GpuMat&, double, int, Size) {throw_no_cuda(); return -1;}
int cv::cuda::CascadeClassifier_CUDA::detectMultiScale( const GpuMat&, GpuMat&, Size, Size, double, int) {throw_no_cuda(); return -1;}
#else
struct cv::cuda::CascadeClassifier_GPU::CascadeClassifierImpl
struct cv::cuda::CascadeClassifier_CUDA::CascadeClassifierImpl
{
public:
CascadeClassifierImpl(){}
@@ -75,7 +75,7 @@ public:
#ifndef HAVE_OPENCV_CUDALEGACY
struct cv::cuda::CascadeClassifier_GPU::HaarCascade : cv::cuda::CascadeClassifier_GPU::CascadeClassifierImpl
struct cv::cuda::CascadeClassifier_CUDA::HaarCascade : cv::cuda::CascadeClassifier_CUDA::CascadeClassifierImpl
{
public:
HaarCascade()
@@ -104,7 +104,7 @@ public:
#else
struct cv::cuda::CascadeClassifier_GPU::HaarCascade : cv::cuda::CascadeClassifier_GPU::CascadeClassifierImpl
struct cv::cuda::CascadeClassifier_CUDA::HaarCascade : cv::cuda::CascadeClassifier_CUDA::CascadeClassifierImpl
{
public:
HaarCascade() : lastAllocatedFrameSize(-1, -1)
@@ -398,7 +398,7 @@ namespace cv { namespace cuda { namespace device
}
}}}
struct cv::cuda::CascadeClassifier_GPU::LbpCascade : cv::cuda::CascadeClassifier_GPU::CascadeClassifierImpl
struct cv::cuda::CascadeClassifier_CUDA::LbpCascade : cv::cuda::CascadeClassifier_CUDA::CascadeClassifierImpl
{
public:
struct Stage
@@ -528,48 +528,48 @@ private:
bool read(const FileNode &root)
{
const char *GPU_CC_STAGE_TYPE = "stageType";
const char *GPU_CC_FEATURE_TYPE = "featureType";
const char *GPU_CC_BOOST = "BOOST";
const char *GPU_CC_LBP = "LBP";
const char *GPU_CC_MAX_CAT_COUNT = "maxCatCount";
const char *GPU_CC_HEIGHT = "height";
const char *GPU_CC_WIDTH = "width";
const char *GPU_CC_STAGE_PARAMS = "stageParams";
const char *GPU_CC_MAX_DEPTH = "maxDepth";
const char *GPU_CC_FEATURE_PARAMS = "featureParams";
const char *GPU_CC_STAGES = "stages";
const char *GPU_CC_STAGE_THRESHOLD = "stageThreshold";
const float GPU_THRESHOLD_EPS = 1e-5f;
const char *GPU_CC_WEAK_CLASSIFIERS = "weakClassifiers";
const char *GPU_CC_INTERNAL_NODES = "internalNodes";
const char *GPU_CC_LEAF_VALUES = "leafValues";
const char *GPU_CC_FEATURES = "features";
const char *GPU_CC_RECT = "rect";
const char *CUDA_CC_STAGE_TYPE = "stageType";
const char *CUDA_CC_FEATURE_TYPE = "featureType";
const char *CUDA_CC_BOOST = "BOOST";
const char *CUDA_CC_LBP = "LBP";
const char *CUDA_CC_MAX_CAT_COUNT = "maxCatCount";
const char *CUDA_CC_HEIGHT = "height";
const char *CUDA_CC_WIDTH = "width";
const char *CUDA_CC_STAGE_PARAMS = "stageParams";
const char *CUDA_CC_MAX_DEPTH = "maxDepth";
const char *CUDA_CC_FEATURE_PARAMS = "featureParams";
const char *CUDA_CC_STAGES = "stages";
const char *CUDA_CC_STAGE_THRESHOLD = "stageThreshold";
const float CUDA_THRESHOLD_EPS = 1e-5f;
const char *CUDA_CC_WEAK_CLASSIFIERS = "weakClassifiers";
const char *CUDA_CC_INTERNAL_NODES = "internalNodes";
const char *CUDA_CC_LEAF_VALUES = "leafValues";
const char *CUDA_CC_FEATURES = "features";
const char *CUDA_CC_RECT = "rect";
String stageTypeStr = (String)root[GPU_CC_STAGE_TYPE];
CV_Assert(stageTypeStr == GPU_CC_BOOST);
String stageTypeStr = (String)root[CUDA_CC_STAGE_TYPE];
CV_Assert(stageTypeStr == CUDA_CC_BOOST);
String featureTypeStr = (String)root[GPU_CC_FEATURE_TYPE];
CV_Assert(featureTypeStr == GPU_CC_LBP);
String featureTypeStr = (String)root[CUDA_CC_FEATURE_TYPE];
CV_Assert(featureTypeStr == CUDA_CC_LBP);
NxM.width = (int)root[GPU_CC_WIDTH];
NxM.height = (int)root[GPU_CC_HEIGHT];
NxM.width = (int)root[CUDA_CC_WIDTH];
NxM.height = (int)root[CUDA_CC_HEIGHT];
CV_Assert( NxM.height > 0 && NxM.width > 0 );
isStumps = ((int)(root[GPU_CC_STAGE_PARAMS][GPU_CC_MAX_DEPTH]) == 1) ? true : false;
isStumps = ((int)(root[CUDA_CC_STAGE_PARAMS][CUDA_CC_MAX_DEPTH]) == 1) ? true : false;
CV_Assert(isStumps);
FileNode fn = root[GPU_CC_FEATURE_PARAMS];
FileNode fn = root[CUDA_CC_FEATURE_PARAMS];
if (fn.empty())
return false;
ncategories = fn[GPU_CC_MAX_CAT_COUNT];
ncategories = fn[CUDA_CC_MAX_CAT_COUNT];
subsetSize = (ncategories + 31) / 32;
nodeStep = 3 + ( ncategories > 0 ? subsetSize : 1 );
fn = root[GPU_CC_STAGES];
fn = root[CUDA_CC_STAGES];
if (fn.empty())
return false;
@@ -586,9 +586,9 @@ private:
{
FileNode fns = *it;
Stage st;
st.threshold = (float)fns[GPU_CC_STAGE_THRESHOLD] - GPU_THRESHOLD_EPS;
st.threshold = (float)fns[CUDA_CC_STAGE_THRESHOLD] - CUDA_THRESHOLD_EPS;
fns = fns[GPU_CC_WEAK_CLASSIFIERS];
fns = fns[CUDA_CC_WEAK_CLASSIFIERS];
if (fns.empty())
return false;
@@ -605,8 +605,8 @@ private:
{
FileNode fnw = *it1;
FileNode internalNodes = fnw[GPU_CC_INTERNAL_NODES];
FileNode leafValues = fnw[GPU_CC_LEAF_VALUES];
FileNode internalNodes = fnw[CUDA_CC_INTERNAL_NODES];
FileNode leafValues = fnw[CUDA_CC_LEAF_VALUES];
if ( internalNodes.empty() || leafValues.empty() )
return false;
@@ -640,7 +640,7 @@ private:
}
}
fn = root[GPU_CC_FEATURES];
fn = root[CUDA_CC_FEATURES];
if( fn.empty() )
return false;
std::vector<uchar> features;
@@ -648,7 +648,7 @@ private:
FileNodeIterator f_it = fn.begin(), f_end = fn.end();
for (; f_it != f_end; ++f_it)
{
FileNode rect = (*f_it)[GPU_CC_RECT];
FileNode rect = (*f_it)[CUDA_CC_RECT];
FileNodeIterator r_it = rect.begin();
features.push_back(saturate_cast<uchar>((int)*(r_it++)));
features.push_back(saturate_cast<uchar>((int)*(r_it++)));
@@ -694,36 +694,36 @@ private:
static const int integralFactor = 4;
};
cv::cuda::CascadeClassifier_GPU::CascadeClassifier_GPU()
cv::cuda::CascadeClassifier_CUDA::CascadeClassifier_CUDA()
: findLargestObject(false), visualizeInPlace(false), impl(0) {}
cv::cuda::CascadeClassifier_GPU::CascadeClassifier_GPU(const String& filename)
cv::cuda::CascadeClassifier_CUDA::CascadeClassifier_CUDA(const String& filename)
: findLargestObject(false), visualizeInPlace(false), impl(0) { load(filename); }
cv::cuda::CascadeClassifier_GPU::~CascadeClassifier_GPU() { release(); }
cv::cuda::CascadeClassifier_CUDA::~CascadeClassifier_CUDA() { release(); }
void cv::cuda::CascadeClassifier_GPU::release() { if (impl) { delete impl; impl = 0; } }
void cv::cuda::CascadeClassifier_CUDA::release() { if (impl) { delete impl; impl = 0; } }
bool cv::cuda::CascadeClassifier_GPU::empty() const { return impl == 0; }
bool cv::cuda::CascadeClassifier_CUDA::empty() const { return impl == 0; }
Size cv::cuda::CascadeClassifier_GPU::getClassifierSize() const
Size cv::cuda::CascadeClassifier_CUDA::getClassifierSize() const
{
return this->empty() ? Size() : impl->getClassifierCvSize();
}
int cv::cuda::CascadeClassifier_GPU::detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor, int minNeighbors, Size minSize)
int cv::cuda::CascadeClassifier_CUDA::detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor, int minNeighbors, Size minSize)
{
CV_Assert( !this->empty());
return impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, minSize, cv::Size());
}
int cv::cuda::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize, double scaleFactor, int minNeighbors)
int cv::cuda::CascadeClassifier_CUDA::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize, double scaleFactor, int minNeighbors)
{
CV_Assert( !this->empty());
return impl->process(image, objectsBuf, (float)scaleFactor, minNeighbors, findLargestObject, visualizeInPlace, minSize, maxObjectSize);
}
bool cv::cuda::CascadeClassifier_GPU::load(const String& filename)
bool cv::cuda::CascadeClassifier_CUDA::load(const String& filename)
{
release();
@@ -744,9 +744,9 @@ bool cv::cuda::CascadeClassifier_GPU::load(const String& filename)
return impl->read(filename);
}
const char *GPU_CC_LBP = "LBP";
const char *CUDA_CC_LBP = "LBP";
String featureTypeStr = (String)fs.getFirstTopLevelNode()["featureType"];
if (featureTypeStr == GPU_CC_LBP)
if (featureTypeStr == CUDA_CC_LBP)
impl = new LbpCascade();
else
impl = new HaarCascade();

4
modules/cuda/src/cuda/lbp.hpp
View File

@@ -40,8 +40,8 @@
//
//M*/
#ifndef __OPENCV_GPU_DEVICE_LBP_HPP_
#define __OPENCV_GPU_DEVICE_LBP_HPP_
#ifndef __OPENCV_CUDA_DEVICE_LBP_HPP_
#define __OPENCV_CUDA_DEVICE_LBP_HPP_
#include "opencv2/core/cuda/common.hpp"
#include "opencv2/core/cuda/emulation.hpp"

12
modules/cuda/test/test_calib3d.cpp
View File

@@ -61,7 +61,7 @@ struct TransformPoints : testing::TestWithParam<cv::cuda::DeviceInfo>
}
};
GPU_TEST_P(TransformPoints, Accuracy)
CUDA_TEST_P(TransformPoints, Accuracy)
{
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@@ -92,7 +92,7 @@ GPU_TEST_P(TransformPoints, Accuracy)
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, TransformPoints, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_Calib3D, TransformPoints, ALL_DEVICES);
///////////////////////////////////////////////////////////////////////////////////////////////////////
// ProjectPoints
@@ -109,7 +109,7 @@ struct ProjectPoints : testing::TestWithParam<cv::cuda::DeviceInfo>
}
};
GPU_TEST_P(ProjectPoints, Accuracy)
CUDA_TEST_P(ProjectPoints, Accuracy)
{
cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@@ -142,7 +142,7 @@ GPU_TEST_P(ProjectPoints, Accuracy)
}
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ProjectPoints, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_Calib3D, ProjectPoints, ALL_DEVICES);
///////////////////////////////////////////////////////////////////////////////////////////////////////
// SolvePnPRansac
@@ -159,7 +159,7 @@ struct SolvePnPRansac : testing::TestWithParam<cv::cuda::DeviceInfo>
}
};
GPU_TEST_P(SolvePnPRansac, Accuracy)
CUDA_TEST_P(SolvePnPRansac, Accuracy)
{
cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
@@ -185,6 +185,6 @@ GPU_TEST_P(SolvePnPRansac, Accuracy)
ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
}
INSTANTIATE_TEST_CASE_P(GPU_Calib3D, SolvePnPRansac, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_Calib3D, SolvePnPRansac, ALL_DEVICES);
#endif // HAVE_CUDA

4
modules/cuda/test/test_global_motion.cpp
View File

@@ -52,7 +52,7 @@ struct CompactPoints : testing::TestWithParam<cuda::DeviceInfo>
virtual void SetUp() { cuda::setDevice(GetParam().deviceID()); }
};
GPU_TEST_P(CompactPoints, CanCompactizeSmallInput)
CUDA_TEST_P(CompactPoints, CanCompactizeSmallInput)
{
Mat src0(1, 3, CV_32FC2);
src0.at<Point2f>(0,0) = Point2f(0,0);
@@ -85,6 +85,6 @@ GPU_TEST_P(CompactPoints, CanCompactizeSmallInput)
ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
}
INSTANTIATE_TEST_CASE_P(GPU_GlobalMotion, CompactPoints, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_GlobalMotion, CompactPoints, ALL_DEVICES);
#endif // HAVE_CUDA

26
modules/cuda/test/test_gpumat.cpp
View File

@@ -67,7 +67,7 @@ PARAM_TEST_CASE(SetTo, cv::cuda::DeviceInfo, cv::Size, MatType, UseRoi)
}
};
GPU_TEST_P(SetTo, Zero)
CUDA_TEST_P(SetTo, Zero)
{
cv::Scalar zero = cv::Scalar::all(0);
@@ -77,7 +77,7 @@ GPU_TEST_P(SetTo, Zero)
EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
}
GPU_TEST_P(SetTo, SameVal)
CUDA_TEST_P(SetTo, SameVal)
{
cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
@@ -102,7 +102,7 @@ GPU_TEST_P(SetTo, SameVal)
}
}
GPU_TEST_P(SetTo, DifferentVal)
CUDA_TEST_P(SetTo, DifferentVal)
{
cv::Scalar val = randomScalar(0.0, 255.0);
@@ -127,7 +127,7 @@ GPU_TEST_P(SetTo, DifferentVal)
}
}
GPU_TEST_P(SetTo, Masked)
CUDA_TEST_P(SetTo, Masked)
{
cv::Scalar val = randomScalar(0.0, 255.0);
cv::Mat mat_gold = randomMat(size, type);
@@ -156,7 +156,7 @@ GPU_TEST_P(SetTo, Masked)
}
}
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, SetTo, testing::Combine(
INSTANTIATE_TEST_CASE_P(CUDA_GpuMat, SetTo, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
ALL_TYPES,
@@ -184,7 +184,7 @@ PARAM_TEST_CASE(CopyTo, cv::cuda::DeviceInfo, cv::Size, MatType, UseRoi)
}
};
GPU_TEST_P(CopyTo, WithOutMask)
CUDA_TEST_P(CopyTo, WithOutMask)
{
cv::Mat src = randomMat(size, type);
@@ -195,7 +195,7 @@ GPU_TEST_P(CopyTo, WithOutMask)
EXPECT_MAT_NEAR(src, dst, 0.0);
}
GPU_TEST_P(CopyTo, Masked)
CUDA_TEST_P(CopyTo, Masked)
{
cv::Mat src = randomMat(size, type);
cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
@@ -226,7 +226,7 @@ GPU_TEST_P(CopyTo, Masked)
}
}
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, CopyTo, testing::Combine(
INSTANTIATE_TEST_CASE_P(CUDA_GpuMat, CopyTo, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
ALL_TYPES,
@@ -255,7 +255,7 @@ PARAM_TEST_CASE(ConvertTo, cv::cuda::DeviceInfo, cv::Size, MatDepth, MatDepth, U
}
};
GPU_TEST_P(ConvertTo, WithOutScaling)
CUDA_TEST_P(ConvertTo, WithOutScaling)
{
cv::Mat src = randomMat(size, depth1);
@@ -285,7 +285,7 @@ GPU_TEST_P(ConvertTo, WithOutScaling)
}
}
GPU_TEST_P(ConvertTo, WithScaling)
CUDA_TEST_P(ConvertTo, WithScaling)
{
cv::Mat src = randomMat(size, depth1);
double a = randomDouble(0.0, 1.0);
@@ -317,7 +317,7 @@ GPU_TEST_P(ConvertTo, WithScaling)
}
}
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, ConvertTo, testing::Combine(
INSTANTIATE_TEST_CASE_P(CUDA_GpuMat, ConvertTo, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
ALL_DEPTH,
@@ -336,7 +336,7 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::cuda::DeviceInfo>
}
};
GPU_TEST_P(EnsureSizeIsEnough, BufferReuse)
CUDA_TEST_P(EnsureSizeIsEnough, BufferReuse)
{
cv::cuda::GpuMat buffer(100, 100, CV_8U);
cv::cuda::GpuMat old = buffer;
@@ -356,6 +356,6 @@ GPU_TEST_P(EnsureSizeIsEnough, BufferReuse)
EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
}
INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
#endif // HAVE_CUDA

4
modules/cuda/test/test_labeling.cpp
View File

@@ -167,7 +167,7 @@ struct Labeling : testing::TestWithParam<cv::cuda::DeviceInfo>
}
};
GPU_TEST_P(Labeling, DISABLED_ConnectedComponents)
CUDA_TEST_P(Labeling, DISABLED_ConnectedComponents)
{
cv::Mat image;
cvtColor(loat_image(), image, cv::COLOR_BGR2GRAY);
@@ -192,6 +192,6 @@ GPU_TEST_P(Labeling, DISABLED_ConnectedComponents)
host.checkCorrectness(cv::Mat(components));
}
INSTANTIATE_TEST_CASE_P(GPU_ConnectedComponents, Labeling, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_ConnectedComponents, Labeling, ALL_DEVICES);
#endif // HAVE_CUDA

2
modules/cuda/test/test_main.cpp
View File

@@ -42,4 +42,4 @@
#include "test_precomp.hpp"
CV_GPU_TEST_MAIN("gpu")
CV_CUDA_TEST_MAIN("gpu")

20
modules/cuda/test/test_objdetect.cpp
View File

@@ -177,7 +177,7 @@ struct HOG : testing::TestWithParam<cv::cuda::DeviceInfo>, cv::cuda::HOGDescript
};
// desabled while resize does not fixed
GPU_TEST_P(HOG, Detect)
CUDA_TEST_P(HOG, Detect)
{
cv::Mat img_rgb = readImage("hog/road.png");
ASSERT_FALSE(img_rgb.empty());
@@ -202,7 +202,7 @@ GPU_TEST_P(HOG, Detect)
f.close();
}
GPU_TEST_P(HOG, GetDescriptors)
CUDA_TEST_P(HOG, GetDescriptors)
{
// Load image (e.g. train data, composed from windows)
cv::Mat img_rgb = readImage("hog/train_data.png");
@@ -286,7 +286,7 @@ GPU_TEST_P(HOG, GetDescriptors)
compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_ObjDetect, HOG, ALL_DEVICES);
//============== caltech hog tests =====================//
@@ -305,7 +305,7 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::cuda::Devic
}
};
GPU_TEST_P(CalTech, HOG)
CUDA_TEST_P(CalTech, HOG)
{
cv::cuda::GpuMat d_img(img);
cv::Mat markedImage(img.clone());
@@ -352,14 +352,14 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::cuda::DeviceInfo, int)
}
};
GPU_TEST_P(LBP_Read_classifier, Accuracy)
CUDA_TEST_P(LBP_Read_classifier, Accuracy)
{
cv::cuda::CascadeClassifier_GPU classifier;
cv::cuda::CascadeClassifier_CUDA classifier;
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
ASSERT_TRUE(classifier.load(classifierXmlPath));
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_Read_classifier,
INSTANTIATE_TEST_CASE_P(CUDA_ObjDetect, LBP_Read_classifier,
testing::Combine(ALL_DEVICES, testing::Values<int>(0)));
@@ -374,7 +374,7 @@ PARAM_TEST_CASE(LBP_classify, cv::cuda::DeviceInfo, int)
}
};
GPU_TEST_P(LBP_classify, Accuracy)
CUDA_TEST_P(LBP_classify, Accuracy)
{
std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
@@ -396,7 +396,7 @@ GPU_TEST_P(LBP_classify, Accuracy)
for (; it != rects.end(); ++it)
cv::rectangle(markedImage, *it, cv::Scalar(255, 0, 0));
cv::cuda::CascadeClassifier_GPU gpuClassifier;
cv::cuda::CascadeClassifier_CUDA gpuClassifier;
ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
cv::cuda::GpuMat gpu_rects;
@@ -421,7 +421,7 @@ GPU_TEST_P(LBP_classify, Accuracy)
(void)count;
}
INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,
INSTANTIATE_TEST_CASE_P(CUDA_ObjDetect, LBP_classify,
testing::Combine(ALL_DEVICES, testing::Values<int>(0)));
#endif // HAVE_CUDA

54
modules/cuda/test/test_opengl.cpp
View File

@@ -71,7 +71,7 @@ PARAM_TEST_CASE(Buffer, cv::Size, MatType)
}
};
GPU_TEST_P(Buffer, Constructor1)
CUDA_TEST_P(Buffer, Constructor1)
{
cv::ogl::Buffer buf(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
@@ -80,7 +80,7 @@ GPU_TEST_P(Buffer, Constructor1)
EXPECT_EQ(type, buf.type());
}
GPU_TEST_P(Buffer, Constructor2)
CUDA_TEST_P(Buffer, Constructor2)
{
cv::ogl::Buffer buf(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
@@ -89,7 +89,7 @@ GPU_TEST_P(Buffer, Constructor2)
EXPECT_EQ(type, buf.type());
}
GPU_TEST_P(Buffer, ConstructorFromMat)
CUDA_TEST_P(Buffer, ConstructorFromMat)
{
cv::Mat gold = randomMat(size, type);
@@ -101,7 +101,7 @@ GPU_TEST_P(Buffer, ConstructorFromMat)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
GPU_TEST_P(Buffer, ConstructorFromGpuMat)
CUDA_TEST_P(Buffer, ConstructorFromGpuMat)
{
cv::Mat gold = randomMat(size, type);
cv::cuda::GpuMat d_gold(gold);
@@ -114,7 +114,7 @@ GPU_TEST_P(Buffer, ConstructorFromGpuMat)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
GPU_TEST_P(Buffer, ConstructorFromBuffer)
CUDA_TEST_P(Buffer, ConstructorFromBuffer)
{
cv::ogl::Buffer buf_gold(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
@@ -126,7 +126,7 @@ GPU_TEST_P(Buffer, ConstructorFromBuffer)
EXPECT_EQ(buf_gold.type(), buf.type());
}
GPU_TEST_P(Buffer, Create)
CUDA_TEST_P(Buffer, Create)
{
cv::ogl::Buffer buf;
buf.create(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true);
@@ -136,7 +136,7 @@ GPU_TEST_P(Buffer, Create)
EXPECT_EQ(type, buf.type());
}
GPU_TEST_P(Buffer, CopyFromMat)
CUDA_TEST_P(Buffer, CopyFromMat)
{
cv::Mat gold = randomMat(size, type);
@@ -149,7 +149,7 @@ GPU_TEST_P(Buffer, CopyFromMat)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
GPU_TEST_P(Buffer, CopyFromGpuMat)
CUDA_TEST_P(Buffer, CopyFromGpuMat)
{
cv::Mat gold = randomMat(size, type);
cv::cuda::GpuMat d_gold(gold);
@@ -163,7 +163,7 @@ GPU_TEST_P(Buffer, CopyFromGpuMat)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
GPU_TEST_P(Buffer, CopyFromBuffer)
CUDA_TEST_P(Buffer, CopyFromBuffer)
{
cv::Mat gold = randomMat(size, type);
cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::ARRAY_BUFFER, true);
@@ -179,7 +179,7 @@ GPU_TEST_P(Buffer, CopyFromBuffer)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
GPU_TEST_P(Buffer, CopyToGpuMat)
CUDA_TEST_P(Buffer, CopyToGpuMat)
{
cv::Mat gold = randomMat(size, type);
@@ -191,7 +191,7 @@ GPU_TEST_P(Buffer, CopyToGpuMat)
EXPECT_MAT_NEAR(gold, dst, 0);
}
GPU_TEST_P(Buffer, CopyToBuffer)
CUDA_TEST_P(Buffer, CopyToBuffer)
{
cv::Mat gold = randomMat(size, type);
@@ -209,7 +209,7 @@ GPU_TEST_P(Buffer, CopyToBuffer)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
GPU_TEST_P(Buffer, Clone)
CUDA_TEST_P(Buffer, Clone)
{
cv::Mat gold = randomMat(size, type);
@@ -225,7 +225,7 @@ GPU_TEST_P(Buffer, Clone)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
GPU_TEST_P(Buffer, MapHostRead)
CUDA_TEST_P(Buffer, MapHostRead)
{
cv::Mat gold = randomMat(size, type);
@@ -238,7 +238,7 @@ GPU_TEST_P(Buffer, MapHostRead)
buf.unmapHost();
}
GPU_TEST_P(Buffer, MapHostWrite)
CUDA_TEST_P(Buffer, MapHostWrite)
{
cv::Mat gold = randomMat(size, type);
@@ -255,7 +255,7 @@ GPU_TEST_P(Buffer, MapHostWrite)
EXPECT_MAT_NEAR(gold, bufData, 0);
}
GPU_TEST_P(Buffer, MapDevice)
CUDA_TEST_P(Buffer, MapDevice)
{
cv::Mat gold = randomMat(size, type);
@@ -302,7 +302,7 @@ PARAM_TEST_CASE(Texture2D, cv::Size, MatType)
}
};
GPU_TEST_P(Texture2D, Constructor1)
CUDA_TEST_P(Texture2D, Constructor1)
{
cv::ogl::Texture2D tex(size.height, size.width, format, true);
@@ -311,7 +311,7 @@ GPU_TEST_P(Texture2D, Constructor1)
EXPECT_EQ(format, tex.format());
}
GPU_TEST_P(Texture2D, Constructor2)
CUDA_TEST_P(Texture2D, Constructor2)
{
cv::ogl::Texture2D tex(size, format, true);
@@ -320,7 +320,7 @@ GPU_TEST_P(Texture2D, Constructor2)
EXPECT_EQ(format, tex.format());
}
GPU_TEST_P(Texture2D, ConstructorFromMat)
CUDA_TEST_P(Texture2D, ConstructorFromMat)
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
@@ -332,7 +332,7 @@ GPU_TEST_P(Texture2D, ConstructorFromMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
GPU_TEST_P(Texture2D, ConstructorFromGpuMat)
CUDA_TEST_P(Texture2D, ConstructorFromGpuMat)
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::cuda::GpuMat d_gold(gold);
@@ -345,7 +345,7 @@ GPU_TEST_P(Texture2D, ConstructorFromGpuMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
GPU_TEST_P(Texture2D, ConstructorFromBuffer)
CUDA_TEST_P(Texture2D, ConstructorFromBuffer)
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true);
@@ -358,7 +358,7 @@ GPU_TEST_P(Texture2D, ConstructorFromBuffer)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
GPU_TEST_P(Texture2D, ConstructorFromTexture2D)
CUDA_TEST_P(Texture2D, ConstructorFromTexture2D)
{
cv::ogl::Texture2D tex_gold(size, format, true);
cv::ogl::Texture2D tex(tex_gold);
@@ -369,7 +369,7 @@ GPU_TEST_P(Texture2D, ConstructorFromTexture2D)
EXPECT_EQ(tex_gold.format(), tex.format());
}
GPU_TEST_P(Texture2D, Create)
CUDA_TEST_P(Texture2D, Create)
{
cv::ogl::Texture2D tex;
tex.create(size.height, size.width, format, true);
@@ -379,7 +379,7 @@ GPU_TEST_P(Texture2D, Create)
EXPECT_EQ(format, tex.format());
}
GPU_TEST_P(Texture2D, CopyFromMat)
CUDA_TEST_P(Texture2D, CopyFromMat)
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
@@ -392,7 +392,7 @@ GPU_TEST_P(Texture2D, CopyFromMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
GPU_TEST_P(Texture2D, CopyFromGpuMat)
CUDA_TEST_P(Texture2D, CopyFromGpuMat)
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::cuda::GpuMat d_gold(gold);
@@ -406,7 +406,7 @@ GPU_TEST_P(Texture2D, CopyFromGpuMat)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
GPU_TEST_P(Texture2D, CopyFromBuffer)
CUDA_TEST_P(Texture2D, CopyFromBuffer)
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true);
@@ -420,7 +420,7 @@ GPU_TEST_P(Texture2D, CopyFromBuffer)
EXPECT_MAT_NEAR(gold, texData, 1e-2);
}
GPU_TEST_P(Texture2D, CopyToGpuMat)
CUDA_TEST_P(Texture2D, CopyToGpuMat)
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
@@ -432,7 +432,7 @@ GPU_TEST_P(Texture2D, CopyToGpuMat)
EXPECT_MAT_NEAR(gold, dst, 1e-2);
}
GPU_TEST_P(Texture2D, CopyToBuffer)
CUDA_TEST_P(Texture2D, CopyToBuffer)
{
cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);

6
modules/cuda/test/test_stream.cpp
View File

@@ -84,7 +84,7 @@ void checkMemSet(int status, void* userData)
ASSERT_MAT_NEAR(dst_gold, dst, 0);
}
GPU_TEST_P(Async, MemSet)
CUDA_TEST_P(Async, MemSet)
{
cv::cuda::Stream stream;
@@ -114,7 +114,7 @@ void checkConvert(int status, void* userData)
ASSERT_MAT_NEAR(dst_gold, dst, 0);
}
GPU_TEST_P(Async, Convert)
CUDA_TEST_P(Async, Convert)
{
cv::cuda::Stream stream;
@@ -128,7 +128,7 @@ GPU_TEST_P(Async, Convert)
stream.waitForCompletion();
}
INSTANTIATE_TEST_CASE_P(GPU_Stream, Async, ALL_DEVICES);
INSTANTIATE_TEST_CASE_P(CUDA_Stream, Async, ALL_DEVICES);
#endif // CUDART_VERSION >= 5000