Blame for README.md

# Human-Object Interaction Dataset

This dataset is designed for learning and evaluating Human-Object Interaction (HOI) in structured 3D environments. It provides a modular library of annotated 3D assets, scene layouts, interaction plans, top-view scene renderings, and natural-language task instructions. The dataset can be used for HOI policy learning, layout-conditioned interaction reasoning, vision-language grounding, and scene-level task planning.

---

## Directory Structure

```plaintext
├── 3d_assets/                    # Category-wise annotated 3D assets
│   ├── chair/
│   │   └── chair_01/
│   │       ├── mesh.obj          # 3D mesh file
│   │       ├── config.yaml       # Geometric features and semantic part point clouds
│   │       └── asset.urdf        # Physics and pose configuration
│   ├── bed/
│   ├── sofa/
│   ├── box/
│   ├── cabinet/
│   ├── table/
│   ├── decoration/
│   └── machine/
├── layout/                       # Multi-object layout configurations
│   ├── dynamic_000.yaml
│   ├── dynamic_001.yaml
│   └── ...
├── image/                        # Top-view rendered images of layouts
│   ├── dynamic_000.png
│   ├── dynamic_001.png
│   └── ...
└── text_instruction.json          # Natural-language task instruction for each scene
```

Each scene is indexed by a shared scene id, such as `dynamic_000`, `static_012`, or `hybrid_034`. The same id is used to align the layout file, rendered image, and text instruction:

```plaintext
layout/dynamic_000.yaml
image/dynamic_000.png
text_instruction.json["dynamic_000"]
```

---

## 3D Asset Specification

Each asset instance contains a `config.yaml` file with the following fields:

| Field | Description |
|---|---|
| `bbox_min/max` | 3D bounding box coordinates of the asset. |
| `part_pcd` | Dictionary mapping semantic part names to point clouds. |
| `h_map` | Semantic height map for interaction reasoning, represented as an array of `[x, y, z]` points. |
| `name` | Unique identifier for the asset instance. |

The asset directory also contains the visual mesh and the physics description:

| File | Description |
|---|---|
| `mesh.obj` | Mesh used for rendering and visualization. |
| `asset.urdf` | Physics and pose configuration used by simulation or interaction environments. |
| `config.yaml` | Geometry and semantic annotations used by layout generation and interaction planning. |

---

## Scene Layout Structure

Each layout file describes a multi-object scene. A layout contains a list of object tuples with the following structure:

```python
[
  (category, name, source_path, position: (x, y), rotation: float),
  ...
]
```

Fields:

| Field | Type | Description |
|---|---|---|
| `category` | `str` | Object category, such as `chair`, `bed`, `table`. |
| `name` | `str` | Unique name or identifier of the object instance. |
| `source_path` | `str` | Path to the corresponding 3D asset directory. |
| `position` | `list[float]` | Object placement on the 2D layout plane, represented as `(x, y)`. |
| `rotation` | `float` | Discrete yaw rotation angle in degrees. |

The layout file is the geometric source of the scene. It defines which assets appear in the scene and where they are placed.

---

## Top-View Image Renderings

The `image/` directory stores top-view rendered images for the generated layouts. Each image is rendered from a bird's-eye camera and provides a compact visual observation of the corresponding scene arrangement.

Naming convention:

```plaintext
image/{scene_id}.png
```

Example:

```plaintext
image/dynamic_000.png
```

This image corresponds to:

```plaintext
layout/dynamic_000.yaml
text_instruction.json["dynamic_000"]
```

The top-view images are useful for:

- quickly checking whether a generated layout is spatially valid;
- training or evaluating vision-language models on scene-level HOI tasks;
- grounding text instructions in visual scene observations;
- retrieving or filtering layouts by visual structure;
- debugging asset placement, object orientation, and scene composition.

The image should be treated as a rendered observation of the layout rather than a replacement for the layout file. Precise object paths, coordinates, rotations, and asset categories should still be read from `layout/{scene_id}.yaml`.

---

## Text Instruction Annotations

The `text_instruction.json` file stores natural-language task instructions for the scenes. It is a JSON dictionary whose keys are scene ids and whose values are instruction strings.

Format:

```json
{
  "dynamic_000": "Arrange the two boxes in suitable spots around the room to tidy up the space.",
  "hybrid_000": "Take a moment to sit on the chair, then move the machine closer to the center of the room.",
  "static_000": "Take a moment to relax in the chair, then move to the bed for some rest."
}
```

Each instruction describes the high-level task goal in natural language. The instruction is intentionally scene-level: it tells the agent what should be achieved, while the detailed object geometry, target locations, semantic parts, and interaction constraints are provided by the layout and interaction plan annotations.

The dataset includes three common task families:

| Prefix | Description |
|---|---|
| `static_*` | Human interaction with static furniture, such as sitting, lying, or resting. |
| `dynamic_*` | Object rearrangement tasks, such as moving boxes or machines to suitable positions. |
| `hybrid_*` | Mixed tasks combining static human-furniture interaction with dynamic object rearrangement. |

---

## Interaction Plan Format

Each interaction plan defines a stage of human-object interaction with the following format:

```json
{
  "human_root_target": "object_name(position)",
  "object_root_target": "object_name(center)",
  "reletive_movement_dynamics": [
    ["pelvis", "seat_surface", "0"],
    ["head", "backrest", "1"] ...
  ]
}
```

Fields:

| Field | Description |
|---|---|
| `human_root_target` | The target location or part of the object that the human is facing or approaching, such as `chair(front)` or `bed(left)`. |
| `object_root_target` | The central or reference part of the object involved in the interaction, usually `object(center)`. |
| `reletive_movement_dynamics` | A list of relative movement dynamics (RMDs) between human joints and object parts. |

Each RMD entry is a triplet:

```python
[human_joint, object_part, rmd_type_id]
```

where `human_joint` can be `pelvis`, `head`, `left_hand`, etc.; `object_part` can be `seat_surface`, `backrest`, `mattress`, etc.; and `rmd_type_id` is a string identifier indicating the interaction phase or relation type.

---


## Example Data Item

For `dynamic_000`, the corresponding files are:

```plaintext
layout/dynamic_000.yaml
image/dynamic_000.png
text_instruction.json["dynamic_000"]
```

The text instruction is:

```plaintext
Arrange the two boxes in suitable spots around the room to tidy up the space.
```

A model can use `image/dynamic_000.png` as the top-view visual observation, `text_instruction.json["dynamic_000"]` as the task command, and `layout/dynamic_000.yaml` as the structured scene representation.

---


## License and Asset Notice

This dataset is released for non-commercial research use under CC BY-NC-SA 4.0. The dataset-specific annotations, layouts, interaction plans, top-view images, text instructions, and simulation metadata are provided under this license. The included 3D meshes are processed assets derived from 3D-FUTURE / 3D-FRONT and remain subject to the original 3D-FUTURE terms of use. Users should comply with the original asset licenses and cite the corresponding sources when using the 3D assets.