Skip to content
All projects

Project · 02

Autonomous Vision & Robot Control

Computer Vision / Robotics

Computer vision + robot project. It looks at road video, finds the lane lines, figures out which way the road is turning, and shows it all in the app you use to drive the robot.

Year
2024
Stack
Python · OpenCV · NumPy · Tkinter · HTTP requests

Overview

This one went through two versions. The first runs on recorded road video — it picks out the lane lines, finds the middle of the lane, guesses if the road is turning left, right, or going straight, and draws all of that back on the video.

The second version does it on a live camera feed from the robot and adds a control panel (Tkinter) that sends movement commands to the robot over HTTP.

  • Recorded and live video processing
  • Yellow lane color filtering
  • Bird's-eye perspective transform
  • Grayscale + Canny edge detection
  • Probabilistic Hough line detection
  • Slope- and position-based lane filtering
  • Lane-center estimation
  • Turn prediction (left / right / straight)
  • Lane overlay projected back onto the frame
  • Tkinter control panel with live video
  • Movement commands sent to the robot over HTTP
  • Account login and per-user command log

Focus

  • Classical computer vision
  • Perspective transforms
  • Edge detection
  • Hough line detection
  • Network-based control

Architecture

First I crop each frame, pick out the yellow lane lines by color, and warp it so it's like looking down at the road from above. Then it goes grayscale, Canny finds the edges, and a Hough transform turns those edges into line segments.

Next I toss out lines that aren't close to vertical and split the rest into left and right lanes based on where they are. Averaging each side gives me the lane lines plus a center line, and where that center line sits decides the turn call. Last step, the overlay gets warped back to the normal view and shown in the app.

The live robot version runs a simpler take on this on the camera feed: grayscale, blur, Canny, Hough, and a slope filter.

Source

  • Video / Camera Feed
  1. 01Image Preprocessing
  2. 02Perspective Transformation
  3. 03Edge Detection
  4. 04Hough Line Detection
  5. 05Lane Filtering
  6. 06Lane Geometry
  7. 07Steering / Turn Decision
  8. 08Robot Control Interface
Processing pipeline: Video / Camera Feed → Image Preprocessing → Perspective Transformation → Edge Detection → Hough Line Detection → Lane Filtering → Lane Geometry → Steering / Turn Decision → Robot Control Interface

Stack

  • Python
  • OpenCV
  • NumPy
  • Tkinter
  • HTTP requests

Contact

Get in touch.

I'm looking for software engineering internships. Email's the fastest way to reach me.