Update app.py

app.py

@@ -1,218 +1,161 @@
-import cv2
 import glob
-import gradio as gr
+import cv2
 import numpy as np
+import gradio as gr
 import matplotlib.pyplot as plt
-from sklearn.model_selection import KFold
-from skimage.feature import graycomatrix, graycoprops
+from sklearn.model_selection import KFold, GridSearchCV
 from sklearn.neighbors import KNeighborsClassifier
-from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
-import pandas as pd
-from sklearn.model_selection import GridSearchCV
-from skimage.feature import local_binary_pattern
-
-
-# Visualize GLCM features for grass and wood
-def plot_features(features, title):
-    plt.figure(figsize=(10, 6))
-    for i, feature in enumerate(features.T):  # Transpose to plot feature by feature
-        plt.plot(feature)
-    plt.title(title)
-    plt.show()
-
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix,
+    precision_score,
+    recall_score,
+    f1_score,
+)
+from skimage.feature import graycomatrix, graycoprops, local_binary_pattern
 
 # Define directories for grass and wood images
 grass_dir = "images/Grass/Train_Grass"
 wood_dir = "images/Wood/Train_Wood"
 
-# Constants for LBP
+# Constants for Local Binary Pattern (LBP) and Gray Level Co-occurrence Matrix (GLCM)
 RADIUS = 1
 N_POINTS = 12 * RADIUS
 TARGET_SIZE = (30, 30)
-
-# for GLCM
 distances = [1]
 angles = [0]
 
-
-# Use glob to load images from the directory
 def load_and_convert_images(directory):
-    """Load images from a directory using glob and convert them to grayscale."""
+    """Load images from a specified directory using glob and convert them to grayscale.
+
+    Args:
+        directory (str): The path to the image directory.
+
+    Returns:
+        list: A list of resized grayscale images.
+    """
     dataset = []
-    image_paths = glob.glob(f"{directory}/*.jpg") + glob.glob(f"{directory}/*.png") + glob.glob(f"{directory}/*.jpeg")
-    
-    for img_path in image_paths:
-        img = cv2.imread(img_path)  # Read the image
-        if img is not None:
-            gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # Convert to grayscale
-            resized_image = cv2.resize(gray_image, TARGET_SIZE, interpolation=cv2.INTER_AREA)
-            dataset.append(resized_image)
-        else:
-            print(f"Warning: Failed to load image {img_path}")
-    
+    # Use glob to find image files in the directory
+    for img_path in glob.glob(f"{directory}/*.*"):
+        if img_path.endswith((".jpg", ".png", ".jpeg")):
+            img = cv2.imread(img_path)  # Read the image
+            if img is not None:
+                # Convert to grayscale and resize the image
+                gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+                resized_image = cv2.resize(gray_image, TARGET_SIZE, interpolation=cv2.INTER_AREA)
+                dataset.append(resized_image)
     return dataset
 
+# Load datasets using glob
+grass_dataset = load_and_convert_images(grass_dir)
+wood_dataset = load_and_convert_images(wood_dir)
 
 def calc_glcm_features(images):
-    features = []
-    for img in images:
-        glcm = graycomatrix(img, distances, angles, symmetric=True, normed=True)
+    """Calculate GLCM features for a list of images.
 
-        contrast = graycoprops(glcm, "contrast")[0, 0]
-        dissimilarity = graycoprops(glcm, "dissimilarity")[0, 0]
-        homogeneity = graycoprops(glcm, "homogeneity")[0, 0]
-        energy = graycoprops(glcm, "energy")[0, 0]
-        correlation = graycoprops(glcm, "correlation")[0, 0]
+    Args:
+        images (list): A list of grayscale images.
 
+    Returns:
+        list: A list of GLCM features for each image.
+    """
+    features = []
+    for image in images:
+        glcm = graycomatrix(image, distances=distances, angles=angles, symmetric=True, normed=True)
+        contrast = graycoprops(glcm, 'contrast')[0, 0]
+        dissimilarity = graycoprops(glcm, 'dissimilarity')[0, 0]
+        homogeneity = graycoprops(glcm, 'homogeneity')[0, 0]
+        energy = graycoprops(glcm, 'energy')[0, 0]
+        correlation = graycoprops(glcm, 'correlation')[0, 0]
         features.append([contrast, dissimilarity, homogeneity, energy, correlation])
     return features
 
-
 def extract_lbp_features(images):
