updated and improved version of the dataset loader

dataset.py

@@ -1,25 +1,47 @@
 
 import os
+import json
 import datasets
 import rasterio
-import tqdm
-import datetime
+from datetime import datetime
+from tqdm import tqdm
 
 class SSL4EOEUForest(datasets.GeneratorBasedBuilder):
+    """
+    SSL4EO-EU Forest Dataset Loader
+
+    This loader supports both directory-based scanning and prebuilt index streaming via JSONL.
+    It yields one sample at a time, making it compatible with Hugging Face's streaming mode.
+
+    Each sample includes:
+    - A list of image paths (one per timestamp)
+    - A single mask path
+    - Start and end timestamps for each image
+    - Sentinel tile IDs
+    - Bounding box metadata
+
+    Bounding boxes are stored as a dictionary of arrays:
+        {
+            "minx": [...], "maxx": [...], "miny": [...], "maxy": [...]
+        }
+
+    This avoids redundancy and simplifies downstream parsing.
+    """
+
     def _info(self):
         return datasets.DatasetInfo(
-            description="SSL4EO-EU Forest dataset with four-season Sentinel-2 timestamps and bounding box metadata extracted from image folders.",
+            description="SSL4EO-EU Forest dataset with grouped timestamps and bounding box metadata.",
             features=datasets.Features({
                 "image_paths": datasets.Sequence(datasets.Value("string")),
                 "mask_path": datasets.Value("string"),
                 "start_timestamps": datasets.Sequence(datasets.Value("timestamp[ms]")),
                 "end_timestamps": datasets.Sequence(datasets.Value("timestamp[ms]")),
                 "sentinel_tile_ids": datasets.Sequence(datasets.Value("string")),
-                "bboxes": datasets.Sequence({
-                    "minx": datasets.Value("float32"),
-                    "maxx": datasets.Value("float32"),
-                    "miny": datasets.Value("float32"),
-                    "maxy": datasets.Value("float32"),
+                "bboxes": datasets.Features({
+                    "minx": datasets.Sequence(datasets.Value("float32")),
+                    "maxx": datasets.Sequence(datasets.Value("float32")),
+                    "miny": datasets.Sequence(datasets.Value("float32")),
+                    "maxy": datasets.Sequence(datasets.Value("float32")),
                 })
             }),
             citation="""@misc{ssl4eo_eu_forest,
@@ -27,90 +49,128 @@ class SSL4EOEUForest(datasets.GeneratorBasedBuilder):
   title = {SSL4EO-EU Forest Dataset},
   year = {2025},
   howpublished = {https://huggingface.co/datasets/dm4eo/ssl4eo-eu-forest},
-  note = {This work was carried under the EvoLand project, cf. https://www.evo-land.eu . This project has received funding from the European Union's Horizon Europe research and innovation programme under grant agreement No. 101082130.}
+  note = {Funded by the EvoLand project under EU Horizon Europe grant No. 101082130.}
 }""",
             homepage="https://www.evo-land.eu",
             license="CC-BY-4.0",
         )
 
     def _split_generators(self, dl_manager):
+        use_index = os.environ.get("HF_DATASET_USE_INDEX", "false").lower() == "true"
         use_local = os.environ.get("HF_DATASET_LOCAL", "false").lower() == "true"
+        root = os.path.abspath(".") if use_local else dl_manager.download_and_extract(".")
 
-        if use_local:
-            root = os.path.abspath(".")
+        if use_index:
+            index_path = os.path.join(root, "index.jsonl")
+            return [datasets.SplitGenerator(name="all", gen_kwargs={"index_path": index_path})]
         else:
-            root = dl_manager.download_and_extract(".")
-
-        images_dir = os.path.join(root, "images")
-        masks_dir = os.path.join(root, "masks")
-
-        return [
-            datasets.SplitGenerator(name=datasets.Split("all"), gen_kwargs={
+            images_dir = os.path.join(root, "images")
+            masks_dir = os.path.join(root, "masks")
+            return [datasets.SplitGenerator(name="all", gen_kwargs={
                 "images_dir": images_dir,
                 "masks_dir": masks_dir
-            })
-        ]
-
-    def _generate_examples(self, images_dir, masks_dir):
-        sample_id_list = sorted(os.listdir(images_dir))
-        key = 0
-
-        for sample_id in sample_id_list:
-            sample_path = os.path.join(images_dir, sample_id)
-            if not os.path.isdir(sample_path):
+            })]
+
+    def _generate_examples(self, index_path=None, images_dir=None, masks_dir=None):
+        if index_path:
+            with open(index_path, "r") as f:
+                for key, line in enumerate(f):
+                    entry = json.loads(line)
+                    entry["start_timestamps"] = [datetime.fromisoformat(ts) for ts in entry["start_timestamps"]]
+                    entry["end_timestamps"] = [datetime.fromisoformat(ts) for ts in entry["end_timestamps"]]
+                    yield key, entry
+        else:
+            sample_ids = sorted(os.listdir(images_dir))
+            key = 0
+            for sample_id in sample_ids:
+                sample = self._parse_sample(sample_id, images_dir, masks_dir)
+                if sample:
+                    yield key, sample
+                    key += 1
+
+    @staticmethod
+    def _parse_sample(sample_id, images_dir, masks_dir):
+        """
+        Parses a single sample directory and returns a dictionary with all metadata.
+
+        Returns None if the sample is incomplete or malformed.
+        """
+        sample_path = os.path.join(images_dir, sample_id)
+        if not os.path.isdir(sample_path):
+            return None
+
+        mask_path = os.path.join(masks_dir, sample_id, "mask.tif")
+        if not os.path.exists(mask_path):
+            return None
+
+        image_paths, start_ts, end_ts, tile_ids = [], [], [], []
+        minx_list, maxx_list, miny_list, maxy_list = [], [], [], []
+
+        for ts in sorted(os.listdir(sample_path)):
+            parts = ts.split("_")
+            if len(parts) != 3:
+                continue
+            try:
+                start = datetime.strptime(parts[0], "%Y%m%dT%H%M%S")
+                end = datetime.strptime(parts[1], "%Y%m%dT%H%M%S")
+            except ValueError:
                 continue
 
-            timestamp_dirs = sorted(os.listdir(sample_path))
-            mask_path = os.path.join(masks_dir, sample_id, "mask.tif")
-            if not os.path.exists(mask_path):
+            tile_id = parts[2]
+            image_path = os.path.join(sample_path, ts, "all_bands.tif")
+            if not os.path.exists(image_path):
                 continue
 
-            image_paths = []
-            start_timestamps = []
-            end_timestamps = []
-            tile_ids = []
-            bboxes = []
-
-            for ts in timestamp_dirs:
-                parts = ts.split("_")
-                if len(parts) != 3:
-                    continue
-
-                try:
-                    start_ts = datetime.datetime.strptime(parts[0], "%Y%m%dT%H%M%S")
-                    end_ts = datetime.datetime.strptime(parts[1], "%Y%m%dT%H%M%S")
-                except ValueError:
-                    continue
-
-                tile_id = parts[2]
-                image_path = os.path.join(sample_path, ts, "all_bands.tif")
-                if not os.path.exists(image_path):
-                    continue
-
-                try:
-                    with rasterio.open(image_path) as src:
-                        bounds = src.bounds
-                except Exception:
-                    continue
-
-                image_paths.append(image_path)
-                start_timestamps.append(start_ts)
-                end_timestamps.append(end_ts)
-                tile_ids.append(tile_id)
-                bboxes.append({
-                    "minx": bounds.left,
-                    "maxx": bounds.right,
-                    "miny": bounds.bottom,
-                    "maxy": bounds.top
-                })
+            try:
+                with rasterio.open(image_path) as src:
+                    bounds = src.bounds
+            except Exception:
+                continue
 
-            if image_paths:
-                yield key, {
-                    "image_paths": image_paths,
-                    "mask_path": mask_path,
-                    "start_timestamps": start_timestamps,
-                    "end_timestamps": end_timestamps,
-                    "sentinel_tile_ids": tile_ids,
-                    "bboxes": bboxes
-                }
-                key += 1
+            image_paths.append(image_path)
+            start_ts.append(start)
+            end_ts.append(end)
+            tile_ids.append(tile_id)
+            minx_list.append(bounds.left)
+            maxx_list.append(bounds.right)
+            miny_list.append(bounds.bottom)
+            maxy_list.append(bounds.top)
+
+        if not image_paths:
+            return None
+
+        return {
+            "image_paths": image_paths,
+            "mask_path": mask_path,
+            "start_timestamps": start_ts,
+            "end_timestamps": end_ts,
+            "sentinel_tile_ids": tile_ids,
+            "bboxes": {
+                "minx": minx_list,
+                "maxx": maxx_list,
+                "miny": miny_list,
+                "maxy": maxy_list
+            }
+        }
+
+    @classmethod
+    def generate_index(cls, dataset_dir, output_path="index.jsonl"):
+        """
+        Scans the dataset directory and writes a streaming-friendly index.jsonl file.
+
+        Each line is a complete sample in JSON format.
+        """
+        images_dir = os.path.join(dataset_dir, "images")
+        masks_dir = os.path.join(dataset_dir, "masks")
+        sample_ids = sorted(os.listdir(images_dir))
+
+        with open(output_path, "w") as f:
+            for sample_id in tqdm(sample_ids, desc="Generating index", unit="sample"):
+                sample = cls._parse_sample(sample_id, images_dir, masks_dir)
+                if sample:
+                    sample["start_timestamps"] = [ts.isoformat() for ts in sample["start_timestamps"]]
+                    sample["end_timestamps"] = [ts.isoformat() for ts in sample["end_timestamps"]]
+                    sample["sample_id"] = sample_id
+                    f.write(json.dumps(sample) + "\n")
+
+        print(f"✅ Index written to {output_path}")