"""Source pixels -> master frame -> road-aligned local metric coordinates.""" import json import cv2 import numpy as np from _common import numeric, parser, read_csv, save_csv, unique class Calibration: def __init__(self, config, source): if config.get("template_only", False): raise ValueError("Use a measured scene calibration with template_only=false") self.origin = np.asarray(config["origin_px"], dtype=float) if self.origin.shape != (2,) or not np.isfinite(self.origin).all(): raise ValueError("origin_px must contain two finite coordinates") if config.get("rotation_rad", 0) != 0: raise ValueError("rotation_rad must be 0 for the supplied road-aligned coordinate conversion") ratios = [] self.references = [] for segment in config["reference_segments"]: a = np.asarray(segment["point_a"], dtype=float) b = np.asarray(segment["point_b"], dtype=float) if a.shape != (2,) or b.shape != (2,) or not np.isfinite([a, b]).all(): raise ValueError("Reference endpoints must each contain two finite pixel coordinates") distance = np.linalg.norm(a - b) real = float(segment["real_distance_m"]) if not np.isfinite([distance, real]).all() or min(distance, real) <= 0: raise ValueError("Reference distances must be finite and positive") ratios.append(real / distance) self.references.append({"name": segment.get("name", ""), "pixel_distance": float(distance), "real_distance_m": real, "scale_m_per_px": float(real / distance)}) if not ratios: raise ValueError("At least one measured master-frame reference is required") self.scale = float(np.mean(ratios)) self.source = source if config["master_source"] not in config["sources"] or source not in config["sources"]: raise ValueError("master_source and --source must identify entries in sources") self.master = source == config["master_source"] entry = config["sources"][source] self.diagnostics = {"source": source, "master_source": config["master_source"], "scale_m_per_px": self.scale, "references": self.references, "control_points": [], "validation_points": [], "review_blocked": bool(entry.get("review_blocked", False))} if self.master: self.homography = np.eye(3) else: src = np.asarray(entry["src_points"], dtype=np.float32) dst = np.asarray(entry["master_points"], dtype=np.float32) if src.shape != dst.shape or src.ndim != 2 or src.shape[1] != 2 or len(src) < 4: raise ValueError("At least four corresponding 2D control points are required") if not np.isfinite(src).all() or not np.isfinite(dst).all(): raise ValueError("Non-finite control points") if any(np.linalg.matrix_rank(np.column_stack([p, np.ones(len(p))])) < 3 for p in (src, dst)): raise ValueError("Control points must not all be collinear") cv2.setRNGSeed(0) self.homography, mask = cv2.findHomography(src, dst, cv2.RANSAC, 3.0) if self.homography is None or mask is None or mask.sum() < 4: raise ValueError("Homography estimation failed") if not np.isfinite(self.homography).all() or np.linalg.matrix_rank(self.homography) != 3: raise ValueError("Non-finite or singular homography") predicted = cv2.perspectiveTransform(src.reshape(-1, 1, 2), self.homography).reshape(-1, 2) errors = np.linalg.norm(predicted - dst, axis=1) self.diagnostics["inlier_ratio"] = float(mask.mean()) self.diagnostics["control_points"] = [ {"point": int(i + 1), "source_px": a.tolist(), "master_px": b.tolist(), "predicted_master_px": c.tolist(), "error_px": float(e), "error_m": float(e * self.scale), "inlier": bool(m)} for i, (a, b, c, e, m) in enumerate(zip(src, dst, predicted, errors, mask.ravel()))] self.diagnostics["control_rmse_px"] = float(np.sqrt(np.mean(errors ** 2))) print(f"Source={source}; master={config['master_source']}; scale={self.scale:.10g} m/px") self.diagnostics["homography"] = self.homography.tolist() validation_src, validation_master = entry.get("validation_src"), entry.get("validation_master") if (validation_src is None) != (validation_master is None): raise ValueError("Supply both validation_src and validation_master, or leave both null") if validation_src is not None: points = np.asarray(validation_src, dtype=float) expected_points = np.asarray(validation_master, dtype=float) if points.ndim != 2 or points.shape[1:] != (2,) or len(points) == 0 or points.shape != expected_points.shape: raise ValueError("Independent validation points must be nonempty matched Nx2 arrays") check = self.transform(points) expected = (expected_points - self.origin) * [self.scale, -self.scale] if check.shape != expected.shape or not np.isfinite(expected).all(): raise ValueError("Invalid independent validation points") error = np.linalg.norm(check - expected, axis=1) self.diagnostics["validation_rmse_m"] = float(np.sqrt(np.mean(error ** 2))) self.diagnostics["validation_max_m"] = float(error.max()) self.diagnostics["validation_points"] = [ {"point": i + 1, "source_px": a.tolist(), "master_px": b.tolist(), "error_m": float(e)} for i, (a, b, e) in enumerate(zip(points, expected_points, error))] print(f"Independent checkpoints={len(error)}; RMSE={np.sqrt(np.mean(error ** 2)):.6f} m; max={error.max():.6f} m") if entry.get("review_blocked", False): raise ValueError(f"Selected source calibration is disabled by its configuration: {entry.get('review_note', source)}") def transform(self, points): points = np.asarray(points, dtype=float).reshape(-1, 2) if not np.isfinite(points).all(): raise ValueError("Non-finite pixel coordinates") if not self.master: denominator = points @ self.homography[2, :2] + self.homography[2, 2] if np.any(np.abs(denominator) < 1e-10): raise ValueError("Points lie on the homography horizon") points = cv2.perspectiveTransform(points.astype(np.float32).reshape(-1, 1, 2), self.homography).reshape(-1, 2).astype(float) result = (points - self.origin) * [self.scale, -self.scale] if not np.isfinite(result).all(): raise ValueError("Non-finite transformed coordinates") return result def load_calibration(path, source): with open(path, encoding="utf-8") as handle: return Calibration(json.load(handle), source) def main(): p = parser(__doc__) p.add_argument("--input", required=True, help="Raw pixel trajectory CSV") p.add_argument("--calibration", required=True, help="Scene calibration JSON") p.add_argument("--source", required=True, help="Source video key in the calibration JSON") p.add_argument("--output", required=True, help="New metric trajectory CSV") args = p.parse_args() df = read_csv(args.input) numeric(df, ["Frame", "Vehicle_ID"], integer=True) numeric(df, ["x_center_px", "y_center_px"]) unique(df, ["Frame", "Vehicle_ID"]) if "Source_ID" in df and not df.Source_ID.eq(args.source).all(): raise ValueError("Process one source at a time; Source_ID disagrees with --source") cal = load_calibration(args.calibration, args.source) df[["x_center", "y_center"]] = cal.transform(df[["x_center_px", "y_center_px"]]) df["Source_ID"] = args.source save_csv(df, args.output) if __name__ == "__main__": main()