new converters

Author: agyurjin

superannotate/input_converters/conversion.py

@@ -11,7 +11,8 @@
 from ..exceptions import SABaseException
 
 AVAILABLE_ANNOTATION_FORMATS = [
-    "COCO", "VOC", "LabelBox", "DataLoop", 'Supervisely'
+    "COCO", "VOC", "LabelBox", "DataLoop", 'Supervisely', 'VoTT', 'SageMaker',
+    'VGG', 'GoogleCloud'
 ]
 
 AVAILABLE_PLATFORMS = ["Desktop", "Web"]
@@ -51,6 +52,20 @@
 
 ALLOWED_CONVERSIONS_SUPERVISELY_TO_SA = [('Vector', 'vector_annotation')]
 
+ALLOWED_CONVERSIONS_VOTT_TO_SA = [
+    ('Vector', 'object_detection'), ('Vector', 'instance_segmentation'),
+    ('Vector', 'vector_annotation')
+]
+
+ALLOWED_CONVERSIONS_SAGEMAKER_TO_SA = [('Vector', 'object_detection')]
+
+ALLOWED_CONVERSIONS_VGG_TO_SA = [
+    ('Vector', 'object_detection'), ('Vector', 'instance_segmentation'),
+    ('Vector', 'vector_annotation')
+]
+
+ALLOWED_CONVERSIONS_GOOGLECLOUD_TO_SA = [('Vector', 'object_detection')]
+
 
 def _passes_sanity_checks(args):
     if not isinstance(args.input_dir, (str, Path)):
@@ -110,6 +125,14 @@ def _passes_converter_sanity(args, direction):
             return True
         elif args.dataset_format == "Supervisely" and converter_values in ALLOWED_CONVERSIONS_SUPERVISELY_TO_SA:
             return True
+        elif args.dataset_format == 'VoTT' and converter_values in ALLOWED_CONVERSIONS_VOTT_TO_SA:
+            return True
+        elif args.dataset_format == 'SageMaker' and converter_values in ALLOWED_CONVERSIONS_SAGEMAKER_TO_SA:
+            return True
+        elif args.dataset_format == 'VGG' and converter_values in ALLOWED_CONVERSIONS_VGG_TO_SA:
+            return True
+        elif args.dataset_format == 'GoogleCloud' and converter_values in ALLOWED_CONVERSIONS_GOOGLECLOUD_TO_SA:
+            return True
     else:
         if args.dataset_format == "COCO" and converter_values in ALLOWED_CONVERSIONS_SA_TO_COCO:
             return True
