OpenCV BGR vs RGB Bug — Why Models Fail After imread

import cv2
import numpy as np

# --- Load an image from disk ---
# cv2.IMREAD_COLOR loads as a 3-channel BGR image (the default)
# cv2.IMREAD_GRAYSCALE loads as a single-channel image
bgr_image = cv2.imread("street_scene.jpg", cv2.IMREAD_COLOR)

# Always check — imread returns None silently if the path is wrong
if bgr_image is None:
    raise FileNotFoundError("Could not load street_scene.jpg — check the file path")

# --- Inspect what we actually have ---
print("Type  :", type(bgr_image))          # numpy.ndarray
print("Shape :", bgr_image.shape)          # (height, width, channels)
print("Dtype :", bgr_image.dtype)          # uint8  (values 0-255)
print("Size  :", bgr_image.size)           # total number of pixel values

height, width, num_channels = bgr_image.shape
print(f"\nImage is {width}px wide × {height}px tall with {num_channels} colour channels")

# --- Access a single pixel (row=100, col=200) ---
# Returns [Blue, Green, Red] — remember, BGR not RGB!
bgr_pixel = bgr_image[100, 200]
print(f"\nPixel at (100,200) — B:{bgr_pixel[0]}  G:{bgr_pixel[1]}  R:{bgr_pixel[2]}")

# --- Convert BGR → RGB so other libraries see colours correctly ---
rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB)
rgb_pixel = rgb_image[100, 200]
print(f"Same pixel in RGB  — R:{rgb_pixel[0]}  G:{rgb_pixel[1]}  B:{rgb_pixel[2]}")

# --- Cropping is just NumPy slicing: array[y_start:y_end, x_start:x_end] ---
# Crop a 200×200 region from the top-left corner
top_left_crop = bgr_image[0:200, 0:200]
print(f"\nCropped shape: {top_left_crop.shape}")  # (200, 200, 3)

# --- Darken the image by halving every pixel value ---
# .astype(float) prevents uint8 overflow wrapping (255+1 = 0)
darkened_image = (bgr_image.astype(np.float32) * 0.5).astype(np.uint8)

# --- Save results to disk ---
cv2.imwrite("cropped_top_left.jpg", top_left_crop)
cv2.imwrite("darkened_scene.jpg", darkened_image)
print("\nSaved cropped_top_left.jpg and darkened_scene.jpg")

import cv2
import numpy as np

# --- Load the source image ---
bgr_frame = cv2.imread("traffic_intersection.jpg", cv2.IMREAD_COLOR)
if bgr_frame is None:
    raise FileNotFoundError("traffic_intersection.jpg not found")

# ── GRAYSCALE ────────────────────────────────────────────────────────────────
# Single channel — perfect for edge detection, thresholding, template matching
gray_frame = cv2.cvtColor(bgr_frame, cv2.COLOR_BGR2GRAY)
print("Grayscale shape:", gray_frame.shape)  # (height, width) — no channel dim

# ── HSV — COLOUR-BASED OBJECT DETECTION ──────────────────────────────────────
# Convert BGR → HSV so we can isolate colours regardless of brightness
hsv_frame = cv2.cvtColor(bgr_frame, cv2.COLOR_BGR2HSV)

# Define the HSV range for detecting RED traffic lights
# Red wraps around 0° on the hue wheel, so we need TWO ranges
red_lower_1 = np.array([0,   120, 70])   # lower bound of first red range
red_upper_1 = np.array([10,  255, 255])  # upper bound of first red range
red_lower_2 = np.array([170, 120, 70])   # lower bound of second red range (wraps)
red_upper_2 = np.array([180, 255, 255])  # upper bound of second red range

# cv2.inRange creates a binary mask: 255 where colour is in range, 0 elsewhere
mask_red_1 = cv2.inRange(hsv_frame, red_lower_1, red_upper_1)
mask_red_2 = cv2.inRange(hsv_frame, red_lower_2, red_upper_2)

# Combine both red masks with bitwise OR
red_mask = cv2.bitwise_or(mask_red_1, mask_red_2)

# Apply the mask to isolate only red regions in the original image
red_regions_only = cv2.bitwise_and(bgr_frame, bgr_frame, mask=red_mask)

# Count how many red pixels were detected
red_pixel_count = cv2.countNonZero(red_mask)
print(f"Red pixels detected: {red_pixel_count}")

if red_pixel_count > 500:   # threshold tuned to filter out small noise
    print("⚠  Red traffic light likely detected — stopping recommended")
else:
    print("✓  No significant red light detected")

# ── LAB — NORMALISE BRIGHTNESS ACROSS IMAGES FROM DIFFERENT CAMERAS ──────────
lab_frame = cv2.cvtColor(bgr_frame, cv2.COLOR_BGR2LAB)

# Split into L (lightness), A (green↔red axis), B (blue↔yellow axis) channels
l_channel, a_channel, b_channel = cv2.split(lab_frame)

# Apply CLAHE (Contrast Limited Adaptive Histogram Equalisation) only to L
# This enhances local contrast without touching colour — great for dim images
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
l_equalised = clahe.apply(l_channel)

# Merge back and convert to BGR for saving
lab_equalised = cv2.merge([l_equalised, a_channel, b_channel])
bgr_enhanced = cv2.cvtColor(lab_equalised, cv2.COLOR_LAB2BGR)

# --- Save all outputs ---
cv2.imwrite("gray_frame.jpg",        gray_frame)
cv2.imwrite("red_mask.jpg",          red_mask)
cv2.imwrite("red_regions_only.jpg",  red_regions_only)
cv2.imwrite("brightness_enhanced.jpg", bgr_enhanced)
print("\nSaved gray_frame.jpg, red_mask.jpg, red_regions_only.jpg, brightness_enhanced.jpg")

import cv2
import numpy as np

# Assume we have a red_mask from the previous example (binary image)
# If not loaded, create a simple test mask:
mask = np.zeros((200, 200), dtype=np.uint8)
cv2.circle(mask, (100, 100), 40, 255, -1)
# Add noise
noise = np.random.randint(0, 2, size=(200, 200), dtype=np.uint8) * 255
noisy_mask = cv2.bitwise_or(mask, cv2.bitwise_and(noise, noise))

print("Noisy mask pixel count:", cv2.countNonZero(noisy_mask))

# Opening: remove small white noise spots
kernel = np.ones((3,3), np.uint8)
opened = cv2.morphologyEx(noisy_mask, cv2.MORPH_OPEN, kernel)
print("After opening:", cv2.countNonZero(opened))

# Closing: fill holes inside the circle
kernel5 = np.ones((5,5), np.uint8)
closed = cv2.morphologyEx(opened, cv2.MORPH_CLOSE, kernel5)
print("After closing:", cv2.countNonZero(closed))

# Save for inspection
cv2.imwrite("original_mask.png", mask)
cv2.imwrite("noisy_mask.png", noisy_mask)
cv2.imwrite("cleaned_mask.png", closed)

import cv2
import numpy as np

# ── LOAD ──────────────────────────────────────────────────────────────────────
original_bgr = cv2.imread("product_photo.jpg", cv2.IMREAD_COLOR)
if original_bgr is None:
    raise FileNotFoundError("product_photo.jpg not found")

print(f"Original size: {original_bgr.shape[1]}×{original_bgr.shape[0]}")

# ── STEP 1: RESIZE ────────────────────────────────────────────────────────────
# Neural networks like MobileNet, ResNet etc. expect 224×224 or 640×640
# INTER_AREA is best when downscaling — avoids moiré patterns
target_size = (224, 224)   # (width, height) — note: width FIRST in cv2.resize
resized_bgr = cv2.resize(original_bgr, target_size, interpolation=cv2.INTER_AREA)
print(f"Resized to:    {resized_bgr.shape[1]}×{resized_bgr.shape[0]}")

