| """Read-only metric helpers for the nine Dev15 handover validators.""" |
| from __future__ import annotations |
|
|
| import math |
|
|
| from common import body_speed, final_window, in_aabb, norm, roll_pitch |
|
|
|
|
| def planar_travel(frames, body_name: str) -> float: |
| first = frames[0]["bodies"][body_name]["position"] |
| last = frames[-1]["bodies"][body_name]["position"] |
| return math.hypot(last[0] - first[0], last[1] - first[1]) |
|
|
|
|
| def signed_travel(frames, body_name: str, axis: int) -> float: |
| first = frames[0]["bodies"][body_name]["position"][axis] |
| last = frames[-1]["bodies"][body_name]["position"][axis] |
| return last - first |
|
|
|
|
| def lateral_span(frames, body_name: str, travel_axis: int) -> float: |
| other = 1 - travel_axis |
| values = [frame["bodies"][body_name]["position"][other] for frame in frames] |
| return max(values) - min(values) |
|
|
|
|
| def height_span(frames, body_name: str) -> float: |
| values = [frame["bodies"][body_name]["position"][2] for frame in frames] |
| return max(values) - min(values) |
|
|
|
|
| def maximum_tilt(frames, body_name: str) -> float: |
| return max( |
| max(abs(value) for value in roll_pitch(frame["bodies"][body_name]["quaternion"])) |
| for frame in frames |
| ) |
|
|
|
|
| def terminal_stopped(frames, body_name: str, hold_s: float, threshold: float) -> bool: |
| window = final_window(frames, hold_s) |
| return bool(window) and all(body_speed(frame, body_name) <= threshold for frame in window) |
|
|
|
|
| def terminal_in_region(frames, body_name: str, hold_s: float, region: dict) -> bool: |
| window = final_window(frames, hold_s) |
| return bool(window) and all( |
| in_aabb(frame["bodies"][body_name]["position"], region) for frame in window |
| ) |
|
|
|
|
| def first_region_time(frames, body_name: str, region: dict): |
| for frame in frames: |
| if in_aabb(frame["bodies"][body_name]["position"], region): |
| return frame["t"] |
| return None |
|
|
|
|
| def first_axis_progress_time(frames, body_name: str, axis: int, threshold: float, sign: float): |
| start = frames[0]["bodies"][body_name]["position"][axis] |
| for frame in frames: |
| progress = sign * (frame["bodies"][body_name]["position"][axis] - start) |
| if progress >= threshold: |
| return frame["t"] |
| return None |
|
|
|
|
| def interpolate_points(points: list[list[float]], phase: float) -> list[float]: |
| phase = max(0.0, min(1.0, phase)) * (len(points) - 1) |
| left = int(phase) |
| right = min(len(points) - 1, left + 1) |
| blend = phase - left |
| return [ |
| (1.0 - blend) * points[left][index] + blend * points[right][index] |
| for index in range(3) |
| ] |
|
|
|
|
| def relative_position_in_body_frame(frame, body_name: str, target_name: str) -> list[float]: |
| body = frame["bodies"][body_name] |
| target = frame["bodies"][target_name] |
| vx, vy, vz = [target["position"][i] - body["position"][i] for i in range(3)] |
| w, x, y, z = body["quaternion"] |
| return [ |
| (1 - 2 * (y * y + z * z)) * vx + 2 * (x * y + z * w) * vy + 2 * (x * z - y * w) * vz, |
| 2 * (x * y - z * w) * vx + (1 - 2 * (x * x + z * z)) * vy + 2 * (y * z + x * w) * vz, |
| 2 * (x * z + y * w) * vx + 2 * (y * z - x * w) * vy + (1 - 2 * (x * x + y * y)) * vz, |
| ] |
|
|
|
|
| def relative_orientation_in_body_frame(frame, body_name: str, target_name: str) -> list[float]: |
| aw, ax, ay, az = frame["bodies"][body_name]["quaternion"] |
| bw, bx, by, bz = frame["bodies"][target_name]["quaternion"] |
| relative = [ |
| aw * bw + ax * bx + ay * by + az * bz, |
| aw * bx - ax * bw - ay * bz + az * by, |
| aw * by + ax * bz - ay * bw - az * bx, |
| aw * bz - ax * by + ay * bx - az * bw, |
| ] |
| magnitude = norm(relative) |
| return [value / magnitude for value in relative] |
|
|
|
|
| def quaternion_distance(a, b) -> float: |
| dot = abs(sum(float(a[index]) * float(b[index]) for index in range(4))) |
| return 2.0 * math.acos(max(-1.0, min(1.0, dot))) |
|
|
|
|
| def point_distance(a, b) -> float: |
| return norm([a[index] - b[index] for index in range(3)]) |
|
|
