---
license: mit
task_categories:
- robotics
- computer-vision
tags:
- point-cloud
- hdf5
- point-tracking
- canonical-point-cloud
- rigid-transform
- world-model
pretty_name: Kinder Worldmodel Dataset
---

# Kinder-worldmodel Dataset

This repository contains processed HDF5 datasets and demo videos for the Kinder-worldmodel project.

The uploaded files demonstrate two related point cloud representations:

1. **Tracked / all-point-cloud HDF5 data**
2. **Canonical point cloud replay using per-geom rigid transforms**

## Files

* `sweep_tracked_pointcloud_all.hdf5`
  Processed HDF5 file containing complete point cloud data and point tracking information.

* `sweep_canonical.hdf5`
  HDF5 file using a transform-based representation. Instead of storing per-timestep point clouds, it stores canonical surface points for each rigid geom and per-timestep 4x4 transforms.

* `videos/complete_pointcloud_demo.mp4`
  Demo video showing complete point cloud visualization.

* `videos/point_tracking_demo.mp4`
  Demo video showing point tracking across frames.

* `videos/canonicalpointcloud-excluding kitchen floor.mp4`
  Demo video showing transform-based canonical point cloud replay at 30 fps.

## Dataset Description

The dataset is intended for inspecting complete point clouds, point tracking, and transform-based point cloud replay.

For the canonical point cloud representation, each rigid geom is stored using:

* one canonical surface point set in local coordinates
* per-timestep 4x4 rigid transforms

This avoids storing a full point cloud for every timestep.

## Canonical Point Cloud Replay

The canonical point cloud replay demo is rendered from the new HDF5 format, not from per-timestep point clouds stored in the file.

For each rigid geom, the file stores:

```text
canonical_pointcloud/<geom_name>/xyz
geom_transforms/<geom_name>[t]
```

At each frame, world-space points are reconstructed using:

```python
world_pts = (T @ pts_h.T).T[:, :3]
```

where:

* `pts_h` is the homogeneous version of the canonical local point cloud
* `T` is the 4x4 rigid transform for that geom at timestep `t`
* `world_pts` are the reconstructed world-frame points

### What is shown in the canonical replay video

The clip shows:

* reconstructed scene at 30 fps from `hdf5_data/sweep_canonical.hdf5`
* task: `SweepIntoDrawer3D-o5`
* number of demos: 1
* kitchen and floor geometry filtered out
* robot, task objects, and other non-kitchen geometry kept

The filtered-out geoms include names containing:

```text
kitchen
floor
```

This removes cabinets, panels, drawers, and floor geometry.

The displayed result is a filtered view of the same transform-based representation. It shows that geom names can be used to drop background geometry and focus on the manipulator and task-relevant parts without re-exporting the dataset.

One-line summary:

```text
Transform-based point cloud replay at 30 fps; kitchen/floor removed by geom-name filter.
```

## Related Fields

The same canonical HDF5 file also contains fields that are not visualized in the canonical replay video:

* `actions`
  Original demo actions.

* `actions_delta_ee_transform`
  End-effector delta transform per action step, computed at `robot_pinch_site`.

* `obs/ee_pose`
  End-effector pose per step for debugging.

## How to Download

You can download the files directly from this Hugging Face dataset repository.

You can also download a file using Python:

```python
from huggingface_hub import hf_hub_download

file_path = hf_hub_download(
    repo_id="Flashkernel/Kinder-worldmodel",
    filename="sweep_tracked_pointcloud_all.hdf5",
    repo_type="dataset"
)

print(file_path)
```

To download the canonical HDF5 file:

```python
from huggingface_hub import hf_hub_download

file_path = hf_hub_download(
    repo_id="Flashkernel/Kinder-worldmodel",
    filename="sweep_canonical.hdf5",
    repo_type="dataset"
)

print(file_path)
```

## How to Inspect the HDF5 File

Install dependencies:

```bash
pip install h5py
```

Then inspect the file structure:

```python
import h5py

file_path = "sweep_canonical.hdf5"

with h5py.File(file_path, "r") as f:
    def print_structure(name, obj):
        if isinstance(obj, h5py.Dataset):
            print(name, obj.shape, obj.dtype)
        else:
            print(name)

    f.visititems(print_structure)
```

## Visualization

The demo videos show:

1. Complete point cloud visualization
2. Point tracking across frames
3. Canonical point cloud replay from canonical points and per-geom 4x4 transforms

The canonical replay video is generated from canonical local point sets and rigid transforms. It does not require storing a dense per-frame point cloud in the HDF5 file.

## Usage Notes

This is a dataset repository, so it is not meant to be run directly.

To use the data, download the HDF5 file and load it with `h5py`. The videos provide visual examples of the stored representations and reconstruction results.

## Repository Link

Dataset page:

https://huggingface.co/datasets/Flashkernel/Kinder-worldmodel