Read the road.Between the lanes.

Movement becomes evidence.

We turn intersection footage into traffic events and accident-risk estimates. Built by AVA, one trajectory at a time.

Follow the evidence.

Pick a video. Click an event bar, the timeline, the risk curve or a table row to jump the video there. The playhead follows playback.

Loading results…

Test every choice.

Ablations on the four sample videos: the same rules on top of a different detector, input size or frame rate, scored with the official metric on our dev labels. Then where the remaining errors are.

Loading the analysis…

See the movement.
Understand the moment.

Part A · events

For every clip, list each traffic event as [start_sec, end_sec, label] from 14 classes (red-light running, jaywalking, U-turns, near misses, …). Scored by per-class F1 at temporal IoU 0.3, 0.5 and 0.7, averaged over classes (Score A).

Part B · accident risk

Output a risk score in [0, 1] for every frame that may only use frames up to that moment. It should rise in the 5 s before an accident. Scored by average precision, alarm F1 at threshold 0.5 and mean time-to-accident (Score B).

Our key idea

The camera is fixed, so geometry does most of the work. We track every road user with an off-the-shelf detector, map the tracks into one reference frame, and check traffic rules against a hand-drawn scene layout and the signal phase read from the lamps. Final score M = 0.7·A + 0.3·B.

Pipeline

  • Learned (pre-trained or fitted to our tracks)
  • Rule-based
  • Geometry
  • Input / output
Inside the pipeline Implementation, frame by frame +

Part A, step by step

  1. Decode only what we need

    The files are 4K H.264 High 4:2:2, 10-bit at ~147 Mb/s. NVDEC cannot decode 4:2:2 10-bit, so decoding is on the CPU and is the bottleneck. With PyAV we decode only the reference frames of the IBBP GOP (every 3rd frame, ≈10 fps) and convert straight to 1920×1080. Decoding runs in a background thread so it overlaps GPU work.

  2. Detect and track

    YOLO26-L (COCO weights, FP16, image size 1280, batch 8, confidence 0.10) detects people, bicycles, cars, motorcycles, buses, trucks and animals. ByteTrack (high/low thresholds 0.25/0.10, 3 s buffer for occlusion by buses and the sign gantry) links detections into tracks.

  3. Register to one reference frame

    Every 5 s the frame is registered to a reference frame with SIFT features and a RANSAC homography, against a bank of three lighting references (noon, evening sun, dusk). The camera is re-mounted between recordings (shifts up to ~60 px) and drifts ~10 px during the first half-minute of a clip. All geometry lives in the reference frame.

  4. Draw the scene once

    On the reference image we drew the approach and outbound carriageways, the median, the islands, three zebra crossings, the approach stop line, the solid lane dividers (as rays from the road's vanishing point) and the traffic-signal lamps. A flow field, the dominant motion direction in every 16-px cell, is learned from all sample tracks.

  5. Read the traffic signal

    The main-road phase comes from the three lamps of the vehicle signal head on the median tip, with per-lamp brightness normalisation and handling for flashing green and occlusion. A pedestrian head that runs in phase is the fallback. The plan is fixed-time: a 75 s cycle at noon (red 36 s, green 36 s, yellow 3 s), 80 s in the evening and dusk clips.

  6. Apply the event rules

    Each class is one rule on trajectories, the layout and the signal (see the class list below). road_obstacle, fire_smoke and the second branch of accident ("crashed car") use the open-vocabulary detector YOLOE-26L with baked-in text prompts once per second and require strict persistence.

  7. Post-process segments

    Overlapping segments of the same class are merged into one (the annotation convention), with small per-class gaps (0–6 s), then clipped to the clip duration. Segments shorter than 0.2 s are dropped.

Part B: the causal risk estimator

  1. Online perception

    The same detector at image size 960 on every 3rd frame, online ByteTrack and registration every 5 s. The score at time t uses only frames up to t.

  2. Conflict cues

    Each mapped to [0, 1]: crossing paths (time-to-collision from predicted footprint overlap), rear-end (fast closing in the same lane, lane identity from the vanishing-point angle), pedestrian conflict (a pedestrian on the carriageway about to be reached by a moving vehicle) and hard braking.

  3. Combine and smooth

    The cues are combined as independent evidence and smoothed with a fast-attack / slow-release filter, so the score rises quickly and decays slowly.

  4. Learned anticipation

    20 scale-free kinematic features per frame (the cues, time to contact under constant velocity and constant acceleration, pedestrians and two-wheelers near moving cars, proximity, closing speed, braking, swerving, speed, counts) feed five small networks (with their last 1–3 s of history) and five causal temporal convolutions (the last ~6 s). Their averaged probability of a crash within 5 s is the output. Trained on 200 real CCTV crashes we timed plus ordinary traffic; on held-out clips Score B is 0.47 (0.12 with the cues alone), with alarms ~2.8 s before contact.

  5. Calibrate

    A monotone mapping sends the lowest probability that raises no false alarm on held-out sample videos to 0.5, the official alarm threshold; once an alarm starts, a new one cannot start for 10 s. On the 18.4 min of sample traffic the output raises no alarm. The hand-made cue score, with its immediate alarm when two vehicles are about to touch, is the fallback when no model file is present.

Learned vs rule-based

Learned

  • Object detector: YOLO26-L, COCO pre-trained, not fine-tuned
  • Hazard detector: YOLOE-26L, open vocabulary (text prompts)
  • Flow field: motion statistics of our own sample tracks
  • Lane positions: peaks of the lane-angle histogram of our tracks

Rule-based

  • Tracking (ByteTrack), registration (SIFT + RANSAC)
  • Scene layout (drawn by hand once)
  • Signal-phase reader
  • All 12 event detectors and post-processing
  • Risk cues, smoothing and calibration

Models & data

ComponentRoleLicence
Ultralytics YOLO26-LDetector, Parts A and B (COCO weights)AGPL-3.0
Ultralytics YOLO26-SDetector of the CPU live demoAGPL-3.0
Ultralytics YOLOE-26LOpen-vocabulary road_obstacle / fire_smoke / crashed carAGPL-3.0
MobileCLIP text encoderOffline only, to bake the YOLOE text prompts; not run at inferencesee model card
ByteTrack, OpenCV SIFTTracking, registrationMIT / Apache-2.0
COCOOnly training data, through the pre-trained weightsCC BY 4.0 (annotations)
TAD benchmark (Xu et al., IEEE Access 2025)Trains and validates the Part B network (200 crashes with our own timings + 127 normal clips); validates the accident rule and sets two of its timing constantsresearch use, citation requested
SO-TAD, ACCIDENTTried as extra Part B training data; lowered the score, not usedno licence stated / CC BY-NC-SA 4.0

The detectors are used as released, with no fine-tuning; the one model we trained is the Part B layer, on TAD. The four sample clips were used to draw the layout, learn the flow field and lane positions, tune rule thresholds and set the Part B alarm point.

The 14 event classes

Colour = the class colour used by every chart on this page.

The street is our starting point.

Every design decision in the pipeline started as an observation here. Each card states what we saw and what we did about it.

Loading the analysis…

Your footage. Our pipeline.

Upload a short recording. Explore the detected events, follow the tracks and inspect the risk curve — all in one place.

Loading the demo…

An honest look at the results.

Loading the report…

Meet AVA.

Loading the team…