Skip to content

Commit bd3b734

Browse files
asmorkalovasmorkalov
committed
Merge branch 4.x
2 parents ddfb5cf + 5741f22 commit bd3b734

24 files changed

+311
-62
lines changed

‎modules/cudaarithm/include/opencv2/cudaarithm.hpp

+215-15
Large diffs are not rendered by default.

‎modules/cudaarithm/misc/python/test/test_cudaarithm.py

+35
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@ def test_cudaarithm(self):
3838
def test_arithmetic(self):
3939
npMat1 = np.random.random((128, 128, 3)) - 0.5
4040
npMat2 = np.random.random((128, 128, 3)) - 0.5
41+
scalar = np.random.random()
4142

4243
cuMat1 = cv.cuda_GpuMat()
4344
cuMat2 = cv.cuda_GpuMat()
@@ -48,36 +49,54 @@ def test_arithmetic(self):
4849
self.assertTrue(np.allclose(cv.cuda.add(cuMat1, cuMat2).download(),
4950
cv.add(npMat1, npMat2)))
5051

52+
self.assertTrue(np.allclose(cv.cuda.addWithScalar(cuMat1, [scalar]*3).download(),
53+
cv.add(npMat1, scalar)))
54+
5155
cv.cuda.add(cuMat1, cuMat2, cuMatDst)
5256
self.assertTrue(np.allclose(cuMatDst.download(),cv.add(npMat1, npMat2)))
5357

5458
self.assertTrue(np.allclose(cv.cuda.subtract(cuMat1, cuMat2).download(),
5559
cv.subtract(npMat1, npMat2)))
5660

61+
self.assertTrue(np.allclose(cv.cuda.subtractWithScalar(cuMat1, [scalar]*3).download(),
62+
cv.subtract(npMat1, scalar)))
63+
5764
cv.cuda.subtract(cuMat1, cuMat2, cuMatDst)
5865
self.assertTrue(np.allclose(cuMatDst.download(),cv.subtract(npMat1, npMat2)))
5966

6067
self.assertTrue(np.allclose(cv.cuda.multiply(cuMat1, cuMat2).download(),
6168
cv.multiply(npMat1, npMat2)))
6269

70+
self.assertTrue(np.allclose(cv.cuda.multiplyWithScalar(cuMat1, [scalar]*3).download(),
71+
cv.multiply(npMat1, scalar)))
72+
6373
cv.cuda.multiply(cuMat1, cuMat2, cuMatDst)
6474
self.assertTrue(np.allclose(cuMatDst.download(),cv.multiply(npMat1, npMat2)))
6575

6676
self.assertTrue(np.allclose(cv.cuda.divide(cuMat1, cuMat2).download(),
6777
cv.divide(npMat1, npMat2)))
6878

79+
self.assertTrue(np.allclose(cv.cuda.divideWithScalar(cuMat1, [scalar]*3).download(),
80+
cv.divide(npMat1, scalar)))
81+
6982
cv.cuda.divide(cuMat1, cuMat2, cuMatDst)
7083
self.assertTrue(np.allclose(cuMatDst.download(),cv.divide(npMat1, npMat2)))
7184

7285
self.assertTrue(np.allclose(cv.cuda.absdiff(cuMat1, cuMat2).download(),
7386
cv.absdiff(npMat1, npMat2)))
7487

88+
self.assertTrue(np.allclose(cv.cuda.absdiffWithScalar(cuMat1, [scalar]*3).download(),
89+
cv.absdiff(npMat1, scalar)))
90+
7591
cv.cuda.absdiff(cuMat1, cuMat2, cuMatDst)
7692
self.assertTrue(np.allclose(cuMatDst.download(),cv.absdiff(npMat1, npMat2)))
7793

7894
self.assertTrue(np.allclose(cv.cuda.compare(cuMat1, cuMat2, cv.CMP_GE).download(),
7995
cv.compare(npMat1, npMat2, cv.CMP_GE)))
8096

