| """Annotate all supplied candidate pairs using existing calibrated PR parameters.""" |
| import numpy as np |
| import pandas as pd |
|
|
| from _common import numeric, output_path, parser, read_csv, require, unique |
|
|
|
|
| PARAMETERS = [f"{name}_{side}" for name in ["rx", "ry", "bx", "by"] for side in ["plus", "minus"]] |
| PAIR_COLUMNS = ["Frame", "EV_Vehicle_ID", "POV_Vehicle_ID", "x_local", "y_local", "v_rel", "cangle"] |
| SEMANTICS = ["Interaction_Target_ID", "x_local", "y_local", "v_rel", "Interaction Strength", |
| "Is Interacting", "Interaction Type"] |
|
|
|
|
| def validate_parameters(params): |
| params = params.copy() |
| numeric(params, ["cangle"], integer=True) |
| numeric(params, ["round_v"] + PARAMETERS) |
| unique(params, ["cangle", "round_v"]) |
| if not params.cangle.isin([0, 1]).all() or params[PARAMETERS].le(0).any().any(): |
| raise ValueError("cangle must be binary and all PR parameters must be positive") |
| params["round_v"] = params.round_v.astype(float) |
| return params.sort_values("round_v") |
|
|
|
|
| def annotate_pairs(pairs, basic, params, tolerance=None): |
| pairs = pairs.copy() |
| numeric(pairs, ["Frame", "EV_Vehicle_ID", "POV_Vehicle_ID", "cangle"], integer=True) |
| numeric(pairs, ["x_local", "y_local", "v_rel"]) |
| unique(pairs, ["Frame", "EV_Vehicle_ID", "POV_Vehicle_ID"]) |
| if (pairs.EV_Vehicle_ID == pairs.POV_Vehicle_ID).any() or not pairs.cangle.isin([0, 1]).all(): |
| raise ValueError("Invalid pair IDs or cangle; cangle is a binary class, NOT an angle in radians") |
| if pairs.v_rel.le(0).any() or np.hypot(pairs.x_local, pairs.y_local).gt(50.0 + 1e-6).any(): |
| raise ValueError("Candidate pairs must have nonzero relative speed and be within 50 m") |
| pairs["round_v"] = pairs.v_rel.round(1).astype(float) |
| joined = pd.merge_asof(pairs.sort_values("round_v"), params, on="round_v", by="cangle", |
| direction="nearest", tolerance=tolerance) |
| if joined[PARAMETERS].isna().any().any(): |
| raise ValueError("Missing calibrated parameters: do not silently discard candidate pairs") |
| pr_exponent = np.zeros(len(joined)) |
| for axis in ["x", "y"]: |
| sign = np.sign(joined[f"{axis}_local"]) |
| scale = (1 + sign) / 2 * joined[f"r{axis}_plus"] + (1 - sign) / 2 * joined[f"r{axis}_minus"] |
| shape = (1 + sign) / 2 * joined[f"b{axis}_plus"] + (1 - sign) / 2 * joined[f"b{axis}_minus"] |
| pr_exponent += np.abs(joined[f"{axis}_local"] / scale) ** shape |
| joined["Interaction Strength"] = np.exp(-pr_exponent) |
| joined["Is Interacting"] = (joined["Interaction Strength"] > np.exp(-1)).astype(int) |
| lookup = basic.set_index(["Frame", "Ego_Vehicle_ID"]) |
| lanes, directions = [], [] |
| for role in ["EV", "POV"]: |
| keys = pd.MultiIndex.from_arrays([joined.Frame, joined[f"{role}_Vehicle_ID"]]) |
| values = lookup.reindex(keys) |
| if values[["Lane number", "Direction"]].isna().any().any(): |
| raise ValueError("Pair vehicle/frame lacks a valid basic trajectory, lane, or direction") |
| lanes.append(values["Lane number"].to_numpy()) |
| directions.append(values.Direction.to_numpy()) |
| if not np.equal(*directions).all(): |
| raise ValueError("Only same-direction candidate pairs are supported") |
| joined["Interaction Type"] = np.where(joined.cangle.eq(1), "Lane Changing/Weaving", |
| np.where(np.equal(*lanes), "Car Following", "Parallel Driving")) |
| joined = joined.rename(columns={"EV_Vehicle_ID": "Ego_Vehicle_ID", "POV_Vehicle_ID": "Interaction_Target_ID"}) |
| return joined[["Frame", "Ego_Vehicle_ID"] + SEMANTICS] |
|
|
|
|
| def process(basic, pairs_path, params, output, chunksize=500000, tolerance=None): |
| basic = basic.copy() |
| numeric(basic, ["Frame", "Ego_Vehicle_ID"], integer=True) |
| require(basic, ["Lane number", "Direction", "x_center", "y_center"]) |
| unique(basic, ["Frame", "Ego_Vehicle_ID"]) |
| if "Source_ID" in basic and basic.Source_ID.nunique() != 1: |
| raise ValueError("Run separately for each source recording") |
| if set(SEMANTICS) & set(basic.columns): |
| raise ValueError("Input must be Basic Trajectory data without existing interaction fields") |
| params = validate_parameters(params) |
| seen, first, count = set(), True, 0 |
| last_frame, boundary_pairs = None, set() |
| |
| with output_path(output) as temporary, pd.read_csv(pairs_path, usecols=PAIR_COLUMNS, chunksize=chunksize) as reader: |
| for chunk in reader: |
| if chunk.empty: |
| continue |
| numeric(chunk, ["Frame", "EV_Vehicle_ID", "POV_Vehicle_ID"], integer=True) |
| if not chunk.Frame.is_monotonic_increasing or (last_frame is not None and chunk.Frame.iloc[0] < last_frame): |
| raise ValueError("Candidate CSV must be sorted by Frame for cross-block duplicate validation") |
| if last_frame is not None: |
| overlap = chunk.loc[chunk.Frame.eq(last_frame), ["EV_Vehicle_ID", "POV_Vehicle_ID"]] |
| if boundary_pairs.intersection(map(tuple, overlap.to_numpy())): |
| raise ValueError("Duplicate candidate pair across CSV blocks") |
| tail = chunk.loc[chunk.Frame.eq(chunk.Frame.iloc[-1]), ["EV_Vehicle_ID", "POV_Vehicle_ID"]] |
| tail_pairs = set(map(tuple, tail.to_numpy())) |
| boundary_pairs = boundary_pairs | tail_pairs if last_frame == chunk.Frame.iloc[-1] else tail_pairs |
| last_frame = chunk.Frame.iloc[-1] |
| annotations = annotate_pairs(chunk, basic, params, tolerance) |
| seen.update(zip(annotations.Frame, annotations.Ego_Vehicle_ID)) |
| result = annotations.merge(basic, on=["Frame", "Ego_Vehicle_ID"], how="left", validate="many_to_one") |
| result = result[list(basic.columns) + SEMANTICS] |
| result.to_csv(temporary, mode="w" if first else "a", header=first, index=False) |
| first, count = False, count + len(result) |
| absent = basic.loc[[key not in seen for key in zip(basic.Frame, basic.Ego_Vehicle_ID)]].copy() |
| absent["Interaction_Target_ID"] = -1 |
| absent[["x_local", "y_local", "v_rel"]] = np.nan |
| absent["Interaction Strength"], absent["Is Interacting"], absent["Interaction Type"] = 0.0, 0, "Safe" |
| absent = absent[list(basic.columns) + SEMANTICS] |
| absent.to_csv(temporary, mode="w" if first else "a", header=first, index=False) |
| count += len(absent) |
| print(f"Saved {count:,} rows; all candidate pairs retained regardless of PR threshold") |
|
|
|
|
| def main(): |
| p = parser(__doc__) |
| p.add_argument("--input", required=True, help="One-source Basic Trajectory CSV, final metric coordinates") |
| p.add_argument("--pairs", required=True, help="Existing validated candidate-pair CSV, not generated here") |
| p.add_argument("--parameters", required=True, help="Existing scenario-specific MLE calibration CSV") |
| p.add_argument("--output", required=True, help="New Interaction Semantic CSV") |
| p.add_argument("--chunksize", type=int, default=500000) |
| p.add_argument("--speed-tolerance", type=float, help="Optional nearest-bin tolerance; omitted preserves source rule") |
| a = p.parse_args() |
| if a.chunksize < 1 or (a.speed_tolerance is not None and a.speed_tolerance < 0): |
| p.error("Invalid chunk size or speed tolerance") |
| process(read_csv(a.input), a.pairs, read_csv(a.parameters), a.output, a.chunksize, a.speed_tolerance) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
