Merge branch 'gpu-tests'

cmake/OpenCVModule.cmake

@@ -509,8 +509,6 @@ endmacro()
 macro(ocv_add_precompiled_headers the_target)
   if("${the_target}" MATCHES "^opencv_test_.*$")
     SET(pch_path "test/test_")
-  elseif("${the_target}" MATCHES "opencv_perf_gpu_cpu")
-    SET(pch_path "perf_cpu/perf_cpu_")
   elseif("${the_target}" MATCHES "^opencv_perf_.*$")
     SET(pch_path "perf/perf_")
   else()

modules/gpu/CMakeLists.txt

@@ -111,43 +111,3 @@ ocv_add_accuracy_tests(FILES "Include" ${test_hdrs}
                        FILES "Src" ${test_srcs}
                        ${nvidia})
 ocv_add_perf_tests()
-
-
-
-set(perf_cpu_path "${CMAKE_CURRENT_SOURCE_DIR}/perf_cpu")
-if(BUILD_PERF_TESTS AND EXISTS "${perf_cpu_path}")
-    # opencv_highgui is required for imread/imwrite
-    set(perf_deps ${the_module} opencv_ts opencv_highgui opencv_imgproc opencv_calib3d opencv_objdetect opencv_video opencv_nonfree)
-    ocv_check_dependencies(${perf_deps})
-
-    if(OCV_DEPENDENCIES_FOUND)
-      set(the_target "opencv_perf_gpu_cpu")
-
-      ocv_module_include_directories(${perf_deps} "${perf_cpu_path}")
-
-      if(NOT OPENCV_PERF_${the_module}_CPU_SOURCES)
-        file(GLOB perf_srcs "${perf_cpu_path}/*.cpp")
-        file(GLOB perf_hdrs "${perf_cpu_path}/*.hpp" "${perf_cpu_path}/*.h")
-        source_group("Src" FILES ${perf_srcs})
-        source_group("Include" FILES ${perf_hdrs})
-        set(OPENCV_PERF_${the_module}_CPU_SOURCES ${perf_srcs} ${perf_hdrs})
-      endif()
-
-      add_executable(${the_target} ${OPENCV_PERF_${the_module}_CPU_SOURCES})
-      target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${perf_deps} ${OPENCV_LINKER_LIBS})
-
-      # Additional target properties
-      set_target_properties(${the_target} PROPERTIES
-        DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-        RUNTIME_OUTPUT_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}"
-      )
-
-      if(ENABLE_SOLUTION_FOLDERS)
-        set_target_properties(${the_target} PROPERTIES FOLDER "tests performance")
-      endif()
-
-      ocv_add_precompiled_headers(${the_target})
-    else(OCV_DEPENDENCIES_FOUND)
-      #TODO: warn about unsatisfied dependencies
-    endif(OCV_DEPENDENCIES_FOUND)
-  endif()

modules/gpu/misc/mark_nvidia.py

 import sys, re
 
 spaces = '[\s]*'
-symbols = '[\s\w\d,.=:|]*'
+symbols = '[\s\w\d,.:|]*'
 
 def pattern1(prefix, test):
-    return re.compile(spaces + 'perf::' + prefix + '/' + test + '::' + '\(' + symbols + '\)' + spaces)
+    return re.compile(spaces + prefix + '_' + test + '::' + symbols + '::' + '\(' + symbols + '\)' + spaces)
 
-def pattern2(prefix, test, cvtype):
-    return re.compile(spaces + 'perf::' + prefix + '/' + test + '::' + '\(' + symbols + cvtype + symbols + '\)' + spaces)
+def pattern2(prefix, test, param1):
+    return re.compile(spaces + prefix + '_' + test + '::' + symbols + '::' + '\(' + symbols + param1 + symbols + '\)' + spaces)
 
-def pattern3(prefix, test, cvtype, param1):
-    return re.compile(spaces + 'perf::' + prefix + '/' + test + '::' + '\(' + symbols + cvtype + symbols + param1 + symbols + '\)' + spaces)
+def pattern3(prefix, test, param1, param2):
+    return re.compile(spaces + prefix + '_' + test + '::' + symbols + '::' + '\(' + symbols + param1 + symbols + param2 + symbols + '\)' + spaces)
 
