Feature Engineering for Computer Vision

# Import numpy and pandas — simulating image data with numpy arrays
import numpy as np
import pandas as pd

# Simulate 8 grayscale images as 32x32 numpy arrays (0–255 pixel values)
# In production these would be loaded with: np.array(PIL.Image.open(path).convert('L'))
np.random.seed(42)

# "Clean" images: smooth, uniform surfaces — low std, moderate mean
clean_images    = [np.random.normal(loc=180, scale=8,  size=(32, 32)).clip(0, 255)
                   for _ in range(4)]   # 4 clean panels

# "Defect" images: scratches create dark patches and high local variance
defect_images   = [np.random.normal(loc=130, scale=45, size=(32, 32)).clip(0, 255)
                   for _ in range(4)]   # 4 defective panels

all_images   = clean_images + defect_images                # combine into one list
labels       = [0]*4 + [1]*4                               # 0=clean, 1=defect

# --- Extract pixel statistics per image ---
def pixel_stats(img):
    flat = img.flatten()                   # collapse 32x32 → 1024 values
    return {
        'mean_intensity':  flat.mean(),    # average brightness
        'std_intensity':   flat.std(),     # spread of brightness — high = high contrast / noise
        'min_intensity':   flat.min(),     # darkest pixel
        'max_intensity':   flat.max(),     # brightest pixel
        'p10_intensity':   np.percentile(flat, 10),  # 10th percentile — shadow level
        'p90_intensity':   np.percentile(flat, 90),  # 90th percentile — highlight level
        'intensity_range': flat.max() - flat.min()   # dynamic range — captures contrast
    }

# --- Extract colour histogram (8 bins for grayscale, 0–255) ---
def pixel_histogram(img, n_bins=8):
    flat    = img.flatten()
    counts, _ = np.histogram(flat, bins=n_bins, range=(0, 255))  # bin pixel counts
    counts  = counts / counts.sum()   # normalise to proportions — sum = 1.0
    return {f'hist_bin_{i}': counts[i] for i in range(n_bins)}   # dict of bin proportions

# Build the feature DataFrame
rows = []
for img, label in zip(all_images, labels):
    row = {'label': label}
    row.update(pixel_stats(img))        # add 7 pixel statistics
    row.update(pixel_histogram(img))    # add 8 histogram bin proportions
    rows.append(row)

features_df = pd.DataFrame(rows)

# Print class separation for the key features
print("Mean feature values by class (0=clean, 1=defect):\n")
print(features_df.groupby('label')[
    ['mean_intensity','std_intensity','intensity_range','hist_bin_0','hist_bin_7']
].mean().round(2).to_string())

print("\nFull feature matrix (pixel stats only):")
print(features_df[['mean_intensity','std_intensity','p10_intensity',
                    'p90_intensity','intensity_range','label']].round(2).to_string(index=False))

# Import numpy, pandas, and scipy for convolution-based edge detection
import numpy as np
import pandas as pd
from scipy.ndimage import convolve  # applies a filter kernel to an image array

# Sobel filter kernels — detect horizontal and vertical edges respectively
# The Sobel operator computes the image gradient (rate of pixel intensity change)
sobel_x = np.array([[-1, 0, 1],
                     [-2, 0, 2],
                     [-1, 0, 1]], dtype=float)   # detects vertical edges (changes left-to-right)

sobel_y = np.array([[-1, -2, -1],
                     [ 0,  0,  0],
                     [ 1,  2,  1]], dtype=float)  # detects horizontal edges (changes top-to-bottom)

# Simulate images: clean (smooth) vs textured-defect (fine cracks = many edges)
np.random.seed(7)

# Clean images: smooth gradient surfaces — few edges
clean_imgs  = [np.random.normal(180, 5,  (32, 32)).clip(0, 255) for _ in range(4)]

# Defect images: fine-crack texture — many sharp local edges
# Simulate cracks by adding high-frequency noise in random patches
defect_imgs = []
for _ in range(4):
    img = np.random.normal(160, 5, (32, 32))           # dark base surface
    # Add 6 random "crack" lines as sharp intensity spikes
    for _ in range(6):
        r, c = np.random.randint(2, 30, 2)             # random crack position
        img[r:r+2, c:c+8] += np.random.choice([-80, 80])  # sharp dark or bright stripe
    defect_imgs.append(img.clip(0, 255))

all_imgs = clean_imgs + defect_imgs
labels   = [0]*4 + [1]*4

# --- Edge feature extraction using Sobel operator ---
def edge_features(img):
    grad_x   = convolve(img, sobel_x)              # horizontal gradient response
    grad_y   = convolve(img, sobel_y)              # vertical gradient response
    magnitude = np.sqrt(grad_x**2 + grad_y**2)    # overall gradient magnitude at each pixel

    return {
        'edge_mean':     magnitude.mean(),          # average edge strength across the image
        'edge_std':      magnitude.std(),            # variability in edge strength
        'edge_max':      magnitude.max(),            # strongest single edge
        'edge_density':  (magnitude > 30).mean(),   # fraction of pixels with strong edges (threshold=30)
        'edge_p90':      np.percentile(magnitude, 90)  # 90th percentile edge strength
    }

