Origametry/origami-step-by-step-tiny

---
license: mit
task_categories:
- image-to-text
- visual-question-answering
tags:
- origami
- crease-pattern
- fold
- multiview
- step-by-step
- 3d-to-code
size_categories:
- n<1K
---

# Origami Step-by-Step Crease Pattern Dataset

A multiview image dataset for training models to infer origami crease patterns from 3D visualizations, one fold at a time.

## Task

Given **14 camera views** of a partially-folded origami sheet, predict the **next crease line** to add (edge position + mountain/valley assignment).

This mirrors a step-by-step folding process: starting from a blank sheet, each step adds one crease and the model must predict the next one from the current 3D visualization.

## Dataset Structure

Each example contains:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique example ID (e.g., `grid3_3c_0000_step_001`) |
| `images` | list[string] | 14 PNG paths — 6 face views + 8 corner views |
| `partial_fold` | dict | Current crease pattern in FOLD format (vertices, edges, assignments) |
| `next_crease` | dict | The crease to predict: `{"edge": [v0, v1], "assignment": "M" or "V"}` |
| `step` | int | Current step index (0-based) |
| `steps_remaining` | int | Steps left to complete the pattern |
| `difficulty` | string | `"easy"`, `"medium"`, or `"hard"` |

### Camera Views (14 per example)

- **6 face views:** `face_pos_x`, `face_neg_x`, `face_pos_y`, `face_neg_y`, `face_pos_z`, `face_neg_z`
- **8 corner views:** `corner_ppp`, `corner_ppn`, `corner_pnp`, `corner_pnn`, `corner_npp`, `corner_npn`, `corner_nnp`, `corner_nnn`

### Splits

| Split | Examples |
|-------|----------|
| train | 75 |
| val | 9 |
| test | 10 |

## Pattern Strategies

Patterns are generated using four strategies for diversity:

| Strategy | Description | Interior vertices |
|----------|-------------|-------------------|
| `grid` | Creases on NxN grid | Grid intersections |
| `singlevertex` | Radial creases from center | 1 (center) |
| `multivertex` | Random interior connections | N random points |
| `parallel` | Parallel lines at an angle | None |

## Usage

```python
from datasets import load_dataset
from PIL import Image

ds = load_dataset("YOUR_USERNAME/origami-step-by-step")

example = ds["train"][0]
print(example["id"]) # "grid3_3c_0000_step_001"
print(len(example["images"])) # 14
print(example["next_crease"]) # {"edge": [3, 7], "assignment": "M"}
print(example["steps_remaining"]) # 2

# Load one view
img = Image.open(example["images"][6]) # corner_ppp
```

### FOLD Format

The `partial_fold` field uses the [FOLD format](https://github.com/edemaine/fold) (JSON-based):

```json
{
"vertices_coords": [[0, 0], [0.5, 0], ...],
"edges_vertices": [[0, 1], [1, 2], ...],
"edges_assignment": ["B", "M", "V", ...],
"edges_foldAngle": [0, -180, 180, ...],
"faces_vertices": [[0, 1, 2], ...]
}
```

Edge assignments: `B` = boundary, `M` = mountain, `V` = valley, `F` = flat (structural).

## Generation

Generated using [OrigamiAnnotator](https://github.com/YOUR_USERNAME/OrigamiAnnotator) with rendering via [OrigamiSimulator](https://origamisimulator.org/).

- Crease patterns built incrementally via tree search with Kawasaki/Maekawa theorem verification
- 3D renderings produced by OrigamiSimulator (GPU physics simulation) at 60% fold
- Post-simulation intersection checking for quality filtering