SAUSAGE-CRAFTING-sample: Fine Manipulation of Deformable Sausage Casings

Overview

This dataset provides a high-quality, multi-view synchronized capture of expert procedural tasks in a professional butchery environment. It specifically focuses on the complex manipulation of non-rigid and deformable objects such as sausage casings and stuffing. This resource addresses current challenges in robotics and computer vision regarding physical interaction with elastic and organic materials.

Key Technical Features

• Synchronized Dual-View: Includes perfectly aligned ego-centric (First-Person View) and third-person perspectives.
• Non-Rigid Physics: Captures complex material behaviors such as plasticity and elasticity during the sausage-making process.
• High-Quality Synchronization: All views are precisely time-aligned using a unified sync_id to ensure seamless cross-modal understanding.
• Expert Craftsmanship: Focused on the specific task of rolling and measuring sausage casings with professional dexterity.

Use Cases for Research

• Embodied AI and World Models: Training agents to predict the physical consequences of interacting with deformable organic matter.
• Procedural Task Learning: Modeling long-form sequential actions where expert intent is critical.
• Tactile-Visual Inference: Learning to estimate force and material resistance through visual observation of fine manipulation.

Custom Data Collection Services

Our team specializes in high-fidelity data acquisition within real-world professional settings. We provide on-demand data collection services tailored to specific AI and robotics requirements:

• Professional Network: Direct access to 100+ professional environments, including professional kitchens, bakeries, mechanical workshops, craft studios, and industrial facilities.
• Multi-Modal Capture: Expertise in collecting synchronized streams including Third-Person views, Ego-centric (FPV), IMU sensors (motion tracking), and Expert Audio Narration.
• Domain Expertise: We bridge the gap between technical AI needs and authentic professional "tacit knowledge."

Full Dataset Specifications

• Expert Audio Narration: Live commentary explaining intent, tactile feedback, and professional heuristics.
• Total Duration: 50+ hours of continuous professional expert operations.
• Extended Tasks: Includes stuffing preparation, casing filling, and specialized tool maintenance.
• Data Quality: Native 4K resolution and comprehensive temporal action annotations.

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, do not hesitate to reach out for more information.
• Contact: [email protected]

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: SAUSAGE-CRAFTING-sample: Fine Manipulation of Deformable Sausage Casings
• Batch ID: 01
• Total Clips: 120
• Number of Sequences: 6
• Number of Streams: 2
• Stream Types: ego, third

Duration Statistics

• Total Duration: 8.00 minutes (480.00 seconds)
• Average Clip Duration: 4.00 seconds
• Min Clip Duration: 4.00 seconds
• Max Clip Duration: 4.00 seconds

Clip Configuration

• Base Clip Duration: 3.00 seconds
• Clip Duration with Padding: 4.00 seconds
• Padding: 500 ms

Statistics by Stream Type

Ego

• Number of clips: 60
• Total duration: 4.00 minutes (240.00 seconds)
• Average clip duration: 4.00 seconds
• Min clip duration: 4.00 seconds
• Max clip duration: 4.00 seconds

Third

• Number of clips: 60
• Total duration: 4.00 minutes (240.00 seconds)
• Average clip duration: 4.00 seconds
• Min clip duration: 4.00 seconds
• Max clip duration: 4.00 seconds

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
    └── third/      # Third video clips

Dataset Format

The dataset contains 120 synchronized scenes in a single train split. Each example includes:

• Synchronized video columns: One column per flux type (e.g., ego_video, third_video)
• Scene metadata: scene_id, sync_id, duration_sec, 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 Dataset

from datasets import load_dataset

# Load from Hugging Face Hub
dataset = load_dataset('orgn3ai/SAUSAGE-CRAFTING-sample')

# IMPORTANT: The dataset has a 'train' split
# Check available splits
print(f"Available splits: {list(dataset.keys())}")  # Should show: ['train']

# Or load from local directory
# from datasets import load_from_disk
# dataset = load_from_disk('outputs/01/dataset')

