Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Eliminate the need of ::testsing::ValuesIn() for CV_ENUM

Browse Source 
Also cv::, cv::gpu:: and cv::ocl:: namespace prefixes can be safely omitted
inside CV_ENUM and CV_FLAGS
pull/822/head
Andrey Kamaev 12 years ago
parent 2ae3ab11e3
commit 96b008cd29
30 changed files with 168 additions and 189 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      modules/core/perf/perf_compare.cpp
  2. 4
      modules/core/perf/perf_reduce.cpp
  3. 2
      modules/features2d/perf/perf_fast.cpp
  4. 21
      modules/gpu/perf/perf_core.cpp
  5. 5
      modules/gpu/perf/perf_filters.cpp
  6. 32
      modules/gpu/perf/perf_imgproc.cpp
  7. 9
      modules/gpu/test/test_core.cpp
  8. 2
      modules/gpu/test/test_features2d.cpp
  9. 5
      modules/gpu/test/test_filters.cpp
  10. 7
      modules/gpu/test/test_imgproc.cpp
  11. 2
      modules/gpu/test/test_optflow.cpp
  12. 5
      modules/gpu/test/test_threshold.cpp
  13. 2
      modules/imgproc/perf/perf_bilateral.cpp
  14. 14
      modules/imgproc/perf/perf_blur.cpp
  15. 2
      modules/imgproc/perf/perf_cornerEigenValsAndVecs.cpp
  16. 2
      modules/imgproc/perf/perf_cornerHarris.cpp
  17. 8
      modules/imgproc/perf/perf_cvt_color.cpp
  18. 2
      modules/imgproc/perf/perf_filter2d.cpp
  19. 4
      modules/imgproc/perf/perf_matchTemplate.cpp
  20. 2
      modules/imgproc/perf/perf_remap.cpp
  21. 16
      modules/imgproc/perf/perf_sepfilters.cpp
  22. 6
      modules/imgproc/perf/perf_threshold.cpp
  23. 18
      modules/imgproc/perf/perf_warp.cpp
  24. 6
      modules/ocl/test/test_brute_force_matcher.cpp
  25. 31
      modules/ocl/test/utility.hpp
  26. 2
      modules/photo/perf/perf_inpaint.cpp
  27. 12
      modules/ts/include/opencv2/ts/gpu_perf.hpp
  28. 8
      modules/ts/include/opencv2/ts/gpu_test.hpp
  29. 122
      modules/ts/include/opencv2/ts/ts_perf.hpp
  30. 2
      modules/video/perf/perf_optflowpyrlk.cpp

4
modules/core/perf/perf_compare.cpp
Unescape View File

