In this guide
Best 10 Computer Vision Projects for Final Year
Computer vision remains one of the most satisfying domains to build a capstone project in. The feedback loop is immediate — you point a camera at something, your code draws boxes, tracks motion, or estimates a pose, and everyone watching the demo instantly understands what happened. No other AI subfield makes its output this visible. That visibility is exactly why vision projects do well at demo day: a working prototype with a live camera feed is more convincing than any slide deck.
How this list was chosen: every project below is a real, published listing on projectech.in in the AI & Machine Learning branch — actual buildable projects with defined scope, not generic ideas pulled from thin air. They were selected to cover the skills that matter in applied vision work: classical OpenCV pipelines, deep-learning detection and recognition, face analysis, pose estimation, and vision on constrained hardware. Some entries also touch neighbouring ML techniques (clustering, segmentation-style analysis) because real projects often blend vision with adjacent methods, and those blends are noted honestly where they appear.
This guide is for engineering students choosing a capstone or major project who want something they can demo with a webcam, a phone camera, or an ESP32-CAM — and who want to learn techniques that transfer directly into jobs in AI, robotics, and embedded systems.
1. Abandoned Luggage Detection Using OpenCV
Unattended bags in railway stations, airports, and bus terminals are a genuine security gap. Human operators watching banks of CCTV monitors suffer from attention fatigue, and an abandoned suitcase can sit unnoticed for a long time. This project builds the classic automated answer: a vision system that watches a fixed camera feed and raises an alert when an object appears, stays still, and its owner never returns.
The implementation is a textbook OpenCV pipeline that teaches you fundamentals no deep-learning course covers as well. A background-subtraction model (typically MOG2) separates moving foreground from the static scene; morphological operations clean up the mask; contour detection finds candidate objects; and a persistence tracker keeps the identity of each blob across frames. When a blob stops moving and remains stationary beyond a configurable time threshold — while no nearby person reclaims it — the system draws an alert box and logs the timestamp. Students commonly extend the baseline with a YOLOv8 detector that classifies the blob as a bag or suitcase, which cuts false alarms from people simply standing still.
Why students pick it: it runs entirely on a CPU, needs no GPU and no training data of your own, and the demo is effortless — point a webcam at a corner of your room, leave a bag, and watch the alert fire. It teaches background modelling, tracking, and threshold logic, which are the building blocks of every real surveillance system.
2. Automatic Number Plate Recognition OpenCV
Toll booths, gated communities, and parking lots all need to log vehicles quickly and without human error. Manual entry is slow and mistake-prone, while commercial ANPR systems are expensive and closed. This project builds a working number-plate reader that takes a camera image of a vehicle and outputs the registration number as text.
The pipeline has three stages. First, plate localization: the image is converted to grayscale, blurred, and edge-detected (Canny), then contours are filtered by aspect ratio and rectangularity to find the plate region — a genuinely instructive exercise in classical CV geometry. Second, character segmentation splits the plate into individual glyphs using projection profiles or connected components. Third, OCR reads the characters, usually with Tesseract or a small trained CNN classifier. Indian plates add real-world difficulty: varied fonts, non-standard layouts, dirt, and angled photos, so students learn preprocessing tricks like perspective correction, contrast normalization, and denoising.
Why students pick it: ANPR is a recognisable, real-world application with clear stages you can demo step by step — show the detected plate box, the segmented characters, and the final text. It also teaches a valuable lesson: classical techniques plus a modest classifier often beat a giant end-to-end model for a tightly scoped task.
3. Customer Segmentation with K-Means (Mall Dataset)
Retailers and malls collect basic customer data — age, annual income, spending score — but raw tables do not tell them who their customers actually are. Segmentation turns that flat data into actionable groups: high-income low-spenders, young frequent buyers, and so on, so marketing can target each group differently. This project applies K-means clustering to the well-known mall customer dataset to discover those segments automatically.
The work is pure applied machine learning rather than image processing, and it sits on this list because several "computer vision" project catalogues group it with vision-adjacent analytics. The build covers the full unsupervised workflow: exploratory analysis with pandas and matplotlib, feature scaling with StandardScaler, choosing K with the elbow method and silhouette scores, fitting K-means with scikit-learn, and visualising the clusters in 2D and 3D. The interesting engineering judgement is in interpreting the clusters — assigning business meaning to each group and sanity-checking that the segments are stable across random initialisations.
Why students pick it: it is a compact, self-contained project with a clean dataset, zero hardware, and a visual output (cluster plots) that looks great in a report. It teaches unsupervised learning properly — evaluation without labels is a skill most courses skip — and it pairs well as a second project alongside a vision build.
4. Customer Segmentation Using K-Means
This is the sibling listing to the mall-dataset variant, and it deserves its own entry because it generalises the technique beyond one dataset. Instead of being tied to mall customers, the project frames K-means segmentation as a reusable pipeline: take any customer or user dataset, clean and scale it, discover natural groups, and profile each group. The emphasis shifts from "analyse this dataset" to "build a segmentation tool."
The technical content covers the same core — elbow method, silhouette analysis, scikit-learn's KMeans — but adds the engineering around it: a data-ingestion step that accepts CSV uploads, preprocessing that handles missing values and categorical features, and a simple dashboard or notebook output that presents each segment with its defining characteristics. Students often extend it with alternative algorithms (DBSCAN for oddly shaped clusters, hierarchical clustering for dendrogram views) and compare results, which makes for strong report material.
Why students pick it: it is one of the most scope-controllable projects on this list. The minimum viable version runs in an afternoon, and every extension — a new algorithm, a Streamlit dashboard, a different domain dataset — is a clean, demoable increment. For students who want a low-risk, high-polish project, this is a strong choice.
5. Driver Drowsiness Detection (Eye Tracking)
Driver fatigue causes a significant share of road accidents, and the dangerous part is that drowsy drivers rarely realise they are drifting off. A dashboard camera that watches the driver's eyes and sounds an alert before a microsleep becomes a crash is a life-saving application of vision. This project builds exactly that: real-time drowsiness detection from a webcam feed.
The standard implementation uses dlib's 68-point facial landmark detector to locate the eyes in each frame, then computes the Eye Aspect Ratio (EAR) — a simple geometric measure of how open the eye is. When the EAR stays below a threshold for a set number of consecutive frames, the system flags drowsiness and triggers an audible alarm. Students learn the practical headaches of real-time CV: frame-rate budgeting on a CPU, handling glasses and poor lighting, tuning thresholds to avoid false alarms, and smoothing predictions over time so one bad frame does not set off the buzzer. A common upgrade swaps dlib for a MediaPipe face mesh, which is faster and more robust.
Why students pick it: it is a safety application with an emotional hook, it demos beautifully (the alarm genuinely goes off when you fake-sleep), and it teaches landmark-based analysis — a technique used in face tracking, emotion detection, and AR filters. The hardware is just a laptop webcam, so there is nothing to buy.
6. Face Age Estimation Using CNN
Age estimation from a face photo powers real features: age-gated content, retail analytics that profile footfall by age group, and accessibility interfaces that adapt to elderly users. Guessing age from pixels is hard — lighting, expression, and ethnicity all confound it — which makes it an excellent deep-learning project with a clear difficulty curve.
The build starts with a face detector (OpenCV DNN or MTCNN) to crop faces from input images, then feeds the crops into a CNN that predicts age. Students learn the two standard formulations: age as classification into brackets (child, teen, adult, senior) versus age as regression to a number, and why the choice changes the loss function, the metrics, and the demo. Training uses public datasets such as UTKFace or Adience with transfer learning from a pretrained backbone (VGG16 or MobileNet) in TensorFlow or PyTorch, because training from scratch on a student GPU budget is unrealistic. Data augmentation — flips, brightness shifts, slight rotations — is essential, and the report practically writes itself around the augmentation and architecture experiments.
Why students pick it: transfer learning on a real dataset is the single most employable skill in applied deep learning, and this project teaches it end to end. The demo — show a photo, get an age estimate — is instantly understandable, and the error cases (a bearded 25-year-old read as 40) make for honest, interesting report discussion.
7. Face Recognition Door Lock (ESP32-CAM)
Keys get lost and copied; PIN codes get shoulder-surfed. A face-recognition door lock replaces all of that with "the door knows you," and building one on an ESP32-CAM — a board that costs less than a pizza — makes the whole project a lesson in doing serious work on unserious hardware.
The architecture splits the problem across the edge and the network. The ESP32-CAM captures frames and streams them over Wi-Fi; a small server or even a second script runs face detection and recognition (typically face encodings compared against an enrolled database with the face_recognition library or a lightweight CNN embedding), and on a match it signals the ESP32 to drive a relay or servo that releases the lock. Students learn the full embedded-plus-AI stack: enrolling faces, handling the ESP32-CAM's limited resolution and frame rate, securing the Wi-Fi link, and designing a fail-safe so a power cut or false negative does not lock anyone out permanently.
Why students pick it: it is a physical thing that moves — a lock clicking open for your face never gets old as a demo. It combines embedded systems, networking, and AI in one build, which is exactly the blend IoT and robotics roles ask about. The bill of materials stays tiny, and every subsystem is independently testable.
8. Gaze Tracking Using Webcam and dlib
Where a person looks is valuable information: it drives hands-free computer control for accessibility, attention analytics for UX research, and driver-monitoring systems. Eye-tracking hardware costs thousands; this project does it with a plain webcam and the dlib library, which makes it a study in extracting maximum signal from minimum equipment.
The method builds on the same 68-point facial landmarks used in drowsiness detection. From the eye-region landmarks, the system isolates the iris — usually by thresholding and contour analysis within the eye bounding box — and computes the pupil's relative position. That position maps to gaze zones (left, right, centre, up, down) after a short per-user calibration step. Students confront the real constraints quickly: webcam resolution limits how fine the gaze grid can be, head movement breaks the mapping, and lighting changes the thresholding. The standard fixes — head-pose normalisation, adaptive thresholding, and smoothing with a moving average — are all genuinely instructive.
Why students pick it: it is a distinctive project that stands out from the crowd of face-detection builds, and the accessibility angle (computer control without hands) gives it a meaningful story. It also teaches calibration and normalisation, two ideas that appear everywhere in applied ML.
9. Grain Quality Grading Using Computer Vision
Grain mandis and procurement centres grade wheat, rice, and pulses by hand — an inspector pours out a sample and judges it by eye. The process is slow, subjective, and a source of disputes between farmers and buyers. A camera-based grading system that measures grain size, colour, and defects objectively would make the trade fairer, and this project is a working prototype of one.
The implementation is applied image analysis: grains are spread on a contrasting background and photographed; segmentation (thresholding plus watershed or connected components) separates individual grains; and each grain is measured — length, width, area, aspect ratio — while colour histograms and texture features flag discoloured, broken, or shrivelled grains. A classifier (SVM, random forest, or a small CNN) then assigns grades. Students learn the unglamorous but critical parts: controlled lighting and a fixed camera distance, because measurement in pixels is meaningless without a scale reference, and building a labelled dataset by photographing and hand-grading a few hundred grains.
Why students pick it: it is a rare vision project with a direct agriculture and rural-economy angle, which examiners and audiences find refreshing. It teaches classical measurement-based vision — a skill set distinct from deep learning that is highly valued in industrial inspection — and the demo with real grain samples is tactile and memorable.
10. Gym Exercise Form Checker (Pose Estimation)
Bad squat form injures knees and backs, but most gym-goers cannot afford a personal trainer watching every rep. A phone camera that watches your workout and flags a rounded back or shallow squat brings coaching to everyone. This project builds that coach using human pose estimation.
The core is a pose model — MediaPipe Pose or MoveNet — that returns 33 body landmarks per frame in real time, even on a phone or laptop CPU. The project logic sits on top: from the landmarks, compute joint angles (knee angle for squats, elbow angle for curls, back angle for deadlifts), track them across the rep cycle, and compare against target ranges. When a rep violates the range — knees caving in, back rounding — the system overlays a warning on the video and counts only clean reps. Students learn temporal analysis (rep segmentation from angle signals), per-exercise rule design, and the UX of real-time feedback that must be instant to be useful.
Why students pick it: fitness tech is relatable — everyone understands the demo — and pose estimation is a genuinely modern technique used in sports analytics, physiotherapy apps, and animation. The project runs on commodity hardware, needs no training data, and produces the kind of live overlay demo that holds a room's attention.
Comparison at a glance
| Project | Core tech | Best for | Build complexity |
|---|---|---|---|
| Abandoned Luggage Detection | OpenCV, MOG2, YOLOv8 | Surveillance and security interest | Medium |
| Number Plate Recognition | OpenCV, Canny, Tesseract/CNN | Step-by-step pipeline demos | Medium |
| Customer Segmentation (Mall) | scikit-learn, K-means | Low-risk, high-polish ML project | Low |
| Customer Segmentation (General) | scikit-learn, Streamlit | Scope-controlled ML with dashboard | Low |
| Driver Drowsiness Detection | dlib, EAR, MediaPipe | Real-time safety applications | Medium |
| Face Age Estimation | TensorFlow/PyTorch, transfer learning | Deep-learning fundamentals | Medium–High |
| Face Recognition Door Lock | ESP32-CAM, face encodings, relay control | Embedded + AI combination | Medium–High |
| Gaze Tracking | dlib, iris detection | Distinctive accessibility angle | Medium |
| Grain Quality Grading | OpenCV segmentation, SVM/CNN | Agriculture and inspection angle | Medium |
| Gym Form Checker | MediaPipe Pose, angle analysis | Relatable fitness-tech demo | Medium |
How to pick yours
- Match the hardware you already own. Webcam-only projects (drowsiness, gaze, ANPR, luggage) cost nothing extra. The ESP32-CAM lock needs the board, a relay, and a lock mechanism — cheap, but plan a week for hardware debugging.
- Be honest about your GPU situation. Face age estimation needs real training; without at least a free Colab GPU session, pick a classical pipeline or a pretrained-model project like the gym form checker.
- Decide how much data you want to collect. Grain grading needs you to photograph and label grains; age estimation uses public datasets; drowsiness and gaze need only your own face. Data collection is the most underestimated time sink in vision projects.
- Think about demo-day conditions. Live-camera demos are powerful but fragile — bad hall lighting breaks thresholding. Projects with a recorded-video fallback mode (luggage detection, ANPR) are safer bets.
- Play to your branch. Electronics students can lean into the ESP32-CAM lock; computer science students can go deeper on the CNN training and model optimisation; the segmentation projects suit anyone who wants a calm, low-risk build.
- Check what your guide expects. Some faculty want a trained model and a dataset; others want hardware. The list covers both — pick the entry whose deliverables match your department's evaluation pattern.
- Leave room for one extension. The strongest projects on this list are baselines with one clear upgrade: YOLOv8 on top of luggage detection, MediaPipe instead of dlib for drowsiness, a Streamlit dashboard for segmentation. One extension beats three half-done ones.
Frequently asked questions
Do I need a GPU for a computer vision capstone?
Not for most of this list. Classical OpenCV pipelines (luggage detection, ANPR, grain grading) and pretrained-model projects (pose estimation, drowsiness with dlib) run fine on a laptop CPU. You only need GPU time — even free Colab sessions — for projects that train a CNN from features, like face age estimation.
Which project is easiest to demo live?
Driver drowsiness detection and the gym form checker, because both react to the person in front of the camera in real time. Keep a pre-recorded video as backup for every live demo — hall lighting and projector glare cause most demo-day failures, not the code.
Classical OpenCV or deep learning — which should I choose?
Choose classical when the problem is geometric and well-defined (plate localisation, grain measurement) — it is faster to build, easier to explain, and debuggable frame by frame. Choose deep learning when the problem is perceptual and messy (age from faces, general object detection). Several projects here sensibly combine both.
Can I run these on a Raspberry Pi or ESP32?
The ESP32-CAM door lock is designed for constrained hardware. MediaPipe pose and dlib landmarks run on a Raspberry Pi 4 at reduced frame rates. Full CNN training and heavy YOLOv8 inference belong on a laptop or Colab — deploy only the optimised, quantised model to the edge.
How do I handle the dataset problem?
Use public datasets where they exist (UTKFace for age, PlantVillage-style sets for agriculture), collect your own where the domain is specific (grain photos), and generate synthetic variation with augmentation. Document your dataset in the report — its size, source, and limitations — because that is what gets asked about first.
A note on getting one of these built
Every project linked above is a real listing on projectech.in, and every project on projectech.in is built to order — nothing is pulled from ready-made stock. You share your requirements (which project, any customisations, your deadline), receive a quotation, and the build is done for you: working code or prototype, the project report, and explanation support so you can present and defend it confidently. If you want to build it yourself instead, use this guide as a roadmap — the techniques described for each project are exactly the ones a working implementation needs.