-    """Extract LBP features from a list of images."""
-    lbp_features = []
-    for image in images:
-        lbp = local_binary_pattern(image, N_POINTS, RADIUS, method="uniform")
-        n_bins = int(lbp.max() + 1)
-        lbp_hist, _ = np.histogram(lbp, bins=n_bins, range=(0, n_bins), density=True)
-        lbp_features.append(lbp_hist)
-    return lbp_features
-
-
-# Load datasets
-grass_dataset = load_and_convert_images(grass_dir)
-wood_dataset = load_and_convert_images(wood_dir)
-
-# Create labels (0 for grass, 1 for wood)
-grass_labels = [0] * len(grass_dataset)
-wood_labels = [1] * len(wood_dataset)
-
-# Calculate features
-grass_glcm_features = calc_glcm_features(grass_dataset)
-wood_glcm_features = calc_glcm_features(wood_dataset)
-
-grass_lbp_features = extract_lbp_features(grass_dataset)
-wood_lbp_features = extract_lbp_features(wood_dataset)
+    """Extract LBP features for a list of images.
 
-# GLCM features for grass and wood
-plot_features(np.array(grass_glcm_features), "GLCM Features for Grass Images")
-plot_features(np.array(wood_glcm_features), "GLCM Features for Wood Images")
+    Args:
+        images (list): A list of grayscale images.
 
-# LBP features for grass and wood
-plot_features(np.array(grass_lbp_features), "LBP Features for Grass Images")
-plot_features(np.array(wood_lbp_features), "LBP Features for Wood Images")
-
-# Combine labels and features for GLCM classifier
-glcm_features = grass_glcm_features + wood_glcm_features
-glcm_labels = grass_labels + wood_labels
-
-# Convert to numpy array
-glcm_features = np.array(glcm_features)
-
-# Prepare labels and features for LBP classifier
-lbp_features = grass_lbp_features + wood_lbp_features
-lbp_labels = grass_labels + wood_labels
-
-# Convert to numpy array
-lbp_features = np.array(lbp_features)
-
-num_grass = len(grass_dataset)  # Number of grass images
-num_wood = len(wood_dataset)  # Number of wood images
-
-# Create the labels: 0 for grass, 1 for wood
-y = np.array([0] * num_grass + [1] * num_wood)
-
-# Define KFold cross-validation
-k = 5
-kf = KFold(n_splits=k, shuffle=True, random_state=42)
-
-# Store results for GLCM and LBP classifiers
-glcm_accuracy_list = []
-lbp_accuracy_list = []
-
-# Parameter tuning using GridSearchCV for KNN classifier
-param_grid = {"n_neighbors": [3, 5, 7], "p": [1, 2]}
-
-# GLCM Classifier Training and Evaluation
-glcm_knn = KNeighborsClassifier()
-glcm_grid_search = GridSearchCV(glcm_knn, param_grid, cv=kf)
-glcm_grid_search.fit(glcm_features, y)
-
-print("Best parameters for GLCM KNN:", glcm_grid_search.best_params_)
-
-# Perform cross-validation and evaluate GLCM classifier
-for train_index, test_index in kf.split(glcm_features):
-    x_train, x_test = glcm_features[train_index], glcm_features[test_index]
-    y_train, y_test = y[train_index], y[test_index]
-
-    glcm_classifier = KNeighborsClassifier(
-        n_neighbors=glcm_grid_search.best_params_["n_neighbors"]
-    )
-    glcm_classifier.fit(x_train, y_train)
-    y_pred = glcm_classifier.predict(x_test)
-
-    accuracy = accuracy_score(y_test, y_pred)
-    glcm_accuracy_list.append(accuracy)
-
-# Print overall GLCM accuracy
-print(f"GLCM Cross-validated accuracy: {np.mean(glcm_accuracy_list) * 100:.2f}%")
-
-# LBP Classifier Training and Evaluation
-lbp_knn = KNeighborsClassifier()
-lbp_grid_search = GridSearchCV(lbp_knn, param_grid, cv=kf)
-lbp_grid_search.fit(lbp_features, y)
-
-print("Best parameters for LBP KNN:", lbp_grid_search.best_params_)
-
-# Perform cross-validation and evaluate LBP classifier
-for train_index, test_index in kf.split(lbp_features):
-    x_train, x_test = lbp_features[train_index], lbp_features[test_index]
-    y_train, y_test = y[train_index], y[test_index]
-
-    lbp_classifier = KNeighborsClassifier(
-        n_neighbors=lbp_grid_search.best_params_["n_neighbors"],
-        p=lbp_grid_search.best_params_["p"]
-    )
-    lbp_classifier.fit(x_train, y_train)
-    y_pred = lbp_classifier.predict(x_test)
-
-    accuracy = accuracy_score(y_test, y_pred)
-    lbp_accuracy_list.append(accuracy)
-
-# Print overall LBP accuracy
-print(f"LBP Cross-validated accuracy: {np.mean(lbp_accuracy_list) * 100:.2f}%")
+    Returns:
+        list: A list of LBP features for each image.
+    """
+    features = []
+    for image in images:
+        lbp = local_binary_pattern(image, N_POINTS, RADIUS, method="uniform")
+        lbp_hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, N_POINTS + 3), range=(0, N_POINTS + 2))
+        lbp_hist = lbp_hist.astype("float")
+        lbp_hist /= lbp_hist.sum()  # Normalize the histogram
+        features.append(lbp_hist)
+    return features
 