@ -15,7 +15,7 @@ PERF_TEST_P( Size_MatType_CmpType, compare,
testing::Combine( testing::Combine(
testing::Values(::perf::szVGA, ::perf::sz1080p), testing::Values(::perf::szVGA, ::perf::sz1080p),
testing::Values(CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1), testing::Values(CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1),
testing::ValuesIn(CmpType::all()) CmpType::all()
) )
) )
{ {
@ -38,7 +38,7 @@ PERF_TEST_P( Size_MatType_CmpType, compareScalar,
testing::Combine( testing::Combine(
testing::Values(TYPICAL_MAT_SIZES), testing::Values(TYPICAL_MAT_SIZES),
testing::Values(TYPICAL_MAT_TYPES), testing::Values(TYPICAL_MAT_TYPES),
testing::ValuesIn(CmpType::all()) CmpType::all()
) )
) )
{ {

4
modules/core/perf/perf_reduce.cpp
Unescape View File

@ -16,7 +16,7 @@ PERF_TEST_P(Size_MatType_ROp, reduceR,
testing::Combine( testing::Combine(
testing::Values(TYPICAL_MAT_SIZES), testing::Values(TYPICAL_MAT_SIZES),
testing::Values(TYPICAL_MAT_TYPES), testing::Values(TYPICAL_MAT_TYPES),
testing::ValuesIn(ROp::all()) ROp::all()
) )
) )
{ {
@ -43,7 +43,7 @@ PERF_TEST_P(Size_MatType_ROp, reduceC,
testing::Combine( testing::Combine(
testing::Values(TYPICAL_MAT_SIZES), testing::Values(TYPICAL_MAT_SIZES),
testing::Values(TYPICAL_MAT_TYPES), testing::Values(TYPICAL_MAT_TYPES),
testing::ValuesIn(ROp::all()) ROp::all()
) )
) )
{ {

2
modules/features2d/perf/perf_fast.cpp
Unescape View File

@ -18,7 +18,7 @@ typedef perf::TestBaseWithParam<File_Type_t> fast;
PERF_TEST_P(fast, detect, testing::Combine( PERF_TEST_P(fast, detect, testing::Combine(
testing::Values(FAST_IMAGES), testing::Values(FAST_IMAGES),
testing::ValuesIn(FastType::all()) FastType::all()
)) ))
{ {
String filename = getDataPath(get<0>(GetParam())); String filename = getDataPath(get<0>(GetParam()));

21
modules/gpu/perf/perf_core.cpp
Unescape View File

@ -712,15 +712,14 @@ PERF_TEST_P(Sz_Depth_Power, Core_Pow,
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// CompareMat // CompareMat
CV_ENUM(CmpCode, cv::CMP_EQ, cv::CMP_GT, cv::CMP_GE, cv::CMP_LT, cv::CMP_LE, cv::CMP_NE) CV_ENUM(CmpCode, CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE)
#define ALL_CMP_CODES ValuesIn(CmpCode::all())
DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CmpCode); DEF_PARAM_TEST(Sz_Depth_Code, cv::Size, MatDepth, CmpCode);
PERF_TEST_P(Sz_Depth_Code, Core_CompareMat, PERF_TEST_P(Sz_Depth_Code, Core_CompareMat,
Combine(GPU_TYPICAL_MAT_SIZES, Combine(GPU_TYPICAL_MAT_SIZES,
ARITHM_MAT_DEPTH, ARITHM_MAT_DEPTH,
ALL_CMP_CODES)) CmpCode::all()))
{ {
const cv::Size size = GET_PARAM(0); const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1); const int depth = GET_PARAM(1);
@ -758,7 +757,7 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareMat,
PERF_TEST_P(Sz_Depth_Code, Core_CompareScalar, PERF_TEST_P(Sz_Depth_Code, Core_CompareScalar,
Combine(GPU_TYPICAL_MAT_SIZES, Combine(GPU_TYPICAL_MAT_SIZES,
ARITHM_MAT_DEPTH, ARITHM_MAT_DEPTH,
ALL_CMP_CODES)) CmpCode::all()))
{ {
const cv::Size size = GET_PARAM(0); const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1); const int depth = GET_PARAM(1);
@ -1304,7 +1303,7 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted,
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// GEMM // GEMM
CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T) CV_FLAGS(GemmFlags, 0, GEMM_1_T, GEMM_2_T, GEMM_3_T)
#define ALL_GEMM_FLAGS Values(0, CV_GEMM_A_T, CV_GEMM_B_T, CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T, CV_GEMM_A_T | CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T | CV_GEMM_C_T) #define ALL_GEMM_FLAGS Values(0, CV_GEMM_A_T, CV_GEMM_B_T, CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T, CV_GEMM_A_T | CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T | CV_GEMM_C_T)
DEF_PARAM_TEST(Sz_Type_Flags, cv::Size, MatType, GemmFlags); DEF_PARAM_TEST(Sz_Type_Flags, cv::Size, MatType, GemmFlags);
@ -1389,7 +1388,6 @@ PERF_TEST_P(Sz_Type, Core_Transpose,
enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1}; enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1};
CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y) CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)
#define ALL_FLIP_CODES ValuesIn(FlipCode::all())
DEF_PARAM_TEST(Sz_Depth_Cn_Code, cv::Size, MatDepth, MatCn, FlipCode); DEF_PARAM_TEST(Sz_Depth_Cn_Code, cv::Size, MatDepth, MatCn, FlipCode);
@ -1397,7 +1395,7 @@ PERF_TEST_P(Sz_Depth_Cn_Code, Core_Flip,
Combine(GPU_TYPICAL_MAT_SIZES, Combine(GPU_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U, CV_32F), Values(CV_8U, CV_16U, CV_32F),
GPU_CHANNELS_1_3_4, GPU_CHANNELS_1_3_4,
ALL_FLIP_CODES)) FlipCode::all()))
{ {
const cv::Size size = GET_PARAM(0); const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1); const int depth = GET_PARAM(1);
@ -2071,12 +2069,9 @@ PERF_TEST_P(Sz_Depth, Core_CountNonZero,
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// Reduce // Reduce
CV_ENUM(ReduceCode, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
#define ALL_REDUCE_CODES ValuesIn(ReduceCode::all())
enum {Rows = 0, Cols = 1}; enum {Rows = 0, Cols = 1};
CV_ENUM(ReduceCode, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
CV_ENUM(ReduceDim, Rows, Cols) CV_ENUM(ReduceDim, Rows, Cols)
#define ALL_REDUCE_DIMS ValuesIn(ReduceDim::all())
DEF_PARAM_TEST(Sz_Depth_Cn_Code_Dim, cv::Size, MatDepth, MatCn, ReduceCode, ReduceDim); DEF_PARAM_TEST(Sz_Depth_Cn_Code_Dim, cv::Size, MatDepth, MatCn, ReduceCode, ReduceDim);
@ -2084,8 +2079,8 @@ PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce,
Combine(GPU_TYPICAL_MAT_SIZES, Combine(GPU_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U, CV_16S, CV_32F), Values(CV_8U, CV_16U, CV_16S, CV_32F),
Values(1, 2, 3, 4), Values(1, 2, 3, 4),
ALL_REDUCE_CODES, ReduceCode::all(),
ALL_REDUCE_DIMS)) ReduceDim::all()))
{ {
const cv::Size size = GET_PARAM(0); const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1); const int depth = GET_PARAM(1);

5
modules/gpu/perf/perf_filters.cpp
Unescape View File

@ -291,12 +291,11 @@ PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// MorphologyEx // MorphologyEx
CV_ENUM(MorphOp, cv::MORPH_OPEN, cv::MORPH_CLOSE, cv::MORPH_GRADIENT, cv::MORPH_TOPHAT, cv::MORPH_BLACKHAT) CV_ENUM(MorphOp, MORPH_OPEN, MORPH_CLOSE, MORPH_GRADIENT, MORPH_TOPHAT, MORPH_BLACKHAT)
#define ALL_MORPH_OPS ValuesIn(MorphOp::all())
DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, MorphOp); DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, MorphOp);
PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4), ALL_MORPH_OPS)) PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4), MorphOp::all()))
{ {
declare.time(20.0); declare.time(20.0);

32
modules/gpu/perf/perf_imgproc.cpp
Unescape View File

@ -51,7 +51,6 @@ using namespace perf;
enum { HALF_SIZE=0, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH }; enum { HALF_SIZE=0, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH };
CV_ENUM(RemapMode, HALF_SIZE, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH); CV_ENUM(RemapMode, HALF_SIZE, UPSIDE_DOWN, REFLECTION_X, REFLECTION_BOTH);
#define ALL_REMAP_MODES ValuesIn(RemapMode::all())
void generateMap(cv::Mat& map_x, cv::Mat& map_y, int remapMode) void generateMap(cv::Mat& map_x, cv::Mat& map_y, int remapMode)
{ {
@ -98,7 +97,7 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap,
GPU_CHANNELS_1_3_4, GPU_CHANNELS_1_3_4,
Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
ALL_BORDER_MODES, ALL_BORDER_MODES,
ALL_REMAP_MODES)) RemapMode::all()))
{ {
declare.time(20.0); declare.time(20.0);
@ -369,15 +368,14 @@ PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder,
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// Threshold // Threshold
CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV) CV_ENUM(ThreshOp, THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV)
#define ALL_THRESH_OPS ValuesIn(ThreshOp::all())
DEF_PARAM_TEST(Sz_Depth_Op, cv::Size, MatDepth, ThreshOp); DEF_PARAM_TEST(Sz_Depth_Op, cv::Size, MatDepth, ThreshOp);
PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold,
Combine(GPU_TYPICAL_MAT_SIZES, Combine(GPU_TYPICAL_MAT_SIZES,
Values(CV_8U, CV_16U, CV_32F, CV_64F), Values(CV_8U, CV_16U, CV_32F, CV_64F),
ALL_THRESH_OPS)) ThreshOp::all()))
{ {
const cv::Size size = GET_PARAM(0); const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1); const int depth = GET_PARAM(1);
@ -894,8 +892,7 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve,
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// MatchTemplate8U // MatchTemplate8U
CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED) CV_ENUM(TemplateMethod, TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED)
#define ALL_TEMPLATE_METHODS ValuesIn(TemplateMethod::all())
DEF_PARAM_TEST(Sz_TemplateSz_Cn_Method, cv::Size, cv::Size, MatCn, TemplateMethod); DEF_PARAM_TEST(Sz_TemplateSz_Cn_Method, cv::Size, cv::Size, MatCn, TemplateMethod);
@ -903,7 +900,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U,
Combine(GPU_TYPICAL_MAT_SIZES, Combine(GPU_TYPICAL_MAT_SIZES,
Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)), Values(cv::Size(5, 5), cv::Size(16, 16), cv::Size(30, 30)),
GPU_CHANNELS_1_3_4, GPU_CHANNELS_1_3_4,
ALL_TEMPLATE_METHODS)) TemplateMethod::all()))
{ {
declare.time(300.0); declare.time(300.0);
@ -979,7 +976,7 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F,
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// MulSpectrums // MulSpectrums
CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT) CV_FLAGS(DftFlags, 0, DFT_INVERSE, DFT_SCALE, DFT_ROWS, DFT_COMPLEX_OUTPUT, DFT_REAL_OUTPUT)
DEF_PARAM_TEST(Sz_Flags, cv::Size, DftFlags); DEF_PARAM_TEST(Sz_Flags, cv::Size, DftFlags);
@ -1454,16 +1451,16 @@ PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColorBayer,
} }
CV_ENUM(DemosaicingCode, CV_ENUM(DemosaicingCode,
cv::COLOR_BayerBG2BGR, cv::COLOR_BayerGB2BGR, cv::COLOR_BayerRG2BGR, cv::COLOR_BayerGR2BGR, COLOR_BayerBG2BGR, COLOR_BayerGB2BGR, COLOR_BayerRG2BGR, COLOR_BayerGR2BGR,
cv::COLOR_BayerBG2GRAY, cv::COLOR_BayerGB2GRAY, cv::COLOR_BayerRG2GRAY, cv::COLOR_BayerGR2GRAY, COLOR_BayerBG2GRAY, COLOR_BayerGB2GRAY, COLOR_BayerRG2GRAY, COLOR_BayerGR2GRAY,
cv::gpu::COLOR_BayerBG2BGR_MHT, cv::gpu::COLOR_BayerGB2BGR_MHT, cv::gpu::COLOR_BayerRG2BGR_MHT, cv::gpu::COLOR_BayerGR2BGR_MHT, COLOR_BayerBG2BGR_MHT, COLOR_BayerGB2BGR_MHT, COLOR_BayerRG2BGR_MHT, COLOR_BayerGR2BGR_MHT,
cv::gpu::COLOR_BayerBG2GRAY_MHT, cv::gpu::COLOR_BayerGB2GRAY_MHT, cv::gpu::COLOR_BayerRG2GRAY_MHT, cv::gpu::COLOR_BayerGR2GRAY_MHT) COLOR_BayerBG2GRAY_MHT, COLOR_BayerGB2GRAY_MHT, COLOR_BayerRG2GRAY_MHT, COLOR_BayerGR2GRAY_MHT)
DEF_PARAM_TEST(Sz_Code, cv::Size, DemosaicingCode); DEF_PARAM_TEST(Sz_Code, cv::Size, DemosaicingCode);
PERF_TEST_P(Sz_Code, ImgProc_Demosaicing, PERF_TEST_P(Sz_Code, ImgProc_Demosaicing,
Combine(GPU_TYPICAL_MAT_SIZES, Combine(GPU_TYPICAL_MAT_SIZES,
ValuesIn(DemosaicingCode::all()))) DemosaicingCode::all()))
{ {
const cv::Size size = GET_PARAM(0); const cv::Size size = GET_PARAM(0);
const int code = GET_PARAM(1); const int code = GET_PARAM(1);
@ -1527,15 +1524,14 @@ PERF_TEST_P(Sz, ImgProc_SwapChannels,
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// AlphaComp // AlphaComp
CV_ENUM(AlphaOp, cv::gpu::ALPHA_OVER, cv::gpu::ALPHA_IN, cv::gpu::ALPHA_OUT, cv::gpu::ALPHA_ATOP, cv::gpu::ALPHA_XOR, cv::gpu::ALPHA_PLUS, cv::gpu::ALPHA_OVER_PREMUL, cv::gpu::ALPHA_IN_PREMUL, cv::gpu::ALPHA_OUT_PREMUL, cv::gpu::ALPHA_ATOP_PREMUL, cv::gpu::ALPHA_XOR_PREMUL, cv::gpu::ALPHA_PLUS_PREMUL, cv::gpu::ALPHA_PREMUL) CV_ENUM(AlphaOp, ALPHA_OVER, ALPHA_IN, ALPHA_OUT, ALPHA_ATOP, ALPHA_XOR, ALPHA_PLUS, ALPHA_OVER_PREMUL, ALPHA_IN_PREMUL, ALPHA_OUT_PREMUL, ALPHA_ATOP_PREMUL, ALPHA_XOR_PREMUL, ALPHA_PLUS_PREMUL, ALPHA_PREMUL)
#define ALL_ALPHA_OPS ValuesIn(AlphaOp::all())
DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, AlphaOp); DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, AlphaOp);
PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp,
Combine(GPU_TYPICAL_MAT_SIZES, Combine(GPU_TYPICAL_MAT_SIZES,
Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4), Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4),
ALL_ALPHA_OPS)) AlphaOp::all()))
{ {
const cv::Size size = GET_PARAM(0); const cv::Size size = GET_PARAM(0);
const int type = GET_PARAM(1); const int type = GET_PARAM(1);
@ -1815,7 +1811,7 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles,
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// GeneralizedHough // GeneralizedHough
CV_FLAGS(GHMethod, cv::GHT_POSITION, cv::GHT_SCALE, cv::GHT_ROTATION); CV_FLAGS(GHMethod, GHT_POSITION, GHT_SCALE, GHT_ROTATION);
DEF_PARAM_TEST(Method_Sz, GHMethod, cv::Size); DEF_PARAM_TEST(Method_Sz, GHMethod, cv::Size);

9
modules/gpu/test/test_core.cpp
Unescape View File

@ -1613,8 +1613,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Compare_Array // Compare_Array
CV_ENUM(CmpCode, cv::CMP_EQ, cv::CMP_GT, cv::CMP_GE, cv::CMP_LT, cv::CMP_LE, cv::CMP_NE) CV_ENUM(CmpCode, CMP_EQ, CMP_NE, CMP_GT, CMP_GE, CMP_LT, CMP_LE)
#define ALL_CMP_CODES testing::Values(CmpCode(cv::CMP_EQ), CmpCode(cv::CMP_NE), CmpCode(cv::CMP_GT), CmpCode(cv::CMP_GE), CmpCode(cv::CMP_LT), CmpCode(cv::CMP_LE))
PARAM_TEST_CASE(Compare_Array, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode, UseRoi) PARAM_TEST_CASE(Compare_Array, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode, UseRoi)
{ {
@ -1669,7 +1668,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Compare_Array, testing::Combine(
ALL_DEVICES, ALL_DEVICES,
DIFFERENT_SIZES, DIFFERENT_SIZES,
ALL_DEPTH, ALL_DEPTH,
ALL_CMP_CODES, CmpCode::all(),
WHOLE_SUBMAT)); WHOLE_SUBMAT));
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -1780,7 +1779,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Compare_Scalar, testing::Combine(
ALL_DEVICES, ALL_DEVICES,
DIFFERENT_SIZES, DIFFERENT_SIZES,
TYPES(CV_8U, CV_64F, 1, 4), TYPES(CV_8U, CV_64F, 1, 4),
ALL_CMP_CODES, CmpCode::all(),
WHOLE_SUBMAT)); WHOLE_SUBMAT));
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
@ -2371,7 +2370,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine(
#ifdef HAVE_CUBLAS #ifdef HAVE_CUBLAS
CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T); CV_FLAGS(GemmFlags, 0, GEMM_1_T, GEMM_2_T, GEMM_3_T);
#define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T)) #define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi) PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi)

