The Ultimate Computer Vision & OpenCV Cheatsheet

import cv2
import numpy as np
from PIL import Image

# ── Image Representation ──
# Images are NumPy arrays: shape = (height, width, channels)
img = cv2.imread('photo.jpg')           # BGR format (OpenCV default)
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # Convert to RGB
gray = cv2.imread('photo.jpg', cv2.IMREAD_GRAYSCALE)  # Grayscale

print(f"Shape: {img.shape}")             # (H, W, 3) for color, (H, W) for gray
print(f"Data type: {img.dtype}")         # uint8 (0-255)
print(f"Size: {img.size} pixels")        # H * W * channels
print(f"Pixel (100,100): {img[100, 100]}")  # BGR values at (row, col)

# ── Color Spaces ──
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)     # Hue, Saturation, Value
img_lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)     # L*a*b* (perceptual)
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)   # Grayscale

# ── Image Properties ──
height, width = img.shape[:2]
center = (width // 2, height // 2)
total_pixels = height * width
aspect_ratio = width / height

# ── Pixel Operations ──
# Access and modify pixels
pixel = img[100, 100]           # BGR values at row=100, col=100
img[100, 100] = [255, 0, 0]     # Set pixel to blue

# Region of Interest (ROI)
roi = img[50:200, 100:300]       # Crop region [y1:y2, x1:x2]
img[0:150, 0:200] = roi           # Paste ROI elsewhere

# ── Image Arithmetic ──
img_add = cv2.add(img1, img2)              # Saturated addition (clips at 255)
img_sub = cv2.subtract(img1, img2)         # Saturated subtraction
img_blend = cv2.addWeighted(img1, 0.7, img2, 0.3, 0)  # Blend images
img_bitwise = cv2.bitwise_and(img, mask)   # Apply binary mask
img_invert = cv2.bitwise_not(img)          # Invert colors

# ── Geometric Transformations ──
# Resize (interpolation methods: INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_LANCZOS4)
resized = cv2.resize(img, (300, 200))                       # Absolute size
resized = cv2.resize(img, None, fx=0.5, fy=0.5)           # Scale factor
resized = cv2.resize(img, (300, 200), interpolation=cv2.INTER_AREA)  # Downscale

# Rotation
M = cv2.getRotationMatrix2D(center=center, angle=45, scale=1.0)
rotated = cv2.warpAffine(img, M, (width, height))

# Translation
M = np.float32([[1, 0, 50], [0, 1, 30]])   # Shift right 50, down 30
translated = cv2.warpAffine(img, M, (width, height))

# Affine Transformation (3 point pairs)
pts1 = np.float32([[50, 50], [200, 50], [50, 200]])
pts2 = np.float32([[10, 100], [200, 50], [100, 250]])
M = cv2.getAffineTransform(pts1, pts2)
warped = cv2.warpAffine(img, M, (width, height))

# Perspective Transform (4 point pairs)
pts1 = np.float32([[56, 65], [368, 52], [28, 387], [389, 390]])
pts2 = np.float32([[0, 0], [300, 0], [0, 300], [300, 300]])
M = cv2.getPerspectiveTransform(pts1, pts2)
warped = cv2.warpPerspective(img, M, (300, 300))

# Flip
flipped_h = cv2.flip(img, 1)   # Horizontal
flipped_v = cv2.flip(img, 0)   # Vertical
flipped_b = cv2.flip(img, -1)  # Both

import cv2
import numpy as np

# ── Thresholding ──
gray = cv2.imread('photo.jpg', cv2.IMREAD_GRAYSCALE)

# Simple threshold
_, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# Adaptive threshold (handles uneven lighting)
adaptive = cv2.adaptiveThreshold(
    gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
    cv2.THRESH_BINARY, blockSize=11, C=2
)

# Otsu's method (automatic threshold selection)
_, otsu = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# ── Morphological Operations ──
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))

erosion = cv2.erode(binary, kernel, iterations=1)       # Shrink white regions
dilation = cv2.dilate(binary, kernel, iterations=1)      # Grow white regions
opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)   # Erode then dilate (remove noise)
closing = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)  # Dilate then erode (fill holes)
gradient = cv2.morphologyEx(binary, cv2.MORPH_GRADIENT, kernel)  # Edge detection
tophat = cv2.morphologyEx(binary, cv2.MORPH_TOPHAT, kernel)    # Difference between input and opening
blackhat = cv2.morphologyEx(binary, cv2.MORPH_BLACKHAT, kernel)  # Difference between closing and input

