Upload 3 files

README.md

@@ -0,0 +1,107 @@
+---
+license: cc-by-nc-sa-3.0
+---
+
+# Dataset Card for KITTI Flow 2012
+
+## Dataset Description
+
+The **KITTI Flow 2012** dataset is a real-world benchmark dataset designed to evaluate optical flow estimation algorithms in the context of autonomous driving. Introduced in the seminal paper ["Are we ready for Autonomous Driving? The KITTI Vision Benchmark Suite"](http://www.cvlibs.net/publications/Geiger2012CVPR.pdf) by Geiger et al., it provides challenging sequences recorded from a moving platform in urban, residential, and highway scenes.
+
+**Optical flow** refers to the apparent motion of brightness patterns in image sequences, used to estimate the motion of objects and the camera in the scene. It is a fundamental problem in computer vision with applications in visual odometry, object tracking, motion segmentation, and autonomous navigation.
+
+KITTI Flow 2012 contributes to optical flow research by providing:
+- Real-world stereo image pairs captured at two consecutive timepoints (t0 and t1).
+- Sparse ground-truth optical flow maps at t0, annotated using 3D laser scans.
+- Calibration files to relate image pixels to 3D geometry.
+- Disparity ground truth and stereo imagery for related benchmarking.
+
+The dataset enables fair and standardized comparison of optical flow algorithms and is widely adopted for benchmarking performance under real driving conditions.
+
+![Data visualization](https://huggingface.co/datasets/randall-lab/kitti-flow2012/resolve/main/header_flow.jpg)
+
+## Dataset Source
+- **Homepage**: [http://www.cvlibs.net/datasets/kitti/eval_stereo_flow.php?benchmark=flow](http://www.cvlibs.net/datasets/kitti/eval_stereo_flow.php?benchmark=flow)
+- **License**: [Creative Commons Attribution-NonCommercial-ShareAlike 3.0 (CC BY-NC-SA 3.0)](https://creativecommons.org/licenses/by-nc-sa/3.0/)
+- **Paper**: Andreas Geiger, Philip Lenz, and Raquel Urtasun. _Are we ready for Autonomous Driving? The KITTI Vision Benchmark Suite_. CVPR 2012.
+
+## Dataset Structure
+
+The dataset is organized into the following folders, each representing a specific modality or annotation:
+
+| Folder | Description |
+|--------|-------------|
+| `image_0/` | Grayscale images from the **left camera** at two timepoints. `<id>_10.png` is the reference frame (t0), `<id>_11.png` is the subsequent frame (t1). |
+| `image_1/` | Grayscale images from the **right camera**, same timestamps as `image_0/`. |
+| `colored_0/` | Color images from the **left camera** at t0 and t1. |
+| `colored_1/` | Color images from the **right camera**. |
+| `disp_noc/` | Disparity maps at t0 for **non-occluded** pixels. |
+| `disp_occ/` | Disparity maps at t0 for **all pixels**, including occlusions. |
+| `disp_refl_noc/` | Disparity maps for **reflective surfaces**, non-occluded only. |
+| `disp_refl_occ/` | Disparity maps for **reflective surfaces**, including occluded regions. |
+| `flow_noc/` | Sparse ground-truth optical flow maps for **non-occluded** pixels between t0 and t1. |
+| `flow_occ/` | Sparse ground-truth optical flow maps including **occluded** regions. |
+| `calib/` | Calibration files for each sample. Contains projection matrices: `P0` (left grayscale), `P1` (right grayscale), `P2` (left color), `P3` (right color). |
+
+### Notes on Filenames:
+- `<id>_10.png` = timepoint **t0** (reference frame)
+- `<id>_11.png` = timepoint **t1** (subsequent frame)
+- `<id>.txt` in `calib/` contains the camera projection matrices (3×4) used for reconstruction.
+- Testing split does not include ground truth.
+
+## Example Usage
+
+```python
+from datasets import load_dataset
+
+# Load the dataset (replace 'your-namespace' with your Hugging Face namespace)
+dataset = load_dataset("randall-lab/kitti-flow2012", split="train", trust_remote_code=True)
+
+example = dataset[0]
+
+# Grayscale Images (left and right)
+left_gray_t0 = example["ImageGray_left"][0] # Image at t0 from left gray camera
+left_gray_t1 = example["ImageGray_left"][1] # Image at t1 from left gray camera
+right_gray_t0 = example["ImageGray_right"][0]
+right_gray_t1 = example["ImageGray_right"][1]
+
+# Color Images
+left_color_t0 = example["ImageColor_left"][0]
+left_color_t1 = example["ImageColor_left"][1]
+right_color_t0 = example["ImageColor_right"][0]
+right_color_t1 = example["ImageColor_right"][1]
+
+# Ground Truth (only for training split)
+flow_noc = example["flow_noc"]          # non-occluded flow map
+flow_occ = example["flow_occ"]          # all-pixels flow map
+
+# GT for disparity map Uncomment it if needed
+# disp_noc = example["disp_noc"]          # disparity map
+# disp_occ = example["disp_occ"]
+# disp_refl_noc = example["disp_refl_noc"]
+# disp_refl_occ = example["disp_refl_occ"]
+
+# Calibration
+P0 = example["calib"]["P0"]  # Left grayscale camera
+P1 = example["calib"]["P1"]  # Right grayscale camera
+P2 = example["calib"]["P2"]  # Left color camera
+P3 = example["calib"]["P3"]  # Right color camera
+
+# Show example
+left_gray_t0.show()
+flow_noc.show()
+print(f"Calibration matrix P0 (left gray camera): {P0}")
+```
+If you are using colab, you should update datasets to avoid errors
+```
+pip install -U datasets
+```
+### Citation
+```
+@inproceedings{Geiger2012CVPR,
+  author = {Andreas Geiger and Philip Lenz and Raquel Urtasun},
+  title = {Are we ready for Autonomous Driving? The KITTI Vision Benchmark Suite},
+  booktitle = {Conference on Computer Vision and Pattern Recognition (CVPR)},
+  year = {2012}
+}
+```

kitti-flow2012.py

@@ -0,0 +1,117 @@
+import datasets
+import os
+from PIL import Image
+
+_KITTI2012_URL = "https://s3.eu-central-1.amazonaws.com/avg-kitti/data_stereo_flow.zip"
+
+class KITTIFLow2012(datasets.GeneratorBasedBuilder):
+    """KITTI Flow 2012 dataset with grayscale/color image sequences, optical flow ground truth, and calibration."""
+
+    VERSION = datasets.Version("1.0.0")
+
+    def _info(self):
+        return datasets.DatasetInfo(
+            description=(
+                "KITTI Flow 2012 dataset: contains grayscale and color stereo image sequences "
+                "captured at two consecutive timepoints, along with sparse optical flow ground truth and calibration files. "
+                "This dataset is widely used for benchmarking optical flow estimation methods in realistic driving scenarios."
+            ),
+            features=datasets.Features(
+                {
+                    "ImageGray_left": datasets.Sequence(datasets.Image()),
+                    "ImageGray_right": datasets.Sequence(datasets.Image()),
+                    "ImageColor_left": datasets.Sequence(datasets.Image()),
+                    "ImageColor_right": datasets.Sequence(datasets.Image()),
+                    "calib": {
+                        "P0": datasets.Sequence(datasets.Value("float32")),
+                        "P1": datasets.Sequence(datasets.Value("float32")),
+                        "P2": datasets.Sequence(datasets.Value("float32")),
+                        "P3": datasets.Sequence(datasets.Value("float32")),
+                    },
+                    "disp_noc": datasets.Image(),
+                    "disp_occ": datasets.Image(),
+                    "disp_refl_noc": datasets.Image(),
+                    "disp_refl_occ": datasets.Image(),
+                    "flow_noc": datasets.Image(),
+                    "flow_occ": datasets.Image(),
+                }
+            ),
+            homepage="http://www.cvlibs.net/datasets/kitti/eval_stereo_flow.php?benchmark=flow",
+            license="CC BY-NC-SA 3.0",
+            citation="""@inproceedings{Geiger2012CVPR,
+  author = {Andreas Geiger and Philip Lenz and Raquel Urtasun},
+  title = {Are we ready for Autonomous Driving? The KITTI Vision Benchmark Suite},
+  booktitle = {Conference on Computer Vision and Pattern Recognition (CVPR)},
+  year = {2012}
+}""",
+        )
+
+    def _split_generators(self, dl_manager):
+        archive_path = dl_manager.download_and_extract(_KITTI2012_URL)
+        train_path = os.path.join(archive_path, "training")
+        test_path = os.path.join(archive_path, "testing")
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={"base_path": train_path, "split": "training"},
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={"base_path": test_path, "split": "testing"},
+            ),
+        ]
+
+    def _generate_examples(self, base_path, split):
+        image_0_path = os.path.join(base_path, "image_0")
+        image_1_path = os.path.join(base_path, "image_1")
+        color_0_path = os.path.join(base_path, "colored_0")
+        color_1_path = os.path.join(base_path, "colored_1")
+        calib_path = os.path.join(base_path, "calib")
+
+        if split == "training":
+            disp_path = os.path.join(base_path, "disp_noc")
+            disp_path_occ = os.path.join(base_path, "disp_occ")
+            disp_path_refl_noc = os.path.join(base_path, "disp_refl_noc")
+            disp_path_refl_occ = os.path.join(base_path, "disp_refl_occ")
+            flow_noc_path = os.path.join(base_path, "flow_noc")
+            flow_occ_path = os.path.join(base_path, "flow_occ")
+
+        files = sorted(os.listdir(image_0_path))
+        ids = sorted(set(f.split("_")[0] for f in files))
+
+        for id_ in ids:
+            example = {
+                "ImageGray_left": [
+                    Image.open(os.path.join(image_0_path, f"{id_}_10.png")),
+                    Image.open(os.path.join(image_0_path, f"{id_}_11.png")),
+                ],
+                "ImageGray_right": [
+                    Image.open(os.path.join(image_1_path, f"{id_}_10.png")),
+                    Image.open(os.path.join(image_1_path, f"{id_}_11.png")),
+                ],
+                "ImageColor_left": [
+                    Image.open(os.path.join(color_0_path, f"{id_}_10.png")),
+                    Image.open(os.path.join(color_0_path, f"{id_}_11.png")),
+                ],
+                "ImageColor_right": [
+                    Image.open(os.path.join(color_1_path, f"{id_}_10.png")),
+                    Image.open(os.path.join(color_1_path, f"{id_}_11.png")),
+                ],
+                "calib": {"P0": [], "P1": [], "P2": [], "P3": []},
+                "disp_noc": Image.open(os.path.join(disp_path, f"{id_}_10.png")) if split == "training" else None,
+                "disp_occ": Image.open(os.path.join(disp_path_occ, f"{id_}_10.png")) if split == "training" else None,
+                "disp_refl_noc": Image.open(os.path.join(disp_path_refl_noc, f"{id_}_10.png")) if split == "training" else None,
+                "disp_refl_occ": Image.open(os.path.join(disp_path_refl_occ, f"{id_}_10.png")) if split == "training" else None,
+                "flow_noc": Image.open(os.path.join(flow_noc_path, f"{id_}_10.png")) if split == "training" else None,
+                "flow_occ": Image.open(os.path.join(flow_occ_path, f"{id_}_10.png")) if split == "training" else None,
+            }
+
+            calib_file = os.path.join(calib_path, f"{id_}.txt")
+            with open(calib_file, "r") as f:
+                lines = f.readlines()
+                for line in lines:
+                    key, value = line.strip().split(":", 1)
+                    if key in ["P0", "P1", "P2", "P3"]:
+                        example["calib"][key] = [float(x) for x in value.strip().split()]
+
+            yield id_, example