#include "perf_precomp.hpp"

#include "opencv2/ts/gpu_perf.hpp"

using namespace std;

using namespace testing;

using namespace perf;

enum { HALF_SIZE=0, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH };

CV_ENUM(RemapMode, HALF_SIZE, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH)

void generateMap(cv::Mat& map_x, cv::Mat& map_y, int remapMode)

}

DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Border_Mode, cv::Size, MatDepth, MatCn, Interpolation, BorderMode, RemapMode);

#ifdef OPENCV_TINY_GPU_MODULE

PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),

ALL_BORDER_MODES,

RemapMode::all()

))

#else

PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_16U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),

ALL_BORDER_MODES,

RemapMode::all()

))

#endif

{

declare.time(20.0);

const cv::Size size = GET_PARAM(0);

const int depth = GET_PARAM(1);

const int channels = GET_PARAM(2);

const int interpolation = GET_PARAM(3);

const int borderMode = GET_PARAM(4);

const int remapMode = GET_PARAM(5);

const int type = CV_MAKE_TYPE(depth, channels);

cv::Mat src(size, type);

declare.in(src, WARMUP_RNG);

cv::Mat xmap(size, CV_32FC1);

cv::Mat ymap(size, CV_32FC1);

generateMap(xmap, ymap, remapMode);

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(src);

const cv::gpu::GpuMat d_xmap(xmap);

const cv::gpu::GpuMat d_ymap(ymap);

cv::gpu::GpuMat dst;

TEST_CYCLE() cv::gpu::remap(d_src, dst, d_xmap, d_ymap, interpolation, borderMode);

GPU_SANITY_CHECK(dst);

}

else

{

cv::Mat dst;

TEST_CYCLE() cv::remap(src, dst, xmap, ymap, interpolation, borderMode);

CPU_SANITY_CHECK(dst);

}

}

DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Scale, cv::Size, MatDepth, MatCn, Interpolation, double);

#ifdef OPENCV_TINY_GPU_MODULE

PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),

Values(0.5, 0.3, 2.0)

))

#else

PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_16U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),

Values(0.5, 0.3, 2.0)

))

#endif

{

declare.time(20.0);

const cv::Size size = GET_PARAM(0);

const int depth = GET_PARAM(1);

const int channels = GET_PARAM(2);

const int interpolation = GET_PARAM(3);

const double f = GET_PARAM(4);

const int type = CV_MAKE_TYPE(depth, channels);

cv::Mat src(size, type);

declare.in(src, WARMUP_RNG);

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(src);

cv::gpu::GpuMat dst;

TEST_CYCLE() cv::gpu::resize(d_src, dst, cv::Size(), f, f, interpolation);

GPU_SANITY_CHECK(dst, 1e-3, ERROR_RELATIVE);

}

else

{

cv::Mat dst;

TEST_CYCLE() cv::resize(src, dst, cv::Size(), f, f, interpolation);

CPU_SANITY_CHECK(dst);

}

}

DEF_PARAM_TEST(Sz_Depth_Cn_Scale, cv::Size, MatDepth, MatCn, double);

#ifdef OPENCV_TINY_GPU_MODULE

PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(0.2, 0.1, 0.05)

))

#else

PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_16U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(0.2, 0.1, 0.05)

))

#endif

{

declare.time(1.0);

const cv::Size size = GET_PARAM(0);

const int depth = GET_PARAM(1);

const int channels = GET_PARAM(2);

const int interpolation = cv::INTER_AREA;

const double f = GET_PARAM(3);

const int type = CV_MAKE_TYPE(depth, channels);

cv::Mat src(size, type);

declare.in(src, WARMUP_RNG);

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(src);

cv::gpu::GpuMat dst;

TEST_CYCLE() cv::gpu::resize(d_src, dst, cv::Size(), f, f, interpolation);

GPU_SANITY_CHECK(dst);

}

else