# ── Contour Detection ──
contours, hierarchy = cv2.findContours(
    binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
)

for contour in contours:
    area = cv2.contourArea(contour)           # Area
    perimeter = cv2.arcLength(contour, True)  # Perimeter
    x, y, w, h = cv2.boundingRect(contour)   # Bounding rectangle
    rect_area = cv2.minAreaRect(contour)      # Minimum area rectangle
    circle = cv2.minEnclosingCircle(contour)  # Minimum enclosing circle
    hull = cv2.convexHull(contour)            # Convex hull
    approx = cv2.approxPolyDP(contour, 0.02 * perimeter, True)  # Polygon approximation
    if len(approx) == 4:  # Rectangle detection
        print("Rectangle detected")

# ── Drawing Functions ──
img_draw = img.copy()
cv2.rectangle(img_draw, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.circle(img_draw, (cx, cy), radius, (255, 0, 0), -1)  # Filled circle
cv2.line(img_draw, (0, 0), (100, 100), (0, 0, 255), 2)
cv2.putText(img_draw, 'Label', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
cv2.polylines(img_draw, [points], True, (0, 255, 0), 2)

# ── Histogram Analysis ──
# Calculate histogram
hist = cv2.calcHist([gray], [0], None, [256], [0, 256])

# Color histogram
color_hist_b = cv2.calcHist([img], [0], None, [256], [0, 256])
color_hist_g = cv2.calcHist([img], [1], None, [256], [0, 256])
color_hist_r = cv2.calcHist([img], [2], None, [256], [0, 256])

# ── Histogram Equalization ──
equalized = cv2.equalizeHist(gray)

# CLAHE (Contrast Limited Adaptive Histogram Equalization)
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
clahe_img = clahe.apply(gray)

# ── Image Blurring (Noise Reduction) ──
avg_blur = cv2.blur(img, (5, 5))                    # Average blur
gaussian = cv2.GaussianBlur(img, (5, 5), 0)         # Gaussian blur
median = cv2.medianBlur(img, 5)                      # Median blur (salt/pepper)
bilateral = cv2.bilateralFilter(img, 9, 75, 75)      # Bilateral (edge-preserving)
# Non-local means (best quality, slow)
nlm = cv2.fastNlMeansDenoisingColored(img, None, h=10, hForColorComponents=10,
                                         templateWindowSize=7, searchWindowSize=21)

import cv2
import numpy as np

# ── Canny Edge Detection (Most Popular) ──
edges = cv2.Canny(img, threshold1=50, threshold2=150)
# threshold1 = lower bound (weak edges)
# threshold2 = upper bound (strong edges)
# Edges between thresholds are kept only if connected to strong edges

# Automatic Canny edge detection (based on median pixel value)
def auto_canny(image, sigma=0.33):
    median = np.median(image)
    lower = int(max(0, (1.0 - sigma) * median))
    upper = int(min(255, (1.0 + sigma) * median))
    return cv2.Canny(image, lower, upper)

# ── Sobel Operator ──
sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)   # Horizontal edges
sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)   # Vertical edges
sobel_mag = np.sqrt(sobel_x**2 + sobel_y**2)              # Magnitude
sobel_mag = np.uint8(np.clip(sobel_mag, 0, 255))

# ── Laplacian Operator ──
laplacian = cv2.Laplacian(gray, cv2.CV_64F)
laplacian = np.uint8(np.clip(np.abs(laplacian), 0, 255))

# ── Scharr Operator (more accurate than Sobel 3x3) ──
scharr_x = cv2.Scharr(gray, cv2.CV_64F, 1, 0)
scharr_y = cv2.Scharr(gray, cv2.CV_64F, 0, 1)

# ── LoG (Laplacian of Gaussian) ──
blurred = cv2.GaussianBlur(gray, (3, 3), 0)
log = cv2.Laplacian(blurred, cv2.CV_64F, ksize=3)

# ── Custom Convolution Kernel ──
# Sharpening kernel
sharpen = np.array([[0, -1, 0],
                    [-1, 5, -1],
                    [0, -1, 0]])
