Supervisely coverage increased

Author: agyurjin

superannotate/input_converters/conversion.py

@@ -42,7 +42,13 @@
             ('Vector', 'object_detection'), ('Vector', 'instance_segmentation'),
             ('Vector', 'vector_annotation')
         ],
-    'Supervisely': [('Vector', 'vector_annotation')],
+    'Supervisely':
+        [
+            ('Vector', 'vector_annotation'), ('Vector', 'object_detection'),
+            ('Vector', 'instance_segmentation'),
+            ('Pixel', 'instance_segmentation'),
+            ('Vector', 'keypoint_detection')
+        ],
     'VoTT':
         [
             ('Vector', 'object_detection'), ('Vector', 'instance_segmentation'),

superannotate/input_converters/converters/converters.py

@@ -57,7 +57,7 @@ def _select_strategy(self, args):
             if args.task == 'object_detection' or args.task == 'instance_segmentation' or args.task == 'vector_annotation':
                 c_strategy = DataLoopObjectDetectionStrategy(args)
         elif args.dataset_format == "Supervisely":
-            if args.task == 'vector_annotation':
+            if args.task == 'vector_annotation' or args.task == 'instance_segmentation' or args.task == 'object_detection' or args.task == 'keypoint_detection':
                 c_strategy = SuperviselyObjectDetectionStrategy(args)
         elif args.dataset_format == "VoTT":
             if args.task == 'object_detection' or args.task == 'instance_segmentation' or args.task == 'vector_annotation':

superannotate/input_converters/converters/supervisely_converters/supervisely_strategies.py

@@ -2,7 +2,12 @@
 import json
 
 from .supervisely_converter import SuperviselyConverter
-from .supervisely_to_sa_vector import supervisely_to_sa
+from .supervisely_to_sa_vector import (
+    supervisely_to_sa, supervisely_instance_segmentation_to_sa_vector,
+    supervisely_object_detection_to_sa_vector,
+    supervisely_keypoint_detection_to_sa_vector
+)
+from .supervisely_to_sa_pixel import supervisely_instance_segmentation_to_sa_pixel
 
 
 class SuperviselyObjectDetectionStrategy(SuperviselyConverter):
@@ -18,9 +23,18 @@ def __setup_conversion_algorithm(self):
         else:
             if self.project_type == "Vector":
                 if self.task == 'vector_annotation':
-                    self.converion_algorithm = supervisely_to_sa
+                    self.conversion_algorithm = supervisely_to_sa
+                elif self.task == 'object_detection':
+                    self.conversion_algorithm = supervisely_object_detection_to_sa_vector
+                elif self.task == 'instance_segmentation':
+                    self.conversion_algorithm = supervisely_instance_segmentation_to_sa_vector
+                elif self.task == 'keypoint_detection':
+                    self.conversion_algorithm = supervisely_keypoint_detection_to_sa_vector
             elif self.project_type == "Pixel":
-                raise NotImplementedError("Doesn't support yet")
+                if self.task == 'instance_segmentation':
+                    self.conversion_algorithm = supervisely_instance_segmentation_to_sa_pixel
+                else:
+                    raise NotImplementedError("Doesn't support yet")
 
     def __str__(self):
         return '{} object'.format(self.name)
@@ -46,7 +60,19 @@ def to_sa_format(self):
                 os.path.join(self.export_root, 'ds', 'ann', file)
                 for file in files
             ]
-        sa_jsons = self.converion_algorithm(json_files, classes_id_map)
+        if self.conversion_algorithm.__name__ == 'supervisely_keypoint_detection_to_sa_vector':
+            meta_json = json.load(
+                open(os.path.join(self.export_root, 'meta.json'))
+            )
+            sa_jsons = self.conversion_algorithm(
+                json_files, classes_id_map, meta_json
+            )
+        elif self.conversion_algorithm.__name__ == 'supervisely_instance_segmentation_to_sa_pixel':
+            sa_jsons = self.conversion_algorithm(
+                json_files, classes_id_map, self.output_dir
+            )
+        else:
+            sa_jsons = self.conversion_algorithm(json_files, classes_id_map)
         self.dump_output(sa_classes, sa_jsons)
 
     def _make_id_generator(self):

superannotate/input_converters/converters/supervisely_converters/supervisely_to_sa_pixel.py

@@ -0,0 +1,109 @@
+import numpy as np
+import os
+import json
+import zlib
+import base64
+import cv2
+
+from ....common import hex_to_rgb, blue_color_generator
+
+
+# Converts bitmaps to polygon
+def _base64_to_polygon(bitmap):
+    z = zlib.decompress(base64.b64decode(bitmap))
+    n = np.frombuffer(z, np.uint8)
+    mask = cv2.imdecode(n, cv2.IMREAD_UNCHANGED)[:, :, 3].astype(bool)
+    contours, hierarchy = cv2.findContours(
+        mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )
+    segmentation = []
+
+    for contour in contours:
+        contour = contour.flatten().tolist()
+        if len(contour) > 4:
+            segmentation.append(contour)
+        if len(segmentation) == 0:
+            continue
+    return segmentation
+
+
+def supervisely_instance_segmentation_to_sa_pixel(
+    json_files, class_id_map, output_path
+):
+    sa_jsons = {}
+    for json_file in json_files:
+        file_name = os.path.splitext(os.path.basename(json_file)
+                                    )[0] + '___pixel.json'
+
+        json_data = json.load(open(json_file))
+        sa_loader = []
+
+        H, W = json_data['size']['height'], json_data['size']['width']
+        mask = np.zeros((H, W, 4))
+
+        hex_colors = blue_color_generator(10 * len(json_data['objects']))
+        index = 0
+        for obj in json_data['objects']:
+            if 'classTitle' in obj and obj['classTitle'] in class_id_map.keys():
+                attributes = []
+                if 'tags' in obj.keys():
+                    for tag in obj['tags']:
+                        group_id = class_id_map[obj['classTitle']
+                                               ]['attr_group']['id']
+                        group_name = class_id_map[obj['classTitle']
+                                                 ]['attr_group']['group_name']
+                        attr_id = class_id_map[obj['classTitle']]['attr_group'][
+                            'attributes'][tag['name']]
+                        attr_name = tag['name']
+                        attributes.append(
+                            {
+                                'id': attr_id,
+                                'name': attr_name,
+                                'groupId': group_id,
+                                'groupName': group_name
+                            }
+                        )
+
+                    sa_obj = {
+                        'className': obj['classTitle'],
+                        'classId': class_id_map[obj['classTitle']]['id'],
+                        'attributes': attributes,
+                        'probability': 100,
+                        'locked': False,
+                        'visible': True,
+                        'parts': [],
+                    }
+
+                    if obj['geometryType'] == 'bitmap':
+                        segments = _base64_to_polygon(obj['bitmap']['data'])
+                        for segment in segments:
+                            ppoints = [
+                                x + obj['bitmap']['origin'][0] if i %
+                                2 == 0 else x + obj['bitmap']['origin'][1]
+                                for i, x in enumerate(segment)
+                            ]
+                            bitmask = np.zeros((H, W)).astype(np.uint8)
+                            pts = np.array(
+                                [
+                                    ppoints[2 * i:2 * (i + 1)]
+                                    for i in range(len(ppoints) // 2)
+                                ],
+                                dtype=np.int32
+                            )
+                            cv2.fillPoly(bitmask, [pts], 1)
+                            color = hex_to_rgb(hex_colors[index])
+                            mask[bitmask == 1] = list(color[::-1]) + [255]
+                            sa_obj['parts'].append({'color': hex_colors[index]})
+                            index += 1
+                        cv2.imwrite(
+                            os.path.join(
+                                output_path,
+                                file_name.replace(
+                                    '___pixel.json', '___save.png'
+                                )
+                            ), mask
+                        )
+                        sa_loader.append(sa_obj)
+
+        sa_jsons[file_name] = sa_loader
+    return sa_jsons