# Build feature DataFrame
rows = []
for img, label in zip(all_imgs, labels):
    row = {'label': label}
    row.update(edge_features(img))
    rows.append(row)

edge_df = pd.DataFrame(rows)

# Print class comparison
print("Edge feature means by class (0=clean, 1=defect):\n")
print(edge_df.groupby('label').mean().round(3).to_string())

print("\nFull edge feature matrix:")
print(edge_df.round(3).to_string(index=False))

# Import numpy, pandas, and scipy
import numpy as np
import pandas as pd
from scipy.ndimage import convolve

# Sobel kernels (same as previous block)
sobel_x = np.array([[-1,0,1],[-2,0,2],[-1,0,1]], dtype=float)
sobel_y = np.array([[-1,-2,-1],[0,0,0],[1,2,1]],  dtype=float)

def compute_hog(img, n_cells=4, n_bins=8):
    """
    Simplified HOG descriptor.
    Divides the image into an n_cells x n_cells grid of cells.
    For each cell, computes an n_bins orientation histogram of gradient directions.
    Returns a flat feature vector of length n_cells * n_cells * n_bins.
    """
    h, w = img.shape                        # image height and width
    cell_h = h // n_cells                   # height of each cell in pixels
    cell_w = w // n_cells                   # width of each cell in pixels

    # Compute gradient magnitude and angle at every pixel
    gx        = convolve(img.astype(float), sobel_x)        # horizontal gradient
    gy        = convolve(img.astype(float), sobel_y)        # vertical gradient
    magnitude = np.sqrt(gx**2 + gy**2)                     # gradient strength
    angle     = np.degrees(np.arctan2(gy, gx)) % 180       # gradient angle 0–180 degrees (unsigned)

    hog_vector = []  # will hold concatenated cell histograms

    for i in range(n_cells):          # row of cells
        for j in range(n_cells):      # column of cells
            # Extract the patch of magnitude and angle values for this cell
            cell_mag   = magnitude[i*cell_h:(i+1)*cell_h, j*cell_w:(j+1)*cell_w]
            cell_angle = angle    [i*cell_h:(i+1)*cell_h, j*cell_w:(j+1)*cell_w]

            # Build weighted orientation histogram: angles binned 0–180, weighted by magnitude
            hist, _ = np.histogram(cell_angle.flatten(),
                                   bins=n_bins,
                                   range=(0, 180),
                                   weights=cell_mag.flatten())  # magnitude-weighted

            # Normalise cell histogram to unit vector (L2 norm)
            norm = np.linalg.norm(hist) + 1e-9
            hog_vector.extend((hist / norm).tolist())  # append normalised histogram

    return np.array(hog_vector)  # returns flat array of length n_cells^2 * n_bins

# Simulate 6 images: 2 scratch-type defects, 2 dent-type, 2 clean
np.random.seed(21)
scratch_imgs = [np.random.normal(160, 6, (32, 32)) for _ in range(2)]
for img in scratch_imgs:                          # add horizontal scratch lines
    for _ in range(4):
        r = np.random.randint(2, 30)
        img[r:r+1, :] += 100                      # bright horizontal stripe

dent_imgs = [np.random.normal(160, 6, (32, 32)) for _ in range(2)]
for img in dent_imgs:                             # add circular dark dent
    cx, cy = 16, 16
    for r in range(32):
        for c in range(32):
            if (r-cx)**2 + (c-cy)**2 < 36:        # pixels within radius 6
                img[r, c] -= 60                    # dark circular patch

clean_imgs  = [np.random.normal(180, 5, (32, 32)) for _ in range(2)]

all_imgs    = [img.clip(0, 255) for img in scratch_imgs + dent_imgs + clean_imgs]
labels      = ['scratch','scratch','dent','dent','clean','clean']

# Compute HOG for each image — 4x4 cells, 8 orientation bins = 128-dim vector
hog_vectors = [compute_hog(img) for img in all_imgs]
hog_df      = pd.DataFrame(hog_vectors, columns=[f'hog_{i}' for i in range(128)])
hog_df['label'] = labels

# Report feature vector shape and mean per class for the first 8 dimensions
print(f"HOG feature vector length: {len(hog_vectors[0])} dimensions")
print(f"(4 cells × 4 cells × 8 orientation bins = 128 features per image)\n")
print("Mean HOG values (first 8 dims) per defect type:")
print(hog_df.groupby('label')[['hog_0','hog_1','hog_2','hog_3',
                                'hog_4','hog_5','hog_6','hog_7']].mean().round(3).to_string())