README.md

---
license: cc-by-nc-nd-4.0
task_categories:
  - video-classification
language:
  - en
tags:
  - egocentric
  - embodied-ai
  - robotics
  - imu
  - real-world
  - computer-vision
  - dataset
  - sample-dataset
size_categories:
  - n<1K
viewer: false
---

# PIZZA-DOUGH-BALLFORMATION-sample

## Overview

This dataset captures the complex, non-linear dynamics of dough manipulation—a frontier in 'Soft-Body' robotics. It features a professional pizzaiolo performing the ball formation process (boulage), recorded through a synchronized multi-modal array. By focusing on deformable materials, this dataset provides the 'Physical Grounding' necessary for World Models to predict material resistance, elasticity, and tactile transitions that are absent in rigid-object datasets. It is an essential resource for training VLA models on high-dexterity, force-sensitive tasks.


<video controls loop width="100%">
  <source src="https://huggingface.co/datasets/orgn3ai/PIZZA-DOUGH-BALLFORMATION-sample/resolve/main/medias/mosaic.mp4" type="video/mp4">
  Your browser does not support the video tag.
</video>

## Key Technical Features

**Tri-Source Synchronization**: Seamless alignment between Ego-centric FPV (Visual Intent), Top-Right Global view (Spatial Context), and Dual-Arm IMU telemetry (Proprioceptive Ground Truth).
**Soft-Body Physics**: High-resolution capture of dough deformation, providing unique data for predicting material flow and surface tension.
**Precision Temporal Protocol (T1-T4)**: Micro-action segmentation designed for Dense-Action learning:
* **T1 (Contact)**: Initial tactile engagement and surface adhesion detection.
* **T2 (Lift)**: Overcoming material stiction and gravitational transition.
* **T3 (Manipulate)**: Complex bimanual deformation, folding, and shaping phase (The 'Tacit Knowledge' core).
* **T4 (Release)**: Final detachment, capturing the elastic snap-back of the material.

## Use Cases for Research

**Deformable Object Manipulation**: Training Foundation Models (like OmniVLA) to understand and predict the behavior of non-rigid, viscoelastic materials.
**Cross-View Spatial Mapping**: Benchmarking FPV-to-Top-Right translation to improve robot spatial awareness in cluttered professional environments.
**Proprioceptive-Visual Fusion**: Leveraging IMU data to correlate visual pixel-flow with real-world acceleration and force-vector proxies during high-dexterity tasks.
**World Model Error Recovery**: Analyzing the T3 (Manipulate) phase to train agents on handling 'Corner Cases' such as sticky textures or uneven dough consistency.

## About Origine AI

We build real-world manipulation datasets from professional environments across France: industrial kitchens, bakeries, butcheries, and workshops.

Our network of 100+ partner sites gives us direct, recurring access to expert practitioners doing their actual jobs. We deploy synchronized multi-modal capture stacks (ego-view, wrist cameras, IMU) on-site and adapt our setup to the specific requirements of each collection.

We are currently working with robotics labs on custom pilots focused on dexterous manipulation and deformable object handling. GDPR-compliant. EU-based.

## Commercial Licensing and Contact

* The complete dataset and our custom collection services are available for commercial licensing and large-scale R&D. Whether you need existing data or a custom setup in a specific professional environment, reach out to discuss your requirements.
* 📩 hello@origineai.com

## License

* This dataset is licensed under cc-by-nc-nd-4.0.

## Dataset Statistics

This section provides detailed statistics extracted from `dataset_metadata.json`:

### Overall Statistics

- **Dataset Name**: PIZZA-DOUGH-BALLFORMATION-sample
- **Batch ID**: pizza
- **Total Clips**: 26
- **Number of Sequences**: 39
- **Number of Streams**: 3
- **Stream Types**: ego, imu_left_wrist, third

### Duration Statistics

- **Total Duration**: 12.62 minutes (757.07 seconds)
- **Average Clip Duration**: 29.12 seconds (29118.0 ms)
- **Min Clip Duration**: 26.37 seconds (26367 ms)
- **Max Clip Duration**: 32.83 seconds (32833 ms)