2
modules/gpu/test/test_features2d.cpp
Unescape View File

@ -123,7 +123,7 @@ namespace
IMPLEMENT_PARAM_CLASS(ORB_BlurForDescriptor, bool) IMPLEMENT_PARAM_CLASS(ORB_BlurForDescriptor, bool)
} }
CV_ENUM(ORB_ScoreType, cv::ORB::HARRIS_SCORE, cv::ORB::FAST_SCORE) CV_ENUM(ORB_ScoreType, ORB::HARRIS_SCORE, ORB::FAST_SCORE)
PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, ORB_LevelsCount, ORB_EdgeThreshold, ORB_firstLevel, ORB_WTA_K, ORB_ScoreType, ORB_PatchSize, ORB_BlurForDescriptor) PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, ORB_LevelsCount, ORB_EdgeThreshold, ORB_firstLevel, ORB_WTA_K, ORB_ScoreType, ORB_PatchSize, ORB_BlurForDescriptor)
{ {

5
modules/gpu/test/test_filters.cpp
Unescape View File

@ -471,8 +471,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Dilate, testing::Combine(
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// MorphEx // MorphEx
CV_ENUM(MorphOp, cv::MORPH_OPEN, cv::MORPH_CLOSE, cv::MORPH_GRADIENT, cv::MORPH_TOPHAT, cv::MORPH_BLACKHAT) CV_ENUM(MorphOp, MORPH_OPEN, MORPH_CLOSE, MORPH_GRADIENT, MORPH_TOPHAT, MORPH_BLACKHAT)
#define ALL_MORPH_OPS testing::Values(MorphOp(cv::MORPH_OPEN), MorphOp(cv::MORPH_CLOSE), MorphOp(cv::MORPH_GRADIENT), MorphOp(cv::MORPH_TOPHAT), MorphOp(cv::MORPH_BLACKHAT))
PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor, Iterations, UseRoi) PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor, Iterations, UseRoi)
{ {
@ -518,7 +517,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, MorphEx, testing::Combine(
ALL_DEVICES, ALL_DEVICES,
DIFFERENT_SIZES, DIFFERENT_SIZES,
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)), testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
ALL_MORPH_OPS, MorphOp::all(),
testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))), testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))),
testing::Values(Iterations(1), Iterations(2), Iterations(3)), testing::Values(Iterations(1), Iterations(2), Iterations(3)),
WHOLE_SUBMAT)); WHOLE_SUBMAT));

