Skip to content

Commit d7d6360

Browse files
cudawarpedcudawarped
authored
Merge pull request #2396 from cudawarped:fix_python_cudawarping_cudaarithm
Add python bindings to cudaobjdetect, cudawarping and cudaarithm * Overload cudawarping functions to generate correct python bindings. Add python wrapper to convolution funciton. * Added shift and hog. * Moved cuda python tests to this repo and added python bindings to SURF. * Fix SURF documentation and allow meanshiftsegmention to create GpuMat internaly if not passed for python bindings consistency. * Add correct cuda SURF test case. * Fix python mog and mog2 python bindings, add tests and correct cudawarping documentation. * Updated KeyPoints in cuda::ORB::Convert python wrapper to be an output argument. * Add changes suggested by alalek * Added changes suggested by asmorkalov
1 parent 223a3cd commit d7d6360

File tree

17 files changed

+780
-23
lines changed

17 files changed

+780
-23
lines changed

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

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -274,6 +274,10 @@ CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst,
274274
*/
275275
CV_EXPORTS void rshift(InputArray src, Scalar_<int> val, OutputArray dst, Stream& stream = Stream::Null());
276276

277+
CV_WRAP inline void rshift(InputArray src, Scalar val, OutputArray dst, Stream& stream = Stream::Null()) {
278+
rshift(src, Scalar_<int>(val), dst, stream);
279+
}
280+
277281
/** @brief Performs pixel by pixel right left of an image by a constant value.
278282
279283
@param src Source matrix. Supports 1, 3 and 4 channels images with CV_8U , CV_16U or CV_32S
@@ -284,6 +288,10 @@ depth.
284288
*/
285289
CV_EXPORTS void lshift(InputArray src, Scalar_<int> val, OutputArray dst, Stream& stream = Stream::Null());
286290

291+
CV_WRAP inline void lshift(InputArray src, Scalar val, OutputArray dst, Stream& stream = Stream::Null()) {
292+
lshift(src, Scalar_<int>(val), dst, stream);
293+
}
294+
287295
/** @brief Computes the per-element minimum of two matrices (or a matrix and a scalar).
288296
289297
@param src1 First source matrix or scalar.
@@ -858,7 +866,7 @@ class CV_EXPORTS_W Convolution : public Algorithm
858866
@param ccorr Flags to evaluate cross-correlation instead of convolution.
859867
@param stream Stream for the asynchronous version.
860868
*/
861-
virtual void convolve(InputArray image, InputArray templ, OutputArray result, bool ccorr = false, Stream& stream = Stream::Null()) = 0;
869+
CV_WRAP virtual void convolve(InputArray image, InputArray templ, OutputArray result, bool ccorr = false, Stream& stream = Stream::Null()) = 0;
862870
};
863871

