"""Compute TTC/DRAC and lane-change-event PET from metric trajectories.""" import warnings import numpy as np import pandas as pd from _common import lane_direction, numeric, parser, read_csv, require, save_csv, unique def time_from_intervals(df): """Recover recording-relative time from the released frame-interval field.""" df = df.copy() numeric(df, ["Frame", "Ego_Vehicle_ID"], integer=True) unique(df, ["Frame", "Ego_Vehicle_ID"]) require(df, ["Delta_t_s"]) if "Time_Reference_ID" in df: raise ValueError("Resolve existing Time_Reference_ID before deriving a new time reference") delta = pd.to_numeric(df.Delta_t_s, errors="raise") observed = delta.notna() if not np.isfinite(delta[observed]).all() or delta[observed].le(0).any(): raise ValueError("Observed Delta_t_s values must be finite and positive") ordered = df.assign(_delta=delta).sort_values(["Ego_Vehicle_ID", "Frame"]) differences = ordered.groupby("Ego_Vehicle_ID").Frame.diff() if differences.dropna().ne(1).any() or ordered.loc[differences.notna(), "_delta"].isna().any(): raise ValueError("Require consecutive vehicle frames with Delta_t_s after each first record") intervals = df.loc[observed, ["Frame"]].assign(_delta=delta[observed]).groupby("Frame")._delta.agg(["min", "max"]) if not np.isclose(intervals["min"], intervals["max"], rtol=1e-8, atol=1e-10).all(): raise ValueError("Conflicting Delta_t_s values for the same processed frame") times, references = {}, {} previous, elapsed, reference = None, 0.0, -1 for frame in np.sort(df.Frame.unique()): frame = int(frame) if previous is None or frame != previous + 1 or frame not in intervals.index: reference += 1 elapsed = 0.0 else: elapsed += float(intervals.loc[frame, "min"]) times[frame], references[frame] = elapsed, reference previous = frame df["Time_s"] = df.Frame.map(times) df["Time_Reference_ID"] = df.Frame.map(references) if df.groupby("Ego_Vehicle_ID").Time_Reference_ID.nunique().gt(1).any(): raise ValueError("A vehicle spans disconnected time references; inspect its frame/interval mapping") return df def crossing_time(times, xs, target, start, sign): indexes = np.flatnonzero(times >= start) if len(indexes) < 2: return None signed = (xs - target) * sign for k in range(indexes[0], len(times) - 1): if signed[k] >= 0: return times[k] if signed[k + 1] >= 0: return times[k] - signed[k] / (signed[k + 1] - signed[k]) * (times[k + 1] - times[k]) return None def annotate(df, drac_cap=15.0, fallback_length=None): df = df.copy() require(df, ["Lane number", "Direction", "Vehicle_Length_m"]) lane_direction(df) numeric(df, ["Frame", "Ego_Vehicle_ID"], integer=True) numeric(df, ["Time_s", "x_center", "v_x"]) unique(df, ["Frame", "Ego_Vehicle_ID"]) if df[["Lane number", "Direction"]].isna().any().any(): raise ValueError("Lane and Direction cannot be missing") if "Source_ID" in df and (df.Source_ID.isna().any() or df.Source_ID.nunique() != 1): raise ValueError("Compute risk separately for each source recording") if drac_cap <= 0 or np.isnan(drac_cap): raise ValueError("DRAC cap must be positive; use inf for no cap") lengths = pd.to_numeric(df.Vehicle_Length_m, errors="raise") if lengths.isna().any(): if fallback_length is None or not np.isfinite(fallback_length) or fallback_length <= 0: raise ValueError("Missing lengths: supply actual estimates or explicitly opt into a fallback") warnings.warn(f"Using {fallback_length} m for {lengths.isna().sum()} missing length rows") lengths = lengths.fillna(fallback_length) if not np.isfinite(lengths).all() or lengths.le(0).any(): raise ValueError("Lengths must be positive and finite") df["_length"] = lengths df = df.sort_values(["Ego_Vehicle_ID", "Frame"]).reset_index(drop=True) grouped = df.groupby("Ego_Vehicle_ID", sort=False) if grouped._length.nunique().gt(1).any() or grouped.Direction.nunique().gt(1).any(): raise ValueError("Length and Direction must be constant within each trajectory") if grouped.Frame.diff().dropna().ne(1).any(): raise ValueError("PET requires gap-filled consecutive trajectory frames") if grouped.Time_s.diff().dropna().le(0).any() or df.groupby("Frame").Time_s.nunique().gt(1).any(): raise ValueError("Inconsistent physical times") previous = grouped["Lane number"].shift() df["_cutin"] = previous.notna() & previous.ne(df["Lane number"]) cache = {vid: (g.Time_s.to_numpy(), g.x_center.to_numpy()) for vid, g in grouped} parts = [] for _, group in df.groupby(["Frame", "Direction"], sort=False): group = group.copy().reset_index(drop=True) n = len(group) x, v = group.x_center.to_numpy(), group.v_x.to_numpy() lane, ids = group["Lane number"].to_numpy(), group.Ego_Vehicle_ID.to_numpy() length, times = group._length.to_numpy(), group.Time_s.to_numpy() ttc, pet, drac = np.full(n, np.inf), np.full(n, np.nan), np.zeros(n) target_ttc, target_pet = np.full(n, -1, dtype=np.int64), np.full(n, -1, dtype=np.int64) for i in range(n): sign = np.sign(v[i]) if sign == 0: continue leaders = np.flatnonzero((lane == lane[i]) & ((x - x[i]) * sign > 0)) if len(leaders): j = leaders[np.argmin(np.abs(x[leaders] - x[i]))] clearance = abs(x[j] - x[i]) - (length[i] + length[j]) / 2 closing = abs(v[i]) - abs(v[j]) if clearance > 0 and closing > 0: ttc[i], drac[i] = clearance / closing, min(closing ** 2 / (2 * clearance), drac_cap) target_ttc[i] = ids[j] if group._cutin.iloc[i]: followers = np.flatnonzero((lane == lane[i]) & ((x[i] - x) * sign > 0)) if not len(followers): continue j = followers[np.argmin(np.abs(x[followers] - x[i]))] clear = crossing_time(*cache[ids[i]], x[i] + sign * length[i] / 2, times[i], sign) arrive = crossing_time(*cache[ids[j]], x[i] - sign * length[j] / 2, times[i], sign) if clear is not None and arrive is not None: value = max(0.0, arrive - clear) for a, b in [(i, j), (j, i)]: if np.isnan(pet[a]) or value < pet[a]: pet[a], target_pet[a] = value, ids[b] high_pet, high_long = pet < 2.5, (ttc < 3.0) | (drac > 3.0) target = np.where(high_pet, target_pet, np.where(high_long, target_ttc, np.where(target_ttc != -1, target_ttc, target_pet))) group["TTC"], group["PET"], group["DRAC"] = ttc, pet, drac group["Max_Risk_Target_ID"] = target group["Risk_Level"] = np.where(high_pet | high_long, "High Risk", "Low Risk") parts.append(group) return pd.concat(parts, ignore_index=True).drop(columns=["_length", "_cutin"]).sort_values( ["Ego_Vehicle_ID", "Frame"]).reset_index(drop=True) def main(): p = parser(__doc__) p.add_argument("--input", required=True, help="Released observation-group Basic CSV or single-source Basic CSV, with metric lengths") p.add_argument("--output", required=True, help="New Risk Semantic CSV") p.add_argument("--fps", type=float, help="Explicit constant source FPS; otherwise use Time_s or released Delta_t_s") p.add_argument("--drac-cap", type=float, default=15.0, help="DRAC cap in m/s^2 (default: 15)") p.add_argument("--fallback-length-m", type=float, help="Optional replacement length in meters for records with missing length") a = p.parse_args() df = read_csv(a.input) if "Time_s" not in df: if a.fps is not None: if not np.isfinite(a.fps) or a.fps <= 0: p.error("Provide a finite positive constant --fps") numeric(df, ["Frame"], integer=True) df["Time_s"] = (df.Frame - df.Frame.min()) / a.fps elif "Delta_t_s" in df: df = time_from_intervals(df) else: p.error("Provide Time_s, released Delta_t_s, or the actual constant --fps") elif a.fps is not None: p.error("Time_s already exists; omit --fps") print(f"DRAC cap={a.drac_cap}; no-closing TTC=inf; PET is event-level") save_csv(annotate(df, a.drac_cap, a.fallback_length_m), a.output) if __name__ == "__main__": main()