-def pattern4(prefix, test, cvtype, param1, param2):
-    return re.compile(spaces + 'perf::' + prefix + '/' + test + '::' + '\(' + symbols + cvtype + symbols + param1 + symbols + param2 + symbols + '\)' + spaces)
+def pattern4(prefix, test, param1, param2, param3):
+    return re.compile(spaces + prefix + '_' + test + '::' + symbols + '::' + '\(' + symbols + param1 + symbols + param2 + symbols + param3 + symbols + '\)' + spaces)
+
+def pattern5(prefix, test, param1, param2, param3, param5):
+    return re.compile(spaces + prefix + '_' + test + '::' + symbols + '::' + '\(' + symbols + param1 + symbols + param2 + symbols + param3 + symbols + param4 + symbols + '\)' + spaces)
 
 npp_patterns = [
     ##############################################################
     # Core
-    
-    # Core/Add_Mat (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'Add_Mat', '8U'),
-    pattern2('Core', 'Add_Mat', '16U'),
-    pattern2('Core', 'Add_Mat', '32F'),
-    
-    # Core/Add_Scalar (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'Add_Scalar', '8U'),
-    pattern2('Core', 'Add_Scalar', '16U'),
-    pattern2('Core', 'Add_Scalar', '32F'),
-    
-    # Core/Subtract_Mat (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'Subtract_Mat', '8U'),
-    pattern2('Core', 'Subtract_Mat', '16U'),
-    pattern2('Core', 'Subtract_Mat', '32F'),
-    
-    # Core/Subtract_Scalar (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'Subtract_Scalar', '8U'),
-    pattern2('Core', 'Subtract_Scalar', '16U'),
-    pattern2('Core', 'Subtract_Scalar', '32F'),
-    
-    # Core/Multiply_Mat (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'Multiply_Mat', '8U'),
-    pattern2('Core', 'Multiply_Mat', '16U'),
-    pattern2('Core', 'Multiply_Mat', '32F'),
-    
-    # Core/Multiply_Scalar (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'Multiply_Scalar', '8U'),
-    pattern2('Core', 'Multiply_Scalar', '16U'),
-    pattern2('Core', 'Multiply_Scalar', '32F'),
-    
-    # Core/Divide_Mat (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'Divide_Mat', '8U'),
-    pattern2('Core', 'Divide_Mat', '16U'),
-    pattern2('Core', 'Divide_Mat', '32F'),
-    
-    # Core/Divide_Scalar (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'Divide_Scalar', '8U'),
-    pattern2('Core', 'Divide_Scalar', '16U'),
-    pattern2('Core', 'Divide_Scalar', '32F'),
-    
-    # Core/AbsDiff_Mat (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'AbsDiff_Mat', '8U'),
-    pattern2('Core', 'AbsDiff_Mat', '16U'),
-    pattern2('Core', 'AbsDiff_Mat', '32F'),
-    
-    # Core/AbsDiff_Scalar (CV_8U | CV_16U | CV_32F)
-    pattern2('Core', 'AbsDiff_Scalar', '8U'),
-    pattern2('Core', 'AbsDiff_Scalar', '16U'),
-    pattern2('Core', 'AbsDiff_Scalar', '32F'),
-
-    # Core/Abs
+
+    # Core_AddMat (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'AddMat', '8U'),
+    pattern2('Core', 'AddMat', '16U'),
+    pattern2('Core', 'AddMat', '32F'),
+
+    # Core_AddScalar (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'AddScalar', '8U'),
+    pattern2('Core', 'AddScalar', '16U'),
+    pattern2('Core', 'AddScalar', '32F'),
+
+    # Core_SubtractMat (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'SubtractMat', '8U'),
+    pattern2('Core', 'SubtractMat', '16U'),
+    pattern2('Core', 'SubtractMat', '32F'),
+
+    # Core_SubtractScalar (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'SubtractScalar', '8U'),
+    pattern2('Core', 'SubtractScalar', '16U'),
+    pattern2('Core', 'SubtractScalar', '32F'),
+
+    # Core_MultiplyMat (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'MultiplyMat', '8U'),
+    pattern2('Core', 'MultiplyMat', '16U'),
+    pattern2('Core', 'MultiplyMat', '32F'),
+
+    # Core_MultiplyScalar (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'MultiplyScalar', '8U'),
+    pattern2('Core', 'MultiplyScalar', '16U'),
+    pattern2('Core', 'MultiplyScalar', '32F'),
+
+    # Core_DivideMat (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'DivideMat', '8U'),
+    pattern2('Core', 'DivideMat', '16U'),
+    pattern2('Core', 'DivideMat', '32F'),
+
+    # Core_Divide_Scalar (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'DivideScalar', '8U'),
+    pattern2('Core', 'DivideScalar', '16U'),
+    pattern2('Core', 'DivideScalar', '32F'),
+
+    # Core_AbsDiff_Mat (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'AbsDiffMat', '8U'),
+    pattern2('Core', 'AbsDiffMat', '16U'),
+    pattern2('Core', 'AbsDiffMat', '32F'),
+
+    # Core_AbsDiffScalar (CV_8U | CV_16U | CV_32F)
+    pattern2('Core', 'AbsDiffScalar', '8U'),
+    pattern2('Core', 'AbsDiffScalar', '16U'),
+    pattern2('Core', 'AbsDiffScalar', '32F'),
+
+    # Core_Abs
     pattern1('Core', 'Abs'),
 
-    # Core/Sqr
+    # Core_Sqr
     pattern1('Core', 'Sqr'),
 
-    # Core/Sqrt
+    # Core_Sqrt
     pattern1('Core', 'Sqrt'),
 
-    # Core/Log
+    # Core_Log
     pattern1('Core', 'Log'),
 
-    # Core/Exp
+    # Core_Exp
     pattern1('Core', 'Exp'),
 
-    # Core/Bitwise_And_Scalar
-    pattern1('Core', 'Bitwise_And_Scalar'),
+    # Core_BitwiseAndScalar
+    pattern1('Core', 'BitwiseAndScalar'),
 
-    # Core/Bitwise_Or_Scalar
-    pattern1('Core', 'Bitwise_Or_Scalar'),
+    # Core_BitwiseOrScalar
+    pattern1('Core', 'BitwiseOrScalar'),
 
-    # Core/Bitwise_Xor_Scalar
-    pattern1('Core', 'Bitwise_Xor_Scalar'),
+    # Core_BitwiseXorScalar
+    pattern1('Core', 'BitwiseXorScalar'),
 
-    # Core/RShift
+    # Core_RShift
     pattern1('Core', 'RShift'),
 
-    # Core/LShift
+    # Core_LShift
     pattern1('Core', 'LShift'),
 
-    # Core/Transpose
+    # Core_Transpose
     pattern1('Core', 'Transpose'),
 
-    # Core/Flip
+    # Core_Flip
     pattern1('Core', 'Flip'),
 
-    # Core/LUT_OneChannel
-    pattern1('Core', 'LUT_OneChannel'),
+    # Core_LutOneChannel
+    pattern1('Core', 'LutOneChannel'),
 
-    # Core/LUT_MultiChannel
-    pattern1('Core', 'LUT_MultiChannel'),
+    # Core_LutMultiChannel
+    pattern1('Core', 'LutMultiChannel'),
 
-    # Core/Magnitude_Complex
-    pattern1('Core', 'Magnitude_Complex'),
+    # Core_MagnitudeComplex
+    pattern1('Core', 'MagnitudeComplex'),
 
-    # Core/Magnitude_Sqr_Complex
-    pattern1('Core', 'Magnitude_Sqr_Complex'),
+    # Core_MagnitudeSqrComplex
+    pattern1('Core', 'MagnitudeSqrComplex'),
 
-    # Core/MeanStdDev
+    # Core_MeanStdDev
     pattern1('Core', 'MeanStdDev'),
 
-    # Core/NormDiff
+    # Core_NormDiff
     pattern1('Core', 'NormDiff'),
-    
+
     ##############################################################
     # Filters
 
-    # Filters/Blur
+    # Filters_Blur
     pattern1('Filters', 'Blur'),
-    
-    # Filters/Erode
+
+    # Filters_Erode
     pattern1('Filters', 'Erode'),
-    
-    # Filters/Dilate
+
+    # Filters_Dilate
     pattern1('Filters', 'Dilate'),
-    
-    # Filters/MorphologyEx
+
+    # Filters_MorphologyEx
     pattern1('Filters', 'MorphologyEx'),
-    
+
     ##############################################################
     # ImgProc
-    
-    # ImgProc/Resize (8UC1 | 8UC4, INTER_NEAREST | INTER_LINEAR)
-    pattern3('ImgProc', 'Resize', '8UC1', 'INTER_NEAREST'),
-    pattern3('ImgProc', 'Resize', '8UC4', 'INTER_NEAREST'),
-    pattern3('ImgProc', 'Resize', '8UC1', 'INTER_LINEAR'),
-    pattern3('ImgProc', 'Resize', '8UC4', 'INTER_LINEAR'),
-    
-    # ImgProc/Resize (8UC4, INTER_CUBIC)
-    pattern3('ImgProc', 'Resize', '8UC4', 'INTER_CUBIC'),
-    
-    # ImgProc/WarpAffine (8UC1 | 8UC3 | 8UC4 | 32FC1 | 32FC3 | 32FC4, INTER_NEAREST | INTER_LINEAR | INTER_CUBIC, BORDER_CONSTANT)
-    pattern4('ImgProc', 'WarpAffine', '8UC1', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '8UC1', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '8UC1', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '8UC3', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '8UC3', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '8UC3', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '8UC4', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '8UC4', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '8UC4', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '32FC1', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '32FC1', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '32FC1', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '32FC3', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '32FC3', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '32FC3', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '32FC4', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '32FC4', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpAffine', '32FC4', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    
-    # ImgProc/WarpPerspective (8UC1 | 8UC3 | 8UC4 | 32FC1 | 32FC3 | 32FC4, INTER_NEAREST | INTER_LINEAR | INTER_CUBIC, BORDER_CONSTANT)
-    pattern4('ImgProc', 'WarpPerspective', '8UC1', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '8UC1', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '8UC1', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '8UC3', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '8UC3', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '8UC3', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '8UC4', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '8UC4', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '8UC4', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '32FC1', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '32FC1', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '32FC1', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '32FC3', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '32FC3', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '32FC3', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '32FC4', 'INTER_NEAREST', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '32FC4', 'INTER_LINEAR', 'BORDER_CONSTANT'),
-    pattern4('ImgProc', 'WarpPerspective', '32FC4', 'INTER_CUBIC', 'BORDER_CONSTANT'),
-    
-    # ImgProc/CopyMakeBorder (8UC1 | 8UC4 | 32SC1 | 32FC1, BORDER_CONSTANT)
-    pattern3('ImgProc', 'CopyMakeBorder', '8UC1', 'BORDER_CONSTANT'),
-    pattern3('ImgProc', 'CopyMakeBorder', '8UC4', 'BORDER_CONSTANT'),
-    pattern3('ImgProc', 'CopyMakeBorder', '32SC1', 'BORDER_CONSTANT'),
-    pattern3('ImgProc', 'CopyMakeBorder', '32FC1', 'BORDER_CONSTANT'),
-    
-    # ImgProc/Threshold (32F, THRESH_TRUNC)
+
+    # ImgProc_Resize (8U, 1 | 4, INTER_NEAREST | INTER_LINEAR)
+    pattern4('ImgProc', 'Resize', '8U', '1', 'INTER_NEAREST'),
+    pattern4('ImgProc', 'Resize', '8U', '4', 'INTER_NEAREST'),
+    pattern4('ImgProc', 'Resize', '8U', '1', 'INTER_LINEAR'),
+    pattern4('ImgProc', 'Resize', '8U', '4', 'INTER_LINEAR'),
+
+    # ImgProc_Resize (8U, 4, INTER_CUBIC)
+    pattern4('ImgProc', 'Resize', '8U', '4', 'INTER_CUBIC'),
+
+    # ImgProc_WarpAffine (8U | 32F, INTER_NEAREST | INTER_LINEAR | INTER_CUBIC, BORDER_CONSTANT)
+    pattern4('ImgProc', 'WarpAffine', '8U' , 'INTER_NEAREST', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpAffine', '8U' , 'INTER_LINEAR', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpAffine', '8U' , 'INTER_CUBIC', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpAffine', '32F', 'INTER_NEAREST', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpAffine', '32F', 'INTER_LINEAR', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpAffine', '32F', 'INTER_CUBIC', 'BORDER_CONSTANT'),
+
+    # ImgProc_WarpPerspective (8U | 32F, INTER_NEAREST | INTER_LINEAR | INTER_CUBIC, BORDER_CONSTANT)
+    pattern4('ImgProc', 'WarpPerspective', '8U' , 'INTER_NEAREST', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpPerspective', '8U' , 'INTER_LINEAR', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpPerspective', '8U' , 'INTER_CUBIC', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpPerspective', '32F', 'INTER_NEAREST', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpPerspective', '32F', 'INTER_LINEAR', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'WarpPerspective', '32F', 'INTER_CUBIC', 'BORDER_CONSTANT'),
+
+    # ImgProc_CopyMakeBorder (8UC1 | 8UC4 | 32SC1 | 32FC1, BORDER_CONSTANT)
+    pattern4('ImgProc', 'CopyMakeBorder', '8U' , '1', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'CopyMakeBorder', '8U' , '4', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'CopyMakeBorder', '32S', '1', 'BORDER_CONSTANT'),
+    pattern4('ImgProc', 'CopyMakeBorder', '32F', '1', 'BORDER_CONSTANT'),
+
+    # ImgProc_Threshold (32F, THRESH_TRUNC)
     pattern3('ImgProc', 'Threshold', '32F', 'THRESH_TRUNC'),
 
-    # ImgProc/Integral_Sqr
-    pattern1('ImgProc', 'Integral_Sqr'),
+    # ImgProc_IntegralSqr
+    pattern1('ImgProc', 'IntegralSqr'),
 
-    # ImgProc/HistEven_OneChannel
-    pattern1('ImgProc', 'HistEven_OneChannel'),
+    # ImgProc_HistEven_OneChannel
+    pattern1('ImgProc', 'HistEvenOneChannel'),
 
-    # ImgProc/HistEven_FourChannel
-    pattern1('ImgProc', 'HistEven_FourChannel'),
+    # ImgProc_HistEven_FourChannel
+    pattern1('ImgProc', 'HistEvenFourChannel'),
 
-    # ImgProc/Rotate
+    # ImgProc_Rotate
     pattern1('ImgProc', 'Rotate'),
 
-    # ImgProc/SwapChannels
+    # ImgProc_SwapChannels
     pattern1('ImgProc', 'SwapChannels'),
 
-    # ImgProc/AlphaComp
+    # ImgProc_AlphaComp
     pattern1('ImgProc', 'AlphaComp'),
 
-    # ImgProc/ImagePyramid_build
-    pattern1('ImgProc', 'ImagePyramid_build'),
+    # ImgProc_ImagePyramidBuild
+    pattern1('ImgProc', 'ImagePyramidBuild'),
+
+    # ImgProc_ImagePyramid_getLayer
+    pattern1('ImgProc', 'ImagePyramidGetLayer'),
 
-    # ImgProc/ImagePyramid_getLayer
-    pattern1('ImgProc', 'ImagePyramid_getLayer'),
-    
     ##############################################################
     # MatOp
-    
-    # MatOp/SetTo (8UC4 | 16UC1 | 16UC4 | 32FC1 | 32FC4)
-    pattern2('MatOp', 'SetTo', '8UC4'),
-    pattern2('MatOp', 'SetTo', '16UC1'),
-    pattern2('MatOp', 'SetTo', '16UC4'),
-    pattern2('MatOp', 'SetTo', '32FC1'),
-    pattern2('MatOp', 'SetTo', '32FC4'),
-    
-    # MatOp/SetToMasked (8UC4 | 16UC1 | 16UC4 | 32FC1 | 32FC4)
-    pattern2('MatOp', 'SetToMasked', '8UC4'),
-    pattern2('MatOp', 'SetToMasked', '16UC1'),
-    pattern2('MatOp', 'SetToMasked', '16UC4'),
-    pattern2('MatOp', 'SetToMasked', '32FC1'),
-    pattern2('MatOp', 'SetToMasked', '32FC4'),
-    
-    # MatOp/CopyToMasked (8UC1 | 8UC3 |8UC4 | 16UC1 | 16UC3 | 16UC4 | 32FC1 | 32FC3 | 32FC4)
-    pattern2('MatOp', 'CopyToMasked', '8UC1'),
-    pattern2('MatOp', 'CopyToMasked', '8UC3'),
-    pattern2('MatOp', 'CopyToMasked', '8UC4'),
-    pattern2('MatOp', 'CopyToMasked', '16UC1'),
-    pattern2('MatOp', 'CopyToMasked', '16UC3'),
-    pattern2('MatOp', 'CopyToMasked', '16UC4'),
-    pattern2('MatOp', 'CopyToMasked', '32FC1'),
-    pattern2('MatOp', 'CopyToMasked', '32FC3'),
-    pattern2('MatOp', 'CopyToMasked', '32FC4'),    
+
+    # MatOp_SetTo (8UC4 | 16UC1 | 16UC4 | 32FC1 | 32FC4)
+    pattern3('MatOp', 'SetTo', '8U' , '4'),
+    pattern3('MatOp', 'SetTo', '16U', '1'),
+    pattern3('MatOp', 'SetTo', '16U', '4'),
+    pattern3('MatOp', 'SetTo', '32F', '1'),
+    pattern3('MatOp', 'SetTo', '32F', '4'),
+
+    # MatOp_SetToMasked (8UC4 | 16UC1 | 16UC4 | 32FC1 | 32FC4)
+    pattern3('MatOp', 'SetToMasked', '8U' , '4'),
+    pattern3('MatOp', 'SetToMasked', '16U', '1'),
+    pattern3('MatOp', 'SetToMasked', '16U', '4'),
+    pattern3('MatOp', 'SetToMasked', '32F', '1'),
+    pattern3('MatOp', 'SetToMasked', '32F', '4'),
+
+    # MatOp_CopyToMasked (8UC1 | 8UC3 |8UC4 | 16UC1 | 16UC3 | 16UC4 | 32FC1 | 32FC3 | 32FC4)
+    pattern3('MatOp', 'CopyToMasked', '8U' , '1'),
+    pattern3('MatOp', 'CopyToMasked', '8U' , '3'),
+    pattern3('MatOp', 'CopyToMasked', '8U' , '4'),
+    pattern3('MatOp', 'CopyToMasked', '16U', '1'),
+    pattern3('MatOp', 'CopyToMasked', '16U', '3'),
+    pattern3('MatOp', 'CopyToMasked', '16U', '4'),
+    pattern3('MatOp', 'CopyToMasked', '32F', '1'),
+    pattern3('MatOp', 'CopyToMasked', '32F', '3'),
+    pattern3('MatOp', 'CopyToMasked', '32F', '4'),
 ]
 
 cublasPattern = pattern1('Core', 'GEMM')
@@ -260,7 +239,7 @@ if __name__ == "__main__":
     inputFile = open(sys.argv[1], 'r')
     lines = inputFile.readlines()
     inputFile.close()
-    
+
 
     for i in range(len(lines)):
         if cublasPattern.match(lines[i]):

modules/gpu/perf/main.cpp

+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+using namespace cvtest;
+using namespace testing;
+
+void printOsInfo()
+{
+#if defined _WIN32
+#   if defined _WIN64
+        cout << "OS: Windows x64 \n" << endl;
+#   else
+        cout << "OS: Windows x32 \n" << endl;
+#   endif
+#elif defined linux
+#   if defined _LP64
+        cout << "OS: Linux x64 \n" << endl;
+#   else
+        cout << "OS: Linux x32 \n" << endl;
+#   endif
+#elif defined __APPLE__
+#   if defined _LP64
+        cout << "OS: Apple x64 \n" << endl;
+#   else
+        cout << "OS: Apple x32 \n" << endl;
+#   endif
+#endif
+}
+
+void printCudaInfo()
+{
+#ifndef HAVE_CUDA
+    cout << "OpenCV was built without CUDA support \n" << endl;
+#else
+    int driver;
+    cudaDriverGetVersion(&driver);
+
+    cout << "CUDA Driver  version: " << driver << '\n';
+    cout << "CUDA Runtime version: " << CUDART_VERSION << '\n';
+
+    cout << endl;
+
+    cout << "GPU module was compiled for the following GPU archs:" << endl;
+    cout << "    BIN: " << CUDA_ARCH_BIN << '\n';
+    cout << "    PTX: " << CUDA_ARCH_PTX << '\n';
+
+    cout << endl;
+
+    int deviceCount = getCudaEnabledDeviceCount();
+    cout << "CUDA device count: " << deviceCount << '\n';
+
+    cout << endl;
+
+    for (int i = 0; i < deviceCount; ++i)
+    {
+        DeviceInfo info(i);
+
+        cout << "Device [" << i << "] \n";
+        cout << "\t Name: " << info.name() << '\n';
+        cout << "\t Compute capability: " << info.majorVersion() << '.' << info.minorVersion()<< '\n';
+        cout << "\t Multi Processor Count: " << info.multiProcessorCount() << '\n';
+        cout << "\t Total memory: " << static_cast<int>(static_cast<int>(info.totalMemory() / 1024.0) / 1024.0) << " Mb \n";
+        cout << "\t Free  memory: " << static_cast<int>(static_cast<int>(info.freeMemory() / 1024.0) / 1024.0) << " Mb \n";
+        if (!info.isCompatible())
+            cout << "\t !!! This device is NOT compatible with current GPU module build \n";
+
+        cout << endl;
+    }
+#endif
+}
+
+int main(int argc, char** argv)
+{
+    CommandLineParser cmd(argc, (const char**) argv,
+        "{ print_info_only | print_info_only | false | Print information about system and exit }"
+        "{ device | device | 0 | Device on which tests will be executed }"
+        "{ cpu | cpu | false | Run tests on cpu }"
+    );
+
+    printOsInfo();
+    printCudaInfo();
+
+    if (cmd.get<bool>("print_info_only"))
+        return 0;
+
+    int device = cmd.get<int>("device");
+    bool cpu = cmd.get<bool>("cpu");
+#ifndef HAVE_CUDA
+    cpu = true;
+#endif
+
+    if (cpu)
+    {
+        runOnGpu = false;
+
+        cout << "Run tests on CPU \n" << endl;
+    }
+    else
+    {
+        runOnGpu = true;
+
+        if (device < 0 || device >= getCudaEnabledDeviceCount())
+        {
+            cerr << "Incorrect device index - " << device << endl;
+            return -1;
+        }
+
+        DeviceInfo info(device);
+        if (!info.isCompatible())
+        {
+            cerr << "Device " << device << " [" << info.name() << "] is NOT compatible with current GPU module build" << endl;
+            return -1;
+        }
+
+        setDevice(device);
+
+        cout << "Run tests on device " << device << " [" << info.name() << "] \n" << endl;
+    }
+
+    InitGoogleTest(&argc, argv);
+    perf::TestBase::Init(argc, argv);
+    return RUN_ALL_TESTS();
+}

modules/gpu/perf/perf_calib3d.cpp

 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
 
 //////////////////////////////////////////////////////////////////////
 // StereoBM
 
-GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)
+typedef pair<string, string> pair_string;
+DEF_PARAM_TEST_1(ImagePair, pair_string);
+
+PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(make_pair<string, string>("gpu/perf/aloe.jpg", "gpu/perf/aloeR.jpg")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(5.0);
 
-    cv::Mat img_l_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_l_host.empty());
+    const cv::Mat imgLeft = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(imgLeft.empty());
 
-    cv::Mat img_r_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_r_host.empty());
+    const cv::Mat imgRight = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(imgRight.empty());
 