864872
/** @brief Creates implementation for cuda::Convolution .

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

Lines changed: 178 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,178 @@
1+
#!/usr/bin/env python
2+
import os
3+
import cv2 as cv
4+
import numpy as np
5+
6+
from tests_common import NewOpenCVTests, unittest
7+
8+
class cudaarithm_test(NewOpenCVTests):
9+
def setUp(self):
10+
super(cudaarithm_test, self).setUp()
11+
if not cv.cuda.getCudaEnabledDeviceCount():
12+
self.skipTest("No CUDA-capable device is detected")
13+
14+
def test_cudaarithm(self):
15+
npMat = (np.random.random((128, 128, 3)) * 255).astype(np.uint8)
16+
17+
cuMat = cv.cuda_GpuMat(npMat)
18+
cuMatDst = cv.cuda_GpuMat(cuMat.size(),cuMat.type())
19+
cuMatB = cv.cuda_GpuMat(cuMat.size(),cv.CV_8UC1)
20+
cuMatG = cv.cuda_GpuMat(cuMat.size(),cv.CV_8UC1)
21+
cuMatR = cv.cuda_GpuMat(cuMat.size(),cv.CV_8UC1)
22+
23+
self.assertTrue(np.allclose(cv.cuda.merge(cv.cuda.split(cuMat)),npMat))
24+
25+
cv.cuda.split(cuMat,[cuMatB,cuMatG,cuMatR])
26+
cv.cuda.merge([cuMatB,cuMatG,cuMatR],cuMatDst)
27+
self.assertTrue(np.allclose(cuMatDst.download(),npMat))
28+
29+
shift = (np.random.random((cuMat.channels(),)) * 8).astype(np.uint8).tolist()
30+
self.assertTrue(np.allclose(cv.cuda.rshift(cuMat,shift).download(),npMat >> shift))
31+
cv.cuda.rshift(cuMat,shift,cuMatDst)
32+
self.assertTrue(np.allclose(cuMatDst.download(),npMat >> shift))
33+
34+
self.assertTrue(np.allclose(cv.cuda.lshift(cuMat,shift).download(),(npMat << shift).astype('uint8')))
35+
cv.cuda.lshift(cuMat,shift,cuMatDst)
36+
self.assertTrue(np.allclose(cuMatDst.download(),(npMat << shift).astype('uint8')))
37+
38+
def test_arithmetic(self):
39+
npMat1 = np.random.random((128, 128, 3)) - 0.5
40+
npMat2 = np.random.random((128, 128, 3)) - 0.5
41+
42+
cuMat1 = cv.cuda_GpuMat()
43+
cuMat2 = cv.cuda_GpuMat()
44+
cuMat1.upload(npMat1)
45+
cuMat2.upload(npMat2)
46+
cuMatDst = cv.cuda_GpuMat(cuMat1.size(),cuMat1.type())
47+
48+
self.assertTrue(np.allclose(cv.cuda.add(cuMat1, cuMat2).download(),
49+
cv.add(npMat1, npMat2)))
50+
51+
cv.cuda.add(cuMat1, cuMat2, cuMatDst)
52+
self.assertTrue(np.allclose(cuMatDst.download(),cv.add(npMat1, npMat2)))
53+
54+
self.assertTrue(np.allclose(cv.cuda.subtract(cuMat1, cuMat2).download(),
55+
cv.subtract(npMat1, npMat2)))
56+
57+
cv.cuda.subtract(cuMat1, cuMat2, cuMatDst)
58+
self.assertTrue(np.allclose(cuMatDst.download(),cv.subtract(npMat1, npMat2)))
59+
60+
self.assertTrue(np.allclose(cv.cuda.multiply(cuMat1, cuMat2).download(),
61+
cv.multiply(npMat1, npMat2)))
62+
63+
cv.cuda.multiply(cuMat1, cuMat2, cuMatDst)
64+
self.assertTrue(np.allclose(cuMatDst.download(),cv.multiply(npMat1, npMat2)))
65+
66+
self.assertTrue(np.allclose(cv.cuda.divide(cuMat1, cuMat2).download(),
67+
cv.divide(npMat1, npMat2)))
68+
69+
cv.cuda.divide(cuMat1, cuMat2, cuMatDst)
70+
self.assertTrue(np.allclose(cuMatDst.download(),cv.divide(npMat1, npMat2)))
71+
72+
self.assertTrue(np.allclose(cv.cuda.absdiff(cuMat1, cuMat2).download(),
73+
cv.absdiff(npMat1, npMat2)))
74+
75+
cv.cuda.absdiff(cuMat1, cuMat2, cuMatDst)
76+
self.assertTrue(np.allclose(cuMatDst.download(),cv.absdiff(npMat1, npMat2)))
77+
78+
self.assertTrue(np.allclose(cv.cuda.compare(cuMat1, cuMat2, cv.CMP_GE).download(),
79+
cv.compare(npMat1, npMat2, cv.CMP_GE)))
80+
81+
cuMatDst1 = cv.cuda_GpuMat(cuMat1.size(),cv.CV_8UC3)
82+
cv.cuda.compare(cuMat1, cuMat2, cv.CMP_GE, cuMatDst1)
83+
self.assertTrue(np.allclose(cuMatDst1.download(),cv.compare(npMat1, npMat2, cv.CMP_GE)))
84+
85+
self.assertTrue(np.allclose(cv.cuda.abs(cuMat1).download(),
86+
np.abs(npMat1)))
87+
88+
cv.cuda.abs(cuMat1, cuMatDst)
89+
self.assertTrue(np.allclose(cuMatDst.download(),np.abs(npMat1)))
90+
91+
self.assertTrue(np.allclose(cv.cuda.sqrt(cv.cuda.sqr(cuMat1)).download(),
92+
cv.cuda.abs(cuMat1).download()))
93+
94+
cv.cuda.sqr(cuMat1, cuMatDst)
95+
cv.cuda.sqrt(cuMatDst, cuMatDst)
96+
self.assertTrue(np.allclose(cuMatDst.download(),cv.cuda.abs(cuMat1).download()))
97+
98+
self.assertTrue(np.allclose(cv.cuda.log(cv.cuda.exp(cuMat1)).download(),
99+
npMat1))
100+
101+
cv.cuda.exp(cuMat1, cuMatDst)
102+
cv.cuda.log(cuMatDst, cuMatDst)
103+
self.assertTrue(np.allclose(cuMatDst.download(),npMat1))
104+
105+
self.assertTrue(np.allclose(cv.cuda.pow(cuMat1, 2).download(),
106+
cv.pow(npMat1, 2)))
107+
108+
cv.cuda.pow(cuMat1, 2, cuMatDst)
109+
self.assertTrue(np.allclose(cuMatDst.download(),cv.pow(npMat1, 2)))
110+
111+
def test_logical(self):
112+
npMat1 = (np.random.random((128, 128)) * 255).astype(np.uint8)
113+
npMat2 = (np.random.random((128, 128)) * 255).astype(np.uint8)
114+
115+
cuMat1 = cv.cuda_GpuMat()
116+
cuMat2 = cv.cuda_GpuMat()
117+
cuMat1.upload(npMat1)
118+
cuMat2.upload(npMat2)
119+
cuMatDst = cv.cuda_GpuMat(cuMat1.size(),cuMat1.type())
120+
121+
self.assertTrue(np.allclose(cv.cuda.bitwise_or(cuMat1, cuMat2).download(),
122+
cv.bitwise_or(npMat1, npMat2)))
123+
124+
cv.cuda.bitwise_or(cuMat1, cuMat2, cuMatDst)
125+
self.assertTrue(np.allclose(cuMatDst.download(),cv.bitwise_or(npMat1, npMat2)))
126+
127+
self.assertTrue(np.allclose(cv.cuda.bitwise_and(cuMat1, cuMat2).download(),
128+
cv.bitwise_and(npMat1, npMat2)))
129+
130+
cv.cuda.bitwise_and(cuMat1, cuMat2, cuMatDst)
131+
self.assertTrue(np.allclose(cuMatDst.download(),cv.bitwise_and(npMat1, npMat2)))
132+
133+
self.assertTrue(np.allclose(cv.cuda.bitwise_xor(cuMat1, cuMat2).download(),
134+
cv.bitwise_xor(npMat1, npMat2)))
135+
136+
cv.cuda.bitwise_xor(cuMat1, cuMat2, cuMatDst)
137+
self.assertTrue(np.allclose(cuMatDst.download(),cv.bitwise_xor(npMat1, npMat2)))
138+
139+
self.assertTrue(np.allclose(cv.cuda.bitwise_not(cuMat1).download(),
140+
cv.bitwise_not(npMat1)))
141+
142+
cv.cuda.bitwise_not(cuMat1, cuMatDst)
143+
self.assertTrue(np.allclose(cuMatDst.download(),cv.bitwise_not(npMat1)))
144+
145+
self.assertTrue(np.allclose(cv.cuda.min(cuMat1, cuMat2).download(),
146+
cv.min(npMat1, npMat2)))
147+
148+
cv.cuda.min(cuMat1, cuMat2, cuMatDst)
149+
self.assertTrue(np.allclose(cuMatDst.download(),cv.min(npMat1, npMat2)))
150+
151+
self.assertTrue(np.allclose(cv.cuda.max(cuMat1, cuMat2).download(),
152+
cv.max(npMat1, npMat2)))
153+
154+
cv.cuda.max(cuMat1, cuMat2, cuMatDst)
155+
self.assertTrue(np.allclose(cuMatDst.download(),cv.max(npMat1, npMat2)))
156+
157+
def test_convolution(self):
158+
npMat = (np.random.random((128, 128)) * 255).astype(np.float32)
159+
npDims = np.array(npMat.shape)
160+
kernel = (np.random.random((3, 3)) * 1).astype(np.float32)
161+
kernelDims = np.array(kernel.shape)
162+
iS = (kernelDims/2).astype(int)
163+
iE = npDims - kernelDims + iS
164+
165+
cuMat = cv.cuda_GpuMat(npMat)
166+
cuKernel= cv.cuda_GpuMat(kernel)
167+
cuMatDst = cv.cuda_GpuMat(tuple(npDims - kernelDims + 1), cuMat.type())
168+
conv = cv.cuda.createConvolution()
169+
170+
self.assertTrue(np.allclose(conv.convolve(cuMat,cuKernel,ccorr=True).download(),
171+
cv.filter2D(npMat,-1,kernel,anchor=(-1,-1))[iS[0]:iE[0]+1,iS[1]:iE[1]+1]))
172+
173+
conv.convolve(cuMat,cuKernel,cuMatDst,True)
174+
self.assertTrue(np.allclose(cuMatDst.download(),
175+
cv.filter2D(npMat,-1,kernel,anchor=(-1,-1))[iS[0]:iE[0]+1,iS[1]:iE[1]+1]))
176+
177+
if __name__ == '__main__':
178+
NewOpenCVTests.bootstrap()

‎modules/cudabgsegm/include/opencv2/cudabgsegm.hpp

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -85,7 +85,11 @@ class CV_EXPORTS_W BackgroundSubtractorMOG : public cv::BackgroundSubtractor
8585
CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate, Stream& stream) = 0;
8686

8787
using cv::BackgroundSubtractor::getBackgroundImage;
88-
CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage, Stream& stream) const = 0;
88+
virtual void getBackgroundImage(OutputArray backgroundImage, Stream& stream) const = 0;
89+
90+
CV_WRAP inline void getBackgroundImage(CV_OUT GpuMat& backgroundImage, Stream& stream) {
91+
getBackgroundImage(OutputArray(backgroundImage), stream);
92+
}
8993

9094
CV_WRAP virtual int getHistory() const = 0;
9195
CV_WRAP virtual void setHistory(int nframes) = 0;
@@ -131,7 +135,11 @@ class CV_EXPORTS_W BackgroundSubtractorMOG2 : public cv::BackgroundSubtractorMOG
131135

132136
CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate, Stream& stream) = 0;
133137

134-
CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage, Stream& stream) const = 0;
138+
virtual void getBackgroundImage(OutputArray backgroundImage, Stream& stream) const = 0;
139+
140+
CV_WRAP inline void getBackgroundImage(CV_OUT GpuMat &backgroundImage, Stream& stream) {
141+
getBackgroundImage(OutputArray(backgroundImage), stream);
142+
}
135143
};
136144

137145
/** @brief Creates MOG2 Background Subtractor

‎modules/cudabgsegm/misc/python/test/test_cudabgsegm.py

Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
#!/usr/bin/env python
2+
import os
3+
import cv2 as cv
4+
import numpy as np
5+
6+
from tests_common import NewOpenCVTests, unittest
7+
8+
class cudabgsegm_test(NewOpenCVTests):
9+
def setUp(self):
10+
super(cudabgsegm_test, self).setUp()
11+
if not cv.cuda.getCudaEnabledDeviceCount():
12+
self.skipTest("No CUDA-capable device is detected")
13+
14+
def test_cudabgsegm(self):
15+
lr = 0.05
16+
sz = (128,128,1)
17+
npMat = (np.random.random(sz) * 255).astype(np.uint8)
18+
cuMat = cv.cuda_GpuMat(npMat)
19+
cuMatBg = cv.cuda_GpuMat(cuMat.size(),cuMat.type())
20+
cuMatFg = cv.cuda_GpuMat(cuMat.size(),cuMat.type())
21+
22+
mog = cv.cuda.createBackgroundSubtractorMOG()
23+
mog.apply(cuMat, lr, cv.cuda.Stream_Null(), cuMatFg)
24+
mog.getBackgroundImage(cv.cuda.Stream_Null(),cuMatBg)
25+
self.assertTrue(sz[:2] == cuMatFg.size() == cuMatBg.size())
26+
self.assertTrue(sz[2] == cuMatFg.channels() == cuMatBg.channels())
27+
self.assertTrue(cv.CV_8UC1 == cuMatFg.type() == cuMatBg.type())
28+
mog = cv.cuda.createBackgroundSubtractorMOG()
29+
self.assertTrue(np.allclose(cuMatFg.download(),mog.apply(cuMat, lr, cv.cuda.Stream_Null()).download()))
30+
self.assertTrue(np.allclose(cuMatBg.download(),mog.getBackgroundImage(cv.cuda.Stream_Null()).download()))
31+
32+
mog2 = cv.cuda.createBackgroundSubtractorMOG2()
33+
mog2.apply(cuMat, lr, cv.cuda.Stream_Null(), cuMatFg)
34+
mog2.getBackgroundImage(cv.cuda.Stream_Null(),cuMatBg)
35+
self.assertTrue(sz[:2] == cuMatFg.size() == cuMatBg.size())
36+
self.assertTrue(sz[2] == cuMatFg.channels() == cuMatBg.channels())
37+
self.assertTrue(cv.CV_8UC1 == cuMatFg.type() == cuMatBg.type())
38+
mog2 = cv.cuda.createBackgroundSubtractorMOG2()
39+
self.assertTrue(np.allclose(cuMatFg.download(),mog2.apply(cuMat, lr, cv.cuda.Stream_Null()).download()))
40+
self.assertTrue(np.allclose(cuMatBg.download(),mog2.getBackgroundImage(cv.cuda.Stream_Null()).download()))
41+
42+
if __name__ == '__main__':
43+
NewOpenCVTests.bootstrap()

‎modules/cudacodec/misc/python/test/test_cudacodec.py

Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
#!/usr/bin/env python
2+
import os
3+
import cv2 as cv
4+
import numpy as np
5+
6+
from tests_common import NewOpenCVTests, unittest
7+
8+
class cudacodec_test(NewOpenCVTests):
9+
def setUp(self):
10+
super(cudacodec_test, self).setUp()
11+
if not cv.cuda.getCudaEnabledDeviceCount():
12+
self.skipTest("No CUDA-capable device is detected")
13+
14+
@unittest.skipIf('OPENCV_TEST_DATA_PATH' not in os.environ,
15+
"OPENCV_TEST_DATA_PATH is not defined")
16+
def test_reader(self):
17+
#Test the functionality but not the results of the video reader
18+
19+
vid_path = os.environ['OPENCV_TEST_DATA_PATH'] + '/cv/video/1920x1080.avi'
20+
try:
21+
reader = cv.cudacodec.createVideoReader(vid_path)
22+
ret, gpu_mat = reader.nextFrame()
23+
self.assertTrue(ret)
24+
self.assertTrue('GpuMat' in str(type(gpu_mat)), msg=type(gpu_mat))
25+
#TODO: print(cv.utils.dumpInputArray(gpu_mat)) # - no support for GpuMat
26+
27+
# not checking output, therefore sepearate tests for different signatures is unecessary
28+
ret, _gpu_mat2 = reader.nextFrame(gpu_mat)
29+
#TODO: self.assertTrue(gpu_mat == gpu_mat2)
30+
self.assertTrue(ret)
31+
except cv.error as e:
32+
notSupported = (e.code == cv.Error.StsNotImplemented or e.code == cv.Error.StsUnsupportedFormat or e.code == cv.Error.GPU_API_CALL_ERROR)
33+
self.assertTrue(notSupported)
34+
if e.code == cv.Error.StsNotImplemented:
35+
self.skipTest("NVCUVID is not installed")
36+
elif e.code == cv.Error.StsUnsupportedFormat:
37+
self.skipTest("GPU hardware video decoder missing or video format not supported")
38+
elif e.code == cv.Error.GPU_API_CALL_ERRROR:
39+
self.skipTest("GPU hardware video decoder is missing")
40+
else:
41+
self.skipTest(e.err)
42+
43+
def test_writer_existence(self):
44+
#Test at least the existence of wrapped functions for now
45+
46+
try:
47+
_writer = cv.cudacodec.createVideoWriter("tmp", (128, 128), 30)
48+
except cv.error as e:
49+
self.assertEqual(e.code, cv.Error.StsNotImplemented)
50+
self.skipTest("NVCUVENC is not installed")
51+
52+
self.assertTrue(True) #It is sufficient that no exceptions have been there
53+
54+
if __name__ == '__main__':
55+
NewOpenCVTests.bootstrap()

‎modules/cudafeatures2d/include/opencv2/cudafeatures2d.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -414,7 +414,7 @@ class CV_EXPORTS_W Feature2DAsync : public cv::Feature2D
414414

415415
/** Converts keypoints array from internal representation to standard vector. */
416416
CV_WRAP virtual void convert(InputArray gpu_keypoints,
417-
std::vector<KeyPoint>& keypoints) = 0;
417+
CV_OUT std::vector<KeyPoint>& keypoints) = 0;
418418
};
419419

