[Ai-1477]-darwin-v2-export-fix

darwin/dataset/remote_dataset.py

@@ -161,7 +161,7 @@ def split_video_annotations(self, release_name: str = "latest") -> None:
 
             frame_annotations = split_video_annotation(darwin_annotation)
             for frame_annotation in frame_annotations:
-                annotation = build_image_annotation(frame_annotation)
+                annotation = self._build_image_annotation(frame_annotation)
 
                 video_frame_annotations_path = annotations_path / annotation_file.stem
                 video_frame_annotations_path.mkdir(exist_ok=True, parents=True)
@@ -947,3 +947,8 @@ def local_images_path(self) -> Path:
     def identifier(self) -> DatasetIdentifier:
         """The ``DatasetIdentifier`` of this ``RemoteDataset``."""
         return DatasetIdentifier(team_slug=self.team, dataset_slug=self.slug)
+
+    def _build_image_annotation(
+        self, annotation_file: AnnotationFile
+    ) -> Dict[str, Any]:
+        return build_image_annotation(annotation_file)

darwin/dataset/remote_dataset_v1.py

@@ -13,8 +13,9 @@
     UploadHandlerV1,
 )
 from darwin.dataset.utils import is_relative_to
-from darwin.datatypes import ItemId, PathLike
+from darwin.datatypes import AnnotationFile, ItemId, PathLike
 from darwin.exceptions import NotFound, ValidationError
+from darwin.exporter.formats.darwin_1_0 import build_image_annotation
 from darwin.item import DatasetItem
 from darwin.item_sorter import ItemSorter
 from darwin.utils import find_files, urljoin
@@ -512,3 +513,8 @@ def import_annotation(self, item_id: ItemId, payload: Dict[str, Any]) -> None:
         """
 
         self.client.import_annotation(item_id, payload=payload)
+
+    def _build_image_annotation(
+        self, annotation_file: AnnotationFile
+    ) -> Dict[str, Any]:
+        return build_image_annotation(annotation_file)

darwin/dataset/remote_dataset_v2.py

@@ -22,8 +22,9 @@
     UploadHandlerV2,
 )
 from darwin.dataset.utils import is_relative_to
-from darwin.datatypes import ItemId, PathLike
+from darwin.datatypes import AnnotationFile, ItemId, PathLike
 from darwin.exceptions import NotFound, UnknownExportVersion
+from darwin.exporter.formats.darwin import build_image_annotation
 from darwin.item import DatasetItem
 from darwin.item_sorter import ItemSorter
 from darwin.utils import find_files, urljoin
@@ -543,3 +544,8 @@ def _fetch_stages(self, stage_type):
             workflow_id,
             [stage for stage in workflow["stages"] if stage["type"] == stage_type],
         )
+
+    def _build_image_annotation(
+        self, annotation_file: AnnotationFile
+    ) -> Dict[str, Any]:
+        return build_image_annotation(annotation_file)

darwin/exporter/formats/darwin.py

@@ -16,65 +16,153 @@
 
 def build_image_annotation(annotation_file: dt.AnnotationFile) -> Dict[str, Any]:
     """
-    Builds and returns a dictionary with the annotations present in the given file.
+    Builds and returns a dictionary with the annotations present in the given file in Darwin v2 format.
 
     Parameters
     ----------
-    annotation_file: dt.AnnotationFile
+    annotation_file: AnnotationFile
         File with the image annotations to extract.
+        For schema, see: https://darwin-public.s3.eu-west-1.amazonaws.com/darwin_json/2.0/schema.json
 
     Returns
     -------
     Dict[str, Any]
