/*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) || defined (CUDA_DISABLER) void cv::gpu::meanStdDev(const GpuMat&, Scalar&, Scalar&) { throw_nogpu(); } void cv::gpu::meanStdDev(const GpuMat&, Scalar&, Scalar&, GpuMat&) { throw_nogpu(); } double cv::gpu::norm(const GpuMat&, int) { throw_nogpu(); return 0.0; } double cv::gpu::norm(const GpuMat&, int, GpuMat&) { 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::absSum(const GpuMat&) { throw_nogpu(); return Scalar(); } Scalar cv::gpu::absSum(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::reduce(const GpuMat&, GpuMat&, int, int, int, Stream&) { throw_nogpu(); } #else namespace { class DeviceBuffer { public: explicit DeviceBuffer(int count_ = 1) : count(count_) { cudaSafeCall( cudaMalloc(&pdev, count * sizeof(double)) ); } ~DeviceBuffer() { cudaSafeCall( cudaFree(pdev) ); } operator double*() {return pdev;} void download(double* hptr) { double hbuf; cudaSafeCall( cudaMemcpy(&hbuf, pdev, sizeof(double), cudaMemcpyDeviceToHost) ); *hptr = hbuf; } void download(double** hptrs) { AutoBuffer hbuf(count); cudaSafeCall( cudaMemcpy((void*)hbuf, pdev, count * sizeof(double), cudaMemcpyDeviceToHost) ); for (int i = 0; i < count; ++i) *hptrs[i] = hbuf[i]; } private: double* pdev; int count; }; } //////////////////////////////////////////////////////////////////////// // meanStdDev void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev) { GpuMat buf; meanStdDev(src, mean, stddev, buf); } void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev, GpuMat& buf) { CV_Assert(src.type() == CV_8UC1); if (!TargetArchs::builtWith(FEATURE_SET_COMPUTE_13) || !DeviceInfo().supports(FEATURE_SET_COMPUTE_13)) CV_Error(CV_StsNotImplemented, "Not sufficient compute capebility"); NppiSize sz; sz.width = src.cols; sz.height = src.rows; DeviceBuffer dbuf(2); int bufSize; #if (CUDA_VERSION <= 4020) nppSafeCall( nppiMeanStdDev8uC1RGetBufferHostSize(sz, &bufSize) ); #else nppSafeCall( nppiMeanStdDevGetBufferHostSize_8u_C1R(sz, &bufSize) ); #endif ensureSizeIsEnough(1, bufSize, CV_8UC1, buf); nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr(), static_cast(src.step), sz, buf.ptr(), dbuf, (double*)dbuf + 1) ); cudaSafeCall( cudaDeviceSynchronize() ); double* ptrs[2] = {mean.val, stddev.val}; dbuf.download(ptrs); } //////////////////////////////////////////////////////////////////////// // norm double cv::gpu::norm(const GpuMat& src, int normType) { GpuMat buf; return norm(src, normType, buf); } double cv::gpu::norm(const GpuMat& src, int normType, GpuMat& buf) { CV_Assert(normType == NORM_INF || normType == NORM_L1 || normType == NORM_L2); GpuMat src_single_channel = src.reshape(1); if (normType == NORM_L1) return absSum(src_single_channel, buf)[0]; if (normType == NORM_L2) return std::sqrt(sqrSum(src_single_channel, buf)[0]); // NORM_INF double min_val, max_val; minMax(src_single_channel, &min_val, &max_val, GpuMat(), buf); return std::max(std::abs(min_val), std::abs(max_val)); } double cv::gpu::norm(const GpuMat& src1, const GpuMat& src2, int normType) { CV_Assert(src1.type() == CV_8UC1); CV_Assert(src1.size() == src2.size() && src1.type() == src2.type()); 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; DeviceBuffer dbuf; nppSafeCall( npp_norm_diff_func[funcIdx](src1.ptr(), static_cast(src1.step), src2.ptr(), static_cast(src2.step), sz, dbuf) ); cudaSafeCall( cudaDeviceSynchronize() ); dbuf.download(&retVal); return retVal; } //////////////////////////////////////////////////////////////////////// // Sum namespace sum { void getBufSize(int cols, int rows, int cn, int& bufcols, int& bufrows); template void run(PtrStepSzb src, void* buf, double* sum); template void runAbs(PtrStepSzb src, void* buf, double* sum); template void runSqr(PtrStepSzb src, void* buf, double* sum); } Scalar cv::gpu::sum(const GpuMat& src) { GpuMat buf; return sum(src, buf); } Scalar cv::gpu::sum(const GpuMat& src, GpuMat& buf) { typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum); static const func_t funcs[7][5] = { {0, ::sum::run, ::sum::run, ::sum::run, ::sum::run}, {0, ::sum::run, ::sum::run, ::sum::run, ::sum::run}, {0, ::sum::run, ::sum::run, ::sum::run, ::sum::run}, {0, ::sum::run, ::sum::run, ::sum::run, ::sum::run}, {0, ::sum::run, ::sum::run, ::sum::run, ::sum::run}, {0, ::sum::run, ::sum::run, ::sum::run, ::sum::run}, {0, ::sum::run, ::sum::run, ::sum::run, ::sum::run} }; if (src.depth() == CV_64F) { if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE)) CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double"); } Size buf_size; ::sum::getBufSize(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height); ensureSizeIsEnough(buf_size, CV_8U, buf); buf.setTo(Scalar::all(0)); const func_t func = funcs[src.depth()][src.channels()]; double result[4]; func(src, buf.data, result); return Scalar(result[0], result[1], result[2], result[3]); } Scalar cv::gpu::absSum(const GpuMat& src) { GpuMat buf; return absSum(src, buf); } Scalar cv::gpu::absSum(const GpuMat& src, GpuMat& buf) { typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum); static const func_t funcs[7][5] = { {0, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs}, {0, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs}, {0, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs}, {0, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs}, {0, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs}, {0, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs}, {0, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs, ::sum::runAbs} }; Size buf_size; ::sum::getBufSize(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height); ensureSizeIsEnough(buf_size, CV_8U, buf); buf.setTo(Scalar::all(0)); const func_t func = funcs[src.depth()][src.channels()]; double result[4]; func(src, buf.data, result); 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) { typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum); static const func_t funcs[7][5] = { {0, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr}, {0, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr}, {0, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr}, {0, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr}, {0, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr}, {0, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr}, {0, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr, ::sum::runSqr} }; Size buf_size; ::sum::getBufSize(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height); ensureSizeIsEnough(buf_size, CV_8U, buf); buf.setTo(Scalar::all(0)); const func_t func = funcs[src.depth()][src.channels()]; double result[4]; func(src, buf.data, result); return Scalar(result[0], result[1], result[2], result[3]); } //////////////////////////////////////////////////////////////////////// // minMax namespace minMax { void getBufSize(int cols, int rows, int& bufcols, int& bufrows); template void run(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb 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) { typedef void (*func_t)(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf); static const func_t funcs[] = { ::minMax::run, ::minMax::run, ::minMax::run, ::minMax::run, ::minMax::run, ::minMax::run, ::minMax::run }; CV_Assert( src.channels() == 1 ); CV_Assert( mask.empty() || (mask.size() == src.size() && mask.type() == CV_8U) ); if (src.depth() == CV_64F) { if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE)) CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double"); } Size buf_size; ::minMax::getBufSize(src.cols, src.rows, buf_size.width, buf_size.height); ensureSizeIsEnough(buf_size, CV_8U, buf); const func_t func = funcs[src.depth()]; double temp1, temp2; func(src, mask, minVal ? minVal : &temp1, maxVal ? maxVal : &temp2, buf); } //////////////////////////////////////////////////////////////////////// // minMaxLoc namespace minMaxLoc { void getBufSize(int cols, int rows, size_t elem_size, int& b1cols, int& b1rows, int& b2cols, int& b2rows); template void run(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb 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) { typedef void (*func_t)(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep locbuf); static const func_t funcs[] = { ::minMaxLoc::run, ::minMaxLoc::run, ::minMaxLoc::run, ::minMaxLoc::run, ::minMaxLoc::run, ::minMaxLoc::run, ::minMaxLoc::run }; CV_Assert( src.channels() == 1 ); CV_Assert( mask.empty() || (mask.size() == src.size() && mask.type() == CV_8U) ); if (src.depth() == CV_64F) { if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE)) CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double"); } Size valbuf_size, locbuf_size; ::minMaxLoc::getBufSize(src.cols, src.rows, src.elemSize(), valbuf_size.width, valbuf_size.height, locbuf_size.width, locbuf_size.height); ensureSizeIsEnough(valbuf_size, CV_8U, valBuf); ensureSizeIsEnough(locbuf_size, CV_8U, locBuf); const func_t func = funcs[src.depth()]; double temp1, temp2; Point temp3, temp4; func(src, mask, minVal ? minVal : &temp1, maxVal ? maxVal : &temp2, minLoc ? &minLoc->x : &temp3.x, maxLoc ? &maxLoc->x : &temp4.x, valBuf, locBuf); } ////////////////////////////////////////////////////////////////////////////// // countNonZero namespace countNonZero { void getBufSize(int cols, int rows, int& bufcols, int& bufrows); template int run(const PtrStepSzb 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) { typedef int (*func_t)(const PtrStepSzb src, PtrStep buf); static const func_t funcs[] = { ::countNonZero::run, ::countNonZero::run, ::countNonZero::run, ::countNonZero::run, ::countNonZero::run, ::countNonZero::run, ::countNonZero::run }; CV_Assert(src.channels() == 1); if (src.depth() == CV_64F) { if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE)) CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double"); } Size buf_size; ::countNonZero::getBufSize(src.cols, src.rows, buf_size.width, buf_size.height); ensureSizeIsEnough(buf_size, CV_8U, buf); const func_t func = funcs[src.depth()]; return func(src, buf); } ////////////////////////////////////////////////////////////////////////////// // reduce namespace reduce { template void rows(PtrStepSzb src, void* dst, int op, cudaStream_t stream); template void cols(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream); } void cv::gpu::reduce(const GpuMat& src, GpuMat& dst, int dim, int reduceOp, int dtype, Stream& stream) { CV_Assert( src.channels() <= 4 ); CV_Assert( dim == 0 || dim == 1 ); CV_Assert( reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG || reduceOp == CV_REDUCE_MAX || reduceOp == CV_REDUCE_MIN ); if (dtype < 0) dtype = src.depth(); dst.create(1, dim == 0 ? src.cols : src.rows, CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels())); if (dim == 0) { typedef void (*func_t)(PtrStepSzb src, void* dst, int op, cudaStream_t stream); static const func_t funcs[7][7] = { { ::reduce::rows, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, ::reduce::rows, ::reduce::rows, ::reduce::rows }, { 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/ }, { 0/*::reduce::rows*/, 0/*::reduce::rows*/, ::reduce::rows, 0/*::reduce::rows*/, ::reduce::rows, ::reduce::rows, ::reduce::rows }, { 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, ::reduce::rows, ::reduce::rows, ::reduce::rows, ::reduce::rows }, { 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, ::reduce::rows, ::reduce::rows, ::reduce::rows }, { 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, ::reduce::rows, ::reduce::rows }, { 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, 0/*::reduce::rows*/, ::reduce::rows } }; const func_t func = funcs[src.depth()][dst.depth()]; if (!func) CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of input and output array formats"); func(src.reshape(1), dst.data, reduceOp, StreamAccessor::getStream(stream)); } else { typedef void (*func_t)(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream); static const func_t funcs[7][7] = { { ::reduce::cols, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, ::reduce::cols, ::reduce::cols, ::reduce::cols }, { 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/ }, { 0/*::reduce::cols*/, 0/*::reduce::cols*/, ::reduce::cols, 0/*::reduce::cols*/, ::reduce::cols, ::reduce::cols, ::reduce::cols }, { 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, ::reduce::cols, ::reduce::cols, ::reduce::cols, ::reduce::cols }, { 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, ::reduce::cols, ::reduce::cols, ::reduce::cols }, { 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, ::reduce::cols, ::reduce::cols }, { 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, 0/*::reduce::cols*/, ::reduce::cols } }; const func_t func = funcs[src.depth()][dst.depth()]; if (!func) CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of input and output array formats"); func(src, dst.data, src.channels(), reduceOp, StreamAccessor::getStream(stream)); } } #endif