# ── STEP 2: GRAYSCALE + BLUR ──────────────────────────────────────────────────
gray = cv2.cvtColor(resized_bgr, cv2.COLOR_BGR2GRAY)

# Gaussian blur: kernel size (5,5) must be ODD and POSITIVE
# sigmaX=0 tells OpenCV to calculate sigma automatically from kernel size
blurred_gray = cv2.GaussianBlur(gray, ksize=(5, 5), sigmaX=0)
print(f"Blur applied — kernel 5×5, sigma auto-calculated")

# ── STEP 3: CANNY EDGE DETECTION ─────────────────────────────────────────────
# threshold1: pixels BELOW this are definitely NOT edges
# threshold2: pixels ABOVE this are definitely edges
# Pixels between the two are edges only if connected to a definite edge
# A good starting ratio is 1:3 (low:high). Adjust based on image contrast.
edge_map = cv2.Canny(blurred_gray, threshold1=50, threshold2=150)

edge_pixel_count = cv2.countNonZero(edge_map)
print(f"Edge pixels found: {edge_pixel_count}")

# ── STEP 4: FIND CONTOURS AND DRAW BOUNDING BOXES ────────────────────────────
# Contours are the outlines of connected white regions in a binary image
# RETR_EXTERNAL: only outermost contours (ignore holes inside shapes)
# CHAIN_APPROX_SIMPLE: compress straight lines to just endpoints (saves memory)
contours, hierarchy = cv2.findContours(
    edge_map,
    cv2.RETR_EXTERNAL,
    cv2.CHAIN_APPROX_SIMPLE
)

print(f"Contours found: {len(contours)}")

# Draw bounding boxes around contours larger than 200 px² (filter out noise)
annotated_image = resized_bgr.copy()   # always work on a COPY — don't mutate original

for contour in contours:
    area = cv2.contourArea(contour)
    if area < 200:            # skip tiny noise blobs
        continue

    # Get the upright bounding rectangle: x, y = top-left corner
    bounding_x, bounding_y, box_width, box_height = cv2.boundingRect(contour)

    # Draw green rectangle: (image, top-left, bottom-right, BGR colour, thickness)
    cv2.rectangle(
        annotated_image,
        (bounding_x, bounding_y),
        (bounding_x + box_width, bounding_y + box_height),
        color=(0, 255, 0),    # green in BGR
        thickness=2
    )

    # Label the area in white text above each box
    cv2.putText(
        annotated_image,
        f"{int(area)}px",
        (bounding_x, bounding_y - 5),     # slightly above the top-left corner
        fontFace=cv2.FONT_HERSHEY_SIMPLEX,
        fontScale=0.4,
        color=(255, 255, 255),
        thickness=1
    )

# ── SAVE OUTPUTS ─────────────────────────────────────────────────────────────
cv2.imwrite("resized_product.jpg",    resized_bgr)
cv2.imwrite("edge_map.jpg",           edge_map)
cv2.imwrite("annotated_product.jpg",  annotated_image)
print("\nSaved resized_product.jpg, edge_map.jpg, annotated_product.jpg")

import cv2
import numpy as np
from pathlib import Path
from typing import Optional

# ImageNet normalisation constants — used when loading weights pretrained on ImageNet
# Values are per-channel means and stds in RGB order, scaled to [0,1]
IMAGENET_MEAN = np.array([0.485, 0.456, 0.406], dtype=np.float32)
IMAGENET_STD  = np.array([0.229, 0.224, 0.225], dtype=np.float32)