97+
self.assertTrue(np.allclose(cv.cuda.compareWithScalar(cuMat1, [scalar]*3, cv.CMP_GE).download(),
98+
cv.compare(npMat1, scalar, cv.CMP_GE)))
99+
81100
cuMatDst1 = cv.cuda_GpuMat(cuMat1.size(),cv.CV_8UC3)
82101
cv.cuda.compare(cuMat1, cuMat2, cv.CMP_GE, cuMatDst1)
83102
self.assertTrue(np.allclose(cuMatDst1.download(),cv.compare(npMat1, npMat2, cv.CMP_GE)))
@@ -111,6 +130,7 @@ def test_arithmetic(self):
111130
def test_logical(self):
112131
npMat1 = (np.random.random((128, 128)) * 255).astype(np.uint8)
113132
npMat2 = (np.random.random((128, 128)) * 255).astype(np.uint8)
133+
scalar = np.random.random()
114134

115135
cuMat1 = cv.cuda_GpuMat()
116136
cuMat2 = cv.cuda_GpuMat()
@@ -121,18 +141,27 @@ def test_logical(self):
121141
self.assertTrue(np.allclose(cv.cuda.bitwise_or(cuMat1, cuMat2).download(),
122142
cv.bitwise_or(npMat1, npMat2)))
123143

144+
self.assertTrue(np.allclose(cv.cuda.bitwise_or_with_scalar(cuMat1, scalar).download(),
145+
cv.bitwise_or(npMat1, scalar)))
146+
124147
cv.cuda.bitwise_or(cuMat1, cuMat2, cuMatDst)
125148
self.assertTrue(np.allclose(cuMatDst.download(),cv.bitwise_or(npMat1, npMat2)))
126149

127150
self.assertTrue(np.allclose(cv.cuda.bitwise_and(cuMat1, cuMat2).download(),
128151
cv.bitwise_and(npMat1, npMat2)))
129152

153+
self.assertTrue(np.allclose(cv.cuda.bitwise_and_with_scalar(cuMat1, scalar).download(),
154+
cv.bitwise_and(npMat1, scalar)))
155+
130156
cv.cuda.bitwise_and(cuMat1, cuMat2, cuMatDst)
131157
self.assertTrue(np.allclose(cuMatDst.download(),cv.bitwise_and(npMat1, npMat2)))
132158

133159
self.assertTrue(np.allclose(cv.cuda.bitwise_xor(cuMat1, cuMat2).download(),
134160
cv.bitwise_xor(npMat1, npMat2)))
135161

162+
self.assertTrue(np.allclose(cv.cuda.bitwise_xor_with_scalar(cuMat1, scalar).download(),
163+
cv.bitwise_xor(npMat1, scalar)))
164+
136165
cv.cuda.bitwise_xor(cuMat1, cuMat2, cuMatDst)
137166
self.assertTrue(np.allclose(cuMatDst.download(),cv.bitwise_xor(npMat1, npMat2)))
138167

@@ -145,12 +174,18 @@ def test_logical(self):
145174
self.assertTrue(np.allclose(cv.cuda.min(cuMat1, cuMat2).download(),
146175
cv.min(npMat1, npMat2)))
147176

177+
self.assertTrue(np.allclose(cv.cuda.minWithScalar(cuMat1, scalar).download(),
178+
cv.min(npMat1, scalar)))
179+
148180
cv.cuda.min(cuMat1, cuMat2, cuMatDst)
149181
self.assertTrue(np.allclose(cuMatDst.download(),cv.min(npMat1, npMat2)))
150182

151183
self.assertTrue(np.allclose(cv.cuda.max(cuMat1, cuMat2).download(),
152184
cv.max(npMat1, npMat2)))
153185

186+
self.assertTrue(np.allclose(cv.cuda.maxWithScalar(cuMat1, scalar).download(),
187+
cv.max(npMat1, scalar)))
188+
154189
cv.cuda.max(cuMat1, cuMat2, cuMatDst)
155190
self.assertTrue(np.allclose(cuMatDst.download(),cv.max(npMat1, npMat2)))
156191

‎modules/cudaarithm/src/arithm.cpp