7
modules/gpu/test/test_imgproc.cpp
Unescape View File

@ -663,8 +663,7 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// MatchTemplate8U // MatchTemplate8U
CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED) CV_ENUM(TemplateMethod, TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED)
#define ALL_TEMPLATE_METHODS testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_SQDIFF_NORMED), TemplateMethod(cv::TM_CCORR), TemplateMethod(cv::TM_CCORR_NORMED), TemplateMethod(cv::TM_CCOEFF), TemplateMethod(cv::TM_CCOEFF_NORMED))
namespace namespace
{ {
@ -710,7 +709,7 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate8U, testing::Combine(
DIFFERENT_SIZES, DIFFERENT_SIZES,
testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))), testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),
testing::Values(Channels(1), Channels(3), Channels(4)), testing::Values(Channels(1), Channels(3), Channels(4)),
ALL_TEMPLATE_METHODS)); TemplateMethod::all()));
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// MatchTemplate32F // MatchTemplate32F
@ -919,7 +918,7 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CanFindBigTemplate, ALL_DEVIC
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// MulSpectrums // MulSpectrums
CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT) CV_FLAGS(DftFlags, 0, DFT_INVERSE, DFT_SCALE, DFT_ROWS, DFT_COMPLEX_OUTPUT, DFT_REAL_OUTPUT)
PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags) PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
{ {

2
modules/gpu/test/test_optflow.cpp
Unescape View File

@ -333,7 +333,7 @@ namespace
{ {
IMPLEMENT_PARAM_CLASS(PyrScale, double) IMPLEMENT_PARAM_CLASS(PyrScale, double)
IMPLEMENT_PARAM_CLASS(PolyN, int) IMPLEMENT_PARAM_CLASS(PolyN, int)
CV_FLAGS(FarnebackOptFlowFlags, 0, cv::OPTFLOW_FARNEBACK_GAUSSIAN) CV_FLAGS(FarnebackOptFlowFlags, 0, OPTFLOW_FARNEBACK_GAUSSIAN)
IMPLEMENT_PARAM_CLASS(UseInitFlow, bool) IMPLEMENT_PARAM_CLASS(UseInitFlow, bool)
} }

5
modules/gpu/test/test_threshold.cpp
Unescape View File

@ -46,8 +46,7 @@
using namespace cvtest; using namespace cvtest;
CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV) CV_ENUM(ThreshOp, THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV)
#define ALL_THRESH_OPS testing::Values(ThreshOp(cv::THRESH_BINARY), ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC), ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))
PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, UseRoi) PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, UseRoi)
{ {
@ -88,7 +87,7 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine(
ALL_DEVICES, ALL_DEVICES,
DIFFERENT_SIZES, DIFFERENT_SIZES,
testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)), testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)),
ALL_THRESH_OPS, ThreshOp::all(),
WHOLE_SUBMAT)); WHOLE_SUBMAT));
#endif // HAVE_CUDA #endif // HAVE_CUDA

2
modules/imgproc/perf/perf_bilateral.cpp
Unescape View File

