README.md

---

license: cc-by-4.0
---


# Neural 3D Video Dataset - Processed

This directory contains preprocessed multi-view video data from the Neural 3D Video dataset, converted into a format suitable for 4D reconstruction and novel view synthesis tasks.

## Dataset Overview

**Source Dataset**: Neural 3D Video  
**License**: CC-BY-4.0  
**Processed Scenes**: 5 dynamic cooking scenes captured from multiple camera angles

### Scenes

| Scene | Description | Cameras | Frames |
|-------|-------------|---------|--------|
| `coffee_martini` | Making a coffee martini cocktail | 18 | 32 |
| `cook_spinach` | Cooking spinach in a pan | 18 | 32 |
| `cut_roasted_beef` | Cutting roasted beef | 18 | 32 |
| `flame_salmon_1` | Flambé salmon preparation | 18 | 32 |
| `sear_steak` | Searing steak in a pan | 18 | 32 |

## Directory Structure

```

Neural-3D-Video-Dataset/

├── README.md (this file)

├── coffee_martini_processed/

│   ├── 256/                          # 256×256 resolution

│   │   ├── images/                   # 32 frame images

│   │   │   ├── sample_000_cam00.jpg

│   │   │   ├── sample_001_cam01.jpg

│   │   │   └── ...

│   │   ├── transforms.json           # Camera poses (JSON format)

│   │   ├── transforms.npz            # Camera poses (NumPy format)

│   │   └── camera_visualization.html # Interactive 3D camera viewer

│   └── 512/                          # 512×512 resolution

│       ├── images/

│       ├── transforms.json

│       ├── transforms.npz

│       └── camera_visualization.html

├── cook_spinach_processed/

│   ├── 256/ ...

│   └── 512/ ...

├── cut_roasted_beef_processed/

│   ├── 256/ ...

│   └── 512/ ...

├── flame_salmon_1_processed/

│   ├── 256/ ...

│   └── 512/ ...

└── sear_steak_processed/

    ├── 256/ ...

    └── 512/ ...

```

## Data Format

### Camera Poses (`transforms.json`)

The camera poses are stored in a JSON file with the following structure:

```json

{

    "frames": [

        {

            "front": {

                "timestamp": 0,

                "file_path": "./images/sample_000_cam00.jpg",

                "w": 256,

                "h": 256,

                "fx": 341.33,

                "fy": 341.33,

                "cx": 128.0,

                "cy": 128.0,

                "w2c": [[...], [...], [...], [...]],     // 4×4 world-to-camera matrix

                "c2w": [[...], [...], [...]],             // 3×4 camera-to-world matrix

                "blender_camera_location": [x, y, z]     // Camera position in world coordinates

            }

        },

        ...

    ]

}

```

**Intrinsics** (camera internal parameters):
- **256×256**: `fx = fy = 341.33`, `cx = cy = 128.0`
- **512×512**: `fx = fy = 682.67`, `cx = cy = 256.0`

**Extrinsics** (camera external parameters):
- `w2c`: 4×4 world-to-camera transformation matrix
- `c2w`: 3×4 camera-to-world transformation matrix (rotation + translation)
- `blender_camera_location`: 3D camera position `[x, y, z]` in world coordinates

### NumPy Format (`transforms.npz`)

For convenience, camera parameters are also provided in NumPy format:

```python

import numpy as np



data = np.load('transforms.npz')

intrinsics = data['intrinsics']          # (32, 3, 3) - intrinsic matrices

extrinsics_w2c = data['extrinsics_w2c']  # (32, 4, 4) - world-to-camera

extrinsics_c2w = data['extrinsics_c2w']  # (32, 4, 4) - camera-to-world

camera_positions = data['camera_positions']  # (32, 3) - camera locations

```

### Frame Images

- **Format**: JPEG
- **Resolutions**: 256×256 and 512×512
- **Count**: 32 frames per scene
- **Naming**: `sample_{frame:03d}_cam{camera:02d}.jpg`

Each frame is extracted from a different camera view:
- Frame 0 → cam00
- Frame 1 → cam01
- ...
- Frame 17 → cam20
- Frame 18 → cam00 (loops back)
- ...
- Frame 31 → cam14

## Data Processing

### Original Data

- **Source resolution**: 2704×2028 (4:3 aspect ratio)
- **Original format**: Multi-view MP4 videos
- **Camera model**: LLFF format with `poses_bounds.npy`

### Processing Pipeline

1. **Center Crop**: 2704×2028 → 2028×2028 (square)
2. **Resize**: 2028×2028 → 256×256 or 512×512
3. **Intrinsics Adjustment**: Focal length and principal point adjusted for crop and resize
4. **Extrinsics Extraction**: Camera poses extracted from LLFF format
5. **Format Conversion**: Converted to standard c2w/w2c matrices

### Frame Sampling Strategy