+2
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,8 @@ void cv::cuda::mulAndScaleSpectrums(InputArray, InputArray, OutputArray, int, fl
5454

5555
void cv::cuda::dft(InputArray, OutputArray, Size, int, Stream&) { throw_no_cuda(); }
5656

57+
Ptr<DFT> cv::cuda::createDFT(Size, int) { throw_no_cuda(); return Ptr<DFT>(); }
58+
5759
Ptr<Convolution> cv::cuda::createConvolution(Size) { throw_no_cuda(); return Ptr<Convolution>(); }
5860

5961
#else /* !defined (HAVE_CUDA) */

‎modules/cudaarithm/src/cuda/polar_cart.cu

+5-5
Original file line numberDiff line numberDiff line change
@@ -289,9 +289,9 @@ namespace
289289
const T scale = angleInDegrees ? static_cast<T>(CV_PI / 180.0) : static_cast<T>(1.0);
290290

291291
if (mag.empty())
292-
polarToCartImpl_<T, false> << <grid, block, 0, stream >> >(mag, angle, x, y, scale);
292+
polarToCartImpl_<T, false> <<<grid, block, 0, stream >>>(mag, angle, x, y, scale);
293293
else
294-
polarToCartImpl_<T, true> << <grid, block, 0, stream >> >(mag, angle, x, y, scale);
294+
polarToCartImpl_<T, true> <<<grid, block, 0, stream >>>(mag, angle, x, y, scale);
295295
}
296296

297297
template <typename T>
@@ -305,9 +305,9 @@ namespace
305305
const T scale = angleInDegrees ? static_cast<T>(CV_PI / 180.0) : static_cast<T>(1.0);
306306

307307
if (mag.empty())
308-
polarToCartDstInterleavedImpl_<T, false> << <grid, block, 0, stream >> >(mag, angle, xy, scale);
308+
polarToCartDstInterleavedImpl_<T, false> <<<grid, block, 0, stream >>>(mag, angle, xy, scale);
309309
else
310-
polarToCartDstInterleavedImpl_<T, true> << <grid, block, 0, stream >> >(mag, angle, xy, scale);
310+
polarToCartDstInterleavedImpl_<T, true> <<<grid, block, 0, stream >>>(mag, angle, xy, scale);
311311
}
312312

313313
template <typename T>
@@ -320,7 +320,7 @@ namespace
320320

321321
const T scale = angleInDegrees ? static_cast<T>(CV_PI / 180.0) : static_cast<T>(1.0);
322322

323-
polarToCartInterleavedImpl_<T> << <grid, block, 0, stream >> >(magAngle, xy, scale);
323+
polarToCartInterleavedImpl_<T> <<<grid, block, 0, stream >>>(magAngle, xy, scale);
324324
}
325325
}
326326

‎modules/cudaarithm/src/element_operations.cpp

