| """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("Fill the calibration template before setting template_only to 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("This release implements the supplied no-rotation workflow") |
| ratios = [] |
| for segment in config["reference_segments"]: |
| distance = np.linalg.norm(np.asarray(segment["point_a"], dtype=float) - |
| np.asarray(segment["point_b"], dtype=float)) |
| 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) |
| 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] |
| 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") |
| cv2.setRNGSeed(0) |
| self.homography, mask = cv2.findHomography(src, dst, cv2.RANSAC, 3.0) |
| if self.homography is None or mask.sum() < 4: |
| raise ValueError("Homography estimation failed") |
| print(f"Source={source}; master={config['master_source']}; scale={self.scale:.10g} m/px") |
| if entry.get("validation_src") is not None: |
| check = self.transform(entry["validation_src"]) |
| expected = (np.asarray(entry["validation_master"], dtype=float) - 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) |
| 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"Calibration blocked pending author review: {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() |
|
|
