File size: 6,428 Bytes
083b02d f5930b6 083b02d f5930b6 083b02d f5930b6 083b02d f5930b6 083b02d 69a0a33 083b02d f5930b6 083b02d f5930b6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | """Which way is up — declared, and converted as one piece or not at all.
WHAT THE DATA IS, AND WHAT IT WAS
The release is now **Z-up, right-handed**: the table normal in world
coordinates is (0.053, -0.056, 0.997), 4.4 degrees off +z, and both the pose
rotations and `T_mocap_to_cam` have determinant +1.
OptiTrack RECORDS Y-up. The release used to ship that unchanged and said so
nowhere, which is the worse half of the problem: robotics code overwhelmingly
assumes Z-up, and a reader taking `pose[2]` as height got a horizontal
coordinate with nothing to complain — plausible numbers, fine-looking plots,
and an error that surfaces only as a model that never learns which way gravity
points.
Poses and extrinsics were converted together, so every projection is
unchanged and every rendered preview, overlay and clip stayed valid. Only the
numbers moved. `ZUP_TO_YUP` converts back for anything that still wants the
raw OptiTrack convention.
THE CONVERSION, AND THE TRAP IN IT
Y-up to Z-up preserving handedness is a rotation of -90 degrees about x:
(x, y, z) -> (x, -z, y)
There are two right-handed candidates; this is the one that sends UP to **+z**
rather than -z. The other, R_x(+90), is equally right-handed and puts the table
normal at (0.053, 0.056, -0.997) — upside down, det still +1, and no assertion
about handedness would catch it.
THE TRAP: a world-frame rotation must be applied to the POSES **and** to
`T_mocap_to_cam` together. Applied to one only, every projection moves and
nothing raises. So this module converts a BUNDLE — poses and cameras — and
`scripts/test_frames.py` asserts that projections are bit-identical afterwards.
Invariance is the test: if a pixel moves, the conversion was half-applied.
The gel centre is in the sensor's own RIGID frame and is therefore untouched.
"""
from __future__ import annotations
import numpy as np
UP_AXIS_RECORDED = "z"
UP_AXIS_ROBOTICS = "z"
# (x, y, z)_yup -> (x, -z, y)_zup. det = +1, and it sends +y to +z.
YUP_TO_ZUP = np.array([[1.0, 0.0, 0.0],
[0.0, 0.0, -1.0],
[0.0, 1.0, 0.0]])
ZUP_TO_YUP = YUP_TO_ZUP.T
def _R(to_zup: bool) -> np.ndarray:
return YUP_TO_ZUP if to_zup else ZUP_TO_YUP
def convert_poses(poses7, to_zup: bool = True) -> np.ndarray:
"""Rotate a pose array into the other up-convention. (N, 7) or (7,).
Positions rotate; orientations PRE-multiply, because this is a change of
the world frame, not a motion of the body.
"""
from scipy.spatial.transform import Rotation
p = np.atleast_2d(np.asarray(poses7, float)).copy()
M = _R(to_zup)
ok = np.isfinite(p).all(1) & (np.linalg.norm(p[:, 3:7], axis=1) > 0.5)
# A column can be entirely untracked -- pushT never tracked an object
# body, so its object_pose is NaN from end to end. scipy raises "Found
# zero norm quaternions" on the resulting EMPTY array, and that exception
# is why the pushT half of the release stayed unconverted while the
# motherboard half went Z-up. Nothing to rotate is not an error.
if ok.any():
p[ok, :3] = p[ok, :3] @ M.T
p[ok, 3:7] = (Rotation.from_matrix(M)
* Rotation.from_quat(p[ok, 3:7])).as_quat()
return p[0] if np.ndim(poses7) == 1 else p
def convert_calibration(cal: dict, to_zup: bool = True) -> dict:
"""The same rotation applied to every camera extrinsic. Returns a copy.
`T_mocap_to_cam` maps mocap -> camera. Rotating the mocap frame by M means
the new matrix is `T @ M^-1`, so that `T_new @ (M @ x) == T @ x` and every
projection is unchanged. Getting this inverse backwards is the other way to
break it silently; the invariance test catches that too.
"""
M = _R(to_zup)
out = {k: v for k, v in cal.items()}
out["up_axis"] = "z" if to_zup else "y"
out["cams"] = {}
for name, c in cal["cams"].items():
T = np.asarray(c["T_mocap_to_cam"], float).copy()
T[:3, :3] = T[:3, :3] @ M.T # M^-1 == M.T for a rotation
out["cams"][name] = {**c, "T_mocap_to_cam": T}
return out
def to_zup(poses7, cal: dict):
"""Convert a pose array and its calibration together. Returns (poses, cal).
Use this rather than the two halves: the whole point is that they move as
one piece.
"""
return convert_poses(poses7, True), convert_calibration(cal, True)
def require_up_axis(cal: dict, expected: str = UP_AXIS_RECORDED, where: str = ""):
"""Raise unless `cal` declares the up-axis convention `expected`.
WHY THIS EXISTS. Poses and calibration are two halves of one convention,
and they are read from two paths. Rotating only one half leaves every
self-consistency check green -- projections still recompute exactly from
the same wrong matrix -- while the pictures are wrong. That happened: the
probe test set drew its poses from the Z-up release and its calibration
from a Y-up tree, and every overlay was a median 153 px off.
So the halves must be paired loudly, not by convention. A file with no
declaration is treated as the pre-conversion Y-up it was.
"""
got = cal.get("up_axis")
if got != expected:
raise ValueError(
f"calibration up-axis mismatch{' in ' + where if where else ''}: "
f"declared {got!r}, need {expected!r}. Poses and calibration must "
f"come from the same release. A missing declaration means a "
f"pre-conversion Y-up file -- convert it with "
f"scripts/convert_release_zup.py, or take the calibration from "
f"the release the poses came from.")
return cal
def as_up_axis(cal: dict, want: str) -> dict:
"""Return `cal` in the convention `want`, converting only if it must.
`require_up_axis` refuses a mismatch; this one repairs it. Use it when the
caller genuinely knows which convention its POSES are in -- a raw-HDF5
reader wants "y", a release reader wants "z" -- and should not have to care
which directory the calibration happened to come from.
An undeclared calibration is the pre-conversion Y-up it was, so this
converts it rather than trusting it.
"""
if want not in ("y", "z"):
raise ValueError(f"up axis must be 'y' or 'z', got {want!r}")
got = cal.get("up_axis") or "y"
if got == want:
return cal
return convert_calibration(cal, to_zup=(want == "z"))
|