+5
Original file line numberDiff line numberDiff line change
@@ -84,8 +84,13 @@ void cv::cuda::magnitude(InputArray, InputArray, OutputArray, Stream&) { throw_n
8484
void cv::cuda::magnitudeSqr(InputArray, OutputArray, Stream&) { throw_no_cuda(); }
8585
void cv::cuda::magnitudeSqr(InputArray, InputArray, OutputArray, Stream&) { throw_no_cuda(); }
8686
void cv::cuda::phase(InputArray, InputArray, OutputArray, bool, Stream&) { throw_no_cuda(); }
87+
void cv::cuda::phase(InputArray, OutputArray, bool, Stream&) { throw_no_cuda(); }
8788
void cv::cuda::cartToPolar(InputArray, InputArray, OutputArray, OutputArray, bool, Stream&) { throw_no_cuda(); }
89+
void cv::cuda::cartToPolar(InputArray, OutputArray, OutputArray, bool, Stream&) { throw_no_cuda(); }
90+
void cv::cuda::cartToPolar(InputArray, OutputArray, bool, Stream&) { throw_no_cuda(); }
8891
void cv::cuda::polarToCart(InputArray, InputArray, OutputArray, OutputArray, bool, Stream&) { throw_no_cuda(); }
92+
void cv::cuda::polarToCart(InputArray, InputArray, OutputArray, bool, Stream&) { throw_no_cuda(); }
93+
void cv::cuda::polarToCart(InputArray, OutputArray, bool, Stream&) { throw_no_cuda(); }
8994

9095
#else
9196

‎modules/cudaarithm/src/reductions.cpp

+3-1
Original file line numberDiff line numberDiff line change
@@ -69,8 +69,10 @@ void cv::cuda::countNonZero(InputArray, OutputArray, Stream&) { throw_no_cuda();
6969

7070
void cv::cuda::reduce(InputArray, OutputArray, int, int, int, Stream&) { throw_no_cuda(); }
7171

72-
void cv::cuda::meanStdDev(InputArray, Scalar&, Scalar&) { throw_no_cuda(); }
72+
void cv::cuda::meanStdDev(InputArray, OutputArray, InputArray, Stream&) { throw_no_cuda(); }
7373
void cv::cuda::meanStdDev(InputArray, OutputArray, Stream&) { throw_no_cuda(); }
74+
void cv::cuda::meanStdDev(InputArray, Scalar&, Scalar&, InputArray) { throw_no_cuda(); }
75+
void cv::cuda::meanStdDev(InputArray, Scalar&, Scalar&) { throw_no_cuda(); }
7476

7577
void cv::cuda::rectStdDev(InputArray, InputArray, OutputArray, Rect, Stream&) { throw_no_cuda(); }
7678

‎modules/cudacodec/src/cuda/nv12_to_rgb.cu

+2-2
Original file line numberDiff line numberDiff line change
@@ -179,9 +179,9 @@ void nv12ToBgra(const GpuMat& decodedFrame, GpuMat& outFrame, int width, int hei
179179
dim3 block(32, 8);
180180
dim3 grid(divUp(width, 2 * block.x), divUp(height, block.y));
181181
if (videoFullRangeFlag)
182-
NV12_to_BGRA<true> << <grid, block, 0, stream >> > (decodedFrame.ptr<uchar>(), decodedFrame.step, outFrame.ptr<uint>(), outFrame.step, width, height);
182+
NV12_to_BGRA<true> <<<grid, block, 0, stream >>> (decodedFrame.ptr<uchar>(), decodedFrame.step, outFrame.ptr<uint>(), outFrame.step, width, height);
183183
else
184-
NV12_to_BGRA<false> << <grid, block, 0, stream >> > (decodedFrame.ptr<uchar>(), decodedFrame.step, outFrame.ptr<uint>(), outFrame.step, width, height);
184+
NV12_to_BGRA<false> <<<grid, block, 0, stream >>> (decodedFrame.ptr<uchar>(), decodedFrame.step, outFrame.ptr<uint>(), outFrame.step, width, height);
185185
CV_CUDEV_SAFE_CALL(cudaGetLastError());
186186
if (stream == 0)
187187
CV_CUDEV_SAFE_CALL(cudaDeviceSynchronize());

‎modules/cudaimgproc/src/color.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ void cv::cuda::cvtColor(InputArray, OutputArray, int, int, Stream&) { throw_no_c
5151

5252
void cv::cuda::demosaicing(InputArray, OutputArray, int, int, Stream&) { throw_no_cuda(); }
5353

54-
void cv::cuda::swapChannels(InputOutputArray, const int[], Stream&) { throw_no_cuda(); }
54+
void cv::cuda::swapChannels(InputOutputArray, const int[4], Stream&) { throw_no_cuda(); }
5555

5656
void cv::cuda::gammaCorrection(InputArray, OutputArray, bool, Stream&) { throw_no_cuda(); }
5757

‎modules/cudaimgproc/src/connectedcomponents.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -9,8 +9,8 @@ using namespace cv::cuda;
99

1010
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
1111

12-
void cv::cuda::connectedComponents(InputArray img_, OutputArray labels_, int connectivity,
13-
int ltype, ConnectedComponentsAlgorithmsTypes ccltype) { throw_no_cuda(); }
12+
void cv::cuda::connectedComponents(InputArray, OutputArray, int, int, ConnectedComponentsAlgorithmsTypes) { throw_no_cuda(); }
13+
void cv::cuda::connectedComponents(InputArray, OutputArray, int, int) { throw_no_cuda(); }
1414

1515
#else /* !defined (HAVE_CUDA) */
1616

‎modules/cudaimgproc/src/cuda/canny.cu

+2-2
Original file line numberDiff line numberDiff line change
@@ -428,7 +428,7 @@ namespace canny
428428
cudaSafeCall( cudaMemsetAsync(d_counter, 0, sizeof(int), stream) );
429429

430430
const dim3 block(128);
431-
const dim3 grid(::min(count, 65535u), divUp(count, 65535), 1);
431+
const dim3 grid(std::min(count, 65535), divUp(count, 65535), 1);
432432

433433
edgesHysteresisGlobalKernel<<<grid, block, 0, stream>>>(map, st1, st2, d_counter, count);
434434
cudaSafeCall( cudaGetLastError() );
@@ -439,7 +439,7 @@ namespace canny
439439
cudaSafeCall( cudaMemcpyAsync(&count, d_counter, sizeof(int), cudaMemcpyDeviceToHost, stream) );
440440
cudaSafeCall( cudaStreamSynchronize(stream) );
441441

442-
count = min(count, map.cols * map.rows);
442+
count = std::min(count, map.cols * map.rows);
443443

444444
//std::swap(st1, st2);
445445
short2* tmp = st1;

‎modules/cudaimgproc/src/cuda/connectedcomponents.cu

+5-5
Original file line numberDiff line numberDiff line change
@@ -317,19 +317,19 @@ void BlockBasedKomuraEquivalence(const cv::cuda::GpuMat& img, cv::cuda::GpuMat&
317317
grid_size = dim3((((img.cols + 1) / 2) - 1) / kblock_cols + 1, (((img.rows + 1) / 2) - 1) / kblock_rows + 1, 1);
318318
block_size = dim3(kblock_cols, kblock_rows, 1);
319319

320-
InitLabeling << <grid_size, block_size >> > (img, labels, last_pixel);
320+
InitLabeling <<<grid_size, block_size >>> (img, labels, last_pixel);
321321
cudaSafeCall(cudaGetLastError());
322322

323-
Compression << <grid_size, block_size >> > (labels);
323+
Compression <<<grid_size, block_size >>> (labels);
324324
cudaSafeCall(cudaGetLastError());
325325

326-
Merge << <grid_size, block_size >> > (labels, last_pixel);
326+
Merge <<<grid_size, block_size >>> (labels, last_pixel);
327327
cudaSafeCall(cudaGetLastError());
328328

329-
Compression << <grid_size, block_size >> > (labels);
329+
Compression <<<grid_size, block_size >>> (labels);
330330
cudaSafeCall(cudaGetLastError());
331331

332-
FinalLabeling << <grid_size, block_size >> > (img, labels);
332+
FinalLabeling <<<grid_size, block_size >>> (img, labels);
333333
cudaSafeCall(cudaGetLastError());
334334

335335
if (last_pixel_allocated) {

‎modules/cudaimgproc/src/cuda/generalized_hough.cu

+2-2
Original file line numberDiff line numberDiff line change
@@ -302,7 +302,7 @@ namespace cv { namespace cuda { namespace device
302302
int totalCount;
303303
cudaSafeCall( cudaMemcpy(&totalCount, counterPtr, sizeof(int), cudaMemcpyDeviceToHost) );
304304

305-
totalCount = ::min(totalCount, maxSize);
305+
totalCount = std::min(totalCount, maxSize);
306306

307307
return totalCount;
308308
}
@@ -812,7 +812,7 @@ namespace cv { namespace cuda { namespace device
812812
int totalCount;
813813
cudaSafeCall( cudaMemcpy(&totalCount, counterPtr, sizeof(int), cudaMemcpyDeviceToHost) );
814814

815-
totalCount = ::min(totalCount, maxSize);
815+
totalCount = std::min(totalCount, maxSize);
816816

817817
return totalCount;
818818
}

‎modules/cudaimgproc/src/cuda/hough_circles.cu

+1-1
Original file line numberDiff line numberDiff line change
@@ -238,7 +238,7 @@ namespace cv { namespace cuda { namespace device
238238
cudaSafeCall( cudaMemcpyAsync(&totalCount, counterPtr, sizeof(int), cudaMemcpyDeviceToHost, stream) );
239239
cudaSafeCall( cudaStreamSynchronize(stream) );
240240

241-
totalCount = ::min(totalCount, maxCircles);
241+
totalCount = std::min(totalCount, maxCircles);
242242

243243
return totalCount;
244244
}

‎modules/cudaimgproc/src/cuda/hough_lines.cu

+1-1
Original file line numberDiff line numberDiff line change
@@ -189,7 +189,7 @@ namespace cv { namespace cuda { namespace device
189189

190190
cudaSafeCall( cudaStreamSynchronize(stream) );
191191

192-
totalCount = ::min(totalCount, maxSize);
192+
totalCount = std::min(totalCount, maxSize);
193193

194194
if (doSort && totalCount > 0)
195195
{

‎modules/cudaimgproc/src/cuda/hough_segments.cu

+1-1
Original file line numberDiff line numberDiff line change
@@ -241,7 +241,7 @@ namespace cv { namespace cuda { namespace device
241241

242242
cudaSafeCall( cudaStreamSynchronize(stream) );
243243

244-
totalCount = ::min(totalCount, maxSize);
244+
totalCount = std::min(totalCount, maxSize);
245245
return totalCount;
246246
}
247247
}

‎modules/cudaimgproc/src/cuda/moments.cu

+3-3
Original file line numberDiff line numberDiff line change
@@ -139,7 +139,7 @@ template <typename TSrc, typename TMoments, int nMoments> struct momentsDispatch
139139
static void call(const PtrStepSz<TSrc> src, PtrStepSz<TMoments> moments, const bool binary, const int offsetX, const cudaStream_t stream) {
140140
dim3 blockSize(blockSizeX, blockSizeY);
141141
dim3 gridSize = dim3(divUp(src.rows, blockSizeY));
142-
spatialMoments<TSrc, TMoments, false, false, nMoments> << <gridSize, blockSize, 0, stream >> > (src, binary, moments.ptr());
142+
spatialMoments<TSrc, TMoments, false, false, nMoments> <<<gridSize, blockSize, 0, stream >>> (src, binary, moments.ptr());
143143
if (stream == 0)
144144
cudaSafeCall(cudaStreamSynchronize(stream));
145145
};
@@ -150,9 +150,9 @@ template <typename TSrc, int nMoments> struct momentsDispatcherChar {
150150
dim3 blockSize(blockSizeX, blockSizeY);
151151
dim3 gridSize = dim3(divUp(src.rows, blockSizeY));
152152
if (offsetX)
153-
spatialMoments<TSrc, float, true, false, nMoments> << <gridSize, blockSize, 0, stream >> > (src, binary, moments.ptr(), offsetX);
153+
spatialMoments<TSrc, float, true, false, nMoments> <<<gridSize, blockSize, 0, stream >>> (src, binary, moments.ptr(), offsetX);
154154
else
155-
spatialMoments<TSrc, float, true, true, nMoments> << <gridSize, blockSize, 0, stream >> > (src, binary, moments.ptr());
155+
spatialMoments<TSrc, float, true, true, nMoments> <<<gridSize, blockSize, 0, stream >>> (src, binary, moments.ptr());
156156

157157
if (stream == 0)
158158
cudaSafeCall(cudaStreamSynchronize(stream));

‎modules/cudaimgproc/src/histogram.cpp

+1
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,7 @@ using namespace cv::cuda;
4848
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
4949

5050
void cv::cuda::calcHist(InputArray, OutputArray, Stream&) { throw_no_cuda(); }
51+
void cv::cuda::calcHist(InputArray, InputArray, OutputArray, Stream&) { throw_no_cuda(); }
5152

5253
void cv::cuda::equalizeHist(InputArray, OutputArray, Stream&) { throw_no_cuda(); }
5354

‎modules/cudaimgproc/src/moments.cpp

+8-6
Original file line numberDiff line numberDiff line change
@@ -3,15 +3,10 @@
33
// of this distribution and at http://opencv.org/license.html.
44

55
#include "precomp.hpp"
6-
#include "cuda/moments.cuh"
76

87
using namespace cv;
98
using namespace cv::cuda;
109

11-
int cv::cuda::numMoments(const MomentsOrder order) {
12-
return order == MomentsOrder::FIRST_ORDER_MOMENTS ? device::imgproc::n1 : order == MomentsOrder::SECOND_ORDER_MOMENTS ? device::imgproc::n12 : device::imgproc::n123;
13-
}
14-
1510
template<typename T>
1611
cv::Moments convertSpatialMomentsT(Mat spatialMoments, const MomentsOrder order) {
1712
switch (order) {
@@ -32,10 +27,17 @@ cv::Moments cv::cuda::convertSpatialMoments(Mat spatialMoments, const MomentsOrd
3227
}
3328

3429
#if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
30+
int cv::cuda::numMoments(MomentsOrder) { throw_no_cuda(); return 0; }
3531
Moments cv::cuda::moments(InputArray src, const bool binary, const MomentsOrder order, const int momentsType) { throw_no_cuda(); }
36-
void spatialMoments(InputArray src, OutputArray moments, const bool binary, const MomentsOrder order, const int momentsType, Stream& stream) { throw_no_cuda(); }
32+
void cv::cuda::spatialMoments(InputArray src, OutputArray moments, const bool binary, const MomentsOrder order, const int momentsType, Stream& stream) { throw_no_cuda(); }
3733
#else /* !defined (HAVE_CUDA) */
3834

35+
#include "cuda/moments.cuh"
36+
37+
int cv::cuda::numMoments(const MomentsOrder order) {
38+
return order == MomentsOrder::FIRST_ORDER_MOMENTS ? device::imgproc::n1 : order == MomentsOrder::SECOND_ORDER_MOMENTS ? device::imgproc::n12 : device::imgproc::n123;
39+
}
40+
3941
namespace cv { namespace cuda { namespace device { namespace imgproc {
4042
template <typename TSrc, typename TMoments>
4143
void moments(const PtrStepSzb src, PtrStepSzb moments, const bool binary, const int order, const int offsetX, const cudaStream_t stream);

‎modules/cudaoptflow/src/cuda/nvidiaOpticalFlow.cu

+1-1
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,7 @@ void FlowUpsample(void* srcDevPtr, uint32_t nSrcWidth, uint32_t nSrcPitch, uint3
9090

9191
dim3 blockDim(BLOCKDIM_X, BLOCKDIM_Y);
9292
dim3 gridDim((nDstWidth + blockDim.x - 1) / blockDim.x, (nDstHeight + blockDim.y - 1) / blockDim.y);
93-
NearestNeighborFlowKernel << <gridDim, blockDim >> > (0, srcDevPtr, nSrcWidth, nSrcPitch, nSrcHeight,
93+
NearestNeighborFlowKernel <<<gridDim, blockDim >>> (0, srcDevPtr, nSrcWidth, nSrcPitch, nSrcHeight,
9494
0, dstDevPtr, nDstWidth, nDstPitch, nDstHeight,
9595
nScaleFactor);
9696

‎modules/cudaoptflow/src/farneback.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ using namespace cv::cuda;
4747

4848
#if !defined HAVE_CUDA || defined(CUDA_DISABLER)
4949

50-
Ptr<FarnebackOpticalFlow> cv::cuda::FarnebackOpticalFlow::create(int, double, bool, int, int, int, double, int) { throw_no_cuda(); return Ptr<FarnebackOpticalFlow>(); }
50+
Ptr<cv::cuda::FarnebackOpticalFlow> cv::cuda::FarnebackOpticalFlow::create(int, double, bool, int, int, int, double, int) { throw_no_cuda(); return Ptr<FarnebackOpticalFlow>(); }
5151

5252
#else
5353

‎modules/cudaoptflow/src/precomp.hpp

+2
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,9 @@
5252
#include "opencv2/video.hpp"
5353

5454
#include "opencv2/core/private.cuda.hpp"
55+
#if defined HAVE_CUDA
5556
#include "opencv2/core/cuda/vec_traits.hpp"
57+
#endif
5658
#include "opencv2/opencv_modules.hpp"
5759

5860
#ifdef HAVE_OPENCV_CUDALEGACY

0 commit comments

Comments
 (0)