Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #20196 from TolyaTalamanov:at/support-vaargs-compile-args

Browse Source 
G-API: Support vaargs for cv.compile_args

* Support cv.compile_args to work with variadic number of inputs

* Disable python2.x G-API

* Move compile_args to gapi pkg
pull/20281/head
Anatoliy Talamanov 4 years ago committed by GitHub
parent f30f1afd47
commit 53eca2ff5b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 802 additions and 689 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      modules/gapi/misc/python/package/gapi/__init__.py
  2. 9
      modules/gapi/misc/python/shadow_gapi.hpp
  3. 332
      modules/gapi/misc/python/test/test_gapi_core.py
  4. 163
      modules/gapi/misc/python/test/test_gapi_imgproc.py
  5. 580
      modules/gapi/misc/python/test/test_gapi_infer.py
  6. 36
      modules/gapi/misc/python/test/test_gapi_sample_pipelines.py
  7. 314
      modules/gapi/misc/python/test/test_gapi_streaming.py
  8. 52
      modules/gapi/misc/python/test/test_gapi_types.py

5
modules/gapi/misc/python/package/gapi/__init__.py
Unescape View File

@ -11,6 +11,11 @@ def register(mname):
return parameterized return parameterized
@register('cv2.gapi')
def compile_args(*args):
return list(map(cv.GCompileArg, args))
@register('cv2') @register('cv2')
class GOpaque(): class GOpaque():
# NB: Inheritance from c++ class cause segfault. # NB: Inheritance from c++ class cause segfault.

9
modules/gapi/misc/python/shadow_gapi.hpp
Unescape View File

