Merge pull request #19804 from TolyaTalamanov:at/python-custom-op

[G-API] Introduce custom python operator API

* Introduce custom python operator API

* Add wip namespace

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

@@ -68,6 +68,85 @@ def custom_boundingRect(array):
     #     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):
 
@@ -270,5 +349,178 @@ class gapi_sample_pipelines(NewOpenCVTests):
         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()