feat: add load script

dogs-video-object-tracking-dataset.py

@@ -0,0 +1,169 @@
+import os
+from xml.etree import ElementTree as ET
+
+import datasets
+
+_CITATION = """\
+@InProceedings{huggingface:dataset,
+title = {dogs-video-object-tracking-dataset},
+author = {TrainingDataPro},
+year = {2023}
+}
+"""
+
+_DESCRIPTION = """\
+The dataset contains frames extracted from videos with dogs on the streets.
+Each frame is accompanied by **bounding box** that specifically **tracks the dog**
+in the image.
+The dataset provides a valuable resource for advancing computer vision tasks,
+enabling the development of more accurate and effective solutions for monitoring and
+understanding dog behavior in urban settings.
+"""
+_NAME = "dogs-video-object-tracking-dataset"
+
+_HOMEPAGE = f"https://huggingface.co/datasets/TrainingDataPro/{_NAME}"
+
+_LICENSE = ""
+
+_DATA = f"https://huggingface.co/datasets/TrainingDataPro/{_NAME}/resolve/main/data/"
+
+_LABELS = ["dog"]
+
+
+class DogsVideoObjectTrackingDataset(datasets.GeneratorBasedBuilder):
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="video_01", data_dir=f"{_DATA}video_01.zip"),
+        datasets.BuilderConfig(name="video_02", data_dir=f"{_DATA}video_02.zip"),
+        datasets.BuilderConfig(name="video_03", data_dir=f"{_DATA}video_03.zip"),
+    ]
+
+    DEFAULT_CONFIG_NAME = "video_01"
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "id": datasets.Value("int32"),
+                    "name": datasets.Value("string"),
+                    "image": datasets.Image(),
+                    "mask": datasets.Image(),
+                    "shapes": datasets.Sequence(
+                        {
+                            "track_id": datasets.Value("uint32"),
+                            "label": datasets.ClassLabel(
+                                num_classes=len(_LABELS),
+                                names=_LABELS,
+                            ),
+                            "type": datasets.Value("string"),
+                            "points": datasets.Sequence(
+                                datasets.Sequence(
+                                    datasets.Value("float"),
+                                ),
+                            ),
+                            "rotation": datasets.Value("float"),
+                            "occluded": datasets.Value("uint8"),
+                            "attributes": datasets.Sequence(
+                                {
+                                    "name": datasets.Value("string"),
+                                    "text": datasets.Value("string"),
+                                }
+                            ),
+                        }
+                    ),
+                }
+            ),
+            supervised_keys=None,
+            homepage=_HOMEPAGE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        data = dl_manager.download_and_extract(self.config.data_dir)
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "data": data,
+                },
+            ),
+        ]
+
+    @staticmethod
+    def extract_shapes_from_tracks(
+        root: ET.Element, file: str, index: int
+    ) -> ET.Element:
+        img = ET.Element("image")
+        img.set("name", file)
+        img.set("id", str(index))
+        for track in root.iter("track"):
+            shape = track.find(f".//*[@frame='{index}']")
+            if shape:
+                shape.set("label", track.get("label"))
+                shape.set("track_id", track.get("id"))
+                img.append(shape)
+
+        return img
+
+    @staticmethod
+    def parse_shape(shape: ET.Element) -> dict:
+        label = shape.get("label")
+        track_id = shape.get("track_id")
+        shape_type = shape.tag
+        rotation = shape.get("rotation", 0.0)
+        occluded = shape.get("occluded", 0)
+
+        points = None
+
+        if shape_type == "points":
+            points = tuple(map(float, shape.get("points").split(",")))
+
+        elif shape_type == "box":
+            points = [
+                (float(shape.get("xtl")), float(shape.get("ytl"))),
+                (float(shape.get("xbr")), float(shape.get("ybr"))),
+            ]
+
+        elif shape_type == "polygon":
+            points = [
+                tuple(map(float, point.split(",")))
+                for point in shape.get("points").split(";")
+            ]
+
+        attributes = []
+
+        for attr in shape:
+            attr_name = attr.get("name")
+            attr_text = attr.text
+            attributes.append({"name": attr_name, "text": attr_text})
+
+        shape_data = {
+            "label": label,
+            "track_id": track_id,
+            "type": shape_type,
+            "points": points,
+            "rotation": rotation,
+            "occluded": occluded,
+            "attributes": attributes,
+        }
+
+        return shape_data
+
+    def _generate_examples(self, data):
+        tree = ET.parse(f"{data}/annotations.xml")
+        root = tree.getroot()
+
+        for idx, file in enumerate(sorted(os.listdir(f"{data}/images"))):
+            img = self.extract_shapes_from_tracks(root, file, idx)
+
+            image_id = img.get("id")
+            name = img.get("name")
+            shapes = [self.parse_shape(shape) for shape in img]
+
+            yield idx, {
+                "id": image_id,
+                "name": name,
+                "image": f"{data}/images/{file}",
+                "mask": f"{data}/boxes/{file}",
+                "shapes": shapes,
+            }