@ -3,11 +3,10 @@
namespace cv namespace cv
{ {
struct GAPI_EXPORTS_W_SIMPLE GCompileArg { }; struct GAPI_EXPORTS_W_SIMPLE GCompileArg {
GAPI_WRAP GCompileArg(gapi::GKernelPackage pkg);
GAPI_EXPORTS_W GCompileArgs compile_args(gapi::GKernelPackage pkg); GAPI_WRAP GCompileArg(gapi::GNetPackage pkg);
GAPI_EXPORTS_W GCompileArgs compile_args(gapi::GNetPackage pkg); };
GAPI_EXPORTS_W GCompileArgs compile_args(gapi::GKernelPackage kernels, gapi::GNetPackage nets);
// NB: This classes doesn't exist in *.so // NB: This classes doesn't exist in *.so
// HACK: Mark them as a class to force python wrapper generate code for this entities // HACK: Mark them as a class to force python wrapper generate code for this entities

332
modules/gapi/misc/python/test/test_gapi_core.py
Unescape View File

@ -3,187 +3,209 @@
import numpy as np import numpy as np
import cv2 as cv import cv2 as cv
import os import os
import sys
import unittest
from tests_common import NewOpenCVTests from tests_common import NewOpenCVTests
# Plaidml is an optional backend try:
pkgs = [
('ocl' , cv.gapi.core.ocl.kernels()),
('cpu' , cv.gapi.core.cpu.kernels()),
('fluid' , cv.gapi.core.fluid.kernels())
# ('plaidml', cv.gapi.core.plaidml.kernels())
]
if sys.version_info[:2] < (3, 0):
raise unittest.SkipTest('Python 2.x is not supported')
class gapi_core_test(NewOpenCVTests): # Plaidml is an optional backend
pkgs = [
('ocl' , cv.gapi.core.ocl.kernels()),
('cpu' , cv.gapi.core.cpu.kernels()),
('fluid' , cv.gapi.core.fluid.kernels())
# ('plaidml', cv.gapi.core.plaidml.kernels())
]
def test_add(self):
# TODO: Extend to use any type and size here
sz = (720, 1280)
in1 = np.full(sz, 100)
in2 = np.full(sz, 50)
# OpenCV class gapi_core_test(NewOpenCVTests):
expected = cv.add(in1, in2)
# G-API def test_add(self):
g_in1 = cv.GMat() # TODO: Extend to use any type and size here
g_in2 = cv.GMat() sz = (720, 1280)
g_out = cv.gapi.add(g_in1, g_in2) in1 = np.full(sz, 100)
comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out)) in2 = np.full(sz, 50)
for pkg_name, pkg in pkgs: # OpenCV
actual = comp.apply(cv.gin(in1, in2), args=cv.compile_args(pkg)) expected = cv.add(in1, in2)
# Comparison
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
self.assertEqual(expected.dtype, actual.dtype, 'Failed on ' + pkg_name + ' backend')
# G-API
g_in1 = cv.GMat()
g_in2 = cv.GMat()
g_out = cv.gapi.add(g_in1, g_in2)
comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
for pkg_name, pkg in pkgs:
actual = comp.apply(cv.gin(in1, in2), args=cv.gapi.compile_args(pkg))
# Comparison
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
self.assertEqual(expected.dtype, actual.dtype, 'Failed on ' + pkg_name + ' backend')
def test_add_uint8(self):
sz = (720, 1280)
in1 = np.full(sz, 100, dtype=np.uint8)
in2 = np.full(sz, 50 , dtype=np.uint8)
# OpenCV
expected = cv.add(in1, in2)
# G-API
g_in1 = cv.GMat()
g_in2 = cv.GMat()
g_out = cv.gapi.add(g_in1, g_in2)
comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
for pkg_name, pkg in pkgs:
actual = comp.apply(cv.gin(in1, in2), args=cv.gapi.compile_args(pkg))
# Comparison
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
self.assertEqual(expected.dtype, actual.dtype, 'Failed on ' + pkg_name + ' backend')
def test_add_uint8(self):
sz = (720, 1280)
in1 = np.full(sz, 100, dtype=np.uint8)
in2 = np.full(sz, 50 , dtype=np.uint8)
# OpenCV def test_mean(self):
expected = cv.add(in1, in2) img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
in_mat = cv.imread(img_path)
# G-API # OpenCV
g_in1 = cv.GMat() expected = cv.mean(in_mat)
g_in2 = cv.GMat()
g_out = cv.gapi.add(g_in1, g_in2)
comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
for pkg_name, pkg in pkgs: # G-API
actual = comp.apply(cv.gin(in1, in2), args=cv.compile_args(pkg)) g_in = cv.GMat()
# Comparison g_out = cv.gapi.mean(g_in)
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF), comp = cv.GComputation(g_in, g_out)
'Failed on ' + pkg_name + ' backend')
self.assertEqual(expected.dtype, actual.dtype, 'Failed on ' + pkg_name + ' backend') for pkg_name, pkg in pkgs:
actual = comp.apply(cv.gin(in_mat), args=cv.gapi.compile_args(pkg))
# Comparison
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
def test_mean(self): def test_split3(self):
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')]) img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
in_mat = cv.imread(img_path) in_mat = cv.imread(img_path)
# OpenCV # OpenCV
expected = cv.mean(in_mat) expected = cv.split(in_mat)
# G-API # G-API
g_in = cv.GMat() g_in = cv.GMat()
g_out = cv.gapi.mean(g_in) b, g, r = cv.gapi.split3(g_in)
comp = cv.GComputation(g_in, g_out) comp = cv.GComputation(cv.GIn(g_in), cv.GOut(b, g, r))
for pkg_name, pkg in pkgs: for pkg_name, pkg in pkgs:
actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg)) actual = comp.apply(cv.gin(in_mat), args=cv.gapi.compile_args(pkg))
# Comparison # Comparison
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF), for e, a in zip(expected, actual):
'Failed on ' + pkg_name + ' backend') self.assertEqual(0.0, cv.norm(e, a, cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
self.assertEqual(e.dtype, a.dtype, 'Failed on ' + pkg_name + ' backend')
def test_split3(self): def test_threshold(self):
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')]) img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
in_mat = cv.imread(img_path) in_mat = cv.cvtColor(cv.imread(img_path), cv.COLOR_RGB2GRAY)
maxv = (30, 30)
# OpenCV # OpenCV
expected = cv.split(in_mat) expected_thresh, expected_mat = cv.threshold(in_mat, maxv[0], maxv[0], cv.THRESH_TRIANGLE)
# G-API # G-API
g_in = cv.GMat() g_in = cv.GMat()
b, g, r = cv.gapi.split3(g_in) g_sc = cv.GScalar()
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(b, g, r)) mat, threshold = cv.gapi.threshold(g_in, g_sc, cv.THRESH_TRIANGLE)
comp = cv.GComputation(cv.GIn(g_in, g_sc), cv.GOut(mat, threshold))
for pkg_name, pkg in pkgs: for pkg_name, pkg in pkgs:
actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg)) actual_mat, actual_thresh = comp.apply(cv.gin(in_mat, maxv), args=cv.gapi.compile_args(pkg))
# Comparison # Comparison
for e, a in zip(expected, actual): self.assertEqual(0.0, cv.norm(expected_mat, actual_mat, cv.NORM_INF),
self.assertEqual(0.0, cv.norm(e, a, cv.NORM_INF), 'Failed on ' + pkg_name + ' backend')
self.assertEqual(expected_mat.dtype, actual_mat.dtype,
'Failed on ' + pkg_name + ' backend')
self.assertEqual(expected_thresh, actual_thresh[0],
'Failed on ' + pkg_name + ' backend') 'Failed on ' + pkg_name + ' backend')
self.assertEqual(e.dtype, a.dtype, 'Failed on ' + pkg_name + ' backend')
def test_kmeans(self):
def test_threshold(self): # K-means params
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')]) count = 100
in_mat = cv.cvtColor(cv.imread(img_path), cv.COLOR_RGB2GRAY) sz = (count, 2)
maxv = (30, 30) in_mat = np.random.random(sz).astype(np.float32)
K = 5
# OpenCV flags = cv.KMEANS_RANDOM_CENTERS
expected_thresh, expected_mat = cv.threshold(in_mat, maxv[0], maxv[0], cv.THRESH_TRIANGLE) attempts = 1
criteria = (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 30, 0)
# G-API
g_in = cv.GMat() # G-API
g_sc = cv.GScalar() g_in = cv.GMat()
mat, threshold = cv.gapi.threshold(g_in, g_sc, cv.THRESH_TRIANGLE) compactness, out_labels, centers = cv.gapi.kmeans(g_in, K, criteria, attempts, flags)
comp = cv.GComputation(cv.GIn(g_in, g_sc), cv.GOut(mat, threshold)) comp = cv.GComputation(cv.GIn(g_in), cv.GOut(compactness, out_labels, centers))
for pkg_name, pkg in pkgs: compact, labels, centers = comp.apply(cv.gin(in_mat))
actual_mat, actual_thresh = comp.apply(cv.gin(in_mat, maxv), args=cv.compile_args(pkg))
# Comparison # Assert
self.assertEqual(0.0, cv.norm(expected_mat, actual_mat, cv.NORM_INF), self.assertTrue(compact >= 0)
'Failed on ' + pkg_name + ' backend') self.assertEqual(sz[0], labels.shape[0])
self.assertEqual(expected_mat.dtype, actual_mat.dtype, self.assertEqual(1, labels.shape[1])
'Failed on ' + pkg_name + ' backend') self.assertTrue(labels.size != 0)
self.assertEqual(expected_thresh, actual_thresh[0], self.assertEqual(centers.shape[1], sz[1])
'Failed on ' + pkg_name + ' backend') self.assertEqual(centers.shape[0], K)
self.assertTrue(centers.size != 0)
def test_kmeans(self):
# K-means params
count = 100 def generate_random_points(self, sz):
sz = (count, 2) arr = np.random.random(sz).astype(np.float32).T
in_mat = np.random.random(sz).astype(np.float32) return list(zip(arr[0], arr[1]))
K = 5
flags = cv.KMEANS_RANDOM_CENTERS
attempts = 1; def test_kmeans_2d(self):
criteria = (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 30, 0) # K-means 2D params
count = 100
# G-API sz = (count, 2)
g_in = cv.GMat() amount = sz[0]
compactness, out_labels, centers = cv.gapi.kmeans(g_in, K, criteria, attempts, flags) K = 5
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(compactness, out_labels, centers)) flags = cv.KMEANS_RANDOM_CENTERS
attempts = 1
compact, labels, centers = comp.apply(cv.gin(in_mat)) criteria = (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 30, 0)
in_vector = self.generate_random_points(sz)
# Assert in_labels = []
self.assertTrue(compact >= 0)
self.assertEqual(sz[0], labels.shape[0]) # G-API
self.assertEqual(1, labels.shape[1]) data = cv.GArrayT(cv.gapi.CV_POINT2F)
self.assertTrue(labels.size != 0) best_labels = cv.GArrayT(cv.gapi.CV_INT)
self.assertEqual(centers.shape[1], sz[1]);
self.assertEqual(centers.shape[0], K); compactness, out_labels, centers = cv.gapi.kmeans(data, K, best_labels, criteria, attempts, flags)
self.assertTrue(centers.size != 0); comp = cv.GComputation(cv.GIn(data, best_labels), cv.GOut(compactness, out_labels, centers))
compact, labels, centers = comp.apply(cv.gin(in_vector, in_labels))
def generate_random_points(self, sz):
arr = np.random.random(sz).astype(np.float32).T # Assert
return list(zip(arr[0], arr[1])) self.assertTrue(compact >= 0)
self.assertEqual(amount, len(labels))
self.assertEqual(K, len(centers))
def test_kmeans_2d(self):
# K-means 2D params
count = 100 except unittest.SkipTest as e:
sz = (count, 2)
amount = sz[0] message = str(e)
K = 5
flags = cv.KMEANS_RANDOM_CENTERS class TestSkip(unittest.TestCase):
attempts = 1; def setUp(self):
criteria = (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 30, 0); self.skipTest('Skip tests: ' + message)
in_vector = self.generate_random_points(sz)
in_labels = [] def test_skip():
pass
# G-API
data = cv.GArrayT(cv.gapi.CV_POINT2F) pass
best_labels = cv.GArrayT(cv.gapi.CV_INT)
compactness, out_labels, centers = cv.gapi.kmeans(data, K, best_labels, criteria, attempts, flags);
comp = cv.GComputation(cv.GIn(data, best_labels), cv.GOut(compactness, out_labels, centers));
compact, labels, centers = comp.apply(cv.gin(in_vector, in_labels));
# Assert
self.assertTrue(compact >= 0)
self.assertEqual(amount, len(labels))
self.assertEqual(K, len(centers))
if __name__ == '__main__': if __name__ == '__main__':

163
modules/gapi/misc/python/test/test_gapi_imgproc.py
Unescape View File

