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

8
modules/cudaimgproc/perf/perf_bilateral_filter.cpp
View File

@@ -52,9 +52,9 @@ using namespace perf;
DEF_PARAM_TEST(Sz_Depth_Cn_KernelSz, cv::Size, MatDepth, MatCn, int);
PERF_TEST_P(Sz_Depth_Cn_KernelSz, BilateralFilter,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_32F),
GPU_CHANNELS_1_3,
CUDA_CHANNELS_1_3,
Values(3, 5, 9)))
{
declare.time(60.0);
@@ -73,14 +73,14 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, BilateralFilter,
cv::Mat src(size, type);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::bilateralFilter(d_src, dst, kernel_size, sigma_color, sigma_spatial, borderMode);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{

8
modules/cudaimgproc/perf/perf_blend.cpp
View File

@@ -50,9 +50,9 @@ using namespace perf;
// BlendLinear
PERF_TEST_P(Sz_Depth_Cn, BlendLinear,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_32F),
GPU_CHANNELS_1_3_4))
CUDA_CHANNELS_1_3_4))
{
const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1);
@@ -67,7 +67,7 @@ PERF_TEST_P(Sz_Depth_Cn, BlendLinear,
const cv::Mat weights1(size, CV_32FC1, cv::Scalar::all(0.5));
const cv::Mat weights2(size, CV_32FC1, cv::Scalar::all(0.5));
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_img1(img1);
const cv::cuda::GpuMat d_img2(img2);
@@ -77,7 +77,7 @@ PERF_TEST_P(Sz_Depth_Cn, BlendLinear,
TEST_CYCLE() cv::cuda::blendLinear(d_img1, d_img2, d_weights1, d_weights2, dst);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{

4
modules/cudaimgproc/perf/perf_canny.cpp
View File

@@ -66,7 +66,7 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, Canny,
const double low_thresh = 50.0;
const double high_thresh = 100.0;
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_image(image);
cv::cuda::GpuMat dst;
@@ -75,7 +75,7 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, Canny,
TEST_CYCLE() canny->detect(d_image, dst);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{

30
modules/cudaimgproc/perf/perf_color.cpp
View File

@@ -52,7 +52,7 @@ using namespace perf;
DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CvtColorInfo);
PERF_TEST_P(Sz_Depth_Code, CvtColor,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_32F),
Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),
CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),
@@ -83,14 +83,14 @@ PERF_TEST_P(Sz_Depth_Code, CvtColor,
cv::Mat src(size, CV_MAKETYPE(depth, info.scn));
cv::randu(src, 0, depth == CV_8U ? 255.0 : 1.0);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::cvtColor(d_src, dst, info.code, info.dcn);
GPU_SANITY_CHECK(dst, 1e-4);
CUDA_SANITY_CHECK(dst, 1e-4);
}
else
{
@@ -103,7 +103,7 @@ PERF_TEST_P(Sz_Depth_Code, CvtColor,
}
PERF_TEST_P(Sz_Depth_Code, CvtColorBayer,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U),
Values(CvtColorInfo(1, 3, cv::COLOR_BayerBG2BGR),
CvtColorInfo(1, 3, cv::COLOR_BayerGB2BGR),
@@ -122,14 +122,14 @@ PERF_TEST_P(Sz_Depth_Code, CvtColorBayer,
cv::Mat src(size, CV_MAKETYPE(depth, info.scn));
declare.in(src, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::cvtColor(d_src, dst, info.code, info.dcn);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{
@@ -153,7 +153,7 @@ CV_ENUM(DemosaicingCode,
DEF_PARAM_TEST(Sz_Code, cv::Size, DemosaicingCode);
PERF_TEST_P(Sz_Code, Demosaicing,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
DemosaicingCode::all()))
{
const cv::Size size = GET_PARAM(0);
@@ -162,14 +162,14 @@ PERF_TEST_P(Sz_Code, Demosaicing,
cv::Mat src(size, CV_8UC1);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::demosaicing(d_src, dst, code);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{
@@ -192,7 +192,7 @@ PERF_TEST_P(Sz_Code, Demosaicing,
// SwapChannels
PERF_TEST_P(Sz, SwapChannels,
GPU_TYPICAL_MAT_SIZES)
CUDA_TYPICAL_MAT_SIZES)
{
const cv::Size size = GetParam();
@@ -201,13 +201,13 @@ PERF_TEST_P(Sz, SwapChannels,
const int dstOrder[] = {2, 1, 0, 3};
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::cuda::GpuMat dst(src);
TEST_CYCLE() cv::cuda::swapChannels(dst, dstOrder);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{
@@ -223,7 +223,7 @@ CV_ENUM(AlphaOp, cv::cuda::ALPHA_OVER, cv::cuda::ALPHA_IN, cv::cuda::ALPHA_OUT,
DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, AlphaOp);
PERF_TEST_P(Sz_Type_Op, AlphaComp,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4),
AlphaOp::all()))
{
@@ -235,7 +235,7 @@ PERF_TEST_P(Sz_Type_Op, AlphaComp,
cv::Mat img2(size, type);
declare.in(img1, img2, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_img1(img1);
const cv::cuda::GpuMat d_img2(img2);
@@ -243,7 +243,7 @@ PERF_TEST_P(Sz_Type_Op, AlphaComp,
TEST_CYCLE() cv::cuda::alphaComp(d_img1, d_img2, dst, alpha_op);
GPU_SANITY_CHECK(dst, 1e-3, ERROR_RELATIVE);
CUDA_SANITY_CHECK(dst, 1e-3, ERROR_RELATIVE);
}
else
{

8
modules/cudaimgproc/perf/perf_corners.cpp
View File

@@ -71,7 +71,7 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, CornerHarris,
const double k = 0.5;
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_img(img);
cv::cuda::GpuMat dst;
@@ -80,7 +80,7 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, CornerHarris,
TEST_CYCLE() harris->compute(d_img, dst);
GPU_SANITY_CHECK(dst, 1e-4);
CUDA_SANITY_CHECK(dst, 1e-4);
}
else
{
@@ -113,7 +113,7 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, CornerMinEigenVal,
img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_img(img);
cv::cuda::GpuMat dst;
@@ -122,7 +122,7 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, CornerMinEigenVal,
TEST_CYCLE() minEigenVal->compute(d_img, dst);
GPU_SANITY_CHECK(dst, 1e-4);
CUDA_SANITY_CHECK(dst, 1e-4);
}
else
{

4
modules/cudaimgproc/perf/perf_gftt.cpp
View File

@@ -64,7 +64,7 @@ PERF_TEST_P(Image_MinDistance, GoodFeaturesToTrack,
const int maxCorners = 8000;
const double qualityLevel = 0.01;
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::Ptr<cv::cuda::CornersDetector> d_detector = cv::cuda::createGoodFeaturesToTrackDetector(image.type(), maxCorners, qualityLevel, minDistance);
@@ -73,7 +73,7 @@ PERF_TEST_P(Image_MinDistance, GoodFeaturesToTrack,
TEST_CYCLE() d_detector->detect(d_image, pts);
GPU_SANITY_CHECK(pts);
CUDA_SANITY_CHECK(pts);
}
else
{

28
modules/cudaimgproc/perf/perf_histogram.cpp
View File

@@ -50,7 +50,7 @@ using namespace perf;
// HistEvenC1
PERF_TEST_P(Sz_Depth, HistEvenC1,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U, CV_16S)))
{
const cv::Size size = GET_PARAM(0);
@@ -59,7 +59,7 @@ PERF_TEST_P(Sz_Depth, HistEvenC1,
cv::Mat src(size, depth);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
@@ -67,7 +67,7 @@ PERF_TEST_P(Sz_Depth, HistEvenC1,
TEST_CYCLE() cv::cuda::histEven(d_src, dst, d_buf, 30, 0, 180);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{
@@ -89,7 +89,7 @@ PERF_TEST_P(Sz_Depth, HistEvenC1,
// HistEvenC4
PERF_TEST_P(Sz_Depth, HistEvenC4,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U, CV_16S)))
{
const cv::Size size = GET_PARAM(0);
@@ -102,7 +102,7 @@ PERF_TEST_P(Sz_Depth, HistEvenC4,
int lowerLevel[] = {0, 0, 0, 0};
int upperLevel[] = {180, 180, 180, 180};
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat d_hist[4];
@@ -130,21 +130,21 @@ PERF_TEST_P(Sz_Depth, HistEvenC4,
// CalcHist
PERF_TEST_P(Sz, CalcHist,
GPU_TYPICAL_MAT_SIZES)
CUDA_TYPICAL_MAT_SIZES)
{
const cv::Size size = GetParam();
cv::Mat src(size, CV_8UC1);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::calcHist(d_src, dst);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{
@@ -156,14 +156,14 @@ PERF_TEST_P(Sz, CalcHist,
// EqualizeHist
PERF_TEST_P(Sz, EqualizeHist,
GPU_TYPICAL_MAT_SIZES)
CUDA_TYPICAL_MAT_SIZES)
{
const cv::Size size = GetParam();
cv::Mat src(size, CV_8UC1);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
@@ -171,7 +171,7 @@ PERF_TEST_P(Sz, EqualizeHist,
TEST_CYCLE() cv::cuda::equalizeHist(d_src, dst, d_buf);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{
@@ -189,7 +189,7 @@ PERF_TEST_P(Sz, EqualizeHist,
DEF_PARAM_TEST(Sz_ClipLimit, cv::Size, double);
PERF_TEST_P(Sz_ClipLimit, CLAHE,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(0.0, 40.0)))
{
const cv::Size size = GET_PARAM(0);
@@ -198,7 +198,7 @@ PERF_TEST_P(Sz_ClipLimit, CLAHE,
cv::Mat src(size, CV_8UC1);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::Ptr<cv::cuda::CLAHE> clahe = cv::cuda::createCLAHE(clipLimit);
cv::cuda::GpuMat d_src(src);
@@ -206,7 +206,7 @@ PERF_TEST_P(Sz_ClipLimit, CLAHE,
TEST_CYCLE() clahe->apply(d_src, dst);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{

22
modules/cudaimgproc/perf/perf_hough.cpp
View File

@@ -81,7 +81,7 @@ namespace
}
PERF_TEST_P(Sz, HoughLines,
GPU_TYPICAL_MAT_SIZES)
CUDA_TYPICAL_MAT_SIZES)
{
declare.time(30.0);
@@ -99,7 +99,7 @@ PERF_TEST_P(Sz, HoughLines,
cv::line(src, cv::Point(200, 0), cv::Point(200, src.rows), cv::Scalar::all(255), 1);
cv::line(src, cv::Point(400, 0), cv::Point(400, src.rows), cv::Scalar::all(255), 1);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat d_lines;
@@ -148,7 +148,7 @@ PERF_TEST_P(Image, HoughLinesP,
cv::Mat mask;
cv::Canny(image, mask, 50, 100);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_mask(mask);
cv::cuda::GpuMat d_lines;
@@ -179,7 +179,7 @@ PERF_TEST_P(Image, HoughLinesP,
DEF_PARAM_TEST(Sz_Dp_MinDist, cv::Size, float, float);
PERF_TEST_P(Sz_Dp_MinDist, HoughCircles,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(1.0f, 2.0f, 4.0f),
Values(1.0f)))
{
@@ -199,7 +199,7 @@ PERF_TEST_P(Sz_Dp_MinDist, HoughCircles,
cv::circle(src, cv::Point(200, 200), 25, cv::Scalar::all(255), -1);
cv::circle(src, cv::Point(200, 100), 25, cv::Scalar::all(255), -1);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat d_circles;
@@ -227,7 +227,7 @@ PERF_TEST_P(Sz_Dp_MinDist, HoughCircles,
//////////////////////////////////////////////////////////////////////
// GeneralizedHough
PERF_TEST_P(Sz, GeneralizedHoughBallard, GPU_TYPICAL_MAT_SIZES)
PERF_TEST_P(Sz, GeneralizedHoughBallard, CUDA_TYPICAL_MAT_SIZES)
{
declare.time(10);
@@ -246,7 +246,7 @@ PERF_TEST_P(Sz, GeneralizedHoughBallard, GPU_TYPICAL_MAT_SIZES)
cv::Sobel(image, dx, CV_32F, 1, 0);
cv::Sobel(image, dy, CV_32F, 0, 1);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::Ptr<cv::GeneralizedHoughBallard> alg = cv::cuda::createGeneralizedHoughBallard();
@@ -259,7 +259,7 @@ PERF_TEST_P(Sz, GeneralizedHoughBallard, GPU_TYPICAL_MAT_SIZES)
TEST_CYCLE() alg->detect(d_edges, d_dx, d_dy, positions);
GPU_SANITY_CHECK(positions);
CUDA_SANITY_CHECK(positions);
}
else
{
@@ -275,7 +275,7 @@ PERF_TEST_P(Sz, GeneralizedHoughBallard, GPU_TYPICAL_MAT_SIZES)
}
}
PERF_TEST_P(Sz, GeneralizedHoughGuil, GPU_TYPICAL_MAT_SIZES)
PERF_TEST_P(Sz, GeneralizedHoughGuil, CUDA_TYPICAL_MAT_SIZES)
{
declare.time(10);
@@ -315,7 +315,7 @@ PERF_TEST_P(Sz, GeneralizedHoughGuil, GPU_TYPICAL_MAT_SIZES)
cv::Sobel(image, dx, CV_32F, 1, 0);
cv::Sobel(image, dy, CV_32F, 0, 1);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
cv::Ptr<cv::GeneralizedHoughGuil> alg = cv::cuda::createGeneralizedHoughGuil();
alg->setMaxAngle(90.0);
@@ -330,7 +330,7 @@ PERF_TEST_P(Sz, GeneralizedHoughGuil, GPU_TYPICAL_MAT_SIZES)
TEST_CYCLE() alg->detect(d_edges, d_dx, d_dy, positions);
GPU_SANITY_CHECK(positions);
CUDA_SANITY_CHECK(positions);
}
else
{

16
modules/cudaimgproc/perf/perf_match_template.cpp
View File

@@ -54,9 +54,9 @@ CV_ENUM(TemplateMethod, TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED,
DEF_PARAM_TEST(Sz_TemplateSz_Cn_Method, cv::Size, cv::Size, MatCn, TemplateMethod);
PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate8U,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),
GPU_CHANNELS_1_3_4,
CUDA_CHANNELS_1_3_4,
TemplateMethod::all()))
{
declare.time(300.0);
@@ -70,7 +70,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate8U,
cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));
declare.in(image, templ, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_image(image);
const cv::cuda::GpuMat d_templ(templ);
@@ -80,7 +80,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate8U,
TEST_CYCLE() alg->match(d_image, d_templ, dst);
GPU_SANITY_CHECK(dst, 1e-5, ERROR_RELATIVE);
CUDA_SANITY_CHECK(dst, 1e-5, ERROR_RELATIVE);
}
else
{
@@ -96,9 +96,9 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate8U,
// MatchTemplate32F
PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate32F,
Combine(GPU_TYPICAL_MAT_SIZES,
Combine(CUDA_TYPICAL_MAT_SIZES,
Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),
GPU_CHANNELS_1_3_4,
CUDA_CHANNELS_1_3_4,
Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))))
{
declare.time(300.0);
@@ -112,7 +112,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate32F,
cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));
declare.in(image, templ, WARMUP_RNG);
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_image(image);
const cv::cuda::GpuMat d_templ(templ);
@@ -122,7 +122,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, MatchTemplate32F,
TEST_CYCLE() alg->match(d_image, d_templ, dst);
GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
CUDA_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
}
else
{

14
modules/cudaimgproc/perf/perf_mean_shift.cpp
View File

@@ -65,14 +65,14 @@ PERF_TEST_P(Image, MeanShiftFiltering,
const int sp = 50;
const int sr = 50;
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(rgba);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::meanShiftFiltering(d_src, dst, sp, sr);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{
@@ -101,7 +101,7 @@ PERF_TEST_P(Image, MeanShiftProc,
const int sp = 50;
const int sr = 50;
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(rgba);
cv::cuda::GpuMat dstr;
@@ -109,8 +109,8 @@ PERF_TEST_P(Image, MeanShiftProc,
TEST_CYCLE() cv::cuda::meanShiftProc(d_src, dstr, dstsp, sp, sr);
GPU_SANITY_CHECK(dstr);
GPU_SANITY_CHECK(dstsp);
CUDA_SANITY_CHECK(dstr);
CUDA_SANITY_CHECK(dstsp);
}
else
{
@@ -136,14 +136,14 @@ PERF_TEST_P(Image, MeanShiftSegmentation,
const int sr = 10;
const int minsize = 20;
if (PERF_RUN_GPU())
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(rgba);
cv::Mat dst;
TEST_CYCLE() cv::cuda::meanShiftSegmentation(d_src, dst, sp, sr, minsize);
GPU_SANITY_CHECK(dst);
CUDA_SANITY_CHECK(dst);
}
else
{