#!/usr/bin/env python3 """Evaluate all 16 flights in the unified UAV tracking dataset.""" from __future__ import annotations import argparse import csv import itertools import json import math from dataclasses import dataclass from datetime import datetime, timezone from pathlib import Path from typing import Any, Iterable, Sequence import numpy as np WGS84_A_M = 6378137.0 WGS84_F = 1.0 / 298.257223563 WGS84_E2 = WGS84_F * (2.0 - WGS84_F) MAX_RTK_GAP_S = 0.30 BOOTSTRAP_REPLICATES = 100_000 BOOTSTRAP_SEED = 20260723 SENSITIVITY_BINS = { "range_m": np.array([9.0, 15.0, 22.0, 28.0, 35.0, 60.0]), "azimuth_deg": np.array([-91.0, -30.0, -10.0, 5.0, 25.0, 70.0]), "elevation_deg": np.array([3.0, 12.0, 18.0, 25.0, 35.0, 55.0]), } LEVER_Z_SENSITIVITY_M = (0.20, 0.25, 0.30) @dataclass class FlightSpec: flight_id: str experiment_day: str vehicle_pose_id: str trajectory: str difficulty: str @dataclass class FlightData: spec: FlightSpec timestamp_us: np.ndarray tracking_v_m: np.ndarray antenna_w_m: np.ndarray tracking_rows: int eligible_rows: int rtk_fixed_rows: int rtk_total_gga_rows: int @dataclass class Evaluation: flight: FlightData reference_v_m: np.ndarray residual_v_m: np.ndarray metrics: dict[str, Any] FLIGHTS: tuple[FlightSpec, ...] = ( FlightSpec("flight_01", "2026-07-16", "vehicle_pose_0716", "稳定悬停", "easy"), FlightSpec( "flight_02", "2026-07-16", "vehicle_pose_0716", "低动态悬停（含垂直漂移）", "easy", ), FlightSpec( "flight_03", "2026-07-16", "vehicle_pose_0716", "垂直升降及两端悬停", "medium", ), FlightSpec("flight_04", "2026-07-16", "vehicle_pose_0716", "左向右横移", "medium"), FlightSpec("flight_05", "2026-07-16", "vehicle_pose_0716", "右向左横移", "medium"), FlightSpec( "flight_06", "2026-07-23", "vehicle_pose_0723", "径向接近后远离", "medium", ), FlightSpec( "flight_07", "2026-07-23", "vehicle_pose_0723", "纵向/径向往返", "medium", ), FlightSpec( "flight_08", "2026-07-16", "vehicle_pose_0716", "宽弧线连续转向", "hard", ), FlightSpec( "flight_09", "2026-07-23", "vehicle_pose_0723", "8 字/连续左右转向", "hard", ), FlightSpec("flight_10", "2026-07-16", "vehicle_pose_0716", "近距横向掠过", "hard"), FlightSpec("flight_11", "2026-07-23", "vehicle_pose_0723", "横向飞越", "hard"), FlightSpec( "flight_12", "2026-07-16", "vehicle_pose_0716", "自然失跟与重捕获", "hard", ), FlightSpec( "flight_13", "2026-07-16", "vehicle_pose_0716", "近距复杂背景连续跟踪", "hard", ), FlightSpec( "flight_14", "2026-07-23", "vehicle_pose_0723", "严格复杂背景横移/缓弧", "hard", ), FlightSpec( "flight_15", "2026-07-23", "vehicle_pose_0723", "复杂背景重复", "hard", ), FlightSpec( "flight_16", "2026-07-23", "vehicle_pose_0723", "远距悬停及缓慢横移", "hard", ), ) def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "dataset_root", nargs="?", type=Path, default=Path(__file__).resolve().parents[1], ) parser.add_argument( "--output-dir", type=Path, help="Default: DATASET_ROOT/script/output", ) return parser.parse_args() def read_json(path: Path) -> dict[str, Any]: with path.open("r", encoding="utf-8") as stream: return json.load(stream) def write_json(path: Path, payload: Any) -> None: path.write_text( json.dumps(json_ready(payload), ensure_ascii=False, indent=2) + "\n", encoding="utf-8", ) def write_csv(path: Path, rows: Sequence[dict[str, Any]]) -> None: if not rows: path.write_text("", encoding="utf-8") return fields: list[str] = [] for row in rows: for key in row: if key not in fields: fields.append(key) with path.open("w", encoding="utf-8", newline="") as stream: writer = csv.DictWriter(stream, fieldnames=fields) writer.writeheader() writer.writerows(rows) def json_ready(value: Any) -> Any: if isinstance(value, Path): return str(value) if isinstance(value, np.ndarray): return value.tolist() if isinstance(value, np.generic): return value.item() if isinstance(value, float) and not math.isfinite(value): return None if isinstance(value, dict): return {str(key): json_ready(item) for key, item in value.items()} if isinstance(value, (list, tuple)): return [json_ready(item) for item in value] return value def exactly_one(paths: Iterable[Path], description: str) -> Path: matches = sorted(paths) if len(matches) != 1: raise ValueError( f"{description} should have exactly one match; found {len(matches)}: " f"{matches}" ) return matches[0] def geodetic_to_ecef( latitude_deg: np.ndarray, longitude_deg: np.ndarray, altitude_m: np.ndarray, ) -> np.ndarray: latitude = np.deg2rad(latitude_deg) longitude = np.deg2rad(longitude_deg) sin_latitude = np.sin(latitude) normal = WGS84_A_M / np.sqrt(1.0 - WGS84_E2 * sin_latitude * sin_latitude) return np.column_stack( ( (normal + altitude_m) * np.cos(latitude) * np.cos(longitude), (normal + altitude_m) * np.cos(latitude) * np.sin(longitude), (normal * (1.0 - WGS84_E2) + altitude_m) * sin_latitude, ) ) def enu_rotation(latitude_deg: float, longitude_deg: float) -> np.ndarray: latitude = math.radians(latitude_deg) longitude = math.radians(longitude_deg) return np.array( [ [-math.sin(longitude), math.cos(longitude), 0.0], [ -math.sin(latitude) * math.cos(longitude), -math.sin(latitude) * math.sin(longitude), math.cos(latitude), ], [ math.cos(latitude) * math.cos(longitude), math.cos(latitude) * math.sin(longitude), math.sin(latitude), ], ], dtype=np.float64, ) def geodetic_to_enu( latitude_deg: np.ndarray, longitude_deg: np.ndarray, altitude_m: np.ndarray, origin: tuple[float, float, float], ) -> np.ndarray: latitude_0, longitude_0, altitude_0 = origin ecef_0 = geodetic_to_ecef( np.array([latitude_0]), np.array([longitude_0]), np.array([altitude_0]), )[0] ecef = geodetic_to_ecef(latitude_deg, longitude_deg, altitude_m) return (enu_rotation(latitude_0, longitude_0) @ (ecef - ecef_0).T).T def read_rtk( path: Path, origin: tuple[float, float, float], ) -> tuple[np.ndarray, np.ndarray, int, int]: rows: list[tuple[int, float, float, float]] = [] gga_rows = 0 fixed_rows = 0 with path.open("r", encoding="utf-8", newline="") as stream: for row in csv.reader(stream): if not row or row[0] != "GGA": continue gga_rows += 1 if len(row) < 8 or row[2] != "4": continue fixed_rows += 1 try: item = (int(row[1]), float(row[5]), float(row[6]), float(row[7])) except ValueError: continue if all(math.isfinite(float(value)) for value in item): rows.append(item) if len(rows) < 2: raise ValueError(f"Not enough fixed GGA samples: {path}") data = np.asarray(rows, dtype=np.float64) order = np.argsort(data[:, 0], kind="stable") data = data[order] time_ms, indices = np.unique(data[:, 0].astype(np.int64), return_index=True) data = data[indices] position_w = geodetic_to_enu(data[:, 1], data[:, 2], data[:, 3], origin) return time_ms * 1000, position_w, gga_rows, fixed_rows def read_tracking( path: Path, ) -> tuple[np.ndarray, np.ndarray, int, int]: time_us: list[int] = [] positions: list[list[float]] = [] total_rows = 0 eligible_rows = 0 with path.open("r", encoding="utf-8", newline="") as stream: for row in csv.DictReader(stream): total_rows += 1 if not ( row.get("lifecycle", "").strip().lower() == "confirmed" and row.get("state_valid") == "1" and row.get("numerical_ok") == "1" and row.get("command_valid") == "1" ): continue try: timestamp = int(row["frame_timestamp_us"]) position = [ float(row["px"]), float(row["py"]), float(row["pz"]), ] except (KeyError, ValueError): continue if timestamp <= 0 or not all(math.isfinite(value) for value in position): continue time_us.append(timestamp) positions.append(position) eligible_rows += 1 if not time_us: raise ValueError(f"No eligible tracking states: {path}") times = np.asarray(time_us, dtype=np.int64) points = np.asarray(positions, dtype=np.float64) order = np.argsort(times, kind="stable") times = times[order] points = points[order] unique_times, indices = np.unique(times, return_index=True) return unique_times, points[indices], total_rows, eligible_rows def interpolate_rtk( query_time_us: np.ndarray, rtk_time_us: np.ndarray, rtk_position_w_m: np.ndarray, ) -> tuple[np.ndarray, np.ndarray]: right = np.searchsorted(rtk_time_us, query_time_us, side="right") valid = (right > 0) & (right < len(rtk_time_us)) selected = np.flatnonzero(valid) right_selected = right[selected] left_selected = right_selected - 1 gap_us = rtk_time_us[right_selected] - rtk_time_us[left_selected] valid_gap = (gap_us > 0) & (gap_us <= int(round(MAX_RTK_GAP_S * 1e6))) selected = selected[valid_gap] right_selected = right_selected[valid_gap] left_selected = left_selected[valid_gap] gap_us = gap_us[valid_gap] alpha = ( query_time_us[selected] - rtk_time_us[left_selected] ) / gap_us.astype(np.float64) position = rtk_position_w_m[left_selected] + alpha[:, None] * ( rtk_position_w_m[right_selected] - rtk_position_w_m[left_selected] ) mask = np.zeros(len(query_time_us), dtype=bool) mask[selected] = True return mask, position def load_flight( dataset_root: Path, spec: FlightSpec, origin: tuple[float, float, float], ) -> FlightData: directory = dataset_root / spec.flight_id tracking_path = exactly_one( (directory / "tracking").glob("tracking_state_*.csv"), f"{spec.flight_id} tracking_state", ) rtk_path = directory / "drone_rtk.csv" if not rtk_path.is_file(): raise FileNotFoundError(rtk_path) track_time, tracking, tracking_rows, eligible_rows = read_tracking(tracking_path) rtk_time, rtk_w, gga_rows, fixed_rows = read_rtk(rtk_path, origin) mask, antenna_w = interpolate_rtk(track_time, rtk_time, rtk_w) if not np.any(mask): raise ValueError(f"No tracking/RTK pairs: {spec.flight_id}") return FlightData( spec=spec, timestamp_us=track_time[mask], tracking_v_m=tracking[mask], antenna_w_m=antenna_w, tracking_rows=tracking_rows, eligible_rows=eligible_rows, rtk_fixed_rows=fixed_rows, rtk_total_gga_rows=gga_rows, ) def reference_from_antenna( flight: FlightData, calibration: dict[str, Any], lever_z_m: float | None = None, ) -> np.ndarray: transform = np.asarray( calibration["transforms"]["T_W_V"][flight.spec.vehicle_pose_id], dtype=np.float64, ) rotation_w_v = transform[:3, :3] translation_w_v = transform[:3, 3] lever_u = np.asarray( calibration["extrinsics_m"]["uav_rtk_antenna_in_u"], dtype=np.float64, ).copy() if lever_z_m is not None: lever_u[2] = lever_z_m antenna_v = ( rotation_w_v.T @ (flight.antenna_w_m - translation_w_v).T ).T # UAV attitude was not logged. U and V axes are treated as parallel for # this small lever; the dominant vertical term is robust for approximately # level flight. return antenna_v - lever_u def metric_summary(residual: np.ndarray) -> dict[str, float]: error_3d = np.linalg.norm(residual, axis=1) horizontal = np.linalg.norm(residual[:, :2], axis=1) vertical = np.abs(residual[:, 2]) return { "error_3d_mean_m": float(np.mean(error_3d)), "error_3d_rmse_m": float(np.sqrt(np.mean(error_3d**2))), "error_3d_median_m": float(np.median(error_3d)), "error_3d_p95_m": float(np.percentile(error_3d, 95)), "error_3d_max_m": float(np.max(error_3d)), "horizontal_rmse_m": float(np.sqrt(np.mean(horizontal**2))), "horizontal_p95_m": float(np.percentile(horizontal, 95)), "vertical_rmse_m": float(np.sqrt(np.mean(vertical**2))), "vertical_p95_m": float(np.percentile(vertical, 95)), "x_mean_error_m": float(np.mean(residual[:, 0])), "y_mean_error_m": float(np.mean(residual[:, 1])), "z_mean_error_m": float(np.mean(residual[:, 2])), "error_ge_1m_ratio": float(np.mean(error_3d >= 1.0)), "error_ge_1_5m_ratio": float(np.mean(error_3d >= 1.5)), "error_ge_2m_ratio": float(np.mean(error_3d >= 2.0)), } def evaluate_flight( flight: FlightData, calibration: dict[str, Any], lever_z_m: float | None = None, ) -> Evaluation: reference = reference_from_antenna(flight, calibration, lever_z_m) residual = flight.tracking_v_m - reference metrics: dict[str, Any] = { "flight_id": flight.spec.flight_id, "experiment_day": flight.spec.experiment_day, "vehicle_pose_id": flight.spec.vehicle_pose_id, "trajectory": flight.spec.trajectory, "difficulty": flight.spec.difficulty, "tracking_rows": flight.tracking_rows, "eligible_tracking_rows": flight.eligible_rows, "paired_rows": len(flight.timestamp_us), "eligible_coverage_ratio": len(flight.timestamp_us) / flight.eligible_rows, "rtk_fixed_rows": flight.rtk_fixed_rows, "rtk_total_gga_rows": flight.rtk_total_gga_rows, "rtk_fixed_ratio": flight.rtk_fixed_rows / flight.rtk_total_gga_rows, } metrics.update(metric_summary(residual)) return Evaluation(flight, reference, residual, metrics) def aggregate(evaluations: Sequence[Evaluation]) -> dict[str, Any]: if not evaluations: raise ValueError("Cannot aggregate an empty evaluation set") metric_keys = ( "error_3d_mean_m", "error_3d_rmse_m", "error_3d_median_m", "error_3d_p95_m", "horizontal_rmse_m", "horizontal_p95_m", "vertical_rmse_m", "vertical_p95_m", ) paired_rows = sum(len(item.flight.timestamp_us) for item in evaluations) output: dict[str, Any] = { "flight_count": len(evaluations), "paired_rows": paired_rows, "aggregation": "unweighted macro mean of per-flight metrics", } for key in metric_keys: output[f"macro_{key}"] = float( np.mean([float(item.metrics[key]) for item in evaluations]) ) output["micro_error_3d_rmse_m"] = math.sqrt( sum( len(item.flight.timestamp_us) * float(item.metrics["error_3d_rmse_m"]) ** 2 for item in evaluations ) / paired_rows ) return output def frame_rows(evaluations: Sequence[Evaluation]) -> list[dict[str, Any]]: rows: list[dict[str, Any]] = [] for item in evaluations: reference = item.reference_v_m residual = item.residual_v_m error_3d = np.linalg.norm(residual, axis=1) horizontal_error = np.linalg.norm(residual[:, :2], axis=1) horizontal_range = np.linalg.norm(reference[:, :2], axis=1) range_m = np.linalg.norm(reference, axis=1) azimuth = np.degrees(np.arctan2(reference[:, 1], reference[:, 0])) elevation = np.degrees(np.arctan2(reference[:, 2], horizontal_range)) for index in range(len(reference)): rows.append( { "flight_id": item.flight.spec.flight_id, "experiment_day": item.flight.spec.experiment_day, "timestamp_us": int(item.flight.timestamp_us[index]), "tracking_x_v_m": float(item.flight.tracking_v_m[index, 0]), "tracking_y_v_m": float(item.flight.tracking_v_m[index, 1]), "tracking_z_v_m": float(item.flight.tracking_v_m[index, 2]), "reference_x_v_m": float(reference[index, 0]), "reference_y_v_m": float(reference[index, 1]), "reference_z_v_m": float(reference[index, 2]), "error_x_m": float(residual[index, 0]), "error_y_m": float(residual[index, 1]), "error_z_m": float(residual[index, 2]), "error_3d_m": float(error_3d[index]), "error_horizontal_m": float(horizontal_error[index]), "error_vertical_abs_m": float(abs(residual[index, 2])), "range_m": float(range_m[index]), "azimuth_deg": float(azimuth[index]), "elevation_deg": float(elevation[index]), "relative_error_percent": float( 100.0 * error_3d[index] / range_m[index] ), } ) return rows def bootstrap_mean_ci(values: np.ndarray, rng: np.random.Generator) -> tuple[float, float]: if len(values) == 1: return float(values[0]), float(values[0]) indices = rng.integers( 0, len(values), size=(BOOTSTRAP_REPLICATES, len(values)), ) distribution = np.mean(values[indices], axis=1) low, high = np.percentile(distribution, [2.5, 97.5]) return float(low), float(high) def sensitivity_rows( evaluations: Sequence[Evaluation], ) -> list[dict[str, Any]]: rng = np.random.default_rng(BOOTSTRAP_SEED) prepared: list[dict[str, Any]] = [] for item in evaluations: reference = item.reference_v_m residual = item.residual_v_m horizontal_range = np.linalg.norm(reference[:, :2], axis=1) prepared.append( { "flight_id": item.flight.spec.flight_id, "error_3d": np.linalg.norm(residual, axis=1), "horizontal": np.linalg.norm(residual[:, :2], axis=1), "vertical": np.abs(residual[:, 2]), "range_m": np.linalg.norm(reference, axis=1), "azimuth_deg": np.degrees( np.arctan2(reference[:, 1], reference[:, 0]) ), "elevation_deg": np.degrees( np.arctan2(reference[:, 2], horizontal_range) ), } ) output: list[dict[str, Any]] = [] for variable, edges in SENSITIVITY_BINS.items(): all_values = np.concatenate([item[variable] for item in prepared]) if np.any((all_values < edges[0]) | (all_values > edges[-1])): raise ValueError( f"{variable} outside the specified bins: " f"[{all_values.min()}, {all_values.max()}]" ) for bin_index in range(len(edges) - 1): per_flight: list[dict[str, float]] = [] frame_count = 0 for item in prepared: values = item[variable] mask = (values >= edges[bin_index]) & ( (values < edges[bin_index + 1]) if bin_index < len(edges) - 2 else (values <= edges[bin_index + 1]) ) if not np.any(mask): continue frame_count += int(np.count_nonzero(mask)) error_3d = item["error_3d"][mask] horizontal = item["horizontal"][mask] vertical = item["vertical"][mask] per_flight.append( { "rmse_3d": float(np.sqrt(np.mean(error_3d**2))), "p95_3d": float(np.percentile(error_3d, 95)), "rmse_horizontal": float( np.sqrt(np.mean(horizontal**2)) ), "p95_horizontal": float( np.percentile(horizontal, 95) ), "rmse_vertical": float(np.sqrt(np.mean(vertical**2))), "p95_vertical": float(np.percentile(vertical, 95)), } ) if not per_flight: raise ValueError(f"Empty sensitivity bin: {variable}/{bin_index}") rmse_values = np.asarray([item["rmse_3d"] for item in per_flight]) low, high = bootstrap_mean_ci(rmse_values, rng) def macro(key: str) -> float: return float(np.mean([item[key] for item in per_flight])) output.append( { "variable": variable, "bin_index": bin_index + 1, "lower": float(edges[bin_index]), "upper": float(edges[bin_index + 1]), "frame_count": frame_count, "flight_count": len(per_flight), "error_3d_rmse_m": macro("rmse_3d"), "error_3d_rmse_ci95_low_m": low, "error_3d_rmse_ci95_high_m": high, "error_3d_p95_m": macro("p95_3d"), "horizontal_rmse_m": macro("rmse_horizontal"), "horizontal_p95_m": macro("p95_horizontal"), "vertical_rmse_m": macro("rmse_vertical"), "vertical_p95_m": macro("p95_vertical"), } ) return output def date_comparison( evaluations: Sequence[Evaluation], ) -> dict[str, Any]: days = sorted({item.flight.spec.experiment_day for item in evaluations}) if len(days) != 2: raise ValueError(f"Expected exactly two acquisition days: {days}") first = np.asarray( [ item.metrics["error_3d_rmse_m"] for item in evaluations if item.flight.spec.experiment_day == days[0] ], dtype=np.float64, ) second = np.asarray( [ item.metrics["error_3d_rmse_m"] for item in evaluations if item.flight.spec.experiment_day == days[1] ], dtype=np.float64, ) observed = float(np.mean(first) - np.mean(second)) rng = np.random.default_rng(BOOTSTRAP_SEED) first_boot = first[ rng.integers( 0, len(first), size=(BOOTSTRAP_REPLICATES, len(first)), ) ].mean(axis=1) second_boot = second[ rng.integers( 0, len(second), size=(BOOTSTRAP_REPLICATES, len(second)), ) ].mean(axis=1) low, high = np.percentile(first_boot - second_boot, [2.5, 97.5]) combined = np.concatenate((first, second)) permutation_differences: list[float] = [] for indices in itertools.combinations(range(len(combined)), len(first)): mask = np.zeros(len(combined), dtype=bool) mask[list(indices)] = True permutation_differences.append( float(np.mean(combined[mask]) - np.mean(combined[~mask])) ) permutation = np.asarray(permutation_differences) p_two_sided = ( np.count_nonzero(np.abs(permutation) >= abs(observed)) - 1 ) / (len(permutation) - 1) return { "unit": "flight", "metric": "per-flight 3D RMSE", "first_day": days[0], "second_day": days[1], "first_day_flight_count": len(first), "second_day_flight_count": len(second), "first_day_macro_rmse_m": float(np.mean(first)), "second_day_macro_rmse_m": float(np.mean(second)), "difference_first_minus_second_m": observed, "bootstrap_95_interval_m": [float(low), float(high)], "bootstrap_replicates": BOOTSTRAP_REPLICATES, "bootstrap_seed": BOOTSTRAP_SEED, "exact_permutation_two_sided_p": float(p_two_sided), "interpretation": ( "Descriptive flight-level comparison; trajectories are not paired " "between acquisition days." ), } def lever_sensitivity( flights: Sequence[FlightData], calibration: dict[str, Any], ) -> list[dict[str, Any]]: output: list[dict[str, Any]] = [] for lever_z in LEVER_Z_SENSITIVITY_M: evaluations = [ evaluate_flight(flight, calibration, lever_z_m=lever_z) for flight in flights ] overall = aggregate(evaluations) by_day = { day: aggregate( [ item for item in evaluations if item.flight.spec.experiment_day == day ] ) for day in sorted( {item.flight.spec.experiment_day for item in evaluations} ) } output.append( { "uav_rtk_antenna_z_in_u_m": lever_z, "all_macro_3d_rmse_m": overall["macro_error_3d_rmse_m"], "all_macro_3d_p95_m": overall["macro_error_3d_p95_m"], "all_macro_horizontal_rmse_m": overall[ "macro_horizontal_rmse_m" ], "all_macro_vertical_rmse_m": overall[ "macro_vertical_rmse_m" ], **{ f"{day}_macro_3d_rmse_m": summary[ "macro_error_3d_rmse_m" ] for day, summary in by_day.items() }, } ) return output def main() -> None: args = parse_args() dataset_root = args.dataset_root.resolve() script_dir = Path(__file__).resolve().parent output_dir = ( args.output_dir.resolve() if args.output_dir else script_dir / "output" ) output_dir.mkdir(parents=True, exist_ok=True) calibration = read_json(script_dir / "calibration.json") world = calibration["frames"]["world"] origin = ( float(world["origin_llh_gga"]["latitude_deg"]), float(world["origin_llh_gga"]["longitude_deg"]), float(world["origin_llh_gga"]["altitude_m"]), ) flights = [load_flight(dataset_root, spec, origin) for spec in FLIGHTS] evaluations = [ evaluate_flight(flight, calibration) for flight in flights ] per_flight = [item.metrics for item in evaluations] overall = aggregate(evaluations) by_day = { day: aggregate( [ item for item in evaluations if item.flight.spec.experiment_day == day ] ) for day in sorted({item.flight.spec.experiment_day for item in evaluations}) } summary = { "generated_at_utc": datetime.now(timezone.utc).isoformat(), "method": { "state_selection": ( "lifecycle=confirmed && state_valid=1 && numerical_ok=1 " "&& command_valid=1" ), "rtk_quality": 4, "rtk_interpolation": "bracketing linear", "maximum_rtk_gap_s": MAX_RTK_GAP_S, "rtk_extrapolation": False, }, "overall": overall, "by_day": by_day, "date_comparison": date_comparison(evaluations), } write_json(output_dir / "accuracy_summary.json", summary) write_csv(output_dir / "accuracy_by_flight.csv", per_flight) write_csv(output_dir / "paired_errors.csv", frame_rows(evaluations)) write_csv( output_dir / "range_azimuth_elevation_sensitivity.csv", sensitivity_rows(evaluations), ) write_csv( output_dir / "uav_lever_arm_sensitivity.csv", lever_sensitivity(flights, calibration), ) print( json.dumps( { "flight_count": overall["flight_count"], "paired_rows": overall["paired_rows"], "macro_3d_rmse_m": overall["macro_error_3d_rmse_m"], "macro_3d_p95_m": overall["macro_error_3d_p95_m"], "output_dir": str(output_dir), }, ensure_ascii=False, indent=2, ) ) if __name__ == "__main__": main()