fixed voc convertor

Author: VaghinakDev

requirements_dev.txt

@@ -1,2 +1,2 @@
-superannotate_schemas>=v1.0.43dev1
+superannotate_schemas>=v1.0.43dev3
 

src/superannotate/lib/app/input_converters/converters/voc_converters/voc_helper.py

@@ -47,3 +47,14 @@ def _get_image_shape_from_xml(file_path):
     height = int(size.find("height").text)
 
     return height, width
+
+
+def _get_image_metadata(file_path):
+    with open(os.path.splitext(file_path)[0] + ".xml") as f:
+        tree = ET.parse(f)
+
+    size = tree.find("size")
+    width = int(size.find("width").text)
+    height = int(size.find("height").text)
+
+    return tree.find("filename").text, height, width

src/superannotate/lib/app/input_converters/converters/voc_converters/voc_to_sa_vector.py

@@ -11,7 +11,7 @@
 from ....common import write_to_json
 from ..sa_json_helper import _create_sa_json
 from ..sa_json_helper import _create_vector_instance
-from .voc_helper import _get_image_shape_from_xml
+from .voc_helper import _get_image_metadata
 from .voc_helper import _get_voc_instances_from_xml
 from .voc_helper import _iou
 
@@ -118,11 +118,11 @@ def voc_instance_segmentation_to_sa_vector(voc_root, output_dir):
             sa_instances.append(sa_obj)
 
         images_converted.append(filename)
-        file_name = "%s.jpg___objects.json" % filename.stem
-        height, width = _get_image_shape_from_xml(annotation_dir / filename.name)
-        sa_metadata = {"name": filename.stem, "height": height, "width": width}
+        file_name, height, width = _get_image_metadata(annotation_dir / filename.name)
+        file_path = f"{file_name}___objects.json"
+        sa_metadata = {"name": str(filename), "height": height, "width": width}
         sa_json = _create_sa_json(sa_instances, sa_metadata)
-        write_to_json(output_dir / file_name, sa_json)
+        write_to_json(output_dir / file_path, sa_json)
 
     finish_event.set()
     tqdm_thread.join()
@@ -161,11 +161,11 @@ def voc_object_detection_to_sa_vector(voc_root, output_dir):
             sa_instances.append(sa_obj)
 
         images_converted.append(filename)
-        file_name = "%s.jpg___objects.json" % filename.stem
-        height, width = _get_image_shape_from_xml(annotation_dir / filename.name)
-        sa_metadata = {"name": filename.stem, "height": height, "width": width}
+        file_name, height, width = _get_image_metadata(annotation_dir / filename.name)
+        file_path = f"{file_name}___objects.json"
+        sa_metadata = {"name": str(filename), "height": height, "width": width}
         sa_json = _create_sa_json(sa_instances, sa_metadata)
-        write_to_json(output_dir / file_name, sa_json)
+        write_to_json(output_dir / file_path, sa_json)
 
     finish_event.set()
     tqdm_thread.join()

src/superannotate/lib/core/video_convertor.py

@@ -6,13 +6,17 @@
 from typing import List
 from typing import Optional
 
+from lib.core.enums import AnnotationTypes
+from lib.core.exceptions import AppException
 from pydantic import BaseModel
 
 
 class Annotation(BaseModel):
     instanceId: int
     type: str
-    className: str
+    className: Optional[str]
+    x: Optional[Any]
+    y: Optional[Any]
     points: Optional[Dict]
     attributes: Optional[List[Any]] = []
     keyframe: bool = False
@@ -25,6 +29,7 @@ class FrameAnnotation(BaseModel):
 
 class VideoFrameGenerator:
     def __init__(self, annotation_data: dict, fps: int):
+        self.validate_annotations(annotation_data)
         self.id_generator = iter(itertools.count(0))
         self._annotation_data = annotation_data
         self.duration = annotation_data["metadata"]["duration"] / (1000 * 1000)
@@ -36,40 +41,54 @@ def __init__(self, annotation_data: dict, fps: int):
         self._mapping = {}
         self._process()
 
+    @staticmethod
+    def validate_annotations(annotation_data: dict):
+        try:
+            annotation_data["metadata"]["duration"]
+        except KeyError:
+            raise AppException("Video not annotated yet")
+
     def get_frame(self, frame_no: int):
         try:
             return self.annotations[frame_no]
         except KeyError:
             self.annotations[frame_no] = FrameAnnotation(frame=frame_no)
             return self.annotations[frame_no]
 