# Access the 'train' split
train_data = dataset['train']

# Access synchronized scenes from the train split
example = train_data[0]  # First synchronized scene

# Or directly:
example = dataset['train'][0]  # First synchronized scene

# Access all synchronized videos
ego_video = example['ego_video']  # Ego-centric view
third_video = example['third_video']  # Third-person view

# Access metadata
print(f"Scene ID: {example['scene_id']}")
print(f"Duration: {example['duration_sec']}s")
print(f"FPS: {example['fps']}")
print(f"Metadata: {example['metadata']}")

# Get dataset info
print(f"Number of examples in train split: {len(dataset['train'])}")

Access Synchronized Videos

Each example contains all synchronized video streams. Access them directly:

import cv2
from pathlib import Path

# IMPORTANT: Always access the 'train' split
# Get a synchronized scene from the train split
example = dataset['train'][0]

# Access video objects (Video type stores path in 'path' attribute or as dict)
ego_video_obj = example.get('ego_video')
third_video_obj = example.get('third_video')

# Extract path from Video object (Video type stores: {{'path': 'videos/ego/0000.mp4', 'bytes': ...}})
def get_video_path(video_obj):
    if isinstance(video_obj, dict) and 'path' in video_obj:
        return video_obj['path']
    elif isinstance(video_obj, str):
        return video_obj
    else:
        return getattr(video_obj, 'path', str(video_obj))

ego_video_path = get_video_path(ego_video_obj)
third_video_path = get_video_path(third_video_obj)

# Resolve full paths from dataset cache (when loading from Hub)
cache_dir = Path(dataset['train'].cache_files[0]['filename']).parent.parent
ego_video_full_path = cache_dir / ego_video_path
third_video_full_path = cache_dir / third_video_path

# Process all synchronized videos together
# IMPORTANT: Iterate over the 'train' split
for example in dataset['train']:
    scene_id = example['scene_id']
    sync_id = example['sync_id']
    metadata = example['metadata']
    
    print(f"Scene {{scene_id}}: {{metadata['num_fluxes']}} synchronized fluxes")
    print(f"Flux names: {{metadata['flux_names']}}")
    
    # Access video paths and resolve them
    ego_video_path = example.get('ego_video')
    third_video_path = example.get('third_video')
    
    # Resolve full paths
    ego_video_full = cache_dir / ego_video_path
    third_video_full = cache_dir / third_video_path
    
    # Process synchronized videos...

Filter and Process

# IMPORTANT: Always work with the 'train' split
# Filter by sync_id
scene = dataset['train'].filter(lambda x: x['sync_id'] == 0)[0]

# Filter by metadata
scenes_with_audio = dataset['train'].filter(lambda x: x['metadata']['has_audio'])

# Access metadata fields
# Iterate over the 'train' split
for example in dataset['train']:
    task = example['metadata']['task']
    environment = example['metadata']['environment']
    has_audio = example['metadata']['has_audio']
    flux_names = example['metadata']['flux_names']
    sync_offsets = example['metadata']['sync_offsets_ms']

Dataset Features

Each example contains:

• scene_id: Unique scene identifier (e.g., "01_0000")
• sync_id: Synchronization ID linking synchronized clips
• duration_sec: Duration of the synchronized clip in seconds
• fps: Frames per second (default: 30.0)
• batch_id: Batch identifier
• dataset_name: Dataset name from config
• ego_video: Video object for ego-centric view (Hugging Face Video type with decode=False, stores path)
• third_video: Video object for third-person view (Hugging Face Video type with decode=False, stores path)
• 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.

Video Paths: Video paths are stored using Hugging Face's Video type with decode=False. To access the actual file path, extract the path attribute from the Video object (see examples above).

• clip_index: Clip index within the flux folder
• duration_sec: Clip duration in seconds
• start_time_sec: Start time in source video
• batch_id, dataset_name, source_video, sync_offset_ms: Additional metadata

License

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