Task 1 - The Classical Computer Vision Baseline

# folder: ./NEU-DET/train/

import os
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix


# we have to loop through NEU-DET/train/{all 6 folders} and add the filepaths of all images inside
image_list = []
path_train = '../NEU-DET/train/images'
path_validation = '../NEU-DET/validation/images'

# get images from training
for folder in os.listdir(path_train):
    for file in os.listdir(os.path.join(path_train, folder)):
        image_list.append({'filepath': os.path.join(path_train, folder, file), 'type': file.split('_')[0], 'id': file.split('_')[-1].split('.')[0]})

# get images from validation
for folder in os.listdir(path_validation):
    for file in os.listdir(os.path.join(path_validation, folder)):
        image_list.append({'filepath': os.path.join(path_validation, folder, file), 'type': file.split('_')[0], 'id': file.split('_')[-1].split('.')[0]})

# create dataframe
df = pd.DataFrame(image_list)

# 80/20 split
train_df, val_df = train_test_split(df, test_size=0.2, stratify=df['type'], random_state=7)

print("training set containing", len(train_df), "images: \n", train_df.head(), "\n")
print("validation set containing", len(val_df), "images: \n", val_df.head())

# get an array of the different defect types
types = df['type'].unique()

# and plot the first image of each type
fig, axs = plt.subplots(2, 3, figsize=(15, 10))
for i, t in enumerate(types):
    img = plt.imread(df[df['type'] == t].iloc[0]['filepath'])
    axs[i // 3, i % 3].imshow(img)
    axs[i // 3, i % 3].set_title(t)
    axs[i // 3, i % 3].axis('off')
plt.show()

from skimage.feature import hog
from skimage.io import imread
from skimage.color import rgb2gray

def extract_hog(filepath):
    img = imread(filepath)
    if img.ndim == 3:
        img = rgb2gray(img)
    features = hog(img, 
                   orientations=8, 
                   pixels_per_cell=(8, 8), 
                   cells_per_block=(2, 2)
                )
    return features

import numpy as np

X_train = np.vstack([extract_hog(fp) for fp in train_df["filepath"]])
y_train = train_df["type"].values

X_test = np.vstack([extract_hog(fp) for fp in val_df["filepath"]])
y_test = val_df["type"].values

# add these to the dataframe as well
train_df['hog_features'] = list(X_train)
val_df['hog_features'] = list(X_test)

print("the head of the train df: \n", train_df.head())

from skimage import exposure

# make a grid 2 rows x 3 columns (one per defect type)
fig, axs = plt.subplots(2, 3, figsize=(15, 10))

for i, t in enumerate(types):
    # get first image for defect type
    fp = df[df['type'] == t].iloc[0]['filepath']
    img = imread(fp)
    if img.ndim == 3:
        img = rgb2gray(img)
    
    # compute HOG features with visualization
    features, hog_image = hog(
        img,
        orientations=9,
        pixels_per_cell=(8, 8),
        cells_per_block=(2, 2),
        block_norm='L2-Hys',
        visualize=True
    )
    
    # rescale HOG image for display
    hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, hog_image.max()))
    
    # plot HOG map
    axs[i // 3, i % 3].imshow(hog_image_rescaled, cmap='gray')
    axs[i // 3, i % 3].set_title(f"{t}")
    axs[i // 3, i % 3].axis('off')

fig.suptitle("HOG Features for Different Defect Types")
plt.tight_layout()
plt.show()

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score

# Prepare features and labels from the DataFrames
X_rf_train = np.vstack(train_df['hog_features'].values)
y_rf_train = train_df['type'].values

X_rf_val = np.vstack(val_df['hog_features'].values)
y_rf_val = val_df['type'].values

# Train Random Forest
rf = RandomForestClassifier(n_estimators=200, random_state=1)
rf.fit(X_rf_train, y_rf_train)

# Predict on validation set
y_pred = rf.predict(X_rf_val)

# Print accuracy and classification report
print("Validation Accuracy:", accuracy_score(y_rf_val, y_pred))
print("classification report: \n", classification_report(y_rf_val, y_pred))

cm = confusion_matrix(y_rf_val, y_pred)
cm_df = pd.DataFrame(cm, index=types, columns=types)
print("Confusion Matrix:\n", cm_df)

from skimage.io import imread
from skimage.color import rgb2gray
from skimage.feature import graycomatrix, graycoprops
import numpy as np

# function to extract GLCM features, 
def extract_glcm(filepath, distances=[1,2,4,8], angles=[0, np.pi/4, np.pi/2, 3*np.pi/4]):

    img = imread(filepath)
    if img.ndim == 3:
        img = rgb2gray(img)
    
    # Convert to 8-bit grayscale (0-255)
    img = (img * 255).astype(np.uint8)
    
    # Compute GLCM
    glcm = graycomatrix(img, distances=distances, angles=angles, symmetric=True, normed=True)
    
    # Extract features
    feats = []
    props = ['contrast', 'dissimilarity', 'homogeneity', 'energy', 'correlation']
    for prop in props:
        vals = graycoprops(glcm, prop)
        feats.extend(vals.flatten())
    
    return np.array(feats)

# Training set
X_glcm_train = np.vstack([extract_glcm(fp) for fp in train_df['filepath']])
train_df['glcm_features'] = list(X_glcm_train)

# Validation/test set
X_glcm_val = np.vstack([extract_glcm(fp) for fp in val_df['filepath']])
val_df['glcm_features'] = list(X_glcm_val)

print("all images processed, head of train df: \n", train_df.head())

# Concatenate HOG + GLCM for each image
X_train_combined = np.vstack([
    np.hstack((hog_feat, glcm_feat))
    for hog_feat, glcm_feat in zip(train_df['hog_features'], train_df['glcm_features'])
])

X_val_combined = np.vstack([
    np.hstack((hog_feat, glcm_feat))
    for hog_feat, glcm_feat in zip(val_df['hog_features'], val_df['glcm_features'])
])

# Labels
y_train = train_df['type'].values
y_val = val_df['type'].values

# Initialize RF (class_weight='balanced' is optional if some classes are rarer)
rf = RandomForestClassifier(n_estimators=100, random_state=1)

# Train
rf.fit(X_train_combined, y_train)

# Predict on validation set
y_pred = rf.predict(X_val_combined)

# Print accuracy and classification report
print("Validation Accuracy:", accuracy_score(y_val, y_pred))
print(classification_report(y_val, y_pred))

# add classification report to df  
report = classification_report(y_val, y_pred, output_dict=True)
report_df = pd.DataFrame(report).transpose()

# get confusion matrix
cm = confusion_matrix(y_val, y_pred)
cm_df = pd.DataFrame(cm, index=types, columns=types)
print("Confusion Matrix:\n", cm_df)

# how many input features for RF
print("Number of input variables for RF:", X_train_combined.shape[1])

# save report_df
report_df.to_csv('task1_classification_report.csv', index=True)

# Save all dataframes to be used in Task 2 and 3.

train_df.to_csv('train_dataframe.csv')
val_df.to_csv('val_dataframe.csv')

# save confusion matrix and report to file
cm_df.to_csv('confusion_matrix.csv')

# generate an interactive plot, where we can scroll through all misclassified images and see what index they are at
import ipywidgets as widgets
from IPython.display import display

# get indices of misclassified images
misclassified_indices = np.where(y_val != y_pred)[0]

# interactive function to display image and its info
def show_image(index):
    if index < 0 or index >= len(misclassified_indices):
        print("Index out of range")
        return
    actual_index = misclassified_indices[index]
    img = imread(val_df.iloc[actual_index]['filepath'])
    plt.imshow(img, cmap='gray')
    plt.title(f"Index: {actual_index}, Actual: {y_val[actual_index]}, Predicted: {y_pred[actual_index]}")
    plt.axis('off')
    plt.show()
slider = widgets.IntSlider(value=0, min=0, max=len(misclassified_indices)-1, step=1, description='Image Index:')
widgets.interact(show_image, index=slider)

# 9 - big dark patches
# 11 - scratches/inclusion
# 21

# make a new df of misclassified images indices 9 11 and 21
actual_indices = misclassified_indices[[9, 11, 21]].copy()
misclassified_samples = val_df.iloc[actual_indices]
misclassified_samples['predicted_type'] = y_pred[actual_indices]

misclassified_samples.to_csv('misclassified_images_1.csv', index=False)