Introduction to Computer Vision: Pixels, Channels, and Color Spaces

Learn the basics of Computer Vision. Understand how computers read images, RGB/Grayscale channels, resolutions, and basic image operations.

Introduction

To humans, an image is a collection of shapes, colors, and objects. We look at a photo and immediately recognize a dog, a car, or a tree.

To a computer, however, an image is nothing more than a massive grid of numbers. Computer Vision (CV) is the subfield of Artificial Intelligence that enables computers to interpret and understand these numerical grids, allowing them to classify objects, detect boundaries, and perceive the physical world from digital images or video.

What You Will Learn

  • How computers represent digital images numerically.
  • The concept of Pixels and Resolution.
  • The difference between Grayscale and RGB Channels.
  • Understanding Color Spaces (RGB vs. HSV).
  • Basic image manipulation using NumPy and OpenCV in Python.

Why This Topic Matters

Before you can build advanced Convolutional Neural Networks (CNNs) for facial recognition or self-driving cars, you must understand how image data is structured. Just as raw text must be preprocessed before NLP, raw images must be reshaped, scaled, and transformed before being fed into a neural network.

Prerequisites

Detailed Explanation

Every image we see on a screen is composed of tiny squares called Pixels (picture elements).

1. Grayscale Images (2D Tensors)

A grayscale (black and white) image is represented as a 2D matrix (height $\times$ width).

  • Each pixel contains a single numerical value representing its brightness.
  • Typically, this value ranges from 0 (pitch black) to 255 (pure white).
  • A $100 \times 100$ pixel grayscale image is represented as a $100 \times 100$ grid of integers.
[  0   0   0 ...  0   0   0 ]   <- Black Border
[  0  50 120 ... 80  50   0 ]   
[  0 120 255 ... 255 120  0 ]   <- Bright Center
[  0   0   0 ...  0   0   0 ]

2. Color Images (3D Tensors)

A color image is represented as a 3D matrix (height $\times$ width $\times$ channels).

  • We use three primary channels: Red, Green, and Blue (RGB).
  • Each channel is its own 2D grid containing values from $0$ to $255$.
  • By overlaying these three grids, we can represent over 16.7 million unique colors ($256 \times 256 \times 256$).
  • An RGB image of size $224 \times 224$ pixels is represented as a tensor of shape (224, 224, 3).

3. Color Spaces

While RGB is the standard for display monitors, other Color Spaces are more useful for computer vision algorithms:

  • RGB / BGR: Red-Green-Blue. Note that the OpenCV library reads images in BGR (Blue-Green-Red) order by default.
  • HSV: Hue-Saturation-Value.
    • Hue (0-179): The color type (e.g., red, green, blue).
    • Saturation (0-255): The vibrance or purity of the color (e.g., faded vs. intense).
    • Value (0-255): The brightness (e.g., dark vs. light).
    • Why use HSV? In HSV, brightness is separated from color. This makes it highly robust to shadow changes and illumination, making it the preferred space for color tracking.

Visual Diagram (Mermaid)

graph TD
    subgraph RGB Image Channels
    A[RGB Color Image <br> Shape: H x W x 3] --> B[Red Channel matrix <br> Shape: H x W]
    A --> C[Green Channel matrix <br> Shape: H x W]
    A --> D[Blue Channel matrix <br> Shape: H x W]
    end
    style B fill:#EF4444,stroke:#fff,color:#fff
    style C fill:#10B981,stroke:#fff,color:#fff
    style D fill:#3B82F6,stroke:#fff,color:#fff

Python Code Examples

We will write a python script using NumPy to simulate a synthetic image, scale its channels, and convert color representations.

import numpy as np

# 1. Create a synthetic 100x100 black image (Grayscale)
grayscale_img = np.zeros((100, 100), dtype=np.uint8)

# Add a bright white square in the center
grayscale_img[40:60, 40:60] = 255

print("Grayscale image shape:", grayscale_img.shape)
print("Grayscale center pixel value:", grayscale_img[50, 50])

# 2. Create a synthetic 3x3 RGB image
# Shape: (Height, Width, Channels)
rgb_img = np.zeros((3, 3, 3), dtype=np.uint8)

# Make top-left pixel red
rgb_img[0, 0] = [255, 0, 0]
# Make center pixel green
rgb_img[1, 1] = [0, 255, 0]
# Make bottom-right pixel blue
rgb_img[2, 2] = [0, 0, 255]

print("\n3x3 RGB Image Matrix:")
print(rgb_img)

# 3. Simulate normalization (convert range from 0-255 to 0.0-1.0)
normalized_img = rgb_img / 255.0
print("\nNormalized Center Pixel:", normalized_img[1, 1])

Industry Use Cases

  • Quality Control in Agriculture: Using HSV thresholding on assembly line cameras to separate ripe yellow fruits from green unripe ones based on color ranges.
  • Medical Imaging: Loading MRI and CT scans as 3D grayscale slices to locate internal structures or anomalies.
  • Photo Editing Applications: Adjusting image saturations and channels programmatically (e.g., Instagram filters).

Advantages & Limitations

Advantages

  • Simple Vectorization: Images map directly to standard tensor structures, matching mathematical GPU pipelines.
  • High Information Content: Captures detailed layouts, dimensions, and colors.

Limitations

  • High Dimensionality: A simple 1080p RGB image contains $1920 \times 1080 \times 3 \approx 6.2$ million parameters. Processing this directly in a standard feedforward network creates far too many parameters, causing overfitting.
  • Lighting Sensitivity: Minor changes in light or shadows drastically change RGB values, confusing raw pixel-matching algorithms.

FAQs

Q: Why does OpenCV read images in BGR format instead of RGB? A: OpenCV was developed in the early days of computer vision when the BGR format was the popular standard among hardware manufacturers. This choice has been maintained for backward compatibility.

Q: What is image normalization? A: It is the practice of dividing pixel values by 255.0 to bring their range between 0.0 and 1.0. Normalization ensures that gradients behave stably during training.

Summary

In computer vision, digital images are processed as tensors of pixels ranging from 0 (dark) to 255 (bright). While grayscale images are 2D grids, color images consist of 3 channels (Red, Green, Blue). Because raw pixels are highly sensitive to shadow changes and high-dimensionality constraints, they must be formatted and normalized before model ingestion.

Next Topic

How do we extract edges, patterns, and boundaries from these raw pixel grids using mathematical templates? Let's check: Image Filters and Convolution: Kernels, Blurs, and Edges.

← Back to Syllabus