# Joint-mocap frame → nerfstudio frame transforms

All point clouds in this folder live in the **joint mocap frame**, defined
as:

- **Origin** at the center of the ArUco tag on the floor.
- **+z** points up (tag normal).
- **+x** is along the tag's printed **+y** direction (a +90° yaw about z
  relative to the tag's intrinsic axes, applied during dataset construction).
- **+y** completes the right-handed frame (`= z × x`).

The **left scene's mocap frame** is the reference. The right scene's
points were aligned to this frame via ICP — that correction is included in
the `*_aligned_mocap` PLYs and in the `joint_mocap_to_nerf_4x4` for the
right scene below.

## Files in this folder

| file | what it contains |
|---|---|
| `left_gate.ply`, `right_gate.ply` | gate point clouds in joint mocap |
| `left_table.ply`, `right_table.ply` | table point clouds in joint mocap |
| `objects_summary.json` | AABBs, polygon / plane cut definitions per object |
| `joint_mocap_to_nerf.json` | the transforms documented here |
| `right_to_left_icp.json` | raw ICP output for the right→joint correction |

## The transform chain

For a single point `p_joint = [x, y, z]` in the **joint mocap frame**, the
chain that maps it into each scene's **nerfstudio internal frame** is:

```
        joint_mocap
            │ T_icp_inv     (identity for the left scene)
            ▼
        scene_mocap
            │ M_dataparser = [[s·R, s·t], [0, 1]]
            ▼            (p_nerf = s · (R · p_mocap + t))
        nerfstudio internal
```

For the **left** scene, `joint_mocap == left_mocap`, so the ICP step is the
identity and the only transform is the dataparser.

For the **right** scene, the ICP correction is applied first (joint →
right's original mocap), then the right scene's dataparser carries it the
rest of the way into right's nerf frame.

`joint_mocap_to_nerf.json` exposes both the composed 4×4 (everything in
one matrix per scene, ready to apply with a single matmul) and the
building blocks if you want to inspect or recompose.

## Quick usage (Python)

```python
import json, numpy as np
import open3d as o3d

ROOT = "/home/javier/Downloads/polycam_gsplat/object_pcds/objects_final"
xforms = json.load(open(f"{ROOT}/joint_mocap_to_nerf.json"))

def to_homogeneous(p_xyz):
    return np.array([*p_xyz, 1.0])

# --- joint mocap -> nerf for either scene ---------------------------------
def joint_to_nerf(p_joint, scene):
    """scene in {"left_gate_new", "right_gate_new"}; p_joint is (3,)."""
    M = np.asarray(xforms["scenes"][scene]["joint_mocap_to_nerf_4x4"])
    return (M @ to_homogeneous(p_joint))[:3]

# --- nerf -> joint mocap --------------------------------------------------
def nerf_to_joint(p_nerf, scene):
    M = np.asarray(xforms["scenes"][scene]["nerf_to_joint_mocap_4x4"])
    return (M @ to_homogeneous(p_nerf))[:3]

# Example: tag origin
print(joint_to_nerf([0, 0, 0], "left_gate_new"))   # ≈ (-0.157, -0.080, -0.188)
print(joint_to_nerf([0, 0, 0], "right_gate_new"))  # ≈ (-0.112, 0.031, -0.201)
```

## Mapping a whole point cloud

```python
pcd = o3d.io.read_point_cloud(f"{ROOT}/left_table.ply")  # already in joint mocap
M = np.asarray(xforms["scenes"]["left_gate_new"]["joint_mocap_to_nerf_4x4"])
pcd_in_nerf = o3d.geometry.PointCloud(pcd).transform(M)
```

For the **right** scene's PLYs in this folder (which are already
ICP-aligned to joint mocap), use the right scene's
`joint_mocap_to_nerf_4x4`. Internally that matrix is the composition
`M_right_dataparser @ T_icp_inv`, so it correctly accounts for the ICP
correction.

## Bypassing joint mocap and going directly between the two nerf frames

```python
# point in the right scene's nerf frame -> left scene's nerf frame
M_right_to_joint = np.asarray(xforms["scenes"]["right_gate_new"]["nerf_to_joint_mocap_4x4"])
M_joint_to_left  = np.asarray(xforms["scenes"]["left_gate_new"]["joint_mocap_to_nerf_4x4"])
p_left_nerf = (M_joint_to_left @ M_right_to_joint @ to_homogeneous(p_right_nerf))[:3]
```

## Where each field comes from

- `right_to_joint_icp.transformation_4x4` is the SE(3) returned by
  `align_right_to_left_icp.py` (multi-scale point-to-plane ICP, voxel
  schedule 0.10 → 0.05 → 0.02 m, final inlier RMSE ≈ 0.028 m).
- `scenes.<scene>.dataparser` is read from each splat's
  `dataparser_transforms.json` produced at training time
  (`mocap_outputs/.../sagesplat/<timestamp>/dataparser_transforms.json`).
  The formula is `p_nerf = scale * (R · p_mocap + t)`; we fold scale
  into the 4×4 via `M = [[s·R, s·t], [0, 1]]`.
- `scenes.<scene>.joint_mocap_to_nerf_4x4` is what you almost always
  want. For the left scene it equals `M_dataparser`; for the right
  scene it equals `M_dataparser @ T_icp_inv`.

## Sanity check

A round-trip of any `p_joint` through `joint_mocap_to_nerf_4x4` and back
through `nerf_to_joint_mocap_4x4` should return the original within
floating-point noise. The build script asserts this for the tag origin
before writing the JSON.