-    cv::gpu::StereoBM_GPU bm(0, 256);
-    cv::gpu::GpuMat img_l(img_l_host);
-    cv::gpu::GpuMat img_r(img_r_host);
-    cv::gpu::GpuMat dst;
+    const int preset = 0;
+    const int ndisp = 256;
 
-    bm(img_l, img_r, dst);
+    if (runOnGpu)
+    {
+        cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
 
-    declare.time(5.0);
+        cv::gpu::GpuMat d_imgLeft(imgLeft);
+        cv::gpu::GpuMat d_imgRight(imgRight);
+        cv::gpu::GpuMat d_dst;
+
+        d_bm(d_imgLeft, d_imgRight, d_dst);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_bm(d_imgLeft, d_imgRight, d_dst);
+        }
+    }
+    else
     {
-        bm(img_l, img_r, dst);
+        cv::StereoBM bm(preset, ndisp);
+
+        cv::Mat dst;
+
+        bm(imgLeft, imgRight, dst);
+
+        TEST_CYCLE()
+        {
+            bm(imgLeft, imgRight, dst);
+        }
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoBM, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // StereoBeliefPropagation
 
-GPU_PERF_TEST_1(StereoBeliefPropagation, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(make_pair<string, string>("gpu/stereobp/aloe-L.png", "gpu/stereobp/aloe-R.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(10.0);
 
-    cv::Mat img_l_host = readImage("gpu/stereobp/aloe-L.png");
-    ASSERT_FALSE(img_l_host.empty());
+    const cv::Mat imgLeft = readImage(GetParam().first);
+    ASSERT_FALSE(imgLeft.empty());
 
-    cv::Mat img_r_host = readImage("gpu/stereobp/aloe-R.png");
-    ASSERT_FALSE(img_r_host.empty());
+    const cv::Mat imgRight = readImage(GetParam().second);
+    ASSERT_FALSE(imgRight.empty());
 
-    cv::gpu::StereoBeliefPropagation bp(64);
-    cv::gpu::GpuMat img_l(img_l_host);
-    cv::gpu::GpuMat img_r(img_r_host);
-    cv::gpu::GpuMat dst;
+    const int ndisp = 64;
 
-    bp(img_l, img_r, dst);
+    if (runOnGpu)
+    {
+        cv::gpu::StereoBeliefPropagation d_bp(ndisp);
 
-    declare.time(10.0);
+        cv::gpu::GpuMat d_imgLeft(imgLeft);
+        cv::gpu::GpuMat d_imgRight(imgRight);
+        cv::gpu::GpuMat d_dst;
 
-    TEST_CYCLE()
+        d_bp(d_imgLeft, d_imgRight, d_dst);
+
+        TEST_CYCLE()
+        {
+            d_bp(d_imgLeft, d_imgRight, d_dst);
+        }
+    }
+    else
     {
-        bp(img_l, img_r, dst);
+        FAIL();
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoBeliefPropagation, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // StereoConstantSpaceBP
 
-GPU_PERF_TEST_1(StereoConstantSpaceBP, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(make_pair<string, string>("gpu/stereobm/aloe-L.png", "gpu/stereobm/aloe-R.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(10.0);
 
-    cv::Mat img_l_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_l_host.empty());
+    const cv::Mat imgLeft = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(imgLeft.empty());
 
-    cv::Mat img_r_host = readImage("gpu/stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_r_host.empty());
+    const cv::Mat imgRight = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(imgRight.empty());
 
-    cv::gpu::StereoConstantSpaceBP csbp(128);
-    cv::gpu::GpuMat img_l(img_l_host);
-    cv::gpu::GpuMat img_r(img_r_host);
-    cv::gpu::GpuMat dst;
+    const int ndisp = 128;
 
-    csbp(img_l, img_r, dst);
+    if (runOnGpu)
+    {
+        cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
 
-    declare.time(10.0);
+        cv::gpu::GpuMat d_imgLeft(imgLeft);
+        cv::gpu::GpuMat d_imgRight(imgRight);
+        cv::gpu::GpuMat d_dst;
+
+        d_csbp(d_imgLeft, d_imgRight, d_dst);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_csbp(d_imgLeft, d_imgRight, d_dst);
+        }
+    }
+    else
     {
-        csbp(img_l, img_r, dst);
+        FAIL();
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // DisparityBilateralFilter
 
-GPU_PERF_TEST_1(DisparityBilateralFilter, cv::gpu::DeviceInfo)
+PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(make_pair<string, string>("gpu/stereobm/aloe-L.png", "gpu/stereobm/aloe-disp.png")))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
+
+    const cv::Mat disp = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(disp.empty());
 
-    cv::Mat img_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+    const int ndisp = 128;
 
-    cv::Mat disp_host = readImage("gpu/stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(disp_host.empty());
+    if (runOnGpu)
+    {
+        cv::gpu::DisparityBilateralFilter d_filter(ndisp);
 
-    cv::gpu::DisparityBilateralFilter f(128);
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat disp(disp_host);
-    cv::gpu::GpuMat dst;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_disp(disp);
+        cv::gpu::GpuMat d_dst;
 
-    f(disp, img, dst);
+        d_filter(d_disp, d_img, d_dst);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_filter(d_disp, d_img, d_dst);
+        }
+    }
+    else
     {
-        f(disp, img, dst);
+        FAIL();
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, DisparityBilateralFilter, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // TransformPoints
 
-IMPLEMENT_PARAM_CLASS(Count, int)
+DEF_PARAM_TEST_1(Count, int);
 
-GPU_PERF_TEST(TransformPoints, cv::gpu::DeviceInfo, Count)
+PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    const int count = GetParam();
 
-    int count = GET_PARAM(1);
+    cv::Mat src(1, count, CV_32FC3);
+    fillRandom(src, -100, 100);
 
-    cv::Mat src_host(1, count, CV_32FC3);
-    fill(src_host, -100, 100);
+    const cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
+    const cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::gpu::GpuMat dst;
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-    cv::gpu::transformPoints(src, rvec, tvec, dst);
+        cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
+        }
+    }
+    else
     {
-        cv::gpu::transformPoints(src, rvec, tvec, dst);
+        FAIL();
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, TransformPoints, testing::Combine(
-    ALL_DEVICES,
-    testing::Values<Count>(5000, 10000, 20000)));
-
 //////////////////////////////////////////////////////////////////////
 // ProjectPoints
 
-GPU_PERF_TEST(ProjectPoints, cv::gpu::DeviceInfo, Count)
+PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    const int count = GetParam();
 
-    int count = GET_PARAM(1);
+    cv::Mat src(1, count, CV_32FC3);
+    fillRandom(src, -100, 100);
 
-    cv::Mat src_host(1, count, CV_32FC3);
-    fill(src_host, -100, 100);
+    const cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
+    const cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
+    const cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
-    cv::gpu::GpuMat dst;
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-    cv::gpu::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(), dst);
+        cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
+        }
+    }
+    else
     {
-        cv::gpu::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(), dst);
+        cv::Mat dst;
+
+        cv::projectPoints(src, rvec, tvec, camera_mat, cv::noArray(), dst);
+
+        TEST_CYCLE()
+        {
+            cv::projectPoints(src, rvec, tvec, camera_mat, cv::noArray(), dst);
+        }
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, ProjectPoints, testing::Combine(
-    ALL_DEVICES,
-    testing::Values<Count>(5000, 10000, 20000)));
-
 //////////////////////////////////////////////////////////////////////
 // SolvePnPRansac
 
-GPU_PERF_TEST(SolvePnPRansac, cv::gpu::DeviceInfo, Count)
+PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(10.0);
 
-    int count = GET_PARAM(1);
+    const int count = GetParam();
 
     cv::Mat object(1, count, CV_32FC3);
-    fill(object, -100, 100);
+    fillRandom(object, -100, 100);
 
     cv::Mat camera_mat(3, 3, CV_32FC1);
-    fill(camera_mat, 0.5, 1);
+    fillRandom(camera_mat, 0.5, 1);
     camera_mat.at<float>(0, 1) = 0.f;
     camera_mat.at<float>(1, 0) = 0.f;
     camera_mat.at<float>(2, 0) = 0.f;
     camera_mat.at<float>(2, 1) = 0.f;
 
-    cv::Mat dist_coef(1, 8, CV_32F, cv::Scalar::all(0));
+    const cv::Mat dist_coef(1, 8, CV_32F, cv::Scalar::all(0));
 
     std::vector<cv::Point2f> image_vec;
     cv::Mat rvec_gold(1, 3, CV_32FC1);
-    fill(rvec_gold, 0, 1);
+    fillRandom(rvec_gold, 0, 1);
     cv::Mat tvec_gold(1, 3, CV_32FC1);
-    fill(tvec_gold, 0, 1);
+    fillRandom(tvec_gold, 0, 1);
     cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, dist_coef, image_vec);
 
     cv::Mat image(1, count, CV_32FC2, &image_vec[0]);
@@ -221,82 +265,92 @@ GPU_PERF_TEST(SolvePnPRansac, cv::gpu::DeviceInfo, Count)
     cv::Mat rvec;
     cv::Mat tvec;
 
-    cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
-
-    declare.time(3.0);
-
-    TEST_CYCLE()
+    if (runOnGpu)
     {
         cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+
+        TEST_CYCLE()
+        {
+            cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+        }
     }
-}
+    else
+    {
+        cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
 
-INSTANTIATE_TEST_CASE_P(Calib3D, SolvePnPRansac, testing::Combine(
-    ALL_DEVICES,
-    testing::Values<Count>(5000, 10000, 20000)));
+        TEST_CYCLE()
+        {
+            cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // ReprojectImageTo3D
 
-GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(0);
+    const int depth = GET_PARAM(1);
 
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-
-    cv::Mat src_host(size, depth);
-    fill(src_host, 5.0, 30.0);
+    cv::Mat src(size, depth);
+    fillRandom(src, 5.0, 30.0);
 
     cv::Mat Q(4, 4, CV_32FC1);
-    fill(Q, 0.1, 1.0);
+    fillRandom(Q, 0.1, 1.0);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-    cv::gpu::reprojectImageTo3D(src, dst, Q);
+        cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
+        }
+    }
+    else
     {
-        cv::gpu::reprojectImageTo3D(src, dst, Q);
+        cv::Mat dst;
+
+        cv::reprojectImageTo3D(src, dst, Q);
+
+        TEST_CYCLE()
+        {
+            cv::reprojectImageTo3D(src, dst, Q);
+        }
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, ReprojectImageTo3D, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16S)));
-
 //////////////////////////////////////////////////////////////////////
 // DrawColorDisp
 
-GPU_PERF_TEST(DrawColorDisp, cv::gpu::DeviceInfo, cv::Size, MatDepth)
+PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S)))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
+    const cv::Size size = GET_PARAM(0);
+    const int type = GET_PARAM(1);
 
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
+    cv::Mat src(size, type);
+    fillRandom(src, 0, 255);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-    cv::gpu::drawColorDisp(src, dst, 255);
+        cv::gpu::drawColorDisp(d_src, d_dst, 255);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            cv::gpu::drawColorDisp(d_src, d_dst, 255);
+        }
+    }
+    else
     {
-        cv::gpu::drawColorDisp(src, dst, 255);
+        FAIL();
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Calib3D, DrawColorDisp, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16S))));
-
-#endif
-
+} // namespace

modules/gpu/perf/perf_features2d.cpp

 #include "perf_precomp.hpp"
 
-#ifdef HAVE_CUDA
+using namespace std;
+using namespace testing;
+
+namespace {
 
 //////////////////////////////////////////////////////////////////////
 // SURF
 
-GPU_PERF_TEST_1(SURF, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+DEF_PARAM_TEST_1(Image, string);
 
-    cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.jpg"))
+{
+    declare.time(50.0);
 
-    cv::gpu::SURF_GPU surf;
+    cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat keypoints, descriptors;
+    if (runOnGpu)
+    {
+        cv::gpu::SURF_GPU d_surf;
 
-    surf(img, cv::gpu::GpuMat(), keypoints, descriptors);
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints, d_descriptors;
 
-    declare.time(2.0);
+        d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        }
+    }
+    else
     {
-        surf(img, cv::gpu::GpuMat(), keypoints, descriptors);
+        cv::SURF surf;
+
+        std::vector<cv::KeyPoint> keypoints;
+        cv::Mat descriptors;
+
+        surf(img, cv::noArray(), keypoints, descriptors);
+
+        TEST_CYCLE()
+        {
+            keypoints.clear();
+            surf(img, cv::noArray(), keypoints, descriptors);
+        }
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, SURF, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // FAST
 
-GPU_PERF_TEST_1(FAST, cv::gpu::DeviceInfo)
+PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.jpg"))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
-
-    cv::gpu::FAST_GPU fast(20);
+    if (runOnGpu)
+    {
+        cv::gpu::FAST_GPU d_fast(20);
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat keypoints;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints;
 
-    fast(img, cv::gpu::GpuMat(), keypoints);
+        d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
+        }
+    }
+    else
     {
-        fast(img, cv::gpu::GpuMat(), keypoints);
+        std::vector<cv::KeyPoint> keypoints;
+
+        cv::FAST(img, keypoints, 20);
+
+        TEST_CYCLE()
+        {
+            keypoints.clear();
+            cv::FAST(img, keypoints, 20);
+        }
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, FAST, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // ORB
 
-GPU_PERF_TEST_1(ORB, cv::gpu::DeviceInfo)
+PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.jpg"))
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_host.empty());
+    if (runOnGpu)
+    {
+        cv::gpu::ORB_GPU d_orb(4000);
 
-    cv::gpu::ORB_GPU orb(4000);
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints, d_descriptors;
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat keypoints, descriptors;
+        d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+        }
+    }
+    else
     {
-        orb(img, cv::gpu::GpuMat(), keypoints, descriptors);
+        cv::ORB orb(4000);
+
+        std::vector<cv::KeyPoint> keypoints;
+        cv::Mat descriptors;
+
+        orb(img, cv::noArray(), keypoints, descriptors);
+
+        TEST_CYCLE()
+        {
+            keypoints.clear();
+            orb(img, cv::noArray(), keypoints, descriptors);
+        }
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, ORB, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
-// BruteForceMatcher_match
+// BFMatch
 
-IMPLEMENT_PARAM_CLASS(DescriptorSize, int)
+DEF_PARAM_TEST(DescSize_Norm, int, NormType);
 
-GPU_PERF_TEST(BruteForceMatcher_match, cv::gpu::DeviceInfo, DescriptorSize, NormType)
+PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(20.0);
 
-    int desc_size = GET_PARAM(1);
-    int normType = GET_PARAM(2);
+    int desc_size = GET_PARAM(0);
+    int normType = GET_PARAM(1);
 
     int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;
 
-    cv::Mat query_host(3000, desc_size, type);
-    fill(query_host, 0.0, 10.0);
-
-    cv::Mat train_host(3000, desc_size, type);
-    fill(train_host, 0.0, 10.0);
+    cv::Mat query(3000, desc_size, type);
+    fillRandom(query);
 
-    cv::gpu::BFMatcher_GPU matcher(normType);
+    cv::Mat train(3000, desc_size, type);
+    fillRandom(train);
 
-    cv::gpu::GpuMat query(query_host);
-    cv::gpu::GpuMat train(train_host);
-    cv::gpu::GpuMat trainIdx, distance;
+    if (runOnGpu)
+    {
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-    matcher.matchSingle(query, train, trainIdx, distance);
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_distance;
 
-    declare.time(3.0);
+        d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+        }
+    }
+    else
     {
-        matcher.matchSingle(query, train, trainIdx, distance);
+        cv::BFMatcher matcher(normType);
+
+        std::vector<cv::DMatch> matches;
+
+        matcher.match(query, train, matches);
+
+        TEST_CYCLE()
+        {
+            matcher.match(query, train, matches);
+        }
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_match, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),
-    testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));
-
 //////////////////////////////////////////////////////////////////////
-// BruteForceMatcher_knnMatch
+// BFKnnMatch
 
-IMPLEMENT_PARAM_CLASS(K, int)
+DEF_PARAM_TEST(DescSize_K_Norm, int, int, NormType);
 
-GPU_PERF_TEST(BruteForceMatcher_knnMatch, cv::gpu::DeviceInfo, DescriptorSize, K, NormType)
+PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
+    Values(64, 128, 256),
+    Values(2, 3),
+    Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(30.0);
 
-    int desc_size = GET_PARAM(1);
-    int k = GET_PARAM(2);
-    int normType = GET_PARAM(3);
+    int desc_size = GET_PARAM(0);
+    int k = GET_PARAM(1);
+    int normType = GET_PARAM(2);
 
     int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;
 
-    cv::Mat query_host(3000, desc_size, type);
-    fill(query_host, 0.0, 10.0);
-
-    cv::Mat train_host(3000, desc_size, type);
-    fill(train_host, 0.0, 10.0);
+    cv::Mat query(3000, desc_size, type);
+    fillRandom(query);
 
-    cv::gpu::BFMatcher_GPU matcher(normType);
+    cv::Mat train(3000, desc_size, type);
+    fillRandom(train);
 
-    cv::gpu::GpuMat query(query_host);
-    cv::gpu::GpuMat train(train_host);
-    cv::gpu::GpuMat trainIdx, distance, allDist;
+    if (runOnGpu)
+    {
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-    matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
 
-    declare.time(3.0);
+        d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
+        }
+    }
+    else
     {
-        matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);
+        cv::BFMatcher matcher(normType);
+
+        std::vector< std::vector<cv::DMatch> > matches;
+
+        matcher.knnMatch(query, train, matches, k);
+
+        TEST_CYCLE()
+        {
+            matcher.knnMatch(query, train, matches, k);
+        }
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_knnMatch, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),
-    testing::Values(K(2), K(3)),
-    testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));
-
 //////////////////////////////////////////////////////////////////////
-// BruteForceMatcher_radiusMatch
+// BFRadiusMatch
 
-GPU_PERF_TEST(BruteForceMatcher_radiusMatch, cv::gpu::DeviceInfo, DescriptorSize, NormType)
+PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256), Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    declare.time(30.0);
 
-    int desc_size = GET_PARAM(1);
-    int normType = GET_PARAM(2);
+    int desc_size = GET_PARAM(0);
+    int normType = GET_PARAM(1);
 
     int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;
 
-    cv::Mat query_host(3000, desc_size, type);
-    fill(query_host, 0.0, 1.0);
-
-    cv::Mat train_host(3000, desc_size, type);
-    fill(train_host, 0.0, 1.0);
+    cv::Mat query(3000, desc_size, type);
+    fillRandom(query, 0.0, 1.0);
 
-    cv::gpu::BFMatcher_GPU matcher(normType);
+    cv::Mat train(3000, desc_size, type);
+    fillRandom(train, 0.0, 1.0);
 
-    cv::gpu::GpuMat query(query_host);
-    cv::gpu::GpuMat train(train_host);
-    cv::gpu::GpuMat trainIdx, nMatches, distance;
+    if (runOnGpu)
+    {
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-    matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
 
-    declare.time(3.0);
+        d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
 
-    TEST_CYCLE()
+        TEST_CYCLE()
+        {
+            d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
+        }
+    }
+    else
     {
-        matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);
+        cv::BFMatcher matcher(normType);
+
+        std::vector< std::vector<cv::DMatch> > matches;
+
+        matcher.radiusMatch(query, train, matches, 2.0);
+
+        TEST_CYCLE()
+        {
+            matcher.radiusMatch(query, train, matches, 2.0);
+        }
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_radiusMatch, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),
-    testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));
-
-#endif
+} // namespace

modules/gpu/perf/perf_main.cpp

-#include "perf_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-int main(int argc, char **argv)
-{
-    testing::InitGoogleTest(&argc, argv);
-    perf::TestBase::Init(argc, argv);
-    return RUN_ALL_TESTS();
-}
-
-#else
-
-int main()
-{
-    printf("OpenCV was built without CUDA support\n");
-    return 0;
-}
-
-#endif

modules/gpu/perf/perf_precomp.hpp

@@ -11,6 +11,10 @@
 
 #include "cvconfig.h"
 
+#ifdef HAVE_CUDA
+#include <cuda_runtime.h>
+#endif
+
 #include "opencv2/ts/ts.hpp"
 #include "opencv2/ts/ts_perf.hpp"
 
@@ -18,8 +22,12 @@
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/gpu/gpu.hpp"
 #include "opencv2/calib3d/calib3d.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/video/video.hpp"
+#include "opencv2/nonfree/nonfree.hpp"
+#include "opencv2/legacy/legacy.hpp"
 
-#include "perf_utility.hpp"
+#include "utility.hpp"
 
 #ifdef GTEST_CREATE_SHARED_LIBRARY
 #error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined

modules/gpu/perf_cpu/perf_cpu_precomp.cpp

-#include "perf_cpu_precomp.hpp"

modules/gpu/perf_cpu/perf_cpu_precomp.hpp

-#ifdef __GNUC__
-#  pragma GCC diagnostic ignored "-Wmissing-declarations"
-#  pragma GCC diagnostic ignored "-Wmissing-prototypes" //OSX
-#endif
-
-#ifndef __OPENCV_PERF_CPU_PRECOMP_HPP__
-#define __OPENCV_PERF_CPU_PRECOMP_HPP__
-
-#include <cstdio>
-#include <iostream>
-
-#include "cvconfig.h"
-
-#include "opencv2/ts/ts.hpp"
-#include "opencv2/ts/ts_perf.hpp"
-
-#include "opencv2/core/core.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/gpu/gpu.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/video/video.hpp"
-#include "opencv2/calib3d/calib3d.hpp"
-#include "opencv2/nonfree/nonfree.hpp"
-#include "opencv2/legacy/legacy.hpp"
-
-#include "perf_utility.hpp"
-
-#ifdef GTEST_CREATE_SHARED_LIBRARY
-#error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
-#endif
-
-#endif