sharpened = cv2.filter2D(img, -1, sharpen)

# Emboss kernel
emboss = np.array([[-2, -1, 0],
                   [-1,  1, 1],
                   [ 0,  1, 2]])
embossed = cv2.filter2D(img, -1, emboss)

import cv2
import numpy as np

# ── YOLO with OpenCV (DNN module) ──
# Load pre-trained YOLO model
net = cv2.dnn.readNetFromDarknet('yolov4.cfg', 'yolov4.weights')
layer_names = net.getLayerNames()
output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]

# Load COCO class names (80 classes)
with open('coco.names', 'r') as f:
    classes = [line.strip() for line in f.readlines()]

# Process image
def detect_objects(image, conf_threshold=0.5, nms_threshold=0.4):
    height, width = image.shape[:2]
    blob = cv2.dnn.blobFromImage(image, 1/255.0, (416, 416),
                                  swapRB=True, crop=False)
    net.setInput(blob)
    outputs = net.forward(output_layers)

    boxes, confidences, class_ids = [], [], []
    for output in outputs:
        for detection in output:
            scores = detection[5:]
            class_id = np.argmax(scores)
            confidence = scores[class_id]
            if confidence > conf_threshold:
                center_x = int(detection[0] * width)
                center_y = int(detection[1] * height)
                w = int(detection[2] * width)
                h = int(detection[3] * height)
                x = int(center_x - w / 2)
                y = int(center_y - h / 2)
                boxes.append([x, y, w, h])
                confidences.append(float(confidence))
                class_ids.append(class_id)

    # Non-Maximum Suppression (remove overlapping boxes)
    indices = cv2.dnn.NMSBoxes(boxes, confidences,
                                conf_threshold, nms_threshold)
    results = []
    for i in indices:
        i = i[0]
        results.append({
            'class': classes[class_ids[i]],
            'confidence': confidences[i],
            'box': boxes[i]
        })
    return results

results = detect_objects(img)
for r in results:
    x, y, w, h = r['box']
    cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
    cv2.putText(img, f"{r['class']} {r['confidence']:.2f}",
                (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 2)

# ── YOLO with Ultralytics (Recommended) ──
from ultralytics import YOLO

# Load pre-trained YOLOv8 model
model = YOLO('yolov8n.pt')  # nano (fastest), s, m, l, x

# Train on custom dataset (YOLO format: images/ + labels/)
results = model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device='0',              # GPU device
    workers=8,
    pretrained=True,
    optimizer='AdamW',
    lr0=0.01,
    augment=True,
    mosaic=True,
)

# Inference
results = model('image.jpg')
for result in results:
    boxes = result.boxes
    for box in boxes:
        cls = int(box.cls[0])
        conf = float(box.conf[0])
        xyxy = box.xyxy[0].tolist()
        class_name = model.names[cls]

# Export to different formats
model.export(format='onnx')    # ONNX
model.export(format='engine')  # TensorRT
model.export(format='openvino')  # OpenVINO
model.export(format='tflite')  # TensorFlow Lite

# ── Semantic Segmentation with OpenCV (GrabCut) ──
import cv2
import numpy as np

img = cv2.imread('photo.jpg')
mask = np.zeros(img.shape[:2], np.uint8)

# Define foreground and background rectangles
rect = (50, 50, 450, 290)

# GrabCut algorithm
bgd_model = np.zeros((1, 65), np.float64)
fgd_model = np.zeros((1, 65), np.float64)
cv2.grabCut(img, mask, rect, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_RECT)

# Create binary mask (foreground = 1, background = 0)
binary_mask = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
segmented = img * binary_mask[:, :, np.newaxis]

# ── Watershed Segmentation ──
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# Noise removal
kernel = np.ones((3, 3), np.uint8)
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)

# Sure background area
sure_bg = cv2.dilate(opening, kernel, iterations=3)

# Finding sure foreground area using distance transform
dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
ret, sure_fg = cv2.threshold(dist_transform, 0.7 * dist_transform.max(), 255, 0)

# Unknown region
sure_fg = np.uint8(sure_fg)
unknown = cv2.subtract(sure_bg, sure_fg)

# Marker labeling
ret, markers = cv2.connectedComponents(sure_fg)
markers = markers + 1  # Add 1 to all labels (background = 1)
markers[unknown == 255] = 0  # Unknown region = 0

