| """Generate directed same-direction pairs and the author's relative-velocity local coordinates.""" |
| import json |
| from pathlib import Path |
| import numpy as np |
| import pandas as pd |
| from scipy.spatial import cKDTree |
| from _common import numeric, output_path, parser, read_csv, require, unique, preflight_outputs |
|
|
| PAIR_COLUMNS = ["Frame", "EV_Vehicle_ID", "POV_Vehicle_ID", "x_local", "y_local", "v_rel", "cangle", |
| "cangle_deg", "Distance_m", "Angle_Defined"] |
|
|
|
|
| def iter_pairs(basic, distance_threshold=50.0, min_distance=0.5, x_column="x_center", y_column="y_center", audit=None): |
| basic = basic.copy() |
| if not np.isfinite([distance_threshold, min_distance]).all() or not 0 <= min_distance < distance_threshold: |
| raise ValueError("Require 0 <= min_distance < distance_threshold") |
| numeric(basic, ["Frame", "Ego_Vehicle_ID"], integer=True) |
| numeric(basic, [x_column, y_column, "v_x", "v_y"]) |
| require(basic, ["Direction"]) |
| unique(basic, ["Frame", "Ego_Vehicle_ID"]) |
| if not basic.Direction.isin(["Left", "Right"]).all(): |
| raise ValueError("Direction must be Left or Right") |
| if "Source_ID" in basic and (basic.Source_ID.isna().any() or basic.Source_ID.nunique() != 1): |
| raise ValueError("Process one synchronized source recording at a time") |
| if "Time_s" in basic: |
| numeric(basic, ["Time_s"]) |
| if basic.groupby("Frame").Time_s.nunique().gt(1).any(): |
| raise ValueError("A frame must represent a single physical time") |
| stats = audit if audit is not None else {} |
| stats.update(input_rows=len(basic), output_pairs=0, zero_relative_velocity_pairs=0, undefined_heading_angle_pairs=0, |
| max_distance_m=distance_threshold, max_distance_inclusive=False, min_distance_m=min_distance, |
| min_distance_inclusive=True, position_difference="POV-EV", velocity_difference="EV-POV") |
| for (frame, direction), group in basic.groupby(["Frame", "Direction"], sort=True): |
| if len(group) < 2: |
| continue |
| group = group.sort_values("Ego_Vehicle_ID") |
| xy = group[[x_column, y_column]].to_numpy(float) |
| undirected = cKDTree(xy).query_pairs(distance_threshold, output_type="ndarray") |
| if not len(undirected): |
| continue |
| indexes = np.concatenate([undirected, undirected[:, ::-1]]) |
| i, j = indexes.T |
| delta = xy[j] - xy[i] |
| distance = np.linalg.norm(delta, axis=1) |
| velocity = group[["v_x", "v_y"]].to_numpy(float) |
| dv = velocity[i] - velocity[j] |
| relative = np.linalg.norm(dv, axis=1) |
| eligible = (distance >= min_distance) & (distance < distance_threshold) |
| stats["zero_relative_velocity_pairs"] += int((eligible & (relative == 0)).sum()) |
| keep = eligible & (relative != 0) |
| i, j, delta, dv, distance, relative = i[keep], j[keep], delta[keep], dv[keep], distance[keep], relative[keep] |
| if not len(i): |
| continue |
| vi, vj = velocity[i], velocity[j] |
| cross = vi[:, 0] * vj[:, 1] - vj[:, 0] * vi[:, 1] |
| dot = np.sum(vi * vj, axis=1) |
| angle = -np.degrees(np.arctan2(cross, dot)) |
| defined = (np.linalg.norm(vi, axis=1) > 0) & (np.linalg.norm(vj, axis=1) > 0) |
| |
| stats["undefined_heading_angle_pairs"] += int((~defined).sum()) |
| ids = group.Ego_Vehicle_ID.to_numpy() |
| out = pd.DataFrame({"Frame": frame, "EV_Vehicle_ID": ids[i], "POV_Vehicle_ID": ids[j], |
| "x_local": (dv[:, 1] * delta[:, 0] - dv[:, 0] * delta[:, 1]) / relative, |
| "y_local": np.sum(dv * delta, axis=1) / relative, |
| "v_rel": relative, "cangle": ((np.abs(angle) >= 5) & (np.abs(angle) <= 175)).astype(int), |
| "cangle_deg": angle, "Distance_m": distance, "Angle_Defined": defined}) |
| stats["output_pairs"] += len(out) |
| yield out.sort_values(["EV_Vehicle_ID", "POV_Vehicle_ID"]).reset_index(drop=True) |
|
|
|
|
| def generate_pairs(basic, **kwargs): |
| parts = list(iter_pairs(basic, **kwargs)) |
| return pd.concat(parts, ignore_index=True) if parts else pd.DataFrame(columns=PAIR_COLUMNS) |
|
|
|
|
| def main(): |
| p = parser(__doc__) |
| p.add_argument("--input", required=True, help="Released observation-group Basic CSV or single-source Basic CSV; positions in meters") |
| p.add_argument("--output", required=True, help="New frame-sorted directed pair CSV") |
| p.add_argument("--audit", required=True, help="New JSON counts and conventions") |
| p.add_argument("--x-column", default="x_center", help="Metric longitudinal coordinate column; x_reconstructed for older reconstruction tables") |
| p.add_argument("--y-column", default="y_center", help="Metric lateral coordinate column; y_reconstructed for older reconstruction tables") |
| p.add_argument("--max-distance-m", type=float, default=50.) |
| p.add_argument("--min-distance-m", type=float, default=0.5, help="Minimum center-distance cutoff in meters") |
| a = p.parse_args() |
| preflight_outputs(a.output, a.audit) |
| if Path(a.audit).resolve() == Path(a.output).resolve() or Path(a.audit).exists(): |
| raise FileExistsError("Choose distinct new output and audit filenames") |
| stats = {} |
| with output_path(a.output) as temporary: |
| first = True |
| for part in iter_pairs(read_csv(a.input), a.max_distance_m, a.min_distance_m, a.x_column, a.y_column, stats): |
| part.to_csv(temporary, mode="w" if first else "a", header=first, index=False) |
| first = False |
| if first: |
| pd.DataFrame(columns=PAIR_COLUMNS).to_csv(temporary, index=False) |
| with output_path(a.audit) as temporary: |
| Path(temporary).write_text(json.dumps(stats, indent=2, allow_nan=False), encoding="utf-8") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