@ -3,103 +3,124 @@
import numpy as np import numpy as np
import cv2 as cv import cv2 as cv
import os import os
import sys
import unittest
from tests_common import NewOpenCVTests from tests_common import NewOpenCVTests
# Plaidml is an optional backend try:
pkgs = [
('ocl' , cv.gapi.core.ocl.kernels()),
('cpu' , cv.gapi.core.cpu.kernels()),
('fluid' , cv.gapi.core.fluid.kernels())
# ('plaidml', cv.gapi.core.plaidml.kernels())
]
if sys.version_info[:2] < (3, 0):
raise unittest.SkipTest('Python 2.x is not supported')
class gapi_imgproc_test(NewOpenCVTests): # Plaidml is an optional backend
pkgs = [
('ocl' , cv.gapi.core.ocl.kernels()),
('cpu' , cv.gapi.core.cpu.kernels()),
('fluid' , cv.gapi.core.fluid.kernels())
# ('plaidml', cv.gapi.core.plaidml.kernels())
]
def test_good_features_to_track(self):
# TODO: Extend to use any type and size here
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
in1 = cv.cvtColor(cv.imread(img_path), cv.COLOR_RGB2GRAY)
# NB: goodFeaturesToTrack configuration class gapi_imgproc_test(NewOpenCVTests):
max_corners = 50
quality_lvl = 0.01
min_distance = 10
block_sz = 3
use_harris_detector = True
k = 0.04
mask = None
# OpenCV def test_good_features_to_track(self):
expected = cv.goodFeaturesToTrack(in1, max_corners, quality_lvl, # TODO: Extend to use any type and size here
min_distance, mask=mask, img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
blockSize=block_sz, useHarrisDetector=use_harris_detector, k=k) in1 = cv.cvtColor(cv.imread(img_path), cv.COLOR_RGB2GRAY)
# G-API # NB: goodFeaturesToTrack configuration
g_in = cv.GMat() max_corners = 50
g_out = cv.gapi.goodFeaturesToTrack(g_in, max_corners, quality_lvl, quality_lvl = 0.01
min_distance, mask, block_sz, use_harris_detector, k) min_distance = 10
block_sz = 3
use_harris_detector = True
k = 0.04
mask = None
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out)) # OpenCV
expected = cv.goodFeaturesToTrack(in1, max_corners, quality_lvl,
min_distance, mask=mask,
blockSize=block_sz, useHarrisDetector=use_harris_detector, k=k)
for pkg_name, pkg in pkgs: # G-API
actual = comp.apply(cv.gin(in1), args=cv.compile_args(pkg)) g_in = cv.GMat()
# NB: OpenCV & G-API have different output shapes: g_out = cv.gapi.goodFeaturesToTrack(g_in, max_corners, quality_lvl,
# OpenCV - (num_points, 1, 2) min_distance, mask, block_sz, use_harris_detector, k)
# G-API - (num_points, 2)
# Comparison
self.assertEqual(0.0, cv.norm(expected.flatten(),
np.array(actual, dtype=np.float32).flatten(),
cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
def test_rgb2gray(self): for pkg_name, pkg in pkgs:
# TODO: Extend to use any type and size here actual = comp.apply(cv.gin(in1), args=cv.gapi.compile_args(pkg))
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')]) # NB: OpenCV & G-API have different output shapes:
in1 = cv.imread(img_path) # OpenCV - (num_points, 1, 2)
# G-API - (num_points, 2)
# Comparison
self.assertEqual(0.0, cv.norm(expected.flatten(),
np.array(actual, dtype=np.float32).flatten(),
cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
# OpenCV
expected = cv.cvtColor(in1, cv.COLOR_RGB2GRAY)
# G-API def test_rgb2gray(self):
g_in = cv.GMat() # TODO: Extend to use any type and size here
g_out = cv.gapi.RGB2Gray(g_in) img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
in1 = cv.imread(img_path)
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out)) # OpenCV
expected = cv.cvtColor(in1, cv.COLOR_RGB2GRAY)
for pkg_name, pkg in pkgs: # G-API
actual = comp.apply(cv.gin(in1), args=cv.compile_args(pkg)) g_in = cv.GMat()
# Comparison g_out = cv.gapi.RGB2Gray(g_in)
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
def test_bounding_rect(self): for pkg_name, pkg in pkgs:
sz = 1280 actual = comp.apply(cv.gin(in1), args=cv.gapi.compile_args(pkg))
fscale = 256 # Comparison
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
def sample_value(fscale):
return np.random.uniform(0, 255 * fscale) / fscale
points = np.array([(sample_value(fscale), sample_value(fscale)) for _ in range(1280)], np.float32) def test_bounding_rect(self):
sz = 1280
fscale = 256
# OpenCV def sample_value(fscale):
expected = cv.boundingRect(points) return np.random.uniform(0, 255 * fscale) / fscale
# G-API points = np.array([(sample_value(fscale), sample_value(fscale)) for _ in range(1280)], np.float32)
g_in = cv.GMat()
g_out = cv.gapi.boundingRect(g_in)
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out)) # OpenCV
expected = cv.boundingRect(points)
for pkg_name, pkg in pkgs: # G-API
actual = comp.apply(cv.gin(points), args=cv.compile_args(pkg)) g_in = cv.GMat()
# Comparison g_out = cv.gapi.boundingRect(g_in)
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
'Failed on ' + pkg_name + ' backend') comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
for pkg_name, pkg in pkgs:
actual = comp.apply(cv.gin(points), args=cv.gapi.compile_args(pkg))
# Comparison
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
'Failed on ' + pkg_name + ' backend')
except unittest.SkipTest as e:
message = str(e)
class TestSkip(unittest.TestCase):
def setUp(self):
self.skipTest('Skip tests: ' + message)
def test_skip():
pass
pass
if __name__ == '__main__': if __name__ == '__main__':

580
modules/gapi/misc/python/test/test_gapi_infer.py
Unescape View File