-        A dictionary with the annotation from the given file. Has the following structure:
-
-        .. code-block:: python
-
-            {
-                "annotations": [
-                    {
-                        "annotation_type": { ... }, # annotation_data
-                        "name": "annotation class name",
-                        "bounding_box": { ... } # Optional parameter, only present if the file has a bounding box as well
-                    }
-                ],
-                "image": {
-                    "filename": "a_file_name.json",
-                    "height": 1000,
-                    "width": 2000,
-                    "url": "https://www.darwin.v7labs.com/..."
-                }
-            }
+        A dictionary with the annotations in Darwin v2 format.
     """
-    annotations: List[Dict[str, Any]] = []
-    print(annotations)
+    annotations_list: List[Dict[str, Any]] = []
+
     for annotation in annotation_file.annotations:
-        payload = {
-            annotation.annotation_class.annotation_type: _build_annotation_data(
-                annotation
-            ),
-            "name": annotation.annotation_class.name,
-        }
+        annotation_data = _build_v2_annotation_data(annotation)
+        annotations_list.append(annotation_data)
+
+    slots_data = _build_slots_data(annotation_file.slots)
+    item = _build_item_data(annotation_file)
+    item["slots"] = slots_data
+
+    return {
+        "version": "2.0",
+        "schema_ref": "https://darwin-public.s3.eu-west-1.amazonaws.com/darwin_json/2.0/schema.json",
+        "item": item,
+        "annotations": annotations_list,
+    }
+
+
+def _build_v2_annotation_data(annotation: dt.Annotation) -> Dict[str, Any]:
+    annotation_data = {"id": annotation.id, "name": annotation.annotation_class.name}
+
+    if annotation.annotation_class.annotation_type == "bounding_box":
+        annotation_data["bounding_box"] = _build_bounding_box_data(annotation.data)
+    elif annotation.annotation_class.annotation_type == "tag":
+        annotation_data["tag"] = {}
+    elif annotation.annotation_class.annotation_type == "polygon":
+        annotation_data["polygon"] = _build_polygon_data(annotation.data)
+
+    return annotation_data
+
+
+def _build_bounding_box_data(data: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "h": data.get("h"),
+        "w": data.get("w"),
+        "x": data.get("x"),
+        "y": data.get("y"),
+    }
+
+
+def _build_polygon_data(
+    data: Dict[str, Any]
+) -> Dict[str, List[List[Dict[str, float]]]]:
+    """
+    Builds the polygon data for Darwin v2 format.
+
+    Parameters
+    ----------
+    data : Dict[str, Any]
+        The original data for the polygon annotation.
+
+    Returns
+    -------
+    Dict[str, List[List[Dict[str, float]]]]
+        The polygon data in the format required for Darwin v2 annotations.
+    """
+    # Assuming the data contains a 'paths' key that is a list of lists of points,
+    # where each point is a dictionary with 'x' and 'y' keys.
+    paths = data.get("paths", [])
+    v2_paths = []
+
+    for path in paths:
+        v2_path = []
+        for point in path:
+            v2_point = {"x": point.get("x"), "y": point.get("y")}
+            v2_path.append(v2_point)
+        v2_paths.append(v2_path)
+
+    return {"paths": v2_paths}
 
-        if (
-            annotation.annotation_class.annotation_type == "complex_polygon"
-            or annotation.annotation_class.annotation_type == "polygon"
-        ) and "bounding_box" in annotation.data:
-            payload["bounding_box"] = annotation.data["bounding_box"]
 
-        annotations.append(payload)
+def _build_item_data(annotation_file: dt.AnnotationFile) -> Dict[str, Any]:
+    """
+    Constructs the 'item' section of the Darwin v2 format annotation.
+
+    Parameters
+    ----------
+    annotation_file: dt.AnnotationFile
+        The AnnotationFile object containing annotation data.
 
