| """Lossless row selection plus explicitly labelled OXT-compatible state arrays. |
| |
| This module reads offline trajectory HDF5 files. It neither decodes camera |
| files nor transforms sensor wrenches, calibrates a TCP, or controls hardware. |
| """ |
|
|
| from pathlib import Path |
|
|
| import h5py |
| import numpy as np |
| from scipy.spatial.transform import Rotation |
|
|
|
|
| _CONTROL_TIME = "observation/timestamp/control/step_start_unix_ns" |
| _CAMERA_PREFIX = "observation/timestamp/cameras/" |
|
|
|
|
| class CameraAlignmentError(ValueError): |
| """Exact camera alignment failed; ``report`` contains JSON-safe diagnostics.""" |
|
|
| def __init__(self, message, report): |
| super().__init__(message) |
| self.report = report |
|
|
|
|
| def _integer_vector(value, name, nonnegative=True): |
| array = np.asarray(value) |
| if array.ndim != 1 or array.dtype.kind not in "iu" or not len(array): |
| raise ValueError(name + " must be a nonempty one-dimensional integer array") |
| if array.dtype.kind == "u" and np.any(array > np.iinfo(np.int64).max): |
| raise ValueError(name + " exceeds int64 range") |
| array = array.astype(np.int64, copy=True) |
| if nonnegative and np.any(array < 0): |
| raise ValueError(name + " must be nonnegative") |
| return array |
|
|
|
|
| def _strictly_increasing(array, name): |
| |
| if np.any(array[1:] <= array[:-1]): |
| raise ValueError(name + " must be unique and strictly increasing") |
|
|
|
|
| def _camera_serials(h5): |
| if _CAMERA_PREFIX.rstrip("/") not in h5: |
| raise ValueError("Trajectory has no camera timestamps") |
| suffix = "_frame_received" |
| return sorted(name[:-len(suffix)] for name in h5[_CAMERA_PREFIX] |
| if name.endswith(suffix)) |
|
|
|
|
| def align_camera_rows(h5_path, camera_timestamps): |
| """Intersect exact IMAGE-time matches from both physical camera streams. |
| |
| ``camera_timestamps`` maps each recorded serial to its complete decoded SDK |
| IMAGE timestamp array, in integer Unix nanoseconds and original frame order. |
| SDK times are floored to milliseconds to match DROID's recorded precision. |
| Both raw nanoseconds and floored milliseconds must be unique and strictly |
| increasing; the HDF5 millisecond sequences must be likewise unambiguous. |
| |
| Return ``(control_rows, frame_indices_by_serial, report)``. Missing camera |
| rows are explicitly reported and removed from the intersection. If there |
| is no common exact match, raise CameraAlignmentError with diagnostics; |
| no nearest-neighbour, clock-offset, or frame-repeat guess is attempted. |
| """ |
| report = { |
| "method": "exact SDK IMAGE unix_ns // 1000000 == H5 frame_received_ms", |
| "cameras": {}, |
| "interpolation": "none", |
| } |
| try: |
| if not isinstance(camera_timestamps, dict): |
| raise ValueError("camera_timestamps must map both serials to SDK timestamps") |
| with h5py.File(h5_path, "r") as h5: |
| serials = _camera_serials(h5) |
| report["recorded_serials"] = serials |
| report["provided_serials"] = sorted(str(k) for k in camera_timestamps) |
| if len(serials) != 2 or set(camera_timestamps) != set(serials): |
| raise ValueError("Exactly both recorded physical camera serials are required") |
| control_time = _integer_vector(h5[_CONTROL_TIME][:], _CONTROL_TIME) |
| _strictly_increasing(control_time, _CONTROL_TIME) |
| count = len(control_time) |
| report["original_control_rows"] = count |
| per_camera_indices = {} |
| all_matched = np.ones(count, dtype=bool) |
| for serial in serials: |
| sdk_ns = _integer_vector(camera_timestamps[serial], serial + " SDK timestamp_ns") |
| _strictly_increasing(sdk_ns, serial + " SDK timestamp_ns") |
| sdk_ms = sdk_ns // 1000000 |
| _strictly_increasing(sdk_ms, serial + " SDK milliseconds") |
| h5_ms = _integer_vector(h5[_CAMERA_PREFIX + serial + "_frame_received"][:], |
| serial + " H5 frame_received_ms") |
| _strictly_increasing(h5_ms, serial + " H5 frame_received_ms") |
| if len(h5_ms) != count: |
| raise ValueError(serial + " H5 camera rows differ from control row count") |
| indices = np.searchsorted(sdk_ms, h5_ms) |
| valid = indices < len(sdk_ms) |
| valid[valid] &= sdk_ms[indices[valid]] == h5_ms[valid] |
| indices = indices.astype(np.int64) |
| indices[~valid] = -1 |
| per_camera_indices[serial] = indices |
| all_matched &= valid |
| report["cameras"][serial] = { |
| "sdk_frames": len(sdk_ns), |
| "matched_control_rows": int(valid.sum()), |
| "unmatched_control_rows": np.flatnonzero(~valid).tolist(), |
| "sdk_unix_ns_range": [int(sdk_ns[0]), int(sdk_ns[-1])], |
| "h5_unix_ms_range": [int(h5_ms[0]), int(h5_ms[-1])], |
| } |
| rows = np.flatnonzero(all_matched).astype(np.int64) |
| report["selected_control_rows"] = rows.tolist() |
| report["selected_row_count"] = len(rows) |
| report["dropped_control_rows"] = np.flatnonzero(~all_matched).tolist() |
| if not len(rows): |
| raise ValueError("No control row has an exact timestamp match in both cameras") |
| result = {serial: indices[rows].copy() |
| for serial, indices in per_camera_indices.items()} |
| for serial, indices in result.items(): |
| _strictly_increasing(indices, serial + " matched frame indices") |
| report["cameras"][serial]["selected_frame_indices"] = indices.tolist() |
| report["cameras"][serial]["unused_sdk_frame_count"] = ( |
| report["cameras"][serial]["sdk_frames"] - len(indices) |
| ) |
| return rows, result, report |
| except (KeyError, TypeError, ValueError) as error: |
| report["error"] = str(error) |
| raise CameraAlignmentError(str(error), report) from error |
|
|
|
|
| def _read_rows(dataset, rows, total): |
| if not dataset.shape or dataset.shape[0] != total: |
| raise ValueError("Cannot preserve non-row-aligned dataset: " + dataset.name) |
| string_info = h5py.check_string_dtype(dataset.dtype) |
| if string_info is not None: |
| |
| |
| value = np.asarray(dataset.asstr()[rows], dtype=str) |
| elif dataset.dtype.kind in "biufc": |
| value = np.asarray(dataset[rows]).copy() |
| else: |
| raise ValueError("Unsupported raw dataset dtype at " + dataset.name + ": " + str(dataset.dtype)) |
| return value |
|
|
|
|
| def _pose_rotvec(pose, name): |
| if pose.ndim != 2 or pose.shape[1] != 6 or not np.isfinite(pose).all(): |
| raise ValueError(name + " must contain finite xyz/Euler-xyz poses with shape (T,6)") |
| return np.concatenate((pose[:, :3], Rotation.from_euler("xyz", pose[:, 3:]).as_rotvec()), axis=1) |
|
|
|
|
| def build_arrays(h5_path, rows, task_instruction, camera_indices=None, |
| camera_timestamp_ns=None): |
| """Return ``(flat_data_arrays, JSON_serializable_metadata)`` for selected rows. |
| |
| Standard wrist poses retain the original robot-model EEF/flange reference, |
| with Euler xyz converted to rotation vectors. No canonical wrist/TCP or FT |
| transformation is inferred. ``native__`` arrays preserve every original |
| row-aligned dataset, including strings, exact timestamps and optional NaNs. |
| |
| Camera dictionaries, when provided, contain *already selected* frame |
| indices/timestamps, each with length ``len(rows)``. Their serials must match |
| both recorded cameras. Nanosecond timestamps are checked against the |
| selected H5 milliseconds. Original file attributes and high-rate FT sidecar |
| preservation are the export orchestrator's responsibility. |
| """ |
| rows = _integer_vector(rows, "rows") |
| _strictly_increasing(rows, "rows") |
| if not isinstance(task_instruction, str) or not task_instruction.strip(): |
| raise ValueError("task_instruction must be a nonempty concrete task string") |
| arrays, native_fields = {}, {} |
| with h5py.File(h5_path, "r") as h5: |
| all_time = _integer_vector(h5[_CONTROL_TIME][:], _CONTROL_TIME) |
| _strictly_increasing(all_time, _CONTROL_TIME) |
| total = len(all_time) |
| if rows[-1] >= total: |
| raise ValueError("rows contains an index outside the trajectory") |
|
|
| def preserve(path, dataset): |
| if not isinstance(dataset, h5py.Dataset): |
| return |
| name = "native__" + path.replace("/", "__") |
| if name in arrays: |
| raise ValueError("Flattened native field name collision: " + name) |
| arrays[name] = _read_rows(dataset, rows, total) |
| native_fields[name] = {"source_path": path, "source_dtype": str(dataset.dtype)} |
|
|
| h5.visititems(preserve) |
|
|
| def original(path, shape=None, finite=False): |
| value = arrays["native__" + path.replace("/", "__")].copy() |
| if shape is not None and value.shape != (len(rows),) + shape: |
| raise ValueError(path + " has unexpected shape " + str(value.shape)) |
| if finite and (value.dtype.kind not in "biuf" or not np.isfinite(value).all()): |
| raise ValueError(path + " must contain finite numeric values") |
| return value |
|
|
| timestamps = all_time[rows] |
| arrays.update({ |
| "timestamps": (timestamps - all_time[0]).astype(np.float64) / 1e9, |
| "timestamp_unix_ns": timestamps.copy(), |
| "source_control_row": rows.copy(), |
| "right_arm_joints": original("observation/robot_state/joint_positions", (7,), True), |
| "right_wrist_pose": _pose_rotvec(original("observation/robot_state/cartesian_position"), "state EEF"), |
| "right_hand_joints": original("observation/robot_state/gripper_position", (), True)[:, None], |
| "right_hand_joints_idx": np.full((len(rows), 1), 28, dtype=np.int64), |
| "sub_task_instruction": np.full(len(rows), task_instruction, dtype="U" + str(len(task_instruction))), |
| "action_joint_position": original("action/joint_position", (7,), True), |
| "action_eef_pose": _pose_rotvec(original("action/cartesian_position"), "action EEF"), |
| "action_eef_pose_with_ft_offset": _pose_rotvec(original("action/cartesian_position_with_ft_offset"), "offset action EEF"), |
| "state_eef_pose_with_ft_offset": _pose_rotvec(original("observation/robot_state/cartesian_position_with_ft_offset"), "offset state EEF"), |
| "command_dispatched": original("action/command_dispatched", ()), |
| }) |
| if arrays["command_dispatched"].dtype.kind != "b": |
| raise ValueError("action/command_dispatched must be boolean") |
| wrench = original("observation/ft_sensor/wrench", (6,), True) |
| arrays.update({ |
| "ft_wrench": wrench.copy(), |
| "supplementary_tactile": wrench.copy(), |
| "right_tactile_data_wrist_torque": wrench[:, None, 3:].copy(), |
| "right_tactile_area_wrist_torque": np.full((len(rows), 1), 15, dtype=np.int64), |
| "right_tactile_sensor_wrist_torque": np.full(len(rows), "SRIM3813A1", dtype="U10"), |
| "right_tactile_type_wrist_torque": np.full(len(rows), "state", dtype="U5"), |
| }) |
| serials = _camera_serials(h5) if camera_indices is not None or camera_timestamp_ns is not None else [] |
| for supplied, label, prefix in ( |
| (camera_indices, "camera_indices", "camera_frame_index__"), |
| (camera_timestamp_ns, "camera_timestamp_ns", "camera_timestamp_unix_ns__")): |
| if supplied is None: |
| continue |
| if not isinstance(supplied, dict) or len(serials) != 2 or set(supplied) != set(serials): |
| raise ValueError(label + " must include exactly both recorded camera serials") |
| for serial in serials: |
| values = _integer_vector(supplied[serial], label + "[" + serial + "]") |
| if len(values) != len(rows): |
| raise ValueError(label + " arrays must already be selected and have len(rows) entries") |
| _strictly_increasing(values, label + "[" + serial + "]") |
| if supplied is camera_timestamp_ns: |
| h5_ms = original(_CAMERA_PREFIX + serial + "_frame_received", ()) |
| if not np.array_equal(values // 1000000, h5_ms): |
| raise ValueError(serial + " SDK timestamp does not exactly match selected H5 milliseconds") |
| arrays[prefix + serial] = values |
|
|
| metadata = { |
| "schema": "droid-native-to-oxt-arrays-v1", |
| "source_h5": str(Path(h5_path).resolve()), |
| "original_control_rows": total, |
| "selected_control_rows": rows.tolist(), |
| "timestamp_origin_unix_ns": int(all_time[0]), |
| "timestamp_semantics": "Host control step_start Unix nanoseconds; relative seconds subtract original episode first row before float conversion. No clock correction or resampling.", |
| "pose_semantics": { |
| "representation": "xyz metres + rotation vector radians (scipy Euler xyz conversion)", |
| "right_wrist_pose_reference": "original robot model EEF/flange; local FR3 configuration names panda_link8", |
| "canonical_wrist_transform_status": "pending; no canonical wrist or complete TCP transform inferred", |
| "action_eef_pose": "original requested EEF target before IK; distinct from future observed state and not FK of the joint target", |
| "offset_fields": "already recorded original EEF local +Z 0.063 m point; orientation unchanged; not full Robotiq TCP", |
| }, |
| "action_semantics": "Real original DROID joint and EEF targets are retained. command_dispatched=false indicates a hypothetical hold, not a sent command; true does not prove asynchronous acceptance.", |
| "hand_semantics": "Single normalized closure 0=open, 1=closed, joint index 28; no conversion to physical width.", |
| "ft_semantics": { |
| "sensor": "SRIM3813A1", |
| "channels": ["Fx", "Fy", "Fz", "Mx", "My", "Mz"], |
| "units": ["N", "N", "N", "Nm", "Nm", "Nm"], |
| "units_source": "assumed from device stored calibration", |
| "frame": "sensor native measurement frame; sensor-to-EEF transform unavailable", |
| "standard_tactile_group": "Only recorded Mx, My, Mz in wrist_torque; area 15. No inferred force magnitude or force-axis reduction.", |
| "software_bias_subtraction": False, |
| "software_gravity_compensation": False, |
| "alignment": "Original latest-persisted per-control snapshot, selected without interpolation; native sample_index identifies full sidecar row.", |
| "high_rate_sidecar": "Must also preserve original ft_sensor.h5 independently; these row-aligned arrays do not contain all high-rate samples.", |
| }, |
| "supplementary_tactile_note": { |
| "SRIM3813A1_native_wrench": { |
| "type": "state", "shape": [6], "sensor_num": 1, "sensor_dimension": 6, |
| "array_key": "supplementary_tactile", |
| "sensor_description": "One device-calibrated six-axis native sensor-frame wrench, flattened as Fx,Fy,Fz,Mx,My,Mz in N,N,N,Nm,Nm,Nm; no software compensation or coordinate transform.", |
| "sensor_idx_description": {"sensor_idx_0": "All six columns belong to the same SRI M3813A1 wrist-mounted sensor."}, |
| } |
| }, |
| "native_fields": native_fields, |
| "fields": {name: {"shape": list(array.shape), "dtype": str(array.dtype)} |
| for name, array in arrays.items()}, |
| } |
| return arrays, metadata |
|
|