@ -3,318 +3,338 @@
import numpy as np import numpy as np
import cv2 as cv import cv2 as cv
import os import os
import sys
import unittest
from tests_common import NewOpenCVTests from tests_common import NewOpenCVTests
class test_gapi_infer(NewOpenCVTests): try:
def infer_reference_network(self, model_path, weights_path, img): if sys.version_info[:2] < (3, 0):
net = cv.dnn.readNetFromModelOptimizer(model_path, weights_path) raise unittest.SkipTest('Python 2.x is not supported')
net.setPreferableBackend(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE)
net.setPreferableTarget(cv.dnn.DNN_TARGET_CPU)
blob = cv.dnn.blobFromImage(img)
net.setInput(blob) class test_gapi_infer(NewOpenCVTests):
return net.forward(net.getUnconnectedOutLayersNames())
def infer_reference_network(self, model_path, weights_path, img):
net = cv.dnn.readNetFromModelOptimizer(model_path, weights_path)
net.setPreferableBackend(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE)
net.setPreferableTarget(cv.dnn.DNN_TARGET_CPU)
def make_roi(self, img, roi): blob = cv.dnn.blobFromImage(img)
return img[roi[1]:roi[1] + roi[3], roi[0]:roi[0] + roi[2], ...]
net.setInput(blob)
return net.forward(net.getUnconnectedOutLayersNames())
def test_age_gender_infer(self):
# NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
root_path = '/omz_intel_models/intel/age-gender-recognition-retail-0013/FP32/age-gender-recognition-retail-0013' def make_roi(self, img, roi):
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')]) return img[roi[1]:roi[1] + roi[3], roi[0]:roi[0] + roi[2], ...]
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
device_id = 'CPU'
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
img = cv.resize(cv.imread(img_path), (62,62))
# OpenCV DNN def test_age_gender_infer(self):
dnn_age, dnn_gender = self.infer_reference_network(model_path, weights_path, img) # NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
# OpenCV G-API root_path = '/omz_intel_models/intel/age-gender-recognition-retail-0013/FP32/age-gender-recognition-retail-0013'
g_in = cv.GMat() model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
inputs = cv.GInferInputs() weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
inputs.setInput('data', g_in) device_id = 'CPU'
outputs = cv.gapi.infer("net", inputs) img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
age_g = outputs.at("age_conv3") img = cv.resize(cv.imread(img_path), (62,62))
gender_g = outputs.at("prob")
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(age_g, gender_g)) # OpenCV DNN
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id) dnn_age, dnn_gender = self.infer_reference_network(model_path, weights_path, img)
gapi_age, gapi_gender = comp.apply(cv.gin(img), args=cv.compile_args(cv.gapi.networks(pp))) # OpenCV G-API
g_in = cv.GMat()
inputs = cv.GInferInputs()
inputs.setInput('data', g_in)
# Check outputs = cv.gapi.infer("net", inputs)
self.assertEqual(0.0, cv.norm(dnn_gender, gapi_gender, cv.NORM_INF)) age_g = outputs.at("age_conv3")
self.assertEqual(0.0, cv.norm(dnn_age, gapi_age, cv.NORM_INF)) gender_g = outputs.at("prob")
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(age_g, gender_g))
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
def test_age_gender_infer_roi(self): gapi_age, gapi_gender = comp.apply(cv.gin(img), args=cv.gapi.compile_args(cv.gapi.networks(pp)))
# NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
root_path = '/omz_intel_models/intel/age-gender-recognition-retail-0013/FP32/age-gender-recognition-retail-0013' # Check
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')]) self.assertEqual(0.0, cv.norm(dnn_gender, gapi_gender, cv.NORM_INF))
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')]) self.assertEqual(0.0, cv.norm(dnn_age, gapi_age, cv.NORM_INF))
device_id = 'CPU'
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
img = cv.imread(img_path)
roi = (10, 10, 62, 62)
# OpenCV DNN def test_age_gender_infer_roi(self):
dnn_age, dnn_gender = self.infer_reference_network(model_path, # NB: Check IE
weights_path, if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
self.make_roi(img, roi)) return
# OpenCV G-API root_path = '/omz_intel_models/intel/age-gender-recognition-retail-0013/FP32/age-gender-recognition-retail-0013'
g_in = cv.GMat() model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
g_roi = cv.GOpaqueT(cv.gapi.CV_RECT) weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
inputs = cv.GInferInputs() device_id = 'CPU'
inputs.setInput('data', g_in)
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
outputs = cv.gapi.infer("net", g_roi, inputs) img = cv.imread(img_path)
age_g = outputs.at("age_conv3") roi = (10, 10, 62, 62)
gender_g = outputs.at("prob")
# OpenCV DNN
comp = cv.GComputation(cv.GIn(g_in, g_roi), cv.GOut(age_g, gender_g)) dnn_age, dnn_gender = self.infer_reference_network(model_path,
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id) weights_path,
self.make_roi(img, roi))
gapi_age, gapi_gender = comp.apply(cv.gin(img, roi), args=cv.compile_args(cv.gapi.networks(pp)))
# OpenCV G-API
# Check g_in = cv.GMat()
self.assertEqual(0.0, cv.norm(dnn_gender, gapi_gender, cv.NORM_INF)) g_roi = cv.GOpaqueT(cv.gapi.CV_RECT)
self.assertEqual(0.0, cv.norm(dnn_age, gapi_age, cv.NORM_INF)) inputs = cv.GInferInputs()
inputs.setInput('data', g_in)
def test_age_gender_infer_roi_list(self): outputs = cv.gapi.infer("net", g_roi, inputs)
# NB: Check IE age_g = outputs.at("age_conv3")
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE): gender_g = outputs.at("prob")
return
comp = cv.GComputation(cv.GIn(g_in, g_roi), cv.GOut(age_g, gender_g))
root_path = '/omz_intel_models/intel/age-gender-recognition-retail-0013/FP32/age-gender-recognition-retail-0013' pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
device_id = 'CPU'
rois = [(10, 15, 62, 62), (23, 50, 62, 62), (14, 100, 62, 62), (80, 50, 62, 62)]
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
img = cv.imread(img_path)
# OpenCV DNN
dnn_age_list = []
dnn_gender_list = []
for roi in rois:
age, gender = self.infer_reference_network(model_path,
weights_path,
self.make_roi(img, roi))
dnn_age_list.append(age)
dnn_gender_list.append(gender)
# OpenCV G-API
g_in = cv.GMat()
g_rois = cv.GArrayT(cv.gapi.CV_RECT)
inputs = cv.GInferInputs()
inputs.setInput('data', g_in)
outputs = cv.gapi.infer("net", g_rois, inputs)
age_g = outputs.at("age_conv3")
gender_g = outputs.at("prob")
comp = cv.GComputation(cv.GIn(g_in, g_rois), cv.GOut(age_g, gender_g))
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
gapi_age_list, gapi_gender_list = comp.apply(cv.gin(img, rois),
args=cv.compile_args(cv.gapi.networks(pp)))
# Check
for gapi_age, gapi_gender, dnn_age, dnn_gender in zip(gapi_age_list,
gapi_gender_list,
dnn_age_list,
dnn_gender_list):
self.assertEqual(0.0, cv.norm(dnn_gender, gapi_gender, cv.NORM_INF))
self.assertEqual(0.0, cv.norm(dnn_age, gapi_age, cv.NORM_INF))
gapi_age, gapi_gender = comp.apply(cv.gin(img, roi), args=cv.gapi.compile_args(cv.gapi.networks(pp)))
def test_age_gender_infer2_roi(self): # Check
# NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
root_path = '/omz_intel_models/intel/age-gender-recognition-retail-0013/FP32/age-gender-recognition-retail-0013'
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
device_id = 'CPU'
rois = [(10, 15, 62, 62), (23, 50, 62, 62), (14, 100, 62, 62), (80, 50, 62, 62)]
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
img = cv.imread(img_path)
# OpenCV DNN
dnn_age_list = []
dnn_gender_list = []
for roi in rois:
age, gender = self.infer_reference_network(model_path,
weights_path,
self.make_roi(img, roi))
dnn_age_list.append(age)
dnn_gender_list.append(gender)
# OpenCV G-API
g_in = cv.GMat()
g_rois = cv.GArrayT(cv.gapi.CV_RECT)
inputs = cv.GInferListInputs()
inputs.setInput('data', g_rois)
outputs = cv.gapi.infer2("net", g_in, inputs)
age_g = outputs.at("age_conv3")
gender_g = outputs.at("prob")
comp = cv.GComputation(cv.GIn(g_in, g_rois), cv.GOut(age_g, gender_g))
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
gapi_age_list, gapi_gender_list = comp.apply(cv.gin(img, rois),
args=cv.compile_args(cv.gapi.networks(pp)))
# Check
for gapi_age, gapi_gender, dnn_age, dnn_gender in zip(gapi_age_list,
gapi_gender_list,
dnn_age_list,
dnn_gender_list):
self.assertEqual(0.0, cv.norm(dnn_gender, gapi_gender, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(dnn_gender, gapi_gender, cv.NORM_INF))
self.assertEqual(0.0, cv.norm(dnn_age, gapi_age, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(dnn_age, gapi_age, cv.NORM_INF))
def test_age_gender_infer_roi_list(self):
# NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
root_path = '/omz_intel_models/intel/age-gender-recognition-retail-0013/FP32/age-gender-recognition-retail-0013'
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
device_id = 'CPU'
rois = [(10, 15, 62, 62), (23, 50, 62, 62), (14, 100, 62, 62), (80, 50, 62, 62)]
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
img = cv.imread(img_path)
# OpenCV DNN
dnn_age_list = []
dnn_gender_list = []
for roi in rois:
age, gender = self.infer_reference_network(model_path,
weights_path,
self.make_roi(img, roi))
dnn_age_list.append(age)
dnn_gender_list.append(gender)
# OpenCV G-API
g_in = cv.GMat()
g_rois = cv.GArrayT(cv.gapi.CV_RECT)
inputs = cv.GInferInputs()
inputs.setInput('data', g_in)
outputs = cv.gapi.infer("net", g_rois, inputs)
age_g = outputs.at("age_conv3")
gender_g = outputs.at("prob")
comp = cv.GComputation(cv.GIn(g_in, g_rois), cv.GOut(age_g, gender_g))
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
gapi_age_list, gapi_gender_list = comp.apply(cv.gin(img, rois),
args=cv.gapi.compile_args(cv.gapi.networks(pp)))
# Check
for gapi_age, gapi_gender, dnn_age, dnn_gender in zip(gapi_age_list,
gapi_gender_list,
dnn_age_list,
dnn_gender_list):
self.assertEqual(0.0, cv.norm(dnn_gender, gapi_gender, cv.NORM_INF))
self.assertEqual(0.0, cv.norm(dnn_age, gapi_age, cv.NORM_INF))
def test_age_gender_infer2_roi(self):
# NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
root_path = '/omz_intel_models/intel/age-gender-recognition-retail-0013/FP32/age-gender-recognition-retail-0013'
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
device_id = 'CPU'
rois = [(10, 15, 62, 62), (23, 50, 62, 62), (14, 100, 62, 62), (80, 50, 62, 62)]
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
img = cv.imread(img_path)
# OpenCV DNN
dnn_age_list = []
dnn_gender_list = []
for roi in rois:
age, gender = self.infer_reference_network(model_path,
weights_path,
self.make_roi(img, roi))
dnn_age_list.append(age)
dnn_gender_list.append(gender)
# OpenCV G-API
g_in = cv.GMat()
g_rois = cv.GArrayT(cv.gapi.CV_RECT)
inputs = cv.GInferListInputs()
inputs.setInput('data', g_rois)
outputs = cv.gapi.infer2("net", g_in, inputs)
age_g = outputs.at("age_conv3")
gender_g = outputs.at("prob")
comp = cv.GComputation(cv.GIn(g_in, g_rois), cv.GOut(age_g, gender_g))
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
gapi_age_list, gapi_gender_list = comp.apply(cv.gin(img, rois),
args=cv.gapi.compile_args(cv.gapi.networks(pp)))
# Check
for gapi_age, gapi_gender, dnn_age, dnn_gender in zip(gapi_age_list,
gapi_gender_list,
dnn_age_list,
dnn_gender_list):
self.assertEqual(0.0, cv.norm(dnn_gender, gapi_gender, cv.NORM_INF))
self.assertEqual(0.0, cv.norm(dnn_age, gapi_age, cv.NORM_INF))
def test_person_detection_retail_0013(self):
# NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
root_path = '/omz_intel_models/intel/person-detection-retail-0013/FP32/person-detection-retail-0013'
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
img_path = self.find_file('gpu/lbpcascade/er.png', [os.environ.get('OPENCV_TEST_DATA_PATH')])
device_id = 'CPU'
img = cv.resize(cv.imread(img_path), (544, 320))
# OpenCV DNN
net = cv.dnn.readNetFromModelOptimizer(model_path, weights_path)
net.setPreferableBackend(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE)
net.setPreferableTarget(cv.dnn.DNN_TARGET_CPU)
blob = cv.dnn.blobFromImage(img)
def parseSSD(detections, size):
h, w = size
bboxes = []
detections = detections.reshape(-1, 7)
for sample_id, class_id, confidence, xmin, ymin, xmax, ymax in detections:
if confidence >= 0.5:
x = int(xmin * w)
y = int(ymin * h)
width = int(xmax * w - x)
height = int(ymax * h - y)
bboxes.append((x, y, width, height))
return bboxes
net.setInput(blob)
dnn_detections = net.forward()
dnn_boxes = parseSSD(np.array(dnn_detections), img.shape[:2])
# OpenCV G-API
g_in = cv.GMat()
inputs = cv.GInferInputs()
inputs.setInput('data', g_in)
g_sz = cv.gapi.streaming.size(g_in)
outputs = cv.gapi.infer("net", inputs)
detections = outputs.at("detection_out")
bboxes = cv.gapi.parseSSD(detections, g_sz, 0.5, False, False)
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(bboxes))
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
gapi_boxes = comp.apply(cv.gin(img.astype(np.float32)),
args=cv.gapi.compile_args(cv.gapi.networks(pp)))
# Comparison
self.assertEqual(0.0, cv.norm(np.array(dnn_boxes).flatten(),
np.array(gapi_boxes).flatten(),
cv.NORM_INF))
def test_person_detection_retail_0013(self):
# NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
root_path = '/omz_intel_models/intel/person-detection-retail-0013/FP32/person-detection-retail-0013'
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
img_path = self.find_file('gpu/lbpcascade/er.png', [os.environ.get('OPENCV_TEST_DATA_PATH')])
device_id = 'CPU'
img = cv.resize(cv.imread(img_path), (544, 320))
# OpenCV DNN
net = cv.dnn.readNetFromModelOptimizer(model_path, weights_path)
net.setPreferableBackend(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE)
net.setPreferableTarget(cv.dnn.DNN_TARGET_CPU)
blob = cv.dnn.blobFromImage(img)
def parseSSD(detections, size):
h, w = size
bboxes = []
detections = detections.reshape(-1, 7)
for sample_id, class_id, confidence, xmin, ymin, xmax, ymax in detections:
if confidence >= 0.5:
x = int(xmin * w)
y = int(ymin * h)
width = int(xmax * w - x)
height = int(ymax * h - y)
bboxes.append((x, y, width, height))
return bboxes
net.setInput(blob)
dnn_detections = net.forward()
dnn_boxes = parseSSD(np.array(dnn_detections), img.shape[:2])
# OpenCV G-API
g_in = cv.GMat()
inputs = cv.GInferInputs()
inputs.setInput('data', g_in)
g_sz = cv.gapi.streaming.size(g_in)
outputs = cv.gapi.infer("net", inputs)
detections = outputs.at("detection_out")
bboxes = cv.gapi.parseSSD(detections, g_sz, 0.5, False, False)
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(bboxes))
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
gapi_boxes = comp.apply(cv.gin(img.astype(np.float32)),
args=cv.gapi.compile_args(cv.gapi.networks(pp)))
# Comparison
self.assertEqual(0.0, cv.norm(np.array(dnn_boxes).flatten(),
np.array(gapi_boxes).flatten(),
cv.NORM_INF))
except unittest.SkipTest as e:
message = str(e)
class TestSkip(unittest.TestCase):
def setUp(self):
self.skipTest('Skip tests: ' + message)
def test_skip():
pass
def test_person_detection_retail_0013(self): pass
# NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
root_path = '/omz_intel_models/intel/person-detection-retail-0013/FP32/person-detection-retail-0013'
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
img_path = self.find_file('gpu/lbpcascade/er.png', [os.environ.get('OPENCV_TEST_DATA_PATH')])
device_id = 'CPU'
img = cv.resize(cv.imread(img_path), (544, 320))
# OpenCV DNN
net = cv.dnn.readNetFromModelOptimizer(model_path, weights_path)
net.setPreferableBackend(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE)
net.setPreferableTarget(cv.dnn.DNN_TARGET_CPU)
blob = cv.dnn.blobFromImage(img)
def parseSSD(detections, size):
h, w = size
bboxes = []
detections = detections.reshape(-1, 7)
for sample_id, class_id, confidence, xmin, ymin, xmax, ymax in detections:
if confidence >= 0.5:
x = int(xmin * w)
y = int(ymin * h)
width = int(xmax * w - x)
height = int(ymax * h - y)
bboxes.append((x, y, width, height))
return bboxes
net.setInput(blob)
dnn_detections = net.forward()
dnn_boxes = parseSSD(np.array(dnn_detections), img.shape[:2])
# OpenCV G-API
g_in = cv.GMat()
inputs = cv.GInferInputs()
inputs.setInput('data', g_in)
g_sz = cv.gapi.streaming.size(g_in)
outputs = cv.gapi.infer("net", inputs)
detections = outputs.at("detection_out")
bboxes = cv.gapi.parseSSD(detections, g_sz, 0.5, False, False)
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(bboxes))
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
gapi_age, gapi_gender = comp.apply(cv.gin(img), args=cv.compile_args(cv.gapi.networks(pp)))
gapi_boxes = comp.apply(cv.gin(img.astype(np.float32)),
args=cv.compile_args(cv.gapi.networks(pp)))
# Comparison
self.assertEqual(0.0, cv.norm(np.array(dnn_boxes).flatten(),
np.array(gapi_boxes).flatten(),
cv.NORM_INF))
def test_person_detection_retail_0013(self):
# NB: Check IE
if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
return
root_path = '/omz_intel_models/intel/person-detection-retail-0013/FP32/person-detection-retail-0013'
model_path = self.find_file(root_path + '.xml', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
weights_path = self.find_file(root_path + '.bin', [os.environ.get('OPENCV_DNN_TEST_DATA_PATH')])
img_path = self.find_file('gpu/lbpcascade/er.png', [os.environ.get('OPENCV_TEST_DATA_PATH')])
device_id = 'CPU'
img = cv.resize(cv.imread(img_path), (544, 320))
# OpenCV DNN
net = cv.dnn.readNetFromModelOptimizer(model_path, weights_path)
net.setPreferableBackend(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE)
net.setPreferableTarget(cv.dnn.DNN_TARGET_CPU)
blob = cv.dnn.blobFromImage(img)
def parseSSD(detections, size):
h, w = size
bboxes = []
detections = detections.reshape(-1, 7)
for sample_id, class_id, confidence, xmin, ymin, xmax, ymax in detections:
if confidence >= 0.5:
x = int(xmin * w)
y = int(ymin * h)
width = int(xmax * w - x)
height = int(ymax * h - y)
bboxes.append((x, y, width, height))
return bboxes
net.setInput(blob)
dnn_detections = net.forward()
dnn_boxes = parseSSD(np.array(dnn_detections), img.shape[:2])
# OpenCV G-API
g_in = cv.GMat()
inputs = cv.GInferInputs()
inputs.setInput('data', g_in)
g_sz = cv.gapi.streaming.size(g_in)
outputs = cv.gapi.infer("net", inputs)
detections = outputs.at("detection_out")
bboxes = cv.gapi.parseSSD(detections, g_sz, 0.5, False, False)
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(bboxes))
pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
gapi_boxes = comp.apply(cv.gin(img.astype(np.float32)),
args=cv.compile_args(cv.gapi.networks(pp)))
# Comparison
self.assertEqual(0.0, cv.norm(np.array(dnn_boxes).flatten(),
np.array(gapi_boxes).flatten(),
cv.NORM_INF))
if __name__ == '__main__': if __name__ == '__main__':

