return parameterized
+@register('cv2.gapi')
+def compile_args(*args):
+ return list(map(cv.GCompileArg, args))
+
+
@register('cv2')
class GOpaque():
# NB: Inheritance from c++ class cause segfault.
namespace cv
{
- struct GAPI_EXPORTS_W_SIMPLE GCompileArg { };
-
- GAPI_EXPORTS_W GCompileArgs compile_args(gapi::GKernelPackage pkg);
- GAPI_EXPORTS_W GCompileArgs compile_args(gapi::GNetPackage pkg);
- GAPI_EXPORTS_W GCompileArgs compile_args(gapi::GKernelPackage kernels, gapi::GNetPackage nets);
+ struct GAPI_EXPORTS_W_SIMPLE GCompileArg {
+ GAPI_WRAP GCompileArg(gapi::GKernelPackage pkg);
+ GAPI_WRAP GCompileArg(gapi::GNetPackage pkg);
+ };
// NB: This classes doesn't exist in *.so
// HACK: Mark them as a class to force python wrapper generate code for this entities
import numpy as np
import cv2 as cv
import os
+import sys
+import unittest
from tests_common import 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())
- ]
+try:
+ 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
- expected = cv.add(in1, in2)
+ class gapi_core_test(NewOpenCVTests):
- # 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))
+ 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)
- for pkg_name, pkg in pkgs:
- actual = comp.apply(cv.gin(in1, in2), args=cv.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')
+ # 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
+ 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
- expected = cv.add(in1, in2)
+ def test_mean(self):
+ img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
+ in_mat = cv.imread(img_path)
- # 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))
+ # OpenCV
+ expected = cv.mean(in_mat)
- for pkg_name, pkg in pkgs:
- actual = comp.apply(cv.gin(in1, in2), args=cv.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')
+ # G-API
+ g_in = cv.GMat()
+ g_out = cv.gapi.mean(g_in)
+ comp = cv.GComputation(g_in, g_out)
+
+ 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):
- img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
- in_mat = cv.imread(img_path)
+ def test_split3(self):
+ img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
+ in_mat = cv.imread(img_path)
- # OpenCV
- expected = cv.mean(in_mat)
+ # OpenCV
+ expected = cv.split(in_mat)
- # G-API
- g_in = cv.GMat()
- g_out = cv.gapi.mean(g_in)
- comp = cv.GComputation(g_in, g_out)
+ # G-API
+ g_in = cv.GMat()
+ b, g, r = cv.gapi.split3(g_in)
+ comp = cv.GComputation(cv.GIn(g_in), cv.GOut(b, g, r))
- for pkg_name, pkg in pkgs:
- actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
- # Comparison
- self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
- '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
+ for e, a in zip(expected, actual):
+ 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):
- img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
- in_mat = cv.imread(img_path)
+ def test_threshold(self):
+ img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
+ in_mat = cv.cvtColor(cv.imread(img_path), cv.COLOR_RGB2GRAY)
+ maxv = (30, 30)
- # OpenCV
- expected = cv.split(in_mat)
+ # OpenCV
+ expected_thresh, expected_mat = cv.threshold(in_mat, maxv[0], maxv[0], cv.THRESH_TRIANGLE)
- # G-API
- g_in = cv.GMat()
- b, g, r = cv.gapi.split3(g_in)
- comp = cv.GComputation(cv.GIn(g_in), cv.GOut(b, g, r))
+ # G-API
+ g_in = cv.GMat()
+ g_sc = cv.GScalar()
+ 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:
- actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
- # Comparison
- for e, a in zip(expected, actual):
- self.assertEqual(0.0, cv.norm(e, a, cv.NORM_INF),
+ for pkg_name, pkg in pkgs:
+ actual_mat, actual_thresh = comp.apply(cv.gin(in_mat, maxv), args=cv.gapi.compile_args(pkg))
+ # Comparison
+ self.assertEqual(0.0, cv.norm(expected_mat, actual_mat, 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')
- self.assertEqual(e.dtype, a.dtype, 'Failed on ' + pkg_name + ' backend')
-
-
- def test_threshold(self):
- img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
- in_mat = cv.cvtColor(cv.imread(img_path), cv.COLOR_RGB2GRAY)
- maxv = (30, 30)
-
- # OpenCV
- expected_thresh, expected_mat = cv.threshold(in_mat, maxv[0], maxv[0], cv.THRESH_TRIANGLE)
-
- # G-API
- g_in = cv.GMat()
- g_sc = cv.GScalar()
- 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:
- actual_mat, actual_thresh = comp.apply(cv.gin(in_mat, maxv), args=cv.compile_args(pkg))
- # Comparison
- self.assertEqual(0.0, cv.norm(expected_mat, actual_mat, 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')
-
- def test_kmeans(self):
- # K-means params
- count = 100
- sz = (count, 2)
- in_mat = np.random.random(sz).astype(np.float32)
- K = 5
- flags = cv.KMEANS_RANDOM_CENTERS
- attempts = 1;
- criteria = (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 30, 0)
-
- # G-API
- g_in = cv.GMat()
- compactness, out_labels, centers = cv.gapi.kmeans(g_in, K, criteria, attempts, flags)
- comp = cv.GComputation(cv.GIn(g_in), cv.GOut(compactness, out_labels, centers))
-
- compact, labels, centers = comp.apply(cv.gin(in_mat))
-
- # Assert
- self.assertTrue(compact >= 0)
- self.assertEqual(sz[0], labels.shape[0])
- self.assertEqual(1, labels.shape[1])
- self.assertTrue(labels.size != 0)
- self.assertEqual(centers.shape[1], sz[1]);
- self.assertEqual(centers.shape[0], K);
- self.assertTrue(centers.size != 0);
-
-
- def generate_random_points(self, sz):
- arr = np.random.random(sz).astype(np.float32).T
- return list(zip(arr[0], arr[1]))
-
-
- def test_kmeans_2d(self):
- # K-means 2D params
- count = 100
- sz = (count, 2)
- amount = sz[0]
- K = 5
- flags = cv.KMEANS_RANDOM_CENTERS
- attempts = 1;
- criteria = (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 30, 0);
- in_vector = self.generate_random_points(sz)
- in_labels = []
-
- # G-API
- data = cv.GArrayT(cv.gapi.CV_POINT2F)
- 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))
+
+
+ def test_kmeans(self):
+ # K-means params
+ count = 100
+ sz = (count, 2)
+ in_mat = np.random.random(sz).astype(np.float32)
+ K = 5
+ flags = cv.KMEANS_RANDOM_CENTERS
+ attempts = 1
+ criteria = (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 30, 0)
+
+ # G-API
+ g_in = cv.GMat()
+ compactness, out_labels, centers = cv.gapi.kmeans(g_in, K, criteria, attempts, flags)
+ comp = cv.GComputation(cv.GIn(g_in), cv.GOut(compactness, out_labels, centers))
+
+ compact, labels, centers = comp.apply(cv.gin(in_mat))
+
+ # Assert
+ self.assertTrue(compact >= 0)
+ self.assertEqual(sz[0], labels.shape[0])
+ self.assertEqual(1, labels.shape[1])
+ self.assertTrue(labels.size != 0)
+ self.assertEqual(centers.shape[1], sz[1])
+ self.assertEqual(centers.shape[0], K)
+ self.assertTrue(centers.size != 0)
+
+
+ def generate_random_points(self, sz):
+ arr = np.random.random(sz).astype(np.float32).T
+ return list(zip(arr[0], arr[1]))
+
+
+ def test_kmeans_2d(self):
+ # K-means 2D params
+ count = 100
+ sz = (count, 2)
+ amount = sz[0]
+ K = 5
+ flags = cv.KMEANS_RANDOM_CENTERS
+ attempts = 1
+ criteria = (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 30, 0)
+ in_vector = self.generate_random_points(sz)
+ in_labels = []
+
+ # G-API
+ data = cv.GArrayT(cv.gapi.CV_POINT2F)
+ 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))
+
+
+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__':
import numpy as np
import cv2 as cv
import os
+import sys
+import unittest
from tests_common import 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())
- ]
+try:
+ 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
- max_corners = 50
- quality_lvl = 0.01
- min_distance = 10
- block_sz = 3
- use_harris_detector = True
- k = 0.04
- mask = None
+ class gapi_imgproc_test(NewOpenCVTests):
- # OpenCV
- expected = cv.goodFeaturesToTrack(in1, max_corners, quality_lvl,
- min_distance, mask=mask,
- blockSize=block_sz, useHarrisDetector=use_harris_detector, k=k)
+ 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)
- # G-API
- g_in = cv.GMat()
- g_out = cv.gapi.goodFeaturesToTrack(g_in, max_corners, quality_lvl,
- min_distance, mask, block_sz, use_harris_detector, k)
+ # 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
- 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:
- actual = comp.apply(cv.gin(in1), args=cv.compile_args(pkg))
- # NB: OpenCV & G-API have different output shapes:
- # 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')
+ # G-API
+ g_in = cv.GMat()
+ g_out = cv.gapi.goodFeaturesToTrack(g_in, max_corners, quality_lvl,
+ min_distance, mask, block_sz, use_harris_detector, k)
+ comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
- def test_rgb2gray(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.imread(img_path)
+ for pkg_name, pkg in pkgs:
+ actual = comp.apply(cv.gin(in1), args=cv.gapi.compile_args(pkg))
+ # NB: OpenCV & G-API have different output shapes:
+ # 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
- g_in = cv.GMat()
- g_out = cv.gapi.RGB2Gray(g_in)
+ def test_rgb2gray(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.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:
- actual = comp.apply(cv.gin(in1), args=cv.compile_args(pkg))
- # Comparison
- self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
- 'Failed on ' + pkg_name + ' backend')
+ # G-API
+ g_in = cv.GMat()
+ g_out = cv.gapi.RGB2Gray(g_in)
+ comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
- def test_bounding_rect(self):
- sz = 1280
- fscale = 256
+ for pkg_name, pkg in pkgs:
+ actual = comp.apply(cv.gin(in1), args=cv.gapi.compile_args(pkg))
+ # 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
- expected = cv.boundingRect(points)
+ def sample_value(fscale):
+ return np.random.uniform(0, 255 * fscale) / fscale
- # G-API
- g_in = cv.GMat()
- g_out = cv.gapi.boundingRect(g_in)
+ points = np.array([(sample_value(fscale), sample_value(fscale)) for _ in range(1280)], np.float32)
- comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
+ # OpenCV
+ expected = cv.boundingRect(points)
- for pkg_name, pkg in pkgs:
- actual = comp.apply(cv.gin(points), args=cv.compile_args(pkg))
- # Comparison
- self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
- 'Failed on ' + pkg_name + ' backend')
+ # G-API
+ g_in = cv.GMat()
+ g_out = cv.gapi.boundingRect(g_in)
+
+ 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__':
import numpy as np
import cv2 as cv
import os
+import sys
+import unittest
from tests_common import NewOpenCVTests
-class test_gapi_infer(NewOpenCVTests):
+try:
- 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)
+ if sys.version_info[:2] < (3, 0):
+ raise unittest.SkipTest('Python 2.x is not supported')
- blob = cv.dnn.blobFromImage(img)
- net.setInput(blob)
- return net.forward(net.getUnconnectedOutLayersNames())
+ class test_gapi_infer(NewOpenCVTests):
+ 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):
- return img[roi[1]:roi[1] + roi[3], roi[0]:roi[0] + roi[2], ...]
+ blob = cv.dnn.blobFromImage(img)
+ 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'
- 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'
+ def make_roi(self, img, roi):
+ return img[roi[1]:roi[1] + roi[3], roi[0]:roi[0] + roi[2], ...]
- 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
- dnn_age, dnn_gender = self.infer_reference_network(model_path, weights_path, img)
+ 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
- # OpenCV G-API
- g_in = cv.GMat()
- inputs = cv.GInferInputs()
- inputs.setInput('data', g_in)
+ 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'
- outputs = cv.gapi.infer("net", inputs)
- age_g = outputs.at("age_conv3")
- gender_g = outputs.at("prob")
+ 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))
- 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)
+ # OpenCV DNN
+ 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
- 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))
+ outputs = cv.gapi.infer("net", inputs)
+ age_g = outputs.at("age_conv3")
+ 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):
- # NB: Check IE
- if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
- return
+ gapi_age, gapi_gender = comp.apply(cv.gin(img), args=cv.gapi.compile_args(cv.gapi.networks(pp)))
- 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'
+ # Check
+ 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))
- 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
- dnn_age, dnn_gender = self.infer_reference_network(model_path,
- weights_path,
- self.make_roi(img, roi))
+ def test_age_gender_infer_roi(self):
+ # NB: Check IE
+ if not cv.dnn.DNN_TARGET_CPU in cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE):
+ return
- # OpenCV G-API
- g_in = cv.GMat()
- g_roi = cv.GOpaqueT(cv.gapi.CV_RECT)
- inputs = cv.GInferInputs()
- inputs.setInput('data', g_in)
-
- outputs = cv.gapi.infer("net", g_roi, inputs)
- age_g = outputs.at("age_conv3")
- gender_g = outputs.at("prob")
-
- comp = cv.GComputation(cv.GIn(g_in, g_roi), cv.GOut(age_g, gender_g))
- pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
-
- gapi_age, gapi_gender = comp.apply(cv.gin(img, roi), args=cv.compile_args(cv.gapi.networks(pp)))
-
- # Check
- 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_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.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))
+ 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'
+
+ 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
+ dnn_age, dnn_gender = self.infer_reference_network(model_path,
+ weights_path,
+ self.make_roi(img, roi))
+
+ # OpenCV G-API
+ g_in = cv.GMat()
+ g_roi = cv.GOpaqueT(cv.gapi.CV_RECT)
+ inputs = cv.GInferInputs()
+ inputs.setInput('data', g_in)
+
+ outputs = cv.gapi.infer("net", g_roi, inputs)
+ age_g = outputs.at("age_conv3")
+ gender_g = outputs.at("prob")
+
+ comp = cv.GComputation(cv.GIn(g_in, g_roi), cv.GOut(age_g, gender_g))
+ pp = cv.gapi.ie.params("net", model_path, weights_path, device_id)
+ 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):
- # 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):
+ # Check
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_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):
- # 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))
+ pass
if __name__ == '__main__':
comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
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))
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_ch1, g_ch2, g_ch3))
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_ch2, ch2, cv.NORM_INF))
comp = cv.GComputation(g_in, g_out)
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
self.assertEqual(expected, actual)
comp = cv.GComputation(cv.GIn(g_in, g_sc), cv.GOut(g_out))
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))
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_sz))
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))
comp = cv.GComputation(cv.GIn(g_r), cv.GOut(g_sz))
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 ?
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
comp = cv.GComputation(cv.GIn(g_pts), cv.GOut(g_br))
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 ?
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
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.
# OpenCV - numpy array with shape (num_points, 1, 2)
g_in = cv.GArray.Int()
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)
- 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, GSumImpl.last_result)
'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)
- 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)
- 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)
arr1 = [3, 'str']
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)
img1 = np.array([1, 2, 3])
with self.assertRaises(Exception): comp.apply(cv.gin(img0, img1),
- args=cv.compile_args(
+ args=cv.gapi.compile_args(
cv.gapi.kernels(GAddImpl)))
img1 = np.array([1, 2, 3])
with self.assertRaises(Exception): comp.apply(cv.gin(img0, img1),
- args=cv.compile_args(
+ args=cv.gapi.compile_args(
cv.gapi.kernels(GAddImpl)))
# FIXME: Cause Bad variant access.
# Need to provide more descriptive error messsage.
with self.assertRaises(Exception): comp.apply(cv.gin(img0, img1),
- args=cv.compile_args(
+ args=cv.gapi.compile_args(
cv.gapi.kernels(GAddImpl)))
def test_pipeline_with_custom_kernels(self):
g_mean = cv.gapi.mean(g_transposed)
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)))
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
import numpy as np
import cv2 as cv
import os
+import sys
+import unittest
from tests_common import NewOpenCVTests
-class test_gapi_streaming(NewOpenCVTests):
- def test_image_input(self):
- sz = (1280, 720)
- in_mat = np.random.randint(0, 100, sz).astype(np.uint8)
+try:
- # OpenCV
- expected = cv.medianBlur(in_mat, 3)
+ if sys.version_info[:2] < (3, 0):
+ 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
- self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+ def test_image_input(self):
+ 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):
- ksize = 3
- path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
+ _, actual = ccomp.pull()
- # OpenCV
- cap = cv.VideoCapture(path)
+ # Assert
+ 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()
- source = cv.gapi.wip.make_capture_src(path)
- ccomp.setSource(source)
- ccomp.start()
+ def test_video_input(self):
+ ksize = 3
+ path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
+
+ # OpenCV
+ cap = cv.VideoCapture(path)
- # Assert
- max_num_frames = 10
- proc_num_frames = 0
- while cap.isOpened():
- has_expected, expected = cap.read()
- has_actual, actual = ccomp.pull()
+ # G-API
+ g_in = cv.GMat()
+ g_out = cv.gapi.medianBlur(g_in, ksize)
+ c = cv.GComputation(g_in, g_out)
- 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:
- break
+ # Assert
+ 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 proc_num_frames == max_num_frames:
- break;
+ if not has_actual:
+ break
+ self.assertEqual(0.0, cv.norm(cv.medianBlur(expected, ksize), actual, cv.NORM_INF))
- def test_video_split3(self):
- path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
+ proc_num_frames += 1
+ if proc_num_frames == max_num_frames:
+ break
- # OpenCV
- cap = cv.VideoCapture(path)
- # G-API
- g_in = cv.GMat()
- b, g, r = cv.gapi.split3(g_in)
- c = cv.GComputation(cv.GIn(g_in), cv.GOut(b, g, r))
+ def test_video_split3(self):
+ path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
- ccomp = c.compileStreaming()
- source = cv.gapi.wip.make_capture_src(path)
- ccomp.setSource(source)
- ccomp.start()
+ # OpenCV
+ cap = cv.VideoCapture(path)
- # Assert
- max_num_frames = 10
- proc_num_frames = 0
- while cap.isOpened():
- has_expected, frame = cap.read()
- has_actual, actual = ccomp.pull()
+ # G-API
+ g_in = cv.GMat()
+ b, g, r = cv.gapi.split3(g_in)
+ c = cv.GComputation(cv.GIn(g_in), cv.GOut(b, g, r))
- 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:
- break
+ # Assert
+ 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)
- for e, a in zip(expected, actual):
- self.assertEqual(0.0, cv.norm(e, a, cv.NORM_INF))
+ self.assertEqual(has_expected, has_actual)
- proc_num_frames += 1
- if proc_num_frames == max_num_frames:
- break;
+ if not has_actual:
+ 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):
- sz = (576, 768, 3)
- in_mat = np.random.randint(0, 100, sz).astype(np.uint8)
+ proc_num_frames += 1
+ if proc_num_frames == max_num_frames:
+ break
- path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
- # OpenCV
- cap = cv.VideoCapture(path)
+ def test_video_add(self):
+ sz = (576, 768, 3)
+ in_mat = np.random.randint(0, 100, sz).astype(np.uint8)
- # G-API
- 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))
+ path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
- ccomp = c.compileStreaming()
- source = cv.gapi.wip.make_capture_src(path)
- ccomp.setSource(cv.gin(source, in_mat))
- ccomp.start()
+ # OpenCV
+ cap = cv.VideoCapture(path)
- # Assert
- max_num_frames = 10
- proc_num_frames = 0
- while cap.isOpened():
- has_expected, frame = cap.read()
- has_actual, actual = ccomp.pull()
+ # G-API
+ 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))
- 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:
- break
+ # Assert
+ 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(0.0, cv.norm(expected, actual, cv.NORM_INF))
+ self.assertEqual(has_expected, has_actual)
- proc_num_frames += 1
- if proc_num_frames == max_num_frames:
- break;
+ if not has_actual:
+ 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):
- path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
+ proc_num_frames += 1
+ 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
- cap = cv.VideoCapture(path)
+ def test_video_good_features_to_track(self):
+ path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
- # G-API
- g_in = cv.GMat()
- g_gray = cv.gapi.RGB2Gray(g_in)
- g_out = cv.gapi.goodFeaturesToTrack(g_gray, max_corners, quality_lvl,
- min_distance, mask, block_sz, use_harris_detector, k)
+ # 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
- c = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
+ # OpenCV
+ cap = cv.VideoCapture(path)
- ccomp = c.compileStreaming()
- source = cv.gapi.wip.make_capture_src(path)
- ccomp.setSource(source)
- ccomp.start()
+ # G-API
+ g_in = cv.GMat()
+ g_gray = cv.gapi.RGB2Gray(g_in)
+ g_out = cv.gapi.goodFeaturesToTrack(g_gray, max_corners, quality_lvl,
+ min_distance, mask, block_sz, use_harris_detector, k)
- # Assert
- max_num_frames = 10
- proc_num_frames = 0
- while cap.isOpened():
- has_expected, frame = cap.read()
- has_actual, actual = ccomp.pull()
+ c = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
- 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:
- break
+ # Assert
+ 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__':
NewOpenCVTests.bootstrap()
import numpy as np
import cv2 as cv
import os
+import sys
+import unittest
from tests_common import NewOpenCVTests
-class gapi_types_test(NewOpenCVTests):
- def test_garray_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 , cv.gapi.CV_SCALAR, cv.gapi.CV_MAT , cv.gapi.CV_GMAT]
+try:
- for t in types:
- g_array = cv.GArrayT(t)
- self.assertEqual(t, g_array.type())
+ if sys.version_info[:2] < (3, 0):
+ raise unittest.SkipTest('Python 2.x is not supported')
+ class gapi_types_test(NewOpenCVTests):
- 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]
+ def test_garray_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 , cv.gapi.CV_SCALAR, cv.gapi.CV_MAT , cv.gapi.CV_GMAT]
- for t in types:
- g_opaque = cv.GOpaqueT(t)
- self.assertEqual(t, g_opaque.type())
+ for t in types:
+ g_array = cv.GArrayT(t)
+ 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__':
projects / platform / upstream / opencv.git / commitdiff