init - 初始化项目

modules/gapi/misc/python/test/test_gapi_core.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+
+import numpy as np
+import cv2 as cv
+import os
+
+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())
+       ]
+
+
+class gapi_core_test(NewOpenCVTests):
+
+    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)
+
+        # 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.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.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_mean(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)
+
+        # 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.compile_args(pkg))
+            # Comparison
+            self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
+                             '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)
+
+        # OpenCV
+        expected = cv.split(in_mat)
+
+        # 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
+            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_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))
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()

modules/gapi/misc/python/test/test_gapi_imgproc.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+
+import numpy as np
+import cv2 as cv
+import os
+
+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())
+       ]
+
+
+class gapi_imgproc_test(NewOpenCVTests):
+
+    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
+
+        # OpenCV
+        expected = cv.goodFeaturesToTrack(in1, max_corners, quality_lvl,
+                                          min_distance, mask=mask,
+                                          blockSize=block_sz, useHarrisDetector=use_harris_detector, k=k)
+
+        # 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))
+
+        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')
+
+
+    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)
+
+        # OpenCV
+        expected = cv.cvtColor(in1, cv.COLOR_RGB2GRAY)
+
+        # G-API
+        g_in = cv.GMat()
+        g_out = cv.gapi.RGB2Gray(g_in)
+
+        comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
+
+        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')
+
+
+    def test_bounding_rect(self):
+        sz = 1280
+        fscale = 256
+
+        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)
+
+        # OpenCV
+        expected = cv.boundingRect(points)
+
+        # 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.compile_args(pkg))
+            # Comparison
+            self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF),
+                             'Failed on ' + pkg_name + ' backend')
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()

modules/gapi/misc/python/test/test_gapi_infer.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python
+
+import numpy as np
+import cv2 as cv
+import os
+
+from tests_common import NewOpenCVTests
+
+
+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)
+
+        blob = cv.dnn.blobFromImage(img)
+
+        net.setInput(blob)
+        return net.forward(net.getUnconnectedOutLayersNames())
+
+
+    def make_roi(self, img, roi):
+        return img[roi[1]:roi[1] + roi[3], roi[0]:roi[0] + roi[2], ...]
+
+
+    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'
+
+        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)
+
+        # OpenCV G-API
+        g_in   = cv.GMat()
+        inputs = cv.GInferInputs()
+        inputs.setInput('data', g_in)
+
+        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)
+
+        gapi_age, gapi_gender = comp.apply(cv.gin(img), 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(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'
+
+        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.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))
+
+
+    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):
+            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_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__':
+    NewOpenCVTests.bootstrap()

modules/gapi/misc/python/test/test_gapi_sample_pipelines.py

