Home | History | Annotate | Download | only in cuda 
      1 /*M///////////////////////////////////////////////////////////////////////////////////////
      2 //
      3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
      4 //
      5 //  By downloading, copying, installing or using the software you agree to this license.
      6 //  If you do not agree to this license, do not download, install,
      7 //  copy or use the software.
      8 //
      9 //
     10 //                           License Agreement
     11 //                For Open Source Computer Vision Library
     12 //
     13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
     14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
     15 // Third party copyrights are property of their respective owners.
     16 //
     17 // Redistribution and use in source and binary forms, with or without modification,
     18 // are permitted provided that the following conditions are met:
     19 //
     20 //   * Redistribution's of source code must retain the above copyright notice,
     21 //     this list of conditions and the following disclaimer.
     22 //
     23 //   * Redistribution's in binary form must reproduce the above copyright notice,
     24 //     this list of conditions and the following disclaimer in the documentation
     25 //     and/or other materials provided with the distribution.
     26 //
     27 //   * The name of the copyright holders may not be used to endorse or promote products
     28 //     derived from this software without specific prior written permission.
     29 //
     30 // This software is provided by the copyright holders and contributors "as is" and
     31 // any express or implied warranties, including, but not limited to, the implied
     32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
     33 // In no event shall the Intel Corporation or contributors be liable for any direct,
     34 // indirect, incidental, special, exemplary, or consequential damages
     35 // (including, but not limited to, procurement of substitute goods or services;
     36 // loss of use, data, or profits; or business interruption) however caused
     37 // and on any theory of liability, whether in contract, strict liability,
     38 // or tort (including negligence or otherwise) arising in any way out of
     39 // the use of this software, even if advised of the possibility of such damage.
     40 //
     41 //M*/
     42 
     43 #include "opencv2/opencv_modules.hpp"
     44 
     45 #ifndef HAVE_OPENCV_CUDEV
     46 
     47 #error "opencv_cudev is required"
     48 
     49 #else
     50 
     51 #include "opencv2/cudaarithm.hpp"
     52 #include "opencv2/cudev.hpp"
     53 #include "opencv2/core/private.cuda.hpp"
     54 
     55 using namespace cv;
     56 using namespace cv::cuda;
     57 using namespace cv::cudev;
     58 
     59 namespace
     60 {
     61     template <typename T, typename R>
     62     void minMaxLocImpl(const GpuMat& _src, const GpuMat& mask, GpuMat& _valBuf, GpuMat& _locBuf, Stream& stream)
     63     {
     64         const GpuMat_<T>& src = (const GpuMat_<T>&) _src;
     65         GpuMat_<R>& valBuf = (GpuMat_<R>&) _valBuf;
     66         GpuMat_<int>& locBuf = (GpuMat_<int>&) _locBuf;
     67 
     68         if (mask.empty())
     69             gridMinMaxLoc(src, valBuf, locBuf, stream);
     70         else
     71             gridMinMaxLoc(src, valBuf, locBuf, globPtr<uchar>(mask), stream);
     72     }
     73 }
     74 
     75 void cv::cuda::findMinMaxLoc(InputArray _src, OutputArray _minMaxVals, OutputArray _loc, InputArray _mask, Stream& stream)
     76 {
     77     typedef void (*func_t)(const GpuMat& _src, const GpuMat& mask, GpuMat& _valBuf, GpuMat& _locBuf, Stream& stream);
     78     static const func_t funcs[] =
     79     {
     80         minMaxLocImpl<uchar, int>,
     81         minMaxLocImpl<schar, int>,
     82         minMaxLocImpl<ushort, int>,
     83         minMaxLocImpl<short, int>,
     84         minMaxLocImpl<int, int>,
     85         minMaxLocImpl<float, float>,
     86         minMaxLocImpl<double, double>
     87     };
     88 
     89     const GpuMat src = getInputMat(_src, stream);
     90     const GpuMat mask = getInputMat(_mask, stream);
     91 
     92     CV_Assert( src.channels() == 1 );
     93     CV_Assert( mask.empty() || (mask.size() == src.size() && mask.type() == CV_8U) );
     94 
     95     const int src_depth = src.depth();
     96 
     97     BufferPool pool(stream);
     98     GpuMat valBuf(pool.getAllocator());
     99     GpuMat locBuf(pool.getAllocator());
    100 
    101     const func_t func = funcs[src_depth];
    102     func(src, mask, valBuf, locBuf, stream);
    103 
    104     GpuMat minMaxVals = valBuf.colRange(0, 1);
    105     GpuMat loc = locBuf.colRange(0, 1);
    106 
    107     if (_minMaxVals.kind() == _InputArray::CUDA_GPU_MAT)
    108     {
    109         minMaxVals.copyTo(_minMaxVals, stream);
    110     }
    111     else
    112     {
    113         minMaxVals.download(_minMaxVals, stream);
    114     }
    115 
    116     if (_loc.kind() == _InputArray::CUDA_GPU_MAT)
    117     {
    118         loc.copyTo(_loc, stream);
    119     }
    120     else
    121     {
    122         loc.download(_loc, stream);
    123     }
    124 }
    125 
    126 void cv::cuda::minMaxLoc(InputArray _src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, InputArray _mask)
    127 {
    128     Stream& stream = Stream::Null();
    129 
    130     HostMem minMaxVals, locVals;
    131     findMinMaxLoc(_src, minMaxVals, locVals, _mask, stream);
    132 
    133     stream.waitForCompletion();
    134 
    135     double vals[2];
    136     minMaxVals.createMatHeader().convertTo(Mat(minMaxVals.size(), CV_64FC1, &vals[0]), CV_64F);
    137 
    138     int locs[2];
    139     locVals.createMatHeader().copyTo(Mat(locVals.size(), CV_32SC1, &locs[0]));
    140     Size size = _src.size();
    141     cv::Point locs2D[] = {
    142         cv::Point(locs[0] % size.width, locs[0] / size.width),
    143         cv::Point(locs[1] % size.width, locs[1] / size.width),
    144     };
    145 
    146     if (minVal)
    147         *minVal = vals[0];
    148 
    149     if (maxVal)
    150         *maxVal = vals[1];
    151 
    152     if (minLoc)
    153         *minLoc = locs2D[0];
    154 
    155     if (maxLoc)
    156         *maxLoc = locs2D[1];
    157 }
    158 
    159 #endif
    160