36
modules/gapi/misc/python/test/test_gapi_sample_pipelines.py
Unescape View File

@ -225,7 +225,7 @@ try:
comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out)) comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
pkg = cv.gapi.kernels(GAddImpl) pkg = cv.gapi.kernels(GAddImpl)
actual = comp.apply(cv.gin(in_mat1, in_mat2), args=cv.compile_args(pkg)) actual = comp.apply(cv.gin(in_mat1, in_mat2), args=cv.gapi.compile_args(pkg))
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
@ -245,7 +245,7 @@ try:
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_ch1, g_ch2, g_ch3)) comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_ch1, g_ch2, g_ch3))
pkg = cv.gapi.kernels(GSplit3Impl) pkg = cv.gapi.kernels(GSplit3Impl)
ch1, ch2, ch3 = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg)) ch1, ch2, ch3 = comp.apply(cv.gin(in_mat), args=cv.gapi.compile_args(pkg))
self.assertEqual(0.0, cv.norm(in_ch1, ch1, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(in_ch1, ch1, cv.NORM_INF))
self.assertEqual(0.0, cv.norm(in_ch2, ch2, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(in_ch2, ch2, cv.NORM_INF))
@ -266,7 +266,7 @@ try:
comp = cv.GComputation(g_in, g_out) comp = cv.GComputation(g_in, g_out)
pkg = cv.gapi.kernels(GMeanImpl) pkg = cv.gapi.kernels(GMeanImpl)
actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg)) actual = comp.apply(cv.gin(in_mat), args=cv.gapi.compile_args(pkg))
# Comparison # Comparison
self.assertEqual(expected, actual) self.assertEqual(expected, actual)
@ -287,7 +287,7 @@ try:
comp = cv.GComputation(cv.GIn(g_in, g_sc), cv.GOut(g_out)) comp = cv.GComputation(cv.GIn(g_in, g_sc), cv.GOut(g_out))
pkg = cv.gapi.kernels(GAddCImpl) pkg = cv.gapi.kernels(GAddCImpl)
actual = comp.apply(cv.gin(in_mat, sc), args=cv.compile_args(pkg)) actual = comp.apply(cv.gin(in_mat, sc), args=cv.gapi.compile_args(pkg))
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
@ -305,7 +305,7 @@ try:
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_sz)) comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_sz))
pkg = cv.gapi.kernels(GSizeImpl) pkg = cv.gapi.kernels(GSizeImpl)
actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg)) actual = comp.apply(cv.gin(in_mat), args=cv.gapi.compile_args(pkg))
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
@ -322,7 +322,7 @@ try:
comp = cv.GComputation(cv.GIn(g_r), cv.GOut(g_sz)) comp = cv.GComputation(cv.GIn(g_r), cv.GOut(g_sz))
pkg = cv.gapi.kernels(GSizeRImpl) pkg = cv.gapi.kernels(GSizeRImpl)
actual = comp.apply(cv.gin(roi), args=cv.compile_args(pkg)) actual = comp.apply(cv.gin(roi), args=cv.gapi.compile_args(pkg))
# cv.norm works with tuples ? # cv.norm works with tuples ?
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
@ -340,7 +340,7 @@ try:
comp = cv.GComputation(cv.GIn(g_pts), cv.GOut(g_br)) comp = cv.GComputation(cv.GIn(g_pts), cv.GOut(g_br))
pkg = cv.gapi.kernels(GBoundingRectImpl) pkg = cv.gapi.kernels(GBoundingRectImpl)
actual = comp.apply(cv.gin(points), args=cv.compile_args(pkg)) actual = comp.apply(cv.gin(points), args=cv.gapi.compile_args(pkg))
# cv.norm works with tuples ? # cv.norm works with tuples ?
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
@ -371,7 +371,7 @@ try:
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out)) comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
pkg = cv.gapi.kernels(GGoodFeaturesImpl) pkg = cv.gapi.kernels(GGoodFeaturesImpl)
actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg)) actual = comp.apply(cv.gin(in_mat), args=cv.gapi.compile_args(pkg))
# NB: OpenCV & G-API have different output types. # NB: OpenCV & G-API have different output types.
# OpenCV - numpy array with shape (num_points, 1, 2) # OpenCV - numpy array with shape (num_points, 1, 2)
@ -453,10 +453,10 @@ try:
g_in = cv.GArray.Int() g_in = cv.GArray.Int()
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(GSum.on(g_in))) comp = cv.GComputation(cv.GIn(g_in), cv.GOut(GSum.on(g_in)))
s = comp.apply(cv.gin([1, 2, 3, 4]), args=cv.compile_args(cv.gapi.kernels(GSumImpl))) s = comp.apply(cv.gin([1, 2, 3, 4]), args=cv.gapi.compile_args(cv.gapi.kernels(GSumImpl)))
self.assertEqual(10, s) self.assertEqual(10, s)
s = comp.apply(cv.gin([1, 2, 8, 7]), args=cv.compile_args(cv.gapi.kernels(GSumImpl))) s = comp.apply(cv.gin([1, 2, 8, 7]), args=cv.gapi.compile_args(cv.gapi.kernels(GSumImpl)))
self.assertEqual(18, s) self.assertEqual(18, s)
self.assertEqual(18, GSumImpl.last_result) self.assertEqual(18, GSumImpl.last_result)
@ -488,13 +488,13 @@ try:
'tuple': (42, 42) 'tuple': (42, 42)
} }
out = comp.apply(cv.gin(table, 'int'), args=cv.compile_args(cv.gapi.kernels(GLookUpImpl))) out = comp.apply(cv.gin(table, 'int'), args=cv.gapi.compile_args(cv.gapi.kernels(GLookUpImpl)))
self.assertEqual(42, out) self.assertEqual(42, out)
out = comp.apply(cv.gin(table, 'str'), args=cv.compile_args(cv.gapi.kernels(GLookUpImpl))) out = comp.apply(cv.gin(table, 'str'), args=cv.gapi.compile_args(cv.gapi.kernels(GLookUpImpl)))
self.assertEqual('hello, world!', out) self.assertEqual('hello, world!', out)
out = comp.apply(cv.gin(table, 'tuple'), args=cv.compile_args(cv.gapi.kernels(GLookUpImpl))) out = comp.apply(cv.gin(table, 'tuple'), args=cv.gapi.compile_args(cv.gapi.kernels(GLookUpImpl)))
self.assertEqual((42, 42), out) self.assertEqual((42, 42), out)
@ -521,7 +521,7 @@ try:
arr1 = [3, 'str'] arr1 = [3, 'str']
out = comp.apply(cv.gin(arr0, arr1), out = comp.apply(cv.gin(arr0, arr1),
args=cv.compile_args(cv.gapi.kernels(GConcatImpl))) args=cv.gapi.compile_args(cv.gapi.kernels(GConcatImpl)))
self.assertEqual(arr0 + arr1, out) self.assertEqual(arr0 + arr1, out)
@ -550,7 +550,7 @@ try:
img1 = np.array([1, 2, 3]) img1 = np.array([1, 2, 3])
with self.assertRaises(Exception): comp.apply(cv.gin(img0, img1), with self.assertRaises(Exception): comp.apply(cv.gin(img0, img1),
args=cv.compile_args( args=cv.gapi.compile_args(
cv.gapi.kernels(GAddImpl))) cv.gapi.kernels(GAddImpl)))
@ -577,7 +577,7 @@ try:
img1 = np.array([1, 2, 3]) img1 = np.array([1, 2, 3])
with self.assertRaises(Exception): comp.apply(cv.gin(img0, img1), with self.assertRaises(Exception): comp.apply(cv.gin(img0, img1),
args=cv.compile_args( args=cv.gapi.compile_args(
cv.gapi.kernels(GAddImpl))) cv.gapi.kernels(GAddImpl)))
@ -607,7 +607,7 @@ try:
# FIXME: Cause Bad variant access. # FIXME: Cause Bad variant access.
# Need to provide more descriptive error messsage. # Need to provide more descriptive error messsage.
with self.assertRaises(Exception): comp.apply(cv.gin(img0, img1), with self.assertRaises(Exception): comp.apply(cv.gin(img0, img1),
args=cv.compile_args( args=cv.gapi.compile_args(
cv.gapi.kernels(GAddImpl))) cv.gapi.kernels(GAddImpl)))
def test_pipeline_with_custom_kernels(self): def test_pipeline_with_custom_kernels(self):
@ -657,7 +657,7 @@ try:
g_mean = cv.gapi.mean(g_transposed) g_mean = cv.gapi.mean(g_transposed)
comp = cv.GComputation(cv.GIn(g_bgr), cv.GOut(g_mean)) comp = cv.GComputation(cv.GIn(g_bgr), cv.GOut(g_mean))
actual = comp.apply(cv.gin(img), args=cv.compile_args( actual = comp.apply(cv.gin(img), args=cv.gapi.compile_args(
cv.gapi.kernels(GResizeImpl, GTransposeImpl))) cv.gapi.kernels(GResizeImpl, GTransposeImpl)))
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF)) self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))

314
modules/gapi/misc/python/test/test_gapi_streaming.py
Unescape View File

@ -3,201 +3,225 @@
import numpy as np import numpy as np
import cv2 as cv import cv2 as cv
import os import os
import sys
import unittest
from tests_common import NewOpenCVTests from tests_common import NewOpenCVTests
class test_gapi_streaming(NewOpenCVTests):
def test_image_input(self): try:
sz = (1280, 720)
in_mat = np.random.randint(0, 100, sz).astype(np.uint8)
# OpenCV if sys.version_info[:2] < (3, 0):
expected = cv.medianBlur(in_mat, 3) raise unittest.SkipTest('Python 2.x is not supported')
# G-API
g_in = cv.GMat()
g_out = cv.gapi.medianBlur(g_in, 3)
c = cv.GComputation(g_in, g_out)
ccomp = c.compileStreaming(cv.descr_of(in_mat))
ccomp.setSource(cv.gin(in_mat))
ccomp.start()
_, actual = ccomp.pull() class test_gapi_streaming(NewOpenCVTests):
# Assert def test_image_input(self):
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF)) sz = (1280, 720)
in_mat = np.random.randint(0, 100, sz).astype(np.uint8)
# OpenCV
expected = cv.medianBlur(in_mat, 3)
# G-API
g_in = cv.GMat()
g_out = cv.gapi.medianBlur(g_in, 3)
c = cv.GComputation(g_in, g_out)
ccomp = c.compileStreaming(cv.descr_of(in_mat))
ccomp.setSource(cv.gin(in_mat))
ccomp.start()
def test_video_input(self): _, actual = ccomp.pull()
ksize = 3
path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
# OpenCV # Assert
cap = cv.VideoCapture(path) self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
# G-API
g_in = cv.GMat()
g_out = cv.gapi.medianBlur(g_in, ksize)
c = cv.GComputation(g_in, g_out)
ccomp = c.compileStreaming() def test_video_input(self):
source = cv.gapi.wip.make_capture_src(path) ksize = 3
ccomp.setSource(source) path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
ccomp.start()
# OpenCV
cap = cv.VideoCapture(path)
# Assert # G-API
max_num_frames = 10 g_in = cv.GMat()
proc_num_frames = 0 g_out = cv.gapi.medianBlur(g_in, ksize)
while cap.isOpened(): c = cv.GComputation(g_in, g_out)
has_expected, expected = cap.read()
has_actual, actual = ccomp.pull()
self.assertEqual(has_expected, has_actual) ccomp = c.compileStreaming()
source = cv.gapi.wip.make_capture_src(path)
ccomp.setSource(source)
ccomp.start()
if not has_actual: # Assert
break max_num_frames = 10
proc_num_frames = 0
while cap.isOpened():
has_expected, expected = cap.read()
has_actual, actual = ccomp.pull()
self.assertEqual(0.0, cv.norm(cv.medianBlur(expected, ksize), actual, cv.NORM_INF)) self.assertEqual(has_expected, has_actual)
proc_num_frames += 1 if not has_actual:
if proc_num_frames == max_num_frames: break
break;
self.assertEqual(0.0, cv.norm(cv.medianBlur(expected, ksize), actual, cv.NORM_INF))
def test_video_split3(self): proc_num_frames += 1
path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']]) if proc_num_frames == max_num_frames:
break
# OpenCV
cap = cv.VideoCapture(path)
# G-API def test_video_split3(self):
g_in = cv.GMat() path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
b, g, r = cv.gapi.split3(g_in)
c = cv.GComputation(cv.GIn(g_in), cv.GOut(b, g, r))
ccomp = c.compileStreaming() # OpenCV
source = cv.gapi.wip.make_capture_src(path) cap = cv.VideoCapture(path)
ccomp.setSource(source)
ccomp.start()
# Assert # G-API
max_num_frames = 10 g_in = cv.GMat()
proc_num_frames = 0 b, g, r = cv.gapi.split3(g_in)
while cap.isOpened(): c = cv.GComputation(cv.GIn(g_in), cv.GOut(b, g, r))
has_expected, frame = cap.read()
has_actual, actual = ccomp.pull()
self.assertEqual(has_expected, has_actual) ccomp = c.compileStreaming()
source = cv.gapi.wip.make_capture_src(path)
ccomp.setSource(source)
ccomp.start()
if not has_actual: # Assert
break max_num_frames = 10
proc_num_frames = 0
while cap.isOpened():
has_expected, frame = cap.read()
has_actual, actual = ccomp.pull()
expected = cv.split(frame) self.assertEqual(has_expected, has_actual)
for e, a in zip(expected, actual):
self.assertEqual(0.0, cv.norm(e, a, cv.NORM_INF))
proc_num_frames += 1 if not has_actual:
if proc_num_frames == max_num_frames: break
break;
expected = cv.split(frame)
for e, a in zip(expected, actual):
self.assertEqual(0.0, cv.norm(e, a, cv.NORM_INF))
def test_video_add(self): proc_num_frames += 1
sz = (576, 768, 3) if proc_num_frames == max_num_frames:
in_mat = np.random.randint(0, 100, sz).astype(np.uint8) break
path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
# OpenCV def test_video_add(self):
cap = cv.VideoCapture(path) sz = (576, 768, 3)
in_mat = np.random.randint(0, 100, sz).astype(np.uint8)
# G-API path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
g_in1 = cv.GMat()
g_in2 = cv.GMat()
out = cv.gapi.add(g_in1, g_in2)
c = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(out))
ccomp = c.compileStreaming() # OpenCV
source = cv.gapi.wip.make_capture_src(path) cap = cv.VideoCapture(path)
ccomp.setSource(cv.gin(source, in_mat))
ccomp.start()
# Assert # G-API
max_num_frames = 10 g_in1 = cv.GMat()
proc_num_frames = 0 g_in2 = cv.GMat()
while cap.isOpened(): out = cv.gapi.add(g_in1, g_in2)
has_expected, frame = cap.read() c = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(out))
has_actual, actual = ccomp.pull()
self.assertEqual(has_expected, has_actual) ccomp = c.compileStreaming()
source = cv.gapi.wip.make_capture_src(path)
ccomp.setSource(cv.gin(source, in_mat))
ccomp.start()
if not has_actual: # Assert
break max_num_frames = 10
proc_num_frames = 0
while cap.isOpened():
has_expected, frame = cap.read()
has_actual, actual = ccomp.pull()
expected = cv.add(frame, in_mat) self.assertEqual(has_expected, has_actual)
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
proc_num_frames += 1 if not has_actual:
if proc_num_frames == max_num_frames: break
break;
expected = cv.add(frame, in_mat)
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
def test_video_good_features_to_track(self): proc_num_frames += 1
path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']]) if proc_num_frames == max_num_frames:
break;
# NB: goodFeaturesToTrack configuration
max_corners = 50
quality_lvl = 0.01
min_distance = 10
block_sz = 3
use_harris_detector = True
k = 0.04
mask = None
# OpenCV def test_video_good_features_to_track(self):
cap = cv.VideoCapture(path) path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
# G-API # NB: goodFeaturesToTrack configuration
g_in = cv.GMat() max_corners = 50
g_gray = cv.gapi.RGB2Gray(g_in) quality_lvl = 0.01
g_out = cv.gapi.goodFeaturesToTrack(g_gray, max_corners, quality_lvl, min_distance = 10
min_distance, mask, block_sz, use_harris_detector, k) block_sz = 3
use_harris_detector = True
k = 0.04
mask = None
c = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out)) # OpenCV
cap = cv.VideoCapture(path)
ccomp = c.compileStreaming() # G-API
source = cv.gapi.wip.make_capture_src(path) g_in = cv.GMat()
ccomp.setSource(source) g_gray = cv.gapi.RGB2Gray(g_in)
ccomp.start() g_out = cv.gapi.goodFeaturesToTrack(g_gray, max_corners, quality_lvl,
min_distance, mask, block_sz, use_harris_detector, k)
# Assert c = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
max_num_frames = 10
proc_num_frames = 0
while cap.isOpened():
has_expected, frame = cap.read()
has_actual, actual = ccomp.pull()
self.assertEqual(has_expected, has_actual) ccomp = c.compileStreaming()
source = cv.gapi.wip.make_capture_src(path)
ccomp.setSource(source)
ccomp.start()
if not has_actual: # Assert
break max_num_frames = 10
proc_num_frames = 0
while cap.isOpened():
has_expected, frame = cap.read()
has_actual, actual = ccomp.pull()
self.assertEqual(has_expected, has_actual)
if not has_actual:
break
# OpenCV
frame = cv.cvtColor(frame, cv.COLOR_RGB2GRAY)
expected = cv.goodFeaturesToTrack(frame, max_corners, quality_lvl,
min_distance, mask=mask,
blockSize=block_sz, useHarrisDetector=use_harris_detector, k=k)
for e, a in zip(expected, actual):
# NB: OpenCV & G-API have different output shapes:
# OpenCV - (num_points, 1, 2)
# G-API - (num_points, 2)
self.assertEqual(0.0, cv.norm(e.flatten(),
np.array(a, np.float32).flatten(),
cv.NORM_INF))
proc_num_frames += 1
if proc_num_frames == max_num_frames:
break
except unittest.SkipTest as e:
message = str(e)
class TestSkip(unittest.TestCase):
def setUp(self):
self.skipTest('Skip tests: ' + message)
def test_skip():
pass
pass
# OpenCV
frame = cv.cvtColor(frame, cv.COLOR_RGB2GRAY)
expected = cv.goodFeaturesToTrack(frame, max_corners, quality_lvl,
min_distance, mask=mask,
blockSize=block_sz, useHarrisDetector=use_harris_detector, k=k)
for e, a in zip(expected, actual):
# NB: OpenCV & G-API have different output shapes:
# OpenCV - (num_points, 1, 2)
# G-API - (num_points, 2)
self.assertEqual(0.0, cv.norm(e.flatten(),
np.array(a, np.float32).flatten(),
cv.NORM_INF))
proc_num_frames += 1
if proc_num_frames == max_num_frames:
break;
if __name__ == '__main__': if __name__ == '__main__':
NewOpenCVTests.bootstrap() NewOpenCVTests.bootstrap()

