Straw6D: plant-disjoint split (train/validation/test), rgb+metadata.jsonl per split

.gitattributes

@@ -0,0 +1,61 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+train/metadata.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,149 @@
+---
+license: cc-by-4.0
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*
+dataset_info:
+  features:
+  - name: image_id
+    dtype: string
+  - name: image
+    dtype: image
+  - name: resolution
+    list: int32
+  - name: fx
+    dtype: float64
+  - name: fy
+    dtype: float64
+  - name: cx
+    dtype: float64
+  - name: cy
+    dtype: float64
+  - name: camera_view_matrix
+    list:
+      list: float64
+  - name: camera_projection_matrix
+    list:
+      list: float64
+  - name: labels
+    list: string
+  - name: bbox_2d_loose
+    list:
+      list: float64
+  - name: size_local
+    list:
+      list: float64
+  - name: center_local
+    list:
+      list: float64
+  - name: local_to_world_transform
+    list:
+      list:
+        list: float64
+  splits:
+  - name: train
+    num_bytes: 5647010348
+    num_examples: 12040
+  download_size: 5485176011
+  dataset_size: 5647010348
+task_categories:
+- object-detection
+tags:
+- robotics
+- 6d-pose-estimation
+- agriculture
+- strawberry
+---
+
+# Straw6D: In-Field 6D Pose Dataset for Robotic Strawberry Harvesting
+
+This dataset accompanies the paper:
+
+> **From Simulation to the Real-World: An In-Field 6D Pose Dataset and Baseline for Robotic Strawberry Harvesting**
+> Woojung Son, Won Suk Lee, Zijing Huang, Daeun Choi, Catia Silva, Yu She, Yan Gu
+> University of Florida & Purdue University
+> [[arXiv]](https://arxiv.org/abs/2606.11381)
+
+## Overview
+
+To the best of our knowledge, Straw6D is the **first real-world 6D pose ground truth dataset of strawberries collected in actual agricultural fields**. Collecting 6D pose ground truth in real agricultural environments is inherently challenging; prior work has largely relied on synthetic data with limited realism. This dataset bridges that gap by providing per-frame 6D pose annotations paired with RGB images captured directly in the field.
+
+- **12,040** RGB images with **16,037** annotated strawberry instances
+- **Single category**: `strawberry` (red-stage / ripe only)
+- Recorded using an Intel RealSense D435i camera
+
+## Annotation Pipeline
+
+Ground truth 6D poses were obtained through a multi-step process:
+1. Checkerboard-based camera calibration (PnP algorithm)
+2. Metric-scale 3D reconstruction via COLMAP
+3. Manual 3D bounding box annotation on reconstructed point clouds
+4. 6D pose derived from camera-to-world and local-to-world transformations
+
+## Dataset Structure
+
+Each sample provides image, per-frame camera parameters, and per-object pose annotations.
+
+**Camera fields** (per frame):
+
+| Field | Description |
+|---|---|
+| `image_id` | Zero-padded frame index (e.g. `000042`) |
+| `image` | RGB image |
+| `resolution` | [width, height] in pixels |
+| `fx`, `fy`, `cx`, `cy` | Camera intrinsics in pixels |
+| `camera_view_matrix` | 4×4 world-to-camera transform |
+| `camera_projection_matrix` | 4×4 OpenGL projection matrix |
+
+**Object fields** (list, one entry per object in the frame):
+
+| Field | Description |
+|---|---|
+| `labels` | Category label (`"strawberry"`) |
+| `bbox_2d_loose` | 2D bounding box [x_min, y_min, x_max, y_max] in pixels |
+| `size_local` | Object size [x, y, z] in meters |
+| `center_local` | Object center in local space |
+| `local_to_world_transform` | 4×4 object-local-to-world transform |
+
+All 4×4 matrices are **row-major**: `p_out = p_in @ M`.
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("WoojungSon/Straw6D")
+sample = ds["train"][0]
+
+print(sample["image_id"])   # "000000"
+print(sample["labels"])     # ["strawberry"]
+sample["image"]             # PIL Image
+```
+
+## Visualization
+
+A visualization script is provided in `scripts/visualization.py`. It projects the 6D pose axes onto the RGB image:
+
+```bash
+python scripts/visualization.py \
+    --image path/to/rgb/000000.png \
+    --json  path/to/json/000000.json \
+    --output output.png
+```
+
+## Citation
+
+```bibtex
+@article{son2025straw6d,
+  title={From Simulation to the Real-World: An In-Field 6D Pose Dataset and Baseline for Robotic Strawberry Harvesting},
+  author={Son, Woojung and Lee, Won Suk and Huang, Zijing and Choi, Daeun and Silva, Catia and She, Yu and Gu, Yan},
+  journal={arXiv preprint arXiv:2606.11381},
+  year={2025}
+}
+```
+
+## License
+
+This dataset is released under the [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/) license.

scripts/visualization.py

@@ -0,0 +1,146 @@
+"""
+Visualize 6D pose annotations by projecting local frame axes onto RGB images.
+
+Coordinate conventions
+----------------------
+- All matrices are **row-major** (Isaac Sim / USD convention).
+  Transforms are applied as:  p_out = p_in @ M   (row vector on the left)
+
+- World / object space uses a **right-handed, Y-up** frame (OpenGL convention).
+    +X : right
+    +Y : up
+    -Z : into the scene (camera looks toward -Z in camera space)
+
+- Camera space also follows **OpenGL**:
+    +X : right,  +Y : up,  -Z : into the scene
+
+- Screen space follows **OpenCV / image** convention:
+    +u : right,  +v : down,  origin at top-left
+
+  Conversion from OpenGL camera space → OpenCV screen space:
+    x_cv =  x_gl
+    y_cv = -y_gl   (flip Y)
+    z_cv = -z_gl   (flip Z; positive depth is in front)
+
+Matrix fields in the JSON
+--------------------------
+- camera_view_matrix      (4x4, row-major) : world → camera
+- local_to_world_transform (4x4, row-major) : object-local → world
+- intrinsics              : {fx, fy, cx, cy} in pixels
+"""
+
+import json
+import numpy as np
+from PIL import Image, ImageDraw
+import argparse
+
+
+def project_world_point_to_screen(world_point, view_matrix, intrinsics):
+    """Project a homogeneous world-space point to pixel coordinates.
+
+    Uses row-major convention: cam = world_point @ view_matrix.
+    Converts OpenGL camera space (y-up, -z forward) to OpenCV screen space (y-down, +z forward).
+    Returns None if the point is behind the camera (z_cv <= 0).
+    """
+    p = np.array([*world_point[:3], 1.0]) if len(world_point) == 3 else np.array(world_point)
+    cam = p @ view_matrix                       # row-major: point on the left
+    x, y, z = cam[0], -cam[1], -cam[2]         # OpenGL → OpenCV axis flip
+    if z <= 0:
+        return None
+    u = intrinsics['fx'] * x / z + intrinsics['cx']
+    v = intrinsics['fy'] * y / z + intrinsics['cy']
+    return round(u), round(v)
+
+
+def draw_local_frame_axes(draw, local_to_world_transform, camera_view_matrix, intrinsics, size_local, origin_local, axes_length_perc=1.5):
+    """Draw X/Y/Z axes of the object's local frame onto the image.
+
+    Axis length is scaled by the mean object size * axes_length_perc.
+    Pipeline: local → world  (@ L),  world → screen  (project_world_point_to_screen).
+    """
+    L = np.array(local_to_world_transform)  # row-major local→world (4x4)
+    V = np.array(camera_view_matrix)        # row-major world→camera (4x4)
+    ax_len = np.mean(size_local) * axes_length_perc
+    ox, oy, oz = origin_local
+
+    points_local = {
+        'origin': [ox,          oy,          oz,          1],
+        'x':      [ox + ax_len, oy,          oz,          1],
+        'y':      [ox,          oy + ax_len, oz,          1],
+        'z':      [ox,          oy,          oz + ax_len, 1],
+    }
+    pts2d = {k: project_world_point_to_screen(np.array(v) @ L, V, intrinsics)
+             for k, v in points_local.items()}
+
+    o = pts2d['origin']
+    for key, color in [('x', 'red'), ('y', 'green'), ('z', 'blue')]:
+        if o is not None and pts2d[key] is not None:
+            draw.line([o, pts2d[key]], fill=color, width=5)
+
+
+def draw_world_frame_axes_bottom_left(draw, camera_view_matrix, intrinsics, screen_size, axes_scale=0.1, margin_percentage=0.05):
+    """Draw world-frame X/Y/Z axes in the bottom-left corner as a reference gizmo.
+
+    Places a virtual origin 1 unit in front of the camera (OpenGL: z=-1 in camera space),
+    converts it to world space via the inverse view matrix, then re-projects to screen.
+    The axes are offset so they appear anchored to the bottom-left corner.
+    """
+    V = np.array(camera_view_matrix)
+    V_inv = np.linalg.inv(V)
+    # z=-1 in OpenGL camera space = 1 unit in front of the camera
+    origin_world = np.array([0, 0, -1.0, 1]) @ V_inv  # camera → world
+
+    pts2d = {}
+    pts2d['origin'] = project_world_point_to_screen(origin_world, V, intrinsics)
+    for key, delta in [('x', [axes_scale, 0, 0, 0]), ('y', [0, axes_scale, 0, 0]), ('z', [0, 0, axes_scale, 0])]:
+        pts2d[key] = project_world_point_to_screen(origin_world + np.array(delta), V, intrinsics)
+
+    if any(v is None for v in pts2d.values()):
+        return
+
+    # Shift projected axes to bottom-left corner
+    margin = int(margin_percentage * min(screen_size))
+    all_x = [pts2d[k][0] for k in pts2d]
+    all_y = [pts2d[k][1] for k in pts2d]
+    ox = margin - min(all_x)
+    oy = screen_size[1] - margin - max(all_y)
+
+    o = (pts2d['origin'][0] + ox, pts2d['origin'][1] + oy)
+    for key, color in [('x', 'red'), ('y', 'green'), ('z', 'blue')]:
+        end = (pts2d[key][0] + ox, pts2d[key][1] + oy)
+        draw.line([o, end], fill=color, width=3)
+
+
+def main(image_path, json_path, output_path):
+    rgb_img = Image.open(image_path)
+    draw = ImageDraw.Draw(rgb_img)
+
+    with open(json_path, 'r') as f:
+        data = json.load(f)
+
+    camera_data = data["camera_data"]
+    V = camera_data["camera_view_matrix"]   # row-major world→camera (4x4)
+    intrinsics = camera_data["intrinsics"]  # {fx, fy, cx, cy} in pixels
+    screen_size = tuple(camera_data["resolution"])  # (width, height)
+
+    for obj in data["objects"]:
+        b = obj["bbox_3d_local"]
+        size_local   = [b["x_max"] - b["x_min"], b["y_max"] - b["y_min"], b["z_max"] - b["z_min"]]
+        center_local = [(b["x_min"] + b["x_max"]) / 2, (b["y_min"] + b["y_max"]) / 2, (b["z_min"] + b["z_max"]) / 2]
+
+        draw_local_frame_axes(draw, obj["local_to_world_transform"], V, intrinsics, size_local, center_local)
+
+    draw_world_frame_axes_bottom_left(draw, V, intrinsics, screen_size)
+
+    rgb_img.save(output_path)
+    print(f"Overlay image saved to: {output_path}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--image",  type=str, required=True)
+    parser.add_argument("--json",   type=str, required=True)
+    parser.add_argument("--output", type=str, required=True)
+    args = parser.parse_args()
+
+    main(args.image, args.json, args.output)