cozyclay 1.9.0 → 2.0.0

package/tools/bench/obs/ground.mjs

@@ -0,0 +1,294 @@
+const FOOT_NAMES = ["L_ankle", "R_ankle", "L_foot", "R_foot"];
+const ANKLE_INDEX = { L_ankle: 15, R_ankle: 16 };
+const LOGIT_INDEX = { L_ankle: 0, L_foot: 1, R_ankle: 2, R_foot: 3 };
+const OPPOSITE = { L_ankle: "R_ankle", R_ankle: "L_ankle" };
+
+function valuesOf(value) {
+	return value?.data ?? value;
+}
+
+function flattenMatrix(matrix) {
+	return Array.isArray(matrix?.[0]) ? matrix.flat() : Array.from(matrix ?? []);
+}
+
+function matrix3(matrix, name) {
+	const flat = flattenMatrix(matrix);
+	if (flat.length !== 9 || flat.some((value) => !Number.isFinite(Number(value)))) throw new Error(`${name}: expected a finite 3x3 matrix`);
+	return flat.map(Number);
+}
+
+function vector3(value, name) {
+	const data = valuesOf(value);
+	if (!data || data.length !== 3 || Array.from(data).some((item) => !Number.isFinite(Number(item)))) throw new Error(`${name}: expected a finite 3-vector`);
+	return Array.from(data, Number);
+}
+
+function frameVectors(value, frames, name) {
+	const data = valuesOf(value);
+	if (Array.isArray(data) && data.length === frames && data.every((row) => Array.isArray(row))) {
+		return data.map((row, frame) => {
+			if (row.length !== 3 || row.some((item) => !Number.isFinite(Number(item)))) throw new Error(`${name}[${frame}]: expected a finite 3-vector`);
+			return row.map(Number);
+		});
+	}
+	if (!data || data.length !== frames * 3) throw new Error(`${name}: expected [${frames}, 3]`);
+	return Array.from({ length: frames }, (_, frame) => Array.from(data.slice(frame * 3, frame * 3 + 3), Number));
+}
+
+function frameKeypoints(value, frames) {
+	const data = valuesOf(value);
+	if (Array.isArray(data) && data.length === frames && data.every((row) => Array.isArray(row))) {
+		return data.map((row, frame) => {
+			if (row.length < 17 || row.some((point) => !Array.isArray(point) || point.length < 3)) throw new Error(`kp2d[${frame}]: expected at least 17 [x, y, confidence] points`);
+			return row.map((point) => point.slice(0, 3).map(Number));
+		});
+	}
+	if (!data || data.length !== frames * 17 * 3) throw new Error(`kp2d: expected [${frames}, 17, 3]`);
+	return Array.from({ length: frames }, (_, frame) => Array.from({ length: 17 }, (_, joint) => {
+		const offset = (frame * 17 + joint) * 3;
+		return Array.from(data.slice(offset, offset + 3), Number);
+	}));
+}
+
+function frameLogits(value, frames) {
+	const data = valuesOf(value);
+	if (Array.isArray(data) && data.length === frames && data.every((row) => Array.isArray(row))) {
+		return data.map((row, frame) => {
+			if (row.length < 6) throw new Error(`static_conf_logits[${frame}]: expected 6 logits`);
+			return row.slice(0, 6).map(Number);
+		});
+	}
+	if (!data || data.length !== frames * 6) throw new Error(`static_conf_logits: expected [${frames}, 6]`);
+	return Array.from({ length: frames }, (_, frame) => Array.from(data.slice(frame * 6, frame * 6 + 6), Number));
+}
+
+function footPoint(footW, frame, name) {
+	if (Array.isArray(footW)) {
+		const row = footW[frame];
+		if (Array.isArray(row)) {
+			const index = FOOT_NAMES.indexOf(name);
+			return row[index];
+		}
+		return row?.[name];
+	}
+	return footW?.[name]?.[frame];
+}
+
+function normalizedFootFrames(footW, frames) {
+	return Array.from({ length: frames }, (_, frame) => Object.fromEntries(FOOT_NAMES.map((name) => {
+		const point = footPoint(footW, frame, name);
+		return [name, point && point.length === 3 ? Array.from(point, Number) : null];
+	})));
+}
+
+function normalizeCamera(camera) {
+	if (!camera) throw new Error("camera: expected K, R_c2w, and t_c2w");
+	const K = matrix3(camera.K ?? [[camera.fx, 0, camera.cx], [0, camera.fy, camera.cy], [0, 0, 1]], "camera.K");
+	let rotation = camera.R_c2w ?? camera.Rc2w;
+	let translation = camera.t_c2w ?? camera.tc2w;
+	if (!rotation && camera.worldToCamera) {
+		const worldToCamera = matrix3(camera.worldToCamera, "camera.worldToCamera");
+		rotation = [worldToCamera[0], worldToCamera[3], worldToCamera[6], worldToCamera[1], worldToCamera[4], worldToCamera[7], worldToCamera[2], worldToCamera[5], worldToCamera[8]];
+		const tW2C = [worldToCamera[3], worldToCamera[7], worldToCamera[11]];
+		translation = [
+			-(rotation[0] * tW2C[0] + rotation[1] * tW2C[1] + rotation[2] * tW2C[2]),
+			-(rotation[3] * tW2C[0] + rotation[4] * tW2C[1] + rotation[5] * tW2C[2]),
+			-(rotation[6] * tW2C[0] + rotation[7] * tW2C[1] + rotation[8] * tW2C[2]),
+		];
+	}
+	return { K, R_c2w: matrix3(rotation, "camera.R_c2w"), t_c2w: vector3(translation, "camera.t_c2w") };
+}
+
+function pixelRay(u, v, camera) {
+	const { K, R_c2w, t_c2w } = camera;
+	const cameraDirection = [(u - K[2]) / K[0], (v - K[5]) / K[4], 1];
+	const direction = [
+		R_c2w[0] * cameraDirection[0] + R_c2w[1] * cameraDirection[1] + R_c2w[2] * cameraDirection[2],
+		R_c2w[3] * cameraDirection[0] + R_c2w[4] * cameraDirection[1] + R_c2w[5] * cameraDirection[2],
+		R_c2w[6] * cameraDirection[0] + R_c2w[7] * cameraDirection[1] + R_c2w[8] * cameraDirection[2],
+	];
+	const length = Math.hypot(...direction);
+	return { origin: t_c2w, direction: direction.map((item) => item / length) };
+}
+
+function median(values) {
+	if (!values.length) return 0;
+	const sorted = values.slice().sort((a, b) => a - b);
+	const middle = Math.floor(sorted.length / 2);
+	return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+
+function sigmoid(logit) {
+	if (!Number.isFinite(logit)) return 0;
+	if (logit >= 0) {
+		const e = Math.exp(-logit);
+		return 1 / (1 + e);
+	}
+	const e = Math.exp(logit);
+	return e / (1 + e);
+}
+
+function translatePoint(point, correction) {
+	return [point[0] + correction[0], point[1], point[2] + correction[2]];
+}
+
+function shiftJoints(jointsW, corrections) {
+	if (!Array.isArray(jointsW)) return jointsW;
+	return jointsW.map((frame, index) => Array.isArray(frame) ? frame.map((point) => point?.length === 3 ? translatePoint(point, corrections[index]) : point) : frame);
+}
+
+function shiftFeet(footW, corrections, frames) {
+	if (Array.isArray(footW)) return footW.map((frame, index) => Array.isArray(frame) ? frame.map((point) => point?.length === 3 ? translatePoint(point, corrections[index]) : point) : Object.fromEntries(FOOT_NAMES.map((name) => [name, frame?.[name]?.length === 3 ? translatePoint(frame[name], corrections[index]) : frame?.[name]])));
+	if (!footW || typeof footW !== "object") return footW;
+	return Object.fromEntries(Object.entries(footW).map(([name, track]) => [name, Array.isArray(track) ? track.map((point, index) => point?.length === 3 ? translatePoint(point, corrections[index]) : point) : track]));
+}
+
+function interpolateCorrections(samples, frames) {
+	const corrections = Array.from({ length: frames }, () => [0, 0, 0]);
+	const contactMask = samples.map((items) => items.length > 0);
+	const runs = [];
+	for (let frame = 0; frame < frames;) {
+		if (!contactMask[frame]) {
+			frame += 1;
+			continue;
+		}
+		const start = frame;
+		while (frame < frames && contactMask[frame]) frame += 1;
+		const end = frame - 1;
+		const anchor = [0, 0, 0];
+		for (let axis of [0, 2]) anchor[axis] = median(samples.slice(start, end + 1).flatMap((items) => items.map((sample) => sample[axis])));
+		runs.push({ start, end, anchor, samples: samples.slice(start, end + 1).flat().length });
+		for (let at = start; at <= end; at += 1) corrections[at] = anchor.slice();
+	}
+	if (!runs.length) return { corrections, runs };
+	for (let index = 0; index + 1 < runs.length; index += 1) {
+		const left = runs[index], right = runs[index + 1];
+		const span = right.start - left.end;
+		for (let frame = left.end + 1; frame < right.start; frame += 1) {
+			const weight = (frame - left.end) / span;
+			corrections[frame] = [
+				left.anchor[0] + (right.anchor[0] - left.anchor[0]) * weight,
+				0,
+				left.anchor[2] + (right.anchor[2] - left.anchor[2]) * weight,
+			];
+		}
+	}
+	for (let frame = 0; frame < runs[0].start; frame += 1) corrections[frame] = runs[0].anchor.slice();
+	const last = runs[runs.length - 1];
+	for (let frame = last.end + 1; frame < frames; frame += 1) corrections[frame] = last.anchor.slice();
+	return { corrections, runs };
+}
+
+function footSpeed(feet, name, frame, frames, fps) {
+	const before = feet[Math.max(0, frame - 1)][name], after = feet[Math.min(frames - 1, frame + 1)][name];
+	const span = (Math.min(frames - 1, frame + 1) - Math.max(0, frame - 1)) / fps;
+	return before?.every(Number.isFinite) && after?.every(Number.isFinite) && span > 0 ? Math.hypot(after[0] - before[0], after[2] - before[2]) / span : Infinity;
+}
+
+/**
+ * Correct a world trajectory using 2D ankle observations at static floor
+ * contacts. Corrections are XZ translations represented as [dx, 0, dz].
+ * Optional `jointsW` and `footW` inputs receive the same rigid translation.
+ */
+export function correctTrajectory({
+	rootW,
+	footW,
+	jointsW,
+	kp2d,
+	static_conf_logits: staticConfLogits,
+	camera,
+	ankleHeight,
+	contactProbability = 0.8,
+	maxFootHeight = 0.12,
+	minKeypointConfidence = 0.3,
+	// "kinematic" is the default. "hybrid": stance when EITHER GVHMR's static-contact logit OR the
+	// kinematic test says so. "kinematic" (default): lower foot, near its own low height,
+	// nearly still (absolutely, or relative to the other foot). GVHMR's logits are
+	// weak on the part-coloured mannequin (walk: right foot never exceeds 0.8), so
+	// kinematics carry real clips; logits carry clips whose planted foot still
+	// slides in the estimate. "logits": logits only.
+	stanceMode = "kinematic",
+	fps = 24,
+	stanceHeightMargin = 0.04,
+	maxStanceSpeed = 0.25,
+	minStanceFrames = 3,
+} = {}) {
+	if (!Array.isArray(rootW) || !rootW.length) throw new Error("rootW: expected at least one frame");
+	if (!Number.isFinite(ankleHeight)) throw new Error("ankleHeight: expected a finite number");
+	if (!(contactProbability > 0 && contactProbability < 1)) throw new Error("contactProbability: expected a value in (0, 1)");
+	if (!(maxFootHeight > 0) || !Number.isFinite(maxFootHeight)) throw new Error("maxFootHeight: expected a positive number");
+	if (!(minKeypointConfidence >= 0) || !Number.isFinite(minKeypointConfidence)) throw new Error("minKeypointConfidence: expected a nonnegative number");
+	const frames = rootW.length;
+	const roots = frameVectors(rootW, frames, "rootW");
+	const feet = normalizedFootFrames(footW, frames);
+	const keypoints = frameKeypoints(kp2d, frames);
+	const logits = frameLogits(staticConfLogits, frames);
+	const intrinsics = normalizeCamera(camera);
+	const samples = Array.from({ length: frames }, () => []);
+	const contactByFoot = Object.fromEntries(Object.keys(OPPOSITE).map((name) => [name, []]));
+	if (!["hybrid", "kinematic", "logits"].includes(stanceMode)) throw new Error(`stanceMode: expected "hybrid", "kinematic" or "logits", got ${stanceMode}`);
+	const stance = Object.fromEntries(Object.keys(OPPOSITE).map((name) => {
+		const heights = feet.map((row) => row[name]?.[1]).filter(Number.isFinite).sort((a, b) => a - b);
+		const low = heights.length ? heights[Math.floor(heights.length * 0.1)] : NaN;
+		const flags = Array.from({ length: frames }, (_, frame) => {
+			const point = feet[frame][name];
+			const opposite = feet[frame][OPPOSITE[name]];
+			const keypoint = keypoints[frame][ANKLE_INDEX[name]];
+			const base = point?.every(Number.isFinite) && opposite?.every(Number.isFinite) && keypoint?.every(Number.isFinite) && keypoint[2] >= minKeypointConfidence && point[1] <= opposite[1];
+			if (!base) return false;
+			const logitOffset = LOGIT_INDEX[name];
+			const staticProbability = Math.max(sigmoid(logits[frame][logitOffset]), sigmoid(logits[frame][logitOffset + 1]));
+			const byLogits = staticProbability > contactProbability && point[1] < maxFootHeight;
+			if (stanceMode === "logits") return byLogits;
+			if (stanceMode === "hybrid" && byLogits) return true;
+			// The planted foot is the slower of the two, or absolutely still. A
+			// relative test survives the very error G3 corrects: a mis-scaled
+			// trajectory makes even the stance foot slide in world space.
+			const speed = footSpeed(feet, name, frame, frames, fps);
+			const otherSpeed = footSpeed(feet, OPPOSITE[name], frame, frames, fps);
+			return point[1] <= low + stanceHeightMargin && (speed < maxStanceSpeed || speed < 0.5 * otherSpeed);
+		});
+		// Short flickers are not a planted foot: keep runs of at least minStanceFrames.
+		for (let start = 0; start < frames;) {
+			if (!flags[start]) { start += 1; continue; }
+			let end = start;
+			while (end + 1 < frames && flags[end + 1]) end += 1;
+			if (end - start + 1 < minStanceFrames) for (let i = start; i <= end; i += 1) flags[i] = false;
+			start = end + 1;
+		}
+		return [name, flags];
+	}));
+	for (let frame = 0; frame < frames; frame += 1) {
+		for (const name of Object.keys(OPPOSITE)) {
+			const point = feet[frame][name];
+			const keypoint = keypoints[frame][ANKLE_INDEX[name]];
+			if (!stance[name][frame]) continue;
+			const ray = pixelRay(keypoint[0], keypoint[1], intrinsics);
+			if (Math.abs(ray.direction[1]) < 1e-10) continue;
+			const distance = (ankleHeight - ray.origin[1]) / ray.direction[1];
+			if (!(distance > 0) || !Number.isFinite(distance)) continue;
+			const observed = [ray.origin[0] + distance * ray.direction[0], ankleHeight, ray.origin[2] + distance * ray.direction[2]];
+			samples[frame].push([observed[0] - point[0], 0, observed[2] - point[2]]);
+			contactByFoot[name].push(frame);
+		}
+	}
+	const { corrections, runs } = interpolateCorrections(samples, frames);
+	const correctedRoot = roots.map((point, frame) => translatePoint(point, corrections[frame]));
+	const result = {
+		rootW: correctedRoot,
+		corrections,
+		contactFrames: samples.flatMap((items, frame) => items.length ? [frame] : []),
+		diagnostics: {
+			contactByFoot,
+			stanceRuns: runs.map((run) => ({ ...run, anchor: run.anchor.slice() })),
+			contactCount: samples.reduce((total, items) => total + items.length, 0),
+			interpolatedFrames: corrections.reduce((total, correction, frame) => total + (samples[frame].length ? 0 : (runs.length ? 1 : 0)), 0),
+			maxCorrectionM: Math.max(...corrections.map((correction) => Math.hypot(correction[0], correction[2]))),
+			planeY: ankleHeight,
+			thresholds: { stanceMode, contactProbability, maxFootHeight, minKeypointConfidence, stanceHeightMargin, maxStanceSpeed, minStanceFrames, fps },
+		},
+	};
+	if (jointsW !== undefined) result.jointsW = shiftJoints(jointsW, corrections);
+	if (footW !== undefined) result.footW = shiftFeet(footW, corrections, frames);
+	return result;
+}

package/tools/bench/obs/heading.mjs

@@ -0,0 +1,151 @@
+/**
+ * heading.mjs — remove GVHMR's short front/back yaw-flip runs from a SMPL
+ * global_orient series before temporal smoothing.
+ *
+ * On the faceless mannequin ViTPose swaps left/right for 1-8 frames, so the
+ * raw global_orient turns 97-178 deg about world vertical in one frame (or two
+ * or three) and turns back later. body_pose and pelvis do not flip. Gaussian
+ * smoothing then smears each such run into a visible spin, so the runs are
+ * removed here first.
+ *
+ * Mechanism:
+ *  1. Heading = twist of global_orient about world +Y (swing-twist
+ *     decomposition). Pre-multiplying a world Ry(a) shifts it by exactly a
+ *     and leaves the swing (tilt) unchanged.
+ *  2. Jump events = maximal clusters of consecutive frames whose yaw step
+ *     exceeds minJumpDeg/2, kept when the cluster's net yaw exceeds
+ *     minJumpDeg. A flip spread over 2-3 transitional frames is one event.
+ *  3. Paired runs: an entry event followed within maxRunFrames by the events
+ *     whose summed yaw returns within minJumpDeg of zero. The run is every
+ *     frame from the first frame of the entry event up to the frame before
+ *     the last frame of the exit event.
+ *  4. Each run frame t is corrected by Ry(-offset(t)). offset(t) is the
+ *     summed measured jump yaw up to t, not a fixed 180. Any exit mismatch r
+ *     (flips that are not exactly opposite) is spread linearly over the
+ *     run, so both joins step by only r/(L+1).
+ *  5. An unpaired event within maxRunFrames of the clip start or end marks
+ *     a run touching frame 0 or the last frame. It is corrected toward the
+ *     stable side when that side is longer than the run.
+ *  6. A flip spread over several frames leaves mid-flip frames that match
+ *     neither heading. Their tilt is corrupted too (walk f24 tilts 33 deg
+ *     against 8-12 deg neighbours). These frames only (event frames before
+ *     the event's last frame, inside a run) are replaced by a slerp between
+ *     their corrected neighbours. Every other run frame gets the yaw-only
+ *     correction and keeps its tilt.
+ * Frames outside runs are returned as copies of their input values.
+ */
+
+import { axisAngleToMatrix, matrixToAxisAngle } from "./extrinsics.mjs";
+
+const DEG = 180 / Math.PI;
+
+/** Wrap degrees into [-180, 180). */
+const wrapDeg = (a) => a - 360 * Math.floor((a + 180) / 360);
+
+/** Twist of an axis-angle rotation about world +Y, degrees. */
+export function worldYawDeg(aa) {
+	const theta = Math.hypot(aa[0], aa[1], aa[2]);
+	const qw = Math.cos(theta / 2);
+	const qy = theta > 1e-12 ? (aa[1] / theta) * Math.sin(theta / 2) : aa[1] / 2;
+	return wrapDeg(2 * Math.atan2(qy, qw) * DEG);
+}
+
+function mul3(a, b) {
+	const o = new Array(9);
+	for (let i = 0; i < 3; i++) for (let j = 0; j < 3; j++) o[i * 3 + j] = a[i * 3] * b[j] + a[i * 3 + 1] * b[3 + j] + a[i * 3 + 2] * b[6 + j];
+	return o;
+}
+
+function slerpAA(a, b, f) {
+	const A = axisAngleToMatrix(a);
+	const At = [A[0], A[3], A[6], A[1], A[4], A[7], A[2], A[5], A[8]];
+	const rel = matrixToAxisAngle(mul3(At, axisAngleToMatrix(b)));
+	return matrixToAxisAngle(mul3(A, axisAngleToMatrix(rel.map((v) => v * f))));
+}
+
+function preRotateY(aa, deg) {
+	const a = deg / DEG, c = Math.cos(a), s = Math.sin(a);
+	const m = axisAngleToMatrix(Array.from(aa));
+	// Ry(a) * m, Ry = [c 0 s; 0 1 0; -s 0 c]
+	return matrixToAxisAngle([
+		c * m[0] + s * m[6], c * m[1] + s * m[7], c * m[2] + s * m[8],
+		m[3], m[4], m[5],
+		-s * m[0] + c * m[6], -s * m[1] + c * m[7], -s * m[2] + c * m[8],
+	]);
+}
+
+/**
+ * @param {ArrayLike<number>[]} orientAA  [T] axis-angle global_orient (world, +Y up)
+ * @param {{ maxRunFrames?: number, minJumpDeg?: number }} [options]
+ * @returns {{ orient: number[][], runs: { start: number, end: number, yawDeg: number }[] }}
+ */
+export function unwrapHeadingFlips(orientAA, { maxRunFrames = 12, minJumpDeg = 60 } = {}) {
+	const T = orientAA.length;
+	const yaw = Array.from(orientAA, worldYawDeg);
+	const d = yaw.map((y, t) => (t ? wrapDeg(y - yaw[t - 1]) : 0));
+
+	const events = [];
+	for (let t = 1; t < T;) {
+		if (!(Math.abs(d[t]) > minJumpDeg / 2)) { t++; continue; }
+		let e = t, sum = 0;
+		while (e < T && Math.abs(d[e]) > minJumpDeg / 2) sum += d[e++];
+		if (Math.abs(wrapDeg(sum)) > minJumpDeg) events.push({ first: t, last: e - 1, sum: wrapDeg(sum), used: false });
+		t = e;
+	}
+	// Summed wrapped steps over every event frame in [from, to].
+	const eventYaw = (from, to) => {
+		let s = 0;
+		for (const ev of events) for (let k = Math.max(ev.first, from); k <= Math.min(ev.last, to); k++) s += d[k];
+		return s;
+	};
+
+	// runs: { start, end, yawDeg, offset(t) }
+	let runs = [];
+	outer: for (let i = 0; i < events.length; i++) {
+		let net = events[i].sum;
+		for (let j = i + 1; j < events.length; j++) {
+			const start = events[i].first, end = events[j].last - 1;
+			if (end - start + 1 > maxRunFrames) break;
+			net += events[j].sum;
+			if (Math.abs(wrapDeg(net)) < minJumpDeg) {
+				const L = end - start + 1, r = wrapDeg(eventYaw(start, events[j].last));
+				runs.push({ start, end, yawDeg: events[i].sum, offset: (t) => eventYaw(start, t) - (r * (t - start + 1)) / (L + 1) });
+				for (let k = i; k <= j; k++) events[k].used = true;
+				i = j;
+				continue outer;
+			}
+		}
+	}
+
+	const unpaired = events.filter((ev) => !ev.used);
+	const head = unpaired.filter((ev) => ev.last <= maxRunFrames).pop();
+	if (head) {
+		const next = events.find((ev) => ev.first > head.last);
+		if ((next ? next.first : T) - head.last > head.last) {
+			const end = head.last - 1;
+			runs = runs.filter((run) => run.start > end);
+			runs.unshift({ start: 0, end, yawDeg: wrapDeg(-eventYaw(0, head.last)), offset: (t) => -eventYaw(t + 1, head.last) });
+			head.used = true;
+		}
+	}
+	const tail = unpaired.find((ev) => !ev.used && T - ev.first <= maxRunFrames);
+	if (tail) {
+		const prev = events.filter((ev) => ev.last < tail.first).pop();
+		const start = tail.first;
+		if (start - (prev ? prev.last : 0) > T - start) {
+			runs = runs.filter((run) => run.end < start);
+			runs.push({ start, end: T - 1, yawDeg: wrapDeg(eventYaw(start, T - 1)), offset: (t) => eventYaw(start, t) });
+		}
+	}
+
+	const orient = Array.from(orientAA, (aa) => Array.from(aa));
+	for (const run of runs) for (let t = run.start; t <= run.end; t++) orient[t] = preRotateY(orientAA[t], -run.offset(t));
+	for (const run of runs) {
+		for (const ev of events) {
+			if (ev.last - ev.first < 1 || ev.first > run.end + 1 || ev.last < run.start) continue;
+			const lo = ev.first - 1, hi = ev.last;
+			for (let k = Math.max(ev.first, run.start); k <= Math.min(ev.last - 1, run.end); k++) orient[k] = slerpAA(orient[lo], orient[hi], (k - lo) / (hi - lo));
+		}
+	}
+	return { orient, runs: runs.map(({ start, end, yawDeg }) => ({ start, end, yawDeg: Math.round(yawDeg * 10) / 10 })) };
+}