def preprocess_for_model(
    image_path: str,
    target_size: tuple = (224, 224),
    normalise_imagenet: bool = False
) -> Optional[np.ndarray]:
    """
    Load an image and return a float32 NumPy array ready for a CNN.

    Returns shape: (target_height, target_width, 3) in RGB order.
    Pixel values are in [0, 1] range (or ImageNet-normalised if requested).
    Returns None if the image cannot be loaded.
    """
    image_file = Path(image_path)

    # ── VALIDATE ──────────────────────────────────────────────────────────────
    if not image_file.exists():
        print(f"[WARN] File not found: {image_path}")
        return None

    raw_bgr = cv2.imread(str(image_file), cv2.IMREAD_COLOR)
    if raw_bgr is None:
        print(f"[WARN] OpenCV could not decode: {image_path}")
        return None

    # ── HANDLE UNEXPECTED SHAPES ──────────────────────────────────────────────
    # Some images are loaded as grayscale even with IMREAD_COLOR (rare but happens)
    if raw_bgr.ndim == 2:
        raw_bgr = cv2.cvtColor(raw_bgr, cv2.COLOR_GRAY2BGR)

    # Some PNGs have an alpha channel — strip it
    if raw_bgr.shape[2] == 4:
        raw_bgr = cv2.cvtColor(raw_bgr, cv2.COLOR_BGRA2BGR)

    # ── RESIZE ────────────────────────────────────────────────────────────────
    # INTER_AREA for shrinking, INTER_LINEAR for enlarging
    original_h, original_w = raw_bgr.shape[:2]
    interpolation = (
        cv2.INTER_AREA
        if (original_w > target_size[0] or original_h > target_size[1])
        else cv2.INTER_LINEAR
    )
    resized_bgr = cv2.resize(raw_bgr, target_size, interpolation=interpolation)

    # ── BGR → RGB ─────────────────────────────────────────────────────────────
    # Models expect RGB. This is the single most common source of silent bugs.
    resized_rgb = cv2.cvtColor(resized_bgr, cv2.COLOR_BGR2RGB)

    # ── NORMALISE TO [0, 1] ───────────────────────────────────────────────────
    # Divide by 255 and cast to float32 (float64 wastes memory, models use float32)
    normalised = resized_rgb.astype(np.float32) / 255.0

    # ── OPTIONAL: IMAGENET NORMALISATION ─────────────────────────────────────
    # Apply only when using weights pretrained on ImageNet (ResNet, VGG, etc.)
    if normalise_imagenet:
        normalised = (normalised - IMAGENET_MEAN) / IMAGENET_STD

    return normalised  # shape: (224, 224, 3), dtype: float32


# ── BATCH PROCESSING EXAMPLE ─────────────────────────────────────────────────
if __name__ == "__main__":
    image_paths = [
        "cat.jpg",
        "dog.png",
        "corrupt_file.jpg",     # intentionally bad — tests our None handling
        "high_res_landscape.jpg"
    ]

    processed_batch = []

    for path in image_paths:
        preprocessed = preprocess_for_model(
            path,
            target_size=(224, 224),
            normalise_imagenet=True
        )
        if preprocessed is not None:
            processed_batch.append(preprocessed)
            print(f"✓  {path:<30} shape={preprocessed.shape}  "
                  f"min={preprocessed.min():.3f}  max={preprocessed.max():.3f}")

    # Stack into a batch array ready for model.predict() or torch DataLoader
    if processed_batch:
        batch_array = np.stack(processed_batch, axis=0)
        print(f"\nBatch array shape: {batch_array.shape}")   # (N, 224, 224, 3)
        print(f"Batch dtype:       {batch_array.dtype}")
        print(f"Successfully processed {len(processed_batch)}/{len(image_paths)} images")

// io.thecodeforge — ml-ai tutorial

import cv2
import numpy as np

# Create binary mask: outer square, inner circle
mask = np.zeros((200, 200), dtype=np.uint8)
cv2.rectangle(mask, (30, 30), (170, 170), 255, -1)
cv2.circle(mask, (100, 100), 40, 0, -1)