{

cv::Mat dst;

TEST_CYCLE() cv::resize(src, dst, cv::Size(), f, f, interpolation);

CPU_SANITY_CHECK(dst);

}

}

DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Border, cv::Size, MatDepth, MatCn, Interpolation, BorderMode);

#ifdef OPENCV_TINY_GPU_MODULE

PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),

ALL_BORDER_MODES)

)

#else

PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_16U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),

ALL_BORDER_MODES)

)

#endif

{

declare.time(20.0);

const cv::Size size = GET_PARAM(0);

const int depth = GET_PARAM(1);

const int channels = GET_PARAM(2);

const int interpolation = GET_PARAM(3);

const int borderMode = GET_PARAM(4);

const int type = CV_MAKE_TYPE(depth, channels);

cv::Mat src(size, type);

declare.in(src, WARMUP_RNG);

const double aplha = CV_PI / 4;

const double mat[2 * 3] =

{

std::cos(aplha), -std::sin(aplha), static_cast<double>(src.cols) / 2.0,

std::sin(aplha), std::cos(aplha), 0

};

const cv::Mat M(2, 3, CV_64F, (void*) mat);

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(src);

cv::gpu::GpuMat dst;

TEST_CYCLE() cv::gpu::warpAffine(d_src, dst, M, size, interpolation, borderMode);

GPU_SANITY_CHECK(dst, 1);

}

else

{

cv::Mat dst;

TEST_CYCLE() cv::warpAffine(src, dst, M, size, interpolation, borderMode);

CPU_SANITY_CHECK(dst);

}

}

#ifdef OPENCV_TINY_GPU_MODULE

PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),

ALL_BORDER_MODES)

)

#else

PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_16U, CV_32F),

GPU_CHANNELS_1_3_4,

Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),

ALL_BORDER_MODES)

)

#endif

{

declare.time(20.0);

const cv::Size size = GET_PARAM(0);

const int depth = GET_PARAM(1);

const int channels = GET_PARAM(2);

const int interpolation = GET_PARAM(3);

const int borderMode = GET_PARAM(4);

const int type = CV_MAKE_TYPE(depth, channels);

cv::Mat src(size, type);

declare.in(src, WARMUP_RNG);

const double aplha = CV_PI / 4;

double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), static_cast<double>(src.cols) / 2.0},

{std::sin(aplha), std::cos(aplha), 0},

{0.0, 0.0, 1.0}};

const cv::Mat M(3, 3, CV_64F, (void*) mat);

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(src);

cv::gpu::GpuMat dst;

TEST_CYCLE() cv::gpu::warpPerspective(d_src, dst, M, size, interpolation, borderMode);

GPU_SANITY_CHECK(dst, 1);

}

else

{

cv::Mat dst;

TEST_CYCLE() cv::warpPerspective(src, dst, M, size, interpolation, borderMode);

CPU_SANITY_CHECK(dst);

}

}

DEF_PARAM_TEST(Sz_Depth_Cn_Border, cv::Size, MatDepth, MatCn, BorderMode);

#ifdef OPENCV_TINY_GPU_MODULE

PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_32F),

GPU_CHANNELS_1_3_4,

ALL_BORDER_MODES)

)

#else

PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_16U, CV_32F),

GPU_CHANNELS_1_3_4,

ALL_BORDER_MODES)

)

#endif

{

const cv::Size size = GET_PARAM(0);

const int depth = GET_PARAM(1);

const int channels = GET_PARAM(2);

const int borderMode = GET_PARAM(3);

const int type = CV_MAKE_TYPE(depth, channels);

cv::Mat src(size, type);

declare.in(src, WARMUP_RNG);

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(src);

cv::gpu::GpuMat dst;

TEST_CYCLE() cv::gpu::copyMakeBorder(d_src, dst, 5, 5, 5, 5, borderMode);

GPU_SANITY_CHECK(dst);

}

else

{

cv::Mat dst;

TEST_CYCLE() cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderMode);

