feat(RCLane): switch to C++ for runtime modeling

.gitignore

@@ -19,6 +19,14 @@ checkpoints/
 *.pt
 *.onnx
 *.ckpt
+*.engine
+*.profile
+*.timing
+exports/
+cpp/build*/
+
+# local videos / visualization outputs
+*.mp4
 
 # python
 __pycache__/

README.md

@@ -84,8 +84,32 @@ python eval_checkpoints.py --data-root data/dataset \
 # Export a checkpoint and verify its outputs with ONNX Runtime
 python export_onnx.py --checkpoint checkpoints/rclane_b0_e19.pth \
     --output exports/rclane_b0_e19.onnx --check-runtime
+
+# Build/cache a device-specific TensorRT FP16 engine and compare it to CUDA FP32
+python build_tensorrt_engine.py --model exports/rclane_b0_e19.onnx \
+    --cache-dir exports/trt_cache
+
+# Benchmark the sequential production core (preprocess + engine + 1024-seed
+# decode + raw-model BEV) without visualization/video-I/O
+python benchmark_realtime.py --model exports/rclane_b0_e19.onnx \
+    --video raw_Town04_Opt_20260714_093110.mp4 --provider tensorrt \
+    --trt-cache-dir exports/trt_cache --cpu-threads 8 --max-seeds 1024 \
+    --max-frames 300 --report runs/realtime_benchmark_1024seeds.json
+
+# Render raw decoded lanes in BEV and export one cubic per detected lane.
+# No lane is synthesized or forced parallel; cubics are clipped to camera FOV.
+python test_video_bev_onnx.py --model exports/rclane_b0_e19.onnx \
+    --video raw_Town04_Opt_20260714_093110.mp4 --provider tensorrt \
+    --trt-cache-dir exports/trt_cache --decode-cpu-threads 8 \
+    --decode-max-seeds 1024 --output runs/video_bev_e19.mp4
 ```
 
+TensorRT cache files are tied to the TensorRT version and GPU compute
+capability. Rebuild the cache on a different deployment GPU. The real-time
+benchmark deliberately reports camera/video acquisition and visualization
+separately: its core latency is the latency relevant to the ADAS algorithm,
+whereas rendering and MP4 encoding are offline diagnostics.
+
 For CUDA inference, use the CUDA 13 ONNX Runtime build pinned in
 `requirements.txt`. Disable TF32 when exact lane decisions matter:
 

benchmark_realtime.py

@@ -0,0 +1,216 @@
+"""Benchmark the optimized RCLane -> decode -> BEV core pipeline.
+
+Rendering, video writing and source-frame acquisition are reported separately
+from the sequential per-frame ADAS latency. Each frame completes inference,
+decode and raw-model BEV projection before the next frame is processed.
+"""
+
+import argparse
+import json
+import os
+import time
+from pathlib import Path
+from types import SimpleNamespace
+
+import cv2
+import numba
+import numpy as np
+
+from bev import BevRange, CameraCalibration
+from dataset import normalize_image_numpy
+from decode import decode, warmup_decode_backend
+from test_video_bev_onnx import clip_lane_results_to_funnel, lane_to_record
+from test_video_onnx import (
+    MODEL_HEIGHT,
+    MODEL_WIDTH,
+    OUTPUT_NAMES,
+    create_session,
+    softmax_foreground,
+    timing_summary,
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--video", required=True)
+    parser.add_argument("--provider", choices=("tensorrt", "cuda"),
+                        default="tensorrt")
+    parser.add_argument("--trt-cache-dir", default="exports/trt_cache")
+    parser.add_argument("--start-frame", type=int, default=0)
+    parser.add_argument("--max-frames", type=int, default=300)
+    parser.add_argument("--cpu-threads", type=int, default=8)
+    parser.add_argument("--max-seeds", type=int, default=1024)
+    parser.add_argument("--report", default="runs/realtime_benchmark.json")
+    return parser.parse_args()
+
+
+def projection_args():
+    return SimpleNamespace(funnel_margin=0.10)
+
+
+def postprocess(outputs, calibration, bev_range, config, max_seeds):
+    started = time.perf_counter()
+    stage = time.perf_counter()
+    seg_prob = softmax_foreground(outputs[0])[0]
+    softmax_ms = (time.perf_counter() - stage) * 1000.0
+    stage = time.perf_counter()
+    lanes = decode(
+        seg_prob, outputs[1][0], outputs[2][0], outputs[3][0], outputs[4][0],
+        max_seeds=max_seeds,
+        nms_max_lanes=128,
+        max_output_lanes=4,
+        crawl_backend="numba",
+        point_nms_backend="numba",
+    )
+    decode_ms = (time.perf_counter() - stage) * 1000.0
+    stage = time.perf_counter()
+    lane_results = [
+        lane_to_record(lane, calibration, bev_range, 0.5) for lane in lanes
+    ]
+    funnel = clip_lane_results_to_funnel(lane_results, config)
+    bev_ms = (time.perf_counter() - stage) * 1000.0
+    return {
+        "softmax_ms": softmax_ms,
+        "decode_ms": decode_ms,
+        "bev_ms": bev_ms,
+        "postprocess_ms": (time.perf_counter() - started) * 1000.0,
+        "lane_count": len(lanes),
+        "funnel_clipped_lanes": len(funnel["clipped_lanes"]),
+        "funnel_rejected_lanes": len(funnel["rejected_lanes"]),
+    }
+
+
+def load_frames(path, start_frame, max_frames):
+    capture = cv2.VideoCapture(str(path))
+    if not capture.isOpened():
+        raise RuntimeError(f"cannot open video: {path}")
+    capture.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+    frames = []
+    read_timings = []
+    for _ in range(max_frames):
+        started = time.perf_counter()
+        ok, frame = capture.read()
+        read_timings.append((time.perf_counter() - started) * 1000.0)
+        if not ok:
+            break
+        frames.append(frame)
+    capture.release()
+    if not frames:
+        raise RuntimeError("video produced no benchmark frames")
+    return frames, read_timings[:len(frames)]
+
+
+def summarize_results(results):
+    return {
+        name: timing_summary([result[name] for result in results])
+        for name in ("softmax_ms", "decode_ms", "bev_ms", "postprocess_ms")
+    }
+
+
+def main():
+    args = parse_args()
+    if args.start_frame < 0 or args.max_frames <= 0:
+        raise ValueError("start-frame must be >=0 and max-frames positive")
+    if args.cpu_threads <= 0 or args.cpu_threads > numba.config.NUMBA_NUM_THREADS:
+        raise ValueError(
+            f"cpu-threads must be in [1, {numba.config.NUMBA_NUM_THREADS}]"
+        )
+    if args.max_seeds <= 0:
+        raise ValueError("max-seeds must be positive")
+    model_path = Path(args.model).expanduser().resolve()
+    video_path = Path(args.video).expanduser().resolve()
+    report_path = Path(args.report).expanduser().resolve()
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+
+    cv2.setNumThreads(1)
+    numba.set_num_threads(args.cpu_threads)
+    warmup_decode_backend("numba")
+    session = create_session(
+        model_path, args.provider, False, args.trt_cache_dir
+    )
+    warmup = np.zeros((1, 3, MODEL_HEIGHT, MODEL_WIDTH), np.float32)
+    for _ in range(10):
+        session.run(list(OUTPUT_NAMES), {"images": warmup})
+    frames, read_timings = load_frames(
+        video_path, args.start_frame, args.max_frames
+    )
+    calibration = CameraCalibration()
+    bev_range = BevRange()
+    config = projection_args()
+
+    sequential_results = []
+    preprocess_timings = []
+    inference_timings = []
+    total_timings = []
+    for frame in frames:
+        total_started = time.perf_counter()
+        stage = time.perf_counter()
+        images = normalize_image_numpy(frame, MODEL_WIDTH, MODEL_HEIGHT)
+        preprocess_timings.append((time.perf_counter() - stage) * 1000.0)
+        stage = time.perf_counter()
+        outputs = session.run(list(OUTPUT_NAMES), {"images": images})
+        inference_timings.append((time.perf_counter() - stage) * 1000.0)
+        sequential_results.append(postprocess(
+            outputs, calibration, bev_range, config, args.max_seeds
+        ))
+        total_timings.append((time.perf_counter() - total_started) * 1000.0)
+
+    report = {
+        "model": str(model_path),
+        "video": str(video_path),
+        "provider": session.get_providers()[0],
+        "frames": len(frames),
+        "start_frame": args.start_frame,
+        "cpu_threads": args.cpu_threads,
+        "max_seeds": args.max_seeds,
+        "rendering_included": False,
+        "source_read_ms": timing_summary(read_timings),
+        "sequential": {
+            "preprocess_ms": timing_summary(preprocess_timings),
+            "inference_ms": timing_summary(inference_timings),
+            **summarize_results(sequential_results),
+            "core_pipeline_ms": timing_summary(total_timings),
+            "fps_from_median_latency": 1000.0 / np.median(total_timings),
+        },
+        "lane_count": {
+            "mean": float(np.mean([
+                result["lane_count"] for result in sequential_results
+            ])),
+            "min": int(min(
+                result["lane_count"] for result in sequential_results
+            )),
+            "max": int(max(
+                result["lane_count"] for result in sequential_results
+            )),
+        },
+        "bev_projection": {
+            "mode": "raw_model_projection",
+            "parallel_assumption": False,
+            "synthetic_lanes": False,
+            "funnel_clipped_lane_fits": int(sum(
+                result["funnel_clipped_lanes"]
+                for result in sequential_results
+            )),
+            "funnel_rejected_lane_fits": int(sum(
+                result["funnel_rejected_lanes"]
+                for result in sequential_results
+            )),
+        },
+    }
+    temporary = report_path.with_suffix(report_path.suffix + ".tmp")
+    with temporary.open("w") as handle:
+        json.dump(report, handle, indent=2)
+        handle.write("\n")
+    os.replace(temporary, report_path)
+    print(f"report: {report_path}")
+    print(
+        "sequential median={:.3f}ms ({:.2f} FPS)".format(
+            report["sequential"]["core_pipeline_ms"]["median_ms"],
+            report["sequential"]["fps_from_median_latency"],
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

bev.py

@@ -0,0 +1,361 @@
+"""Ego-centric inverse-perspective mapping and cubic lane fitting.
+
+The public coordinate convention is ADAS-style:
+
+    X: forward from the ego origin (metres)
+    Y: left of ego (metres)
+
+Z is used only internally to intersect an image ray with the local road plane
+``Z = 0``. The returned BEV lane points and cubic models are strictly 2-D.
+"""
+
+from dataclasses import dataclass
+from functools import lru_cache
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class CameraCalibration:
+    width: int = 1920
+    height: int = 1080
+    horizontal_fov_deg: float = 30.0
+    fx: float = 3582.768775
+    fy: float = 3582.768775
+    cx: float = 960.0
+    cy: float = 540.0
+    camera_to_vehicle: tuple = (
+        (0.997564, 0.0, 0.069756, 1.0),
+        (0.0, 1.0, 0.0, 0.0),
+        (-0.069756, 0.0, 0.997564, 1.8),
+        (0.0, 0.0, 0.0, 1.0),
+    )
+
+    @property
+    def intrinsic(self):
+        return np.array(
+            ((self.fx, 0.0, self.cx),
+             (0.0, self.fy, self.cy),
+             (0.0, 0.0, 1.0)),
+            dtype=np.float64,
+        )
+
+    @property
+    def camera_to_vehicle_matrix(self):
+        return np.asarray(self.camera_to_vehicle, dtype=np.float64)
+
+
+@dataclass(frozen=True)
+class BevRange:
+    x_min: float = 0.0
+    x_max: float = 300.0
+    y_min: float = -85.0
+    y_max: float = 85.0
+
+
+@lru_cache(maxsize=8)
+def _projection_constants(calibration):
+    optical_to_ue = np.array(
+        ((0.0, 0.0, 1.0),
+         (1.0, 0.0, 0.0),
+         (0.0, -1.0, 0.0)),
+        dtype=np.float64,
+    )
+    mount = calibration.camera_to_vehicle_matrix
+    return (
+        np.linalg.inv(calibration.intrinsic),
+        optical_to_ue,
+        mount[:3, 3].copy(),
+        mount[:3, :3].copy(),
+    )
+
+
+def pixels_to_ground(pixels, calibration=CameraCalibration(),
+                     bev_range=BevRange()):
+    """Project raw-image pixels onto the local ground plane.
+
+    Args:
+        pixels: ``(N, 2)`` raw-image coordinates ``(u, v)``.
+        calibration: pinhole intrinsics and fixed camera-to-vehicle mount.
+        bev_range: accepted metric ROI.
+
+    Returns:
+        ``(points_xy, valid_mask)``. ``points_xy`` contains only valid points in
+        ADAS coordinates ``(X forward, Y left)``. ``valid_mask`` indexes the
+        input array and is useful for carrying per-point scores through IPM.
+    """
+    pixels = np.asarray(pixels, dtype=np.float64)
+    if pixels.size == 0:
+        return np.empty((0, 2), dtype=np.float64), np.zeros(0, dtype=bool)
+    if pixels.ndim != 2 or pixels.shape[1] != 2:
+        raise ValueError("pixels must have shape (N, 2)")
+
+    finite = np.isfinite(pixels).all(axis=1)
+    homogeneous = np.column_stack((pixels, np.ones(len(pixels))))
+    inverse_intrinsic, optical_to_ue, origin_vehicle, rotation = (
+        _projection_constants(calibration)
+    )
+    rays_optical = (inverse_intrinsic @ homogeneous.T).T
+
+    # CARLA/UE camera axes are X forward, Y right, Z up. OpenCV optical axes
+    # are x right, y down, z forward: optical -> UE = (z, x, -y).
+    rays_camera_ue = (optical_to_ue @ rays_optical.T).T
+    rays_vehicle = (rotation @ rays_camera_ue.T).T
+    dz = rays_vehicle[:, 2]
+    with np.errstate(divide="ignore", invalid="ignore"):
+        scale = -origin_vehicle[2] / dz
+        ground_vehicle = origin_vehicle + scale[:, None] * rays_vehicle
+
+    # CARLA Y points right; public BEV Y points left.
+    x_forward = ground_vehicle[:, 0]
+    y_left = -ground_vehicle[:, 1]
+    valid = (
+        finite
+        & np.isfinite(ground_vehicle).all(axis=1)
+        & (dz < -1e-8)
+        & (scale > 0.0)
+        & (x_forward >= bev_range.x_min)
+        & (x_forward <= bev_range.x_max)
+        & (y_left >= bev_range.y_min)
+        & (y_left <= bev_range.y_max)
+    )
+    return np.column_stack((x_forward[valid], y_left[valid])), valid
+
+
+def ground_to_pixels(points_xy, calibration=CameraCalibration()):
+    """Project ADAS ground points to raw pixels (used for calibration tests)."""
+    points_xy = np.asarray(points_xy, dtype=np.float64)
+    if points_xy.ndim != 2 or points_xy.shape[1] != 2:
+        raise ValueError("points_xy must have shape (N, 2)")
+    # ADAS Y-left -> CARLA Y-right.
+    points_vehicle = np.column_stack(
+        (points_xy[:, 0], -points_xy[:, 1], np.zeros(len(points_xy)))
+    )
+    mount = calibration.camera_to_vehicle_matrix
+    rotation_vehicle_to_camera = mount[:3, :3].T
+    points_camera_ue = (
+        rotation_vehicle_to_camera
+        @ (points_vehicle - mount[:3, 3]).T
+    ).T
+    points_optical = np.column_stack(
+        (points_camera_ue[:, 1], -points_camera_ue[:, 2], points_camera_ue[:, 0])
+    )
+    projected = (calibration.intrinsic @ points_optical.T).T
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return projected[:, :2] / projected[:, 2:3]
+
+
+def model_lane_to_ground(lane, model_width=800, model_height=320,
+                         calibration=CameraCalibration(),
+                         bev_range=BevRange()):
+    """Convert one decoded RCLane polyline into metric BEV points + scores."""
+    if len(lane.points) == 0:
+        return np.empty((0, 2)), np.empty(0)
+    lane_points = np.asarray(lane.points, dtype=np.float64)
+    raw_pixels = lane_points[:, :2].copy()
+    raw_pixels[:, 0] *= calibration.width / float(model_width)
+    raw_pixels[:, 1] *= calibration.height / float(model_height)
+    ground, valid = pixels_to_ground(raw_pixels, calibration, bev_range)
+    return ground, lane_points[valid, 2]
+
+
+def _weighted_lstsq(design, targets, weights):
+    root_weight = np.sqrt(np.maximum(weights, 1e-8))
+    return np.linalg.lstsq(
+        design * root_weight[:, None], targets * root_weight, rcond=None
+    )[0]
+
+
+def fit_cubic_lane(points_xy, point_scores=None, min_points=6,
+                   huber_delta_m=0.30, iterations=5):
+    """Robustly fit ``Y(X) = c0 + c1 X + c2 X^2 + c3 X^3``.
+
+    X is normalized internally for numerical stability out to 300 metres. The
+    returned coefficients are converted back to metric X and ordered
+    ``[c0, c1, c2, c3]``.
+    """
+    points = np.asarray(points_xy, dtype=np.float64)
+    if points.ndim != 2 or points.shape[1] != 2:
+        raise ValueError("points_xy must have shape (N, 2)")
+    finite = np.isfinite(points).all(axis=1)
+    points = points[finite]
+    if len(points) < min_points:
+        return None
+    order = np.argsort(points[:, 0])
+    x = points[order, 0]
+    y = points[order, 1]
+    if np.ptp(x) < 1.0:
+        return None
+
+    if point_scores is None:
+        base_weights = np.ones(len(x), dtype=np.float64)
+    else:
+        scores = np.asarray(point_scores, dtype=np.float64)[finite][order]
+        base_weights = np.clip(scores, 0.05, 1.0)
+
+    center = float((x.min() + x.max()) * 0.5)
+    scale = float(max((x.max() - x.min()) * 0.5, 1.0))
+    z = (x - center) / scale
+    design = np.column_stack((np.ones(len(z)), z, z ** 2, z ** 3))
+    weights = base_weights.copy()
+    coefficients_normalized = _weighted_lstsq(design, y, weights)
+    for _ in range(iterations):
+        residual = y - design @ coefficients_normalized
+        robust_weight = np.minimum(
+            1.0, huber_delta_m / np.maximum(np.abs(residual), 1e-8)
+        )
+        weights = base_weights * robust_weight
+        coefficients_normalized = _weighted_lstsq(design, y, weights)
+
+    residual = y - design @ coefficients_normalized
+    inliers = np.abs(residual) <= max(huber_delta_m, 2.5 * np.median(np.abs(residual)))
+    if np.count_nonzero(inliers) >= min_points:
+        coefficients_normalized = _weighted_lstsq(
+            design[inliers], y[inliers], base_weights[inliers]
+        )
+    else:
+        inliers = np.ones(len(x), dtype=bool)
+
+    # Compose p((X - center) / scale) and return ascending metric coefficients.
+    normalized_polynomial = np.polynomial.Polynomial(coefficients_normalized)
+    metric_argument = np.polynomial.Polynomial((-center / scale, 1.0 / scale))
+    metric_polynomial = normalized_polynomial(metric_argument)
+    coefficients = np.zeros(4, dtype=np.float64)
+    coefficients[:len(metric_polynomial.coef)] = metric_polynomial.coef
+
+    fitted = np.polynomial.polynomial.polyval(x[inliers], coefficients)
+    rmse = float(np.sqrt(np.mean((y[inliers] - fitted) ** 2)))
+    return {
+        "coefficients": coefficients,
+        "x_min": float(x[inliers].min()),
+        "x_max": float(x[inliers].max()),
+        "rmse": rmse,
+        "point_count": int(len(x)),
+        "inlier_count": int(np.count_nonzero(inliers)),
+        "inlier_ratio": float(np.mean(inliers)),
+    }
+
+
+def evaluate_cubic(coefficients, x):
+    return np.polynomial.polynomial.polyval(
+        np.asarray(x, dtype=np.float64), np.asarray(coefficients, dtype=np.float64)
+    )
+
+
+def _copy_fit(fit):
+    copied = dict(fit)
+    copied["coefficients"] = np.asarray(
+        fit["coefficients"], dtype=np.float64
+    ).copy()
+    return copied
+
+
+def clip_cubic_fit_to_funnel(fit, camera_x_m=1.0,
+                             horizontal_fov_deg=30.0, margin_m=0.10,
+                             sample_step_m=0.5, minimum_span_m=1.0):
+    """Restrict a cubic's declared domain to the visible camera funnel.
+
+    The polynomial coefficients are left unchanged. Only the longest
+    contiguous, physically visible X interval is exported, which makes the
+    ``x_domain_m`` contract explicit and prevents a renderer from drawing an
+    otherwise valid cubic after it leaves the camera footprint.
+    """
+    copied = _copy_fit(fit)
+    x_min = float(fit["x_min"])
+    x_max = float(fit["x_max"])
+    report = {
+        "original_x_domain_m": [x_min, x_max],
+        "x_domain_m": None,
+        "clipped": False,
+        "valid": False,
+    }
+    if x_max - x_min < minimum_span_m:
+        return None, report
+    count = max(3, int(np.ceil((x_max - x_min) / sample_step_m)) + 1)
+    x = np.linspace(x_min, x_max, count)
+    y = evaluate_cubic(fit["coefficients"], x)
+    half_width = np.maximum(0.0, x - camera_x_m) * np.tan(
+        np.deg2rad(horizontal_fov_deg * 0.5)
+    )
+    valid = (
+        np.isfinite(y)
+        & (x >= camera_x_m)
+        & (np.abs(y) <= half_width + margin_m)
+    )
+
+    runs = []
+    start = None
+    for index, value in enumerate(valid):
+        if value and start is None:
+            start = index
+        if start is not None and (not value or index == len(valid) - 1):
+            end = index if value and index == len(valid) - 1 else index - 1
+            if x[end] - x[start] >= minimum_span_m:
+                runs.append((start, end))
+            start = None
+    if not runs:
+        return None, report
+    start, end = max(runs, key=lambda run: x[run[1]] - x[run[0]])
+    copied["x_min"] = float(x[start])
+    copied["x_max"] = float(x[end])
+    report.update({
+        "x_domain_m": [copied["x_min"], copied["x_max"]],
+        "clipped": bool(
+            copied["x_min"] > x_min + 1e-6
+            or copied["x_max"] < x_max - 1e-6
+        ),
+        "valid": True,
+    })
+    return copied, report
+
+
+def _self_test():
+    calibration = CameraCalibration()
+    bev_range = BevRange()
+    ground = np.array(
+        ((5.0, 0.0), (20.0, 3.5), (50.0, -3.5), (150.0, 2.0),
+         (299.0, 0.0)),
+        dtype=np.float64,
+    )
+    pixels = ground_to_pixels(ground, calibration)
+    reconstructed, valid = pixels_to_ground(pixels, calibration, bev_range)
+    assert valid.all()
+    assert np.allclose(reconstructed, ground, atol=1e-5), (
+        reconstructed, ground
+    )
+
+    x = np.linspace(5.0, 180.0, 80)
+    truth = np.array((1.8, 1.5e-2, -1.2e-4, 3.0e-7))
+    y = evaluate_cubic(truth, x)
+    y[20] += 4.0
+    fitted = fit_cubic_lane(np.column_stack((x, y)))
+    assert fitted is not None
+    prediction = evaluate_cubic(fitted["coefficients"], x)
+    clean = np.ones(len(x), dtype=bool)
+    clean[20] = False
+    clean_rmse = np.sqrt(np.mean(
+        (prediction[clean] - evaluate_cubic(truth, x[clean])) ** 2
+    ))
+    assert clean_rmse < 0.02
+
+    runaway_fit = {
+        "coefficients": np.array((-5.0, 0.4, -0.013, 1.15e-4)),
+        "x_min": 10.0, "x_max": 130.0, "rmse": 0.1,
+        "point_count": 50, "inlier_count": 50, "inlier_ratio": 1.0,
+    }
+    source_coefficients = runaway_fit["coefficients"].copy()
+    clipped, funnel_report = clip_cubic_fit_to_funnel(runaway_fit)
+    assert clipped is not None and funnel_report["clipped"]
+    assert clipped["x_max"] < runaway_fit["x_max"]
+    assert np.array_equal(clipped["coefficients"], source_coefficients)
+    check_x = np.linspace(clipped["x_min"], clipped["x_max"], 300)
+    check_y = evaluate_cubic(clipped["coefficients"], check_x)
+    funnel_half_width = (check_x - 1.0) * np.tan(np.deg2rad(15.0))
+    assert np.all(np.abs(check_y) <= funnel_half_width + 0.11)
+    print("OK -- pixel/ground projection round trip")
+    print("OK -- robust metric cubic lane fit")
+    print("OK -- raw cubic funnel clipping preserves coefficients")
+
+
+if __name__ == "__main__":
+    _self_test()

build_tensorrt_engine.py

@@ -0,0 +1,133 @@
+"""Build/cache the RCLane TensorRT FP16 engine and verify its outputs.
+
+TensorRT is used through ONNX Runtime's TensorRT Execution Provider so the
+cached ``.engine`` remains consumable by the same runtime pipeline. The script
+refuses silent provider fallback and records numerical/performance comparisons
+against CUDA FP32.
+"""
+
+import argparse
+import json
+import os
+import time
+from pathlib import Path
+
+import numpy as np
+
+from test_video_onnx import OUTPUT_NAMES, create_session, timing_summary
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--cache-dir", default="exports/trt_cache")
+    parser.add_argument("--report", default=None)
+    parser.add_argument("--warmup", type=int, default=10)
+    parser.add_argument("--iterations", type=int, default=100)
+    parser.add_argument("--seed", type=int, default=0)
+    return parser.parse_args()
+
+
+def benchmark(session, images, warmup, iterations):
+    for _ in range(warmup):
+        session.run(list(OUTPUT_NAMES), {"images": images})
+    timings = []
+    outputs = None
+    for _ in range(iterations):
+        started = time.perf_counter()
+        outputs = session.run(list(OUTPUT_NAMES), {"images": images})
+        timings.append((time.perf_counter() - started) * 1000.0)
+    return outputs, timing_summary(timings)
+
+
+def main():
+    args = parse_args()
+    if args.warmup < 0 or args.iterations <= 0:
+        raise ValueError("warmup must be non-negative and iterations positive")
+    model_path = Path(args.model).expanduser().resolve()
+    cache_dir = Path(args.cache_dir).expanduser().resolve()
+    report_path = (
+        Path(args.report).expanduser().resolve()
+        if args.report else cache_dir / "build_report.json"
+    )
+    if not model_path.is_file():
+        raise FileNotFoundError(model_path)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+
+    rng = np.random.default_rng(args.seed)
+    images = rng.normal(size=(1, 3, 320, 800)).astype(np.float32)
+
+    build_started = time.perf_counter()
+    trt_session = create_session(
+        model_path, "tensorrt", allow_tf32=False, trt_cache_dir=cache_dir
+    )
+    build_seconds = time.perf_counter() - build_started
+    if trt_session.get_providers()[0] != "TensorrtExecutionProvider":
+        raise RuntimeError("TensorRT provider silently fell back")
+    cuda_session = create_session(model_path, "cuda", allow_tf32=False)
+
+    trt_outputs, trt_timing = benchmark(
+        trt_session, images, args.warmup, args.iterations
+    )
+    cuda_outputs, cuda_timing = benchmark(
+        cuda_session, images, args.warmup, args.iterations
+    )
+    comparisons = {}
+    for name, trt_output, cuda_output in zip(
+        OUTPUT_NAMES, trt_outputs, cuda_outputs
+    ):
+        difference = trt_output.astype(np.float64) - cuda_output.astype(
+            np.float64
+        )
+        comparisons[name] = {
+            "shape": list(trt_output.shape),
+            "max_abs": float(np.max(np.abs(difference))),
+            "mean_abs": float(np.mean(np.abs(difference))),
+            "rmse": float(np.sqrt(np.mean(difference ** 2))),
+        }
+
+    cache_files = []
+    for path in sorted(cache_dir.iterdir()):
+        if path.is_file():
+            cache_files.append({
+                "path": str(path),
+                "size_bytes": path.stat().st_size,
+            })
+    engines = [
+        item for item in cache_files if item["path"].endswith(".engine")
+    ]
+    if not engines:
+        raise RuntimeError(f"TensorRT did not create an engine in {cache_dir}")
+
+    report = {
+        "model": str(model_path),
+        "provider": trt_session.get_providers()[0],
+        "precision": "fp16",
+        "input_shape": list(images.shape),
+        "build_or_cache_load_seconds": build_seconds,
+        "tensorrt_timing": trt_timing,
+        "cuda_fp32_timing": cuda_timing,
+        "speedup_from_median": (
+            cuda_timing["median_ms"] / trt_timing["median_ms"]
+        ),
+        "output_comparison_to_cuda_fp32": comparisons,
+        "cache_files": cache_files,
+    }
+    temporary = report_path.with_suffix(report_path.suffix + ".tmp")
+    with temporary.open("w") as handle:
+        json.dump(report, handle, indent=2)
+        handle.write("\n")
+    os.replace(temporary, report_path)
+    print(f"TensorRT engine OK: {engines[0]['path']}")
+    print(f"report: {report_path}")
+    print(
+        "median inference: TensorRT={:.3f}ms CUDA={:.3f}ms speedup={:.2f}x".format(
+            trt_timing["median_ms"], cuda_timing["median_ms"],
+            report["speedup_from_median"],
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

cpp/CMakeLists.txt

@@ -0,0 +1,67 @@
+cmake_minimum_required(VERSION 3.20)
+project(rclane_runtime LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+find_path(TENSORRT_INCLUDE_DIR NvInferRuntime.h
+    HINTS "$ENV{TENSORRT_ROOT}/include"
+    PATHS /usr/include /usr/include/aarch64-linux-gnu /usr/local/TensorRT/include
+)
+find_library(TENSORRT_LIBRARY NAMES nvinfer libnvinfer.so.10
+    HINTS "$ENV{TENSORRT_ROOT}/lib" "$ENV{TENSORRT_ROOT}/lib64"
+    PATHS /usr/lib /usr/lib/x86_64-linux-gnu /usr/lib/aarch64-linux-gnu
+)
+find_path(CUDA_INCLUDE_DIR cuda_runtime_api.h
+    HINTS "$ENV{CUDA_HOME}/include" "$ENV{CUDA_PATH}/include"
+    PATHS /usr/local/cuda/include /usr/include
+)
+find_library(CUDART_LIBRARY NAMES cudart libcudart.so.13 libcudart.so.12
+    HINTS "$ENV{CUDA_HOME}/lib64" "$ENV{CUDA_PATH}/lib64"
+    PATHS /usr/local/cuda/lib64 /usr/lib/x86_64-linux-gnu
+          /usr/lib/aarch64-linux-gnu
+)
+
+foreach(required_path
+        TENSORRT_INCLUDE_DIR TENSORRT_LIBRARY CUDA_INCLUDE_DIR CUDART_LIBRARY)
+    if(NOT ${required_path})
+        message(FATAL_ERROR
+            "${required_path} was not found; pass -D${required_path}=..."
+        )
+    endif()
+endforeach()
+
+find_package(OpenMP REQUIRED)
+
+add_executable(rclane_runtime
+    src/bev.cpp
+    src/decoder.cpp
+    src/main.cpp
+    src/preprocess.cpp
+    src/tensorrt_runner.cpp
+)
+target_include_directories(rclane_runtime PRIVATE
+    include
+    "${TENSORRT_INCLUDE_DIR}"
+    "${CUDA_INCLUDE_DIR}"
+)
+target_link_libraries(rclane_runtime PRIVATE
+    "${TENSORRT_LIBRARY}"
+    "${CUDART_LIBRARY}"
+    OpenMP::OpenMP_CXX
+    dl
+)
+target_compile_options(rclane_runtime PRIVATE
+    -O3 -march=native -Wall -Wextra -Wpedantic
+)
+
+get_filename_component(TENSORRT_LIBRARY_DIR "${TENSORRT_LIBRARY}" DIRECTORY)
+get_filename_component(CUDART_LIBRARY_DIR "${CUDART_LIBRARY}" DIRECTORY)
+set_target_properties(rclane_runtime PROPERTIES
+    BUILD_RPATH "${TENSORRT_LIBRARY_DIR};${CUDART_LIBRARY_DIR}"
+)

cpp/README.md

@@ -0,0 +1,73 @@
+# RCLane native C++ runtime
+
+This directory is the sequential deployment runtime. One frame completes
+preprocessing, TensorRT inference, 1024-seed decode and raw-model BEV export
+before the next frame begins. There is no inter-frame overlap. Rendering,
+source-video decoding and video writing are outside the measured core latency.
+
+The BEV output is a one-to-one projection of decoded model lanes. It does not
+force curves to be parallel and does not synthesize missing lanes. The funnel
+guard may only shorten a cubic's valid X domain; it never changes coefficients.
+
+The build intentionally consumes TensorRT/CUDA SDK headers and shared libraries
+from the target machine; serialized TensorRT engines must be rebuilt per GPU.
+
+```bash
+cmake -S cpp -B cpp/build -G "Unix Makefiles" \
+  -DTENSORRT_INCLUDE_DIR=/path/to/TensorRT/include \
+  -DTENSORRT_LIBRARY=/path/to/libnvinfer.so \
+  -DCUDA_INCLUDE_DIR=/path/to/cuda/include \
+  -DCUDART_LIBRARY=/path/to/libcudart.so
+cmake --build cpp/build -j8
+```
+
+TensorRT and CUDA are auto-discovered in standard x86/Jetson locations. The
+explicit `-D` paths above are useful for Python-wheel installations.
+
+## One-frame parity harness
+
+The runtime accepts either a preprocessed float32 NCHW tensor or a raw
+1920x1080 BGR frame. It can dump maps, decoded image lanes and metric BEV
+cubics for comparison with Python:
+
+```bash
+cpp/build/rclane_runtime \
+  --engine exports/trt_cache/model.engine \
+  --input-bgr /tmp/frame.bgr \
+  --dump-prefix /tmp/cpp \
+  --lanes-json /tmp/cpp_lanes.json \
+  --bev-json /tmp/cpp_bev.json \
+  --threads 8
+```
+
+## Sequential full-video benchmark
+
+Pipe decoded BGR frames from FFmpeg. The reported `core_pipeline` contains
+only preprocess + TensorRT (including transfers) + decode + BEV/cubic/funnel.
+
+```bash
+ffmpeg -loglevel error -i raw_Town04_Opt_20260714_093110.mp4 \
+  -f rawvideo -pix_fmt bgr24 - | \
+cpp/build/rclane_runtime \
+  --engine exports/trt_cache/model.engine \
+  --raw-bgr-stdin --source-width 1920 --source-height 1080 \
+  --threads 8 --warmup 10 --timing-warmup 5 \
+  --frames-jsonl runs/cpp_final_lanes.jsonl \
+  --report runs/cpp_benchmark_final_full.json
+```
+
+Render those saved C++ results later without rerunning inference or affecting
+the measured pipeline latency:
+
+```bash
+python cpp/render_cpp_results.py \
+  --video raw_Town04_Opt_20260714_093110.mp4 \
+  --results runs/cpp_final_lanes.jsonl \
+  --benchmark-report runs/cpp_benchmark_final_full.json \
+  --output runs/cpp_final_render_h264.mp4
+```
+
+On the development RTX 3050/i5-13420H machine, the complete 1768-frame final
+video measured 13.39 ms median and 14.15 ms p95 core latency (74.67 FPS median)
+with 1024 seeds and 8 CPU threads. TensorRT engines are GPU-architecture
+specific and must be rebuilt on the deployment target.

cpp/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,19 @@
+# Third-party notices
+
+The native runtime links against NVIDIA TensorRT and the CUDA Runtime supplied
+by the deployment environment. Those libraries are not distributed in this
+repository and remain subject to NVIDIA's respective licenses.
+
+Small compatibility routines were independently ported from these upstream
+implementations so C++ reproduces the established Python pipeline:
+
+- NumPy `npysort/aquicksort`, used to reproduce the tie ordering of
+  `numpy.argsort`: NumPy is distributed under the BSD 3-Clause license.
+  Source: <https://github.com/numpy/numpy/blob/v1.26.4/numpy/core/src/npysort/quicksort.cpp>
+- OpenCV fixed-point bilinear resize arithmetic, used to reproduce
+  `cv2.dnn.blobFromImage`: OpenCV 4.11 is distributed under the Apache License
+  2.0. Source:
+  <https://github.com/opencv/opencv/blob/4.11.0/modules/imgproc/src/resize.cpp>
+
+The full upstream license texts and copyright notices are available at the
+linked projects.

cpp/include/bev.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "decoder.hpp"
+
+#include <array>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace rclane {
+
+struct GroundPoint {
+    double x{};
+    double y{};
+    double score{};
+};
+
+struct CubicFit {
+    std::array<double, 4> coefficients{};
+    double x_min{};
+    double x_max{};
+    double rmse{};
+    std::size_t point_count{};
+    std::size_t inlier_count{};
+    bool valid{};
+};
+
+struct BevLane {
+    int lane_id{};
+    std::string role;
+    double score{};
+    std::vector<GroundPoint> points;
+    CubicFit fit;
+    bool fit_accepted{};
+    bool funnel_clipped{};
+};
+
+struct BevConfig {
+    double x_min{0.0};
+    double x_max{300.0};
+    double y_min{-85.0};
+    double y_max{85.0};
+    double maximum_rmse{0.5};
+    double funnel_margin{0.10};
+};
+
+std::vector<BevLane> project_lanes_to_bev(
+    const std::vector<Lane>& lanes,
+    const BevConfig& config = {}
+);
+
+void write_bev_json(
+    const std::string& path,
+    const std::vector<BevLane>& lanes
+);
+
+}  // namespace rclane

cpp/include/decoder.hpp

@@ -0,0 +1,80 @@
+#pragma once
+
+#include "tensorrt_runner.hpp"
+
+#include <cstddef>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace rclane {
+
+struct LanePoint {
+    float x{};
+    float y{};
+    float score{};
+};
+
+struct Lane {
+    int width{};
+    int height{};
+    std::vector<LanePoint> points;
+    double score_sum{};
+    int lane_id{};
+    std::string role;
+    bool ego_boundary{};
+    int lateral_rank{};
+
+    double score() const;
+};
+
+struct DecoderConfig {
+    float step_length{10.0F};
+    float segmentation_threshold{0.5F};
+    float seed_threshold{0.5F};
+    int seed_min_distance{2};
+    float score_threshold{0.10F};
+    float iou_threshold{0.5F};
+    int max_seeds{1024};
+    int nms_max_lanes{128};
+    float nms_scale{0.25F};
+    int lane_width{15};
+    int max_output_lanes{4};
+    float ego_x{400.0F};
+    float ego_min_score_ratio{0.5F};
+    int threads{8};
+};
+
+struct DecodeStatistics {
+    std::size_t foreground_pixels{};
+    std::size_t seeds{};
+    std::size_t crawled_candidates{};
+    std::size_t nms_candidates{};
+    std::size_t nms_survivors{};
+};
+
+std::vector<float> softmax_foreground(const Tensor& segmentation_logits);
+
+std::vector<Lane> decode(
+    const std::vector<float>& segmentation_probability,
+    const Tensor& up_arrow,
+    const Tensor& down_arrow,
+    const Tensor& up_bound,
+    const Tensor& down_bound,
+    const DecoderConfig& config = {},
+    DecodeStatistics* statistics = nullptr
+);
+
+std::vector<Lane> decode_outputs(
+    const std::unordered_map<std::string, Tensor>& outputs,
+    const DecoderConfig& config = {},
+    DecodeStatistics* statistics = nullptr
+);
+
+void write_lanes_json(
+    const std::string& path,
+    const std::vector<Lane>& lanes,
+    const DecodeStatistics* statistics = nullptr
+);
+
+}  // namespace rclane

cpp/include/preprocess.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+namespace rclane {
+
+void normalize_bgr_to_nchw(
+    const std::uint8_t* bgr,
+    int source_width,
+    int source_height,
+    std::vector<float>& destination
+);
+
+}  // namespace rclane

cpp/include/tensorrt_runner.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace rclane {
+
+struct Tensor {
+    std::vector<std::int64_t> shape;
+    std::vector<float> values;
+};
+
+struct InferenceTiming {
+    double mean_ms{};
+    double median_ms{};
+    double p95_ms{};
+    double min_ms{};
+    double max_ms{};
+};
+
+class TensorRTRunner {
+public:
+    explicit TensorRTRunner(const std::string& engine_path);
+    ~TensorRTRunner();
+
+    TensorRTRunner(const TensorRTRunner&) = delete;
+    TensorRTRunner& operator=(const TensorRTRunner&) = delete;
+    TensorRTRunner(TensorRTRunner&&) noexcept;
+    TensorRTRunner& operator=(TensorRTRunner&&) noexcept;
+
+    const std::vector<std::int64_t>& input_shape() const;
+    std::size_t input_elements() const;
+    std::unordered_map<std::string, Tensor> infer(const float* input);
+    const std::unordered_map<std::string, Tensor>& infer_reuse(
+        const float* input
+    );
+    InferenceTiming benchmark(
+        const float* input, int warmup, int iterations
+    );
+
+private:
+    class Impl;
+    std::unique_ptr<Impl> impl_;
+};
+
+}  // namespace rclane

cpp/render_cpp_results.py

@@ -0,0 +1,188 @@
+"""Render native C++ decoded lanes in a separate, untimed video pass."""
+
+import argparse
+from collections import deque
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import cv2
+import imageio_ffmpeg
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from decode import Lane
+from bev import BevRange, CameraCalibration
+from test_video_bev_onnx import draw_bev, make_composite
+from test_video_onnx import draw_predictions
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--video", required=True)
+    parser.add_argument("--results", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--benchmark-report", default=None)
+    return parser.parse_args()
+
+
+def load_lane(payload):
+    lane = Lane(800, 320)
+    lane.points = np.asarray(payload["points"], dtype=np.float32)
+    lane._score_sum = float(payload["score"]) * len(lane.points)
+    lane.lane_id = int(payload["lane_id"])
+    lane.lane_role = payload["role"]
+    lane.is_ego_boundary = lane.lane_role in ("ego_left", "ego_right")
+    lane.lateral_rank = None
+    return lane
+
+
+def load_bev_result(payload):
+    fit_payload = payload["fit"]
+    fit = None
+    if payload["fit_accepted"] and fit_payload is not None:
+        fit = {
+            "coefficients": np.asarray(
+                fit_payload["coefficients"], dtype=np.float64
+            ),
+            "x_min": float(fit_payload["x_min"]),
+            "x_max": float(fit_payload["x_max"]),
+            "rmse": float(fit_payload["rmse"]),
+            "point_count": int(fit_payload["point_count"]),
+            "inlier_count": int(fit_payload["inlier_count"]),
+        }
+    lane_id = int(payload["lane_id"])
+    record = {
+        "lane_id": f"P{lane_id}",
+        "lane_index": lane_id,
+        "role": payload["role"],
+        "score": float(payload["score"]),
+        "valid_fit": fit is not None,
+    }
+    if fit_payload is not None:
+        record["rmse_m"] = float(fit_payload["rmse"])
+    points = np.asarray(payload["points"], dtype=np.float64)
+    return {
+        "record": record,
+        "points": points[:, :2] if points.size else np.empty((0, 2)),
+        "fit": fit,
+    }
+
+
+def funnel_report(bev_payloads):
+    return {
+        "mode": "raw_model_projection",
+        "parallel_assumption": False,
+        "synthetic_lanes": False,
+        "clipped_lanes": [
+            f"P{item['lane_id']}" for item in bev_payloads
+            if item["funnel_clipped"]
+        ],
+        "rejected_lanes": [
+            f"P{item['lane_id']}" for item in bev_payloads
+            if item["fit"] is not None and not item["fit_accepted"]
+        ],
+    }
+
+
+def main():
+    args = parse_args()
+    video_path = Path(args.video).expanduser().resolve()
+    results_path = Path(args.results).expanduser().resolve()
+    output_path = Path(args.output).expanduser().resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    calibration = CameraCalibration()
+    bev_range = BevRange()
+
+    capture = cv2.VideoCapture(str(video_path))
+    if not capture.isOpened():
+        raise RuntimeError(f"cannot open video: {video_path}")
+    fps = float(capture.get(cv2.CAP_PROP_FPS))
+    width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    temporary = output_path.with_name(output_path.stem + ".mp4v.mp4")
+    writer = cv2.VideoWriter(
+        str(temporary), cv2.VideoWriter_fourcc(*"mp4v"), fps,
+        (width, height),
+    )
+    if not writer.isOpened():
+        capture.release()
+        raise RuntimeError(f"cannot create temporary video: {temporary}")
+
+    rendered = 0
+    rolling_core_ms = deque(maxlen=20)
+    try:
+        with results_path.open() as results:
+            for line in results:
+                payload = json.loads(line)
+                ok, frame = capture.read()
+                if not ok:
+                    raise RuntimeError(
+                        f"video ended before result frame {payload['frame_index']}"
+                    )
+                lanes = [load_lane(item) for item in payload["lanes"]]
+                bev_payloads = payload["bev_lanes"]
+                lane_results = [
+                    load_bev_result(item) for item in bev_payloads
+                ]
+                guard = funnel_report(bev_payloads)
+                timing = payload["timing"]
+                rolling_core_ms.append(float(timing["core_ms"]))
+                rolling_fps = 1000.0 / max(
+                    float(np.mean(rolling_core_ms)), 1e-9
+                )
+                draw_predictions(frame, lanes)
+                bev_canvas = draw_bev(
+                    lane_results, bev_range, calibration, guard
+                )
+                composite = make_composite(
+                    frame, bev_canvas, int(payload["frame_index"]),
+                    sum(item["fit"] is not None for item in lane_results),
+                    float(timing["core_ms"]), guard,
+                    result_generation_fps=rolling_fps,
+                )
+                detail = (
+                    f"C++ current={timing['core_ms']:.1f}ms | "
+                    f"infer={timing['inference_ms']:.1f} "
+                    f"decode={timing['decode_ms']:.1f} "
+                    f"BEV-result={timing['bev_result_ms']:.2f}ms | "
+                    "draw/encode excluded"
+                )
+                cv2.putText(
+                    composite, detail, (664, 101),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.50, (0, 0, 0), 4,
+                    cv2.LINE_AA,
+                )
+                cv2.putText(
+                    composite, detail, (664, 101),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.50, (255, 255, 255), 1,
+                    cv2.LINE_AA,
+                )
+                writer.write(composite)
+                rendered += 1
+                if rendered % 200 == 0:
+                    print(f"rendered {rendered} frames", flush=True)
+    finally:
+        capture.release()
+        writer.release()
+
+    encoded = output_path.with_name(output_path.stem + ".h264.tmp.mp4")
+    subprocess.run(
+        [
+            imageio_ffmpeg.get_ffmpeg_exe(), "-y", "-loglevel", "error",
+            "-i", str(temporary), "-c:v", "libx264", "-preset", "fast",
+            "-crf", "18", "-pix_fmt", "yuv420p", "-movflags", "+faststart",
+            str(encoded),
+        ],
+        check=True,
+    )
+    os.replace(encoded, output_path)
+    temporary.unlink(missing_ok=True)
+    print(f"rendered video: {output_path} ({rendered} frames)")
+
+
+if __name__ == "__main__":
+    main()

cpp/src/bev.cpp

@@ -0,0 +1,352 @@
+#include "bev.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <fstream>
+#include <iomanip>
+#include <limits>
+#include <stdexcept>
+#include <vector>
+
+namespace rclane {
+namespace {
+
+constexpr double kFx = 3582.768775;
+constexpr double kFy = 3582.768775;
+constexpr double kCx = 960.0;
+constexpr double kCy = 540.0;
+constexpr double kRawWidth = 1920.0;
+constexpr double kRawHeight = 1080.0;
+constexpr double kModelWidth = 800.0;
+constexpr double kModelHeight = 320.0;
+constexpr double kCameraX = 1.0;
+constexpr double kCameraZ = 1.8;
+constexpr double kCosPitch = 0.997564;
+constexpr double kSinDown = 0.069756;
+constexpr double kPi = 3.14159265358979323846;
+
+bool solve_four_by_four(
+    std::array<std::array<double, 4>, 4> matrix,
+    std::array<double, 4> target,
+    std::array<double, 4>& solution
+) {
+    for (int column = 0; column < 4; ++column) {
+        int pivot = column;
+        for (int row = column + 1; row < 4; ++row) {
+            if (std::abs(matrix[row][column]) > std::abs(matrix[pivot][column])) {
+                pivot = row;
+            }
+        }
+        if (std::abs(matrix[pivot][column]) < 1e-12) {
+            return false;
+        }
+        std::swap(matrix[pivot], matrix[column]);
+        std::swap(target[pivot], target[column]);
+        const double divisor = matrix[column][column];
+        for (int index = column; index < 4; ++index) {
+            matrix[column][index] /= divisor;
+        }
+        target[column] /= divisor;
+        for (int row = 0; row < 4; ++row) {
+            if (row == column) {
+                continue;
+            }
+            const double factor = matrix[row][column];
+            for (int index = column; index < 4; ++index) {
+                matrix[row][index] -= factor * matrix[column][index];
+            }
+            target[row] -= factor * target[column];
+        }
+    }
+    solution = target;
+    return true;
+}
+
+bool weighted_fit(
+    const std::vector<double>& z,
+    const std::vector<double>& y,
+    const std::vector<double>& weights,
+    const std::vector<std::uint8_t>* include,
+    std::array<double, 4>& coefficients
+) {
+    std::array<std::array<double, 4>, 4> normal{};
+    std::array<double, 4> target{};
+    for (std::size_t index = 0; index < z.size(); ++index) {
+        if (include != nullptr && (*include)[index] == 0U) {
+            continue;
+        }
+        const std::array<double, 4> row{1.0, z[index], z[index] * z[index],
+                                        z[index] * z[index] * z[index]};
+        for (int i = 0; i < 4; ++i) {
+            target[i] += weights[index] * row[i] * y[index];
+            for (int j = 0; j < 4; ++j) {
+                normal[i][j] += weights[index] * row[i] * row[j];
+            }
+        }
+    }
+    return solve_four_by_four(normal, target, coefficients);
+}
+
+double evaluate(const std::array<double, 4>& c, double x) {
+    return ((c[3] * x + c[2]) * x + c[1]) * x + c[0];
+}
+
+std::vector<GroundPoint> project_lane(
+    const Lane& lane, const BevConfig& config
+) {
+    std::vector<GroundPoint> ground;
+    ground.reserve(lane.points.size());
+    for (const auto& point : lane.points) {
+        const double u = point.x * (kRawWidth / kModelWidth);
+        const double v = point.y * (kRawHeight / kModelHeight);
+        const double ray_right = (u - kCx) / kFx;
+        const double ray_down = (v - kCy) / kFy;
+        // OpenCV optical -> UE camera is (forward,right,up)=(1,x,-y),
+        // followed by the fixed camera-to-vehicle pitch rotation.
+        const double ray_x = kCosPitch - kSinDown * ray_down;
+        const double ray_y = ray_right;
+        const double ray_z = -kSinDown - kCosPitch * ray_down;
+        if (!(ray_z < -1e-8)) {
+            continue;
+        }
+        const double scale = -kCameraZ / ray_z;
+        if (!(scale > 0.0) || !std::isfinite(scale)) {
+            continue;
+        }
+        const double x = kCameraX + scale * ray_x;
+        const double y_left = -scale * ray_y;
+        if (std::isfinite(x) && std::isfinite(y_left)
+            && x >= config.x_min && x <= config.x_max
+            && y_left >= config.y_min && y_left <= config.y_max) {
+            ground.push_back({x, y_left, point.score});
+        }
+    }
+    return ground;
+}
+
+CubicFit fit_cubic(const std::vector<GroundPoint>& input) {
+    CubicFit fit;
+    fit.point_count = input.size();
+    if (input.size() < 6) {
+        return fit;
+    }
+    std::vector<GroundPoint> points = input;
+    std::sort(points.begin(), points.end(), [](const GroundPoint& lhs,
+                                               const GroundPoint& rhs) {
+        return lhs.x < rhs.x;
+    });
+    const double minimum_x = points.front().x;
+    const double maximum_x = points.back().x;
+    if (maximum_x - minimum_x < 1.0) {
+        return fit;
+    }
+    const double center = (minimum_x + maximum_x) * 0.5;
+    const double scale = std::max((maximum_x - minimum_x) * 0.5, 1.0);
+    std::vector<double> z(points.size());
+    std::vector<double> y(points.size());
+    std::vector<double> base(points.size());
+    for (std::size_t index = 0; index < points.size(); ++index) {
+        z[index] = (points[index].x - center) / scale;
+        y[index] = points[index].y;
+        base[index] = std::clamp(points[index].score, 0.05, 1.0);
+    }
+    std::vector<double> weights = base;
+    std::array<double, 4> normalized{};
+    if (!weighted_fit(z, y, weights, nullptr, normalized)) {
+        return fit;
+    }
+    for (int iteration = 0; iteration < 3; ++iteration) {
+        for (std::size_t index = 0; index < points.size(); ++index) {
+            const double residual = y[index] - evaluate(normalized, z[index]);
+            const double robust = std::min(
+                1.0, 0.30 / std::max(std::abs(residual), 1e-8)
+            );
+            weights[index] = base[index] * robust;
+        }
+        if (!weighted_fit(z, y, weights, nullptr, normalized)) {
+            return fit;
+        }
+    }
+    std::vector<double> absolute_residual(points.size());
+    for (std::size_t index = 0; index < points.size(); ++index) {
+        absolute_residual[index] = std::abs(
+            y[index] - evaluate(normalized, z[index])
+        );
+    }
+    std::vector<double> sorted_residual = absolute_residual;
+    std::sort(sorted_residual.begin(), sorted_residual.end());
+    const std::size_t middle = sorted_residual.size() / 2;
+    const double median_residual = (sorted_residual.size() & 1U) != 0U
+        ? sorted_residual[middle]
+        : (sorted_residual[middle - 1] + sorted_residual[middle]) * 0.5;
+    const double threshold = std::max(0.30, 2.5 * median_residual);
+    std::vector<std::uint8_t> inliers(points.size(), 0U);
+    std::size_t inlier_count = 0;
+    for (std::size_t index = 0; index < points.size(); ++index) {
+        inliers[index] = static_cast<std::uint8_t>(
+            absolute_residual[index] <= threshold
+        );
+        inlier_count += inliers[index];
+    }
+    if (inlier_count >= 6) {
+        if (!weighted_fit(z, y, base, &inliers, normalized)) {
+            return fit;
+        }
+    } else {
+        std::fill(inliers.begin(), inliers.end(), 1U);
+        inlier_count = points.size();
+    }
+
+    const double inverse_scale = 1.0 / scale;
+    const double argument_constant = -center * inverse_scale;
+    const double argument_linear = inverse_scale;
+    fit.coefficients[0] = normalized[0]
+        + normalized[1] * argument_constant
+        + normalized[2] * argument_constant * argument_constant
+        + normalized[3] * argument_constant * argument_constant * argument_constant;
+    fit.coefficients[1] = normalized[1] * argument_linear
+        + 2.0 * normalized[2] * argument_constant * argument_linear
+        + 3.0 * normalized[3] * argument_constant * argument_constant * argument_linear;
+    fit.coefficients[2] = normalized[2] * argument_linear * argument_linear
+        + 3.0 * normalized[3] * argument_constant * argument_linear * argument_linear;
+    fit.coefficients[3] = normalized[3] * argument_linear * argument_linear * argument_linear;
+
+    fit.x_min = std::numeric_limits<double>::infinity();
+    fit.x_max = -std::numeric_limits<double>::infinity();
+    double square_error = 0.0;
+    for (std::size_t index = 0; index < points.size(); ++index) {
+        if (inliers[index] == 0U) {
+            continue;
+        }
+        fit.x_min = std::min(fit.x_min, points[index].x);
+        fit.x_max = std::max(fit.x_max, points[index].x);
+        const double residual = points[index].y
+            - evaluate(fit.coefficients, points[index].x);
+        square_error += residual * residual;
+    }
+    fit.inlier_count = inlier_count;
+    fit.rmse = std::sqrt(square_error / static_cast<double>(inlier_count));
+    fit.valid = true;
+    return fit;
+}
+
+bool clip_to_funnel(CubicFit& fit, double margin, bool& clipped) {
+    clipped = false;
+    if (!fit.valid || fit.x_max - fit.x_min < 1.0) {
+        return false;
+    }
+    const int count = std::max(
+        3, static_cast<int>(std::ceil((fit.x_max - fit.x_min) / 0.5)) + 1
+    );
+    std::vector<double> x(static_cast<std::size_t>(count));
+    std::vector<std::uint8_t> valid(static_cast<std::size_t>(count), 0U);
+    const double tangent = std::tan(15.0 * kPi / 180.0);
+    for (int index = 0; index < count; ++index) {
+        x[static_cast<std::size_t>(index)] = fit.x_min
+            + (fit.x_max - fit.x_min) * static_cast<double>(index)
+                / static_cast<double>(count - 1);
+        const double y = evaluate(fit.coefficients, x[static_cast<std::size_t>(index)]);
+        const double half_width = std::max(
+            0.0, x[static_cast<std::size_t>(index)] - kCameraX
+        ) * tangent;
+        valid[static_cast<std::size_t>(index)] = static_cast<std::uint8_t>(
+            std::isfinite(y)
+            && x[static_cast<std::size_t>(index)] >= kCameraX
+            && std::abs(y) <= half_width + margin
+        );
+    }
+    int best_start = -1;
+    int best_end = -1;
+    int start = -1;
+    for (int index = 0; index < count; ++index) {
+        if (valid[static_cast<std::size_t>(index)] != 0U && start < 0) {
+            start = index;
+        }
+        if (start >= 0 && (valid[static_cast<std::size_t>(index)] == 0U
+                          || index == count - 1)) {
+            const int end = valid[static_cast<std::size_t>(index)] != 0U
+                && index == count - 1 ? index : index - 1;
+            if (x[static_cast<std::size_t>(end)] - x[static_cast<std::size_t>(start)] >= 1.0
+                && (best_start < 0
+                    || x[static_cast<std::size_t>(end)] - x[static_cast<std::size_t>(start)]
+                        > x[static_cast<std::size_t>(best_end)] - x[static_cast<std::size_t>(best_start)])) {
+                best_start = start;
+                best_end = end;
+            }
+            start = -1;
+        }
+    }
+    if (best_start < 0) {
+        return false;
+    }
+    const double original_min = fit.x_min;
+    const double original_max = fit.x_max;
+    fit.x_min = x[static_cast<std::size_t>(best_start)];
+    fit.x_max = x[static_cast<std::size_t>(best_end)];
+    clipped = fit.x_min > original_min + 1e-6
+        || fit.x_max < original_max - 1e-6;
+    return true;
+}
+
+}  // namespace
+
+std::vector<BevLane> project_lanes_to_bev(
+    const std::vector<Lane>& lanes,
+    const BevConfig& config
+) {
+    std::vector<BevLane> result;
+    result.reserve(lanes.size());
+    for (const Lane& lane : lanes) {
+        BevLane output;
+        output.lane_id = lane.lane_id;
+        output.role = lane.role;
+        output.score = lane.score();
+        output.points = project_lane(lane, config);
+        output.fit = fit_cubic(output.points);
+        output.fit_accepted = output.fit.valid
+            && output.fit.rmse <= config.maximum_rmse;
+        if (output.fit_accepted) {
+            output.fit_accepted = clip_to_funnel(
+                output.fit, config.funnel_margin, output.funnel_clipped
+            );
+        }
+        result.push_back(std::move(output));
+    }
+    return result;
+}
+
+void write_bev_json(
+    const std::string& path,
+    const std::vector<BevLane>& lanes
+) {
+    std::ofstream stream(path);
+    if (!stream) {
+        throw std::runtime_error("cannot write BEV JSON: " + path);
+    }
+    stream << std::setprecision(12) << "{\n  \"mode\": \"raw_model_projection\",\n"
+           << "  \"parallel_assumption\": false,\n"
+           << "  \"synthetic_lanes\": false,\n  \"lanes\": [\n";
+    for (std::size_t index = 0; index < lanes.size(); ++index) {
+        const BevLane& lane = lanes[index];
+        stream << "    {\"lane_id\": " << lane.lane_id
+               << ", \"role\": \"" << lane.role
+               << "\", \"score\": " << lane.score
+               << ", \"projected_point_count\": " << lane.points.size()
+               << ", \"valid_fit\": " << (lane.fit_accepted ? "true" : "false");
+        if (lane.fit.valid) {
+            stream << ", \"coefficients_c0_to_c3\": ["
+                   << lane.fit.coefficients[0] << ',' << lane.fit.coefficients[1]
+                   << ',' << lane.fit.coefficients[2] << ',' << lane.fit.coefficients[3]
+                   << "], \"x_domain_m\": [" << lane.fit.x_min << ',' << lane.fit.x_max
+                   << "], \"rmse_m\": " << lane.fit.rmse
+                   << ", \"inlier_count\": " << lane.fit.inlier_count
+                   << ", \"funnel_clipped\": "
+                   << (lane.funnel_clipped ? "true" : "false");
+        }
+        stream << '}' << (index + 1 == lanes.size() ? "\n" : ",\n");
+    }
+    stream << "  ]\n}\n";
+}
+
+}  // namespace rclane

cpp/src/decoder.cpp

@@ -0,0 +1,796 @@
+#include "decoder.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <fstream>
+#include <iomanip>
+#include <limits>
+#include <numeric>
+#include <stdexcept>
+#include <unordered_map>
+#include <utility>
+
+#include <omp.h>
+
+namespace rclane {
+namespace {
+
+constexpr int kMapWidth = 800;
+constexpr int kMapHeight = 320;
+
+struct Seed {
+    int x{};
+    int y{};
+    float probability{};
+};
+
+std::vector<std::size_t> numpy_float_argquicksort(
+    const std::vector<Seed>& candidates
+) {
+    // Partition structure follows NumPy's BSD-licensed npysort aquicksort;
+    // see cpp/THIRD_PARTY_NOTICES.md.
+    // Match NumPy 1.26's default np.argsort quicksort, including its
+    // deterministic (but unstable) ordering of equal saturated probabilities.
+    // This matters because the segmentation map contains long probability=1
+    // plateaus and greedy point-NMS consumes candidates in argsort order.
+    std::vector<std::size_t> order(candidates.size());
+    std::iota(order.begin(), order.end(), std::size_t{0});
+    if (order.size() <= 1) {
+        return order;
+    }
+    const auto key = [&candidates](std::size_t index) {
+        return -candidates[index].probability;
+    };
+    const auto less = [&key](std::size_t lhs, std::size_t rhs) {
+        return key(lhs) < key(rhs);
+    };
+    struct Partition {
+        std::ptrdiff_t left{};
+        std::ptrdiff_t right{};
+        int depth{};
+    };
+    std::vector<Partition> stack;
+    stack.reserve(128);
+    std::ptrdiff_t left = 0;
+    std::ptrdiff_t right = static_cast<std::ptrdiff_t>(order.size() - 1);
+    int most_significant_bit = 0;
+    for (std::size_t size = order.size(); size > 1; size >>= 1U) {
+        ++most_significant_bit;
+    }
+    int depth = most_significant_bit * 2;
+    for (;;) {
+        if (depth < 0) {
+            // NumPy switches to arg-heapsort here. This branch is not reached
+            // by the map sizes/distributions used by RCLane; retain a safe
+            // deterministic fallback for adversarial inputs.
+            std::sort(
+                order.begin() + left, order.begin() + right + 1, less
+            );
+            goto pop_partition;
+        }
+        while (right - left > 15) {
+            const std::ptrdiff_t middle = left + ((right - left) >> 1);
+            if (less(order[static_cast<std::size_t>(middle)],
+                     order[static_cast<std::size_t>(left)])) {
+                std::swap(order[static_cast<std::size_t>(middle)],
+                          order[static_cast<std::size_t>(left)]);
+            }
+            if (less(order[static_cast<std::size_t>(right)],
+                     order[static_cast<std::size_t>(middle)])) {
+                std::swap(order[static_cast<std::size_t>(right)],
+                          order[static_cast<std::size_t>(middle)]);
+            }
+            if (less(order[static_cast<std::size_t>(middle)],
+                     order[static_cast<std::size_t>(left)])) {
+                std::swap(order[static_cast<std::size_t>(middle)],
+                          order[static_cast<std::size_t>(left)]);
+            }
+            const float pivot = key(order[static_cast<std::size_t>(middle)]);
+            std::ptrdiff_t i = left;
+            std::ptrdiff_t j = right - 1;
+            std::swap(order[static_cast<std::size_t>(middle)],
+                      order[static_cast<std::size_t>(j)]);
+            for (;;) {
+                do {
+                    ++i;
+                } while (key(order[static_cast<std::size_t>(i)]) < pivot);
+                do {
+                    --j;
+                } while (pivot < key(order[static_cast<std::size_t>(j)]));
+                if (i >= j) {
+                    break;
+                }
+                std::swap(order[static_cast<std::size_t>(i)],
+                          order[static_cast<std::size_t>(j)]);
+            }
+            std::swap(order[static_cast<std::size_t>(i)],
+                      order[static_cast<std::size_t>(right - 1)]);
+            --depth;
+            if (i - left < right - i) {
+                stack.push_back({i + 1, right, depth});
+                right = i - 1;
+            } else {
+                stack.push_back({left, i - 1, depth});
+                left = i + 1;
+            }
+        }
+        for (std::ptrdiff_t i = left + 1; i <= right; ++i) {
+            const std::size_t value = order[static_cast<std::size_t>(i)];
+            std::ptrdiff_t position = i;
+            std::ptrdiff_t previous = i - 1;
+            while (position > left
+                   && key(value) < key(order[static_cast<std::size_t>(previous)])) {
+                order[static_cast<std::size_t>(position--)]
+                    = order[static_cast<std::size_t>(previous--)];
+            }
+            order[static_cast<std::size_t>(position)] = value;
+        }
+    pop_partition:
+        if (stack.empty()) {
+            break;
+        }
+        const Partition next = stack.back();
+        stack.pop_back();
+        left = next.left;
+        right = next.right;
+        depth = next.depth;
+    }
+    return order;
+}
+
+float median(std::vector<float> values) {
+    if (values.empty()) {
+        return 0.0F;
+    }
+    const std::size_t middle = values.size() / 2;
+    std::nth_element(values.begin(), values.begin() + middle, values.end());
+    const float upper = values[middle];
+    if ((values.size() & 1U) != 0U) {
+        return upper;
+    }
+    const float lower = *std::max_element(
+        values.begin(), values.begin() + middle
+    );
+    return (lower + upper) * 0.5F;
+}
+
+double quantile(std::vector<float> values, double fraction) {
+    if (values.empty()) {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    std::sort(values.begin(), values.end());
+    const double position = fraction * static_cast<double>(values.size() - 1);
+    const auto lower = static_cast<std::size_t>(std::floor(position));
+    const auto upper = static_cast<std::size_t>(std::ceil(position));
+    const double blend = position - static_cast<double>(lower);
+    return static_cast<double>(values[lower]) * (1.0 - blend)
+        + static_cast<double>(values[upper]) * blend;
+}
+
+std::vector<Seed> select_seeds(
+    const std::vector<float>& probability,
+    const DecoderConfig& config,
+    DecodeStatistics* statistics
+) {
+    std::vector<Seed> candidates;
+    candidates.reserve(probability.size() / 20);
+    for (int y = 0; y < kMapHeight; ++y) {
+        for (int x = 0; x < kMapWidth; ++x) {
+            const float value = probability[static_cast<std::size_t>(
+                y * kMapWidth + x
+            )];
+            if (value > config.seed_threshold) {
+                candidates.push_back({x, y, value});
+            }
+        }
+    }
+    if (statistics != nullptr) {
+        statistics->foreground_pixels = candidates.size();
+    }
+    const auto order = numpy_float_argquicksort(candidates);
+
+    std::vector<std::uint8_t> taken(
+        static_cast<std::size_t>(kMapWidth * kMapHeight), 0
+    );
+    std::vector<Seed> selected;
+    selected.reserve(static_cast<std::size_t>(config.max_seeds));
+    for (const std::size_t candidate_index : order) {
+        const Seed& candidate = candidates[candidate_index];
+        const std::size_t position = static_cast<std::size_t>(
+            candidate.y * kMapWidth + candidate.x
+        );
+        if (taken[position] != 0U) {
+            continue;
+        }
+        selected.push_back(candidate);
+        const int y0 = std::max(0, candidate.y - config.seed_min_distance);
+        const int y1 = std::min(
+            kMapHeight - 1, candidate.y + config.seed_min_distance
+        );
+        const int x0 = std::max(0, candidate.x - config.seed_min_distance);
+        const int x1 = std::min(
+            kMapWidth - 1, candidate.x + config.seed_min_distance
+        );
+        for (int y = y0; y <= y1; ++y) {
+            for (int x = x0; x <= x1; ++x) {
+                taken[static_cast<std::size_t>(y * kMapWidth + x)] = 1U;
+            }
+        }
+        if (static_cast<int>(selected.size()) >= config.max_seeds) {
+            break;
+        }
+    }
+    if (statistics != nullptr) {
+        statistics->seeds = selected.size();
+    }
+    return selected;
+}
+
+std::vector<LanePoint> crawl(
+    const Seed& seed,
+    const std::vector<float>& probability,
+    const std::vector<float>& arrow,
+    const std::vector<float>& bound,
+    const DecoderConfig& config
+) {
+    std::vector<LanePoint> points;
+    points.reserve(48);
+    int cx = seed.x;
+    int cy = seed.y;
+    double remain_square_sum = 0.0;
+    int remain_count = 0;
+    const std::size_t channel_elements = static_cast<std::size_t>(
+        kMapWidth * kMapHeight
+    );
+    for (int index = 0; index < kMapHeight; ++index) {
+        const std::size_t current = static_cast<std::size_t>(
+            cy * kMapWidth + cx
+        );
+        if (probability[current] > config.segmentation_threshold) {
+            const double remain = static_cast<double>(bound[current]) * 100.0
+                / static_cast<double>(config.step_length)
+                + static_cast<double>(index);
+            remain_square_sum += remain * remain;
+            ++remain_count;
+        }
+        const float dx = arrow[current];
+        const float dy = arrow[channel_elements + current];
+        const float norm = std::sqrt(dx * dx + dy * dy);
+        if (norm == 0.0F || !std::isfinite(norm)) {
+            break;
+        }
+        cx = static_cast<int>(std::floor(
+            static_cast<float>(cx) + dx / norm * config.step_length
+        ));
+        cy = static_cast<int>(std::floor(
+            static_cast<float>(cy) + dy / norm * config.step_length
+        ));
+        if (cx < 0 || cx >= kMapWidth || cy < 0 || cy >= kMapHeight) {
+            break;
+        }
+        const float score = probability[static_cast<std::size_t>(
+            cy * kMapWidth + cx
+        )];
+        points.push_back({static_cast<float>(cx), static_cast<float>(cy), score});
+        const double remaining = remain_count > 0
+            ? std::sqrt(remain_square_sum / static_cast<double>(remain_count))
+            : 1.0;
+        if (score > config.segmentation_threshold) {
+            continue;
+        }
+        if (static_cast<double>(index) > remaining * 0.75) {
+            break;
+        }
+    }
+    return points;
+}
+
+double reference_x(const Lane& lane) {
+    if (lane.points.empty()) {
+        return std::numeric_limits<double>::infinity();
+    }
+    if (lane.points.size() < 2) {
+        return lane.points.front().x;
+    }
+    std::vector<float> y_values;
+    y_values.reserve(lane.points.size());
+    for (const auto& point : lane.points) {
+        if (std::isfinite(point.x) && std::isfinite(point.y)) {
+            y_values.push_back(point.y);
+        }
+    }
+    if (y_values.size() < 2) {
+        return lane.points.front().x;
+    }
+    const double cutoff = quantile(y_values, 0.6);
+    double sum_x = 0.0;
+    double sum_y = 0.0;
+    double min_y = std::numeric_limits<double>::infinity();
+    double max_y = -std::numeric_limits<double>::infinity();
+    std::vector<const LanePoint*> lower;
+    for (const auto& point : lane.points) {
+        if (std::isfinite(point.x) && std::isfinite(point.y)
+            && static_cast<double>(point.y) >= cutoff) {
+            lower.push_back(&point);
+            sum_x += point.x;
+            sum_y += point.y;
+            min_y = std::min(min_y, static_cast<double>(point.y));
+            max_y = std::max(max_y, static_cast<double>(point.y));
+        }
+    }
+    const auto bottom_x = [&lane]() {
+        return static_cast<double>(std::max_element(
+            lane.points.begin(), lane.points.end(),
+            [](const LanePoint& lhs, const LanePoint& rhs) {
+                return lhs.y < rhs.y;
+            }
+        )->x);
+    };
+    if (lower.size() < 2 || max_y - min_y < 1.0) {
+        return bottom_x();
+    }
+    const double mean_x = sum_x / static_cast<double>(lower.size());
+    const double mean_y = sum_y / static_cast<double>(lower.size());
+    double numerator = 0.0;
+    double denominator = 0.0;
+    for (const auto* point : lower) {
+        const double centered_y = static_cast<double>(point->y) - mean_y;
+        numerator += centered_y * (static_cast<double>(point->x) - mean_x);
+        denominator += centered_y * centered_y;
+    }
+    if (denominator <= 1e-6) {
+        return bottom_x();
+    }
+    return mean_x + numerator / denominator
+        * (static_cast<double>(lane.height - 1) - mean_y);
+}
+
+std::vector<int> preselect_candidates(
+    const std::vector<Lane>& lanes,
+    const std::vector<int>& score_order,
+    int max_lanes
+) {
+    if (static_cast<int>(score_order.size()) <= max_lanes) {
+        return score_order;
+    }
+    struct Bucket {
+        int key{};
+        std::vector<int> indices;
+    };
+    std::vector<Bucket> buckets;
+    for (const int index : score_order) {
+        const Lane& lane = lanes[static_cast<std::size_t>(index)];
+        std::vector<float> y;
+        y.reserve(lane.points.size());
+        for (const auto& point : lane.points) {
+            y.push_back(point.y);
+        }
+        const float median_y = median(std::move(y));
+        std::vector<float> lower_x;
+        for (const auto& point : lane.points) {
+            if (point.y >= median_y) {
+                lower_x.push_back(point.x);
+            }
+        }
+        const int key = static_cast<int>(std::floor(median(lower_x) / 16.0F));
+        auto found = std::find_if(
+            buckets.begin(), buckets.end(),
+            [key](const Bucket& bucket) { return bucket.key == key; }
+        );
+        if (found == buckets.end()) {
+            buckets.push_back({key, {index}});
+        } else {
+            found->indices.push_back(index);
+        }
+    }
+    std::vector<int> selected;
+    selected.reserve(static_cast<std::size_t>(max_lanes));
+    for (std::size_t rank = 0; static_cast<int>(selected.size()) < max_lanes;
+         ++rank) {
+        bool progressed = false;
+        for (const auto& bucket : buckets) {
+            if (rank < bucket.indices.size()) {
+                selected.push_back(bucket.indices[rank]);
+                progressed = true;
+                if (static_cast<int>(selected.size()) == max_lanes) {
+                    break;
+                }
+            }
+        }
+        if (!progressed) {
+            break;
+        }
+    }
+    std::stable_sort(selected.begin(), selected.end(), [&lanes](int lhs, int rhs) {
+        return lanes[static_cast<std::size_t>(lhs)].score()
+            > lanes[static_cast<std::size_t>(rhs)].score();
+    });
+    return selected;
+}
+
+void draw_disk(
+    std::vector<std::uint8_t>& mask, int width, int height,
+    int cx, int cy, int radius
+) {
+    for (int y = std::max(0, cy - radius); y <= std::min(height - 1, cy + radius); ++y) {
+        for (int x = std::max(0, cx - radius); x <= std::min(width - 1, cx + radius); ++x) {
+            const int dx = x - cx;
+            const int dy = y - cy;
+            if (dx * dx + dy * dy <= radius * radius) {
+                mask[static_cast<std::size_t>(y * width + x)] = 1U;
+            }
+        }
+    }
+}
+
+std::vector<std::uint64_t> rasterize(
+    const Lane& lane, float scale, int lane_width, int width, int height
+) {
+    std::vector<std::uint8_t> pixels(
+        static_cast<std::size_t>(width * height), 0U
+    );
+    if (lane.points.size() < 2) {
+        return std::vector<std::uint64_t>(
+            (pixels.size() + 63U) / 64U, 0U
+        );
+    }
+    const int thickness = std::max(1, static_cast<int>(std::lround(
+        static_cast<double>(lane_width) * scale
+    )));
+    const int radius = std::max(1, thickness / 2);
+    for (std::size_t index = 1; index < lane.points.size(); ++index) {
+        int x0 = std::clamp(static_cast<int>(lane.points[index - 1].x * scale), 0, width - 1);
+        int y0 = std::clamp(static_cast<int>(lane.points[index - 1].y * scale), 0, height - 1);
+        const int x1 = std::clamp(static_cast<int>(lane.points[index].x * scale), 0, width - 1);
+        const int y1 = std::clamp(static_cast<int>(lane.points[index].y * scale), 0, height - 1);
+        const int dx = std::abs(x1 - x0);
+        const int sx = x0 < x1 ? 1 : -1;
+        const int dy = -std::abs(y1 - y0);
+        const int sy = y0 < y1 ? 1 : -1;
+        int error = dx + dy;
+        for (;;) {
+            draw_disk(pixels, width, height, x0, y0, radius);
+            if (x0 == x1 && y0 == y1) {
+                break;
+            }
+            const int twice = 2 * error;
+            if (twice >= dy) {
+                error += dy;
+                x0 += sx;
+            }
+            if (twice <= dx) {
+                error += dx;
+                y0 += sy;
+            }
+        }
+    }
+    std::vector<std::uint64_t> mask((pixels.size() + 63U) / 64U, 0U);
+    for (std::size_t index = 0; index < pixels.size(); ++index) {
+        if (pixels[index] != 0U) {
+            mask[index / 64U] |= std::uint64_t{1} << (index % 64U);
+        }
+    }
+    return mask;
+}
+
+std::vector<Lane> nms(
+    std::vector<Lane> lanes,
+    const DecoderConfig& config,
+    DecodeStatistics* statistics
+) {
+    std::vector<int> order(lanes.size());
+    std::iota(order.begin(), order.end(), 0);
+    std::stable_sort(order.begin(), order.end(), [&lanes](int lhs, int rhs) {
+        return lanes[static_cast<std::size_t>(lhs)].score()
+            > lanes[static_cast<std::size_t>(rhs)].score();
+    });
+    order = preselect_candidates(lanes, order, config.nms_max_lanes);
+    if (statistics != nullptr) {
+        statistics->nms_candidates = order.size();
+    }
+    const int width = std::max(1, static_cast<int>(std::lround(
+        static_cast<double>(kMapWidth) * config.nms_scale
+    )));
+    const int height = std::max(1, static_cast<int>(std::lround(
+        static_cast<double>(kMapHeight) * config.nms_scale
+    )));
+    std::vector<std::vector<std::uint64_t>> masks;
+    std::vector<int> areas;
+    masks.reserve(order.size());
+    areas.reserve(order.size());
+    for (const int index : order) {
+        masks.push_back(rasterize(
+            lanes[static_cast<std::size_t>(index)], config.nms_scale,
+            config.lane_width, width, height
+        ));
+        int area = 0;
+        for (const std::uint64_t word : masks.back()) {
+            area += __builtin_popcountll(word);
+        }
+        areas.push_back(area);
+    }
+    std::vector<std::uint8_t> suppressed(order.size(), 0U);
+    std::vector<Lane> kept;
+    for (std::size_t i = 0; i < order.size(); ++i) {
+        if (suppressed[i] != 0U) {
+            continue;
+        }
+        kept.push_back(std::move(lanes[static_cast<std::size_t>(order[i])])) ;
+        for (std::size_t j = i + 1; j < order.size(); ++j) {
+            if (suppressed[j] != 0U) {
+                continue;
+            }
+            int intersection = 0;
+            for (std::size_t word = 0; word < masks[i].size(); ++word) {
+                intersection += __builtin_popcountll(
+                    masks[i][word] & masks[j][word]
+                );
+            }
+            const int union_area = areas[i] + areas[j] - intersection;
+            if (union_area > 0
+                && static_cast<double>(intersection) / union_area
+                    >= config.iou_threshold) {
+                suppressed[j] = 1U;
+            }
+        }
+    }
+    if (statistics != nullptr) {
+        statistics->nms_survivors = kept.size();
+    }
+    return kept;
+}
+
+void assign_roles(std::vector<Lane>& lanes, double ego_x) {
+    std::vector<Lane*> left;
+    std::vector<Lane*> right;
+    std::unordered_map<const Lane*, double> references;
+    for (auto& lane : lanes) {
+        lane.lane_id = std::numeric_limits<int>::min();
+        lane.role.clear();
+        lane.ego_boundary = false;
+        lane.lateral_rank = 0;
+        references[&lane] = reference_x(lane);
+        (references[&lane] < ego_x ? left : right).push_back(&lane);
+    }
+    const auto near_ego = [&references, ego_x](const Lane* lhs, const Lane* rhs) {
+        const double dl = std::abs(references[lhs] - ego_x);
+        const double dr = std::abs(references[rhs] - ego_x);
+        return dl != dr ? dl < dr : lhs->score() > rhs->score();
+    };
+    std::sort(left.begin(), left.end(), near_ego);
+    std::sort(right.begin(), right.end(), near_ego);
+    for (std::size_t index = 0; index < left.size(); ++index) {
+        const int rank = static_cast<int>(index + 1);
+        left[index]->lane_id = 2 - rank;
+        left[index]->lateral_rank = -rank;
+        left[index]->ego_boundary = rank == 1;
+        left[index]->role = rank == 1 ? "ego_left" : "left_" + std::to_string(rank);
+    }
+    for (std::size_t index = 0; index < right.size(); ++index) {
+        const int rank = static_cast<int>(index + 1);
+        right[index]->lane_id = 1 + rank;
+        right[index]->lateral_rank = rank;
+        right[index]->ego_boundary = rank == 1;
+        right[index]->role = rank == 1 ? "ego_right" : "right_" + std::to_string(rank);
+    }
+    std::sort(lanes.begin(), lanes.end(), [](const Lane& lhs, const Lane& rhs) {
+        return lhs.lane_id < rhs.lane_id;
+    });
+}
+
+std::vector<Lane> select_ego_lanes(
+    std::vector<Lane> lanes, const DecoderConfig& config
+) {
+    if (lanes.empty()) {
+        return {};
+    }
+    std::vector<int> pool(lanes.size());
+    std::iota(pool.begin(), pool.end(), 0);
+    std::vector<double> references(lanes.size());
+    for (std::size_t index = 0; index < lanes.size(); ++index) {
+        references[index] = reference_x(lanes[index]);
+    }
+    if (static_cast<int>(lanes.size()) > config.max_output_lanes) {
+        const double best = std::max_element(
+            lanes.begin(), lanes.end(), [](const Lane& lhs, const Lane& rhs) {
+                return lhs.score() < rhs.score();
+            }
+        )->score();
+        std::vector<int> reliable;
+        for (const int index : pool) {
+            if (lanes[static_cast<std::size_t>(index)].score()
+                >= best * config.ego_min_score_ratio) {
+                reliable.push_back(index);
+            }
+        }
+        if (static_cast<int>(reliable.size()) >= config.max_output_lanes) {
+            pool = std::move(reliable);
+        }
+    }
+    const auto proximity = [&lanes, &references, &config](int lhs, int rhs) {
+        const double dl = std::abs(references[static_cast<std::size_t>(lhs)] - config.ego_x);
+        const double dr = std::abs(references[static_cast<std::size_t>(rhs)] - config.ego_x);
+        return dl != dr ? dl < dr
+            : lanes[static_cast<std::size_t>(lhs)].score()
+                > lanes[static_cast<std::size_t>(rhs)].score();
+    };
+    std::vector<int> left;
+    std::vector<int> right;
+    for (const int index : pool) {
+        (references[static_cast<std::size_t>(index)] < config.ego_x
+            ? left : right).push_back(index);
+    }
+    std::sort(left.begin(), left.end(), proximity);
+    std::sort(right.begin(), right.end(), proximity);
+    std::vector<int> selected;
+    if (config.max_output_lanes == 4) {
+        selected.insert(selected.end(), left.begin(), left.begin() + std::min<std::size_t>(2, left.size()));
+        selected.insert(selected.end(), right.begin(), right.begin() + std::min<std::size_t>(2, right.size()));
+    } else {
+        std::sort(pool.begin(), pool.end(), proximity);
+        pool.resize(std::min<std::size_t>(pool.size(), static_cast<std::size_t>(config.max_output_lanes)));
+        selected = std::move(pool);
+    }
+    std::vector<Lane> result;
+    result.reserve(selected.size());
+    for (const int index : selected) {
+        result.push_back(std::move(lanes[static_cast<std::size_t>(index)]));
+    }
+    assign_roles(result, config.ego_x);
+    return result;
+}
+
+const Tensor& require_output(
+    const std::unordered_map<std::string, Tensor>& outputs,
+    const std::string& name
+) {
+    const auto found = outputs.find(name);
+    if (found == outputs.end()) {
+        throw std::runtime_error("missing TensorRT output: " + name);
+    }
+    return found->second;
+}
+
+}  // namespace
+
+double Lane::score() const {
+    return points.empty() ? 0.0
+        : score_sum / static_cast<double>(points.size());
+}
+
+std::vector<float> softmax_foreground(const Tensor& logits) {
+    const std::size_t plane = static_cast<std::size_t>(kMapWidth * kMapHeight);
+    if (logits.values.size() != plane * 2) {
+        throw std::invalid_argument("seg_map must have shape (1,2,320,800)");
+    }
+    std::vector<float> probability(plane);
+#pragma omp parallel for schedule(static)
+    for (std::int64_t index = 0; index < static_cast<std::int64_t>(plane); ++index) {
+        const float difference = logits.values[static_cast<std::size_t>(index)]
+            - logits.values[plane + static_cast<std::size_t>(index)];
+        probability[static_cast<std::size_t>(index)]
+            = 1.0F / (1.0F + std::exp(difference));
+    }
+    return probability;
+}
+
+std::vector<Lane> decode(
+    const std::vector<float>& probability,
+    const Tensor& up_arrow,
+    const Tensor& down_arrow,
+    const Tensor& up_bound,
+    const Tensor& down_bound,
+    const DecoderConfig& config,
+    DecodeStatistics* statistics
+) {
+    const std::size_t plane = static_cast<std::size_t>(kMapWidth * kMapHeight);
+    if (probability.size() != plane
+        || up_arrow.values.size() != plane * 2
+        || down_arrow.values.size() != plane * 2
+        || up_bound.values.size() != plane * 2
+        || down_bound.values.size() != plane * 2) {
+        throw std::invalid_argument("decoder map shape mismatch");
+    }
+    if (statistics != nullptr) {
+        *statistics = {};
+    }
+    omp_set_num_threads(config.threads);
+    const auto seeds = select_seeds(probability, config, statistics);
+    std::vector<std::vector<LanePoint>> up(seeds.size());
+    std::vector<std::vector<LanePoint>> down(seeds.size());
+#pragma omp parallel for schedule(static)
+    for (std::int64_t index = 0; index < static_cast<std::int64_t>(seeds.size()); ++index) {
+        up[static_cast<std::size_t>(index)] = crawl(
+            seeds[static_cast<std::size_t>(index)], probability,
+            up_arrow.values, up_bound.values, config
+        );
+        down[static_cast<std::size_t>(index)] = crawl(
+            seeds[static_cast<std::size_t>(index)], probability,
+            down_arrow.values, down_bound.values, config
+        );
+    }
+    std::vector<Lane> candidates;
+    candidates.reserve(seeds.size());
+    for (std::size_t index = 0; index < seeds.size(); ++index) {
+        const std::size_t count = up[index].size() + down[index].size();
+        if (count <= 1) {
+            continue;
+        }
+        Lane lane;
+        lane.width = kMapWidth;
+        lane.height = kMapHeight;
+        lane.points.reserve(count);
+        for (auto point = up[index].rbegin(); point != up[index].rend(); ++point) {
+            lane.points.push_back(*point);
+            lane.score_sum += point->score;
+        }
+        for (const auto& point : down[index]) {
+            lane.points.push_back(point);
+            lane.score_sum += point.score;
+        }
+        if (lane.score() >= config.score_threshold) {
+            candidates.push_back(std::move(lane));
+        }
+    }
+    if (statistics != nullptr) {
+        statistics->crawled_candidates = candidates.size();
+    }
+    auto kept = nms(std::move(candidates), config, statistics);
+    return select_ego_lanes(std::move(kept), config);
+}
+
+std::vector<Lane> decode_outputs(
+    const std::unordered_map<std::string, Tensor>& outputs,
+    const DecoderConfig& config,
+    DecodeStatistics* statistics
+) {
+    const auto probability = softmax_foreground(require_output(outputs, "seg_map"));
+    return decode(
+        probability,
+        require_output(outputs, "up_arrow"),
+        require_output(outputs, "down_arrow"),
+        require_output(outputs, "up_bound"),
+        require_output(outputs, "down_bound"),
+        config,
+        statistics
+    );
+}
+
+void write_lanes_json(
+    const std::string& path,
+    const std::vector<Lane>& lanes,
+    const DecodeStatistics* statistics
+) {
+    std::ofstream stream(path);
+    if (!stream) {
+        throw std::runtime_error("cannot write lanes JSON: " + path);
+    }
+    stream << std::setprecision(9) << "{\n";
+    if (statistics != nullptr) {
+        stream << "  \"statistics\": {\"foreground_pixels\": "
+               << statistics->foreground_pixels << ", \"seeds\": "
+               << statistics->seeds << ", \"crawled_candidates\": "
+               << statistics->crawled_candidates << ", \"nms_candidates\": "
+               << statistics->nms_candidates << ", \"nms_survivors\": "
+               << statistics->nms_survivors << "},\n";
+    }
+    stream << "  \"lanes\": [\n";
+    for (std::size_t lane_index = 0; lane_index < lanes.size(); ++lane_index) {
+        const Lane& lane = lanes[lane_index];
+        stream << "    {\"lane_id\": " << lane.lane_id
+               << ", \"role\": \"" << lane.role
+               << "\", \"score\": " << lane.score() << ", \"points\": [";
+        for (std::size_t point_index = 0; point_index < lane.points.size(); ++point_index) {
+            const auto& point = lane.points[point_index];
+            if (point_index != 0) {
+                stream << ',';
+            }
+            stream << '[' << point.x << ',' << point.y << ',' << point.score << ']';
+        }
+        stream << "]}" << (lane_index + 1 == lanes.size() ? "\n" : ",\n");
+    }
+    stream << "  ]\n}\n";
+}
+
+}  // namespace rclane

cpp/src/main.cpp

@@ -0,0 +1,528 @@
+#include "tensorrt_runner.hpp"
+#include "decoder.hpp"
+#include "bev.hpp"
+#include "preprocess.hpp"
+
+#include <fstream>
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <iomanip>
+#include <iostream>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace {
+
+struct Arguments {
+    std::string engine;
+    std::string input;
+    std::string input_bgr;
+    std::string dump_prefix;
+    std::string lanes_json;
+    std::string bev_json;
+    std::string report;
+    std::string frames_jsonl;
+    bool raw_bgr_stdin{false};
+    int source_width{1920};
+    int source_height{1080};
+    int max_frames{0};
+    int timing_warmup{5};
+    int warmup{10};
+    int iterations{100};
+    int threads{8};
+};
+
+Arguments parse_arguments(int argc, char** argv) {
+    Arguments args;
+    for (int index = 1; index < argc; ++index) {
+        const std::string option = argv[index];
+        const auto value = [&]() -> std::string {
+            if (++index >= argc) {
+                throw std::invalid_argument("missing value for " + option);
+            }
+            return argv[index];
+        };
+        if (option == "--engine") {
+            args.engine = value();
+        } else if (option == "--input-nchw") {
+            args.input = value();
+        } else if (option == "--input-bgr") {
+            args.input_bgr = value();
+        } else if (option == "--raw-bgr-stdin") {
+            args.raw_bgr_stdin = true;
+        } else if (option == "--dump-prefix") {
+            args.dump_prefix = value();
+        } else if (option == "--lanes-json") {
+            args.lanes_json = value();
+        } else if (option == "--bev-json") {
+            args.bev_json = value();
+        } else if (option == "--report") {
+            args.report = value();
+        } else if (option == "--frames-jsonl") {
+            args.frames_jsonl = value();
+        } else if (option == "--source-width") {
+            args.source_width = std::stoi(value());
+        } else if (option == "--source-height") {
+            args.source_height = std::stoi(value());
+        } else if (option == "--max-frames") {
+            args.max_frames = std::stoi(value());
+        } else if (option == "--timing-warmup") {
+            args.timing_warmup = std::stoi(value());
+        } else if (option == "--warmup") {
+            args.warmup = std::stoi(value());
+        } else if (option == "--iterations") {
+            args.iterations = std::stoi(value());
+        } else if (option == "--threads") {
+            args.threads = std::stoi(value());
+        } else {
+            throw std::invalid_argument("unknown argument: " + option);
+        }
+    }
+    const int input_modes = static_cast<int>(!args.input.empty())
+        + static_cast<int>(!args.input_bgr.empty())
+        + static_cast<int>(args.raw_bgr_stdin);
+    if (args.engine.empty() || input_modes != 1
+        || args.source_width <= 0 || args.source_height <= 0
+        || args.timing_warmup < 0 || args.max_frames < 0) {
+        throw std::invalid_argument(
+            "usage: rclane_runtime --engine model.engine "
+            "(--input-nchw frame.f32 | --input-bgr frame.bgr | "
+            "--raw-bgr-stdin) "
+            "[--dump-prefix output]"
+        );
+    }
+    return args;
+}
+
+std::vector<float> read_floats(
+    const std::string& path, std::size_t expected
+) {
+    std::ifstream stream(path, std::ios::binary | std::ios::ate);
+    if (!stream) {
+        throw std::runtime_error("cannot open input: " + path);
+    }
+    const auto byte_count = static_cast<std::size_t>(stream.tellg());
+    if (byte_count != expected * sizeof(float)) {
+        throw std::runtime_error(
+            "input byte count mismatch: expected "
+            + std::to_string(expected * sizeof(float)) + ", got "
+            + std::to_string(byte_count)
+        );
+    }
+    std::vector<float> values(expected);
+    stream.seekg(0);
+    stream.read(
+        reinterpret_cast<char*>(values.data()),
+        static_cast<std::streamsize>(byte_count)
+    );
+    return values;
+}
+
+std::vector<std::uint8_t> read_bytes(
+    const std::string& path, std::size_t expected
+) {
+    std::ifstream stream(path, std::ios::binary | std::ios::ate);
+    if (!stream) {
+        throw std::runtime_error("cannot open input: " + path);
+    }
+    const auto byte_count = static_cast<std::size_t>(stream.tellg());
+    if (byte_count != expected) {
+        throw std::runtime_error(
+            "BGR byte count mismatch: expected " + std::to_string(expected)
+            + ", got " + std::to_string(byte_count)
+        );
+    }
+    std::vector<std::uint8_t> bytes(expected);
+    stream.seekg(0);
+    stream.read(reinterpret_cast<char*>(bytes.data()),
+                static_cast<std::streamsize>(byte_count));
+    return bytes;
+}
+
+void dump_outputs(
+    const std::string& prefix,
+    const std::unordered_map<std::string, rclane::Tensor>& outputs
+) {
+    if (prefix.empty()) {
+        return;
+    }
+    for (const auto& [name, tensor] : outputs) {
+        const std::string path = prefix + "." + name + ".f32";
+        std::ofstream stream(path, std::ios::binary);
+        if (!stream) {
+            throw std::runtime_error("cannot write output: " + path);
+        }
+        stream.write(
+            reinterpret_cast<const char*>(tensor.values.data()),
+            static_cast<std::streamsize>(
+                tensor.values.size() * sizeof(float)
+            )
+        );
+    }
+}
+
+void dump_input(const std::string& prefix, const std::vector<float>& input) {
+    if (prefix.empty()) {
+        return;
+    }
+    std::ofstream stream(prefix + ".input.f32", std::ios::binary);
+    if (!stream) {
+        throw std::runtime_error("cannot write normalized input");
+    }
+    stream.write(
+        reinterpret_cast<const char*>(input.data()),
+        static_cast<std::streamsize>(input.size() * sizeof(float))
+    );
+}
+
+struct TimingSummary {
+    double mean{};
+    double median{};
+    double p95{};
+    double minimum{};
+    double maximum{};
+};
+
+TimingSummary summarize(std::vector<double> values) {
+    if (values.empty()) {
+        throw std::runtime_error("no timed frames after warmup");
+    }
+    std::sort(values.begin(), values.end());
+    const auto percentile = [&values](double fraction) {
+        const auto position = static_cast<std::size_t>(std::floor(
+            fraction * static_cast<double>(values.size() - 1)
+        ));
+        return values[position];
+    };
+    return {
+        std::accumulate(values.begin(), values.end(), 0.0)
+            / static_cast<double>(values.size()),
+        percentile(0.5), percentile(0.95), values.front(), values.back(),
+    };
+}
+
+double milliseconds(
+    std::chrono::steady_clock::time_point start,
+    std::chrono::steady_clock::time_point stop
+) {
+    return std::chrono::duration<double, std::milli>(stop - start).count();
+}
+
+void write_stream_report(
+    const std::string& path,
+    std::size_t frames,
+    std::size_t timed_frames,
+    int threads,
+    const TimingSummary& read,
+    const TimingSummary& preprocess,
+    const TimingSummary& inference,
+    const TimingSummary& decode,
+    const TimingSummary& bev,
+    const TimingSummary& core,
+    double mean_lanes
+) {
+    if (path.empty()) {
+        return;
+    }
+    std::ofstream stream(path);
+    if (!stream) {
+        throw std::runtime_error("cannot write benchmark report: " + path);
+    }
+    const auto timing = [&stream](const char* name, const TimingSummary& value,
+                                  bool comma) {
+        stream << "    \"" << name << "\": {\"mean_ms\": " << value.mean
+               << ", \"median_ms\": " << value.median
+               << ", \"p95_ms\": " << value.p95
+               << ", \"min_ms\": " << value.minimum
+               << ", \"max_ms\": " << value.maximum << '}'
+               << (comma ? ",\n" : "\n");
+    };
+    stream << std::setprecision(12)
+           << "{\n  \"runtime\": \"native_tensorrt_cpp\",\n"
+           << "  \"sequential_per_frame\": true,\n"
+           << "  \"frame_overlap\": false,\n"
+           << "  \"rendering_included\": false,\n"
+           << "  \"video_writing_included\": false,\n"
+           << "  \"bev_mode\": \"raw_model_projection\",\n"
+           << "  \"parallel_assumption\": false,\n"
+           << "  \"synthetic_lanes\": false,\n"
+           << "  \"frames\": " << frames << ",\n"
+           << "  \"timed_frames\": " << timed_frames << ",\n"
+           << "  \"decode_threads\": " << threads << ",\n"
+           << "  \"mean_output_lanes\": " << mean_lanes << ",\n"
+           << "  \"timing\": {\n";
+    timing("source_read", read, true);
+    timing("preprocess", preprocess, true);
+    timing("inference_with_transfers", inference, true);
+    timing("decode", decode, true);
+    timing("bev_cubic_funnel", bev, true);
+    timing("core_pipeline", core, false);
+    stream << "  },\n  \"fps_from_core_median_latency\": "
+           << 1000.0 / core.median << "\n}\n";
+}
+
+int run_raw_stream(
+    const Arguments& args,
+    rclane::TensorRTRunner& runner
+) {
+    const std::size_t frame_bytes = static_cast<std::size_t>(
+        args.source_width * args.source_height * 3
+    );
+    std::vector<std::uint8_t> frame(frame_bytes);
+    std::vector<float> input(runner.input_elements(), 0.0F);
+    // Warm only TensorRT with a neutral tensor; actual frame timings discard
+    // the first timing_warmup frames so OpenMP and allocator startup are absent.
+    for (int index = 0; index < args.warmup; ++index) {
+        runner.infer_reuse(input.data());
+    }
+    rclane::DecoderConfig decoder_config;
+    decoder_config.threads = args.threads;
+    std::vector<double> read_samples;
+    std::vector<double> preprocess_samples;
+    std::vector<double> inference_samples;
+    std::vector<double> decode_samples;
+    std::vector<double> bev_samples;
+    std::vector<double> core_samples;
+    std::size_t frames = 0;
+    std::size_t timed_frames = 0;
+    double lane_sum = 0.0;
+    std::ofstream frame_results;
+    if (!args.frames_jsonl.empty()) {
+        frame_results.open(args.frames_jsonl);
+        if (!frame_results) {
+            throw std::runtime_error(
+                "cannot write frame results: " + args.frames_jsonl
+            );
+        }
+        frame_results << std::setprecision(9);
+    }
+    for (;;) {
+        if (args.max_frames > 0 && static_cast<int>(frames) >= args.max_frames) {
+            break;
+        }
+        const auto read_start = std::chrono::steady_clock::now();
+        std::cin.read(
+            reinterpret_cast<char*>(frame.data()),
+            static_cast<std::streamsize>(frame.size())
+        );
+        const auto read_stop = std::chrono::steady_clock::now();
+        if (std::cin.gcount() == 0) {
+            break;
+        }
+        if (std::cin.gcount() != static_cast<std::streamsize>(frame.size())) {
+            throw std::runtime_error("partial BGR frame on stdin");
+        }
+        const auto core_start = std::chrono::steady_clock::now();
+        const auto preprocess_start = core_start;
+        rclane::normalize_bgr_to_nchw(
+            frame.data(), args.source_width, args.source_height, input
+        );
+        const auto preprocess_stop = std::chrono::steady_clock::now();
+        const auto inference_start = preprocess_stop;
+        const auto& outputs = runner.infer_reuse(input.data());
+        const auto inference_stop = std::chrono::steady_clock::now();
+        const auto decode_start = inference_stop;
+        rclane::DecodeStatistics decode_statistics;
+        const auto lanes = rclane::decode_outputs(
+            outputs, decoder_config, &decode_statistics
+        );
+        const auto decode_stop = std::chrono::steady_clock::now();
+        const auto bev_lanes = rclane::project_lanes_to_bev(lanes);
+        const auto bev_stop = std::chrono::steady_clock::now();
+        const double frame_preprocess_ms = milliseconds(
+            preprocess_start, preprocess_stop
+        );
+        const double frame_inference_ms = milliseconds(
+            inference_start, inference_stop
+        );
+        const double frame_decode_ms = milliseconds(decode_start, decode_stop);
+        const double frame_bev_ms = milliseconds(decode_stop, bev_stop);
+        const double frame_core_ms = milliseconds(core_start, bev_stop);
+        // Serialization is deliberately after bev_stop, outside core latency.
+        if (frame_results) {
+            frame_results << "{\"frame_index\":" << frames
+                          << ",\"timing\":{\"preprocess_ms\":"
+                          << frame_preprocess_ms
+                          << ",\"inference_ms\":" << frame_inference_ms
+                          << ",\"decode_ms\":" << frame_decode_ms
+                          << ",\"bev_result_ms\":" << frame_bev_ms
+                          << ",\"core_ms\":" << frame_core_ms << "}"
+                          << ",\"lanes\":[";
+            for (std::size_t lane_index = 0; lane_index < lanes.size();
+                 ++lane_index) {
+                const auto& lane = lanes[lane_index];
+                if (lane_index != 0U) {
+                    frame_results << ',';
+                }
+                frame_results << "{\"lane_id\":" << lane.lane_id
+                              << ",\"role\":\"" << lane.role
+                              << "\",\"score\":" << lane.score()
+                              << ",\"points\":[";
+                for (std::size_t point_index = 0;
+                     point_index < lane.points.size(); ++point_index) {
+                    const auto& point = lane.points[point_index];
+                    if (point_index != 0U) {
+                        frame_results << ',';
+                    }
+                    frame_results << '[' << point.x << ',' << point.y << ','
+                                  << point.score << ']';
+                }
+                frame_results << "]}";
+            }
+            frame_results << "],\"bev_lanes\":[";
+            for (std::size_t lane_index = 0;
+                 lane_index < bev_lanes.size(); ++lane_index) {
+                const auto& lane = bev_lanes[lane_index];
+                if (lane_index != 0U) {
+                    frame_results << ',';
+                }
+                frame_results << "{\"lane_id\":" << lane.lane_id
+                              << ",\"role\":\"" << lane.role
+                              << "\",\"score\":" << lane.score
+                              << ",\"fit_accepted\":"
+                              << (lane.fit_accepted ? "true" : "false")
+                              << ",\"funnel_clipped\":"
+                              << (lane.funnel_clipped ? "true" : "false")
+                              << ",\"points\":[";
+                for (std::size_t point_index = 0;
+                     point_index < lane.points.size(); ++point_index) {
+                    const auto& point = lane.points[point_index];
+                    if (point_index != 0U) {
+                        frame_results << ',';
+                    }
+                    frame_results << '[' << point.x << ',' << point.y << ','
+                                  << point.score << ']';
+                }
+                frame_results << ']';
+                if (lane.fit.valid) {
+                    frame_results << ",\"fit\":{\"coefficients\":["
+                                  << lane.fit.coefficients[0] << ','
+                                  << lane.fit.coefficients[1] << ','
+                                  << lane.fit.coefficients[2] << ','
+                                  << lane.fit.coefficients[3]
+                                  << "],\"x_min\":" << lane.fit.x_min
+                                  << ",\"x_max\":" << lane.fit.x_max
+                                  << ",\"rmse\":" << lane.fit.rmse
+                                  << ",\"point_count\":"
+                                  << lane.fit.point_count
+                                  << ",\"inlier_count\":"
+                                  << lane.fit.inlier_count << '}';
+                } else {
+                    frame_results << ",\"fit\":null";
+                }
+                frame_results << '}';
+            }
+            frame_results << "]}\n";
+        }
+        lane_sum += static_cast<double>(lanes.size());
+        if (static_cast<int>(frames) >= args.timing_warmup) {
+            read_samples.push_back(milliseconds(read_start, read_stop));
+            preprocess_samples.push_back(frame_preprocess_ms);
+            inference_samples.push_back(frame_inference_ms);
+            decode_samples.push_back(frame_decode_ms);
+            bev_samples.push_back(frame_bev_ms);
+            core_samples.push_back(frame_core_ms);
+            ++timed_frames;
+        }
+        ++frames;
+        if (frames % 100U == 0U) {
+            std::cerr << "processed " << frames << " frames\n";
+        }
+    }
+    if (frames == 0 || timed_frames == 0) {
+        throw std::runtime_error("raw stream produced no timed frames");
+    }
+    const auto read = summarize(std::move(read_samples));
+    const auto preprocess = summarize(std::move(preprocess_samples));
+    const auto inference = summarize(std::move(inference_samples));
+    const auto decode = summarize(std::move(decode_samples));
+    const auto bev = summarize(std::move(bev_samples));
+    const auto core = summarize(std::move(core_samples));
+    write_stream_report(
+        args.report, frames, timed_frames, args.threads, read, preprocess,
+        inference, decode, bev, core, lane_sum / static_cast<double>(frames)
+    );
+    std::cout << std::fixed << std::setprecision(3)
+              << "C++ sequential raw-BEV benchmark (render/write excluded)\n"
+              << "frames=" << frames << " timed=" << timed_frames
+              << " threads=" << args.threads << '\n'
+              << "preprocess median=" << preprocess.median << "ms\n"
+              << "inference+D2H median=" << inference.median << "ms\n"
+              << "decode median=" << decode.median << "ms\n"
+              << "BEV median=" << bev.median << "ms\n"
+              << "core median=" << core.median << "ms p95=" << core.p95
+              << "ms FPS=" << (1000.0 / core.median) << '\n';
+    return 0;
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+    try {
+        const auto args = parse_arguments(argc, argv);
+        rclane::TensorRTRunner runner(args.engine);
+        if (args.raw_bgr_stdin) {
+            return run_raw_stream(args, runner);
+        }
+        std::vector<float> input;
+        if (!args.input.empty()) {
+            input = read_floats(args.input, runner.input_elements());
+        } else {
+            const auto bgr = read_bytes(
+                args.input_bgr, static_cast<std::size_t>(1920 * 1080 * 3)
+            );
+            rclane::normalize_bgr_to_nchw(bgr.data(), 1920, 1080, input);
+        }
+        dump_input(args.dump_prefix, input);
+        const auto outputs = runner.infer(input.data());
+        dump_outputs(args.dump_prefix, outputs);
+        rclane::DecoderConfig decoder_config;
+        decoder_config.threads = args.threads;
+        rclane::DecodeStatistics decode_statistics;
+        const auto lanes = rclane::decode_outputs(
+            outputs, decoder_config, &decode_statistics
+        );
+        if (!args.lanes_json.empty()) {
+            rclane::write_lanes_json(
+                args.lanes_json, lanes, &decode_statistics
+            );
+        }
+        const auto bev_lanes = rclane::project_lanes_to_bev(lanes);
+        if (!args.bev_json.empty()) {
+            rclane::write_bev_json(args.bev_json, bev_lanes);
+        }
+        const auto timing = runner.benchmark(
+            input.data(), args.warmup, args.iterations
+        );
+        std::cout << std::fixed << std::setprecision(3)
+                  << "TensorRT C++ inference: mean=" << timing.mean_ms
+                  << "ms median=" << timing.median_ms
+                  << "ms p95=" << timing.p95_ms
+                  << "ms min=" << timing.min_ms
+                  << "ms max=" << timing.max_ms
+                  << "ms FPS=" << (1000.0 / timing.median_ms) << '\n';
+        for (const auto& [name, tensor] : outputs) {
+            std::cout << name << " elements=" << tensor.values.size() << '\n';
+        }
+        std::cout << "decode seeds=" << decode_statistics.seeds
+                  << " candidates=" << decode_statistics.crawled_candidates
+                  << " NMS=" << decode_statistics.nms_candidates
+                  << "->" << decode_statistics.nms_survivors
+                  << " output_lanes=" << lanes.size() << '\n';
+        std::cout << "BEV lanes=" << bev_lanes.size() << " valid_cubics="
+                  << std::count_if(
+                      bev_lanes.begin(), bev_lanes.end(),
+                      [](const rclane::BevLane& lane) {
+                          return lane.fit_accepted;
+                      }
+                  ) << '\n';
+        return 0;
+    } catch (const std::exception& error) {
+        std::cerr << "error: " << error.what() << '\n';
+        return 1;
+    }
+}

cpp/src/preprocess.cpp

@@ -0,0 +1,119 @@
+#include "preprocess.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <stdexcept>
+
+#include <omp.h>
+
+namespace rclane {
+
+void normalize_bgr_to_nchw(
+    const std::uint8_t* bgr,
+    int source_width,
+    int source_height,
+    std::vector<float>& destination
+) {
+    constexpr int output_width = 800;
+    constexpr int output_height = 320;
+    constexpr float mean[3]{0.485F, 0.456F, 0.406F};
+    constexpr float standard_deviation[3]{0.229F, 0.224F, 0.225F};
+    if (bgr == nullptr || source_width <= 0 || source_height <= 0) {
+        throw std::invalid_argument("invalid BGR source image");
+    }
+    const std::size_t plane = static_cast<std::size_t>(
+        output_width * output_height
+    );
+    destination.resize(plane * 3);
+    constexpr int coefficient_scale = 1 << 11;
+    const double scale_x = static_cast<double>(source_width)
+        / static_cast<double>(output_width);
+    const double scale_y = static_cast<double>(source_height)
+        / static_cast<double>(output_height);
+#pragma omp parallel for schedule(static)
+    for (int output_y = 0; output_y < output_height; ++output_y) {
+        const float source_y = static_cast<float>(
+            (static_cast<double>(output_y) + 0.5) * scale_y - 0.5
+        );
+        int y0 = static_cast<int>(std::floor(source_y));
+        float wy = source_y - static_cast<float>(y0);
+        if (y0 < 0) {
+            y0 = 0;
+            wy = 0.0F;
+        }
+        int y1 = std::min(y0 + 1, source_height - 1);
+        if (y0 >= source_height - 1) {
+            y0 = source_height - 1;
+            y1 = y0;
+            wy = 0.0F;
+        }
+        const int beta1 = static_cast<int>(std::nearbyint(
+            wy * static_cast<float>(coefficient_scale)
+        ));
+        const int beta0 = static_cast<int>(std::nearbyint(
+            (1.0F - wy) * static_cast<float>(coefficient_scale)
+        ));
+        for (int output_x = 0; output_x < output_width; ++output_x) {
+            const float source_x = static_cast<float>(
+                (static_cast<double>(output_x) + 0.5) * scale_x - 0.5
+            );
+            int x0 = static_cast<int>(std::floor(source_x));
+            float wx = source_x - static_cast<float>(x0);
+            if (x0 < 0) {
+                x0 = 0;
+                wx = 0.0F;
+            }
+            int x1 = std::min(x0 + 1, source_width - 1);
+            if (x0 >= source_width - 1) {
+                x0 = source_width - 1;
+                x1 = x0;
+                wx = 0.0F;
+            }
+            const int alpha1 = static_cast<int>(std::nearbyint(
+                wx * static_cast<float>(coefficient_scale)
+            ));
+            const int alpha0 = static_cast<int>(std::nearbyint(
+                (1.0F - wx) * static_cast<float>(coefficient_scale)
+            ));
+            const std::size_t output = static_cast<std::size_t>(
+                output_y * output_width + output_x
+            );
+            const std::size_t top_left = static_cast<std::size_t>(
+                (y0 * source_width + x0) * 3
+            );
+            const std::size_t top_right = static_cast<std::size_t>(
+                (y0 * source_width + x1) * 3
+            );
+            const std::size_t bottom_left = static_cast<std::size_t>(
+                (y1 * source_width + x0) * 3
+            );
+            const std::size_t bottom_right = static_cast<std::size_t>(
+                (y1 * source_width + x1) * 3
+            );
+            for (int rgb_channel = 0; rgb_channel < 3; ++rgb_channel) {
+                const int bgr_channel = 2 - rgb_channel;
+                const int top = static_cast<int>(bgr[top_left + bgr_channel]) * alpha0
+                    + static_cast<int>(bgr[top_right + bgr_channel]) * alpha1;
+                const int bottom = static_cast<int>(bgr[bottom_left + bgr_channel]) * alpha0
+                    + static_cast<int>(bgr[bottom_right + bgr_channel]) * alpha1;
+                // Match OpenCV 4.11's Apache-licensed VResizeLinear<8u>; see
+                // cpp/THIRD_PARTY_NOTICES.md. Its
+                // fixed-point shifts intentionally happen before accumulation.
+                const int pixel_integer = (
+                    ((beta0 * (top >> 4)) >> 16)
+                    + ((beta1 * (bottom >> 4)) >> 16) + 2
+                ) >> 2;
+                const float pixel = static_cast<float>(
+                    std::clamp(pixel_integer, 0, 255)
+                );
+                destination[static_cast<std::size_t>(rgb_channel) * plane + output]
+                    = (pixel * (1.0F / 255.0F) - mean[rgb_channel])
+                        / standard_deviation[rgb_channel];
+            }
+        }
+    }
+}
+
+}  // namespace rclane

cpp/src/tensorrt_runner.cpp

@@ -0,0 +1,313 @@
+#include "tensorrt_runner.hpp"
+
+#include <NvInferRuntime.h>
+#include <cuda_runtime_api.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <fstream>
+#include <limits>
+#include <numeric>
+#include <stdexcept>
+#include <utility>
+
+namespace rclane {
+namespace {
+
+class Logger final : public nvinfer1::ILogger {
+public:
+    void log(Severity severity, const char* message) noexcept override {
+        if (severity <= Severity::kWARNING) {
+            // TensorRT owns message storage; copying is unnecessary here.
+            last_message_ = message == nullptr ? "" : message;
+        }
+    }
+
+    const std::string& last_message() const { return last_message_; }
+
+private:
+    std::string last_message_;
+};
+
+void check_cuda(cudaError_t status, const char* operation) {
+    if (status != cudaSuccess) {
+        throw std::runtime_error(
+            std::string(operation) + ": " + cudaGetErrorString(status)
+        );
+    }
+}
+
+std::vector<char> read_binary(const std::string& path) {
+    std::ifstream stream(path, std::ios::binary | std::ios::ate);
+    if (!stream) {
+        throw std::runtime_error("cannot open TensorRT engine: " + path);
+    }
+    const auto end = stream.tellg();
+    if (end <= 0) {
+        throw std::runtime_error("empty TensorRT engine: " + path);
+    }
+    std::vector<char> bytes(static_cast<std::size_t>(end));
+    stream.seekg(0);
+    stream.read(bytes.data(), static_cast<std::streamsize>(bytes.size()));
+    if (!stream) {
+        throw std::runtime_error("cannot read TensorRT engine: " + path);
+    }
+    return bytes;
+}
+
+std::vector<std::int64_t> dimensions(const nvinfer1::Dims& dims) {
+    std::vector<std::int64_t> shape;
+    shape.reserve(static_cast<std::size_t>(dims.nbDims));
+    for (int index = 0; index < dims.nbDims; ++index) {
+        if (dims.d[index] <= 0) {
+            throw std::runtime_error("dynamic/invalid TensorRT shape");
+        }
+        shape.push_back(dims.d[index]);
+    }
+    return shape;
+}
+
+std::size_t element_count(const std::vector<std::int64_t>& shape) {
+    return std::accumulate(
+        shape.begin(), shape.end(), std::size_t{1},
+        [](std::size_t total, std::int64_t value) {
+            return total * static_cast<std::size_t>(value);
+        }
+    );
+}
+
+struct DeviceTensor {
+    std::string name;
+    bool input{};
+    std::vector<std::int64_t> shape;
+    std::size_t elements{};
+    void* device{};
+};
+
+}  // namespace
+
+class TensorRTRunner::Impl {
+public:
+    explicit Impl(const std::string& engine_path) {
+        const auto bytes = read_binary(engine_path);
+        runtime_.reset(nvinfer1::createInferRuntime(logger_));
+        if (!runtime_) {
+            throw std::runtime_error("createInferRuntime failed");
+        }
+        engine_.reset(runtime_->deserializeCudaEngine(
+            bytes.data(), bytes.size()
+        ));
+        if (!engine_) {
+            throw std::runtime_error(
+                "deserializeCudaEngine failed: " + logger_.last_message()
+            );
+        }
+        context_.reset(engine_->createExecutionContext());
+        if (!context_) {
+            throw std::runtime_error("createExecutionContext failed");
+        }
+        check_cuda(cudaStreamCreate(&stream_), "cudaStreamCreate");
+
+        const int tensor_count = engine_->getNbIOTensors();
+        for (int index = 0; index < tensor_count; ++index) {
+            const char* tensor_name = engine_->getIOTensorName(index);
+            if (engine_->getTensorDataType(tensor_name)
+                != nvinfer1::DataType::kFLOAT) {
+                throw std::runtime_error(
+                    std::string("non-FP32 engine tensor: ") + tensor_name
+                );
+            }
+            DeviceTensor tensor;
+            tensor.name = tensor_name;
+            tensor.input = engine_->getTensorIOMode(tensor_name)
+                == nvinfer1::TensorIOMode::kINPUT;
+            tensor.shape = dimensions(engine_->getTensorShape(tensor_name));
+            tensor.elements = element_count(tensor.shape);
+            check_cuda(
+                cudaMalloc(&tensor.device, tensor.elements * sizeof(float)),
+                "cudaMalloc"
+            );
+            if (!context_->setTensorAddress(tensor.name.c_str(), tensor.device)) {
+                throw std::runtime_error(
+                    "setTensorAddress failed for " + tensor.name
+                );
+            }
+            if (tensor.input) {
+                if (input_index_ >= 0) {
+                    throw std::runtime_error("engine has multiple inputs");
+                }
+                input_index_ = static_cast<int>(tensors_.size());
+            }
+            tensors_.push_back(std::move(tensor));
+        }
+        if (input_index_ < 0) {
+            throw std::runtime_error("engine has no input tensor");
+        }
+    }
+
+    ~Impl() {
+        for (auto& tensor : tensors_) {
+            if (tensor.device != nullptr) {
+                cudaFree(tensor.device);
+            }
+        }
+        if (stream_ != nullptr) {
+            cudaStreamDestroy(stream_);
+        }
+    }
+
+    void enqueue(const float* input) {
+        const auto& tensor = tensors_[static_cast<std::size_t>(input_index_)];
+        check_cuda(cudaMemcpyAsync(
+            tensor.device, input, tensor.elements * sizeof(float),
+            cudaMemcpyHostToDevice, stream_
+        ), "cudaMemcpyAsync input");
+        if (!context_->enqueueV3(stream_)) {
+            throw std::runtime_error("TensorRT enqueueV3 failed");
+        }
+    }
+
+    void synchronize() {
+        check_cuda(cudaStreamSynchronize(stream_), "cudaStreamSynchronize");
+    }
+
+    std::unordered_map<std::string, Tensor> infer(const float* input) {
+        enqueue(input);
+        std::unordered_map<std::string, Tensor> output;
+        for (const auto& tensor : tensors_) {
+            if (tensor.input) {
+                continue;
+            }
+            Tensor host;
+            host.shape = tensor.shape;
+            host.values.resize(tensor.elements);
+            check_cuda(cudaMemcpyAsync(
+                host.values.data(), tensor.device,
+                tensor.elements * sizeof(float), cudaMemcpyDeviceToHost,
+                stream_
+            ), "cudaMemcpyAsync output");
+            output.emplace(tensor.name, std::move(host));
+        }
+        synchronize();
+        return output;
+    }
+
+    const std::unordered_map<std::string, Tensor>& infer_reuse(
+        const float* input
+    ) {
+        if (host_outputs_.empty()) {
+            for (const auto& tensor : tensors_) {
+                if (tensor.input) {
+                    continue;
+                }
+                Tensor host;
+                host.shape = tensor.shape;
+                host.values.resize(tensor.elements);
+                host_outputs_.emplace(tensor.name, std::move(host));
+            }
+        }
+        enqueue(input);
+        for (const auto& tensor : tensors_) {
+            if (tensor.input) {
+                continue;
+            }
+            auto& host = host_outputs_.at(tensor.name);
+            check_cuda(cudaMemcpyAsync(
+                host.values.data(), tensor.device,
+                tensor.elements * sizeof(float), cudaMemcpyDeviceToHost,
+                stream_
+            ), "cudaMemcpyAsync reusable output");
+        }
+        synchronize();
+        return host_outputs_;
+    }
+
+    InferenceTiming benchmark(const float* input, int warmup, int iterations) {
+        if (warmup < 0 || iterations <= 0) {
+            throw std::invalid_argument("invalid benchmark iteration count");
+        }
+        for (int index = 0; index < warmup; ++index) {
+            enqueue(input);
+            synchronize();
+        }
+        std::vector<double> samples;
+        samples.reserve(static_cast<std::size_t>(iterations));
+        for (int index = 0; index < iterations; ++index) {
+            const auto started = std::chrono::steady_clock::now();
+            enqueue(input);
+            synchronize();
+            const auto stopped = std::chrono::steady_clock::now();
+            samples.push_back(std::chrono::duration<double, std::milli>(
+                stopped - started
+            ).count());
+        }
+        std::sort(samples.begin(), samples.end());
+        const auto percentile = [&samples](double fraction) {
+            const auto position = static_cast<std::size_t>(std::floor(
+                fraction * static_cast<double>(samples.size() - 1)
+            ));
+            return samples[position];
+        };
+        const double sum = std::accumulate(samples.begin(), samples.end(), 0.0);
+        return {
+            sum / static_cast<double>(samples.size()),
+            percentile(0.50),
+            percentile(0.95),
+            samples.front(),
+            samples.back(),
+        };
+    }
+
+    const std::vector<std::int64_t>& input_shape() const {
+        return tensors_[static_cast<std::size_t>(input_index_)].shape;
+    }
+
+    std::size_t input_elements() const {
+        return tensors_[static_cast<std::size_t>(input_index_)].elements;
+    }
+
+private:
+    Logger logger_;
+    struct RuntimeDeleter {
+        template <typename T>
+        void operator()(T* pointer) const { delete pointer; }
+    };
+    std::unique_ptr<nvinfer1::IRuntime, RuntimeDeleter> runtime_;
+    std::unique_ptr<nvinfer1::ICudaEngine, RuntimeDeleter> engine_;
+    std::unique_ptr<nvinfer1::IExecutionContext, RuntimeDeleter> context_;
+    cudaStream_t stream_{};
+    std::vector<DeviceTensor> tensors_;
+    std::unordered_map<std::string, Tensor> host_outputs_;
+    int input_index_{-1};
+};
+
+TensorRTRunner::TensorRTRunner(const std::string& engine_path)
+    : impl_(std::make_unique<Impl>(engine_path)) {}
+TensorRTRunner::~TensorRTRunner() = default;
+TensorRTRunner::TensorRTRunner(TensorRTRunner&&) noexcept = default;
+TensorRTRunner& TensorRTRunner::operator=(TensorRTRunner&&) noexcept = default;
+
+const std::vector<std::int64_t>& TensorRTRunner::input_shape() const {
+    return impl_->input_shape();
+}
+std::size_t TensorRTRunner::input_elements() const {
+    return impl_->input_elements();
+}
+std::unordered_map<std::string, Tensor> TensorRTRunner::infer(
+    const float* input
+) {
+    return impl_->infer(input);
+}
+const std::unordered_map<std::string, Tensor>& TensorRTRunner::infer_reuse(
+    const float* input
+) {
+    return impl_->infer_reuse(input);
+}
+InferenceTiming TensorRTRunner::benchmark(
+    const float* input, int warmup, int iterations
+) {
+    return impl_->benchmark(input, warmup, iterations);
+}
+
+}  // namespace rclane

dataset.py

@@ -33,6 +33,23 @@ def normalize_image(img_bgr, W, H):
     return torch.from_numpy(np.ascontiguousarray(x.transpose(2, 0, 1)))
 
 
+def normalize_image_numpy(img_bgr, W, H):
+    """Fast inference-only BGR uint8 -> normalized ``(1, 3, H, W)`` NumPy.
+
+    ``cv2.dnn.blobFromImage`` performs resize, RGB channel swap and NCHW
+    packing in compiled code. The result is numerically equivalent to
+    :func:`normalize_image` within float32 rounding, while avoiding the
+    temporary HWC float image and Torch tensor wrapper.
+    """
+    images = cv2.dnn.blobFromImage(
+        img_bgr, scalefactor=1.0 / 255.0, size=(W, H), mean=(0, 0, 0),
+        swapRB=True, crop=False,
+    )
+    images[0] -= _MEAN.reshape(3, 1, 1)
+    images[0] /= _STD.reshape(3, 1, 1)
+    return images
+
+
 def sparse_from_dense(gt):
     """Keep only foreground pixels of the dense GT maps."""
     ys, xs = np.where(gt["seg_map"] > 0.5)

decode.py

@@ -26,6 +26,44 @@ Map layout (matches encode.py / rclane.py, channel-first):
 import numpy as np
 import cv2
 
+try:
+    from numba import njit, prange
+except ImportError:  # portable fallback for environments without the JIT
+    njit = None
+    prange = range
+
+
+if njit is not None:
+    @njit(cache=True)
+    def _greedy_seed_select_numba(sorted_x, sorted_y, height, width,
+                                  radius, max_seeds):
+        taken = np.zeros((height, width), dtype=np.uint8)
+        limit = len(sorted_x) if max_seeds < 0 else min(
+            len(sorted_x), max_seeds
+        )
+        seeds = np.empty((limit, 2), dtype=np.int32)
+        seed_count = 0
+        for candidate in range(len(sorted_x)):
+            x = int(sorted_x[candidate])
+            y = int(sorted_y[candidate])
+            if taken[y, x] != 0:
+                continue
+            seeds[seed_count, 0] = x
+            seeds[seed_count, 1] = y
+            seed_count += 1
+            y_start = max(0, y - radius)
+            y_stop = min(height, y + radius + 1)
+            x_start = max(0, x - radius)
+            x_stop = min(width, x + radius + 1)
+            for yy in range(y_start, y_stop):
+                for xx in range(x_start, x_stop):
+                    taken[yy, xx] = 1
+            if max_seeds >= 0 and seed_count >= max_seeds:
+                break
+        return seeds[:seed_count]
+else:
+    _greedy_seed_select_numba = None
+
 
 # --------------------------------------------------------------------------- #
 #  Lane container (replaces FloatLengthLine + PointSelf)
@@ -36,32 +74,51 @@ class Lane:
         self.height = height
         self.points = []  # list of (x, y, score)
         self._score_sum = 0.0
-        self.lane_id = None  # stable left-to-right index, set by order_lanes()
+        self.lane_id = None
+        self.lane_role = None
+        self.is_ego_boundary = False
+        self.lateral_rank = None
 
     def append(self, x, y, score):
+        if isinstance(self.points, np.ndarray):
+            self.points = [tuple(map(float, point)) for point in self.points]
         self.points.append((float(x), float(y), float(score)))
         self._score_sum += float(score)
 
     def reverse(self):
-        self.points.reverse()
+        if isinstance(self.points, np.ndarray):
+            self.points = self.points[::-1].copy()
+        else:
+            self.points.reverse()
 
     def __len__(self):
         return len(self.points)
 
     @property
     def score(self):
-        if not self.points:
+        if len(self.points) == 0:
             return 0.0
         return self._score_sum / len(self.points)
 
     def concat(self, other):
         out = Lane(self.width, self.height)
-        out.points = self.points + other.points
+        if isinstance(self.points, np.ndarray) or isinstance(
+            other.points, np.ndarray
+        ):
+            out.points = np.concatenate((
+                np.asarray(self.points, dtype=np.float32),
+                np.asarray(other.points, dtype=np.float32),
+            ))
+        else:
+            out.points = self.points + other.points
         out._score_sum = self._score_sum + other._score_sum
         return out
 
     def xy(self):
-        return np.array([(p[0], p[1]) for p in self.points], dtype=float)
+        points = np.asarray(self.points, dtype=np.float32)
+        if points.size == 0:
+            return np.empty((0, 2), dtype=np.float32)
+        return points[:, :2]
 
     def iou(self, other, lane_width=15):
         """Rasterize both lanes (cv2.line, width 15) and return mask IoU."""
@@ -83,13 +140,28 @@ class Lane:
 # --------------------------------------------------------------------------- #
 #  seeding
 # --------------------------------------------------------------------------- #
-def point_nms(prob, thr=0.5, min_dist=2, max_seeds=1024):
+def point_nms(prob, thr=0.5, min_dist=2, max_seeds=1024,
+              backend="auto"):
     """Greedy point-NMS: keep highest-prob foreground pixels >= min_dist apart."""
     H, W = prob.shape
     ys, xs = np.where(prob > thr)
     if len(ys) == 0:
         return []
     order = np.argsort(-prob[ys, xs])
+    selected_backend = backend
+    if backend == "auto":
+        selected_backend = (
+            "numba" if _greedy_seed_select_numba is not None else "python"
+        )
+    if selected_backend == "numba":
+        limit = -1 if max_seeds is None else int(max_seeds)
+        return _greedy_seed_select_numba(
+            np.ascontiguousarray(xs[order], dtype=np.int32),
+            np.ascontiguousarray(ys[order], dtype=np.int32),
+            H, W, int(min_dist), limit,
+        )
+    if selected_backend != "python":
+        raise ValueError("point-NMS backend must be auto, numba, or python")
     taken = np.zeros((H, W), dtype=bool)
     seeds = []
     r = min_dist
@@ -144,6 +216,341 @@ def decode_branch(cx, cy, semantic_fine, arrow, bound, step_length, seg_threshol
     return lane
 
 
+def decode_branches_batch(seeds, semantic_fine, arrow, bound, step_length,
+                          seg_threshold):
+    """Vectorized equivalent of :func:`decode_branch` for many seeds.
+
+    The relay walk is inherently sequential along each lane, but every seed at
+    a given crawl step is independent. Advancing all active seeds with NumPy
+    gathers removes the expensive Python ``seeds x steps`` nested loop while
+    retaining the original stopping rule and integer pixel trajectory.
+
+    Returns:
+        ``(points, lengths)`` where ``points`` has shape ``(N, H, 3)`` and each
+        valid prefix stores ``(x, y, score)`` exactly like ``Lane.points``.
+    """
+    H, W = semantic_fine.shape
+    seed_array = np.asarray(seeds, dtype=np.int32)
+    if seed_array.size == 0:
+        return np.empty((0, H, 3), dtype=np.float32), np.zeros(0, np.int32)
+    if seed_array.ndim != 2 or seed_array.shape[1] != 2:
+        raise ValueError("seeds must have shape (N, 2)")
+
+    count = len(seed_array)
+    cx = seed_array[:, 0].copy()
+    cy = seed_array[:, 1].copy()
+    active = np.ones(count, dtype=bool)
+    lengths = np.zeros(count, dtype=np.int32)
+    remain_sq_sum = np.zeros(count, dtype=np.float64)
+    remain_count = np.zeros(count, dtype=np.int32)
+    points = np.empty((count, H, 3), dtype=np.float32)
+    arrow_dx, arrow_dy = arrow[0], arrow[1]
+
+    for index in range(H):
+        active_ids = np.flatnonzero(active)
+        if len(active_ids) == 0:
+            break
+        current_x = cx[active_ids]
+        current_y = cy[active_ids]
+        current_score = semantic_fine[current_y, current_x]
+        foreground = current_score > seg_threshold
+        if np.any(foreground):
+            foreground_ids = active_ids[foreground]
+            remain = (
+                bound[current_y[foreground], current_x[foreground]]
+                * 100.0 / step_length + index
+            )
+            remain_sq_sum[foreground_ids] += remain * remain
+            remain_count[foreground_ids] += 1
+
+        dx = arrow_dx[current_y, current_x]
+        dy = arrow_dy[current_y, current_x]
+        norm = np.sqrt(dx * dx + dy * dy)
+        movable = np.isfinite(norm) & (norm != 0.0)
+        if np.any(~movable):
+            active[active_ids[~movable]] = False
+        active_ids = active_ids[movable]
+        if len(active_ids) == 0:
+            continue
+        next_x = np.floor(
+            cx[active_ids] + dx[movable] / norm[movable] * step_length
+        ).astype(np.int32)
+        next_y = np.floor(
+            cy[active_ids] + dy[movable] / norm[movable] * step_length
+        ).astype(np.int32)
+        in_bounds = (
+            (next_x >= 0) & (next_x < W) & (next_y >= 0) & (next_y < H)
+        )
+        if np.any(~in_bounds):
+            active[active_ids[~in_bounds]] = False
+        active_ids = active_ids[in_bounds]
+        if len(active_ids) == 0:
+            continue
+        next_x = next_x[in_bounds]
+        next_y = next_y[in_bounds]
+        cx[active_ids] = next_x
+        cy[active_ids] = next_y
+        next_score = semantic_fine[next_y, next_x]
+        points[active_ids, index, 0] = next_x
+        points[active_ids, index, 1] = next_y
+        points[active_ids, index, 2] = next_score
+        lengths[active_ids] = index + 1
+
+        has_remaining = remain_count[active_ids] > 0
+        remaining = np.ones(len(active_ids), dtype=np.float64)
+        remaining[has_remaining] = np.sqrt(
+            remain_sq_sum[active_ids[has_remaining]]
+            / remain_count[active_ids[has_remaining]]
+        )
+        stop = (
+            (next_score <= seg_threshold)
+            & (index > remaining * 0.75)
+        )
+        if np.any(stop):
+            active[active_ids[stop]] = False
+    return points, lengths
+
+
+if njit is not None:
+    @njit(cache=True, parallel=True)
+    def _decode_branches_numba_impl(seeds, semantic_fine, arrow, bound,
+                                    step_length, seg_threshold):
+        """Parallel scalar relay walks compiled to native CPU code."""
+        height, width = semantic_fine.shape
+        seed_count = len(seeds)
+        points = np.empty((seed_count, height, 3), dtype=np.float32)
+        lengths = np.zeros(seed_count, dtype=np.int32)
+        for seed_index in prange(seed_count):
+            cx = int(seeds[seed_index, 0])
+            cy = int(seeds[seed_index, 1])
+            remain_sq_sum = 0.0
+            remain_count = 0
+            for index in range(height):
+                if semantic_fine[cy, cx] > seg_threshold:
+                    remain = (
+                        bound[cy, cx] * 100.0 / step_length + index
+                    )
+                    remain_sq_sum += remain * remain
+                    remain_count += 1
+
+                dx = arrow[0, cy, cx]
+                dy = arrow[1, cy, cx]
+                norm = np.sqrt(dx * dx + dy * dy)
+                if norm == 0.0 or not np.isfinite(norm):
+                    break
+                cx = int(np.floor(cx + dx / norm * step_length))
+                cy = int(np.floor(cy + dy / norm * step_length))
+                if not (0 <= cx < width and 0 <= cy < height):
+                    break
+
+                score = semantic_fine[cy, cx]
+                points[seed_index, index, 0] = cx
+                points[seed_index, index, 1] = cy
+                points[seed_index, index, 2] = score
+                lengths[seed_index] = index + 1
+
+                ret = (
+                    np.sqrt(remain_sq_sum / remain_count)
+                    if remain_count else 1.0
+                )
+                if score > seg_threshold:
+                    continue
+                if index > ret * 0.75:
+                    break
+        return points, lengths
+
+
+    @njit(cache=True, parallel=True)
+    def _candidate_metadata_numba_impl(up_points, up_lengths,
+                                       down_points, down_lengths, bin_px):
+        seed_count = len(up_lengths)
+        scores = np.zeros(seed_count, dtype=np.float64)
+        bins = np.zeros(seed_count, dtype=np.int32)
+        total_lengths = up_lengths + down_lengths
+        for seed_index in prange(seed_count):
+            up_length = int(up_lengths[seed_index])
+            down_length = int(down_lengths[seed_index])
+            total_length = up_length + down_length
+            if total_length <= 1:
+                continue
+            y_values = np.empty(total_length, dtype=np.float32)
+            score_sum = 0.0
+            position = 0
+            for point_index in range(up_length):
+                score_sum += up_points[seed_index, point_index, 2]
+                y_values[position] = up_points[seed_index, point_index, 1]
+                position += 1
+            for point_index in range(down_length):
+                score_sum += down_points[seed_index, point_index, 2]
+                y_values[position] = down_points[seed_index, point_index, 1]
+                position += 1
+            scores[seed_index] = score_sum / total_length
+            median_y = np.median(y_values)
+            lower_x = np.empty(total_length, dtype=np.float32)
+            lower_count = 0
+            for point_index in range(up_length):
+                if up_points[seed_index, point_index, 1] >= median_y:
+                    lower_x[lower_count] = up_points[
+                        seed_index, point_index, 0
+                    ]
+                    lower_count += 1
+            for point_index in range(down_length):
+                if down_points[seed_index, point_index, 1] >= median_y:
+                    lower_x[lower_count] = down_points[
+                        seed_index, point_index, 0
+                    ]
+                    lower_count += 1
+            bins[seed_index] = int(
+                np.median(lower_x[:lower_count]) // bin_px
+            )
+        return total_lengths, scores, bins
+else:
+    _decode_branches_numba_impl = None
+    _candidate_metadata_numba_impl = None
+
+
+def decode_branches_numba(seeds, semantic_fine, arrow, bound, step_length,
+                          seg_threshold):
+    if _decode_branches_numba_impl is None:
+        raise RuntimeError(
+            "Numba crawl requested but numba is not installed; "
+            "install requirements.txt or use crawl_backend='numpy'"
+        )
+    seed_array = np.asarray(seeds, dtype=np.int32)
+    if seed_array.size == 0:
+        height = semantic_fine.shape[0]
+        return (
+            np.empty((0, height, 3), dtype=np.float32),
+            np.zeros(0, dtype=np.int32),
+        )
+    return _decode_branches_numba_impl(
+        seed_array,
+        np.ascontiguousarray(semantic_fine, dtype=np.float32),
+        np.ascontiguousarray(arrow, dtype=np.float32),
+        np.ascontiguousarray(bound, dtype=np.float32),
+        float(step_length),
+        float(seg_threshold),
+    )
+
+
+def warmup_decode_backend(crawl_backend="auto"):
+    """Compile the optional Numba backend before latency measurements."""
+    backend = crawl_backend
+    if crawl_backend == "auto":
+        backend = "numba" if njit is not None else "numpy"
+    if backend != "numba":
+        return backend
+    semantic = np.zeros((8, 8), dtype=np.float32)
+    arrow = np.zeros((2, 8, 8), dtype=np.float32)
+    arrow[1] = 1.0
+    bound = np.zeros((8, 8), dtype=np.float32)
+    points, lengths = decode_branches_numba(
+        [(4, 4)], semantic, arrow, bound, 1, 0.5
+    )
+    _candidate_metadata_numba_impl(
+        points, lengths, points, lengths, 16
+    )
+    _greedy_seed_select_numba(
+        np.array((4,), dtype=np.int32),
+        np.array((4,), dtype=np.int32),
+        8, 8, 2, 1,
+    )
+    return backend
+
+
+def configure_decode_threads(thread_count=8):
+    """Set Numba's relay-crawl worker count and return the applied value."""
+    if njit is None:
+        return 1
+    import numba
+    maximum = int(numba.config.NUMBA_NUM_THREADS)
+    if not 1 <= int(thread_count) <= maximum:
+        raise ValueError(f"decode threads must be in [1, {maximum}]")
+    numba.set_num_threads(int(thread_count))
+    return numba.get_num_threads()
+
+
+def _candidate_metadata_numpy(up_points, up_lengths,
+                              down_points, down_lengths, bin_px):
+    total_lengths = up_lengths + down_lengths
+    scores = np.zeros(len(total_lengths), dtype=np.float64)
+    bins = np.zeros(len(total_lengths), dtype=np.int32)
+    for seed_index, total_length in enumerate(total_lengths):
+        if total_length <= 1:
+            continue
+        up = up_points[seed_index, :up_lengths[seed_index]]
+        down = down_points[seed_index, :down_lengths[seed_index]]
+        merged = np.concatenate((up, down))
+        scores[seed_index] = merged[:, 2].sum(dtype=np.float64) / len(merged)
+        median_y = np.median(merged[:, 1])
+        lower = merged[merged[:, 1] >= median_y]
+        bins[seed_index] = int(np.median(lower[:, 0]) // bin_px)
+    return total_lengths, scores, bins
+
+
+def _preselect_batched_candidates(up_points, up_lengths,
+                                  down_points, down_lengths, score_threshold,
+                                  max_lanes, backend, bin_px=16):
+    metadata = (
+        _candidate_metadata_numba_impl
+        if backend == "numba" else _candidate_metadata_numpy
+    )
+    total_lengths, scores, bins = metadata(
+        up_points, up_lengths, down_points, down_lengths, bin_px
+    )
+    valid = np.flatnonzero(
+        (total_lengths > 1) & (scores >= score_threshold)
+    )
+    order = valid[np.argsort(-scores[valid], kind="stable")]
+    if max_lanes is None or len(order) <= max_lanes:
+        return order
+
+    buckets = {}
+    for candidate in order:
+        buckets.setdefault(int(bins[candidate]), []).append(int(candidate))
+    keys = list(buckets)
+    positions = {key: 0 for key in keys}
+    selected = []
+    while len(selected) < max_lanes:
+        progressed = False
+        for key in keys:
+            position = positions[key]
+            if position < len(buckets[key]):
+                selected.append(buckets[key][position])
+                positions[key] += 1
+                progressed = True
+                if len(selected) >= max_lanes:
+                    break
+        if not progressed:
+            break
+    return np.asarray(
+        sorted(selected, key=lambda index: scores[index], reverse=True),
+        dtype=np.int32,
+    )
+
+
+def _lines_from_batched_crawls(up_points, up_lengths,
+                               down_points, down_lengths, width, height,
+                               candidate_indices=None):
+    lines = []
+    if candidate_indices is None:
+        candidate_indices = range(len(up_lengths))
+    for seed_index in candidate_indices:
+        up_length = int(up_lengths[seed_index])
+        down_length = int(down_lengths[seed_index])
+        if up_length + down_length <= 1:
+            continue
+        merged = np.concatenate((
+            up_points[seed_index, :up_length][::-1],
+            down_points[seed_index, :down_length],
+        ))
+        lane = Lane(width, height)
+        lane.points = merged
+        lane._score_sum = float(merged[:, 2].sum(dtype=np.float64))
+        lines.append(lane)
+    return lines
+
+
 # --------------------------------------------------------------------------- #
 #  post-processing
 # --------------------------------------------------------------------------- #
@@ -255,14 +662,46 @@ def _bottom_x(lane):
     return float(xy[int(np.argmax(xy[:, 1])), 0])
 
 
+def _ego_reference_x(lane, target_y=None):
+    """Estimate where a boundary meets the near-camera reference row.
+
+    On a sharp bend, multiple boundaries can leave through the same image side.
+    Comparing their last visible x then becomes ambiguous (both are about 0 or
+    ``width - 1``), and a short outer boundary can be mistaken for the ego-lane
+    boundary. Extrapolating the lower 40% of each polyline to a common row keeps
+    their lateral order after they leave the image.
+    """
+    xy = lane.xy()
+    if len(xy) < 2:
+        return _bottom_x(lane)
+    xy = xy[np.isfinite(xy).all(axis=1)]
+    if len(xy) < 2:
+        return _bottom_x(lane)
+    if target_y is None:
+        target_y = lane.height - 1.0
+
+    cutoff = np.quantile(xy[:, 1], 0.6)
+    lower = xy[xy[:, 1] >= cutoff]
+    if len(lower) < 2 or np.ptp(lower[:, 1]) < 1.0:
+        return _bottom_x(lane)
+
+    ys = lower[:, 1]
+    xs = lower[:, 0]
+    centered_y = ys - ys.mean()
+    denominator = float(np.dot(centered_y, centered_y))
+    if denominator <= 1e-6:
+        return _bottom_x(lane)
+    slope = float(np.dot(centered_y, xs - xs.mean()) / denominator)
+    return float(xs.mean() + slope * (float(target_y) - ys.mean()))
+
+
 def order_lanes(lanes):
-    """Sort lanes left-to-right and tag each with a stable `lane_id` (0 = leftmost).
+    """Sort lanes left-to-right and assign a frame-local index.
 
     RCLane is anchor-free: `decode` emits lane instances in score order with no
-    inherent identity -- lane 0 today could be the middle lane on the next frame.
-    Ordering by the x at the bottom of the image (nearest the camera) imposes the
-    usual left-to-right numbering so `lanes[i].lane_id == i` is consistent across
-    frames. Returns a new list; also sets `.lane_id` on each Lane in place.
+    inherent identity. This helper only establishes spatial order inside one
+    frame; it must not be used as a persistent video identity because a missing
+    outer lane would shift every following index.
     """
     ordered = sorted(lanes, key=_bottom_x)
     for i, ln in enumerate(ordered):
@@ -270,6 +709,72 @@ def order_lanes(lanes):
     return ordered
 
 
+def assign_ego_lane_roles(lanes, ego_x=None):
+    """Assign stable semantic IDs relative to the ego vehicle.
+
+    IDs describe a lane boundary's role rather than its position in a variable
+    length list:
+
+      * P1: nearest boundary left of ego (current-lane left boundary)
+      * P2: nearest boundary right of ego (current-lane right boundary)
+      * P0: next boundary to the left
+      * P3: next boundary to the right
+
+    Consequently P1/P2 do not become P0/P1 merely because an outer boundary is
+    temporarily missing. With the default four-lane cap, returned IDs are in
+    ``[0, 3]``. More uncapped lanes continue outward with negative IDs on the
+    left and IDs greater than three on the right.
+    """
+    if not lanes:
+        return []
+    if ego_x is None:
+        ego_x = lanes[0].width / 2.0
+    ego_x = float(ego_x)
+
+    for lane in lanes:
+        lane.lane_id = None
+        lane.lane_role = None
+        lane.is_ego_boundary = False
+        lane.lateral_rank = None
+
+    reference_x = {lane: _ego_reference_x(lane) for lane in lanes}
+    left = sorted(
+        (lane for lane in lanes if reference_x[lane] < ego_x),
+        key=lambda lane: (abs(reference_x[lane] - ego_x), -lane.score),
+    )
+    right = sorted(
+        (lane for lane in lanes if reference_x[lane] >= ego_x),
+        key=lambda lane: (abs(reference_x[lane] - ego_x), -lane.score),
+    )
+
+    for rank, lane in enumerate(left, 1):
+        lane.lane_id = 2 - rank  # nearest left=P1, next=P0
+        lane.lateral_rank = -rank
+        lane.is_ego_boundary = rank == 1
+        lane.lane_role = "ego_left" if rank == 1 else f"left_{rank}"
+    for rank, lane in enumerate(right, 1):
+        lane.lane_id = 1 + rank  # nearest right=P2, next=P3
+        lane.lateral_rank = rank
+        lane.is_ego_boundary = rank == 1
+        lane.lane_role = "ego_right" if rank == 1 else f"right_{rank}"
+
+    return sorted(lanes, key=lambda lane: lane.lane_id)
+
+
+def ego_lane_boundaries(lanes):
+    """Return ``(left, right)`` boundaries of the lane containing ego.
+
+    Either value can be ``None`` when that side was not detected.
+    """
+    left = next(
+        (lane for lane in lanes if lane.lane_role == "ego_left"), None
+    )
+    right = next(
+        (lane for lane in lanes if lane.lane_role == "ego_right"), None
+    )
+    return left, right
+
+
 def select_ego_lanes(lanes, max_lanes=4, ego_x=None,
                       min_score_ratio=0.5, balance_sides=True):
     """Keep the closest reliable lane boundaries around the ego vehicle.
@@ -282,24 +787,45 @@ def select_ego_lanes(lanes, max_lanes=4, ego_x=None,
 
     For the usual four-lane output, ``balance_sides`` reserves two slots on
     either side of the camera centre when possible.  Any unfilled slots are
-    taken from the remaining closest candidates.  The returned lanes are
-    re-numbered from left to right.
+    taken from the remaining closest candidates. The returned IDs are semantic:
+    P1/P2 are the current-lane boundaries, while P0/P3 are the adjacent outer
+    boundaries. Missing outer lanes therefore do not shift the ego-lane IDs.
     """
     if max_lanes is None:
-        return order_lanes(lanes)
+        return assign_ego_lane_roles(lanes, ego_x)
     if max_lanes <= 0:
         raise ValueError("max_lanes must be positive or None")
     if not 0.0 <= min_score_ratio <= 1.0:
         raise ValueError("min_score_ratio must be in [0, 1]")
 
     ordered = order_lanes(lanes)
-    if len(ordered) <= max_lanes:
-        return ordered
-
+    if not ordered:
+        return []
     if ego_x is None:
         ego_x = ordered[0].width / 2.0
     ego_x = float(ego_x)
 
+    # The four-lane semantic contract has exactly two possible boundaries per
+    # side: P0/P1 on the left and P2/P3 on the right. If one side is missing,
+    # return fewer lanes instead of filling the gap with P4/P-1 farther out.
+    if len(ordered) <= max_lanes:
+        if balance_sides and max_lanes == 4:
+            reference_x = {lane: _ego_reference_x(lane) for lane in ordered}
+
+            def near_ego(lane):
+                return (abs(reference_x[lane] - ego_x), -lane.score)
+
+            left = sorted(
+                (lane for lane in ordered if reference_x[lane] < ego_x),
+                key=near_ego,
+            )
+            right = sorted(
+                (lane for lane in ordered if reference_x[lane] >= ego_x),
+                key=near_ego,
+            )
+            ordered = left[:2] + right[:2]
+        return assign_ego_lane_roles(ordered, ego_x)
+
     best_score = max(lane.score for lane in ordered)
     reliable = [
         lane for lane in ordered
@@ -308,18 +834,20 @@ def select_ego_lanes(lanes, max_lanes=4, ego_x=None,
     # Never let the reliability gate force the output below the requested cap.
     pool = reliable if len(reliable) >= max_lanes else ordered
 
+    reference_x = {lane: _ego_reference_x(lane) for lane in pool}
+
     def proximity_key(lane):
-        return (abs(_bottom_x(lane) - ego_x), -lane.score)
+        return (abs(reference_x[lane] - ego_x), -lane.score)
 
     ranked = sorted(pool, key=proximity_key)
     selected = []
     if balance_sides and max_lanes >= 2:
         left = sorted(
-            (lane for lane in pool if _bottom_x(lane) < ego_x),
+            (lane for lane in pool if reference_x[lane] < ego_x),
             key=proximity_key,
         )
         right = sorted(
-            (lane for lane in pool if _bottom_x(lane) >= ego_x),
+            (lane for lane in pool if reference_x[lane] >= ego_x),
             key=proximity_key,
         )
         left_slots = max_lanes // 2
@@ -327,13 +855,14 @@ def select_ego_lanes(lanes, max_lanes=4, ego_x=None,
         selected.extend(left[:left_slots])
         selected.extend(right[:right_slots])
 
-    for lane in ranked:
-        if lane not in selected:
-            selected.append(lane)
-        if len(selected) == max_lanes:
-            break
+    if not (balance_sides and max_lanes == 4):
+        for lane in ranked:
+            if lane not in selected:
+                selected.append(lane)
+            if len(selected) == max_lanes:
+                break
 
-    return order_lanes(selected[:max_lanes])
+    return assign_ego_lane_roles(selected[:max_lanes], ego_x)
 
 
 # --------------------------------------------------------------------------- #
@@ -344,7 +873,9 @@ def decode(seg_prob, up_arrow, down_arrow, up_bound, down_bound,
            score_thresh=0.10, iou_thresh=0.5, seed_threshold=None,
            max_seeds=1024, nms_max_lanes=128, nms_scale=0.25,
            sort_lanes=True, max_output_lanes=4, ego_x=None,
-           ego_min_score_ratio=0.5, balance_ego_sides=True):
+           ego_min_score_ratio=0.5, balance_ego_sides=True,
+           batch_crawl=True, crawl_backend="auto",
+           point_nms_backend="auto"):
     """
     Args:
         seg_prob: (H, W) foreground probability.
@@ -361,17 +892,49 @@ def decode(seg_prob, up_arrow, down_arrow, up_bound, down_bound,
     H, W = seg_prob.shape
     if seed_threshold is None:
         seed_threshold = seg_threshold
-    seeds = point_nms(seg_prob, seed_threshold, seed_min_dist, max_seeds)
+    seeds = point_nms(
+        seg_prob, seed_threshold, seed_min_dist, max_seeds,
+        backend=point_nms_backend,
+    )
     ub0, db0 = up_bound[0], down_bound[0]  # bound channel 0 (both channels equal)
 
-    lines = []
-    for (x, y) in seeds:
-        up = decode_branch(x, y, seg_prob, up_arrow, ub0, step_length, seg_threshold)
-        down = decode_branch(x, y, seg_prob, down_arrow, db0, step_length, seg_threshold)
-        up.reverse()
-        full = up.concat(down)
-        if len(full) > 1:
-            lines.append(full)
+    if batch_crawl:
+        backend = crawl_backend
+        if crawl_backend == "auto":
+            backend = "numba" if njit is not None else "numpy"
+        if backend not in ("numba", "numpy"):
+            raise ValueError("crawl_backend must be auto, numba, or numpy")
+        crawl = (
+            decode_branches_numba if backend == "numba"
+            else decode_branches_batch
+        )
+        up_points, up_lengths = crawl(
+            seeds, seg_prob, up_arrow, ub0, step_length, seg_threshold
+        )
+        down_points, down_lengths = crawl(
+            seeds, seg_prob, down_arrow, db0, step_length, seg_threshold
+        )
+        candidate_indices = _preselect_batched_candidates(
+            up_points, up_lengths, down_points, down_lengths,
+            score_thresh, nms_max_lanes, backend,
+        )
+        lines = _lines_from_batched_crawls(
+            up_points, up_lengths, down_points, down_lengths, W, H,
+            candidate_indices,
+        )
+    else:
+        lines = []
+        for (x, y) in seeds:
+            up = decode_branch(
+                x, y, seg_prob, up_arrow, ub0, step_length, seg_threshold
+            )
+            down = decode_branch(
+                x, y, seg_prob, down_arrow, db0, step_length, seg_threshold
+            )
+            up.reverse()
+            full = up.concat(down)
+            if len(full) > 1:
+                lines.append(full)
 
     lines = thresh_line(lines, score_thresh)
     lines = iou_nms(lines, iou_thresh, max_lanes=nms_max_lanes,
@@ -486,4 +1049,43 @@ if __name__ == "__main__":
         f"ego selector kept the wrong lanes: {ego_xs}"
     )
     assert [lane.lane_id for lane in ego_lanes] == [0, 1, 2, 3]
+    ego_left, ego_right = ego_lane_boundaries(ego_lanes)
+    assert ego_left is not None and int(_bottom_x(ego_left)) == 95
+    assert ego_right is not None and int(_bottom_x(ego_right)) == 748
+
+    # Semantic IDs must not shift when an outer lane disappears. P1/P2 remain
+    # the current-lane boundaries and P3 remains the next boundary on the right.
+    missing_outer_left = select_ego_lanes(
+        [vertical_lane(95, 0.94), vertical_lane(748, 0.89),
+         vertical_lane(796, 0.81)],
+        max_lanes=4,
+    )
+    assert [lane.lane_id for lane in missing_outer_left] == [1, 2, 3]
+    missing_outer_right = select_ego_lanes(
+        [vertical_lane(8, 0.93), vertical_lane(95, 0.94),
+         vertical_lane(748, 0.89)],
+        max_lanes=4,
+    )
+    assert [lane.lane_id for lane in missing_outer_right] == [0, 1, 2]
+
+    right_only = select_ego_lanes(
+        [vertical_lane(500, 0.95), vertical_lane(600, 0.90),
+         vertical_lane(700, 0.80)],
+        max_lanes=4,
+    )
+    assert [lane.lane_id for lane in right_only] == [2, 3]
+
+    # Two right boundaries can both leave through x=width on a sharp curve.
+    # The longer/nearer curve must remain P2 even if its last visible x is a
+    # little farther right than the short outer curve's last x.
+    near_right = Lane(800, 320)
+    outer_right = Lane(800, 320)
+    for x, y in ((700, 200), (740, 225), (780, 250)):
+        near_right.append(x, y, 0.9)
+    for x, y in ((700, 125), (750, 137.5), (790, 147.5)):
+        outer_right.append(x, y, 0.8)
+    curved_right = assign_ego_lane_roles([outer_right, near_right], ego_x=400)
+    assert near_right.lane_id == 2 and near_right.lane_role == "ego_right"
+    assert outer_right.lane_id == 3 and outer_right.lane_role == "right_2"
+    assert [lane.lane_id for lane in curved_right] == [2, 3]
     print("OK -- ego post-processing keeps four reliable nearby lanes.")

requirements.txt

@@ -10,3 +10,6 @@ onnx>=1.16,<2.0
 # `onnxruntime` package alongside this package; both expose the same module.
 onnxruntime-gpu==1.27.0.dev20260511001
 torch==2.13.0+cu130
+# TensorRT 10 is required because ONNX Runtime's provider links libnvinfer.so.10.
+tensorrt-cu13==10.16.1.11
+numba>=0.61,<0.63

test_video_bev_onnx.py

@@ -0,0 +1,781 @@
+"""Run RCLane ONNX and export ego-centric cubic lane models in BEV.
+
+Each JSONL frame stores one metric polynomial per visible marking:
+
+    Y(X) = c0 + c1*X + c2*X^2 + c3*X^3
+
+X points forward from ego and Y points left. Coefficients are valid only inside
+the exported ``x_domain_m``; the implementation never extrapolates a detected
+lane to the full 300 m visualization range.
+"""
+
+import argparse
+import json
+import os
+import time
+from collections import Counter
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+from bev import (
+    BevRange,
+    CameraCalibration,
+    clip_cubic_fit_to_funnel,
+    evaluate_cubic,
+    fit_cubic_lane,
+    model_lane_to_ground,
+)
+from dataset import normalize_image_numpy
+from decode import configure_decode_threads, decode, warmup_decode_backend
+from test_video_onnx import (
+    MODEL_HEIGHT,
+    MODEL_WIDTH,
+    OUTPUT_NAMES,
+    create_session,
+    draw_predictions,
+    softmax_foreground,
+    timing_summary,
+)
+
+
+LANE_COLORS = {
+    0: (255, 255, 0),
+    1: (0, 255, 0),
+    2: (0, 165, 255),
+    3: (255, 255, 0),
+}
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--video", required=True)
+    parser.add_argument("--output", default="runs/video_bev_e19.mp4")
+    parser.add_argument("--polynomials", default=None,
+                        help="per-frame JSONL; defaults next to output")
+    parser.add_argument("--summary", default=None)
+    parser.add_argument(
+        "--provider", choices=("tensorrt", "cuda", "cpu"),
+        default="tensorrt",
+    )
+    parser.add_argument("--trt-cache-dir", default="exports/trt_cache")
+    parser.add_argument("--allow-tf32", action="store_true")
+    parser.add_argument(
+        "--start-frame", type=int, default=0,
+        help="zero-based source frame at which processing starts",
+    )
+    parser.add_argument("--max-frames", type=int, default=None)
+    parser.add_argument("--x-min", type=float, default=0.0)
+    parser.add_argument("--x-max", type=float, default=300.0)
+    parser.add_argument("--y-min", type=float, default=-85.0)
+    parser.add_argument("--y-max", type=float, default=85.0)
+    parser.add_argument(
+        "--max-cubic-rmse", type=float, default=0.5,
+        help="reject a cubic visualization above this metric RMSE",
+    )
+    parser.add_argument("--decode-seg-threshold", type=float, default=0.5)
+    parser.add_argument("--decode-seed-threshold", type=float, default=None)
+    parser.add_argument("--decode-seed-min-dist", type=int, default=2)
+    parser.add_argument("--decode-score-thresh", type=float, default=0.10)
+    parser.add_argument("--decode-nms-iou", type=float, default=0.5)
+    parser.add_argument("--decode-max-seeds", type=int, default=1024)
+    parser.add_argument(
+        "--decode-crawl-backend", choices=("auto", "numba", "numpy"),
+        default="auto",
+    )
+    parser.add_argument("--decode-cpu-threads", type=int, default=8)
+    parser.add_argument("--decode-nms-max-lanes", type=int, default=128)
+    parser.add_argument("--decode-nms-scale", type=float, default=0.25)
+    parser.add_argument("--max-ego-lanes", type=int, default=4)
+    parser.add_argument(
+        "--funnel-margin", type=float, default=0.10,
+        help="metric tolerance around the calibrated camera funnel",
+    )
+    return parser.parse_args()
+
+
+def lane_to_record(lane, calibration, bev_range, max_cubic_rmse=0.5):
+    points, scores = model_lane_to_ground(
+        lane, MODEL_WIDTH, MODEL_HEIGHT, calibration, bev_range
+    )
+    fit = fit_cubic_lane(points, scores, iterations=3)
+    lane_id = int(lane.lane_id) if lane.lane_id is not None else None
+    valid_fit = fit is not None and fit["rmse"] <= max_cubic_rmse
+    record = {
+        "lane_id": f"P{lane_id}" if lane_id is not None else None,
+        "lane_index": lane_id,
+        "role": lane.lane_role,
+        "score": float(lane.score),
+        "projected_point_count": int(len(points)),
+        "valid_fit": valid_fit,
+        "fit_status": (
+            "ok" if valid_fit else
+            "rmse_above_limit" if fit is not None else
+            "insufficient_geometry"
+        ),
+    }
+    if fit is not None:
+        record.update({
+            "polynomial": "Y(X)=c0+c1*X+c2*X^2+c3*X^3",
+            "coefficients_c0_to_c3": [
+                float(value) for value in fit["coefficients"]
+            ],
+            "x_domain_m": [fit["x_min"], fit["x_max"]],
+            "rmse_m": fit["rmse"],
+            "fit_point_count": fit["point_count"],
+            "inlier_count": fit["inlier_count"],
+            "inlier_ratio": fit["inlier_ratio"],
+        })
+    return {
+        "record": record,
+        "points": points,
+        "fit": fit if valid_fit else None,
+    }
+
+
+def clip_lane_results_to_funnel(lane_results, args):
+    """Clip raw model-derived cubics without changing their geometry.
+
+    Every output lane corresponds one-to-one with a decoded image-space lane.
+    No lane is synthesized, shifted, reordered, or forced to be parallel. The
+    cubic coefficients remain unchanged; only the declared X domain may shrink
+    when the fitted curve leaves the calibrated camera footprint.
+    """
+    calibration = CameraCalibration()
+    report = {
+        "mode": "raw_model_projection",
+        "parallel_assumption": False,
+        "synthetic_lanes": False,
+        "camera_x_m": float(calibration.camera_to_vehicle_matrix[0, 3]),
+        "horizontal_fov_deg": float(calibration.horizontal_fov_deg),
+        "margin_m": float(args.funnel_margin),
+        "clipped_lanes": [],
+        "rejected_lanes": [],
+    }
+    for result in lane_results:
+        fit = result["fit"]
+        record = result["record"]
+        if fit is None:
+            continue
+        original_coefficients = np.asarray(
+            fit["coefficients"], dtype=np.float64
+        ).copy()
+        clipped_fit, clip_report = clip_cubic_fit_to_funnel(
+            fit,
+            camera_x_m=report["camera_x_m"],
+            horizontal_fov_deg=report["horizontal_fov_deg"],
+            margin_m=args.funnel_margin,
+        )
+        lane_label = record["lane_id"]
+        if clipped_fit is None:
+            result["fit"] = None
+            record.update({
+                "valid_fit": False,
+                "fit_status": "outside_camera_funnel",
+                "funnel_guard": clip_report,
+            })
+            report["rejected_lanes"].append(lane_label)
+            continue
+        if not np.array_equal(
+            original_coefficients, clipped_fit["coefficients"]
+        ):
+            raise AssertionError("funnel clipping changed cubic coefficients")
+        result["fit"] = clipped_fit
+        record["x_domain_m"] = [
+            float(clipped_fit["x_min"]), float(clipped_fit["x_max"])
+        ]
+        record["funnel_guard"] = clip_report
+        if clip_report["clipped"]:
+            report["clipped_lanes"].append(lane_label)
+    return report
+
+
+def _bev_pixel(x_forward, y_left, bev_range, bounds):
+    left, top, right, bottom = bounds
+    px = left + (bev_range.y_max - y_left) / (
+        bev_range.y_max - bev_range.y_min
+    ) * (right - left)
+    py = top + (bev_range.x_max - x_forward) / (
+        bev_range.x_max - bev_range.x_min
+    ) * (bottom - top)
+    return np.column_stack((px, py))
+
+
+def _draw_dashed_curve(canvas, points, color, thickness=4,
+                       dash_points=7, gap_points=4):
+    stride = dash_points + gap_points
+    for start in range(0, len(points) - 1, stride):
+        segment = points[start:min(start + dash_points + 1, len(points))]
+        if len(segment) >= 2:
+            cv2.polylines(
+                canvas, [segment], False, (0, 0, 0), thickness + 4,
+                cv2.LINE_AA,
+            )
+            cv2.polylines(
+                canvas, [segment], False, color, thickness, cv2.LINE_AA,
+            )
+
+
+def draw_bev(lane_results, bev_range, calibration, funnel_report=None,
+             width=640, height=1080):
+    canvas = np.full((height, width, 3), (35, 19, 10), dtype=np.uint8)
+    bounds = (72, 62, width - 24, height - 70)
+    left, top, right, bottom = bounds
+
+    # Requested sensor-style ROI funnel: ego at the apex and the configured
+    # metric ROI at its far edge. It is a visualization of the output ROI, not
+    # a replacement for the calibrated camera ray/ground intersection.
+    camera_x = float(calibration.camera_to_vehicle_matrix[0, 3])
+    half_fov_radians = np.deg2rad(
+        calibration.horizontal_fov_deg * 0.5
+    )
+    fov_half_width = min(
+        bev_range.y_max,
+        max(0.0, bev_range.x_max - camera_x) * np.tan(half_fov_radians),
+    )
+    roi_metric = np.array(
+        ((camera_x, 0.0),
+         (bev_range.x_max, fov_half_width),
+         (bev_range.x_max, -fov_half_width)),
+        dtype=np.float64,
+    )
+    roi_pixels = np.round(_bev_pixel(
+        roi_metric[:, 0], roi_metric[:, 1], bev_range, bounds
+    )).astype(np.int32)
+    overlay = canvas.copy()
+    cv2.fillPoly(overlay, [roi_pixels], (105, 74, 105), cv2.LINE_AA)
+    cv2.addWeighted(overlay, 0.72, canvas, 0.28, 0.0, canvas)
+    cv2.polylines(canvas, [roi_pixels], True, (150, 120, 165), 2, cv2.LINE_AA)
+
+    for x in np.arange(
+        np.ceil(bev_range.x_min / 50.0) * 50.0,
+        bev_range.x_max + 0.1,
+        50.0,
+    ):
+        half_width = min(
+            fov_half_width,
+            max(0.0, x - camera_x) * np.tan(half_fov_radians),
+        )
+        y_at_left_edge = half_width
+        y_at_right_edge = -half_width
+        range_line = _bev_pixel(
+            np.array([x, x]),
+            np.array([y_at_left_edge, y_at_right_edge]),
+            bev_range,
+            bounds,
+        )
+        range_line = np.round(range_line).astype(np.int32)
+        row = int(round(range_line[0, 1]))
+        cv2.line(
+            canvas, tuple(range_line[0]), tuple(range_line[1]),
+            (118, 91, 120), 1, cv2.LINE_AA,
+        )
+        cv2.putText(
+            canvas, f"{x:.0f}m", (8, min(bottom, max(top + 12, row + 5))),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.42, (205, 190, 210), 1,
+            cv2.LINE_AA,
+        )
+
+    zero = _bev_pixel(
+        np.array([bev_range.x_min]), np.array([0.0]), bev_range, bounds
+    )[0].astype(int)
+    far_center = _bev_pixel(
+        np.array([bev_range.x_max]), np.array([0.0]), bev_range, bounds
+    )[0].astype(int)
+    for y0 in range(zero[1] - 12, far_center[1], -28):
+        y1 = max(far_center[1], y0 - 15)
+        cv2.line(canvas, (zero[0], y0), (far_center[0], y1),
+                 (225, 215, 230), 2, cv2.LINE_AA)
+    ego = np.array(
+        ((zero[0] - 10, bottom - 22), (zero[0] + 10, bottom - 22),
+         (zero[0] + 14, bottom), (zero[0] - 14, bottom)),
+        dtype=np.int32,
+    )
+    cv2.fillPoly(canvas, [ego], (238, 238, 238), cv2.LINE_AA)
+    cv2.polylines(canvas, [ego], True, (20, 20, 20), 2, cv2.LINE_AA)
+
+    formula_rows = []
+    for result in lane_results:
+        record = result["record"]
+        lane_id = record["lane_index"]
+        color = LANE_COLORS.get(lane_id, (220, 220, 220))
+        points = result["points"]
+        if len(points):
+            pixels = _bev_pixel(
+                points[:, 0], points[:, 1], bev_range, bounds
+            )
+            pixels = np.round(pixels).astype(np.int32)
+            for pixel in pixels[::max(1, len(pixels) // 40)]:
+                cv2.circle(canvas, tuple(pixel), 2, color, -1, cv2.LINE_AA)
+
+        fit = result["fit"]
+        if fit is None:
+            rmse = record.get("rmse_m")
+            reason = (
+                f"rejected rmse={rmse:.2f}m" if rmse is not None
+                else "insufficient geometry"
+            )
+            formula_rows.append((color, f"{record['lane_id']}: {reason}"))
+            continue
+        x = np.linspace(fit["x_min"], fit["x_max"], 160)
+        y = evaluate_cubic(fit["coefficients"], x)
+        valid = (
+            np.isfinite(y)
+            & (y >= bev_range.y_min)
+            & (y <= bev_range.y_max)
+        )
+        curve = _bev_pixel(x[valid], y[valid], bev_range, bounds)
+        if len(curve) >= 2:
+            curve = np.round(curve).astype(np.int32)
+            _draw_dashed_curve(canvas, curve, color)
+            cv2.putText(
+                canvas, record["lane_id"], tuple(curve[-1]),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.48, color, 2, cv2.LINE_AA,
+            )
+        formula_rows.append((
+            color,
+            f"{record['lane_id']}: X={fit['x_min']:.1f}..{fit['x_max']:.1f}m  "
+            f"rmse={fit['rmse']:.2f}m",
+        ))
+
+    cv2.putText(
+        canvas,
+        f"CAMERA FOV {calibration.horizontal_fov_deg:.0f}deg: "
+        "X forward / Y left",
+        (20, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.54,
+        (255, 255, 255), 2, cv2.LINE_AA,
+    )
+    cv2.putText(
+        canvas, "RAW MODEL LANES | no synthetic/parallel prior",
+        (20, 52), cv2.FONT_HERSHEY_SIMPLEX, 0.42,
+        (80, 220, 255), 1, cv2.LINE_AA,
+    )
+    cv2.putText(
+        canvas, "Y left (+)                          Y right (-)",
+        (left, height - 16), cv2.FONT_HERSHEY_SIMPLEX, 0.38,
+        (210, 210, 210), 1, cv2.LINE_AA,
+    )
+    for row, (color, text) in enumerate(formula_rows[:4]):
+        cv2.putText(
+            canvas, text, (82, 82 + row * 18),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.33, color, 1, cv2.LINE_AA,
+        )
+    return canvas
+
+
+def _preprocess_and_infer(session, frame):
+    """Run the producer stage; safe to execute in a dedicated GPU thread."""
+    stage = time.perf_counter()
+    images = normalize_image_numpy(frame, MODEL_WIDTH, MODEL_HEIGHT)
+    preprocess_ms = (time.perf_counter() - stage) * 1000.0
+
+    stage = time.perf_counter()
+    outputs = session.run(list(OUTPUT_NAMES), {"images": images})
+    inference_ms = (time.perf_counter() - stage) * 1000.0
+    return outputs, preprocess_ms, inference_ms
+
+
+def _decode_and_generate_bev_result(outputs, args, calibration, bev_range):
+    """Generate metric BEV data without drawing, compositing, or file I/O."""
+    stage = time.perf_counter()
+    lanes = decode(
+        softmax_foreground(outputs[0])[0], outputs[1][0], outputs[2][0],
+        outputs[3][0], outputs[4][0],
+        seg_threshold=args.decode_seg_threshold,
+        seed_threshold=args.decode_seed_threshold,
+        seed_min_dist=args.decode_seed_min_dist,
+        score_thresh=args.decode_score_thresh,
+        iou_thresh=args.decode_nms_iou,
+        max_seeds=args.decode_max_seeds,
+        nms_max_lanes=args.decode_nms_max_lanes,
+        nms_scale=args.decode_nms_scale,
+        max_output_lanes=args.max_ego_lanes,
+        crawl_backend=args.decode_crawl_backend,
+    )
+    decode_ms = (time.perf_counter() - stage) * 1000.0
+
+    stage = time.perf_counter()
+    lane_results = [
+        lane_to_record(lane, calibration, bev_range, args.max_cubic_rmse)
+        for lane in lanes
+    ]
+    funnel_report = clip_lane_results_to_funnel(lane_results, args)
+    valid_records = [
+        result["record"] for result in lane_results
+        if result["record"]["valid_fit"]
+    ]
+    bev_result_ms = (time.perf_counter() - stage) * 1000.0
+    return {
+        "lanes": lanes,
+        "lane_results": lane_results,
+        "funnel_report": funnel_report,
+        "valid_records": valid_records,
+        "decode_ms": decode_ms,
+        "bev_result_ms": bev_result_ms,
+    }
+
+
+def generate_bev_results(capture, target_frames, start_frame, session, args,
+                         calibration, bev_range):
+    """Generate ordered BEV results sequentially, one complete frame at a time.
+
+    No BEV/camera drawing, compositing, video writing, or JSON serialization is
+    performed inside this timed region.
+    """
+    timings = {
+        "preprocess": [],
+        "inference": [],
+        "decode": [],
+        "bev_result": [],
+        "pipeline": [],
+    }
+    results = []
+    generation_started = time.perf_counter()
+
+    def finish(frame_index, inference_payload):
+        outputs, preprocess_ms, inference_ms = inference_payload
+        bundle = _decode_and_generate_bev_result(
+            outputs, args, calibration, bev_range
+        )
+        compute_ms = (
+            preprocess_ms + inference_ms + bundle["decode_ms"]
+            + bundle["bev_result_ms"]
+        )
+        bundle.update({
+            "frame_index": frame_index,
+            "preprocess_ms": preprocess_ms,
+            "inference_ms": inference_ms,
+            "compute_ms": compute_ms,
+        })
+        results.append(bundle)
+        timings["preprocess"].append(preprocess_ms)
+        timings["inference"].append(inference_ms)
+        timings["decode"].append(bundle["decode_ms"])
+        timings["bev_result"].append(bundle["bev_result_ms"])
+        timings["pipeline"].append(compute_ms)
+        processed = len(results)
+        if processed % 25 == 0 or processed == target_frames:
+            elapsed = time.perf_counter() - generation_started
+            print(
+                f"result {processed}/{target_frames} "
+                f"(source={frame_index}) | "
+                f"lanes={len(bundle['lanes'])} "
+                f"cubic={len(bundle['valid_records'])} "
+                f"decode={bundle['decode_ms']:.1f}ms "
+                f"bev-result={bundle['bev_result_ms']:.1f}ms "
+                f"throughput={processed / max(elapsed, 1e-9):.1f} FPS",
+                flush=True,
+            )
+
+    for offset in range(target_frames):
+        ok, frame = capture.read()
+        if not ok:
+            break
+        finish(
+            start_frame + offset,
+            _preprocess_and_infer(session, frame),
+        )
+
+    generation_seconds = time.perf_counter() - generation_started
+    if not results:
+        raise RuntimeError("input video produced no BEV results")
+    return results, timings, generation_seconds
+
+
+def make_composite(frame, bev_canvas, frame_index, fit_count, pipeline_ms,
+                   funnel_report=None, result_generation_fps=None):
+    output = np.zeros((1080, 1920, 3), dtype=np.uint8)
+    bev_width = 640
+    output[:, :bev_width] = cv2.resize(
+        bev_canvas, (bev_width, 1080), interpolation=cv2.INTER_AREA
+    )
+    camera_width = 1920 - bev_width
+    scaled_height = int(round(frame.shape[0] * camera_width / frame.shape[1]))
+    camera_view = cv2.resize(frame, (camera_width, scaled_height),
+                             interpolation=cv2.INTER_AREA)
+    top = (1080 - scaled_height) // 2
+    output[top:top + scaled_height, bev_width:] = camera_view
+    cv2.line(output, (bev_width, 0), (bev_width, 1079), (255, 255, 255), 2)
+    if result_generation_fps is None:
+        result_generation_fps = 1000.0 / max(float(pipeline_ms), 1e-9)
+    runtime_label = (
+        f"frame={frame_index} | cubic lanes={fit_count} | "
+        f"BEV-result={result_generation_fps:.1f} FPS "
+        "(sequential, no render)"
+    )
+    cv2.putText(
+        output, runtime_label,
+        (bev_width + 24, 42), cv2.FONT_HERSHEY_SIMPLEX, 0.78,
+        (0, 0, 0), 5, cv2.LINE_AA,
+    )
+    cv2.putText(
+        output, runtime_label,
+        (bev_width + 24, 42), cv2.FONT_HERSHEY_SIMPLEX, 0.78,
+        (255, 255, 255), 2, cv2.LINE_AA,
+    )
+    cv2.putText(
+        output, "CAMERA: raw decode (not back-projected)",
+        (bev_width + 24, 72), cv2.FONT_HERSHEY_SIMPLEX, 0.55,
+        (0, 0, 0), 4, cv2.LINE_AA,
+    )
+    cv2.putText(
+        output, "CAMERA: raw decode (not back-projected)",
+        (bev_width + 24, 72), cv2.FONT_HERSHEY_SIMPLEX, 0.55,
+        (255, 255, 255), 1, cv2.LINE_AA,
+    )
+    return output
+
+
+def main():
+    args = parse_args()
+    if args.max_frames is not None and args.max_frames <= 0:
+        raise ValueError("--max-frames must be positive")
+    if args.start_frame < 0:
+        raise ValueError("--start-frame must be non-negative")
+    if args.max_cubic_rmse <= 0:
+        raise ValueError("--max-cubic-rmse must be positive")
+    if not args.x_min < args.x_max or not args.y_min < args.y_max:
+        raise ValueError("invalid BEV range")
+    if args.funnel_margin < 0:
+        raise ValueError("--funnel-margin must be non-negative")
+
+    model_path = Path(args.model).expanduser().resolve()
+    video_path = Path(args.video).expanduser().resolve()
+    output_path = Path(args.output).expanduser().resolve()
+    polynomial_path = (
+        Path(args.polynomials).expanduser().resolve()
+        if args.polynomials else output_path.with_suffix(".lanes.jsonl")
+    )
+    summary_path = (
+        Path(args.summary).expanduser().resolve()
+        if args.summary else output_path.with_suffix(".json")
+    )
+    for path in (model_path, video_path):
+        if not path.is_file():
+            raise FileNotFoundError(path)
+    for path in (output_path, polynomial_path, summary_path):
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+    calibration = CameraCalibration()
+    bev_range = BevRange(args.x_min, args.x_max, args.y_min, args.y_max)
+    cv2.setNumThreads(1)
+    configure_decode_threads(args.decode_cpu_threads)
+    session = create_session(
+        model_path, args.provider, args.allow_tf32, args.trt_cache_dir
+    )
+    warmup_decode_backend(args.decode_crawl_backend)
+    warmup = np.zeros((1, 3, MODEL_HEIGHT, MODEL_WIDTH), dtype=np.float32)
+    for _ in range(5):
+        session.run(list(OUTPUT_NAMES), {"images": warmup})
+
+    capture = cv2.VideoCapture(str(video_path))
+    if not capture.isOpened():
+        raise RuntimeError(f"cannot open video: {video_path}")
+    width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = float(capture.get(cv2.CAP_PROP_FPS) or 20.0)
+    source_frames = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
+    if (width, height) != (calibration.width, calibration.height):
+        capture.release()
+        raise ValueError(
+            f"calibration is {calibration.width}x{calibration.height}, "
+            f"video is {width}x{height}; crop/resize must be calibrated"
+        )
+    if args.start_frame >= source_frames:
+        capture.release()
+        raise ValueError(
+            f"--start-frame {args.start_frame} is outside {source_frames} frames"
+        )
+    if args.start_frame:
+        capture.set(cv2.CAP_PROP_POS_FRAMES, args.start_frame)
+    available_frames = source_frames - args.start_frame
+    target_frames = min(available_frames, args.max_frames or available_frames)
+
+    overall_started = time.perf_counter()
+    try:
+        results, timings, generation_seconds = generate_bev_results(
+            capture, target_frames, args.start_frame, session, args,
+            calibration, bev_range,
+        )
+    finally:
+        capture.release()
+    processed_frames = len(results)
+    result_generation_fps = processed_frames / generation_seconds
+
+    fit_counts = Counter()
+    funnel_clipped_lanes = Counter()
+    funnel_rejected_lanes = Counter()
+    lane_counts = []
+    for bundle in results:
+        valid_records = bundle["valid_records"]
+        funnel_report = bundle["funnel_report"]
+        for record in valid_records:
+            fit_counts[record["lane_id"]] += 1
+        funnel_clipped_lanes.update(
+            funnel_report["clipped_lanes"]
+        )
+        funnel_rejected_lanes.update(
+            funnel_report["rejected_lanes"]
+        )
+        lane_counts.append(len(bundle["lanes"]))
+
+    temporary_polynomials = polynomial_path.with_suffix(
+        polynomial_path.suffix + ".tmp"
+    )
+    with temporary_polynomials.open("w") as polynomial_file:
+        for bundle in results:
+            polynomial_file.write(json.dumps({
+                "frame_index": bundle["frame_index"],
+                "timestamp_seconds": bundle["frame_index"] / fps,
+                "coordinate_system": {"X": "forward_m", "Y": "left_m"},
+                "funnel_guard": bundle["funnel_report"],
+                "lanes": [
+                    result["record"] for result in bundle["lane_results"]
+                ],
+            }) + "\n")
+    os.replace(temporary_polynomials, polynomial_path)
+
+    # Rendering is a separate, untimed pass. Reopen the source video so none
+    # of these operations can affect the reported BEV-result throughput.
+    temporary_output = output_path.with_name(
+        output_path.stem + ".tmp" + output_path.suffix
+    )
+    render_capture = cv2.VideoCapture(str(video_path))
+    if not render_capture.isOpened():
+        raise RuntimeError(f"cannot reopen video for rendering: {video_path}")
+    if args.start_frame:
+        render_capture.set(cv2.CAP_PROP_POS_FRAMES, args.start_frame)
+    writer = cv2.VideoWriter(
+        str(temporary_output), cv2.VideoWriter_fourcc(*"mp4v"), fps,
+        (1920, 1080),
+    )
+    if not writer.isOpened():
+        render_capture.release()
+        raise RuntimeError(f"cannot open writer: {temporary_output}")
+    render_started = time.perf_counter()
+    try:
+        for position, bundle in enumerate(results, 1):
+            ok, frame = render_capture.read()
+            if not ok:
+                raise RuntimeError(
+                    f"render pass stopped before frame {bundle['frame_index']}"
+                )
+            bev_canvas = draw_bev(
+                bundle["lane_results"], bev_range, calibration,
+                bundle["funnel_report"],
+            )
+            draw_predictions(frame, bundle["lanes"])
+            composite = make_composite(
+                frame, bev_canvas, bundle["frame_index"],
+                len(bundle["valid_records"]), bundle["compute_ms"],
+                bundle["funnel_report"],
+                result_generation_fps=result_generation_fps,
+            )
+            writer.write(composite)
+            if position % 100 == 0 or position == processed_frames:
+                print(
+                    f"render {position}/{processed_frames} "
+                    "(excluded from BEV-result FPS)",
+                    flush=True,
+                )
+    finally:
+        render_capture.release()
+        writer.release()
+    render_seconds = time.perf_counter() - render_started
+    os.replace(temporary_output, output_path)
+
+    summary = {
+        "model": str(model_path),
+        "video": str(video_path),
+        "output_video": str(output_path),
+        "output_polynomials": str(polynomial_path),
+        "processed_frames": processed_frames,
+        "start_frame": args.start_frame,
+        "source_frames": source_frames,
+        "fps": fps,
+        "provider": args.provider,
+        "execution": {
+            "mode": "sequential_per_frame",
+            "result_generation_scope": (
+                "video read + normalize + inference + decode + metric "
+                "projection + cubic fit + camera-funnel clipping"
+            ),
+            "excluded_from_result_fps": [
+                "draw_bev",
+                "draw_predictions",
+                "make_composite",
+                "video_encode_write",
+                "json_serialize_write",
+            ],
+            "result_generation_wall_seconds": generation_seconds,
+            "result_generation_fps": result_generation_fps,
+            "render_wall_seconds": render_seconds,
+        },
+        "coordinate_system": {
+            "X": "forward from ego, metres",
+            "Y": "left of ego, metres",
+            "Z": "not exported; local road plane is Z=0",
+        },
+        "camera": {
+            "resolution": [calibration.width, calibration.height],
+            "horizontal_fov_deg": calibration.horizontal_fov_deg,
+            "intrinsic": calibration.intrinsic.tolist(),
+            "camera_to_vehicle": calibration.camera_to_vehicle_matrix.tolist(),
+            "distortion": None,
+        },
+        "bev_range_m": {
+            "X": [bev_range.x_min, bev_range.x_max],
+            "Y": [bev_range.y_min, bev_range.y_max],
+        },
+        "polynomial": {
+            "formula": "Y(X)=c0+c1*X+c2*X^2+c3*X^3",
+            "coefficient_order": ["c0", "c1", "c2", "c3"],
+            "max_accepted_rmse_m": args.max_cubic_rmse,
+            "fit_counts_by_lane": dict(sorted(fit_counts.items())),
+        },
+        "bev_projection": {
+            "mode": "raw_model_projection",
+            "parallel_assumption": False,
+            "synthetic_lanes": False,
+            "funnel_margin_m": args.funnel_margin,
+            "funnel_clipped_lane_fits": int(
+                sum(funnel_clipped_lanes.values())
+            ),
+            "funnel_clipped_by_lane": dict(
+                sorted(funnel_clipped_lanes.items())
+            ),
+            "funnel_rejected_lane_fits": int(
+                sum(funnel_rejected_lanes.values())
+            ),
+            "funnel_rejected_by_lane": dict(
+                sorted(funnel_rejected_lanes.items())
+            ),
+        },
+        "lane_count": {
+            "mean": float(np.mean(lane_counts)),
+            "min": int(min(lane_counts)),
+            "max": int(max(lane_counts)),
+        },
+        "timings": {
+            name: timing_summary(values) for name, values in timings.items()
+        },
+        "wall_time_seconds": time.perf_counter() - overall_started,
+    }
+    temporary_summary = summary_path.with_suffix(summary_path.suffix + ".tmp")
+    with temporary_summary.open("w") as handle:
+        json.dump(summary, handle, indent=2)
+        handle.write("\n")
+    os.replace(temporary_summary, summary_path)
+    print(f"video OK: {output_path}")
+    print(f"polynomials OK: {polynomial_path}")
+    print(f"summary: {summary_path}")
+    print(
+        f"BEV-result throughput: {result_generation_fps:.2f} FPS "
+        f"({generation_seconds:.3f}s, render excluded)"
+    )
+
+
+if __name__ == "__main__":
+    main()

test_video_onnx.py

@@ -1,8 +1,8 @@
 """Run an RCLane ONNX model on a video and render predicted lanes + timing.
 
-The input video may already contain ground-truth annotations. Predictions are
-drawn as solid cyan polylines with a black outline so they remain distinguishable
-from colored GT points.
+The input video may already contain ground-truth annotations. Ego-lane boundaries
+are highlighted in green/orange, other predictions in cyan, all with a black
+outline so they remain distinguishable from colored GT points.
 """
 
 import argparse
@@ -16,8 +16,13 @@ import cv2
 import numpy as np
 import onnxruntime as ort
 
-from dataset import normalize_image
-from decode import decode
+from dataset import normalize_image_numpy
+from decode import (
+    configure_decode_threads,
+    decode,
+    ego_lane_boundaries,
+    warmup_decode_backend,
+)
 
 
 MODEL_HEIGHT = 320
@@ -32,77 +37,183 @@ OUTPUT_NAMES = (
 
 
 def softmax_foreground(logits):
-    shifted = logits - np.max(logits, axis=1, keepdims=True)
-    exp_logits = np.exp(shifted)
-    return exp_logits[:, 1] / np.sum(exp_logits, axis=1)
+    # Binary softmax: exp(l1)/(exp(l0)+exp(l1)) = sigmoid(l1-l0).
+    # This halves exponent work and avoids allocating a two-channel temporary.
+    difference = logits[:, 0] - logits[:, 1]
+    with np.errstate(over="ignore"):
+        return 1.0 / (1.0 + np.exp(difference))
 
 
-def create_session(model_path, provider, allow_tf32):
+def create_session(model_path, provider, allow_tf32, trt_cache_dir=None):
     available = ort.get_available_providers()
-    if provider == "cuda":
-        if "CUDAExecutionProvider" not in available:
+    cuda_options = {
+        "device_id": "0",
+        "use_tf32": "1" if allow_tf32 else "0",
+        "cudnn_conv_algo_search": "HEURISTIC",
+        "cudnn_conv_use_max_workspace": "1",
+        "do_copy_in_default_stream": "1",
+    }
+    if provider == "tensorrt":
+        if "TensorrtExecutionProvider" not in available:
             raise RuntimeError(
-                "CUDAExecutionProvider is unavailable; install the CUDA 13 "
-                "onnxruntime-gpu build from requirements.txt"
+                "TensorrtExecutionProvider is unavailable in ONNX Runtime"
             )
+        try:
+            import tensorrt  # noqa: F401 - preloads libnvinfer for ORT
+        except ImportError as exc:
+            raise RuntimeError(
+                "TensorRT provider requested but tensorrt-cu13 is not installed"
+            ) from exc
+        cache_dir = Path(
+            trt_cache_dir or Path(model_path).resolve().parent / "trt_cache"
+        )
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        shape = f"images:1x3x{MODEL_HEIGHT}x{MODEL_WIDTH}"
         providers = [
             (
-                "CUDAExecutionProvider",
+                "TensorrtExecutionProvider",
                 {
                     "device_id": "0",
-                    "use_tf32": "1" if allow_tf32 else "0",
-                    "cudnn_conv_algo_search": "HEURISTIC",
-                    "cudnn_conv_use_max_workspace": "1",
-                    "do_copy_in_default_stream": "1",
+                    "trt_fp16_enable": "True",
+                    "trt_engine_cache_enable": "True",
+                    "trt_engine_cache_path": str(cache_dir),
+                    "trt_timing_cache_enable": "True",
+                    "trt_timing_cache_path": str(cache_dir),
+                    "trt_force_timing_cache": "True",
+                    "trt_builder_optimization_level": "3",
+                    "trt_max_workspace_size": str(2 * 1024 ** 3),
+                    "trt_min_subgraph_size": "1",
+                    "trt_profile_min_shapes": shape,
+                    "trt_profile_opt_shapes": shape,
+                    "trt_profile_max_shapes": shape,
                 },
             ),
+            ("CUDAExecutionProvider", cuda_options),
+            "CPUExecutionProvider",
+        ]
+    elif provider == "cuda":
+        if "CUDAExecutionProvider" not in available:
+            raise RuntimeError(
+                "CUDAExecutionProvider is unavailable; install the CUDA 13 "
+                "onnxruntime-gpu build from requirements.txt"
+            )
+        providers = [
+            ("CUDAExecutionProvider", cuda_options),
             "CPUExecutionProvider",
         ]
     else:
         providers = ["CPUExecutionProvider"]
 
     session = ort.InferenceSession(str(model_path), providers=providers)
-    if provider == "cuda" and session.get_providers()[0] != "CUDAExecutionProvider":
+    expected_provider = {
+        "cuda": "CUDAExecutionProvider",
+        "tensorrt": "TensorrtExecutionProvider",
+    }.get(provider)
+    if expected_provider and session.get_providers()[0] != expected_provider:
         raise RuntimeError(
-            f"CUDA provider was requested but session uses {session.get_providers()}"
+            f"{expected_provider} was requested but session uses "
+            f"{session.get_providers()}"
         )
     return session
 
 
+def _lane_points_in_frame(lane, width, height):
+    points = lane.xy().copy()
+    if len(points) < 2:
+        return np.empty((0, 2), dtype=np.float32)
+    points[:, 0] *= width / MODEL_WIDTH
+    points[:, 1] *= height / MODEL_HEIGHT
+    points[:, 0] = np.clip(points[:, 0], 0, width - 1)
+    points[:, 1] = np.clip(points[:, 1], 0, height - 1)
+    return points
+
+
+def _x_at_rows(points, rows):
+    order = np.argsort(points[:, 1])
+    ys = points[order, 1]
+    xs = points[order, 0]
+    unique_y, inverse = np.unique(ys, return_inverse=True)
+    x_sum = np.zeros(len(unique_y), dtype=np.float64)
+    count = np.zeros(len(unique_y), dtype=np.float64)
+    np.add.at(x_sum, inverse, xs)
+    np.add.at(count, inverse, 1)
+    return np.interp(rows, unique_y, x_sum / count)
+
+
+def draw_ego_corridor(frame, ego_left, ego_right):
+    """Shade the visible region bounded by the two current-lane boundaries."""
+    if ego_left is None or ego_right is None:
+        return
+    height, width = frame.shape[:2]
+    left = _lane_points_in_frame(ego_left, width, height)
+    right = _lane_points_in_frame(ego_right, width, height)
+    if len(left) < 2 or len(right) < 2:
+        return
+    y_start = max(float(left[:, 1].min()), float(right[:, 1].min()))
+    y_stop = min(float(left[:, 1].max()), float(right[:, 1].max()))
+    if y_stop - y_start < 8:
+        return
+    rows = np.linspace(y_start, y_stop, 64)
+    left_x = _x_at_rows(left, rows)
+    right_x = _x_at_rows(right, rows)
+    valid = right_x > left_x
+    if np.count_nonzero(valid) < 2:
+        return
+    rows = rows[valid]
+    left_edge = np.column_stack((left_x[valid], rows))
+    right_edge = np.column_stack((right_x[valid], rows))[::-1]
+    polygon = np.round(np.vstack((left_edge, right_edge))).astype(np.int32)
+    overlay = frame.copy()
+    cv2.fillPoly(overlay, [polygon], (40, 140, 40), cv2.LINE_AA)
+    cv2.addWeighted(overlay, 0.18, frame, 0.82, 0, frame)
+
+
 def draw_predictions(frame, lanes):
     height, width = frame.shape[:2]
-    sx = width / MODEL_WIDTH
-    sy = height / MODEL_HEIGHT
+    ego_left, ego_right = ego_lane_boundaries(lanes)
+    draw_ego_corridor(frame, ego_left, ego_right)
+
     for index, lane in enumerate(lanes):
-        points = lane.xy().copy()
+        points = _lane_points_in_frame(lane, width, height)
         if len(points) < 2:
             continue
-        points[:, 0] *= sx
-        points[:, 1] *= sy
-        points[:, 0] = np.clip(points[:, 0], 0, width - 1)
-        points[:, 1] = np.clip(points[:, 1], 0, height - 1)
         points = np.round(points).astype(np.int32)
-        cv2.polylines(frame, [points], False, (0, 0, 0), 10, cv2.LINE_AA)
-        cv2.polylines(frame, [points], False, (255, 255, 0), 5, cv2.LINE_AA)
+        role = getattr(lane, "lane_role", None)
+        if role == "ego_left":
+            color, role_text, thickness = (0, 255, 0), "EGO-L", 7
+        elif role == "ego_right":
+            color, role_text, thickness = (0, 165, 255), "EGO-R", 7
+        else:
+            color, role_text, thickness = (255, 255, 0), "", 5
+        cv2.polylines(
+            frame, [points], False, (0, 0, 0), thickness + 5, cv2.LINE_AA
+        )
+        cv2.polylines(frame, [points], False, color, thickness, cv2.LINE_AA)
 
         near = points[int(np.argmax(points[:, 1]))]
         lane_id = lane.lane_id if lane.lane_id is not None else index
-        label = f"P{lane_id} {lane.score:.2f}"
-        position = (int(near[0]) + 8, max(32, int(near[1]) - 8))
+        role_label = f" {role_text}" if role_text else ""
+        label = f"P{lane_id}{role_label} {lane.score:.2f}"
+        text_size = cv2.getTextSize(
+            label, cv2.FONT_HERSHEY_SIMPLEX, 0.65, 2
+        )[0]
+        label_x = min(max(8, int(near[0]) + 8), width - text_size[0] - 8)
+        position = (label_x, max(32, int(near[1]) - 8))
         cv2.putText(
             frame, label, position, cv2.FONT_HERSHEY_SIMPLEX,
             0.65, (0, 0, 0), 5, cv2.LINE_AA,
         )
         cv2.putText(
             frame, label, position, cv2.FONT_HERSHEY_SIMPLEX,
-            0.65, (255, 255, 0), 2, cv2.LINE_AA,
+            0.65, color, 2, cv2.LINE_AA,
         )
 
 
 def draw_runtime(frame, provider, lane_count, infer_ms, decode_ms, pipeline_ms,
-                 rolling_pipeline_ms, source_fps, input_has_gt):
+                 rolling_pipeline_ms, source_fps, input_has_gt, ego_left,
+                 ego_right):
     height, width = frame.shape[:2]
-    box_width, box_height = min(690, width - 20), 160
+    box_width, box_height = min(690, width - 20), 196
     left, top = width - box_width - 10, 10
     overlay = frame.copy()
     cv2.rectangle(
@@ -113,8 +224,11 @@ def draw_runtime(frame, provider, lane_count, infer_ms, decode_ms, pipeline_ms,
     model_fps = 1000.0 / max(infer_ms, 1e-9)
     pipeline_fps = 1000.0 / max(rolling_pipeline_ms, 1e-9)
     realtime = "YES" if pipeline_fps >= source_fps else "NO"
+    left_id = f"P{ego_left.lane_id}" if ego_left is not None else "missing"
+    right_id = f"P{ego_right.lane_id}" if ego_right is not None else "missing"
     lines = (
         f"RCLane e19 ONNX {provider.upper()} | lanes={lane_count}",
+        f"ego lane boundaries: {left_id} (L) | {right_id} (R)",
         f"infer {infer_ms:6.1f} ms ({model_fps:5.1f} FPS)",
         f"decode {decode_ms:6.1f} ms | pipeline {pipeline_ms:6.1f} ms",
         f"rolling pipeline {pipeline_fps:5.1f} FPS | realtime@{source_fps:g}: {realtime}",
@@ -126,9 +240,10 @@ def draw_runtime(frame, provider, lane_count, infer_ms, decode_ms, pipeline_ms,
             2, cv2.LINE_AA,
         )
 
+    prediction_legend = "EGO-L: green | EGO-R: orange | other: cyan"
     legend = (
-        "GT: colored dots | Prediction: cyan solid lines"
-        if input_has_gt else "Prediction: cyan solid lines"
+        f"GT: colored dots | {prediction_legend}"
+        if input_has_gt else prediction_legend
     )
     cv2.putText(
         frame, legend, (16, height - 20), cv2.FONT_HERSHEY_SIMPLEX,
@@ -158,7 +273,11 @@ def parse_args():
     parser.add_argument("--output", default="runs/video_test.mp4")
     parser.add_argument("--summary", default=None,
                         help="timing JSON; defaults next to output video")
-    parser.add_argument("--provider", choices=["cuda", "cpu"], default="cuda")
+    parser.add_argument(
+        "--provider", choices=["tensorrt", "cuda", "cpu"],
+        default="tensorrt",
+    )
+    parser.add_argument("--trt-cache-dir", default="exports/trt_cache")
     parser.add_argument("--allow-tf32", action="store_true",
                         help="faster CUDA math with slightly larger numerical drift")
     parser.add_argument("--input-has-gt", action="store_true",
@@ -177,6 +296,11 @@ def parse_args():
         "--max-ego-lanes", type=int, default=4,
         help="post-process to at most N reliable lanes nearest the ego vehicle",
     )
+    parser.add_argument(
+        "--decode-crawl-backend", choices=("auto", "numba", "numpy"),
+        default="auto",
+    )
+    parser.add_argument("--decode-cpu-threads", type=int, default=8)
     return parser.parse_args()
 
 
@@ -204,7 +328,12 @@ def main():
         output_path.stem + ".tmp" + output_path.suffix
     )
 
-    session = create_session(model_path, args.provider, args.allow_tf32)
+    cv2.setNumThreads(1)
+    configure_decode_threads(args.decode_cpu_threads)
+    session = create_session(
+        model_path, args.provider, args.allow_tf32, args.trt_cache_dir
+    )
+    warmup_decode_backend(args.decode_crawl_backend)
     warmup = np.zeros((1, 3, MODEL_HEIGHT, MODEL_WIDTH), dtype=np.float32)
     for _ in range(5):
         session.run(list(OUTPUT_NAMES), {"images": warmup})
@@ -228,6 +357,9 @@ def main():
 
     timings = {"preprocess": [], "inference": [], "decode": [], "pipeline": []}
     lane_counts = []
+    ego_left_frames = 0
+    ego_right_frames = 0
+    ego_pair_frames = 0
     rolling = deque(maxlen=30)
     started = time.perf_counter()
     frame_index = 0
@@ -239,8 +371,7 @@ def main():
             pipeline_start = time.perf_counter()
 
             stage = time.perf_counter()
-            images = normalize_image(frame, MODEL_WIDTH, MODEL_HEIGHT)
-            images = images.unsqueeze(0).numpy()
+            images = normalize_image_numpy(frame, MODEL_WIDTH, MODEL_HEIGHT)
             preprocess_ms = (time.perf_counter() - stage) * 1000
 
             stage = time.perf_counter()
@@ -266,6 +397,7 @@ def main():
                 nms_max_lanes=args.decode_nms_max_lanes,
                 nms_scale=args.decode_nms_scale,
                 max_output_lanes=args.max_ego_lanes,
+                crawl_backend=args.decode_crawl_backend,
             )
             decode_ms = (time.perf_counter() - stage) * 1000
             pipeline_ms = (time.perf_counter() - pipeline_start) * 1000
@@ -276,12 +408,16 @@ def main():
             timings["pipeline"].append(pipeline_ms)
             lane_counts.append(len(lanes))
             rolling.append(pipeline_ms)
+            ego_left, ego_right = ego_lane_boundaries(lanes)
+            ego_left_frames += int(ego_left is not None)
+            ego_right_frames += int(ego_right is not None)
+            ego_pair_frames += int(ego_left is not None and ego_right is not None)
 
             draw_predictions(frame, lanes)
             draw_runtime(
                 frame, args.provider, len(lanes), inference_ms, decode_ms,
                 pipeline_ms, float(np.median(rolling)), source_fps,
-                args.input_has_gt,
+                args.input_has_gt, ego_left, ego_right,
             )
             writer.write(frame)
             frame_index += 1
@@ -313,6 +449,12 @@ def main():
             "max_ego_lanes": args.max_ego_lanes,
             "min_score_ratio": 0.5,
             "balance_sides": True,
+            "lane_id_semantics": {
+                "P0": "next boundary left of ego lane",
+                "P1": "ego lane left boundary",
+                "P2": "ego lane right boundary",
+                "P3": "next boundary right of ego lane",
+            },
         },
         "resolution": [width, height],
         "source_fps": source_fps,
@@ -326,6 +468,12 @@ def main():
             "min": int(min(lane_counts)),
             "max": int(max(lane_counts)),
         },
+        "ego_lane_boundary_coverage": {
+            "left_frames": ego_left_frames,
+            "right_frames": ego_right_frames,
+            "pair_frames": ego_pair_frames,
+            "pair_rate": ego_pair_frames / frame_index,
+        },
     }
     temporary_summary = summary_path.with_suffix(summary_path.suffix + ".tmp")
     with temporary_summary.open("w") as handle: