refactoring: moved gpu reduction-based functions into separated file

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

@@ -360,66 +360,17 @@ namespace cv
             friend struct StreamAccessor;
         };
 
+
         ////////////////////////////// Arithmetics ///////////////////////////////////
 
         //! transposes the matrix
         //! supports CV_8UC1, CV_8SC1, CV_8UC4, CV_8SC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32FC1 type
         CV_EXPORTS void transpose(const GpuMat& src1, GpuMat& dst);
 
-        //! computes mean value and standard deviation of all or selected array elements
-        //! supports only CV_8UC1 type
-        CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
-
-        //! computes norm of array
-        //! supports NORM_INF, NORM_L1, NORM_L2
-        //! supports only CV_8UC1 type
-        CV_EXPORTS double norm(const GpuMat& src1, int normType=NORM_L2);
-
-        //! computes norm of the difference between two arrays
-        //! supports NORM_INF, NORM_L1, NORM_L2
-        //! supports only CV_8UC1 type
-        CV_EXPORTS double norm(const GpuMat& src1, const GpuMat& src2, int normType=NORM_L2);
-
         //! reverses the order of the rows, columns or both in a matrix
         //! supports CV_8UC1, CV_8UC4 types
         CV_EXPORTS void flip(const GpuMat& a, GpuMat& b, int flipCode);
 
-        //! computes sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sum(const GpuMat& src);
-
-        //! computes sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sum(const GpuMat& src, GpuMat& buf);
-
-        //! computes squared sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sqrSum(const GpuMat& src);
-
-        //! computes squared sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sqrSum(const GpuMat& src, GpuMat& buf);
-
-        //! finds global minimum and maximum array elements and returns their values
-        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal=0, const GpuMat& mask=GpuMat());
-
-        //! finds global minimum and maximum array elements and returns their values
-        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf);
-
-        //! finds global minimum and maximum array elements and returns their values with locations
-        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0,
-                                  const GpuMat& mask=GpuMat());
-
-        //! finds global minimum and maximum array elements and returns their values with locations
-        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
-                                  const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf);
-
-        //! counts non-zero array elements
-        CV_EXPORTS int countNonZero(const GpuMat& src);
-
-        //! counts non-zero array elements
-        CV_EXPORTS int countNonZero(const GpuMat& src, GpuMat& buf);
-
         //! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
         //! destination array will have the depth type as lut and the same channels number as source
         //! supports CV_8UC1, CV_8UC3 types
@@ -487,25 +438,6 @@ namespace cv
         //! async version
         CV_EXPORTS void polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, const Stream& stream);
 
-        //! computes per-element minimum of two arrays (dst = min(src1, src2))
-        CV_EXPORTS void min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst);
-        //! Async version
-        CV_EXPORTS void min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream);
-
-        //! computes per-element minimum of array and scalar (dst = min(src1, src2))
-        CV_EXPORTS void min(const GpuMat& src1, double src2, GpuMat& dst);
-        //! Async version
-        CV_EXPORTS void min(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream);
-
-        //! computes per-element maximum of two arrays (dst = max(src1, src2))
-        CV_EXPORTS void max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst);
-        //! Async version
-        CV_EXPORTS void max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream);
-
-        //! computes per-element maximum of array and scalar (dst = max(src1, src2))
-        CV_EXPORTS void max(const GpuMat& src1, double src2, GpuMat& dst);
-        //! Async version
-        CV_EXPORTS void max(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream);
 
         //////////////////////////// Per-element operations ////////////////////////////////////
 
@@ -576,6 +508,26 @@ namespace cv
         //! async version
         CV_EXPORTS void bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream);
 
+        //! computes per-element minimum of two arrays (dst = min(src1, src2))
+        CV_EXPORTS void min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst);
+        //! Async version
+        CV_EXPORTS void min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream);
+
+        //! computes per-element minimum of array and scalar (dst = min(src1, src2))
+        CV_EXPORTS void min(const GpuMat& src1, double src2, GpuMat& dst);
+        //! Async version
+        CV_EXPORTS void min(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream);
+
+        //! computes per-element maximum of two arrays (dst = max(src1, src2))
+        CV_EXPORTS void max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst);
+        //! Async version
+        CV_EXPORTS void max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream);
+
+        //! computes per-element maximum of array and scalar (dst = max(src1, src2))
+        CV_EXPORTS void max(const GpuMat& src1, double src2, GpuMat& dst);
+        //! Async version
+        CV_EXPORTS void max(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream);
+
 
         ////////////////////////////// Image processing //////////////////////////////
 
@@ -663,15 +615,66 @@ namespace cv
         //! computes Harris cornerness criteria at each image pixel
         CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101);
 
-
         //! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
         CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
 
-
         //! computes the proximity map for the raster template and the image where the template is searched for
         CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method);
 
 
+        ////////////////////////////// Matrix reductions //////////////////////////////
+
+        //! computes mean value and standard deviation of all or selected array elements
+        //! supports only CV_8UC1 type
+        CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
+
+        //! computes norm of array
+        //! supports NORM_INF, NORM_L1, NORM_L2
+        //! supports only CV_8UC1 type
+        CV_EXPORTS double norm(const GpuMat& src1, int normType=NORM_L2);
+
+        //! computes norm of the difference between two arrays
+        //! supports NORM_INF, NORM_L1, NORM_L2
+        //! supports only CV_8UC1 type
+        CV_EXPORTS double norm(const GpuMat& src1, const GpuMat& src2, int normType=NORM_L2);
+
+        //! computes sum of array elements
+        //! supports only single channel images
+        CV_EXPORTS Scalar sum(const GpuMat& src);
+
+        //! computes sum of array elements
+        //! supports only single channel images
+        CV_EXPORTS Scalar sum(const GpuMat& src, GpuMat& buf);
+
+        //! computes squared sum of array elements
+        //! supports only single channel images
+        CV_EXPORTS Scalar sqrSum(const GpuMat& src);
+
+        //! computes squared sum of array elements
+        //! supports only single channel images
+        CV_EXPORTS Scalar sqrSum(const GpuMat& src, GpuMat& buf);
+
+        //! finds global minimum and maximum array elements and returns their values
+        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal=0, const GpuMat& mask=GpuMat());
+
+        //! finds global minimum and maximum array elements and returns their values
+        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf);
+
+        //! finds global minimum and maximum array elements and returns their values with locations
+        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0,
+                                  const GpuMat& mask=GpuMat());
+
+        //! finds global minimum and maximum array elements and returns their values with locations
+        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
+                                  const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf);
+
+        //! counts non-zero array elements
+        CV_EXPORTS int countNonZero(const GpuMat& src);
+
+        //! counts non-zero array elements
+        CV_EXPORTS int countNonZero(const GpuMat& src, GpuMat& buf);
+
+
         //////////////////////////////// Filter Engine ////////////////////////////////
 
         /*!

modules/gpu/src/arithm.cpp

@@ -49,20 +49,7 @@ using namespace std;
 #if !defined (HAVE_CUDA)
 
 void cv::gpu::transpose(const GpuMat&, GpuMat&) { throw_nogpu(); }
-void cv::gpu::meanStdDev(const GpuMat&, Scalar&, Scalar&) { throw_nogpu(); }
-double cv::gpu::norm(const GpuMat&, int) { throw_nogpu(); return 0.0; }
-double cv::gpu::norm(const GpuMat&, const GpuMat&, int) { throw_nogpu(); return 0.0; }
 void cv::gpu::flip(const GpuMat&, GpuMat&, int) { throw_nogpu(); }
-Scalar cv::gpu::sum(const GpuMat&) { throw_nogpu(); return Scalar(); }
-Scalar cv::gpu::sum(const GpuMat&, GpuMat&) { throw_nogpu(); return Scalar(); }
-Scalar cv::gpu::sqrSum(const GpuMat&) { throw_nogpu(); return Scalar(); }
-Scalar cv::gpu::sqrSum(const GpuMat&, GpuMat&) { throw_nogpu(); return Scalar(); }
-void cv::gpu::minMax(const GpuMat&, double*, double*, const GpuMat&) { throw_nogpu(); }
-void cv::gpu::minMax(const GpuMat&, double*, double*, const GpuMat&, GpuMat&) { throw_nogpu(); }
-void cv::gpu::minMaxLoc(const GpuMat&, double*, double*, Point*, Point*, const GpuMat&) { throw_nogpu(); }
-void cv::gpu::minMaxLoc(const GpuMat&, double*, double*, Point*, Point*, const GpuMat&, GpuMat&, GpuMat&) { throw_nogpu(); }
-int cv::gpu::countNonZero(const GpuMat&) { throw_nogpu(); return 0; }
-int cv::gpu::countNonZero(const GpuMat&, GpuMat&) { throw_nogpu(); return 0; }
 void cv::gpu::LUT(const GpuMat&, const Mat&, GpuMat&) { throw_nogpu(); }
 void cv::gpu::exp(const GpuMat&, GpuMat&) { throw_nogpu(); }
 void cv::gpu::log(const GpuMat&, GpuMat&) { throw_nogpu(); }
@@ -78,14 +65,6 @@ void cv::gpu::cartToPolar(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool)
 void cv::gpu::cartToPolar(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool, const Stream&) { throw_nogpu(); }
 void cv::gpu::polarToCart(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool) { throw_nogpu(); }
 void cv::gpu::polarToCart(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool, const Stream&) { throw_nogpu(); }
-void cv::gpu::min(const GpuMat&, const GpuMat&, GpuMat&) { throw_nogpu(); }
-void cv::gpu::min(const GpuMat&, const GpuMat&, GpuMat&, const Stream&) { throw_nogpu(); }
-void cv::gpu::min(const GpuMat&, double, GpuMat&) { throw_nogpu(); }
-void cv::gpu::min(const GpuMat&, double, GpuMat&, const Stream&) { throw_nogpu(); }
-void cv::gpu::max(const GpuMat&, const GpuMat&, GpuMat&) { throw_nogpu(); }
-void cv::gpu::max(const GpuMat&, const GpuMat&, GpuMat&, const Stream&) { throw_nogpu(); }
-void cv::gpu::max(const GpuMat&, double, GpuMat&) { throw_nogpu(); }
-void cv::gpu::max(const GpuMat&, double, GpuMat&, const Stream&) { throw_nogpu(); }
 
 #else /* !defined (HAVE_CUDA) */
 
@@ -118,54 +97,6 @@ void cv::gpu::transpose(const GpuMat& src, GpuMat& dst)
     }
 }
 
-////////////////////////////////////////////////////////////////////////
-// meanStdDev
-
-void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev)
-{
-    CV_Assert(src.type() == CV_8UC1);
-
-    NppiSize sz;
-    sz.width  = src.cols;
-    sz.height = src.rows;
-
-    nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), src.step, sz, mean.val, stddev.val) );
-}
-
-////////////////////////////////////////////////////////////////////////
-// norm
-
-double cv::gpu::norm(const GpuMat& src1, int normType)
-{
-    return norm(src1, GpuMat(src1.size(), src1.type(), Scalar::all(0.0)), normType);
-}
-
-double cv::gpu::norm(const GpuMat& src1, const GpuMat& src2, int normType)
-{
-    CV_DbgAssert(src1.size() == src2.size() && src1.type() == src2.type());
-
-    CV_Assert(src1.type() == CV_8UC1);
-    CV_Assert(normType == NORM_INF || normType == NORM_L1 || normType == NORM_L2);
-
-    typedef NppStatus (*npp_norm_diff_func_t)(const Npp8u* pSrc1, int nSrcStep1, const Npp8u* pSrc2, int nSrcStep2,
-        NppiSize oSizeROI, Npp64f* pRetVal);
-
-    static const npp_norm_diff_func_t npp_norm_diff_func[] = {nppiNormDiff_Inf_8u_C1R, nppiNormDiff_L1_8u_C1R, nppiNormDiff_L2_8u_C1R};
-
-    NppiSize sz;
-    sz.width  = src1.cols;
-    sz.height = src1.rows;
-
-    int funcIdx = normType >> 1;
-    double retVal;
-
-    nppSafeCall( npp_norm_diff_func[funcIdx](src1.ptr<Npp8u>(), src1.step,
-        src2.ptr<Npp8u>(), src2.step,
-        sz, &retVal) );
-
-    return retVal;
-}
-
 ////////////////////////////////////////////////////////////////////////
 // flip
 
@@ -193,305 +124,6 @@ void cv::gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode)
     }
 }
 
-////////////////////////////////////////////////////////////////////////
-// sum
-
-namespace cv { namespace gpu { namespace mathfunc
-{
-    template <typename T>
-    void sum_caller(const DevMem2D src, PtrStep buf, double* sum, int cn);
-
-    template <typename T>
-    void sum_multipass_caller(const DevMem2D src, PtrStep buf, double* sum, int cn);
-
-    template <typename T>
-    void sqsum_caller(const DevMem2D src, PtrStep buf, double* sum, int cn);
-
-    template <typename T>
-    void sqsum_multipass_caller(const DevMem2D src, PtrStep buf, double* sum, int cn);
-
-    namespace sum
-    {
-        void get_buf_size_required(int cols, int rows, int cn, int& bufcols, int& bufrows);
-    }
-}}}
-
-Scalar cv::gpu::sum(const GpuMat& src) 
-{
-    GpuMat buf;
-    return sum(src, buf);
-}
-
-Scalar cv::gpu::sum(const GpuMat& src, GpuMat& buf) 
-{
-    using namespace mathfunc;
-
-    typedef void (*Caller)(const DevMem2D, PtrStep, double*, int);
-    static const Caller callers[2][7] = 
-        { { sum_multipass_caller<unsigned char>, sum_multipass_caller<char>, 
-            sum_multipass_caller<unsigned short>, sum_multipass_caller<short>, 
-            sum_multipass_caller<int>, sum_multipass_caller<float>, 0 },
-          { sum_caller<unsigned char>, sum_caller<char>, 
-            sum_caller<unsigned short>, sum_caller<short>, 
-            sum_caller<int>, sum_caller<float>, 0 } };
-
-    Size bufSize;
-    sum::get_buf_size_required(src.cols, src.rows, src.channels(), bufSize.width, bufSize.height); 
-    buf.create(bufSize, CV_8U);
-
-    Caller caller = callers[hasAtomicsSupport(getDevice())][src.depth()];
-    if (!caller) CV_Error(CV_StsBadArg, "sum: unsupported type");
-
-    double result[4];
-    caller(src, buf, result, src.channels());
-    return Scalar(result[0], result[1], result[2], result[3]);
-}
-
-Scalar cv::gpu::sqrSum(const GpuMat& src) 
-{
-    GpuMat buf;
-    return sqrSum(src, buf);
-}
-
-Scalar cv::gpu::sqrSum(const GpuMat& src, GpuMat& buf) 
-{
-    using namespace mathfunc;
-
-    typedef void (*Caller)(const DevMem2D, PtrStep, double*, int);
-    static const Caller callers[2][7] = 
-        { { sqsum_multipass_caller<unsigned char>, sqsum_multipass_caller<char>, 
-            sqsum_multipass_caller<unsigned short>, sqsum_multipass_caller<short>, 
-            sqsum_multipass_caller<int>, sqsum_multipass_caller<float>, 0 },
-          { sqsum_caller<unsigned char>, sqsum_caller<char>, 
-            sqsum_caller<unsigned short>, sqsum_caller<short>, 
-            sqsum_caller<int>, sqsum_caller<float>, 0 } };
-
-    Size bufSize;
-    sum::get_buf_size_required(src.cols, src.rows, src.channels(), bufSize.width, bufSize.height); 
-    buf.create(bufSize, CV_8U);
-
-    Caller caller = callers[hasAtomicsSupport(getDevice())][src.depth()];
-    if (!caller) CV_Error(CV_StsBadArg, "sqrSum: unsupported type");
-
-    double result[4];
-    caller(src, buf, result, src.channels());
-    return Scalar(result[0], result[1], result[2], result[3]);
-}
-
-////////////////////////////////////////////////////////////////////////
-// minMax
-
-namespace cv { namespace gpu { namespace mathfunc { namespace minmax {
-
-    void get_buf_size_required(int cols, int rows, int elem_size, int& bufcols, int& bufrows);
-    
-    template <typename T> 
-    void min_max_caller(const DevMem2D src, double* minval, double* maxval, PtrStep buf);
-
-    template <typename T> 
-    void min_max_mask_caller(const DevMem2D src, const PtrStep mask, double* minval, double* maxval, PtrStep buf);
-
-    template <typename T> 
-    void min_max_multipass_caller(const DevMem2D src, double* minval, double* maxval, PtrStep buf);
-
-    template <typename T> 
-    void min_max_mask_multipass_caller(const DevMem2D src, const PtrStep mask, double* minval, double* maxval, PtrStep buf);
-
-}}}}
-
-void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask)
-{
-    GpuMat buf;
-    minMax(src, minVal, maxVal, mask, buf);
-}
-
-void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf)
-{
-    using namespace mathfunc::minmax;
-
-    typedef void (*Caller)(const DevMem2D, double*, double*, PtrStep);
-    typedef void (*MaskedCaller)(const DevMem2D, const PtrStep, double*, double*, PtrStep);
-
-    static const Caller callers[2][7] = 
-    { { min_max_multipass_caller<unsigned char>, min_max_multipass_caller<char>, 
-        min_max_multipass_caller<unsigned short>, min_max_multipass_caller<short>, 
-        min_max_multipass_caller<int>, min_max_multipass_caller<float>, 0 },
-      { min_max_caller<unsigned char>, min_max_caller<char>, 
-        min_max_caller<unsigned short>, min_max_caller<short>, 
-        min_max_caller<int>, min_max_caller<float>, min_max_caller<double> } };
-
-    static const MaskedCaller masked_callers[2][7] = 
-    { { min_max_mask_multipass_caller<unsigned char>, min_max_mask_multipass_caller<char>, 
-        min_max_mask_multipass_caller<unsigned short>, min_max_mask_multipass_caller<short>, 
-        min_max_mask_multipass_caller<int>, min_max_mask_multipass_caller<float>, 0 },
-      { min_max_mask_caller<unsigned char>, min_max_mask_caller<char>, 
-        min_max_mask_caller<unsigned short>, min_max_mask_caller<short>, 
-        min_max_mask_caller<int>, min_max_mask_caller<float>, 
-        min_max_mask_caller<double> } };
-
-
-    CV_Assert(src.channels() == 1);
-    CV_Assert(mask.empty() || (mask.type() == CV_8U && src.size() == mask.size()));
-    CV_Assert(src.type() != CV_64F || hasNativeDoubleSupport(getDevice()));
-
-    double minVal_; if (!minVal) minVal = &minVal_;
-    double maxVal_; if (!maxVal) maxVal = &maxVal_;
-    
-    Size bufSize;
-    get_buf_size_required(src.cols, src.rows, src.elemSize(), bufSize.width, bufSize.height);
-    buf.create(bufSize, CV_8U);
-
-    if (mask.empty())
-    {
-        Caller caller = callers[hasAtomicsSupport(getDevice())][src.type()];
-        if (!caller) CV_Error(CV_StsBadArg, "minMax: unsupported type");
-        caller(src, minVal, maxVal, buf);
-    }
-    else
-    {
-        MaskedCaller caller = masked_callers[hasAtomicsSupport(getDevice())][src.type()];
-        if (!caller) CV_Error(CV_StsBadArg, "minMax: unsupported type");
-        caller(src, mask, minVal, maxVal, buf);
-    }
-}
-
-
-////////////////////////////////////////////////////////////////////////
-// minMaxLoc
-
-namespace cv { namespace gpu { namespace mathfunc { namespace minmaxloc {
-
-    void get_buf_size_required(int cols, int rows, int elem_size, int& b1cols, 
-                               int& b1rows, int& b2cols, int& b2rows);
-
-    template <typename T> 
-    void min_max_loc_caller(const DevMem2D src, double* minval, double* maxval, 
-                            int minloc[2], int maxloc[2], PtrStep valbuf, PtrStep locbuf);
-
-    template <typename T> 
-    void min_max_loc_mask_caller(const DevMem2D src, const PtrStep mask, double* minval, double* maxval, 
-                                 int minloc[2], int maxloc[2], PtrStep valbuf, PtrStep locbuf);
-
-    template <typename T> 
-    void min_max_loc_multipass_caller(const DevMem2D src, double* minval, double* maxval, 
-                                     int minloc[2], int maxloc[2], PtrStep valbuf, PtrStep locbuf);
-
-    template <typename T> 
-    void min_max_loc_mask_multipass_caller(const DevMem2D src, const PtrStep mask, double* minval, double* maxval, 
-                                           int minloc[2], int maxloc[2], PtrStep valbuf, PtrStep locbuf);
-
-
-}}}}
-
-void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, const GpuMat& mask)
-{    
-    GpuMat valbuf, locbuf;
-    minMaxLoc(src, minVal, maxVal, minLoc, maxLoc, mask, valbuf, locbuf);
-}
-
-void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
-                        const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf)
-{
-    using namespace mathfunc::minmaxloc;
-
-    typedef void (*Caller)(const DevMem2D, double*, double*, int[2], int[2], PtrStep, PtrStep);
-    typedef void (*MaskedCaller)(const DevMem2D, const PtrStep, double*, double*, int[2], int[2], PtrStep, PtrStep);
-
-    static const Caller callers[2][7] = 
-    { { min_max_loc_multipass_caller<unsigned char>, min_max_loc_multipass_caller<char>, 
-        min_max_loc_multipass_caller<unsigned short>, min_max_loc_multipass_caller<short>, 
-        min_max_loc_multipass_caller<int>, min_max_loc_multipass_caller<float>, 0 },
-      { min_max_loc_caller<unsigned char>, min_max_loc_caller<char>, 
-        min_max_loc_caller<unsigned short>, min_max_loc_caller<short>, 
-        min_max_loc_caller<int>, min_max_loc_caller<float>, min_max_loc_caller<double> } };
-
-    static const MaskedCaller masked_callers[2][7] = 
-    { { min_max_loc_mask_multipass_caller<unsigned char>, min_max_loc_mask_multipass_caller<char>, 
-        min_max_loc_mask_multipass_caller<unsigned short>, min_max_loc_mask_multipass_caller<short>, 
-        min_max_loc_mask_multipass_caller<int>, min_max_loc_mask_multipass_caller<float>, 0 },
-      { min_max_loc_mask_caller<unsigned char>, min_max_loc_mask_caller<char>, 
-        min_max_loc_mask_caller<unsigned short>, min_max_loc_mask_caller<short>, 
-        min_max_loc_mask_caller<int>, min_max_loc_mask_caller<float>, min_max_loc_mask_caller<double> } };
-
-    CV_Assert(src.channels() == 1);
-    CV_Assert(mask.empty() || (mask.type() == CV_8U && src.size() == mask.size()));
-    CV_Assert(src.type() != CV_64F || hasNativeDoubleSupport(getDevice()));
-
-    double minVal_; if (!minVal) minVal = &minVal_;
-    double maxVal_; if (!maxVal) maxVal = &maxVal_;
-    int minLoc_[2];
-    int maxLoc_[2];
-
-    Size valbuf_size, locbuf_size;
-    get_buf_size_required(src.cols, src.rows, src.elemSize(), valbuf_size.width, 
-                          valbuf_size.height, locbuf_size.width, locbuf_size.height);
-    valbuf.create(valbuf_size, CV_8U);
-    locbuf.create(locbuf_size, CV_8U);
-
-    if (mask.empty())
-    {
-        Caller caller = callers[hasAtomicsSupport(getDevice())][src.type()];
-        if (!caller) CV_Error(CV_StsBadArg, "minMaxLoc: unsupported type");
-        caller(src, minVal, maxVal, minLoc_, maxLoc_, valbuf, locbuf);
-    }
-    else
-    {
-        MaskedCaller caller = masked_callers[hasAtomicsSupport(getDevice())][src.type()];
-        if (!caller) CV_Error(CV_StsBadArg, "minMaxLoc: unsupported type");
-        caller(src, mask, minVal, maxVal, minLoc_, maxLoc_, valbuf, locbuf);
-    }
-
-    if (minLoc) { minLoc->x = minLoc_[0]; minLoc->y = minLoc_[1]; }
-    if (maxLoc) { maxLoc->x = maxLoc_[0]; maxLoc->y = maxLoc_[1]; }
-}
-
-////////////////////////////////////////////////////////////////////////
-// Count non zero
-
-namespace cv { namespace gpu { namespace mathfunc { namespace countnonzero {
-
-    void get_buf_size_required(int cols, int rows, int& bufcols, int& bufrows);
-
-    template <typename T> 
-    int count_non_zero_caller(const DevMem2D src, PtrStep buf);
-
-    template <typename T> 
-    int count_non_zero_multipass_caller(const DevMem2D src, PtrStep buf);
-
-}}}}
-
-int cv::gpu::countNonZero(const GpuMat& src)
-{
-    GpuMat buf;
-    return countNonZero(src, buf);
-}
-
-int cv::gpu::countNonZero(const GpuMat& src, GpuMat& buf)
-{
-    using namespace mathfunc::countnonzero;
-
-    typedef int (*Caller)(const DevMem2D src, PtrStep buf);
-
-    static const Caller callers[2][7] = 
-    { { count_non_zero_multipass_caller<unsigned char>, count_non_zero_multipass_caller<char>,
-        count_non_zero_multipass_caller<unsigned short>, count_non_zero_multipass_caller<short>,
-        count_non_zero_multipass_caller<int>, count_non_zero_multipass_caller<float>, 0},
-      { count_non_zero_caller<unsigned char>, count_non_zero_caller<char>,
-        count_non_zero_caller<unsigned short>, count_non_zero_caller<short>,
-        count_non_zero_caller<int>, count_non_zero_caller<float>, count_non_zero_caller<double> } };
-
-    CV_Assert(src.channels() == 1);
-    CV_Assert(src.type() != CV_64F || hasNativeDoubleSupport(getDevice()));
-
-    Size buf_size;
-    get_buf_size_required(src.cols, src.rows, buf_size.width, buf_size.height);
-    buf.create(buf_size, CV_8U);
-
-    Caller caller = callers[hasAtomicsSupport(getDevice())][src.type()];
-    if (!caller) CV_Error(CV_StsBadArg, "countNonZero: unsupported type");
-    return caller(src, buf);
-}
-
 ////////////////////////////////////////////////////////////////////////
 // LUT
 
@@ -711,144 +343,4 @@ void cv::gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat&
 }
 
 
-//////////////////////////////////////////////////////////////////////////////
-// min/max
-
-namespace cv { namespace gpu { namespace mathfunc
-{
-    template <typename T>
-    void min_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream);
-
-    template <typename T>
-    void max_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream);
-
-    template <typename T>
-    void min_gpu(const DevMem2D_<T>& src1, double src2, const DevMem2D_<T>& dst, cudaStream_t stream);
-
-    template <typename T>
-    void max_gpu(const DevMem2D_<T>& src1, double src2, const DevMem2D_<T>& dst, cudaStream_t stream);
-}}}
-
-namespace
-{
-    template <typename T>
-    void min_caller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream)
-    {
-        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
-        dst.create(src1.size(), src1.type());
-        mathfunc::min_gpu<T>(src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
-    }
-
-    template <typename T>
-    void min_caller(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream)
-    {
-        dst.create(src1.size(), src1.type());
-        mathfunc::min_gpu<T>(src1.reshape(1), src2, dst.reshape(1), stream);
-    }
-    
-    template <typename T>
-    void max_caller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream)
-    {
-        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
-        dst.create(src1.size(), src1.type());
-        mathfunc::max_gpu<T>(src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
-    }
-
-    template <typename T>
-    void max_caller(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream)
-    {
-        dst.create(src1.size(), src1.type());
-        mathfunc::max_gpu<T>(src1.reshape(1), src2, dst.reshape(1), stream);
-    }
-}
-
-void cv::gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) 
-{ 
-    typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream);
-    static const func_t funcs[] = 
-    {
-        min_caller<uchar>, min_caller<char>, min_caller<ushort>, min_caller<short>, min_caller<int>, 
-        min_caller<float>, min_caller<double>
-    };
-    funcs[src1.depth()](src1, src2, dst, 0);
-}
-
-void cv::gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream) 
-{ 
-    typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream);
-    static const func_t funcs[] = 
-    {
-        min_caller<uchar>, min_caller<char>, min_caller<ushort>, min_caller<short>, min_caller<int>, 
-        min_caller<float>, min_caller<double>
-    };
-    funcs[src1.depth()](src1, src2, dst, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::min(const GpuMat& src1, double src2, GpuMat& dst) 
-{
-    typedef void (*func_t)(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream);
-    static const func_t funcs[] = 
-    {
-        min_caller<uchar>, min_caller<char>, min_caller<ushort>, min_caller<short>, min_caller<int>, 
-        min_caller<float>, min_caller<double>
-    };
-    funcs[src1.depth()](src1, src2, dst, 0);
-}
-
-void cv::gpu::min(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream) 
-{
-    typedef void (*func_t)(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream);
-    static const func_t funcs[] = 
-    {
-        min_caller<uchar>, min_caller<char>, min_caller<ushort>, min_caller<short>, min_caller<int>, 
-        min_caller<float>, min_caller<double>
-    };
-    funcs[src1.depth()](src1, src2, dst, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) 
-{ 
-    typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream);
-    static const func_t funcs[] = 
-    {
-        max_caller<uchar>, max_caller<char>, max_caller<ushort>, max_caller<short>, max_caller<int>, 
-        max_caller<float>, max_caller<double>
-    };
-    funcs[src1.depth()](src1, src2, dst, 0);
-}
-
-void cv::gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream) 
-{ 
-    typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream);
-    static const func_t funcs[] = 
-    {
-        max_caller<uchar>, max_caller<char>, max_caller<ushort>, max_caller<short>, max_caller<int>, 
-        max_caller<float>, max_caller<double>
-    };
-    funcs[src1.depth()](src1, src2, dst, StreamAccessor::getStream(stream));
-}
-
-void cv::gpu::max(const GpuMat& src1, double src2, GpuMat& dst) 
-{
-    typedef void (*func_t)(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream);
-    static const func_t funcs[] = 
-    {
-        max_caller<uchar>, max_caller<char>, max_caller<ushort>, max_caller<short>, max_caller<int>, 
-        max_caller<float>, max_caller<double>
-    };
-    funcs[src1.depth()](src1, src2, dst, 0);
-}
-
-void cv::gpu::max(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream) 
-{
-    typedef void (*func_t)(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream);
-    static const func_t funcs[] = 
-    {
-        max_caller<uchar>, max_caller<char>, max_caller<ushort>, max_caller<short>, max_caller<int>, 
-        max_caller<float>, max_caller<double>
-    };
-    funcs[src1.depth()](src1, src2, dst, StreamAccessor::getStream(stream));
-}
-
-
 #endif /* !defined (HAVE_CUDA) */

modules/gpu/src/cuda/element_operations.cu

@@ -345,4 +345,127 @@ namespace cv { namespace gpu { namespace mathfunc
     template void bitwiseMaskXorCaller<ushort>(int, int, int, const PtrStep, const PtrStep, const PtrStep, PtrStep, cudaStream_t);
     template void bitwiseMaskXorCaller<uint>(int, int, int, const PtrStep, const PtrStep, const PtrStep, PtrStep, cudaStream_t);
 
+
+    //////////////////////////////////////////////////////////////////////////
+    // min/max
+
+    struct MinOp
+    {        
+        template <typename T>
+        __device__ T operator()(T a, T b)
+        {
+            return min(a, b);
+        }
+        __device__ float operator()(float a, float b)
+        {
+            return fmin(a, b);
+        }
+        __device__ double operator()(double a, double b)
+        {
+            return fmin(a, b);
+        }
+    };
+
+    struct MaxOp
+    {        
+        template <typename T>
+        __device__ T operator()(T a, T b)
+        {
+            return max(a, b);
+        }
+        __device__ float operator()(float a, float b)
+        {
+            return fmax(a, b);
+        }
+        __device__ double operator()(double a, double b)
+        {
+            return fmax(a, b);
+        }
+    };
+    
+    struct ScalarMinOp
+    {
+        double s;
+
+        explicit ScalarMinOp(double s_) : s(s_) {}
+
+        template <typename T>
+        __device__ T operator()(T a)
+        {
+            return saturate_cast<T>(fmin((double)a, s));
+        }
+    };
+    
+    struct ScalarMaxOp
+    {
+        double s;
+
+        explicit ScalarMaxOp(double s_) : s(s_) {}
+
+        template <typename T>
+        __device__ T operator()(T a)
+        {
+            return saturate_cast<T>(fmax((double)a, s));
+        }
+    };
+    
+    template <typename T>
+    void min_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {
+        MinOp op;
+        transform(src1, src2, dst, op, stream);    
+    }
+
+    template void min_gpu<uchar >(const DevMem2D& src1, const DevMem2D& src2, const DevMem2D& dst, cudaStream_t stream);
+    template void min_gpu<char  >(const DevMem2D_<char>& src1, const DevMem2D_<char>& src2, const DevMem2D_<char>& dst, cudaStream_t stream);
+    template void min_gpu<ushort>(const DevMem2D_<ushort>& src1, const DevMem2D_<ushort>& src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
+    template void min_gpu<short >(const DevMem2D_<short>& src1, const DevMem2D_<short>& src2, const DevMem2D_<short>& dst, cudaStream_t stream);
+    template void min_gpu<int   >(const DevMem2D_<int>& src1, const DevMem2D_<int>& src2, const DevMem2D_<int>& dst, cudaStream_t stream);
+    template void min_gpu<float >(const DevMem2D_<float>& src1, const DevMem2D_<float>& src2, const DevMem2D_<float>& dst, cudaStream_t stream);
+    template void min_gpu<double>(const DevMem2D_<double>& src1, const DevMem2D_<double>& src2, const DevMem2D_<double>& dst, cudaStream_t stream);
+
+    template <typename T>
+    void max_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {
+        MaxOp op;
+        transform(src1, src2, dst, op, stream);    
+    }
+    
+    template void max_gpu<uchar >(const DevMem2D& src1, const DevMem2D& src2, const DevMem2D& dst, cudaStream_t stream);
+    template void max_gpu<char  >(const DevMem2D_<char>& src1, const DevMem2D_<char>& src2, const DevMem2D_<char>& dst, cudaStream_t stream);
+    template void max_gpu<ushort>(const DevMem2D_<ushort>& src1, const DevMem2D_<ushort>& src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
+    template void max_gpu<short >(const DevMem2D_<short>& src1, const DevMem2D_<short>& src2, const DevMem2D_<short>& dst, cudaStream_t stream);
+    template void max_gpu<int   >(const DevMem2D_<int>& src1, const DevMem2D_<int>& src2, const DevMem2D_<int>& dst, cudaStream_t stream);
+    template void max_gpu<float >(const DevMem2D_<float>& src1, const DevMem2D_<float>& src2, const DevMem2D_<float>& dst, cudaStream_t stream);
+    template void max_gpu<double>(const DevMem2D_<double>& src1, const DevMem2D_<double>& src2, const DevMem2D_<double>& dst, cudaStream_t stream);
+
+    template <typename T>
+    void min_gpu(const DevMem2D_<T>& src1, double src2, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {
+        ScalarMinOp op(src2);
+        transform(src1, dst, op, stream);    
+    }
+
+    template void min_gpu<uchar >(const DevMem2D& src1, double src2, const DevMem2D& dst, cudaStream_t stream);
+    template void min_gpu<char  >(const DevMem2D_<char>& src1, double src2, const DevMem2D_<char>& dst, cudaStream_t stream);
+    template void min_gpu<ushort>(const DevMem2D_<ushort>& src1, double src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
+    template void min_gpu<short >(const DevMem2D_<short>& src1, double src2, const DevMem2D_<short>& dst, cudaStream_t stream);
+    template void min_gpu<int   >(const DevMem2D_<int>& src1, double src2, const DevMem2D_<int>& dst, cudaStream_t stream);
+    template void min_gpu<float >(const DevMem2D_<float>& src1, double src2, const DevMem2D_<float>& dst, cudaStream_t stream);
+    template void min_gpu<double>(const DevMem2D_<double>& src1, double src2, const DevMem2D_<double>& dst, cudaStream_t stream);
+    
+    template <typename T>
+    void max_gpu(const DevMem2D_<T>& src1, double src2, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {
+        ScalarMaxOp op(src2);
+        transform(src1, dst, op, stream);    
+    }
+
+    template void max_gpu<uchar >(const DevMem2D& src1, double src2, const DevMem2D& dst, cudaStream_t stream);
+    template void max_gpu<char  >(const DevMem2D_<char>& src1, double src2, const DevMem2D_<char>& dst, cudaStream_t stream);
+    template void max_gpu<ushort>(const DevMem2D_<ushort>& src1, double src2, const DevMem2D_<ushort>& dst, cudaStream_t stream);
+    template void max_gpu<short >(const DevMem2D_<short>& src1, double src2, const DevMem2D_<short>& dst, cudaStream_t stream);
+    template void max_gpu<int   >(const DevMem2D_<int>& src1, double src2, const DevMem2D_<int>& dst, cudaStream_t stream);
+    template void max_gpu<float >(const DevMem2D_<float>& src1, double src2, const DevMem2D_<float>& dst, cudaStream_t stream);
+    template void max_gpu<double>(const DevMem2D_<double>& src1, double src2, const DevMem2D_<double>& dst, cudaStream_t stream);
 }}}

modules/gpu/src/element_operations.cpp

@@ -66,10 +66,14 @@ void cv::gpu::bitwise_and(const GpuMat&, const GpuMat&, GpuMat&, const GpuMat&)
 void cv::gpu::bitwise_and(const GpuMat&, const GpuMat&, GpuMat&, const GpuMat&, const Stream&) { throw_nogpu(); }
 void cv::gpu::bitwise_xor(const GpuMat&, const GpuMat&, GpuMat&, const GpuMat&) { throw_nogpu(); }
 void cv::gpu::bitwise_xor(const GpuMat&, const GpuMat&, GpuMat&, const GpuMat&, const Stream&) { throw_nogpu(); }
-cv::gpu::GpuMat cv::gpu::operator ~ (const GpuMat&) { throw_nogpu(); return GpuMat(); }
+void cv::gpu::min(const GpuMat&, const GpuMat&, GpuMat&) { throw_nogpu(); }
-cv::gpu::GpuMat cv::gpu::operator | (const GpuMat&, const GpuMat&) { throw_nogpu(); return GpuMat(); }
+void cv::gpu::min(const GpuMat&, const GpuMat&, GpuMat&, const Stream&) { throw_nogpu(); }
-cv::gpu::GpuMat cv::gpu::operator & (const GpuMat&, const GpuMat&) { throw_nogpu(); return GpuMat(); }
+void cv::gpu::min(const GpuMat&, double, GpuMat&) { throw_nogpu(); }
-cv::gpu::GpuMat cv::gpu::operator ^ (const GpuMat&, const GpuMat&) { throw_nogpu(); return GpuMat(); }
+void cv::gpu::min(const GpuMat&, double, GpuMat&, const Stream&) { throw_nogpu(); }
+void cv::gpu::max(const GpuMat&, const GpuMat&, GpuMat&) { throw_nogpu(); }
+void cv::gpu::max(const GpuMat&, const GpuMat&, GpuMat&, const Stream&) { throw_nogpu(); }
+void cv::gpu::max(const GpuMat&, double, GpuMat&) { throw_nogpu(); }
+void cv::gpu::max(const GpuMat&, double, GpuMat&, const Stream&) { throw_nogpu(); }
 
 #else
 
@@ -574,4 +578,144 @@ void cv::gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, c
         ::bitwiseXorCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
 }
 
+
+//////////////////////////////////////////////////////////////////////////////
+// Minimum and maximum operations
+
+namespace cv { namespace gpu { namespace mathfunc
+{
+    template <typename T>
+    void min_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream);
+
+    template <typename T>
+    void max_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream);
+
+    template <typename T>
+    void min_gpu(const DevMem2D_<T>& src1, double src2, const DevMem2D_<T>& dst, cudaStream_t stream);
+
+    template <typename T>
+    void max_gpu(const DevMem2D_<T>& src1, double src2, const DevMem2D_<T>& dst, cudaStream_t stream);
+}}}
+
+namespace
+{
+    template <typename T>
+    void min_caller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream)
+    {
+        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
+        dst.create(src1.size(), src1.type());
+        mathfunc::min_gpu<T>(src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
+    }
+
+    template <typename T>
+    void min_caller(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream)
+    {
+        dst.create(src1.size(), src1.type());
+        mathfunc::min_gpu<T>(src1.reshape(1), src2, dst.reshape(1), stream);
+    }
+    
+    template <typename T>
+    void max_caller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream)
+    {
+        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
+        dst.create(src1.size(), src1.type());
+        mathfunc::max_gpu<T>(src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
+    }
+
+    template <typename T>
+    void max_caller(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream)
+    {
+        dst.create(src1.size(), src1.type());
+        mathfunc::max_gpu<T>(src1.reshape(1), src2, dst.reshape(1), stream);
+    }
+}
+
+void cv::gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) 
+{ 
+    typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream);
+    static const func_t funcs[] = 
+    {
+        min_caller<uchar>, min_caller<char>, min_caller<ushort>, min_caller<short>, min_caller<int>, 
+        min_caller<float>, min_caller<double>
+    };
+    funcs[src1.depth()](src1, src2, dst, 0);
+}
+
+void cv::gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream) 
+{ 
+    typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream);
+    static const func_t funcs[] = 
+    {
+        min_caller<uchar>, min_caller<char>, min_caller<ushort>, min_caller<short>, min_caller<int>, 
+        min_caller<float>, min_caller<double>
+    };
+    funcs[src1.depth()](src1, src2, dst, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::min(const GpuMat& src1, double src2, GpuMat& dst) 
+{
+    typedef void (*func_t)(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream);
+    static const func_t funcs[] = 
+    {
+        min_caller<uchar>, min_caller<char>, min_caller<ushort>, min_caller<short>, min_caller<int>, 
+        min_caller<float>, min_caller<double>
+    };
+    funcs[src1.depth()](src1, src2, dst, 0);
+}
+
+void cv::gpu::min(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream) 
+{
+    typedef void (*func_t)(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream);
+    static const func_t funcs[] = 
+    {
+        min_caller<uchar>, min_caller<char>, min_caller<ushort>, min_caller<short>, min_caller<int>, 
+        min_caller<float>, min_caller<double>
+    };
+    funcs[src1.depth()](src1, src2, dst, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) 
+{ 
+    typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream);
+    static const func_t funcs[] = 
+    {
+        max_caller<uchar>, max_caller<char>, max_caller<ushort>, max_caller<short>, max_caller<int>, 
+        max_caller<float>, max_caller<double>
+    };
+    funcs[src1.depth()](src1, src2, dst, 0);
+}
+
+void cv::gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream) 
+{ 
+    typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream);
+    static const func_t funcs[] = 
+    {
+        max_caller<uchar>, max_caller<char>, max_caller<ushort>, max_caller<short>, max_caller<int>, 
+        max_caller<float>, max_caller<double>
+    };
+    funcs[src1.depth()](src1, src2, dst, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::max(const GpuMat& src1, double src2, GpuMat& dst) 
+{
+    typedef void (*func_t)(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream);
+    static const func_t funcs[] = 
+    {
+        max_caller<uchar>, max_caller<char>, max_caller<ushort>, max_caller<short>, max_caller<int>, 
+        max_caller<float>, max_caller<double>
+    };
+    funcs[src1.depth()](src1, src2, dst, 0);
+}
+
+void cv::gpu::max(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream) 
+{
+    typedef void (*func_t)(const GpuMat& src1, double src2, GpuMat& dst, cudaStream_t stream);
+    static const func_t funcs[] = 
+    {
+        max_caller<uchar>, max_caller<char>, max_caller<ushort>, max_caller<short>, max_caller<int>, 
+        max_caller<float>, max_caller<double>
+    };
+    funcs[src1.depth()](src1, src2, dst, StreamAccessor::getStream(stream));
+}
+
 #endif

modules/gpu/src/matrix_reductions.cpp

@@ -0,0 +1,423 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other GpuMaterials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or bpied warranties, including, but not limited to, the bpied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+using namespace cv;
+using namespace cv::gpu;
+
+#if !defined (HAVE_CUDA)
+
+void cv::gpu::meanStdDev(const GpuMat&, Scalar&, Scalar&) { throw_nogpu(); }
+double cv::gpu::norm(const GpuMat&, int) { throw_nogpu(); return 0.0; }
+double cv::gpu::norm(const GpuMat&, const GpuMat&, int) { throw_nogpu(); return 0.0; }
+Scalar cv::gpu::sum(const GpuMat&) { throw_nogpu(); return Scalar(); }
+Scalar cv::gpu::sum(const GpuMat&, GpuMat&) { throw_nogpu(); return Scalar(); }
+Scalar cv::gpu::sqrSum(const GpuMat&) { throw_nogpu(); return Scalar(); }
+Scalar cv::gpu::sqrSum(const GpuMat&, GpuMat&) { throw_nogpu(); return Scalar(); }
+void cv::gpu::minMax(const GpuMat&, double*, double*, const GpuMat&) { throw_nogpu(); }
+void cv::gpu::minMax(const GpuMat&, double*, double*, const GpuMat&, GpuMat&) { throw_nogpu(); }
+void cv::gpu::minMaxLoc(const GpuMat&, double*, double*, Point*, Point*, const GpuMat&) { throw_nogpu(); }
+void cv::gpu::minMaxLoc(const GpuMat&, double*, double*, Point*, Point*, const GpuMat&, GpuMat&, GpuMat&) { throw_nogpu(); }
+int cv::gpu::countNonZero(const GpuMat&) { throw_nogpu(); return 0; }
+int cv::gpu::countNonZero(const GpuMat&, GpuMat&) { throw_nogpu(); return 0; }
+
+#else
+
+
+////////////////////////////////////////////////////////////////////////
+// meanStdDev
+
+void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev)
+{
+    CV_Assert(src.type() == CV_8UC1);
+
+    NppiSize sz;
+    sz.width  = src.cols;
+    sz.height = src.rows;
+
+    nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), src.step, sz, mean.val, stddev.val) );
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// norm
+
+double cv::gpu::norm(const GpuMat& src1, int normType)
+{
+    return norm(src1, GpuMat(src1.size(), src1.type(), Scalar::all(0.0)), normType);
+}
+
+double cv::gpu::norm(const GpuMat& src1, const GpuMat& src2, int normType)
+{
+    CV_DbgAssert(src1.size() == src2.size() && src1.type() == src2.type());
+
+    CV_Assert(src1.type() == CV_8UC1);
+    CV_Assert(normType == NORM_INF || normType == NORM_L1 || normType == NORM_L2);
+
+    typedef NppStatus (*npp_norm_diff_func_t)(const Npp8u* pSrc1, int nSrcStep1, const Npp8u* pSrc2, int nSrcStep2,
+        NppiSize oSizeROI, Npp64f* pRetVal);
+
+    static const npp_norm_diff_func_t npp_norm_diff_func[] = {nppiNormDiff_Inf_8u_C1R, nppiNormDiff_L1_8u_C1R, nppiNormDiff_L2_8u_C1R};
+
+    NppiSize sz;
+    sz.width  = src1.cols;
+    sz.height = src1.rows;
+
+    int funcIdx = normType >> 1;
+    double retVal;
+
+    nppSafeCall( npp_norm_diff_func[funcIdx](src1.ptr<Npp8u>(), src1.step,
+        src2.ptr<Npp8u>(), src2.step,
+        sz, &retVal) );
+
+    return retVal;
+}
+
+////////////////////////////////////////////////////////////////////////
+// Sum
+
+namespace cv { namespace gpu { namespace mathfunc
+{
+    template <typename T>
+    void sum_caller(const DevMem2D src, PtrStep buf, double* sum, int cn);
+
+    template <typename T>
+    void sum_multipass_caller(const DevMem2D src, PtrStep buf, double* sum, int cn);
+
+    template <typename T>
+    void sqsum_caller(const DevMem2D src, PtrStep buf, double* sum, int cn);
+
+    template <typename T>
+    void sqsum_multipass_caller(const DevMem2D src, PtrStep buf, double* sum, int cn);
+
+    namespace sum
+    {
+        void get_buf_size_required(int cols, int rows, int cn, int& bufcols, int& bufrows);
+    }
+}}}
+
+
+Scalar cv::gpu::sum(const GpuMat& src) 
+{
+    GpuMat buf;
+    return sum(src, buf);
+}
+
+
+Scalar cv::gpu::sum(const GpuMat& src, GpuMat& buf) 
+{
+    using namespace mathfunc;
+
+    typedef void (*Caller)(const DevMem2D, PtrStep, double*, int);
+    static const Caller callers[2][7] = 
+        { { sum_multipass_caller<unsigned char>, sum_multipass_caller<char>, 
+            sum_multipass_caller<unsigned short>, sum_multipass_caller<short>, 
+            sum_multipass_caller<int>, sum_multipass_caller<float>, 0 },
+          { sum_caller<unsigned char>, sum_caller<char>, 
+            sum_caller<unsigned short>, sum_caller<short>, 
+            sum_caller<int>, sum_caller<float>, 0 } };
+
+    Size bufSize;
+    sum::get_buf_size_required(src.cols, src.rows, src.channels(), bufSize.width, bufSize.height); 
+    buf.create(bufSize, CV_8U);
+
+    Caller caller = callers[hasAtomicsSupport(getDevice())][src.depth()];
+    if (!caller) CV_Error(CV_StsBadArg, "sum: unsupported type");
+
+    double result[4];
+    caller(src, buf, result, src.channels());
+    return Scalar(result[0], result[1], result[2], result[3]);
+}
+
+
+Scalar cv::gpu::sqrSum(const GpuMat& src) 
+{
+    GpuMat buf;
+    return sqrSum(src, buf);
+}
+
+
+Scalar cv::gpu::sqrSum(const GpuMat& src, GpuMat& buf) 
+{
+    using namespace mathfunc;
+
+    typedef void (*Caller)(const DevMem2D, PtrStep, double*, int);
+    static const Caller callers[2][7] = 
+        { { sqsum_multipass_caller<unsigned char>, sqsum_multipass_caller<char>, 
+            sqsum_multipass_caller<unsigned short>, sqsum_multipass_caller<short>, 
+            sqsum_multipass_caller<int>, sqsum_multipass_caller<float>, 0 },
+          { sqsum_caller<unsigned char>, sqsum_caller<char>, 
+            sqsum_caller<unsigned short>, sqsum_caller<short>, 
+            sqsum_caller<int>, sqsum_caller<float>, 0 } };
+
+    Size bufSize;
+    sum::get_buf_size_required(src.cols, src.rows, src.channels(), bufSize.width, bufSize.height); 
+    buf.create(bufSize, CV_8U);
+
+    Caller caller = callers[hasAtomicsSupport(getDevice())][src.depth()];
+    if (!caller) CV_Error(CV_StsBadArg, "sqrSum: unsupported type");
+
+    double result[4];
+    caller(src, buf, result, src.channels());
+    return Scalar(result[0], result[1], result[2], result[3]);
+}
+
+////////////////////////////////////////////////////////////////////////
+// Find min or max
+
+namespace cv { namespace gpu { namespace mathfunc { namespace minmax {
+
+    void get_buf_size_required(int cols, int rows, int elem_size, int& bufcols, int& bufrows);
+    
+    template <typename T> 
+    void min_max_caller(const DevMem2D src, double* minval, double* maxval, PtrStep buf);
+
+    template <typename T> 
+    void min_max_mask_caller(const DevMem2D src, const PtrStep mask, double* minval, double* maxval, PtrStep buf);
+
+    template <typename T> 
+    void min_max_multipass_caller(const DevMem2D src, double* minval, double* maxval, PtrStep buf);
+
+    template <typename T> 
+    void min_max_mask_multipass_caller(const DevMem2D src, const PtrStep mask, double* minval, double* maxval, PtrStep buf);
+
+}}}}
+
+
+void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask)
+{
+    GpuMat buf;
+    minMax(src, minVal, maxVal, mask, buf);
+}
+
+
+void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf)
+{
+    using namespace mathfunc::minmax;
+
+    typedef void (*Caller)(const DevMem2D, double*, double*, PtrStep);
+    typedef void (*MaskedCaller)(const DevMem2D, const PtrStep, double*, double*, PtrStep);
+
+    static const Caller callers[2][7] = 
+    { { min_max_multipass_caller<unsigned char>, min_max_multipass_caller<char>, 
+        min_max_multipass_caller<unsigned short>, min_max_multipass_caller<short>, 
+        min_max_multipass_caller<int>, min_max_multipass_caller<float>, 0 },
+      { min_max_caller<unsigned char>, min_max_caller<char>, 
+        min_max_caller<unsigned short>, min_max_caller<short>, 
+        min_max_caller<int>, min_max_caller<float>, min_max_caller<double> } };
+
+    static const MaskedCaller masked_callers[2][7] = 
+    { { min_max_mask_multipass_caller<unsigned char>, min_max_mask_multipass_caller<char>, 
+        min_max_mask_multipass_caller<unsigned short>, min_max_mask_multipass_caller<short>, 
+        min_max_mask_multipass_caller<int>, min_max_mask_multipass_caller<float>, 0 },
+      { min_max_mask_caller<unsigned char>, min_max_mask_caller<char>, 
+        min_max_mask_caller<unsigned short>, min_max_mask_caller<short>, 
+        min_max_mask_caller<int>, min_max_mask_caller<float>, 
+        min_max_mask_caller<double> } };
+
+
+    CV_Assert(src.channels() == 1);
+    CV_Assert(mask.empty() || (mask.type() == CV_8U && src.size() == mask.size()));
+    CV_Assert(src.type() != CV_64F || hasNativeDoubleSupport(getDevice()));
+
+    double minVal_; if (!minVal) minVal = &minVal_;
+    double maxVal_; if (!maxVal) maxVal = &maxVal_;
+    
+    Size bufSize;
+    get_buf_size_required(src.cols, src.rows, src.elemSize(), bufSize.width, bufSize.height);
+    buf.create(bufSize, CV_8U);
+
+    if (mask.empty())
+    {
+        Caller caller = callers[hasAtomicsSupport(getDevice())][src.type()];
+        if (!caller) CV_Error(CV_StsBadArg, "minMax: unsupported type");
+        caller(src, minVal, maxVal, buf);
+    }
+    else
+    {
+        MaskedCaller caller = masked_callers[hasAtomicsSupport(getDevice())][src.type()];
+        if (!caller) CV_Error(CV_StsBadArg, "minMax: unsupported type");
+        caller(src, mask, minVal, maxVal, buf);
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// Locate min and max
+
+namespace cv { namespace gpu { namespace mathfunc { namespace minmaxloc {
+
+    void get_buf_size_required(int cols, int rows, int elem_size, int& b1cols, 
+                               int& b1rows, int& b2cols, int& b2rows);
+
+    template <typename T> 
+    void min_max_loc_caller(const DevMem2D src, double* minval, double* maxval, 
+                            int minloc[2], int maxloc[2], PtrStep valbuf, PtrStep locbuf);
+
+    template <typename T> 
+    void min_max_loc_mask_caller(const DevMem2D src, const PtrStep mask, double* minval, double* maxval, 
+                                 int minloc[2], int maxloc[2], PtrStep valbuf, PtrStep locbuf);
+
+    template <typename T> 
+    void min_max_loc_multipass_caller(const DevMem2D src, double* minval, double* maxval, 
+                                     int minloc[2], int maxloc[2], PtrStep valbuf, PtrStep locbuf);
+
+    template <typename T> 
+    void min_max_loc_mask_multipass_caller(const DevMem2D src, const PtrStep mask, double* minval, double* maxval, 
+                                           int minloc[2], int maxloc[2], PtrStep valbuf, PtrStep locbuf);
+}}}}
+
+
+void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, const GpuMat& mask)
+{    
+    GpuMat valbuf, locbuf;
+    minMaxLoc(src, minVal, maxVal, minLoc, maxLoc, mask, valbuf, locbuf);
+}
+
+
+void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
+                        const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf)
+{
+    using namespace mathfunc::minmaxloc;
+
+    typedef void (*Caller)(const DevMem2D, double*, double*, int[2], int[2], PtrStep, PtrStep);
+    typedef void (*MaskedCaller)(const DevMem2D, const PtrStep, double*, double*, int[2], int[2], PtrStep, PtrStep);
+
+    static const Caller callers[2][7] = 
+    { { min_max_loc_multipass_caller<unsigned char>, min_max_loc_multipass_caller<char>, 
+        min_max_loc_multipass_caller<unsigned short>, min_max_loc_multipass_caller<short>, 
+        min_max_loc_multipass_caller<int>, min_max_loc_multipass_caller<float>, 0 },
+      { min_max_loc_caller<unsigned char>, min_max_loc_caller<char>, 
+        min_max_loc_caller<unsigned short>, min_max_loc_caller<short>, 
+        min_max_loc_caller<int>, min_max_loc_caller<float>, min_max_loc_caller<double> } };
+
+    static const MaskedCaller masked_callers[2][7] = 
+    { { min_max_loc_mask_multipass_caller<unsigned char>, min_max_loc_mask_multipass_caller<char>, 
+        min_max_loc_mask_multipass_caller<unsigned short>, min_max_loc_mask_multipass_caller<short>, 
+        min_max_loc_mask_multipass_caller<int>, min_max_loc_mask_multipass_caller<float>, 0 },
+      { min_max_loc_mask_caller<unsigned char>, min_max_loc_mask_caller<char>, 
+        min_max_loc_mask_caller<unsigned short>, min_max_loc_mask_caller<short>, 
+        min_max_loc_mask_caller<int>, min_max_loc_mask_caller<float>, min_max_loc_mask_caller<double> } };
+
+    CV_Assert(src.channels() == 1);
+    CV_Assert(mask.empty() || (mask.type() == CV_8U && src.size() == mask.size()));
+    CV_Assert(src.type() != CV_64F || hasNativeDoubleSupport(getDevice()));
+
+    double minVal_; if (!minVal) minVal = &minVal_;
+    double maxVal_; if (!maxVal) maxVal = &maxVal_;
+    int minLoc_[2];
+    int maxLoc_[2];
+
+    Size valbuf_size, locbuf_size;
+    get_buf_size_required(src.cols, src.rows, src.elemSize(), valbuf_size.width, 
+                          valbuf_size.height, locbuf_size.width, locbuf_size.height);
+    valbuf.create(valbuf_size, CV_8U);
+    locbuf.create(locbuf_size, CV_8U);
+
+    if (mask.empty())
+    {
+        Caller caller = callers[hasAtomicsSupport(getDevice())][src.type()];
+        if (!caller) CV_Error(CV_StsBadArg, "minMaxLoc: unsupported type");
+        caller(src, minVal, maxVal, minLoc_, maxLoc_, valbuf, locbuf);
+    }
+    else
+    {
+        MaskedCaller caller = masked_callers[hasAtomicsSupport(getDevice())][src.type()];
+        if (!caller) CV_Error(CV_StsBadArg, "minMaxLoc: unsupported type");
+        caller(src, mask, minVal, maxVal, minLoc_, maxLoc_, valbuf, locbuf);
+    }
+
+    if (minLoc) { minLoc->x = minLoc_[0]; minLoc->y = minLoc_[1]; }
+    if (maxLoc) { maxLoc->x = maxLoc_[0]; maxLoc->y = maxLoc_[1]; }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Count non-zero elements
+
+namespace cv { namespace gpu { namespace mathfunc { namespace countnonzero {
+
+    void get_buf_size_required(int cols, int rows, int& bufcols, int& bufrows);
+
+    template <typename T> 
+    int count_non_zero_caller(const DevMem2D src, PtrStep buf);
+
+    template <typename T> 
+    int count_non_zero_multipass_caller(const DevMem2D src, PtrStep buf);
+
+}}}}
+
+
+int cv::gpu::countNonZero(const GpuMat& src)
+{
+    GpuMat buf;
+    return countNonZero(src, buf);
+}
+
+
+int cv::gpu::countNonZero(const GpuMat& src, GpuMat& buf)
+{
+    using namespace mathfunc::countnonzero;
+
+    typedef int (*Caller)(const DevMem2D src, PtrStep buf);
+
+    static const Caller callers[2][7] = 
+    { { count_non_zero_multipass_caller<unsigned char>, count_non_zero_multipass_caller<char>,
+        count_non_zero_multipass_caller<unsigned short>, count_non_zero_multipass_caller<short>,
+        count_non_zero_multipass_caller<int>, count_non_zero_multipass_caller<float>, 0},
+      { count_non_zero_caller<unsigned char>, count_non_zero_caller<char>,
+        count_non_zero_caller<unsigned short>, count_non_zero_caller<short>,
+        count_non_zero_caller<int>, count_non_zero_caller<float>, count_non_zero_caller<double> } };
+
+    CV_Assert(src.channels() == 1);
+    CV_Assert(src.type() != CV_64F || hasNativeDoubleSupport(getDevice()));
+
+    Size buf_size;
+    get_buf_size_required(src.cols, src.rows, buf_size.width, buf_size.height);
+    buf.create(buf_size, CV_8U);
+
+    Caller caller = callers[hasAtomicsSupport(getDevice())][src.type()];
+    if (!caller) CV_Error(CV_StsBadArg, "countNonZero: unsupported type");
+    return caller(src, buf);
+}
+
+#endif