# Schema

One row = one **(motion, robot)** pair. `T` is the row's `n_frames`.

## Identity and provenance
| column | type | meaning |
|---|---|---|
| `clip_id` | string | `<dataset>/<robot>/<subject>`, unique |
| `dataset` | string | `omomo` \| `parahome` \| `neuraldome` \| `corolehoi` \| `imhd2` |
| `robot` | string | `unitree_g1` (29 DoF) \| `unitree_h2` (31 DoF) |
| `subject` | string | source clip stem, verbatim from the source dataset |
| `object` | string | object mesh name; **not unique across datasets** — see README |
| `object_model_path` | string | the URDF this row was solved against, dataset-scoped and relative (e.g. `neuraldome/_assets/monitor.urdf`). **OMOMO's 13 meshes ship here** under `assets/objects/` (InterMimic, MIT); the other four datasets' are not ours to redistribute. [`docs/DATA.md`](https://github.com/leggedrobotics/hoi-retarget/blob/main/docs/DATA.md) in the code repo says how to obtain each one, and `hoi-retarget-stage-object` writes the URDF and the `sample_points.npy` the floor-height check needs |
| `projection_mode` | string | pipeline metadata (`contact`) |
| `schema_version` | int64 | 2: each clip is retargeted from its subject's own recorded skeleton |

## Timing and scale
| column | type | meaning |
|---|---|---|
| `n_frames` | int64 | `T` |
| `fps` | float | 30.0 throughout |
| `duration_s` | float | `n_frames / fps` |
| `object_scale` | float | object mesh (geometry) scale: 0.83 on the G1, 1.0 on the H2. The object trajectory is scaled separately, by the robot's root scale (G1 0.83, H2 1.08444) |
| `object_aug_scale` | float | extra augmentation factor, 1.0 unless augmented |
| `scale_object_mesh`, `scale_object_trajectory` | bool | whether the mesh (G1 true, H2 false) and the trajectory (true for both) were scaled |
| `video` | Video(decode=False) | mp4 preview of this row's motion, 320x320; CoRoleHOI rows show both robots (this row's robot in the normal colour, the partner tinted). Undecoded, so a cell is `{bytes, path}` and reading rows needs no video decoder; `cast_column("video", Video())` (`from datasets import Video`) with `torchcodec` installed gives frames instead |

## Quality control
| column | type | meaning |
|---|---|---|
| `qc_pass` | bool | see the rule in the README; false when `qc_flags` is non-empty |
| `qc_flags` | list[string] | `wrist_sustained` (runfrac > 0.50), `body_folded` (trunk folds >= 50 deg further from vertical than the human's, or >= 15 deg alongside >= 15 % joint saturation), `object_floating` (set by hand: the IMHD² skateboard floats ~25 cm above the floor in the source) — empty when passing |
| `wrist_runfrac` | float | longest run with a wrist joint beyond 80 % of its own half-range, as a fraction of the clip |
| `dj_max_deg` | float | peak per-frame joint displacement, deg/frame. Descriptive only; no QC rule uses it |
| `palm_contact` | float | fraction of that excursion window in which the matching palm is flagged in contact. `NaN` when the clip has no excursion at all. Descriptive only; no QC rule uses it |

## Sequence and collaboration

Every row answers these, whether or not it is collaborative — a solo clip is a sequence of one,
not a row with holes, so `groupby("sequence_id")` needs no special case.

| column | type | meaning |
|---|---|---|
| `sequence_id` | string | the captured event. Robot-agnostic, so grouping by it returns every row from that capture — for a two-actor sequence that is 4 rows (2 actors x 2 robots) |
| `n_actors` | int32 | 1 or 2 |
| `actor_role` | string | `solo`, or `female` / `male` |
| `partner_clip_id` | string | the same-robot partner's `clip_id`; **empty string** (not null) when there is none |
| `partner_z_offset_cm` | float32 | signed: **this row's object z minus the partner's**. Subtract it from this row's `object_pos` z to land in the partner's frame. `0.0` when solo |
| `pair_composable` | bool | `abs(partner_z_offset_cm) <= 3.0`; `true` when solo |

**Why the offset exists.** CoRoleHOI sequences were captured with two actors and solved one at a
time. `object_scale` is identical within every pair, but the two halves disagree about where the
floor is: the source preprocessing estimates each actor's floor from that actor's own first frames.
The disagreement is a **constant rigid translation**, not a scale error and not a drift: horizontally
a fixed 0.23 cm (G1) / 0.30 cm (H2) in every pair, and vertically 0 to 37.6 cm on the G1 and 0 to
49.1 cm on the H2. It is stored per row because it passes through each robot's trajectory scale
(G1 0.83, H2 1.08444); the H2 offset is typically about 1.3x the G1 offset of the same pair, but the
per-pair ratio varies (0.5 to 2.1), so read each robot's own value.

```python
pair = ds.filter(lambda r: r["sequence_id"] == "corolehoi/100_camera__0_191"
                           and r["robot"] == "unitree_g1")
# align the partner into this row's frame before composing one scene:
#   partner_object_pos[:, 2] += row["partner_z_offset_cm"] / 100.0
```

912 of 13,904 rows are collaborative (228 CoRoleHOI pairs x 2 robots). The other four datasets are
single-actor.

## Trajectories
All are lists of per-frame values, length `T`. Reconstruct with
`np.array([np.asarray(x) for x in row[col]])`.

| column | shape | meaning |
|---|---|---|
| `root_pos` | (T, 3) | floating-base position, metres, world frame |
| `root_rot` | (T, 4) | base orientation, quaternion **wxyz** |
| `dof_pos` | (T, ndof) | joint angles, radians; order given by `dof_names` |
| `object_pos` | (T, 3) | object position, metres |
| `object_rot` | (T, 4) | object orientation, quaternion **wxyz** |
| `object_vel` | (T, 3) | object linear velocity, m/s |
| `object_pos_realsize_ref` | (T, 3) | object position before scaling to the robot's reach |
| `object_min_height_per_frame` | (T,) | lowest point of the object above the floor, metres |

## Contact
| column | shape | meaning |
|---|---|---|
| `contact_link_names` | list[string] | the links contact is tracked on (4 for the G1: two palm pads, two ankles) |
| `per_link_contact_flags` | (T, n_links) bool | which of those links touch the object each frame |
| `fixed_contact_points_per_frame_in_object_frame` | (T, n_links, 3) | the point on the object each link is holding, **in the object frame**. `NaN` where the link is not in contact — this is the no-contact sentinel, not corruption |
| `robot_foot_ground_contact_flags` | (T, 2) bool | left/right foot on the ground |
| `object_contact_sequence` | (T,) int8 | object in contact with the human/robot |
| `object_ground_contact_sequence` | (T,) int8 | object resting on the ground |
| `object_near_floor_flags` | (T,) bool | object within a floor-proximity threshold |

## Easy to get wrong
* `object` is **not** a key. Three different chairs share the name `chair`; join on `object_model_path` or `(dataset, object)`.
* Quaternions are **wxyz**, not xyzw.
* `dof_names` differs between robots (29 vs 31 entries). Never index `dof_pos` by a hard-coded position — look the joint up by name.
* The entries named `baseball` are baseball **bats**.