@@ -0,0 +1,526 @@
+#!/usr/bin/env python
+
+import numpy as np
+import cv2 as cv
+import os
+
+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())
+     ]
+
+# Test output GMat.
+def custom_add(img1, img2, dtype):
+    return cv.add(img1, img2)
+
+# Test output GScalar.
+def custom_mean(img):
+    return cv.mean(img)
+
+# Test output tuple of GMat's.
+def custom_split3(img):
+    # NB: cv.split return list but g-api requires tuple in multiple output case
+    return tuple(cv.split(img))
+
+# Test output GOpaque.
+def custom_size(img):
+    # NB: Take only H, W, because the operation should return cv::Size which is 2D.
+    return img.shape[:2]
+
+# Test output GArray.
+def custom_goodFeaturesToTrack(img, max_corners, quality_lvl,
+                               min_distance, mask, block_sz,
+                               use_harris_detector, k):
+    features = cv.goodFeaturesToTrack(img, max_corners, quality_lvl,
+                                      min_distance, mask=mask,
+                                      blockSize=block_sz,
+                                      useHarrisDetector=use_harris_detector, k=k)
+    # NB: The operation output is cv::GArray<cv::Pointf>, so it should be mapped
+    # to python paramaters like this: [(1.2, 3.4), (5.2, 3.2)], because the cv::Point2f
+    # according to opencv rules mapped to the tuple and cv::GArray<> mapped to the list.
+    # OpenCV returns np.array with shape (n_features, 1, 2), so let's to convert it to list
+    # tuples with size - n_features.
+    features = list(map(tuple, features.reshape(features.shape[0], -1)))
+    return features
+
+# Test input scalar.
+def custom_addC(img, sc, dtype):
+    # NB: dtype is just ignored in this implementation.
+    # More over from G-API kernel got scalar as tuples with 4 elements
+    # where the last element is equal to zero, just cut him for broadcasting.
+    return img + np.array(sc, dtype=np.uint8)[:-1]
+
+
+# Test input opaque.
+def custom_sizeR(rect):
+    # NB: rect - is tuple (x, y, h, w)
+    return (rect[2], rect[3])
+
+# Test input array.
+def custom_boundingRect(array):
+    # NB: OpenCV - numpy array (n_points x 2).
+    #     G-API  - array of tuples (n_points).
+    return cv.boundingRect(np.array(array))
+
+# Test input mat
+def add(g_in1, g_in2, dtype):
+    def custom_add_meta(img_desc1, img_desc2, dtype):
+        return img_desc1
+
+    return cv.gapi.wip.op('custom.add', custom_add_meta, g_in1, g_in2, dtype).getGMat()
+
+
+# Test multiple output mat
+def split3(g_in):
+    def custom_split3_meta(img_desc):
+        out_desc = img_desc.withType(img_desc.depth, 1)
+        return out_desc, out_desc, out_desc
+
+    op = cv.gapi.wip.op('custom.split3', custom_split3_meta, g_in)
+
+    ch1 = op.getGMat()
+    ch2 = op.getGMat()
+    ch3 = op.getGMat()
+
+    return ch1, ch2, ch3
+
+# Test output scalar
+def mean(g_in):
+    def custom_mean_meta(img_desc):
+        return cv.empty_scalar_desc()
+
+    op = cv.gapi.wip.op('custom.mean', custom_mean_meta, g_in)
+    return op.getGScalar()
+
+
+# Test input scalar
+def addC(g_in, g_sc, dtype):
+    def custom_addC_meta(img_desc, sc_desc, dtype):
+        return img_desc
+
+    op = cv.gapi.wip.op('custom.addC', custom_addC_meta, g_in, g_sc, dtype)
+    return op.getGMat()
+
+
+# Test output opaque.
+def size(g_in):
+    def custom_size_meta(img_desc):
+        return cv.empty_gopaque_desc()
+
+    op = cv.gapi.wip.op('custom.size', custom_size_meta, g_in)
+    return op.getGOpaque(cv.gapi.CV_SIZE)
+
+
+# Test input opaque.
+def sizeR(g_rect):
+    def custom_sizeR_meta(opaque_desc):
+        return cv.empty_gopaque_desc()
+
+    op = cv.gapi.wip.op('custom.sizeR', custom_sizeR_meta, g_rect)
+    return op.getGOpaque(cv.gapi.CV_SIZE)
+
+
+# Test input array.
+def boundingRect(g_array):
+    def custom_boundingRect_meta(array_desc):
+        return cv.empty_gopaque_desc()
+
+    op = cv.gapi.wip.op('custom.boundingRect', custom_boundingRect_meta, g_array)
+    return op.getGOpaque(cv.gapi.CV_RECT)
+
+
+# Test output GArray.
+def goodFeaturesToTrack(g_in, max_corners, quality_lvl,
+                        min_distance, mask, block_sz,
+                        use_harris_detector, k):
+    def custom_goodFeaturesToTrack_meta(img_desc, max_corners, quality_lvl,
+                                        min_distance, mask, block_sz, use_harris_detector, k):
+        return cv.empty_array_desc()
+
+    op = cv.gapi.wip.op('custom.goodFeaturesToTrack', custom_goodFeaturesToTrack_meta, g_in,
+            max_corners, quality_lvl, min_distance, mask, block_sz, use_harris_detector, k)
+    return op.getGArray(cv.gapi.CV_POINT2F)
+
+
+class gapi_sample_pipelines(NewOpenCVTests):
+
+    # NB: This test check multiple outputs for operation
+    def test_mean_over_r(self):
+        img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
+        in_mat = cv.imread(img_path)
+
+        # # OpenCV
+        _, _, r_ch = cv.split(in_mat)
+        expected = cv.mean(r_ch)
+
+        # G-API
+        g_in = cv.GMat()
+        b, g, r = cv.gapi.split3(g_in)
+        g_out = cv.gapi.mean(r)
+        comp = cv.GComputation(g_in, g_out)
+
+        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')
+
+
+    def test_custom_mean(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)
+
+        # G-API
+        g_in = cv.GMat()
+        g_out = cv.gapi.mean(g_in)
+
+        comp = cv.GComputation(g_in, g_out)
+
+        pkg    = cv.gapi.wip.kernels((custom_mean, 'org.opencv.core.math.mean'))
+        actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
+
+        # Comparison
+        self.assertEqual(expected, actual)
+
+
+    def test_custom_add(self):
+        sz = (3, 3)
+        in_mat1 = np.full(sz, 45, dtype=np.uint8)
+        in_mat2 = np.full(sz, 50 , dtype=np.uint8)
+
+        # OpenCV
+        expected = cv.add(in_mat1, in_mat2)
+
+        # 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))
+
+        pkg = cv.gapi.wip.kernels((custom_add, 'org.opencv.core.math.add'))
+        actual = comp.apply(cv.gin(in_mat1, in_mat2), args=cv.compile_args(pkg))
+
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_size(self):
+        sz = (100, 150, 3)
+        in_mat = np.full(sz, 45, dtype=np.uint8)
+
+        # OpenCV
+        expected = (100, 150)
+
+        # G-API
+        g_in = cv.GMat()
+        g_sz = cv.gapi.streaming.size(g_in)
+        comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_sz))
+
+        pkg = cv.gapi.wip.kernels((custom_size, 'org.opencv.streaming.size'))
+        actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
+
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_goodFeaturesToTrack(self):
+        # G-API
+        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)
+
+        # 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
+        expected = cv.goodFeaturesToTrack(in_mat, max_corners, quality_lvl,
+                                          min_distance, mask=mask,
+                                          blockSize=block_sz, useHarrisDetector=use_harris_detector, k=k)
+
+        # 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))
+        pkg = cv.gapi.wip.kernels((custom_goodFeaturesToTrack, 'org.opencv.imgproc.feature.goodFeaturesToTrack'))
+        actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
+
+        # NB: OpenCV & G-API have different output types.
+        # OpenCV - numpy array with shape (num_points, 1, 2)
+        # G-API  - list of tuples with size - num_points
+        # Comparison
+        self.assertEqual(0.0, cv.norm(expected.flatten(),
+                                      np.array(actual, dtype=np.float32).flatten(), cv.NORM_INF))
+
+
+    def test_custom_addC(self):
+        sz = (3, 3, 3)
+        in_mat = np.full(sz, 45, dtype=np.uint8)
+        sc = (50, 10, 20)
+
+        # Numpy reference, make array from sc to keep uint8 dtype.
+        expected = in_mat + np.array(sc, dtype=np.uint8)
+
+        # G-API
+        g_in = cv.GMat()
+        g_sc = cv.GScalar()
+        g_out = cv.gapi.addC(g_in, g_sc)
+        comp = cv.GComputation(cv.GIn(g_in, g_sc), cv.GOut(g_out))
+
+        pkg = cv.gapi.wip.kernels((custom_addC, 'org.opencv.core.math.addC'))
+        actual = comp.apply(cv.gin(in_mat, sc), args=cv.compile_args(pkg))
+
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_sizeR(self):
+        # x, y, h, w
+        roi = (10, 15, 100, 150)
+
+        expected = (100, 150)
+
+        # G-API
+        g_r  = cv.GOpaqueT(cv.gapi.CV_RECT)
+        g_sz = cv.gapi.streaming.size(g_r)
+        comp = cv.GComputation(cv.GIn(g_r), cv.GOut(g_sz))
+
+        pkg = cv.gapi.wip.kernels((custom_sizeR, 'org.opencv.streaming.sizeR'))
+        actual = comp.apply(cv.gin(roi), args=cv.compile_args(pkg))
+
+        # cv.norm works with tuples ?
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_boundingRect(self):
+        points = [(0,0), (0,1), (1,0), (1,1)]
+
+        # OpenCV
+        expected = cv.boundingRect(np.array(points))
+
+        # G-API
+        g_pts = cv.GArrayT(cv.gapi.CV_POINT)
+        g_br  = cv.gapi.boundingRect(g_pts)
+        comp = cv.GComputation(cv.GIn(g_pts), cv.GOut(g_br))
+
+        pkg = cv.gapi.wip.kernels((custom_boundingRect, 'org.opencv.imgproc.shape.boundingRectVector32S'))
+        actual = comp.apply(cv.gin(points), args=cv.compile_args(pkg))
+
+        # cv.norm works with tuples ?
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_multiple_custom_kernels(self):
+        sz = (3, 3, 3)
+        in_mat1 = np.full(sz, 45, dtype=np.uint8)
+        in_mat2 = np.full(sz, 50 , dtype=np.uint8)
+
+        # OpenCV
+        expected = cv.mean(cv.split(cv.add(in_mat1, in_mat2))[1])
+
+        # G-API
+        g_in1 = cv.GMat()
+        g_in2 = cv.GMat()
+        g_sum = cv.gapi.add(g_in1, g_in2)
+        g_b, g_r, g_g = cv.gapi.split3(g_sum)
+        g_mean = cv.gapi.mean(g_b)
+
+        comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_mean))
+
+
+        pkg = cv.gapi.wip.kernels((custom_add   , 'org.opencv.core.math.add'),
+                         (custom_mean  , 'org.opencv.core.math.mean'),
+                         (custom_split3, 'org.opencv.core.transform.split3'))
+
+        actual = comp.apply(cv.gin(in_mat1, in_mat2), args=cv.compile_args(pkg))
+
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_op_add(self):
+        sz = (3, 3)
+        in_mat1 = np.full(sz, 45, dtype=np.uint8)
+        in_mat2 = np.full(sz, 50, dtype=np.uint8)
+
+        # OpenCV
+        expected = cv.add(in_mat1, in_mat2)
+
+        # G-API
+        g_in1  = cv.GMat()
+        g_in2  = cv.GMat()
+        g_out = add(g_in1, g_in2, cv.CV_8UC1)
+
+        comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
+
+        pkg = cv.gapi.wip.kernels((custom_add, 'custom.add'))
+        actual = comp.apply(cv.gin(in_mat1, in_mat2), args=cv.compile_args(pkg))
+
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_op_split3(self):
+        sz = (4, 4)
+        in_ch1 = np.full(sz, 1, dtype=np.uint8)
+        in_ch2 = np.full(sz, 2, dtype=np.uint8)
+        in_ch3 = np.full(sz, 3, dtype=np.uint8)
+        # H x W x C
+        in_mat = np.stack((in_ch1, in_ch2, in_ch3), axis=2)
+
+        # G-API
+        g_in  = cv.GMat()
+        g_ch1, g_ch2, g_ch3 = split3(g_in)
+
+        comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_ch1, g_ch2, g_ch3))
+
+        pkg = cv.gapi.wip.kernels((custom_split3, 'custom.split3'))
+        ch1, ch2, ch3 = comp.apply(cv.gin(in_mat), args=cv.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))
+        self.assertEqual(0.0, cv.norm(in_ch3, ch3, cv.NORM_INF))
+
+
+    def test_custom_op_mean(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)
+
+        # G-API
+        g_in  = cv.GMat()
+        g_out = mean(g_in)
+
+        comp = cv.GComputation(g_in, g_out)
+
+        pkg    = cv.gapi.wip.kernels((custom_mean, 'custom.mean'))
+        actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
+
+        # Comparison
+        self.assertEqual(expected, actual)
+
+
+    def test_custom_op_addC(self):
+        sz = (3, 3, 3)
+        in_mat = np.full(sz, 45, dtype=np.uint8)
+        sc = (50, 10, 20)
+
+        # Numpy reference, make array from sc to keep uint8 dtype.
+        expected = in_mat + np.array(sc, dtype=np.uint8)
+
+        # G-API
+        g_in  = cv.GMat()
+        g_sc  = cv.GScalar()
+        g_out = addC(g_in, g_sc, cv.CV_8UC1)
+        comp  = cv.GComputation(cv.GIn(g_in, g_sc), cv.GOut(g_out))
+
+        pkg = cv.gapi.wip.kernels((custom_addC, 'custom.addC'))
+        actual = comp.apply(cv.gin(in_mat, sc), args=cv.compile_args(pkg))
+
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_op_size(self):
+        sz = (100, 150, 3)
+        in_mat = np.full(sz, 45, dtype=np.uint8)
+
+        # Open_cV
+        expected = (100, 150)
+
+        # G-API
+        g_in = cv.GMat()
+        g_sz = size(g_in)
+        comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_sz))
+
+        pkg = cv.gapi.wip.kernels((custom_size, 'custom.size'))
+        actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
+
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_op_sizeR(self):
+        # x, y, h, w
+        roi = (10, 15, 100, 150)
+
+        expected = (100, 150)
+
+        # G-API
+        g_r  = cv.GOpaqueT(cv.gapi.CV_RECT)
+        g_sz = sizeR(g_r)
+        comp = cv.GComputation(cv.GIn(g_r), cv.GOut(g_sz))
+
+        pkg = cv.gapi.wip.kernels((custom_sizeR, 'custom.sizeR'))
+        actual = comp.apply(cv.gin(roi), args=cv.compile_args(pkg))
+
+        # cv.norm works with tuples ?
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_op_boundingRect(self):
+        points = [(0,0), (0,1), (1,0), (1,1)]
+
+        # OpenCV
+        expected = cv.boundingRect(np.array(points))
+
+        # G-API
+        g_pts = cv.GArrayT(cv.gapi.CV_POINT)
+        g_br  = boundingRect(g_pts)
+        comp = cv.GComputation(cv.GIn(g_pts), cv.GOut(g_br))
+
+        pkg = cv.gapi.wip.kernels((custom_boundingRect, 'custom.boundingRect'))
+        actual = comp.apply(cv.gin(points), args=cv.compile_args(pkg))
+
+        # cv.norm works with tuples ?
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    def test_custom_op_goodFeaturesToTrack(self):
+        # G-API
+        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)
+
+        # 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
+        expected = cv.goodFeaturesToTrack(in_mat, max_corners, quality_lvl,
+                                          min_distance, mask=mask,
+                                          blockSize=block_sz, useHarrisDetector=use_harris_detector, k=k)
+
+        # G-API
+        g_in = cv.GMat()
+        g_out = 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))
+        pkg = cv.gapi.wip.kernels((custom_goodFeaturesToTrack, 'custom.goodFeaturesToTrack'))
+        actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
+
+        # NB: OpenCV & G-API have different output types.
+        # OpenCV - numpy array with shape (num_points, 1, 2)
+        # G-API  - list of tuples with size - num_points
+        # Comparison
+        self.assertEqual(0.0, cv.norm(expected.flatten(),
+                                      np.array(actual, dtype=np.float32).flatten(), cv.NORM_INF))
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()