+    Returns
+    -------
+    Dict[str, Any]
+        The 'item' section of the Darwin v2 format annotation.
+    """
     return {
-        "annotations": annotations,
-        "image": {
-            "filename": annotation_file.filename,
-            "height": annotation_file.image_height,
-            "width": annotation_file.image_width,
-            "url": annotation_file.image_url,
+        "name": annotation_file.filename,
+        "path": annotation_file.remote_path or "/",
+        "source_info": {
+            "dataset": {
+                "name": annotation_file.dataset_name,
+                "slug": annotation_file.dataset_name.lower().replace(" ", "-")
+                if annotation_file.dataset_name
+                else None,
+            },
+            "item_id": annotation_file.item_id or "unknown-item-id",
+            "team": {
+                "name": None,  # TODO Replace with actual team name
+                "slug": None,  # TODO Replace with actual team slug
+            },
+            "workview_url": annotation_file.workview_url,
         },
     }
 
 
+def _build_slots_data(slots: List[dt.Slot]) -> List[Dict[str, Any]]:
+    """
+    Constructs the 'slots' data for the Darwin v2 format annotation.
+
+    Parameters
+    ----------
+    slots: List[Slot]
+        A list of Slot objects from the AnnotationFile.
+
+    Returns
+    -------
+    List[Dict[str, Any]]
+        The 'slots' data for the Darwin v2 format annotation.
+    """
+    slots_data = []
+    for slot in slots:
+        slot_data = {
+            "type": slot.type,
+            "slot_name": slot.name,
+            "width": slot.width,
+            "height": slot.height,
+            "thumbnail_url": slot.thumbnail_url,
+            "source_files": slot.source_files,
+        }
+        slots_data.append(slot_data)
+
+    return slots_data
+
+
 @deprecation.deprecated(
     deprecated_in="0.7.8",
     removed_in="0.8.0",

darwin/exporter/formats/darwin_1_0.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Iterable, List, Union
+from typing import Any, Dict, Iterable, List, Union
 
 import orjson as json
 
@@ -213,3 +213,75 @@ def _build_metadata(annotation_file: AnnotationFile) -> DictFreeForm:
         return {"metadata": annotation_file.slots[0].metadata}
     else:
         return {}
+
+
+def build_image_annotation(annotation_file: AnnotationFile) -> Dict[str, Any]:
+    """
+    Builds and returns a dictionary with the annotations present in the given file.
+
+    Parameters
+    ----------
+    annotation_file: dt.AnnotationFile
+        File with the image annotations to extract.
+
+    Returns
+    -------
+    Dict[str, Any]
+        A dictionary with the annotation from the given file. Has the following structure:
+
+        .. code-block:: python
+
+            {
+                "annotations": [
+                    {
+                        "annotation_type": { ... }, # annotation_data
+                        "name": "annotation class name",
+                        "bounding_box": { ... } # Optional parameter, only present if the file has a bounding box as well
+                    }
+                ],
+                "image": {
+                    "filename": "a_file_name.json",
+                    "height": 1000,
+                    "width": 2000,
+                    "url": "https://www.darwin.v7labs.com/..."
+                }
+            }
+    """
+    annotations: List[Dict[str, Any]] = []
+    for annotation in annotation_file.annotations:
+        payload = {
+            annotation.annotation_class.annotation_type: _build_annotation_data(
+                annotation
+            ),
+            "name": annotation.annotation_class.name,
+        }
+
+        if (
+            annotation.annotation_class.annotation_type == "complex_polygon"
+            or annotation.annotation_class.annotation_type == "polygon"
+        ) and "bounding_box" in annotation.data:
+            payload["bounding_box"] = annotation.data["bounding_box"]
+
+        annotations.append(payload)
+
+    return {
+        "annotations": annotations,
+        "image": {
+            "filename": annotation_file.filename,
+            "height": annotation_file.image_height,
+            "width": annotation_file.image_width,
+            "url": annotation_file.image_url,
+        },
+    }
+
+
+def _build_annotation_data(annotation: Annotation) -> Dict[str, Any]:
+    if annotation.annotation_class.annotation_type == "complex_polygon":
+        return {"path": annotation.data["paths"]}
+
+    if annotation.annotation_class.annotation_type == "polygon":
+        return dict(
+            filter(lambda item: item[0] != "bounding_box", annotation.data.items())
+        )
+
+    return dict(annotation.data)

darwin/utils/utils.py

@@ -1005,6 +1005,10 @@ def split_video_annotation(annotation: dt.AnnotationFile) -> List[dt.AnnotationF
             for a in annotation.annotations
             if isinstance(a, dt.VideoAnnotation) and i in a.frames
         ]
+
+        if len(annotations) < 1:
+            continue
+
         annotation_classes: Set[dt.AnnotationClass] = set(
             [annotation.annotation_class for annotation in annotations]
         )

tests/darwin/dataset/remote_dataset_test.py

@@ -391,8 +391,10 @@ def test_works_on_videos(
         )
         assert video_path.exists()
 
+        print(list(video_path.iterdir()))
+
         assert (video_path / "0000000.json").exists()
-        assert (video_path / "0000001.json").exists()
+        assert not (video_path / "0000001.json").exists()
         assert (video_path / "0000002.json").exists()
         assert not (video_path / "0000003.json").exists()
 
@@ -418,17 +420,6 @@ def test_works_on_videos(
                 },
             }
 
-        with (video_path / "0000001.json").open() as f:
-            assert json.loads(f.read()) == {
-                "annotations": [],
-                "image": {
-                    "filename": "test_video/0000001.png",
-                    "height": 1080,
-                    "url": "frame_2.jpg",
-                    "width": 1920,
-                },
-            }
-
         with (video_path / "0000002.json").open() as f:
             assert json.loads(f.read()) == {
                 "annotations": [