CPU_SANITY_CHECK(dst);

}

}

CV_ENUM(ThreshOp, THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV)

DEF_PARAM_TEST(Sz_Depth_Op, cv::Size, MatDepth, ThreshOp);

#ifdef OPENCV_TINY_GPU_MODULE

PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_32F),

ThreshOp::all()

))

#else

PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(

GPU_TYPICAL_MAT_SIZES,

Values(CV_8U, CV_16U, CV_32F, CV_64F),

ThreshOp::all()

))

#endif

{

const cv::Size size = GET_PARAM(0);

const int depth = GET_PARAM(1);

const int threshOp = GET_PARAM(2);

cv::Mat src(size, depth);

declare.in(src, WARMUP_RNG);

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(src);

cv::gpu::GpuMat dst;

TEST_CYCLE() cv::gpu::threshold(d_src, dst, 100.0, 255.0, threshOp);

GPU_SANITY_CHECK(dst, 1e-10);

}

else

{

cv::Mat dst;

TEST_CYCLE() cv::threshold(src, dst, 100.0, 255.0, threshOp);

CPU_SANITY_CHECK(dst);

}

}

PERF_TEST_P(Sz, ImgProc_Integral,

}

PERF_TEST_P(Sz, ImgProc_IntegralSqr,

}

PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1,

}

PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4,

}

PERF_TEST_P(Sz, ImgProc_CalcHist,

}

PERF_TEST_P(Sz, ImgProc_EqualizeHist,

}

DEF_PARAM_TEST(Sz_ClipLimit, cv::Size, double);

PERF_TEST_P(Sz_ClipLimit, ImgProc_CLAHE,

Combine(GPU_TYPICAL_MAT_SIZES,

Values(0.0, 40.0)))

{

const cv::Size size = GET_PARAM(0);

const double clipLimit = GET_PARAM(1);

cv::Mat src(size, CV_8UC1);

declare.in(src, WARMUP_RNG);

if (PERF_RUN_GPU())

{

cv::Ptr<cv::gpu::CLAHE> clahe = cv::gpu::createCLAHE(clipLimit);

cv::gpu::GpuMat d_src(src);

cv::gpu::GpuMat dst;

TEST_CYCLE() clahe->apply(d_src, dst);

GPU_SANITY_CHECK(dst);

}

else

{

cv::Ptr<cv::CLAHE> clahe = cv::createCLAHE(clipLimit);

cv::Mat dst;

TEST_CYCLE() clahe->apply(src, dst);

CPU_SANITY_CHECK(dst);

}

}

PERF_TEST_P(Sz, ImgProc_ColumnSum,

}

DEF_PARAM_TEST(Image_AppertureSz_L2gradient, string, int, bool);

#ifdef OPENCV_TINY_GPU_MODULE

PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(

Values("perf/800x600.png", "perf/1280x1024.png", "perf/1680x1050.png"),

Values(3),

Bool()

))

#else

PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(

Values("perf/800x600.png", "perf/1280x1024.png", "perf/1680x1050.png"),

Values(3, 5),

Bool()

))

#endif

{

const string fileName = GET_PARAM(0);

const int apperture_size = GET_PARAM(1);

const bool useL2gradient = GET_PARAM(2);

const cv::Mat image = readImage(fileName, cv::IMREAD_GRAYSCALE);

ASSERT_FALSE(image.empty());

const double low_thresh = 50.0;

const double high_thresh = 100.0;

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_image(image);

cv::gpu::GpuMat dst;

cv::gpu::CannyBuf d_buf;

TEST_CYCLE() cv::gpu::Canny(d_image, d_buf, dst, low_thresh, high_thresh, apperture_size, useL2gradient);

GPU_SANITY_CHECK(dst);

}

else

{

cv::Mat dst;

TEST_CYCLE() cv::Canny(image, dst, low_thresh, high_thresh, apperture_size, useL2gradient);

CPU_SANITY_CHECK(dst);

}

}