# Watershed
markers = cv2.watershed(img, markers)
img[markers == -1] = [255, 0, 0]  # Mark boundaries in red

# ── Segment Anything Model (SAM) ──
from segment_anything import SamPredictor, sam_model_registry

# Load model (vit_h, vit_l, vit_b)
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h_4b8939.pth")
predictor = SamPredictor(sam)

# Set image
predictor.set_image(image)

# Predict with point prompt
input_point = np.array([[500, 375]])  # x, y coordinates
input_label = np.array([1])          # 1 = foreground, 0 = background
masks, scores, logits = predictor.predict(
    point_coords=input_point,
    point_labels=input_label,
    multimask_output=True
)
# masks: (num_masks, H, W) boolean arrays
# scores: confidence scores for each mask

# Predict with bounding box prompt
input_box = np.array([425, 600, 700, 875])  # x1, y1, x2, y2
masks, scores, logits = predictor.predict(
    box=input_box,
    multimask_output=False
)

import torch
import torch.nn as nn
import torchvision.models as models
import torchvision.transforms as transforms
from torchvision import datasets
from torch.utils.data import DataLoader

# ── Pre-trained Models (Transfer Learning) ──
# ResNet-50 (pretrained on ImageNet)
resnet = models.resnet50(weights='IMAGENET1K_V2')
num_features = resnet.fc.in_features  # 2048
resnet.fc = nn.Linear(num_features, num_classes)  # Replace final layer

# EfficientNet-V2
efficientnet = models.efficientnet_v2_s(weights='IMAGENET1K_V1')

# Vision Transformer (ViT)
vit = models.vit_b_16(weights='IMAGENET1K_V1')

# ── Image Preprocessing Pipeline ──
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),       # Standard input size for most models
    transforms.ToTensor(),           # Convert PIL to Tensor [0, 1]
    transforms.Normalize(             # ImageNet statistics
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    ),
])

# ── Training Loop ──
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = resnet.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)

for epoch in range(num_epochs):
    model.train()
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)
        outputs = model(images)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    scheduler.step()

import cv2
import numpy as np

# ── Haar Cascade Face Detection (Classic, Fast, OpenCV) ──
face_cascade = cv2.CascadeClassifier(
    cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
)
eye_cascade = cv2.CascadeClassifier(
    cv2.data.haarcascades + 'haarcascade_eye.xml'
)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(
    gray, scaleFactor=1.1, minNeighbors=5,
    minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE
)

for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)
    roi_gray = gray[y:y+h, x:x+w]
    eyes = eye_cascade.detectMultiScale(roi_gray, scaleFactor=1.1, minNeighbors=5)
    for (ex, ey, ew, eh) in eyes:
        cv2.rectangle(img, (x+ex, y+ey), (x+ex+ew, y+ey+eh), (0, 255, 0), 2)

# ── DNN Face Detection (More Accurate) ──
face_net = cv2.dnn.readNetFromCaffe('deploy.prototxt', 'res10_300x300.caffemodel')
blob = cv2.dnn.blobFromImage(cv2.resize(img, (300, 300)), 1.0,
                               (104.0, 177.0, 123.0))
face_net.setInput(blob)
detections = face_net.forward()

h, w = img.shape[:2]
for i in range(detections.shape[2]):
    confidence = detections[0, 0, i, 2]
    if confidence > 0.7:
        box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
        (startX, startY, endX, endY) = box.astype('int')
        cv2.rectangle(img, (startX, startY), (endX, endY), (0, 255, 0), 2)

# ── Face Recognition with face_recognition library ──
# pip install face_recognition
import face_recognition

# Load and encode known faces
known_image = face_recognition.load_image_file("known_person.jpg")
known_encoding = face_recognition.face_encodings(known_image)[0]

# Find faces in unknown image
unknown_image = face_recognition.load_image_file("group_photo.jpg")
face_locations = face_recognition.face_locations(unknown_image)
face_encodings = face_recognition.face_encodings(unknown_image, face_locations)

# Compare faces
for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings):
    matches = face_recognition.compare_faces([known_encoding], face_encoding, tolerance=0.6)
    distance = face_recognition.face_distance([known_encoding], face_encoding)
    name = "Known Person" if matches[0] else "Unknown"