### Clip Configuration

- **Padding**: 1500 ms

### Statistics by Stream Type

#### Ego

- **Number of clips**: 13
- **Total duration**: 6.31 minutes (378.53 seconds)
- **Average clip duration**: 29.12 seconds (29118.0 ms)
- **Min clip duration**: 26.37 seconds (26367 ms)
- **Max clip duration**: 32.83 seconds (32833 ms)

#### Third

- **Number of clips**: 13
- **Total duration**: 6.31 minutes (378.53 seconds)
- **Average clip duration**: 29.12 seconds (29118.0 ms)
- **Min clip duration**: 26.37 seconds (26367 ms)
- **Max clip duration**: 32.83 seconds (32833 ms)

> **Note**: Complete metadata is available in `dataset_metadata.json` in the dataset root directory.

## Dataset Structure

The dataset uses a **unified structure** where each example contains all synchronized video streams:

```
dataset/
├── data-*.arrow         # Dataset files (Arrow format)
├── dataset_info.json    # Dataset metadata
├── dataset_metadata.json  # Complete dataset statistics
├── state.json           # Dataset state
├── README.md            # This file
├── medias/              # Media files (mosaics, previews, etc.)
│   └── mosaic.mp4       # Mosaic preview video
└── videos/              # All video clips
    └── ego/      # Ego video clips
    └── imu_left_wrist/      # Imu_left_wrist video clips
    └── third/      # Third video clips
```

### Dataset Format

The dataset contains **26 synchronized scenes** in a single `train` split. Each example includes:

- **Synchronized video columns**: One column per flux type (e.g., `ego`, `imu_left_wrist`, `third`)
- **Scene metadata**: `scene_id`, `sync_id`, `duration_ms`, `padding_ms`, `fps`
- **Rich metadata dictionary**: Task, environment, audio info, and synchronization details

All videos in a single example are synchronized and correspond to the same moment in time.

## Usage

### Load and Access Dataset