-    def interpolate_annotations(
-        self,
-        class_name: str,
-        from_frame: int,
-        to_frame: int,
-        data: dict,
-        instance_id: int,
-        steps: dict = None,
-        annotation_type: str = "bbox",
+    def _interpolate(
+            self,
+            class_name: str,
+            from_frame: int,
+            to_frame: int,
+            data: dict,
+            instance_id: int,
+            steps: dict = None,
+            annotation_type: str = "bbox",
     ) -> dict:
         annotations = {}
         for idx, frame_idx in enumerate(range(from_frame + 1, to_frame), 1):
-            points = None
-            if annotation_type == "bbox" and data.get("points") and steps:
-                points = {
+            tmp_data = {}
+            if annotation_type == AnnotationTypes.BBOX and data.get("points") and steps:
+                tmp_data["points"] = {
                     "x1": round(data["points"]["x1"] + steps["x1"] * idx, 2),
                     "y1": round(data["points"]["y1"] + steps["y1"] * idx, 2),
                     "x2": round(data["points"]["x2"] + steps["x2"] * idx, 2),
                     "y2": round(data["points"]["y2"] + steps["y2"] * idx, 2),
                 }
+            elif annotation_type == AnnotationTypes.POINT:
+                tmp_data = {
+                    "x": round(data["x"] + steps["x"] * idx, 2),
+                    "y": round(data["y"] + steps["y"] * idx, 2)
+                }
+            elif annotation_type in (AnnotationTypes.POLYGON, AnnotationTypes.POLYLINE):
+                tmp_data["points"] = [point + steps[idx] * 2 for idx, point in enumerate(data["points"])]
             annotations[frame_idx] = Annotation(
                 instanceId=instance_id,
                 type=annotation_type,
                 className=class_name,
-                points=points,
                 attributes=data["attributes"],
                 keyframe=False,
+                **tmp_data
             )
         return annotations
 
@@ -98,6 +117,9 @@ def get_median(self, annotations: List[dict]) -> dict:
                 median_annotation = annotation
         return median_annotation
 
+    def calculate_sped(self, from_frame, to_frame):
+        pass
+
     @staticmethod
     def merge_first_frame(frames_mapping):
         try:
@@ -108,11 +130,37 @@ def merge_first_frame(frames_mapping):
         finally:
             return frames_mapping
 
+    def _interpolate_frames(
+            self, from_frame, from_frame_no, to_frame, to_frame_no, annotation_type, class_name, instance_id
+    ):
+        steps = None
+        frames_diff = to_frame_no - from_frame_no
+        if annotation_type == AnnotationTypes.BBOX and from_frame.get("points") and to_frame.get("points"):
+            steps = {}
+            for point in "x1", "x2", "y1", "y2":
+                steps[point] = round(
+                    (to_frame["points"][point] - from_frame["points"][point]) / frames_diff, 2
+                )
+        elif annotation_type == AnnotationTypes.POINT:
+            steps = {
+                "x": (to_frame["x"] - from_frame["x"]) / frames_diff,
+                "y": (to_frame["y"] - from_frame["y"]) / frames_diff
+            }
+        elif annotation_type in (AnnotationTypes.POLYGON, AnnotationTypes.POLYLINE):
+            steps = [
+                (to_point - from_point) / frames_diff
+                for from_point, to_point in zip(from_frame["points"], to_frame["points"])
+            ]
+        return self._interpolate(
+            class_name=class_name, from_frame=from_frame_no, to_frame=to_frame_no, data=from_frame,
+            instance_id=instance_id, steps=steps, annotation_type=annotation_type
+        )
+
     def _process(self):
         for instance in self._annotation_data["instances"]:
             instance_id = next(self.id_generator)
             annotation_type = instance["meta"]["type"]
-            class_name = instance["meta"]["className"]
+            class_name = instance["meta"].get("className")
             for parameter in instance["parameters"]:
                 frames_mapping = defaultdict(list)
                 last_frame_no = None
@@ -131,55 +179,15 @@ def _process(self):
                     )
                     frames_diff = to_frame_no - from_frame_no
                     if frames_diff > 1:
-                        steps = None
-                        if (
-                            annotation_type == "bbox"
-                            and from_frame.get("points")
-                            and to_frame.get("points")
-                        ):
-                            steps = {
-                                "y1": round(
-                                    (
-                                        to_frame["points"]["y1"]
-                                        - from_frame["points"]["y1"]
-                                    )
-                                    / frames_diff,
-                                    2,
-                                ),
-                                "x2": round(
-                                    (
-                                        to_frame["points"]["x2"]
-                                        - from_frame["points"]["x2"]
-                                    )
-                                    / frames_diff,
-                                    2,
-                                ),
-                                "x1": round(
-                                    (
-                                        to_frame["points"]["x1"]
-                                        - from_frame["points"]["x1"]
-                                    )
-                                    / frames_diff,
-                                    2,
-                                ),
-                                "y2": round(
-                                    (
-                                        to_frame["points"]["y2"]
-                                        - from_frame["points"]["y2"]
-                                    )
-                                    / frames_diff,
-                                    2,
-                                ),
-                            }
                         interpolated_frames.update(
-                            self.interpolate_annotations(
+                            self._interpolate_frames(
+                                from_frame=from_frame,
+                                from_frame_no=from_frame_no,
+                                to_frame=to_frame,
+                                to_frame_no=to_frame_no,
                                 class_name=class_name,
-                                from_frame=from_frame_no,
-                                to_frame=to_frame_no,
-                                data=from_frame,
-                                instance_id=instance_id,
-                                steps=steps,
                                 annotation_type=annotation_type,
+                                instance_id=instance_id
                             )
                         )
                     start_median_frame = self.get_median(frames_mapping[from_frame_no])
@@ -188,6 +196,8 @@ def _process(self):
                         instanceId=instance_id,
                         type=annotation_type,
                         className=class_name,
+                        x=start_median_frame.get("x"),
+                        y=start_median_frame.get("y"),
                         points=start_median_frame.get("points"),
                         attributes=start_median_frame["attributes"],
                         keyframe=True,
@@ -196,6 +206,8 @@ def _process(self):
                         instanceId=instance_id,
                         type=annotation_type,
                         className=class_name,
+                        x=start_median_frame.get("x"),
+                        y=start_median_frame.get("y"),
                         points=end_median_frame.get("points"),
                         attributes=end_median_frame["attributes"],
                         keyframe=True,
@@ -208,4 +220,5 @@ def _process(self):
 
     def __iter__(self):
         for frame_no in range(1, int(self.frames_count) + 1):
-            yield self.get_frame(frame_no).dict()
+            frame = self.get_frame(frame_no)
+            yield {**frame.dict(exclude_unset=True), **frame.dict(exclude_none=True)}

src/superannotate/lib/infrastructure/controller.py

@@ -1174,18 +1174,15 @@ def benchmark(
         if export_response.errors:
             return export_response
 
-        download_use_case = usecases.DownloadExportUseCase(
+        usecases.DownloadExportUseCase(
             service=self._backend_client,
             project=project,
             export_name=export_response.data["name"],
             folder_path=export_root,
             extract_zip_contents=True,
             to_s3_bucket=False,
             reporter=self.default_reporter,
-        )
-        if download_use_case.is_valid():
-            for _ in download_use_case.execute():
-                pass
+        ).execute()
 
         use_case = usecases.BenchmarkUseCase(
             project=project,

src/superannotate/lib/infrastructure/services.py

@@ -1,6 +1,7 @@
 import asyncio
 import datetime
 import json
+import platform
 import time
 from contextlib import contextmanager
 from typing import Callable
@@ -24,6 +25,7 @@
 from lib.infrastructure.helpers import timed_lru_cache
 from lib.infrastructure.stream_data_handler import StreamedAnnotations
 from requests.exceptions import HTTPError
+from superannotate.version import __version__
 
 requests.packages.urllib3.disable_warnings()
 
@@ -83,7 +85,8 @@ def default_headers(self):
             "Authorization": self._auth_token,
             "authtype": self.AUTH_TYPE,
             "Content-Type": "application/json",
-            # "User-Agent": constance.__version__,
+            "User-Agent": f"Python-SDK-Version: {__version__}; Python: {platform.python_version()}; "
+                          f"OS: {platform.system()}; Team: {self.team_id}",
         }
 
     @property

src/superannotate/version.py

@@ -1 +1 @@
-__version__ = "4.3.5dev1"
+__version__ = "4.3.5dev2"

tests/convertors/test_voc.py

@@ -1,7 +1,10 @@
+import os
+from os.path import dirname
 from pathlib import Path
 
 import pytest
 import superannotate as sa
+from tests import DATA_SET_PATH
 
 
 @pytest.mark.skip(reason="Need to adjust")
@@ -10,7 +13,7 @@ def test_voc_vector_instance(tmpdir):
 
     input_dir = (
         Path("tests")
-        / "converter_test"
+        / f"{DATA_SET_PATH}/converter_test"
         / "VOC"
         / "input"
         / "fromPascalVOCToSuperAnnotate"