To capture the dynamic motion from multiple viewpoints, frames are sampled such that each frame shows the scene from a different camera angle in sequence. This creates a "synchronized" multi-view video where:
- The temporal progression shows the dynamic action
- Each frame provides a different spatial viewpoint
- Camera angles loop after exhausting all 18 cameras

## Camera Visualization

Each processed scene includes an interactive 3D camera visualization (`camera_visualization.html`):

- **View camera positions** and orientations in 3D space
- **Interactive**: Rotate, pan, and zoom to explore the camera rig
- **Camera frustums**: Visualize the viewing direction and field of view
- **Trajectory path**: See the sequence of frames and camera transitions
- **Powered by Plotly**: High-quality interactive graphics

Open the HTML file in any web browser to explore the camera setup.

## Usage Examples

### Loading Camera Poses (Python)

```python

import json

import numpy as np



# Load from JSON

with open('coffee_martini_processed/256/transforms.json', 'r') as f:

    data = json.load(f)

    

# Access first frame

frame0 = data['frames'][0]['front']

print(f"Camera intrinsics: fx={frame0['fx']}, fy={frame0['fy']}")

print(f"Camera position: {frame0['blender_camera_location']}")

print(f"Image path: {frame0['file_path']}")



# Load from NumPy

poses = np.load('coffee_martini_processed/256/transforms.npz')

intrinsics = poses['intrinsics']  # (32, 3, 3)

c2w = poses['extrinsics_c2w']     # (32, 4, 4)

```

### Loading Images

```python

import cv2

import os



scene_dir = 'coffee_martini_processed/256'

img_dir = os.path.join(scene_dir, 'images')



# Load all frames

frames = []

for i in range(32):

    img_path = os.path.join(img_dir, f'sample_{i:03d}_cam*.jpg')

    # Find the actual file (camera number may vary)

    import glob

    img_file = glob.glob(img_path)[0]

    img = cv2.imread(img_file)

    frames.append(img)



print(f"Loaded {len(frames)} frames, shape: {frames[0].shape}")

```

### PyTorch Dataset Example

```python

import torch

from torch.utils.data import Dataset

from PIL import Image

import json

import numpy as np



class Neural3DVideoDataset(Dataset):

    def __init__(self, scene_dir):

        self.scene_dir = scene_dir

        

        # Load transforms

        with open(os.path.join(scene_dir, 'transforms.json'), 'r') as f:

            self.data = json.load(f)

        

        self.frames = self.data['frames']

    

    def __len__(self):

        return len(self.frames)

    

    def __getitem__(self, idx):

        frame_data = self.frames[idx]['front']

        

        # Load image

        img_path = os.path.join(self.scene_dir, frame_data['file_path'])

        img = Image.open(img_path).convert('RGB')

        img = torch.from_numpy(np.array(img)).float() / 255.0

        

        # Get camera parameters

        intrinsics = torch.tensor([

            [frame_data['fx'], 0, frame_data['cx']],

            [0, frame_data['fy'], frame_data['cy']],

            [0, 0, 1]

        ], dtype=torch.float32)

        

        c2w = torch.tensor(frame_data['c2w'], dtype=torch.float32)

        

        return {

            'image': img,

            'intrinsics': intrinsics,

            'c2w': c2w,

            'timestamp': frame_data['timestamp']

        }



# Usage

dataset = Neural3DVideoDataset('coffee_martini_processed/256')

sample = dataset[0]

print(f"Image shape: {sample['image'].shape}")

print(f"Camera position: {sample['c2w'][:, 3]}")

```

## Technical Details

### Camera Configuration

- **Number of cameras**: 18 per scene
- **Camera arrangement**: Surrounding the scene in a roughly circular pattern
- **Frame rate**: 30 FPS (original videos)
- **Camera model**: Pinhole camera with radial distortion (pre-undistorted)

### Coordinate System

- **World coordinates**: Right-handed coordinate system
- **Camera coordinates**: 
  - X-axis: Right
  - Y-axis: Down
  - Z-axis: Forward (viewing direction)
- **c2w matrix**: Transforms from camera space to world space
- **w2c matrix**: Transforms from world space to camera space

### Quality Settings

- **JPEG quality**: 95
- **Interpolation**: Bilinear (cv2.INTER_LINEAR)

- **Color space**: RGB (8-bit per channel)



## Citation



If you use this dataset in your research, please cite the original Neural 3D Video dataset:



```bibtex

@article{neural3dvideo2021,

  title={Neural 3D Video Synthesis},

  author={Author Names},

  journal={Conference/Journal Name},

  year={2021}

}

```



## Processing Scripts



The data was processed using custom scripts available in the parent directory:

- `create_sync_video_with_poses.py` - Single scene processing

- `batch_process_scenes.py` - Batch processing for all scenes



## License



This processed dataset inherits the CC-BY-4.0 license from the original Neural 3D Video dataset. Please respect the license terms when using this data.



## Contact



For questions or issues regarding this processed dataset, please contact the dataset maintainer.