52
modules/gapi/misc/python/test/test_gapi_types.py
Unescape View File

@ -3,29 +3,51 @@
import numpy as np import numpy as np
import cv2 as cv import cv2 as cv
import os import os
import sys
import unittest
from tests_common import NewOpenCVTests from tests_common import NewOpenCVTests
class gapi_types_test(NewOpenCVTests):
def test_garray_type(self): try:
types = [cv.gapi.CV_BOOL , cv.gapi.CV_INT , cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT,
cv.gapi.CV_STRING, cv.gapi.CV_POINT , cv.gapi.CV_POINT2F, cv.gapi.CV_SIZE ,
cv.gapi.CV_RECT , cv.gapi.CV_SCALAR, cv.gapi.CV_MAT , cv.gapi.CV_GMAT]
for t in types: if sys.version_info[:2] < (3, 0):
g_array = cv.GArrayT(t) raise unittest.SkipTest('Python 2.x is not supported')
self.assertEqual(t, g_array.type())
class gapi_types_test(NewOpenCVTests):
def test_gopaque_type(self): def test_garray_type(self):
types = [cv.gapi.CV_BOOL , cv.gapi.CV_INT , cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT, types = [cv.gapi.CV_BOOL , cv.gapi.CV_INT , cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT,
cv.gapi.CV_STRING, cv.gapi.CV_POINT , cv.gapi.CV_POINT2F, cv.gapi.CV_SIZE , cv.gapi.CV_STRING, cv.gapi.CV_POINT , cv.gapi.CV_POINT2F, cv.gapi.CV_SIZE ,
cv.gapi.CV_RECT] cv.gapi.CV_RECT , cv.gapi.CV_SCALAR, cv.gapi.CV_MAT , cv.gapi.CV_GMAT]
for t in types: for t in types:
g_opaque = cv.GOpaqueT(t) g_array = cv.GArrayT(t)
self.assertEqual(t, g_opaque.type()) self.assertEqual(t, g_array.type())
def test_gopaque_type(self):
types = [cv.gapi.CV_BOOL , cv.gapi.CV_INT , cv.gapi.CV_DOUBLE , cv.gapi.CV_FLOAT,
cv.gapi.CV_STRING, cv.gapi.CV_POINT , cv.gapi.CV_POINT2F, cv.gapi.CV_SIZE ,
cv.gapi.CV_RECT]
for t in types:
g_opaque = cv.GOpaqueT(t)
self.assertEqual(t, g_opaque.type())
except unittest.SkipTest as e:
message = str(e)
class TestSkip(unittest.TestCase):
def setUp(self):
self.skipTest('Skip tests: ' + message)
def test_skip():
pass
pass
if __name__ == '__main__': if __name__ == '__main__':

Write Preview
Loading…
Cancel
Save