```python
import json
import random
from pathlib import Path
import cv2
from huggingface_hub import snapshot_download
from datasets import load_from_disk

repo = "orgn3ai/PIZZA-DOUGH-BALLFORMATION-sample"

# 1) Download snapshot locally
local_path = snapshot_download(repo_id=repo, repo_type="dataset")
base_dir = Path(local_path)
print("Snapshot path:", base_dir)

# 2) Load dataset saved with save_to_disk()
ds = load_from_disk(str(base_dir))
train = ds["train"] if isinstance(ds, dict) and "train" in ds else ds
print("Train rows:", len(train))
print("Train columns:", train.column_names)

# 3) Read root metadata.json and extract "flux"
metadata_path = base_dir / "dataset_metadata.json"
if not metadata_path.exists():
    raise FileNotFoundError(
        f"dataset_metadata.json not found at repo root: {metadata_path}\n"
        "Check your repo tree; maybe it's named dataset_metadata.json instead."
    )

with metadata_path.open("r", encoding="utf-8") as f:
    root_meta = json.load(f)

flux = root_meta.get("flux")
if not isinstance(flux, list) or not flux:
    raise ValueError(f'Expected metadata.json["flux"] to be a non-empty list, got: {flux}')

print("Flux entries:", flux)

# 4) Pick a random dataset entry
idx = random.randrange(len(train))
ex = train[idx]

print("\nRandom example index:", idx)
print("Example keys:", list(ex.keys()))

def resolve_video_path(video_value) -> Path:
    """
    video_value can be:
    - string path (most common case)
    - dict like {"path": "...", "bytes": ...} (for backward compatibility)
    """
    if isinstance(video_value, dict) and "path" in video_value:
        rel = video_value["path"]
    elif isinstance(video_value, str):
        rel = video_value
    else:
        raise TypeError(f"Unsupported video value type: {type(video_value)}; value={video_value}")

    # Normalize to avoid leading "./"
    rel = str(rel).lstrip("/")

    # Your dataset may store relative paths like "videos/ego/xxx.mp4"
    # Resolve them inside the snapshot folder.
    return base_dir / rel

def inspect_video(path: Path):
    print(f"  Local path: {path}")
    print(f"  Exists: {path.exists()}")
    if not path.exists():
        return {"ok": False, "reason": "file_not_found"}

    cap = cv2.VideoCapture(str(path))
    if not cap.isOpened():
        return {"ok": False, "reason": "cannot_open"}

    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    fps = float(cap.get(cv2.CAP_PROP_FPS))
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    # Some codecs report fps=0; guard it
    duration = (frame_count / fps) if fps and fps > 0 else None

    # Try read first frame
    ret, frame0 = cap.read()
    cap.release()

    info = {
        "ok": True,
        "width": width,
        "height": height,
        "fps": fps,
        "frame_count": frame_count,
        "duration_sec": duration,
        "first_frame_ok": bool(ret),
        "first_frame_shape": tuple(frame0.shape) if ret and frame0 is not None else None,
        "first_frame_dtype": str(frame0.dtype) if ret and frame0 is not None else None,
    }
    return info

# 5) For each flux key, inspect the associated video
print("\n=== VIDEO CHECK ===")
for key in flux:
    print(f"\nFlux key: {key}")
    if key not in ex:
        print(f"  ERROR: key '{key}' not in example. Available keys: {list(ex.keys())}")
        continue

    try:
        video_path = resolve_video_path(ex[key])
    except Exception as e:
        print(f"  ERROR resolving path: {e}")
        continue

    info = inspect_video(video_path)
    if not info["ok"]:
        print(f"  ERROR: {info['reason']}")
        continue

    print("  Video properties:")
    print(f"    - Resolution: {info['width']}x{info['height']}")
    print(f"    - FPS: {info['fps']:.3f}")
    print(f"    - Frames: {info['frame_count']}")
    if info["duration_sec"] is not None:
        print(f"    - Duration: {info['duration_sec']:.3f}s")
    else:
        print("    - Duration: (fps unavailable)")
    print(f"    - First frame decoded: {info['first_frame_ok']}")
    if info["first_frame_ok"]:
        print(f"    - Frame0 shape: {info['first_frame_shape']}")
        print(f"    - Frame0 dtype: {info['first_frame_dtype']}")

print('\n=== LABELS ===')
print(f"nbLabels: {len(ex['labels'])}")
for label in ex['labels']:
    print(f"    - {label['time_ms']}ms (withoutPadding): {label['label']}")

print("\nDONE.")
```

### Dataset Features

Each example contains:

- **`scene_id`**: Unique scene identifier (e.g., "01_0000")
- **`sync_id`**: Synchronization ID linking synchronized clips
- **`duration_ms`**: Duration of the synchronized clip in milliseconds (includes padding)
- **`padding_ms`**: Padding applied to clips (added at beginning and end, total padding = padding_ms × 2)
- **`fps`**: Frames per second (extracted from video)
- **`batch_id`**: Batch identifier
- **`dataset_name`**: Dataset name from config
- **One column per flux**: Each flux name from `metadata['flux_names']` has its own column (e.g., `ego`, `imu_left_wrist`, `third`) - String path to video file (relative to dataset root)
- **`metadata`**: Dictionary containing:
  - `task`: Task identifier
  - `environment`: Environment description
  - `has_audio`: Whether videos contain audio
  - `num_fluxes`: Number of synchronized flux types
  - `flux_names`: List of flux names present
  - `sequence_ids`: List of original sequence IDs
  - `sync_offsets_ms`: List of synchronization offsets

## Additional Notes

**Important**: This dataset uses a unified structure where each example contains all synchronized video streams in separate columns. All examples are in the `train` split.

**Synchronization**: Videos in the same example (same index in the `train` split) are automatically synchronized. They share the same `sync_id` and correspond to the same moment in time.

**Flux Keys**: The available flux keys are listed in `dataset_metadata.json` under the `"flux"` key. Use these keys to programmatically access video columns in each example.

**Video Paths**: Video paths are stored as strings (relative to the dataset root directory). Paths can be resolved using the `resolve_video_path` function shown in the usage example above.

## License

This dataset is licensed under **cc-by-nc-nd-4.0**.