@ -15,7 +15,7 @@ PERF_TEST_P( TestBilateralFilter, BilateralFilter,
Combine( Combine(
Values( szVGA, sz1080p ), // image size Values( szVGA, sz1080p ), // image size
Values( 3, 5 ), // d Values( 3, 5 ), // d
ValuesIn( Mat_Type::all() ) // image type Mat_Type::all() // image type
) )
) )
{ {

14
modules/imgproc/perf/perf_blur.cpp
Unescape View File

@ -48,7 +48,7 @@ PERF_TEST_P(Size_MatType_BorderType3x3, gaussianBlur3x3,
testing::Combine( testing::Combine(
testing::Values(szODD, szQVGA, szVGA, sz720p), testing::Values(szODD, szQVGA, szVGA, sz720p),
testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1), testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
testing::ValuesIn(BorderType3x3::all()) BorderType3x3::all()
) )
) )
{ {
@ -70,7 +70,7 @@ PERF_TEST_P(Size_MatType_BorderType3x3, blur3x3,
testing::Combine( testing::Combine(
testing::Values(szODD, szQVGA, szVGA, sz720p), testing::Values(szODD, szQVGA, szVGA, sz720p),
testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1), testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
testing::ValuesIn(BorderType3x3::all()) BorderType3x3::all()
) )
) )
{ {
@ -92,7 +92,7 @@ PERF_TEST_P(Size_MatType_BorderType, blur16x16,
testing::Combine( testing::Combine(
testing::Values(szVGA, sz720p), testing::Values(szVGA, sz720p),
testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1), testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
testing::ValuesIn(BorderType::all()) BorderType::all()
) )
) )
{ {
@ -114,7 +114,7 @@ PERF_TEST_P(Size_MatType_BorderType3x3, box3x3,
testing::Combine( testing::Combine(
testing::Values(szODD, szQVGA, szVGA, sz720p), testing::Values(szODD, szQVGA, szVGA, sz720p),
testing::Values(CV_8UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_32FC3), testing::Values(CV_8UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_32FC3),
testing::ValuesIn(BorderType3x3::all()) BorderType3x3::all()
) )
) )
{ {
@ -136,7 +136,7 @@ PERF_TEST_P(Size_MatType_BorderType3x3, box3x3_inplace,
testing::Combine( testing::Combine(
testing::Values(szODD, szQVGA, szVGA, sz720p), testing::Values(szODD, szQVGA, szVGA, sz720p),
testing::Values(CV_8UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_32FC3), testing::Values(CV_8UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_32FC3),
testing::ValuesIn(BorderType3x3::all()) BorderType3x3::all()
) )
) )
{ {
@ -164,7 +164,7 @@ PERF_TEST_P(Size_MatType_BorderType, gaussianBlur5x5,
testing::Combine( testing::Combine(
testing::Values(szODD, szQVGA, szVGA, sz720p), testing::Values(szODD, szQVGA, szVGA, sz720p),
testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1), testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
testing::ValuesIn(BorderType::all()) BorderType::all()
) )
) )
{ {
@ -186,7 +186,7 @@ PERF_TEST_P(Size_MatType_BorderType, blur5x5,
testing::Combine( testing::Combine(
testing::Values(szVGA, sz720p), testing::Values(szVGA, sz720p),
testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1, CV_32FC3), testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1, CV_32FC3),
testing::ValuesIn(BorderType::all()) BorderType::all()
) )
) )
{ {

2
modules/imgproc/perf/perf_cornerEigenValsAndVecs.cpp
Unescape View File

@ -16,7 +16,7 @@ PERF_TEST_P(Img_BlockSize_ApertureSize_BorderType, cornerEigenValsAndVecs,
testing::Values( "stitching/a1.png", "cv/shared/pic5.png"), testing::Values( "stitching/a1.png", "cv/shared/pic5.png"),
testing::Values( 3, 5 ), testing::Values( 3, 5 ),
testing::Values( 3, 5 ), testing::Values( 3, 5 ),
testing::ValuesIn(BorderType::all()) BorderType::all()
) )
) )
{ {

2
modules/imgproc/perf/perf_cornerHarris.cpp
Unescape View File

@ -17,7 +17,7 @@ PERF_TEST_P(Img_BlockSize_ApertureSize_k_BorderType, cornerHarris,
testing::Values( 3, 5 ), testing::Values( 3, 5 ),
testing::Values( 3, 5 ), testing::Values( 3, 5 ),
testing::Values( 0.04, 0.1 ), testing::Values( 0.04, 0.1 ),
testing::ValuesIn(BorderType::all()) BorderType::all()
) )
) )
{ {

8
modules/imgproc/perf/perf_cvt_color.cpp
Unescape View File

@ -243,7 +243,7 @@ typedef perf::TestBaseWithParam<Size_CvtMode_t> Size_CvtMode;
PERF_TEST_P(Size_CvtMode, cvtColor8u, PERF_TEST_P(Size_CvtMode, cvtColor8u,
testing::Combine( testing::Combine(
testing::Values(::perf::szODD, ::perf::szVGA, ::perf::sz1080p), testing::Values(::perf::szODD, ::perf::szVGA, ::perf::sz1080p),
testing::ValuesIn(CvtMode::all()) CvtMode::all()
) )
) )
{ {
@ -269,7 +269,7 @@ typedef perf::TestBaseWithParam<Size_CvtMode_Bayer_t> Size_CvtMode_Bayer;
PERF_TEST_P(Size_CvtMode_Bayer, cvtColorBayer8u, PERF_TEST_P(Size_CvtMode_Bayer, cvtColorBayer8u,
testing::Combine( testing::Combine(
testing::Values(::perf::szODD, ::perf::szVGA), testing::Values(::perf::szODD, ::perf::szVGA),
testing::ValuesIn(CvtModeBayer::all()) CvtModeBayer::all()
) )
) )
{ {
@ -295,7 +295,7 @@ typedef perf::TestBaseWithParam<Size_CvtMode2_t> Size_CvtMode2;
PERF_TEST_P(Size_CvtMode2, cvtColorYUV420, PERF_TEST_P(Size_CvtMode2, cvtColorYUV420,
testing::Combine( testing::Combine(
testing::Values(szVGA, sz1080p, Size(130, 60)), testing::Values(szVGA, sz1080p, Size(130, 60)),
testing::ValuesIn(CvtMode2::all()) CvtMode2::all()
) )
) )
{ {
@ -320,7 +320,7 @@ typedef perf::TestBaseWithParam<Size_CvtMode3_t> Size_CvtMode3;
PERF_TEST_P(Size_CvtMode3, cvtColorRGB2YUV420p, PERF_TEST_P(Size_CvtMode3, cvtColorRGB2YUV420p,
testing::Combine( testing::Combine(
testing::Values(szVGA, sz720p, sz1080p, Size(130, 60)), testing::Values(szVGA, sz720p, sz1080p, Size(130, 60)),
testing::ValuesIn(CvtMode3::all()) CvtMode3::all()
) )
) )
{ {

2
modules/imgproc/perf/perf_filter2d.cpp
Unescape View File

@ -17,7 +17,7 @@ PERF_TEST_P( TestFilter2d, Filter2d,
Combine( Combine(
Values( Size(320, 240), sz1080p ), Values( Size(320, 240), sz1080p ),
Values( 3, 5 ), Values( 3, 5 ),
ValuesIn( BorderMode::all() ) BorderMode::all()
) )
) )
{ {

4
modules/imgproc/perf/perf_matchTemplate.cpp
Unescape View File

@ -18,7 +18,7 @@ PERF_TEST_P(ImgSize_TmplSize_Method, matchTemplateSmall,
cv::Size(1024, 768), cv::Size(1280, 1024)), cv::Size(1024, 768), cv::Size(1280, 1024)),
testing::Values(cv::Size(12, 12), cv::Size(28, 9), testing::Values(cv::Size(12, 12), cv::Size(28, 9),
cv::Size(8, 30), cv::Size(16, 16)), cv::Size(8, 30), cv::Size(16, 16)),
testing::ValuesIn(MethodType::all()) MethodType::all()
) )
) )
{ {
@ -52,7 +52,7 @@ PERF_TEST_P(ImgSize_TmplSize_Method, matchTemplateBig,
testing::Combine( testing::Combine(
testing::Values(cv::Size(1280, 1024)), testing::Values(cv::Size(1280, 1024)),
testing::Values(cv::Size(1260, 1000), cv::Size(1261, 1013)), testing::Values(cv::Size(1260, 1000), cv::Size(1261, 1013)),
testing::ValuesIn(MethodType::all()) MethodType::all()
) )
) )
{ {

2
modules/imgproc/perf/perf_remap.cpp
Unescape View File

@ -16,7 +16,7 @@ PERF_TEST_P( TestRemap, Remap,
Values( szVGA, sz1080p ), Values( szVGA, sz1080p ),
Values( CV_16UC1, CV_16SC1, CV_32FC1 ), Values( CV_16UC1, CV_16SC1, CV_32FC1 ),
Values( CV_16SC2, CV_32FC1, CV_32FC2 ), Values( CV_16SC2, CV_32FC1, CV_32FC2 ),
ValuesIn( InterType::all() ) InterType::all()
) )
) )
{ {

16
modules/imgproc/perf/perf_sepfilters.cpp
Unescape View File

@ -34,7 +34,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3, sobelFilter,
testing::Values(FILTER_SRC_SIZES), testing::Values(FILTER_SRC_SIZES),
testing::Values(CV_16S, CV_32F), testing::Values(CV_16S, CV_32F),
testing::Values(make_tuple(0, 1), make_tuple(1, 0), make_tuple(1, 1), make_tuple(0, 2), make_tuple(2, 0), make_tuple(2, 2)), testing::Values(make_tuple(0, 1), make_tuple(1, 0), make_tuple(1, 1), make_tuple(0, 2), make_tuple(2, 0), make_tuple(2, 2)),
testing::ValuesIn(BorderType3x3::all()) BorderType3x3::all()
) )
) )
{ {
@ -59,7 +59,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3ROI, sobelFilter,
testing::Values(FILTER_SRC_SIZES), testing::Values(FILTER_SRC_SIZES),
testing::Values(CV_16S, CV_32F), testing::Values(CV_16S, CV_32F),
testing::Values(make_tuple(0, 1), make_tuple(1, 0), make_tuple(1, 1), make_tuple(0, 2), make_tuple(2, 0), make_tuple(2, 2)), testing::Values(make_tuple(0, 1), make_tuple(1, 0), make_tuple(1, 1), make_tuple(0, 2), make_tuple(2, 0), make_tuple(2, 2)),
testing::ValuesIn(BorderType3x3ROI::all()) BorderType3x3ROI::all()
) )
) )
{ {
@ -87,7 +87,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border5x5, sobelFilter,
testing::Values(FILTER_SRC_SIZES), testing::Values(FILTER_SRC_SIZES),
testing::Values(CV_16S, CV_32F), testing::Values(CV_16S, CV_32F),
testing::Values(make_tuple(0, 1), make_tuple(1, 0), make_tuple(1, 1), make_tuple(0, 2), make_tuple(2, 0)), testing::Values(make_tuple(0, 1), make_tuple(1, 0), make_tuple(1, 1), make_tuple(0, 2), make_tuple(2, 0)),
testing::ValuesIn(BorderType::all()) BorderType::all()
) )
) )
{ {
@ -112,7 +112,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border5x5ROI, sobelFilter,
testing::Values(FILTER_SRC_SIZES), testing::Values(FILTER_SRC_SIZES),
testing::Values(CV_16S, CV_32F), testing::Values(CV_16S, CV_32F),
testing::Values(make_tuple(0, 1), make_tuple(1, 0), make_tuple(1, 1), make_tuple(0, 2), make_tuple(2, 0)), testing::Values(make_tuple(0, 1), make_tuple(1, 0), make_tuple(1, 1), make_tuple(0, 2), make_tuple(2, 0)),
testing::ValuesIn(BorderTypeROI::all()) BorderTypeROI::all()
) )
) )
{ {
@ -142,7 +142,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3, scharrFilter,
testing::Values(FILTER_SRC_SIZES), testing::Values(FILTER_SRC_SIZES),
testing::Values(CV_16S, CV_32F), testing::Values(CV_16S, CV_32F),
testing::Values(make_tuple(0, 1), make_tuple(1, 0)), testing::Values(make_tuple(0, 1), make_tuple(1, 0)),
testing::ValuesIn(BorderType3x3::all()) BorderType3x3::all()
) )
) )
{ {
@ -167,7 +167,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3ROI, scharrFilter,
testing::Values(FILTER_SRC_SIZES), testing::Values(FILTER_SRC_SIZES),
testing::Values(CV_16S, CV_32F), testing::Values(CV_16S, CV_32F),
testing::Values(make_tuple(0, 1), make_tuple(1, 0)), testing::Values(make_tuple(0, 1), make_tuple(1, 0)),
testing::ValuesIn(BorderType3x3ROI::all()) BorderType3x3ROI::all()
) )
) )
{ {
@ -195,7 +195,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3, scharrViaSobelFilter,
testing::Values(FILTER_SRC_SIZES), testing::Values(FILTER_SRC_SIZES),
testing::Values(CV_16S, CV_32F), testing::Values(CV_16S, CV_32F),
testing::Values(make_tuple(0, 1), make_tuple(1, 0)), testing::Values(make_tuple(0, 1), make_tuple(1, 0)),
testing::ValuesIn(BorderType3x3::all()) BorderType3x3::all()
) )
) )
{ {
@ -220,7 +220,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3ROI, scharrViaSobelFilter,
testing::Values(FILTER_SRC_SIZES), testing::Values(FILTER_SRC_SIZES),
testing::Values(CV_16S, CV_32F), testing::Values(CV_16S, CV_32F),
testing::Values(make_tuple(0, 1), make_tuple(1, 0)), testing::Values(make_tuple(0, 1), make_tuple(1, 0)),
testing::ValuesIn(BorderType3x3ROI::all()) BorderType3x3ROI::all()
) )
) )
{ {

6
modules/imgproc/perf/perf_threshold.cpp
Unescape View File

@ -15,7 +15,7 @@ PERF_TEST_P(Size_MatType_ThreshType, threshold,
testing::Combine( testing::Combine(
testing::Values(TYPICAL_MAT_SIZES), testing::Values(TYPICAL_MAT_SIZES),
testing::Values(CV_8UC1, CV_16SC1), testing::Values(CV_8UC1, CV_16SC1),
testing::ValuesIn(ThreshType::all()) ThreshType::all()
) )
) )
{ {
@ -65,8 +65,8 @@ typedef perf::TestBaseWithParam<Size_AdaptThreshType_AdaptThreshMethod_BlockSize
PERF_TEST_P(Size_AdaptThreshType_AdaptThreshMethod_BlockSize, adaptiveThreshold, PERF_TEST_P(Size_AdaptThreshType_AdaptThreshMethod_BlockSize, adaptiveThreshold,
testing::Combine( testing::Combine(
testing::Values(TYPICAL_MAT_SIZES), testing::Values(TYPICAL_MAT_SIZES),
testing::ValuesIn(AdaptThreshType::all()), AdaptThreshType::all(),
testing::ValuesIn(AdaptThreshMethod::all()), AdaptThreshMethod::all(),
testing::Values(3, 5) testing::Values(3, 5)
) )
) )

18
modules/imgproc/perf/perf_warp.cpp
Unescape View File

@ -23,8 +23,8 @@ void update_map(const Mat& src, Mat& map_x, Mat& map_y, const int remapMode );
PERF_TEST_P( TestWarpAffine, WarpAffine, PERF_TEST_P( TestWarpAffine, WarpAffine,
Combine( Combine(
Values( szVGA, sz720p, sz1080p ), Values( szVGA, sz720p, sz1080p ),
ValuesIn( InterType::all() ), InterType::all(),
ValuesIn( BorderMode::all() ) BorderMode::all()
) )
) )
{ {
@ -53,8 +53,8 @@ PERF_TEST_P( TestWarpAffine, WarpAffine,
PERF_TEST_P( TestWarpPerspective, WarpPerspective, PERF_TEST_P( TestWarpPerspective, WarpPerspective,
Combine( Combine(
Values( szVGA, sz720p, sz1080p ), Values( szVGA, sz720p, sz1080p ),
ValuesIn( InterType::all() ), InterType::all(),
ValuesIn( BorderMode::all() ) BorderMode::all()
) )
) )
{ {
@ -91,8 +91,8 @@ PERF_TEST_P( TestWarpPerspective, WarpPerspective,
PERF_TEST_P( TestWarpPerspectiveNear_t, WarpPerspectiveNear, PERF_TEST_P( TestWarpPerspectiveNear_t, WarpPerspectiveNear,
Combine( Combine(
Values( Size(640,480), Size(1920,1080), Size(2592,1944) ), Values( Size(640,480), Size(1920,1080), Size(2592,1944) ),
ValuesIn( InterType::all() ), InterType::all(),
ValuesIn( BorderMode::all() ), BorderMode::all(),
Values( CV_8UC1, CV_8UC4 ) Values( CV_8UC1, CV_8UC4 )
) )
) )
@ -138,9 +138,9 @@ PERF_TEST_P( TestRemap, remap,
Combine( Combine(
Values( TYPICAL_MAT_TYPES ), Values( TYPICAL_MAT_TYPES ),
Values( szVGA, sz720p, sz1080p ), Values( szVGA, sz720p, sz1080p ),
ValuesIn( InterType::all() ), InterType::all(),
ValuesIn( BorderMode::all() ), BorderMode::all(),
ValuesIn( RemapMode::all() ) RemapMode::all()
) )
) )
{ {

6
modules/ocl/test/test_brute_force_matcher.cpp
Unescape View File

@ -45,9 +45,9 @@ namespace
{ {
///////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////
// BruteForceMatcher // BruteForceMatcher
CV_ENUM(DistType, cv::ocl::BruteForceMatcher_OCL_base::L1Dist,\ CV_ENUM(DistType, BruteForceMatcher_OCL_base::L1Dist,
cv::ocl::BruteForceMatcher_OCL_base::L2Dist,\ BruteForceMatcher_OCL_base::L2Dist,
cv::ocl::BruteForceMatcher_OCL_base::HammingDist) BruteForceMatcher_OCL_base::HammingDist)
IMPLEMENT_PARAM_CLASS(DescriptorSize, int) IMPLEMENT_PARAM_CLASS(DescriptorSize, int)
PARAM_TEST_CASE(BruteForceMatcher, DistType, DescriptorSize) PARAM_TEST_CASE(BruteForceMatcher, DistType, DescriptorSize)
{ {

31
modules/ocl/test/utility.hpp
Unescape View File

@ -130,30 +130,21 @@ private:
void PrintTo(const Inverse &useRoi, std::ostream *os); void PrintTo(const Inverse &useRoi, std::ostream *os);
CV_ENUM(CmpCode, cv::CMP_EQ, cv::CMP_GT, cv::CMP_GE, cv::CMP_LT, cv::CMP_LE, cv::CMP_NE)
CV_ENUM(NormCode, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2, cv::NORM_TYPE_MASK, cv::NORM_RELATIVE, cv::NORM_MINMAX)
enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1}; enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1};
CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y) CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)
CV_ENUM(CmpCode, CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE)
CV_ENUM(NormCode, NORM_INF, NORM_L1, NORM_L2, NORM_TYPE_MASK, NORM_RELATIVE, NORM_MINMAX)
CV_ENUM(ReduceOp, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN) CV_ENUM(ReduceOp, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
CV_ENUM(MorphOp, MORPH_OPEN, MORPH_CLOSE, MORPH_GRADIENT, MORPH_TOPHAT, MORPH_BLACKHAT)
CV_FLAGS(GemmFlags, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T); CV_ENUM(ThreshOp, THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV)
CV_ENUM(Interpolation, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC)
CV_ENUM(MorphOp, cv::MORPH_OPEN, cv::MORPH_CLOSE, cv::MORPH_GRADIENT, cv::MORPH_TOPHAT, cv::MORPH_BLACKHAT) CV_ENUM(Border, BORDER_REFLECT101, BORDER_REPLICATE, BORDER_CONSTANT, BORDER_REFLECT, BORDER_WRAP)
CV_ENUM(TemplateMethod, TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED)
CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)
CV_FLAGS(GemmFlags, GEMM_1_T, GEMM_2_T, GEMM_3_T);
CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC) CV_FLAGS(WarpFlags, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, WARP_INVERSE_MAP)
CV_FLAGS(DftFlags, DFT_INVERSE, DFT_SCALE, DFT_ROWS, DFT_COMPLEX_OUTPUT, DFT_REAL_OUTPUT)
CV_ENUM(Border, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP)
CV_FLAGS(WarpFlags, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::WARP_INVERSE_MAP)
CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)
CV_FLAGS(DftFlags, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)
void run_perf_test(); void run_perf_test();

2
modules/photo/perf/perf_inpaint.cpp
Unescape View File

@ -14,7 +14,7 @@ typedef perf::TestBaseWithParam<InpaintArea_InpaintingMethod_t> InpaintArea_Inpa
PERF_TEST_P(InpaintArea_InpaintingMethod, inpaint, PERF_TEST_P(InpaintArea_InpaintingMethod, inpaint,
testing::Combine( testing::Combine(
testing::Values(::perf::szSmall24, ::perf::szSmall32, ::perf::szSmall64), testing::Values(::perf::szSmall24, ::perf::szSmall32, ::perf::szSmall64),
testing::ValuesIn(InpaintingMethod::all()) InpaintingMethod::all()
) )
) )
{ {

12
modules/ts/include/opencv2/ts/gpu_perf.hpp
Unescape View File

@ -50,16 +50,16 @@
namespace perf namespace perf
{ {
CV_ENUM(BorderMode, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP) #define ALL_BORDER_MODES BorderMode::all()
#define ALL_BORDER_MODES testing::ValuesIn(BorderMode::all()) #define ALL_INTERPOLATIONS Interpolation::all()
CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::INTER_AREA) CV_ENUM(BorderMode, BORDER_REFLECT101, BORDER_REPLICATE, BORDER_CONSTANT, BORDER_REFLECT, BORDER_WRAP)
#define ALL_INTERPOLATIONS testing::ValuesIn(Interpolation::all()) CV_ENUM(Interpolation, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_AREA)
CV_ENUM(NormType, NORM_INF, NORM_L1, NORM_L2, NORM_HAMMING, NORM_MINMAX)
CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2, cv::NORM_HAMMING, cv::NORM_MINMAX)
enum { Gray = 1, TwoChannel = 2, BGR = 3, BGRA = 4 }; enum { Gray = 1, TwoChannel = 2, BGR = 3, BGRA = 4 };
CV_ENUM(MatCn, Gray, TwoChannel, BGR, BGRA) CV_ENUM(MatCn, Gray, TwoChannel, BGR, BGRA)
#define GPU_CHANNELS_1_3_4 testing::Values(MatCn(Gray), MatCn(BGR), MatCn(BGRA)) #define GPU_CHANNELS_1_3_4 testing::Values(MatCn(Gray), MatCn(BGR), MatCn(BGRA))
#define GPU_CHANNELS_1_3 testing::Values(MatCn(Gray), MatCn(BGR)) #define GPU_CHANNELS_1_3 testing::Values(MatCn(Gray), MatCn(BGR))

8
modules/ts/include/opencv2/ts/gpu_test.hpp
Unescape View File

@ -313,14 +313,14 @@ namespace cvtest
// Flags and enums // Flags and enums
CV_ENUM(NormCode, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2, cv::NORM_TYPE_MASK, cv::NORM_RELATIVE, cv::NORM_MINMAX) CV_ENUM(NormCode, NORM_INF, NORM_L1, NORM_L2, NORM_TYPE_MASK, NORM_RELATIVE, NORM_MINMAX)
CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::INTER_AREA) CV_ENUM(Interpolation, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_AREA)
CV_ENUM(BorderType, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP) CV_ENUM(BorderType, BORDER_REFLECT101, BORDER_REPLICATE, BORDER_CONSTANT, BORDER_REFLECT, BORDER_WRAP)
#define ALL_BORDER_TYPES testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)) #define ALL_BORDER_TYPES testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP))
CV_FLAGS(WarpFlags, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::WARP_INVERSE_MAP) CV_FLAGS(WarpFlags, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, WARP_INVERSE_MAP)
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// Features2D // Features2D

122
modules/ts/include/opencv2/ts/ts_perf.hpp
Unescape View File

@ -2,6 +2,7 @@
#define __OPENCV_TS_PERF_HPP__ #define __OPENCV_TS_PERF_HPP__
#include "opencv2/core/core.hpp" #include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/features2d/features2d.hpp" #include "opencv2/features2d/features2d.hpp"
#include "ts_gtest.h" #include "ts_gtest.h"
@ -26,6 +27,9 @@
# endif # endif
#endif #endif
// declare major namespaces to avoid errors on unknown namespace
namespace cv { namespace gpu {} namespace ocl {} }
namespace perf namespace perf
{ {
class TestBase; class TestBase;
@ -92,66 +96,64 @@ private:
* CV_ENUM and CV_FLAGS - macro to create printable wrappers for defines and enums * * CV_ENUM and CV_FLAGS - macro to create printable wrappers for defines and enums *
\*****************************************************************************************/ \*****************************************************************************************/
#define CV_ENUM(class_name, ...) \ #define CV_ENUM(class_name, ...) \
namespace { class CV_EXPORTS class_name {\ namespace { \
public:\ struct class_name { \
class_name(int val = 0) : _val(val) {}\ class_name(int val = 0) : val_(val) {} \
operator int() const {return _val;}\ operator int() const { return val_; } \
void PrintTo(std::ostream* os) const {\ void PrintTo(std::ostream* os) const { \
const int vals[] = {__VA_ARGS__};\ using namespace cv;using namespace cv::gpu; using namespace cv::ocl; \
const char* svals = #__VA_ARGS__;\ const int vals[] = { __VA_ARGS__ }; \
for(int i = 0, pos = 0; i < (int)(sizeof(vals)/sizeof(int)); ++i){\ const char* svals = #__VA_ARGS__; \
while(isspace(svals[pos]) || svals[pos] == ',') ++pos;\ for(int i = 0, pos = 0; i < (int)(sizeof(vals)/sizeof(int)); ++i) { \
int start = pos;\ while(isspace(svals[pos]) || svals[pos] == ',') ++pos; \
while(!(isspace(svals[pos]) || svals[pos] == ',' || svals[pos] == 0)) ++pos;\ int start = pos; \
if (_val == vals[i]) {\ while(!(isspace(svals[pos]) || svals[pos] == ',' || svals[pos] == 0)) \
*os << std::string(svals + start, svals + pos);\ ++pos; \
return;\ if (val_ == vals[i]) { \
}\ *os << std::string(svals + start, svals + pos); \
}\ return; \
*os << "UNKNOWN";\ } \
}\ } \
struct Container{\ *os << "UNKNOWN"; \
typedef class_name value_type;\ } \
Container(class_name* first, size_t len): _begin(first), _end(first+len){}\ static ::testing::internal::ParamGenerator<class_name> all() { \
const class_name* begin() const {return _begin;}\ using namespace cv;using namespace cv::gpu; using namespace cv::ocl; \
const class_name* end() const {return _end;}\ static class_name vals[] = { __VA_ARGS__ }; \
private: class_name *_begin, *_end;\ return ::testing::ValuesIn(vals); \
};\ } \
static Container all(){\ private: int val_; \
static int vals[] = {__VA_ARGS__};\ }; \
return Container((class_name*)vals, sizeof(vals)/sizeof(vals[0]));\ inline void PrintTo(const class_name& t, std::ostream* os) { t.PrintTo(os); } }
}\
private: int _val;\ #define CV_FLAGS(class_name, ...) \
};\ namespace { \
inline void PrintTo(const class_name& t, std::ostream* os) { t.PrintTo(os); } } struct class_name { \
class_name(int val = 0) : val_(val) {} \
#define CV_FLAGS(class_name, ...) \ operator int() const { return val_; } \
class CV_EXPORTS class_name {\ void PrintTo(std::ostream* os) const { \
public:\ using namespace cv;using namespace cv::gpu; using namespace cv::ocl; \
class_name(int val = 0) : _val(val) {}\ const int vals[] = { __VA_ARGS__ }; \
operator int() const {return _val;}\ const char* svals = #__VA_ARGS__; \
void PrintTo(std::ostream* os) const {\ int value = val_; \
const int vals[] = {__VA_ARGS__};\ bool first = true; \
const char* svals = #__VA_ARGS__;\ for(int i = 0, pos = 0; i < (int)(sizeof(vals)/sizeof(int)); ++i) { \
int value = _val;\ while(isspace(svals[pos]) || svals[pos] == ',') ++pos; \
bool first = true;\ int start = pos; \
for(int i = 0, pos = 0; i < (int)(sizeof(vals)/sizeof(int)); ++i){\ while(!(isspace(svals[pos]) || svals[pos] == ',' || svals[pos] == 0)) \
while(isspace(svals[pos]) || svals[pos] == ',') ++pos;\ ++pos; \
int start = pos;\ if ((value & vals[i]) == vals[i]) { \
while(!(isspace(svals[pos]) || svals[pos] == ',' || svals[pos] == 0)) ++pos;\ value &= ~vals[i]; \
if ((value & vals[i]) == vals[i]) {\ if (first) first = false; else *os << "|"; \
value &= ~vals[i]; \ *os << std::string(svals + start, svals + pos); \
if (first) first = false; else *os << "|"; \ if (!value) return; \
*os << std::string(svals + start, svals + pos);\ } \
if (!value) return;\ } \
}\ if (first) *os << "UNKNOWN"; \
}\ } \
if (first) *os << "UNKNOWN";\ private: int val_; \
}\ }; \
private: int _val;\ inline void PrintTo(const class_name& t, std::ostream* os) { t.PrintTo(os); } }
};\
inline void PrintTo(const class_name& t, std::ostream* os) { t.PrintTo(os); }
CV_ENUM(MatDepth, CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F, CV_USRTYPE1) CV_ENUM(MatDepth, CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F, CV_USRTYPE1)

2
modules/video/perf/perf_optflowpyrlk.cpp
Unescape View File

@ -185,7 +185,7 @@ PERF_TEST_P(Path_Win_Deriv_Border_Reuse, OpticalFlowPyrLK_pyr, testing::Combine(
testing::Values<std::string>("cv/optflow/frames/720p_01.png"), testing::Values<std::string>("cv/optflow/frames/720p_01.png"),
testing::Values(7, 11), testing::Values(7, 11),
testing::Bool(), testing::Bool(),
testing::ValuesIn(PyrBorderMode::all()), PyrBorderMode::all(),
testing::Bool() testing::Bool()
) )
) )

Write Preview
Loading…
Cancel
Save