# Capture ALL nesting relationships
contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# hierarchy shape: (1, N, 4) — N contours, each with [Next, Previous, First_Child, Parent]

print(f"Found {len(contours)} contours")
for idx, h in enumerate(hierarchy[0]):
    print(f"Contour {idx}: next={h[0]}, prev={h[1]}, child={h[2]}, parent={h[3]}")

// io.thecodeforge — ml-ai tutorial

import cv2
import numpy as np
import glob

# Prepare 9x6 chessboard points in real-world units (mm here)
CHECKER_SIZE = (9, 6)
objp = np.zeros((CHECKER_SIZE[0]*CHECKER_SIZE[1], 3), np.float32)
objp[:,:2] = np.mgrid[0:CHECKER_SIZE[0], 0:CHECKER_SIZE[1]].T.reshape(-1,2) * 25.0  # 25mm per square

objpoints = []  # 3D points in real world
imgpoints = []  # 2D points in image plane

for fname in glob.glob('checkerboard_*.jpg'):
    img = cv2.imread(fname)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    ret, corners = cv2.findChessboardCorners(gray, CHECKER_SIZE, None)
    if ret:
        objpoints.append(objp)
        imgpoints.append(corners)

ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)

print("Intrinsic matrix:\n", mtx)
print("Distortion coefficients:\n", dist)

# Save for production — remap once
map1, map2 = cv2.initUndistortRectifyMap(mtx, dist, None, mtx, gray.shape[::-1], cv2.CV_32FC1)
cv2.imwrite('undistorted_example.jpg', cv2.remap(img, map1, map2, cv2.INTER_LINEAR))

// io.thecodeforge — ml-ai tutorial

import cv2
import numpy as np

# Prefer KNN for scenes with swaying foliage or conveyor belts
sub = cv2.createBackgroundSubtractorKNN(history=500, dist2Threshold=400, detectShadows=True)

cap = cv2.VideoCapture('warehouse_footage.mp4')

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # Lighting normalisation before subtraction
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
    equalized = clahe.apply(gray)

    # Apply background subtractor to normalised luminance
    fgmask = sub.apply(equalized)

    # Remove noise — small blobs are usually lighting flicker
    fgmask = cv2.medianBlur(fgmask, 5)
    _, fgmask = cv2.threshold(fgmask, 200, 255, cv2.THRESH_BINARY)

    cv2.imshow('Foreground mask', fgmask)
    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

// io.thecodeforge — ml-ai tutorial
import cv2
import numpy as np
import sys

assert cv2.__version__.startswith('4.'), f"OpenCV 4.x required, got {cv2.__version__}"
img = np.zeros((10,10,3), dtype=np.uint8)
assert img.shape == (10,10,3), f"Shape mismatch: {img.shape}"

info = cv2.getBuildInformation()
if 'CUDA' in info and 'YES' in info.split('CUDA')[1][:10]:
    print('GPU acceleration: enabled')
else:
    print('GPU acceleration: disabled — falling back to CPU')

print(f'OpenCV {cv2.__version__} verified. NumPy {np.__version__}')
sys.exit(0)

// io.thecodeforge — ml-ai tutorial
import cv2
import numpy as np

frame = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
x, y, w, h = 200, 100, 150, 200  # bounding box

# Shallow slice — modifications bleed to original
roi_view = frame[y:y+h, x:x+w]
roi_view[:] = [0, 255, 0]  # paints green rectangle on original frame

# Safe copy for independent processing
roi_copy = frame[y:y+h, x:x+w].copy()
roi_copy = cv2.GaussianBlur(roi_copy, (5,5), 0)

# Irregular ROI via mask
mask = np.zeros(frame.shape[:2], dtype=np.uint8)
cv2.rectangle(mask, (x,y), (x+w,y+h), 255, -1)
masked_roi = cv2.bitwise_and(frame, frame, mask=mask)

cv2.imshow('Safe Blur', roi_copy)
cv2.waitKey(0)