-# Preprocess uploaded image for classification
-def preprocess_image(image):
-    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # Convert to grayscale
-    resized_image = cv2.resize(gray_image, TARGET_SIZE, interpolation=cv2.INTER_AREA)  # Resize to match training size
-    return resized_image
+# Train classifiers (for example purposes, using KNN)
+X = np.concatenate([grass_dataset, wood_dataset])
+y = np.concatenate([np.zeros(len(grass_dataset)), np.ones(len(wood_dataset))])  # Labels: 0 for Grass, 1 for Wood
+
+# Extract GLCM and LBP features
+glcm_features = calc_glcm_features(X)
+lbp_features = extract_lbp_features(X)
+
+# KFold cross-validation
+kf = KFold(n_splits=5)
+
+# Example: KNN classifier for GLCM features
+knn_glcm = KNeighborsClassifier(n_neighbors=3)
+knn_glcm.fit(glcm_features, y)
+
+# Example: KNN classifier for LBP features
+knn_lbp = KNeighborsClassifier(n_neighbors=3)
+knn_lbp.fit(lbp_features, y)
+
+def classify_texture(image, method):
+    """Classify the texture of the uploaded image as grass or wood using the selected method.
+
+    Args:
+        image (numpy.ndarray): The uploaded image to classify.
+        method (str): The feature extraction method ('GLCM' or 'LBP').
+
+    Returns:
+        Tuple[str, numpy.ndarray]: The classification result ('Grass' or 'Wood') and the highlighted image.
+    """
+    # Pre-process the image
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    resized_image = cv2.resize(gray_image, TARGET_SIZE, interpolation=cv2.INTER_AREA)
+
+    # Extract features based on the selected method
+    if method == "GLCM":
+        feature = calc_glcm_features([resized_image])
+        prediction = knn_glcm.predict(feature)
+    elif method == "LBP":
+        feature = extract_lbp_features([resized_image])
+        prediction = knn_lbp.predict(feature)
+    else:
+        raise ValueError("The method is not recognized")
 
-# Define the Gradio interface
-def classify_uploaded_image(image, algorithm):
-    image = preprocess_image(np.array(image, dtype=np.uint8))  # Preprocess uploaded image
+    # Classify the prediction
+    result = "Grass" if prediction == 0 else "Wood"
 
-    if algorithm == "GLCM":
-        features = calc_glcm_features([image])  # Use parentheses, pass as a list
-        prediction = glcm_classifier.predict(features)
-    elif algorithm == "LBP":
-        features = extract_lbp_features([image])
-        prediction = lbp_classifier.predict(features)
+    # Highlight the image based on the classification
+    if result == "Grass":
+        highlighted_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert to RGB for displaying
+        highlighted_image[:] = [0, 255, 0]  # Highlight in green
     else:
-        raise ValueError(f"Algorithm '{algorithm}' is not recognized.")
+        highlighted_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        highlighted_image[:] = [165, 42, 42]  # Highlight in brown
 
-    return "Grass" if prediction[0] == 0 else "Wood"
+    return result, highlighted_image
 
-# Gradio Interface Setup
+# Gradio interface setup with a dropdown for method selection
 iface = gr.Interface(
-    fn=classify_uploaded_image,
+    fn=classify_texture,
     inputs=[
-        gr.Image(type="numpy", label="Upload an Image"),
-        gr.Dropdown(choices=["GLCM", "LBP"], label="Algorithm"),
+        gr.Image(type="numpy", label="Upload Image"),
+        gr.Dropdown(choices=["GLCM", "LBP"], label="Select Feature Extraction Method"),
     ],
-    outputs="text",
+    outputs=["text", gr.Image(type="numpy", label="Highlighted Image")],
     title="Texture Classification",
+    description="Upload an image of grass or wood to classify the texture. Select GLCM or LBP as the method.",
 )
 
-# Launch the interface
+# Launch Gradio interface
 iface.launch()