Lane Detection for Driver Assistance using OpenCV

Lane keeping is one of the core functions of modern driver-assistance systems: before a car can warn about drifting or steer itself, it must reliably find the lane markings in the camera frame. That turns out to be a genuinely instructive computer-vision problem — perspective makes parallel lines converge, shadows and wet asphalt create false edges, and dashed markings appear and disappear between frames. This project implements the classic, explainable solution: a multi-stage OpenCV pipeline that converts each frame to grayscale, extracts vertical edge gradients with a Sobel-X operator, restricts processing to a road-region trapezoid, and fits one line per side through the surviving lane pixels with least squares. The lateral offset of the vehicle from the lane centre is computed from the two fitted lines, and a departure warning fires when the offset exceeds a configurable threshold. The project is honest about its approach: it uses deterministic classical vision rather than a learned model, which makes every intermediate stage inspectable — ideal for a viva where each step can be questioned and defended.

This is a built-to-order software project: the Python OpenCV pipeline, the interactive web demo, sample dashcam frames and the complete viva kit (report, PPT, Q&A) are prepared fresh for you.

Dataset & Model Details

• Dataset: TuSimple Lane Detection Benchmark (tuSimple / CVPR 2017 workshop data). Real highway driving clips with annotated lane polylines: 3,626 training and 2,782 test clips at 1280x720, the standard public benchmark for lane-line detection.
• Task: Detect the ego-lane's left and right boundary lines in each frame and estimate lateral vehicle offset.
• Model (classical, non-learned): Grayscale conversion → Gaussian blur → Sobel-X gradient magnitude → brightness/gradient thresholding → trapezoidal region-of-interest mask → weighted least-squares line fit (x = m·y + b) per lane side, with slope-sign and steepness sanity checks. No neural network is involved; every stage is inspectable.
• Metrics: Evaluated with the TuSimple official protocol — per-point accuracy, false-positive rate and false-negative rate. Reported as design targets (typically ≥90% point accuracy on clear daytime highway clips) — actual measured values depend on the student's own evaluation run and are reported honestly from it, never pre-filled.
• Demo data: The web demo ships with three sample dashcam frames (day highway, night rain, rural curve) plus upload-your-own support, so the pipeline can be exercised and its failure modes (heavy rain, sharp curves) demonstrated live.

1. The input frame is downscaled and converted to grayscale, removing colour information that lane detection does not need.
2. A Sobel-X operator computes horizontal brightness gradients, highlighting the vertical-ish edges that lane paint produces.
3. Pixels must pass both the gradient threshold and a brightness floor, then survive the trapezoidal road-region mask that excludes sky, dashboard and roadside clutter.
4. Surviving pixels are split into left and right halves; each side gets a gradient-weighted least-squares line fit (x = m·y + b).
5. Fits are sanity-checked: minimum pixel support, plausible steepness and the correct slope sign for their side (up-to-the-right for left, up-to-the-left for right).
6. The two lines are drawn over the frame, the drivable lane region is shaded, and the lateral offset is computed from the lane centre at the bottom of the region of interest.
7. If the absolute offset exceeds the warning threshold (default 25% of lane width), a lane-departure warning is raised.

Tech stack:

• Python 3.10+ with OpenCV (cv2) for the reference pipeline
• NumPy for the gradient and least-squares computation
• JavaScript (ES6) + HTML5 Canvas for the interactive web demo
• TuSimple Lane Detection Benchmark for evaluation
• Matplotlib for evaluation plots and the report figures

• [Multi-stage lane pipeline] Grayscale, Sobel-X edges, road-region mask and least-squares line fitting run as a real, inspectable pipeline — each stage can be viewed separately in the demo.
• [Left/right lane tracking] One weighted line fit per lane side with slope-sign and steepness validation, so spurious edges are rejected rather than drawn.
• [Lateral offset estimation] The vehicle position relative to the lane centre is computed from the two fitted lines and shown as a percentage of lane width, left or right.
• [Lane-departure warning] A configurable offset threshold triggers a visual warning when the vehicle drifts — the core driver-assistance behaviour.
• [Three built-in test frames] Day highway, night rain and rural curve dashcam photos let the pipeline be compared across easy, hard and curved conditions.
• [Live threshold tuning] Edge-strength and brightness sliders re-run the pipeline instantly, showing exactly how each parameter changes detection.
• [Upload your own frame] Any dashcam photo can be dropped in to test the pipeline on new roads.

• Complete Python source code (OpenCV lane-detection pipeline with all stages)
• Interactive web demo (3 sample dashcam frames, stage inspector, live threshold sliders, upload-your-own)
• Evaluation script for the TuSimple benchmark with the official accuracy/FP/FN protocol
• Setup guide (installing OpenCV, downloading TuSimple, running the evaluation)
• Project report PDF (background, pipeline design, stage-by-stage explanation, evaluation results, limitations)
• PPT presentation for final review
• Viva Q&A preparation document (Sobel operators, ROI design, least-squares fitting, lane-departure logic)