@@ -251,7 +274,7 @@ def import_annotation_format(
     :type input_dir: str
     :param output_dir: Path to the folder, where you want to have converted dataset.
     :type output_dir: str
-    :param dataset_format: Annotation format to convert SuperAnnotate annotation format. Available candidates are: ["COCO", "VOC", "LabelBox"]
+    :param dataset_format: Annotation format to convert SuperAnnotate annotation format. Available candidates are: ["COCO", "VOC", "LabelBox", "DataLoop", "Supervisely"]
     :type dataset_format: str
     :param dataset_name: Name of the json file in the input_dir, which should be converted.
     :type dataset_name: str

superannotate/input_converters/converters/converters.py

@@ -18,6 +18,10 @@
 from .labelbox_converters.labelbox_strategies import LabelBoxObjectDetectionStrategy
 from .dataloop_converters.dataloop_strategies import DataLoopObjectDetectionStrategy
 from .supervisely_converters.supervisely_strategies import SuperviselyObjectDetectionStrategy
+from .vott_converters.vott_strategies import VoTTObjectDetectionStrategy
+from .sagemaker_converters.sagemaker_strategies import SageMakerObjectDetectionStrategy
+from .vgg_converters.vgg_strategies import VGGObjectDetectionStrategy
+from .googlecloud_converters.googlecloud_strategies import GoogleCloudObjectDetectionStrategy
 
 
 class Converter(object):
@@ -56,6 +60,18 @@ def _select_strategy(self, args):
         elif args.dataset_format == "Supervisely":
             if args.task == 'vector_annotation':
                 c_strategy = SuperviselyObjectDetectionStrategy(args)
+        elif args.dataset_format == "VoTT":
+            if args.task == 'object_detection' or args.task == 'instance_segmentation' or args.task == 'vector_annotation':
+                c_strategy = VoTTObjectDetectionStrategy(args)
+        elif args.dataset_format == "SageMaker":
+            if args.task == 'object_detection' or args.task == 'instance_segmentation' or args.task == 'vector_annotation':
+                c_strategy = SageMakerObjectDetectionStrategy(args)
+        elif args.dataset_format == "VGG":
+            if args.task == 'object_detection' or args.task == 'instance_segmentation' or args.task == 'vector_annotation':
+                c_strategy = VGGObjectDetectionStrategy(args)
+        elif args.dataset_format == "GoogleCloud":
+            if args.task == 'object_detection':
+                c_strategy = GoogleCloudObjectDetectionStrategy(args)
         else:
             pass
 

superannotate/input_converters/converters/googlecloud_converters/__init__.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+import json
+
+
+class GoogleCloudConverter(object):
+    def __init__(self, args):
+        self.dataset_name = args.dataset_name
+        self.project_type = args.project_type
+        self.task = args.task
+        self.output_dir = args.output_dir
+        self.export_root = args.export_root
+        self.direction = args.direction
+
+    def set_output_dir(self, output_dir_):
+        self.output_dir = output_dir_
+
+    def set_export_root(self, export_root_):
+        self.export_root = export_root_
+
+    def set_dataset_name(self, dname):
+        self.dataset_name = dname
+
+    def save_objects(self, files_dict):
+        for key, value in files_dict.items():
+            path = Path(self.output_dir)
+            print(path.joinpath(key))
+            with open(path.joinpath(key), 'w') as fw:
+                json.dump(value, fw, indent=2)
+
+    def save_classes(self, classes):
+        path = Path(self.output_dir)
+        with open(path.joinpath('classes', 'classes.json'), 'w') as fw:
+            json.dump(classes, fw)

superannotate/input_converters/converters/googlecloud_converters/googlecloud_converter.py

@@ -0,0 +1,44 @@
+import os
+from pathlib import Path
+
+from .googlecloud_converter import GoogleCloudConverter
+from .googlecloud_to_sa_vector import googlecloud_object_detection_to_sa_vector
+
+
+class GoogleCloudObjectDetectionStrategy(GoogleCloudConverter):
+    name = "ObjectDetection converter"
+
+    def __init__(self, args):
+        super().__init__(args)
+        self.__setup_conversion_algorithm()
+
+    def __setup_conversion_algorithm(self):
+        if self.direction == "to":
+            raise NotImplementedError("Doesn't support yet")
+        else:
+            if self.project_type == "Vector":
+                if self.task == "object_detection":
+                    self.converion_algorithm = googlecloud_object_detection_to_sa_vector
+                else:
+                    raise NotImplementedError("Doesn't support yet")
+            elif self.project_type == "Pixel":
+                raise NotImplementedError("Doesn't support yet")
+
+    def __str__(self):
+        return '{} object'.format(self.name)
+
+    def from_sa_format(self):
+        pass
+
+    def to_sa_format(self):
+        path = Path(self.export_root).joinpath(self.dataset_name + '.csv')
+        id_generator = self._make_id_generator()
+        sa_jsons, sa_classes = self.converion_algorithm(path, id_generator)
+        self.save_objects(sa_jsons)
+        self.save_classes(sa_classes)
+
+    def _make_id_generator(self):
+        cur_id = 0
+        while True:
+            cur_id += 1
+            yield cur_id

superannotate/input_converters/converters/googlecloud_converters/googlecloud_strategies.py

@@ -0,0 +1,63 @@
+import os
+import pandas as pd
+import numpy as np
+import cv2
+
+
+def _create_classes(classes):
+    classes_loader = []
+    for class_, id_ in classes.items():
+        color = np.random.choice(range(256), size=3)
+        hexcolor = "#%02x%02x%02x" % tuple(color)
+        sa_classes = {
+            'id': id_,
+            'name': class_,
+            'color': hexcolor,
+            'attribute_groups': []
+        }
+        classes_loader.append(sa_classes)
+    return classes_loader
+
+
+def googlecloud_object_detection_to_sa_vector(path, id_generator):
+    df = pd.read_csv(path, header=None)
+    dir_name = os.path.dirname(path)
+
+    sa_jsons = {}
+    classes = {}
+    for idx, row in df.iterrows():
+        if row[2] not in classes.keys():
+            classes[row[2]] = next(id_generator)
+
+        file_name = row[1].split('/')[-1]
+        img = cv2.imread(os.path.join(dir_name, file_name))
+        H, W, C = img.shape
+        sa_file_name = os.path.basename(file_name) + '___objects.json'
+        xmin = row[3] * W
+        xmax = row[5] * W
+        ymin = row[4] * H
+        ymax = row[8] * H
+
+        sa_obj = {
+            'type': 'bbox',
+            'points': {
+                'x1': xmin,
+                'y1': ymin,
+                'x2': xmax,
+                'y2': ymax
+            },
+            'className': row[2],
+            'classId': classes[row[2]],
+            'attributes': [],
+            'probability': 100,
+            'locked': False,
+            'visible': True,
+            'groupId': 0
+        }
+
+        if sa_file_name in sa_jsons.keys():
+            sa_jsons[sa_file_name].append(sa_obj)
+        else:
+            sa_jsons[sa_file_name] = [sa_obj]
+
+    return sa_jsons, _create_classes(classes)

superannotate/input_converters/converters/googlecloud_converters/googlecloud_to_sa_vector.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+import json
+
+
+class VGGConverter(object):
+    def __init__(self, args):
+        self.dataset_name = args.dataset_name
+        self.project_type = args.project_type
+        self.task = args.task
+        self.output_dir = args.output_dir
+        self.export_root = args.export_root
+        self.direction = args.direction
+
+    def set_output_dir(self, output_dir_):
+        self.output_dir = output_dir_
+
+    def set_export_root(self, export_root_):
+        self.export_root = export_root_
+
+    def set_dataset_name(self, dname):
+        self.dataset_name = dname
+
+    def get_file_list(self):
+        json_file_list = []
+        path = Path(self.export_root)
+        if self.dataset_name != '':
+            json_file_list.append(path.joinpath(self.dataset_name + '.json'))
+        else:
+            file_generator = path.glob('*.json')
+            for gen in file_generator:
+                json_file_list.append(gen)
+
+        return json_file_list
+
+    def save_objects(self, files_dict):
+        for key, value in files_dict.items():
+            path = Path(self.output_dir)
+            with open(path.joinpath(key), 'w') as fw:
+                json.dump(value, fw, indent=2)
+
+    def save_classes(self, classes):
+        path = Path(self.output_dir)
+        with open(path.joinpath('classes', 'classes.json'), 'w') as fw:
+            json.dump(classes, fw)

superannotate/input_converters/converters/vgg_converters/__init__.py

@@ -0,0 +1,47 @@
+import json
+
+from .vgg_converter import VGGConverter
+from .vgg_to_sa_vector import vgg_object_detection_to_sa_vector, vgg_instance_segmentation_to_sa_vector, vgg_to_sa
+
+
+class VGGObjectDetectionStrategy(VGGConverter):
+    name = "ObjectDetection converter"
+
+    def __init__(self, args):
+        super().__init__(args)
+        self.__setup_conversion_algorithm()
+
+    def __setup_conversion_algorithm(self):
+        if self.direction == "to":
+            raise NotImplementedError("Doesn't support yet")
+        else:
+            if self.project_type == "Vector":
+                if self.task == "object_detection":
+                    self.conversion_algorithm = vgg_object_detection_to_sa_vector
+                elif self.task == 'instance_segmentation':
+                    self.conversion_algorithm = vgg_instance_segmentation_to_sa_vector
+                elif self.task == 'vector_annotation':
+                    self.conversion_algorithm = vgg_to_sa
+            elif self.project_type == "Pixel":
+                raise NotImplementedError("Doesn't support yet")
+
+    def __str__(self):
+        return '{} object'.format(self.name)
+
+    def from_sa_format(self):
+        pass
+
+    def to_sa_format(self):
+        json_data = self.get_file_list()
+        id_generator = self._make_id_generator()
+        sa_jsons, sa_classes = self.conversion_algorithm(
+            json_data, id_generator
+        )
+        self.save_objects(sa_jsons)
+        self.save_classes(sa_classes)
+
+    def _make_id_generator(self):
+        cur_id = 0
+        while True:
+            cur_id += 1
+            yield cur_id