Introduction to Computer Vision

What Is Computer Vision, Really?

Imagine you’re looking at a photo of a street. Within a fraction of a second, your brain identifies cars, people, traffic lights, and road signs: recognising shapes, distances, and even reading text. You do this effortlessly, without any conscious effort.

Computer vision (CV) is the field of AI that teaches computers to do exactly that: to extract meaningful information from images and video, just like your eyes and brain do. Instead of processing numbers in a spreadsheet or words in a document, CV models process visual data: the colours, shapes, textures, and patterns that make up the world we see.

This might sound simple, but it’s actually one of the hardest problems in all of computing. A photo is just a grid of coloured dots (pixels). Teaching a machine to understand that certain arrangements of those dots represent “a person walking”, and that this matters, requires sophisticated mathematics and vast amounts of training data.

The good news: as of today, computers can do this extraordinarily well. In some tasks, CV models now outperform human experts, particularly in medical imaging, where AI can spot certain cancers earlier than radiologists.

The Classic Computer Graphics Analogy

Here’s an insight that helps cement the concept:

Computer graphics starts with a description (“draw a red circle with a shadow”) and produces an image.

Computer vision starts with an image and produces a description (“there is a red circular object with a reflective surface”).

They’re inverses of each other. Graphics goes from meaning → pixels. Vision goes from pixels → meaning.

Why Did This Become Possible?

For decades, researchers tried to program rules manually: “an eye is a roughly circular shape with a dark region in the centre.” This worked for controlled environments but broke down instantly when lighting changed, the angle shifted, or the object looked slightly different.

The breakthrough came with deep learning, specifically a type of network called a Convolutional Neural Network (CNN), which you’ll learn about in Module 4. Instead of writing rules by hand, you feed the network millions of example images and let it discover the rules itself. This turned out to be dramatically more powerful than anything humans could hand-code.

The ImageNet moment in 2012 is the watershed: a deep learning model beat the previous best approach by a stunning margin. Since then, the field has advanced so quickly that today’s models seem almost magical compared to what was possible just 15 years ago.

The Four Core Problem Types

Every computer vision task in the real world falls into one of four categories. Understanding these will help you immediately identify what kind of CV solution a given problem needs.

1. Image Classification: “What is in this image?”

The model looks at an entire image and assigns a single label to it.

Example: You upload a photo of a skin lesion. The model outputs: “Benign mole, 94% confidence.” Or: “Melanoma, 87% confidence.”

Classification is the simplest CV task. The model doesn’t tell you where in the image the thing is, just what it is. You’ll use this for:

• Product categorisation in e-commerce
• Medical diagnosis from scans
• Document type identification

2. Object Detection: “Where are things in this image?”

The model draws bounding boxes around specific objects and labels each one.

Example: A security camera feed. The model draws green boxes around every person, yellow boxes around vehicles, and red boxes around unidentified objects, all in real time.

Detection gives you both what and where, which makes it more powerful than classification but also more complex. Common uses:

• Traffic monitoring systems
• Counting products on a factory conveyor belt
• Face detection in photos (note: detection just finds the face; recognition identifies whose face it is)

3. Image Segmentation: “Which pixels belong to which object?”

The model assigns a label to every single pixel in the image.

Example: An autonomous vehicle needs to understand its surroundings at pixel level, this pixel is road, this pixel is pedestrian, this pixel is sky. Only then can it make safe driving decisions.

There are two flavours:

• Semantic segmentation: every pixel gets a class (road, person, car), but individual objects aren’t separated
• Instance segmentation: like semantic, but also differentiates between individual objects (person #1, person #2)

4. Image Generation: “Can we create new visual content?”

The model creates new images, either from scratch or by transforming existing ones.

Examples: Removing a watermark from a photo. Generating product photos in different colours without a photoshoot. Creating synthetic training data for other models.

This is the domain of GANs (Generative Adversarial Networks) and diffusion models (the technology behind Stable Diffusion and DALL-E).

Which Problem Type Does Your Use Case Need?

Here’s a quick reference:

Most production systems combine multiple types. An invoice processing system might classify whether the document is an invoice (vs. a receipt), detect the key fields (invoice number, date, amount), and then run OCR on those detected regions.

How a Modern CV Pipeline Works

Understanding the stages of a production CV pipeline will help you debug problems and reason about where errors come from. Every CV system, from the simplest mobile app to the most complex industrial inspection system, follows these five stages:

Stage 1: Raw Input

Your visual data comes in. This might be:

• A JPEG photo uploaded by a user
• A stream of frames from a security camera
• A high-resolution TIFF medical scan
• A video file on a server

The challenge here is variety. Images come in wildly different sizes, formats, and quality levels. A 4K cinema frame and a blurry smartphone photo of the same object are very different things for a computer to process.

Stage 2: Preprocessing

Before your model sees the image, it must be standardised. Models expect a specific input size (e.g., 224×224 pixels) and value range (e.g., pixel values between 0 and 1, normalised to a specific mean and standard deviation).

This stage also includes augmentation during training, randomly flipping, rotating, or adjusting the brightness of images so the model learns to handle real-world variation.

Common pitfall: The single most common cause of “my model works in testing but fails in production” is a mismatch between preprocessing at training time and preprocessing at inference time. If you trained with images normalised one way and your live system normalises differently, your model will produce garbage results.

Stage 3: Model Inference

The preprocessed image is passed through the neural network. The model computes its predictions, these are raw numbers: confidence scores, bounding box coordinates, pixel masks, or whatever your model was trained to output.

This is the “magic” step, but it’s actually just matrix multiplication at massive scale, billions of arithmetic operations happening in milliseconds on a GPU.

Stage 4: Post-Processing

Raw model output is rarely directly useful. Post-processing converts it:

• Confidence scores below 0.5 might be discarded
• Overlapping bounding boxes are merged (this is called Non-Maximum Suppression)
• Pixel probabilities are converted to binary masks
• Business logic is applied (“if the model says defective AND confidence > 0.9, flag for human review”)

Stage 5: Output / Action

Finally, the processed result is used:

• Written to a database
• Displayed as an overlay on a video stream
• Sent as a webhook to trigger a downstream process
• Flagged for human review

Classical vs. Deep Learning Approaches

You don’t always need a neural network. Here’s how to think about the choice:

Use classical image processing when:

• Your environment is highly controlled (consistent lighting, background, object position)
• You have very few examples (no training data at all)
• You need to understand exactly why the algorithm made a decision (interpretability)
• You’re running on a very low-power device (a microcontroller, for example)

Use deep learning when:

• The visual variation is high (real-world conditions)
• You have at least a few hundred labelled examples
• Accuracy is critical and you can afford compute
• The problem is too complex to write rules for manually

In practice, most modern production systems use deep learning for the core model, but wrap it with classical processing for preprocessing and post-processing.

Your Learning Path in This Course

Here’s what you’ll build toward over the next 11 modules:

Module 1 (this): What CV is and how pipelines work
      ↓
Module 2: How images are stored as numbers (pixels, colour spaces)
      ↓
Module 3: Classical image processing with OpenCV
      ↓
Module 4: How CNNs learn visual features
      ↓
Modules 5-7: Detection, Segmentation, Face Recognition
      ↓
Module 8: OCR, reading text from images
      ↓
Module 9: Cloud APIs, when to build vs. buy
      ↓
Module 10: Video analysis
      ↓
Module 11: Building a complete end-to-end application
      ↓
Module 12: Capstone project, invoice OCR + defect detector

Each module is hands-on. You’ll write real Python code and build towards a working system.

Exercise before continuing: Think of a visual problem in your current work or industry. Which of the four problem types does it fall into? What would the five pipeline stages look like for your specific use case? Write it down, we’ll return to this example throughout the course.