Merge branch 'master' of code.opencv.org:opencv

3rdparty/libtiff/CMakeLists.txt

@@ -89,7 +89,7 @@ endif(WIN32)
 
 ocv_warnings_disable(CMAKE_C_FLAGS -Wno-unused-but-set-variable -Wmissing-prototypes -Wmissing-declarations -Wundef -Wunused -Wsign-compare
                                    -Wcast-align -Wshadow -Wno-maybe-uninitialized -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast)
-ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations -Wunused-parameter /wd4100 /wd4244 /wd4706 /wd4127 /wd4701 /wd4018 /wd4267 /wd4306 /wd4305 /wd4312 /wd4311)
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations -Wunused-parameter /wd4100 /wd4244 /wd4706 /wd4127 /wd4701 /wd4018 /wd4267 /wd4306 /wd4305 /wd4312 /wd4311 /wd4703)
 
 if(UNIX AND (CMAKE_COMPILER_IS_GNUCXX OR CV_ICC))
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")

CMakeLists.txt

@@ -189,11 +189,11 @@ OCV_OPTION(ENABLE_PROFILING           "Enable profiling in the GCC compiler (Add
 OCV_OPTION(ENABLE_OMIT_FRAME_POINTER  "Enable -fomit-frame-pointer for GCC"                      ON   IF CMAKE_COMPILER_IS_GNUCXX )
 OCV_OPTION(ENABLE_POWERPC             "Enable PowerPC for GCC"                                   ON   IF (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_SYSTEM_PROCESSOR MATCHES powerpc.*) )
 OCV_OPTION(ENABLE_FAST_MATH           "Enable -ffast-math (not recommended for GCC 4.6.x)"       OFF  IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
-OCV_OPTION(ENABLE_SSE                 "Enable SSE instructions"                                  ON   IF (MSVC OR CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
-OCV_OPTION(ENABLE_SSE2                "Enable SSE2 instructions"                                 ON   IF (MSVC OR CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
-OCV_OPTION(ENABLE_SSE3                "Enable SSE3 instructions"                                 OFF  IF (CV_ICC OR CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_SSE                 "Enable SSE instructions"                                  ON   IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_SSE2                "Enable SSE2 instructions"                                 ON   IF ((MSVC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_SSE3                "Enable SSE3 instructions"                                 ON   IF ((CV_ICC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
 OCV_OPTION(ENABLE_SSSE3               "Enable SSSE3 instructions"                                OFF  IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
-OCV_OPTION(ENABLE_SSE41               "Enable SSE4.1 instructions"                               OFF  IF (CV_ICC OR CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
+OCV_OPTION(ENABLE_SSE41               "Enable SSE4.1 instructions"                               OFF  IF ((CV_ICC OR CMAKE_COMPILER_IS_GNUCXX) AND (X86 OR X86_64)) )
 OCV_OPTION(ENABLE_SSE42               "Enable SSE4.2 instructions"                               OFF  IF (CMAKE_COMPILER_IS_GNUCXX AND (X86 OR X86_64)) )
 OCV_OPTION(ENABLE_NOISY_WARNINGS      "Show all warnings even if they are too noisy"             OFF )
 OCV_OPTION(OPENCV_WARNINGS_ARE_ERRORS "Treat warnings as errors"                                 OFF )

cmake/OpenCVDetectCUDA.cmake

@@ -88,7 +88,11 @@ if(CUDA_FOUND)
     if(APPLE)
       set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fno-finite-math-only)
     endif()
-    string(REPLACE "-Wsign-promo" "" CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS}")
+
+    # disabled because of multiple warnings during building nvcc auto generated files
+    if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_GCC_REGEX_VERSION VERSION_GREATER "4.6.0")
+      ocv_warnings_disable(CMAKE_CXX_FLAGS -Wunused-but-set-variable)
+    endif()
 
     # we remove -ggdb3 flag as it leads to preprocessor errors when compiling CUDA files (CUDA 4.1)
     set(CMAKE_CXX_FLAGS_DEBUG_ ${CMAKE_CXX_FLAGS_DEBUG})

cmake/OpenCVGenConfig.cmake

@@ -64,9 +64,14 @@ macro(ocv_generate_dependencies_map_configcmake suffix configuration)
       string(REGEX REPLACE "${CMAKE_SHARED_LIBRARY_SUFFIX}$" "${OPENCV_LINK_LIBRARY_SUFFIX}" __libname "${__libname}")
     endif()
 
+    string(REPLACE " " "\\ " __mod_deps "${${__ocv_lib}_MODULE_DEPS_${suffix}}")
+    string(REPLACE " " "\\ " __ext_deps "${${__ocv_lib}_EXTRA_DEPS_${suffix}}")
+    string(REPLACE "\"" "\\\"" __mod_deps "${__mod_deps}")
+    string(REPLACE "\"" "\\\"" __ext_deps "${__ext_deps}")
+
     set(OPENCV_DEPENDENCIES_MAP_${suffix} "${OPENCV_DEPENDENCIES_MAP_${suffix}}set(OpenCV_${__ocv_lib}_LIBNAME_${suffix} \"${__libname}\")\n")
-    set(OPENCV_DEPENDENCIES_MAP_${suffix} "${OPENCV_DEPENDENCIES_MAP_${suffix}}set(OpenCV_${__ocv_lib}_DEPS_${suffix} ${${__ocv_lib}_MODULE_DEPS_${suffix}})\n")
-    set(OPENCV_DEPENDENCIES_MAP_${suffix} "${OPENCV_DEPENDENCIES_MAP_${suffix}}set(OpenCV_${__ocv_lib}_EXTRA_DEPS_${suffix} ${${__ocv_lib}_EXTRA_DEPS_${suffix}})\n")
+    set(OPENCV_DEPENDENCIES_MAP_${suffix} "${OPENCV_DEPENDENCIES_MAP_${suffix}}set(OpenCV_${__ocv_lib}_DEPS_${suffix} ${__mod_deps})\n")
+    set(OPENCV_DEPENDENCIES_MAP_${suffix} "${OPENCV_DEPENDENCIES_MAP_${suffix}}set(OpenCV_${__ocv_lib}_EXTRA_DEPS_${suffix} ${__ext_deps})\n")
 
     list(APPEND OPENCV_PROCESSED_LIBS ${__ocv_lib})
     list(APPEND OPENCV_LIBS_TO_PROCESS ${${__ocv_lib}_MODULE_DEPS_${suffix}})

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()

ios/cmake/Modules/Platform/iOS.cmake

@@ -42,6 +42,8 @@ set (CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}")
 set (CMAKE_C_FLAGS "")
 set (CMAKE_CXX_FLAGS "-headerpad_max_install_names -fvisibility=hidden -fvisibility-inlines-hidden")
 
+set (CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -O3 -fomit-frame-pointer -ffast-math")
+
 if (HAVE_FLAG_SEARCH_PATHS_FIRST)
 	set (CMAKE_C_LINK_FLAGS "-Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}")
 	set (CMAKE_CXX_LINK_FLAGS "-Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}")

modules/core/include/opencv2/core/core.hpp

@@ -440,7 +440,7 @@ template<typename _Tp, int m, int n> class CV_EXPORTS Matx
 {
 public:
     typedef _Tp value_type;
-    typedef Matx<_Tp, MIN(m, n), 1> diag_type;
+    typedef Matx<_Tp, (m < n ? m : n), 1> diag_type;
     typedef Matx<_Tp, m, n> mat_type;
     enum { depth = DataDepth<_Tp>::value, rows = m, cols = n, channels = rows*cols,
            type = CV_MAKETYPE(depth, channels) };

modules/core/include/opencv2/core/gpumat.hpp

@@ -72,9 +72,11 @@ namespace cv { namespace gpu
         FEATURE_SET_COMPUTE_13 = 13,
         FEATURE_SET_COMPUTE_20 = 20,
         FEATURE_SET_COMPUTE_21 = 21,
+        FEATURE_SET_COMPUTE_30 = 30,
         GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11,
         SHARED_ATOMICS = FEATURE_SET_COMPUTE_12,
-        NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13
+        NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13,
+        WARP_SHUFFLE_FUNCTIONS = FEATURE_SET_COMPUTE_30
     };
 
     // Gives information about what GPU archs this OpenCV GPU module was

modules/core/src/cuda/matrix_operations.cu

@@ -44,7 +44,7 @@
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/functional.hpp"
 
-namespace cv { namespace gpu { namespace device 
+namespace cv { namespace gpu { namespace device
 {
     template <typename T> struct shift_and_sizeof;
     template <> struct shift_and_sizeof<signed char> { enum { shift = 0 }; };
@@ -272,7 +272,7 @@ namespace cv { namespace gpu { namespace device
     template <typename T, typename D> struct TransformFunctorTraits< Convertor<T, D> > : detail::ConvertTraits< Convertor<T, D> >
     {
     };
-        
+
     template<typename T, typename D>
     void cvt_(DevMem2Db src, DevMem2Db dst, double alpha, double beta, cudaStream_t stream)
     {
@@ -282,6 +282,11 @@ namespace cv { namespace gpu { namespace device
         cv::gpu::device::transform((DevMem2D_<T>)src, (DevMem2D_<D>)dst, op, WithOutMask(), stream);
     }
 
+#if defined  __clang__
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wmissing-declarations"
+#endif
+
     void convert_gpu(DevMem2Db src, int sdepth, DevMem2Db dst, int ddepth, double alpha, double beta, cudaStream_t stream)
     {
         typedef void (*caller_t)(DevMem2Db src, DevMem2Db dst, double alpha, double beta, cudaStream_t stream);
@@ -318,4 +323,8 @@ namespace cv { namespace gpu { namespace device
 
         func(src, dst, alpha, beta, stream);
     }
+
+#if defined __clang__
+# pragma clang diagnostic pop
+#endif
 }}} // namespace cv { namespace gpu { namespace device

modules/core/src/gpumat.cpp

@@ -1199,10 +1199,6 @@ namespace
 
         void setTo(GpuMat& m, Scalar s, const GpuMat& mask) const
         {
-            NppiSize sz;
-            sz.width  = m.cols;
-            sz.height = m.rows;
-
             if (mask.empty())
             {
                 if (s[0] == 0.0 && s[1] == 0.0 && s[2] == 0.0 && s[3] == 0.0)

modules/features2d/src/features2d_init.cpp

@@ -59,7 +59,7 @@ CV_INIT_ALGORITHM(BriefDescriptorExtractor, "Feature2D.BRIEF",
 CV_INIT_ALGORITHM(FastFeatureDetector, "Feature2D.FAST",
                   obj.info()->addParam(obj, "threshold", obj.threshold);
                   obj.info()->addParam(obj, "nonmaxSuppression", obj.nonmaxSuppression);
-                  obj.info()->addParam(obj, "type", obj.type, FastFeatureDetector::TYPE_9_16));
+                  obj.info()->addParam(obj, "type", obj.type));
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 

modules/features2d/test/test_fast.cpp

@@ -75,8 +75,8 @@ void CV_FastTest::run( int )
 
     vector<KeyPoint> keypoints1;
     vector<KeyPoint> keypoints2;
-    FAST(gray1, keypoints1, 30, type);
-    FAST(gray2, keypoints2, 30, type);
+    FAST(gray1, keypoints1, 30, true, type);
+    FAST(gray2, keypoints2, 30, true, type);
 
     for(size_t i = 0; i < keypoints1.size(); ++i)
     {

modules/features2d/test/test_nearestneighbors.cpp

@@ -200,7 +200,7 @@ int CV_KDTreeTest_CPP::checkGetPoins( const Mat& data )
 
 int CV_KDTreeTest_CPP::checkFindBoxed()
 {
-    vector<float> min( dims, minValue), max(dims, maxValue);
+    vector<float> min( dims, static_cast<float>(minValue)), max(dims, static_cast<float>(maxValue));
     vector<int> indices;
     tr->findOrthoRange( min, max, indices );
     // TODO check indices
@@ -214,8 +214,8 @@ int CV_KDTreeTest_CPP::findNeighbors( Mat& points, Mat& neighbors )
     const int emax = 20;
     Mat neighbors2( neighbors.size(), CV_32SC1 );
     int j;
-    vector<float> min(points.cols, minValue);
-    vector<float> max(points.cols, maxValue);
+    vector<float> min(points.cols, static_cast<float>(minValue));
+    vector<float> max(points.cols, static_cast<float>(maxValue));
     for( int pi = 0; pi < points.rows; pi++ )
     {
         // 1st way

modules/features2d/test/test_rotation_and_scale_invariance.cpp

@@ -54,7 +54,7 @@ static
 Mat generateHomography(float angle)
 {
     // angle - rotation around Oz in degrees
-    float angleRadian = angle * CV_PI / 180.;
+    float angleRadian = static_cast<float>(angle * CV_PI / 180);
     Mat H = Mat::eye(3, 3, CV_32FC1);
     H.at<float>(0,0) = H.at<float>(1,1) = std::cos(angleRadian);
     H.at<float>(0,1) = -std::sin(angleRadian);
@@ -69,8 +69,8 @@ Mat rotateImage(const Mat& srcImage, float angle, Mat& dstImage, Mat& dstMask)
     // angle - rotation around Oz in degrees
     float diag = std::sqrt(static_cast<float>(srcImage.cols * srcImage.cols + srcImage.rows * srcImage.rows));
     Mat LUShift = Mat::eye(3, 3, CV_32FC1); // left up
-    LUShift.at<float>(0,2) = -srcImage.cols/2;
-    LUShift.at<float>(1,2) = -srcImage.rows/2;
+    LUShift.at<float>(0,2) = static_cast<float>(-srcImage.cols/2);
+    LUShift.at<float>(1,2) = static_cast<float>(-srcImage.rows/2);
     Mat RDShift = Mat::eye(3, 3, CV_32FC1); // right down
     RDShift.at<float>(0,2) = diag/2;
     RDShift.at<float>(1,2) = diag/2;
@@ -114,7 +114,7 @@ void scaleKeyPoints(const vector<KeyPoint>& src, vector<KeyPoint>& dst, float sc
 static
 float calcCirclesIntersectArea(const Point2f& p0, float r0, const Point2f& p1, float r1)
 {
-    float c = norm(p0 - p1), sqr_c = c * c;
+    float c = static_cast<float>(norm(p0 - p1)), sqr_c = c * c;
 
     float sqr_r0 = r0 * r0;
     float sqr_r1 = r1 * r1;
@@ -125,7 +125,7 @@ float calcCirclesIntersectArea(const Point2f& p0, float r0, const Point2f& p1, f
     float minR = std::min(r0, r1);
     float maxR = std::max(r0, r1);
     if(c + minR <= maxR)
-        return CV_PI * minR * minR;
+        return static_cast<float>(CV_PI * minR * minR);
 
     float cos_halfA0 = (sqr_r0 + sqr_c - sqr_r1) / (2 * r0 * c);
     float cos_halfA1 = (sqr_r1 + sqr_c - sqr_r0) / (2 * r1 * c);
@@ -133,15 +133,15 @@ float calcCirclesIntersectArea(const Point2f& p0, float r0, const Point2f& p1, f
     float A0 = 2 * acos(cos_halfA0);
     float A1 = 2 * acos(cos_halfA1);
 
-    return  0.5 * sqr_r0 * (A0 - sin(A0)) +
-            0.5 * sqr_r1 * (A1 - sin(A1));
+    return  0.5f * sqr_r0 * (A0 - sin(A0)) +
+            0.5f * sqr_r1 * (A1 - sin(A1));
 }
 
 static
 float calcIntersectRatio(const Point2f& p0, float r0, const Point2f& p1, float r1)
 {
     float intersectArea = calcCirclesIntersectArea(p0, r0, p1, r1);
-    float unionArea = CV_PI * (r0 * r0 + r1 * r1) - intersectArea;
+    float unionArea = static_cast<float>(CV_PI) * (r0 * r0 + r1 * r1) - intersectArea;
     return intersectArea / unionArea;
 }
 
@@ -160,7 +160,7 @@ void matchKeyPoints(const vector<KeyPoint>& keypoints0, const Mat& H,
 
     matches.clear();
     vector<uchar> usedMask(keypoints1.size(), 0);
-    for(size_t i0 = 0; i0 < keypoints0.size(); i0++)
+    for(int i0 = 0; i0 < static_cast<int>(keypoints0.size()); i0++)
     {
         int nearestPointIndex = -1;
         float maxIntersectRatio = 0.f;
@@ -176,7 +176,7 @@ void matchKeyPoints(const vector<KeyPoint>& keypoints0, const Mat& H,
             if(intersectRatio > maxIntersectRatio)
             {
                 maxIntersectRatio = intersectRatio;
-                nearestPointIndex = i1;
+                nearestPointIndex = static_cast<int>(i1);
             }
         }
 
@@ -222,7 +222,7 @@ protected:
         const int maxAngle = 360, angleStep = 15;
         for(int angle = 0; angle < maxAngle; angle += angleStep)
         {
-            Mat H = rotateImage(image0, angle, image1, mask1);
+            Mat H = rotateImage(image0, static_cast<float>(angle), image1, mask1);
 
             vector<KeyPoint> keypoints1;
             featureDetector->detect(image1, keypoints1, mask1);
@@ -339,10 +339,10 @@ protected:
         const int maxAngle = 360, angleStep = 15;
         for(int angle = 0; angle < maxAngle; angle += angleStep)
         {
-            Mat H = rotateImage(image0, angle, image1, mask1);
+            Mat H = rotateImage(image0, static_cast<float>(angle), image1, mask1);
 
             vector<KeyPoint> keypoints1;
-            rotateKeyPoints(keypoints0, H, angle, keypoints1);
+            rotateKeyPoints(keypoints0, H, static_cast<float>(angle), keypoints1);
             Mat descriptors1;
             descriptorExtractor->compute(image1, keypoints1, descriptors1);
 
@@ -457,7 +457,7 @@ protected:
                 keyPointMatchesCount++;
 
                 // Check does this inlier have consistent sizes
-                const float maxSizeDiff = 0.8;//0.9f; // grad
+                const float maxSizeDiff = 0.8f;//0.9f; // grad
                 float size0 = keypoints0[matches[m].trainIdx].size;
                 float size1 = osiKeypoints1[matches[m].queryIdx].size;
                 CV_Assert(size0 > 0 && size1 > 0);
@@ -545,7 +545,7 @@ protected:
             resize(image0, image1, Size(), 1./scale, 1./scale);
 
             vector<KeyPoint> keypoints1;
-            scaleKeyPoints(keypoints0, keypoints1, 1./scale);
+            scaleKeyPoints(keypoints0, keypoints1, 1.0f/scale);
             Mat descriptors1;
             descriptorExtractor->compute(image1, keypoints1, descriptors1);
 

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/doc/object_detection.rst

@@ -204,7 +204,7 @@ gpu::CascadeClassifier_GPU
 --------------------------
 .. ocv:class:: gpu::CascadeClassifier_GPU
 
-Cascade classifier class used for object detection. ::
+Cascade classifier class used for object detection. Supports HAAR and LBP cascades. ::
 
     class CV_EXPORTS CascadeClassifier_GPU
     {
@@ -219,6 +219,7 @@ Cascade classifier class used for object detection. ::
 
             /* Returns number of detected objects */
             int detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size());
+            int detectMultiScale( const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize = Size(), double scaleFactor = 1.1, int minNeighbors = 4);
 
             /* Finds only the largest object. Special mode if training is required.*/
             bool findLargestObject;
@@ -233,11 +234,11 @@ Cascade classifier class used for object detection. ::
 
 gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
 -----------------------------------------------------
-Loads the classifier from a file.
+Loads the classifier from a file. Cascade type is detected automatically by constructor parameter.
 
 .. ocv:function:: gpu::CascadeClassifier_GPU::CascadeClassifier_GPU(const string& filename)
 
-    :param filename: Name of the file from which the classifier is loaded. Only the old ``haar`` classifier (trained by the ``haar`` training application) and NVIDIA's ``nvbin`` are supported.
+    :param filename: Name of the file from which the classifier is loaded. Only the old ``haar`` classifier (trained by the ``haar`` training application) and NVIDIA's ``nvbin`` are supported for HAAR and only new type of OpenCV XML cascade supported for LBP.
 
 
 
@@ -255,8 +256,7 @@ Loads the classifier from a file. The previous content is destroyed.
 
 .. ocv:function:: bool gpu::CascadeClassifier_GPU::load(const string& filename)
 
-    :param filename: Name of the file from which the classifier is loaded. Only the old ``haar`` classifier (trained by the ``haar`` training application) and NVIDIA's ``nvbin`` are supported.
-
+    :param filename: Name of the file from which the classifier is loaded. Only the old ``haar`` classifier (trained by the ``haar`` training application) and NVIDIA's ``nvbin`` are supported for HAAR and only new type of OpenCV XML cascade supported for LBP.
 
 
 gpu::CascadeClassifier_GPU::release
@@ -273,13 +273,17 @@ Detects objects of different sizes in the input image.
 
 .. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size())
 
+.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize = Size(), double scaleFactor = 1.1, int minNeighbors = 4)
+
     :param image: Matrix of type  ``CV_8U``  containing an image where objects should be detected.
 
     :param objectsBuf: Buffer to store detected objects (rectangles). If it is empty, it is allocated with the default size. If not empty, the function searches not more than N objects, where ``N = sizeof(objectsBufer's data)/sizeof(cv::Rect)``.
 
-    :param scaleFactor: Value to specify how much the image size is reduced at each image scale.
+    :param maxObjectSize: Maximum possible object size. Objects larger than that are ignored. Used for second signature and supported only for LBP cascades.
+
+    :param scaleFactor:  Parameter specifying how much the image size is reduced at each image scale.
 
-    :param minNeighbors: Value to specify how many neighbours each candidate rectangle has to retain.
+    :param minNeighbors: Parameter specifying how many neighbors each candidate rectangle should have to retain it.
 
     :param minSize: Minimum possible object size. Objects smaller than that are ignored.
 

modules/gpu/include/opencv2/gpu/gpu.hpp

@@ -820,6 +820,7 @@ private:
     int nLayers_;
 };
 
+//! HoughLines
 CV_EXPORTS void HoughLines(const GpuMat& src, GpuMat& lines, float rho, float theta, int threshold, bool doSort = false, int maxLines = 4096);
 CV_EXPORTS void HoughLines(const GpuMat& src, GpuMat& lines, GpuMat& accum, GpuMat& buf, float rho, float theta, int threshold, bool doSort = false, int maxLines = 4096);
 CV_EXPORTS void HoughLinesTransform(const GpuMat& src, GpuMat& accum, GpuMat& buf, float rho, float theta);

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_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