420420
//

‎modules/cudafeatures2d/misc/python/test/test_cudafeatures2d.py

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
#!/usr/bin/env python
2+
import os
3+
import cv2 as cv
4+
import numpy as np
5+
6+
from tests_common import NewOpenCVTests, unittest
7+
8+
class cudafeatures2d_test(NewOpenCVTests):
9+
def setUp(self):
10+
super(cudafeatures2d_test, self).setUp()
11+
if not cv.cuda.getCudaEnabledDeviceCount():
12+
self.skipTest("No CUDA-capable device is detected")
13+
14+
def test_cudafeatures2d(self):
15+
npMat1 = self.get_sample("samples/data/right01.jpg")
16+
npMat2 = self.get_sample("samples/data/right02.jpg")
17+
18+
cuMat1 = cv.cuda_GpuMat()
19+
cuMat2 = cv.cuda_GpuMat()
20+
cuMat1.upload(npMat1)
21+
cuMat2.upload(npMat2)
22+
23+
cuMat1 = cv.cuda.cvtColor(cuMat1, cv.COLOR_RGB2GRAY)
24+
cuMat2 = cv.cuda.cvtColor(cuMat2, cv.COLOR_RGB2GRAY)
25+
26+
fast = cv.cuda_FastFeatureDetector.create()
27+
_kps = fast.detectAsync(cuMat1)
28+
29+
orb = cv.cuda_ORB.create()
30+
_kps1, descs1 = orb.detectAndComputeAsync(cuMat1, None)
31+
_kps2, descs2 = orb.detectAndComputeAsync(cuMat2, None)
32+
33+
self.assertTrue(len(orb.convert(_kps1)) == _kps1.size()[0])
34+
self.assertTrue(len(orb.convert(_kps2)) == _kps2.size()[0])
35+
36+
bf = cv.cuda_DescriptorMatcher.createBFMatcher(cv.NORM_HAMMING)
37+
matches = bf.match(descs1, descs2)
38+
self.assertGreater(len(matches), 0)
39+
matches = bf.knnMatch(descs1, descs2, 2)
40+
self.assertGreater(len(matches), 0)
41+
matches = bf.radiusMatch(descs1, descs2, 0.1)
42+
self.assertGreater(len(matches), 0)
43+
44+
self.assertTrue(True) #It is sufficient that no exceptions have been there
45+
46+
if __name__ == '__main__':
47+
NewOpenCVTests.bootstrap()

0 commit comments

Comments
 (0)