Computer Vision Roadmap: From Basics to Real Projects

This is a 29-post path through computer vision, written so that someone who has never opened an image in Python and someone who trains models for a living both find something they can use. Every post has hand-worked examples, runnable code, and a practice task.

What you will be able to build

By the end of the series you should be able to do all of these without looking anything up:

• Load, inspect, and clean images, and know from a histogram whether an image is even usable.
• Tell from a file whether it has already been through a lossy step that will hurt your model.
• Build a working inspection or counting system using thresholds, contours, and shape measurements, with no training data at all.
• Calibrate a camera, correct perspective, and convert pixel measurements into real-world millimetres.
• Stitch photos into a panorama and estimate depth from a stereo pair.
• Fine-tune an image classifier, train an object detector, and train a segmentation model.
• Process video efficiently instead of running an image model 30 times a second.
• Explain why a model made a prediction, and find the bias in it before someone else does.
• Deploy a model to run in real time on a CPU, a GPU, or an edge device.
• Evaluate all of the above honestly and know which metric is lying to you.

The four parts

graph LR
  P1["Part 1<br/>Foundations<br/>posts 1-9"] --> P2["Part 2<br/>Classical CV<br/>posts 10-16"]
  P1 --> P3["Part 3<br/>Deep learning<br/>posts 17-22"]
  P2 --> P3
  P3 --> P4["Part 4<br/>Production<br/>posts 23-29"]
  P2 --> P4

Choose your route

You do not have to read all 29 posts in order. Pick the route that matches where you are.

graph TD
  Q{"What do you<br/>want first?"} -->|"understand images"| A["Post 1, then 2, 3, 4"]
  Q -->|"working code this week"| B["Post 1, then 6, 10, 11"]
  Q -->|"train a model"| C["Post 7, then 17, 18"]
  Q -->|"ship what I have"| D["Post 7, 8, then 27, 28"]
  A --> E["Posts 7 and 8:<br/>how to measure and iterate"]
  B --> E
  C --> E
  D --> E
  E --> F["Everything else,<br/>in whatever order you need"]

Posts 7 and 8 sit in the middle of every route on purpose. Measuring honestly and knowing what to fix next are the two skills that decide whether a project finishes, and they apply equally to a threshold rule and to a transformer.

Part 1: Foundations (posts 1–9)

• What is computer vision? — pixels, the recognition ladder, and why the same object produces wildly different numbers under different light.
• History of computer vision — camera obscura to CLIP, told as a sequence of methods that each broke for a specific reason.
• Math for CV beginners — array shapes, convolution, the output size formula, normalization, and 2D transforms.
• Image fundamentals — colour spaces, histograms, and which filter removes which kind of noise.
• How images and video are stored — sampling, bit depth, JPEG, and why B-frames decide your live-video architecture.
• OpenCV setup + first 10 tasks — a working environment and ten hands-on exercises.
• Vision metrics — accuracy, precision, recall, IoU, mAP, and Dice, all worked out on real numbers.
• CV project workflow — spec, data audit, leak-free splits, baselines, and error analysis.
• Intensity transforms and frequency filtering — log, gamma, slicing, and the Fourier view that explains why a blur is a low-pass filter.

Part 2: Classical CV and geometry (posts 10–16)

Classical methods still run most working vision systems in factories, on production lines, and inside larger pipelines. They need no training data, they run on any CPU, and you can explain exactly why they made a decision.

• Edge detection and thresholding — Sobel, Canny, Otsu, and adaptive thresholding on images that fight back.
• Morphology, contours, and shape analysis — clean up masks, separate touching objects, measure real shapes.
• Feature matching and image stitching — SIFT and ORB keypoints, matching, RANSAC, and a working panorama.
• Camera calibration and perspective correction — remove lens distortion and convert pixels into millimetres.
• Epipolar geometry and stereo depth — depth from two cameras, and where it breaks.
• Optical flow and motion tracking — measuring movement between frames and tracking objects over time.
• HOG, HOF and MBH descriptors — the descriptors that ran detection before deep learning, worked out to the exact 3780 numbers.

Part 3: Deep learning for vision (posts 17–22)

• Your first image classifier — transfer learning end to end, with a real training loop.
• Vision data pipelines and augmentation — the part that usually gives the biggest gain for the least effort.
• CNN architectures explained — why each design change happened and what it fixed.
• YOLO object detection pipeline — data format, anchors, training, NMS, and evaluation.
• Semantic and instance segmentation — U-Net and Mask R-CNN, and when each is right.
• Vision transformers — patches, attention, and the data volume ViT actually needs.

Part 4: Modern CV, video, deployment, and responsible use (posts 23–29)

• Model explainability and bias checks — Grad-CAM, failure analysis, and finding the shortcut your model learned.
• 3D vision basics — structure from motion, point clouds, and pose estimation.
• Multimodal vision with CLIP — image and text embeddings, zero-shot classification, and retrieval.
• Video understanding — learned flow, interpolation, stabilisation, denoising, and detection that exploits time.
• Real-time CV systems — latency budgets, batching, tracking, and streaming.
• Deploying CV models — ONNX, TensorRT, quantization, and edge devices.
• Responsible computer vision — privacy, fairness, security, and the release checks that catch problems early.

Check whether you are ready

Answer these four. If you can, start at post 1 and move quickly. If you cannot, start at post 1 and move slowly. Either way, post 1 is the right place.

1. In Python, what does a[2:5] give you if a = [10, 20, 30, 40, 50]?
2. If a NumPy array has shape (480, 640, 3), how many numbers does it contain in total?
3. What is $\frac{18}{18 + 7}$ as a decimal?
4. If you multiply every number in a list by 0.5, what happens to the average?

Answers: (1) [30, 40, 50]. (2) $480 \times 640 \times 3 = 921{,}600$. (3) $0.72$. (4) It halves.

That is genuinely the entry bar for parts 1 and 2. Part 3 additionally assumes you have seen a training loop before; if not, the machine learning series covers that ground first, and neural networks from scratch covers backpropagation.

What you will install

If you have no GPU, Google Colab and Kaggle Notebooks both give free GPU time that is enough for every training task in part 3.

How to actually get through it

Checkpoints

Five points where you should be able to build something on your own, with nothing open but a terminal.

Roughly 86 hours end to end with the practice tasks. At five hours a week that is about four months, which is a realistic pace for something you are learning alongside other work.

Summary

Twenty-nine posts, four parts, five routes. Parts 1 and 2 need nothing but a laptop and give you systems that work without any training data. Part 3 adds learned models for classification, detection, and segmentation. Part 4 covers video, explaining, shipping, and keeping models working once real conditions hit them.

Whichever route you take, posts 7 and 8 are the ones to read early. Everything else is a technique; those two are the judgement that decides which technique you need.

Start here

What is computer vision? opens with a real factory problem and solves it completely using nothing but a grid of numbers and a threshold. It is the shortest path to understanding what every method in the rest of the series is actually doing.