}
};
- template <int BLOCK_SIZE, typename src_type, typename result_type, class Op>
- __global__ void kernel(const PtrStepSz<src_type> src, result_type* result, const Op op, const int twidth, const int theight)
+ template <int BLOCK_SIZE, typename src_type, typename result_type, class Mask, class Op>
+ __global__ void kernel(const PtrStepSz<src_type> src, result_type* result, const Mask mask, const Op op, const int twidth, const int theight)
{
typedef typename VecTraits<src_type>::elem_type T;
typedef typename VecTraits<result_type>::elem_type R;
for (int j = 0, x = x0; j < twidth && x < src.cols; ++j, x += blockDim.x)
{
- const src_type srcVal = ptr[x];
-
- sum = sum + op(saturate_cast<result_type>(srcVal));
+ if (mask(y, x))
+ {
+ const src_type srcVal = ptr[x];
+ sum = sum + op(saturate_cast<result_type>(srcVal));
+ }
}
}
}
template <typename T, typename R, int cn, template <typename> class Op>
- void caller(PtrStepSzb src_, void* buf_, double* out)
+ void caller(PtrStepSzb src_, void* buf_, double* out, PtrStepSzb mask)
{
typedef typename TypeVec<T, cn>::vec_type src_type;
typedef typename TypeVec<R, cn>::vec_type result_type;
Op<result_type> op;
- kernel<threads_x * threads_y><<<grid, block>>>(src, buf, op, twidth, theight);
+ if (mask.data)
+ kernel<threads_x * threads_y><<<grid, block>>>(src, buf, SingleMask(mask), op, twidth, theight);
+ else
+ kernel<threads_x * threads_y><<<grid, block>>>(src, buf, WithOutMask(), op, twidth, theight);
cudaSafeCall( cudaGetLastError() );
cudaSafeCall( cudaDeviceSynchronize() );
template <> struct SumType<double> { typedef double R; };
template <typename T, int cn>
- void run(PtrStepSzb src, void* buf, double* out)
+ void run(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask)
{
typedef typename SumType<T>::R R;
- caller<T, R, cn, identity>(src, buf, out);
+ caller<T, R, cn, identity>(src, buf, out, mask);
}
- template void run<uchar, 1>(PtrStepSzb src, void* buf, double* out);
- template void run<uchar, 2>(PtrStepSzb src, void* buf, double* out);
- template void run<uchar, 3>(PtrStepSzb src, void* buf, double* out);
- template void run<uchar, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void run<schar, 1>(PtrStepSzb src, void* buf, double* out);
- template void run<schar, 2>(PtrStepSzb src, void* buf, double* out);
- template void run<schar, 3>(PtrStepSzb src, void* buf, double* out);
- template void run<schar, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void run<ushort, 1>(PtrStepSzb src, void* buf, double* out);
- template void run<ushort, 2>(PtrStepSzb src, void* buf, double* out);
- template void run<ushort, 3>(PtrStepSzb src, void* buf, double* out);
- template void run<ushort, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void run<short, 1>(PtrStepSzb src, void* buf, double* out);
- template void run<short, 2>(PtrStepSzb src, void* buf, double* out);
- template void run<short, 3>(PtrStepSzb src, void* buf, double* out);
- template void run<short, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void run<int, 1>(PtrStepSzb src, void* buf, double* out);
- template void run<int, 2>(PtrStepSzb src, void* buf, double* out);
- template void run<int, 3>(PtrStepSzb src, void* buf, double* out);
- template void run<int, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void run<float, 1>(PtrStepSzb src, void* buf, double* out);
- template void run<float, 2>(PtrStepSzb src, void* buf, double* out);
- template void run<float, 3>(PtrStepSzb src, void* buf, double* out);
- template void run<float, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void run<double, 1>(PtrStepSzb src, void* buf, double* out);
- template void run<double, 2>(PtrStepSzb src, void* buf, double* out);
- template void run<double, 3>(PtrStepSzb src, void* buf, double* out);
- template void run<double, 4>(PtrStepSzb src, void* buf, double* out);
+ template void run<uchar, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<uchar, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<uchar, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<uchar, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void run<schar, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<schar, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<schar, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<schar, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void run<ushort, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<ushort, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<ushort, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<ushort, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void run<short, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<short, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<short, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<short, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void run<int, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<int, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<int, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<int, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void run<float, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<float, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<float, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<float, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void run<double, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<double, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<double, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void run<double, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
template <typename T, int cn>
- void runAbs(PtrStepSzb src, void* buf, double* out)
+ void runAbs(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask)
{
typedef typename SumType<T>::R R;
- caller<T, R, cn, abs_func>(src, buf, out);
+ caller<T, R, cn, abs_func>(src, buf, out, mask);
}
- template void runAbs<uchar, 1>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<uchar, 2>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<uchar, 3>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<uchar, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runAbs<schar, 1>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<schar, 2>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<schar, 3>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<schar, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runAbs<ushort, 1>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<ushort, 2>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<ushort, 3>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<ushort, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runAbs<short, 1>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<short, 2>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<short, 3>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<short, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runAbs<int, 1>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<int, 2>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<int, 3>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<int, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runAbs<float, 1>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<float, 2>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<float, 3>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<float, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runAbs<double, 1>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<double, 2>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<double, 3>(PtrStepSzb src, void* buf, double* out);
- template void runAbs<double, 4>(PtrStepSzb src, void* buf, double* out);
+ template void runAbs<uchar, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<uchar, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<uchar, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<uchar, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runAbs<schar, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<schar, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<schar, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<schar, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runAbs<ushort, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<ushort, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<ushort, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<ushort, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runAbs<short, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<short, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<short, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<short, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runAbs<int, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<int, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<int, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<int, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runAbs<float, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<float, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<float, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<float, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runAbs<double, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<double, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<double, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runAbs<double, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
template <typename T> struct Sqr : unary_function<T, T>
{
};
template <typename T, int cn>
- void runSqr(PtrStepSzb src, void* buf, double* out)
+ void runSqr(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask)
{
- caller<T, double, cn, Sqr>(src, buf, out);
+ caller<T, double, cn, Sqr>(src, buf, out, mask);
}
- template void runSqr<uchar, 1>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<uchar, 2>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<uchar, 3>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<uchar, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runSqr<schar, 1>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<schar, 2>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<schar, 3>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<schar, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runSqr<ushort, 1>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<ushort, 2>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<ushort, 3>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<ushort, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runSqr<short, 1>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<short, 2>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<short, 3>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<short, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runSqr<int, 1>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<int, 2>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<int, 3>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<int, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runSqr<float, 1>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<float, 2>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<float, 3>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<float, 4>(PtrStepSzb src, void* buf, double* out);
-
- template void runSqr<double, 1>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<double, 2>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<double, 3>(PtrStepSzb src, void* buf, double* out);
- template void runSqr<double, 4>(PtrStepSzb src, void* buf, double* out);
+ template void runSqr<uchar, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<uchar, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<uchar, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<uchar, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runSqr<schar, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<schar, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<schar, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<schar, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runSqr<ushort, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<ushort, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<ushort, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<ushort, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runSqr<short, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<short, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<short, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<short, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runSqr<int, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<int, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<int, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<int, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runSqr<float, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<float, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<float, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<float, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+
+ template void runSqr<double, 1>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<double, 2>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<double, 3>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
+ template void runSqr<double, 4>(PtrStepSzb src, void* buf, double* out, PtrStepSzb mask);
}
/////////////////////////////////////////////////////////////
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&, int, const GpuMat&, 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::sum(const GpuMat&, 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::absSum(const GpuMat&, 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(); }
+Scalar cv::gpu::sqrSum(const GpuMat&, 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(); }
double cv::gpu::norm(const GpuMat& src, int normType)
{
GpuMat buf;
- return norm(src, normType, buf);
+ return norm(src, normType, GpuMat(), buf);
}
double cv::gpu::norm(const GpuMat& src, int normType, GpuMat& buf)
{
+ return norm(src, normType, GpuMat(), buf);
+}
+
+double cv::gpu::norm(const GpuMat& src, int normType, const GpuMat& mask, GpuMat& buf)
+{
CV_Assert(normType == NORM_INF || normType == NORM_L1 || normType == NORM_L2);
+ CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src.size() && src.channels() == 1));
GpuMat src_single_channel = src.reshape(1);
if (normType == NORM_L1)
- return absSum(src_single_channel, buf)[0];
+ return absSum(src_single_channel, mask, buf)[0];
if (normType == NORM_L2)
- return std::sqrt(sqrSum(src_single_channel, buf)[0]);
+ return std::sqrt(sqrSum(src_single_channel, mask, buf)[0]);
// NORM_INF
double min_val, max_val;
- minMax(src_single_channel, &min_val, &max_val, GpuMat(), buf);
+ minMax(src_single_channel, &min_val, &max_val, mask, buf);
return std::max(std::abs(min_val), std::abs(max_val));
}
void getBufSize(int cols, int rows, int cn, int& bufcols, int& bufrows);
template <typename T, int cn>
- void run(PtrStepSzb src, void* buf, double* sum);
+ void run(PtrStepSzb src, void* buf, double* sum, PtrStepSzb mask);
template <typename T, int cn>
- void runAbs(PtrStepSzb src, void* buf, double* sum);
+ void runAbs(PtrStepSzb src, void* buf, double* sum, PtrStepSzb mask);
template <typename T, int cn>
- void runSqr(PtrStepSzb src, void* buf, double* sum);
+ void runSqr(PtrStepSzb src, void* buf, double* sum, PtrStepSzb mask);
}
Scalar cv::gpu::sum(const GpuMat& src)
{
GpuMat buf;
- return sum(src, buf);
+ return sum(src, GpuMat(), buf);
}
Scalar cv::gpu::sum(const GpuMat& src, GpuMat& buf)
{
- typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum);
+ return sum(src, GpuMat(), buf);
+}
+
+Scalar cv::gpu::sum(const GpuMat& src, const GpuMat& mask, GpuMat& buf)
+{
+ typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum, PtrStepSzb mask);
static const func_t funcs[7][5] =
{
{0, ::sum::run<uchar , 1>, ::sum::run<uchar , 2>, ::sum::run<uchar , 3>, ::sum::run<uchar , 4>},
{0, ::sum::run<double, 1>, ::sum::run<double, 2>, ::sum::run<double, 3>, ::sum::run<double, 4>}
};
+ CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src.size()) );
+
if (src.depth() == CV_64F)
{
if (!deviceSupports(NATIVE_DOUBLE))
const func_t func = funcs[src.depth()][src.channels()];
double result[4];
- func(src, buf.data, result);
+ func(src, buf.data, result, mask);
return Scalar(result[0], result[1], result[2], result[3]);
}
Scalar cv::gpu::absSum(const GpuMat& src)
{
GpuMat buf;
- return absSum(src, buf);
+ return absSum(src, GpuMat(), buf);
}
Scalar cv::gpu::absSum(const GpuMat& src, GpuMat& buf)
{
- typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum);
+ return absSum(src, GpuMat(), buf);
+}
+
+Scalar cv::gpu::absSum(const GpuMat& src, const GpuMat& mask, GpuMat& buf)
+{
+ typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum, PtrStepSzb mask);
static const func_t funcs[7][5] =
{
{0, ::sum::runAbs<uchar , 1>, ::sum::runAbs<uchar , 2>, ::sum::runAbs<uchar , 3>, ::sum::runAbs<uchar , 4>},
{0, ::sum::runAbs<double, 1>, ::sum::runAbs<double, 2>, ::sum::runAbs<double, 3>, ::sum::runAbs<double, 4>}
};
+ CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src.size()) );
+
if (src.depth() == CV_64F)
{
if (!deviceSupports(NATIVE_DOUBLE))
const func_t func = funcs[src.depth()][src.channels()];
double result[4];
- func(src, buf.data, result);
+ func(src, buf.data, result, mask);
return Scalar(result[0], result[1], result[2], result[3]);
}
Scalar cv::gpu::sqrSum(const GpuMat& src)
{
GpuMat buf;
- return sqrSum(src, buf);
+ return sqrSum(src, GpuMat(), buf);
}
Scalar cv::gpu::sqrSum(const GpuMat& src, GpuMat& buf)
{
- typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum);
+ return sqrSum(src, GpuMat(), buf);
+}
+
+Scalar cv::gpu::sqrSum(const GpuMat& src, const GpuMat& mask, GpuMat& buf)
+{
+ typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum, PtrStepSzb mask);
static const func_t funcs[7][5] =
{
{0, ::sum::runSqr<uchar , 1>, ::sum::runSqr<uchar , 2>, ::sum::runSqr<uchar , 3>, ::sum::runSqr<uchar , 4>},
{0, ::sum::runSqr<double, 1>, ::sum::runSqr<double, 2>, ::sum::runSqr<double, 3>, ::sum::runSqr<double, 4>}
};
+ CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src.size()) );
+
if (src.depth() == CV_64F)
{
if (!deviceSupports(NATIVE_DOUBLE))
const func_t func = funcs[src.depth()][src.channels()];
double result[4];
- func(src, buf.data, result);
+ func(src, buf.data, result, mask);
return Scalar(result[0], result[1], result[2], result[3]);
}