README.md

---
license: apache-2.0
task_categories:
- robotics
tags:
- humanoid
- motion-tracking
- locomotion
- ff-master
- phc
viewer: false
---

# motionSample — FF Master motion references

Joint-space motion references for the **FF Master** humanoid (31 DoF), stored in the
**PHC-style pickle** format used by the humanoid motion-tracking codebase family
(PHC / H2O / OmniH2O / ASAP / HumanoidVerse).

Interactive viewer: **[Master Motion Sample Space](https://huggingface.co/spaces/faradayfuture/MotionSampleViewer)**

| | |
|---|---|
| Clips | 2 (one file each) |
| Frames | 2759 total |
| FPS | 120 (inferred — see below) |
| DoF | 31 |
| Robot | FF Master (URDF `x2_ultra`) |

**One file per clip** — they are not bundled together. `highjump` is trimmed to 5 consecutive
jumps (source frames 654–1589 of a 21-jump take); `jogging` is the full take.

| file | clip key | frames | duration | size |
|---|---|---|---|---|
| `jogging.pkl` | `jogging` | 1824 | 15.2 s | 1.3 MB |
| `highjump.pkl` | `highjump` | 935 | 7.8 s | 0.7 MB |

## Loading

Each file holds a `{clip_name: {...}}` dict with a single entry, so PHC-family loaders that
expect a dict-of-motions read a single file without any code change.

```python
import pickle
d = pickle.load(open("highjump.pkl", "rb"))
list(d)                            # ['highjump']

m = d["highjump"]
m["dof"].shape                     # (935, 31)    joint angles, rad
m["root_trans_offset"].shape       # (935, 3)     base position, m
m["root_rot"].shape                # (935, 4)     base orientation, xyzw
m["fps"]                           # 120
```

To use both at once, merge them:

```python
import glob, pickle
d = {}
for f in sorted(glob.glob("*.pkl")):
    d.update(pickle.load(open(f, "rb")))
list(d)                            # ['highjump', 'jogging']
```

## Keys

Key names are the **union** of what the PHC family reads. Each framework picks up the
subset it knows; the extras are inert.

| key | shape | read by |
|---|---|---|
| `root_trans_offset` | (T, 3) | all |
| `root_rot` | (T, 4) **xyzw** | all |
| `pose_aa` | (T, 1+31, 3) | PHC / H2O / OmniH2O |
| `dof` | (T, 31) | all |
| `fps` | int = 120 | all |
| `dof_pos` | (T, 31), same array as `dof` | ASAP / HumanoidVerse |
| `dof_vel` | (T, 31) | ASAP / HumanoidVerse |
| `root_lin_vel` / `root_ang_vel` | (T, 3) | ASAP / HumanoidVerse |
| `contacts` | (T, 2) left / right foot | — |
| `com_pos` | (T, 3) whole-body centre of mass, world frame | — |
| `total_mass` | float = 42.0 kg (from the URDF) | — |
| `dof_names` / `body_names` | list | — |
| `dof_axes` | (31, 3) | — |
| `quat_order` | `"xyzw"` | — |

### `pose_aa`

Per-body local rotation in axis-angle form, root first. For a 1-DoF revolute joint the
local rotation is a turn of `q` about the URDF `axis`, so the axis-angle vector is just
`axis * q`:

```
pose_aa[t, 0]     = axis-angle of root_rot
pose_aa[t, 1 + j] = dof_axes[j] * dof[t, j]
```

`dof_axes` ships with the file, so `pose_aa` can be rebuilt or cross-checked without the URDF.

### Conventions

- **Quaternions are xyzw** (PHC / Isaac). MuJoCo and USD use wxyz — reorder when crossing over.
- **z up, soles at z = 0.** Ground alignment uses the *stance-phase median* height, not a
  per-frame clamp (a per-frame clamp would flatten the high jump's flight phase). After
  alignment the stance-phase foot height IQR is within ±0.5 cm.
- **Velocities are stored**, low-passed at 20 Hz zero-phase. Most loaders finite-difference
  them at load time instead, which yields noisier values than these — pick one and be consistent.

## Known characteristics and limits

These clips are human motion capture retargeted onto the Master kinematics — no physics engine
was involved in producing them. **They have been run on the real robot**: a whole-body
motion-tracking controller follows them successfully on hardware.

Everything below describes the **reference trajectory itself**, not what the robot can do. A
tracking controller *approximates* a reference; it does not replay it frame-for-frame. So
"the reference carries 0.72 g through flight" and "it runs on the real robot" are both true and
not in conflict. Read this section before using a clip as a **per-frame** tracking target, or
before assuming a number in it describes the machine.

### Flight-phase gravity is 0.72 g

Fitting a parabola to the centre-of-mass height over the middle two thirds of each of
`highjump`'s 5 flight phases gives a vertical acceleration of **−7.090 ± 0.057 m/s²**, not
−9.807 — a consistent **0.723 g**. The spread across phases is 0.8 %, so this is systematic,
not noise, and it is a property of the retargeted reference rather than of the robot.

The likely cause is retargeting that rescaled the motion **spatially** to the robot's
proportions while keeping the human's **original timing**. Froude similarity requires time to
scale as √s when length scales by s; s = 0.723 implies the timeline should be compressed by
√0.723, i.e. replayed at 120 × 1.176 ≈ **141 Hz**. That reading is self-consistent: s = 0.723
against the URDF's 0.602 m standing pelvis height implies a 0.833 m human pelvis, i.e. a
subject about 1.57 m tall — a plausible capture subject.

**This dataset ships at the source timing, un-retimed.** Retiming was tested and does fix the
gravity (−9.843 ± 0.080 m/s², 0.37 % residual), but it pushes a few joints marginally past the
URDF velocity limits (`jogging` 1/31 at 106 %, `highjump` 3/31 at 105 %) and raises the jogging
cadence to 195 steps/min. To apply it yourself: resample the timeline by 1.176 and leave the
joint angles untouched.

### `jogging`'s contact pattern is a walk, not a run

Cadence is fine (166 steps/min) and swing clearance reaches 22 cm, but each foot is loaded
**79 %** of the time, double support is **65.6 %**, and flight phases have a median of only
**17 ms**. Real running has a duty factor below 0.5 and 100–200 ms of flight. Good enough as an
AMP style prior; per-frame tracking will not teach running dynamics.

`highjump`'s phase structure is sound: 73.8 % double support, 25.5 % airborne, 5 flight phases
with a 400 ms median.

### Other limits

- Residual ground penetration at the deepest frames: −1.9 cm (`jogging`), −3.6 cm (`highjump`).
- **Base pose is not robot-measurable.** It comes from the capture system, so it is valid as an
  offline reference only — never as an observation the robot could produce on its own.
- Joint angles are all within the URDF position limits, and joint velocities stay inside the
  URDF velocity limits (0/31 violations, peaking at 95 % of the limit). So the clips are
  **kinematically legal**; the trajectories are just not rigid-body-consistent on their own,
  which is normal for retargeted references and is what the tracking controller absorbs.

## Validation

```bash
python3 validate.py    # keys, shapes, quaternion norms, pose_aa round-trip, contact phases,
                       # and flight-phase gravity computed from the shipped com_pos
```

## Why 120 Hz

The source files carry no sample rate. 120 Hz is inferred from `jogging`'s cadence: the knee
angle's dominant period is 80–86 frames, which at 120 Hz is 166–180 steps/min — the normal
jogging band. 60 Hz would give ~87 steps/min (a stroll) and 240 Hz ~340 (impossible). The
gravity result above suggests the *dynamically* correct playback rate is ~141 Hz, so treat
120 Hz as the source timing rather than a physically validated one.