modules/gapi/misc/python/test/test_gapi_streaming.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python
+
+import numpy as np
+import cv2 as cv
+import os
+
+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)
+
+        # 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()
+
+        _, actual = ccomp.pull()
+
+        # Assert
+        self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+
+    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)
+
+        # 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()
+
+        # Assert
+        max_num_frames  = 10
+        proc_num_frames = 0
+        while cap.isOpened():
+            has_expected, expected = cap.read()
+            has_actual,   actual   = ccomp.pull()
+
+            self.assertEqual(has_expected, has_actual)
+
+            if not has_actual:
+                break
+
+            self.assertEqual(0.0, cv.norm(cv.medianBlur(expected, ksize), actual, cv.NORM_INF))
+
+            proc_num_frames += 1
+            if proc_num_frames == max_num_frames:
+                break;
+
+
+    def test_video_split3(self):
+        path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
+
+        # 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))
+
+        ccomp = c.compileStreaming()
+        source = cv.gapi.wip.make_capture_src(path)
+        ccomp.setSource(source)
+        ccomp.start()
+
+        # 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
+
+            expected = cv.split(frame)
+            for e, a in zip(expected, actual):
+                self.assertEqual(0.0, cv.norm(e, a, cv.NORM_INF))
+
+            proc_num_frames += 1
+            if proc_num_frames == max_num_frames:
+                break;
+
+
+    def test_video_add(self):
+        sz = (576, 768, 3)
+        in_mat = np.random.randint(0, 100, sz).astype(np.uint8)
+
+        path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
+
+        # OpenCV
+        cap = cv.VideoCapture(path)
+
+        # 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))
+
+        ccomp = c.compileStreaming()
+        source = cv.gapi.wip.make_capture_src(path)
+        ccomp.setSource(cv.gin(source, in_mat))
+        ccomp.start()
+
+        # 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
+
+            expected = cv.add(frame, in_mat)
+            self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
+
+            proc_num_frames += 1
+            if proc_num_frames == max_num_frames:
+                break;
+
+
+    def test_video_good_features_to_track(self):
+        path = self.find_file('cv/video/768x576.avi', [os.environ['OPENCV_TEST_DATA_PATH']])
+
+        # 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)
+
+        # 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)
+
+        c = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
+
+        ccomp = c.compileStreaming()
+        source = cv.gapi.wip.make_capture_src(path)
+        ccomp.setSource(source)
+        ccomp.start()
+
+        # 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;
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()

modules/gapi/misc/python/test/test_gapi_types.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+import numpy as np
+import cv2 as cv
+import os
+
+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]
+
+        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())
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()