DEF_PARAM_TEST_1(Image, string);

PERF_TEST_P(Image, ImgProc_MeanShiftFiltering,

Values<string>("gpu/meanshift/cones.png"))

{

declare.time(300.0);

const cv::Mat img = readImage(GetParam());

ASSERT_FALSE(img.empty());

cv::Mat rgba;

cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);

const int sp = 50;

const int sr = 50;

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(rgba);

cv::gpu::GpuMat dst;

TEST_CYCLE() cv::gpu::meanShiftFiltering(d_src, dst, sp, sr);

GPU_SANITY_CHECK(dst);

}

else

{

cv::Mat dst;

TEST_CYCLE() cv::pyrMeanShiftFiltering(img, dst, sp, sr);

CPU_SANITY_CHECK(dst);

}

}

PERF_TEST_P(Image, ImgProc_MeanShiftProc,

Values<string>("gpu/meanshift/cones.png"))

{

declare.time(300.0);

const cv::Mat img = readImage(GetParam());

ASSERT_FALSE(img.empty());

cv::Mat rgba;

cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);

const int sp = 50;

const int sr = 50;

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(rgba);

cv::gpu::GpuMat dstr;

cv::gpu::GpuMat dstsp;

TEST_CYCLE() cv::gpu::meanShiftProc(d_src, dstr, dstsp, sp, sr);

GPU_SANITY_CHECK(dstr);

GPU_SANITY_CHECK(dstsp);

}

else

{

FAIL_NO_CPU();

}

}

PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation,

Values<string>("gpu/meanshift/cones.png"))

{

declare.time(300.0);

const cv::Mat img = readImage(GetParam());

ASSERT_FALSE(img.empty());

cv::Mat rgba;

cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);

const int sp = 10;

const int sr = 10;

const int minsize = 20;

if (PERF_RUN_GPU())

{

const cv::gpu::GpuMat d_src(rgba);

cv::Mat dst;

TEST_CYCLE() cv::gpu::meanShiftSegmentation(d_src, dst, sp, sr, minsize);

GPU_SANITY_CHECK(dst);

}

else

{

FAIL_NO_CPU();

}

}

PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear,

}

#ifdef HAVE_CUFFT

DEF_PARAM_TEST(Sz_KernelSz_Ccorr, cv::Size, int, bool);

PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve,

Combine(GPU_TYPICAL_MAT_SIZES,

Values(17, 27, 32, 64),

Bool()))

{

declare.time(10.0);

const cv::Size size = GET_PARAM(0);

const int templ_size = GET_PARAM(1);

const bool ccorr = GET_PARAM(2);

const cv::Mat image(size, CV_32FC1);

const cv::Mat templ(templ_size, templ_size, CV_32FC1);

declare.in(image, templ, WARMUP_RNG);

if (PERF_RUN_GPU())

{

cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);

d_image.upload(image);

cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);

d_templ.upload(templ);

cv::gpu::GpuMat dst;

cv::gpu::ConvolveBuf d_buf;

TEST_CYCLE() cv::gpu::convolve(d_image, d_templ, dst, ccorr, d_buf);

GPU_SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);

}

else

{

if (ccorr)

FAIL_NO_CPU();

cv::Mat dst;

TEST_CYCLE() cv::filter2D(image, dst, image.depth(), templ);

CPU_SANITY_CHECK(dst);

}

}

CV_ENUM(TemplateMethod, TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED)

DEF_PARAM_TEST(Sz_TemplateSz_Cn_Method, cv::Size, cv::Size, MatCn, TemplateMethod);

PERF_TEST_P(Sz_TemplateSz_Cn_Method, DISABLED_ImgProc_MatchTemplate8U,

Combine(GPU_TYPICAL_MAT_SIZES,

Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),

GPU_CHANNELS_1_3_4,

TemplateMethod::all()))

{