Update app.py

app.py

@@ -1,10 +1,5 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-# In[55]:
-
-
 import cv2
+import glob
 import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
@@ -14,23 +9,18 @@ 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 sklearn.neighbors import KNeighborsClassifier
 from skimage.feature import local_binary_pattern
-import os 
-
-
-# In[56]:
 
 
 # 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, label=f'Feature {i+1}')
+        plt.plot(feature)
     plt.title(title)
-    plt.legend()
     plt.show()
 
+
 # Define directories for grass and wood images
 grass_dir = "images/Grass/Train_Grass"
 wood_dir = "images/Wood/Train_Wood"
@@ -38,76 +28,71 @@ wood_dir = "images/Wood/Train_Wood"
 # Constants for LBP
 RADIUS = 1
 N_POINTS = 12 * RADIUS
-TARGET_SIZE = (30,30)
+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 and convert them to grayscale."""
+    """Load images from a directory using glob and convert them to grayscale."""
     dataset = []
-    for filename in os.listdir(directory):
-        if filename.endswith(('.jpg', '.png', '.jpeg')):
-            img_path = os.path.join(directory, filename)  # Construct full image path
-            img = cv2.imread(img_path)  # Read the image
-            if img is not None:
-                # resized_image = cv2.resize(img, TARGET_SIZE, interpolation=cv2.INTER_AREA)   #resize the images 
-                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)
+    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}")
+    
     return dataset
 
 
-# In[57]:
-
-
 def calc_glcm_features(images):
     features = []
     for img in images:
         glcm = graycomatrix(img, distances, 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]
+        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]) 
+        features.append([contrast, dissimilarity, homogeneity, energy, correlation])
     return features
 
-# Function to extract LBP features from an image
-def extract_lbp_features(images):
-     """Extract LBP features from a list of images."""
 
-     lbp_features = []
-     for image in images:
+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
-    
+    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)  # Label all grass images as 0
-wood_labels = [1] * len(wood_dataset)    # Label all wood images as 1
+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) 
-
-
+wood_glcm_features = calc_glcm_features(wood_dataset)
 
 grass_lbp_features = extract_lbp_features(grass_dataset)
-wood_lbp_features = extract_lbp_features(wood_dataset) 
-
-####TESTING...
+wood_lbp_features = extract_lbp_features(wood_dataset)
 
 # GLCM features for grass and wood
 plot_features(np.array(grass_glcm_features), "GLCM Features for Grass Images")
@@ -115,36 +100,24 @@ plot_features(np.array(wood_glcm_features), "GLCM Features for Wood 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") 
-
-
-###MATPLOTLIB....
+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 
+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 
+lbp_labels = grass_labels + wood_labels
 
 # Convert to numpy array
 lbp_features = np.array(lbp_features)
 
-print("block 2 run") 
-
-
-# In[58]:
-
-
 num_grass = len(grass_dataset)  # Number of grass images
-num_wood = len(wood_dataset) # Number of wood 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)
@@ -158,9 +131,7 @@ glcm_accuracy_list = []
 lbp_accuracy_list = []
 
 # Parameter tuning using GridSearchCV for KNN classifier
-param_grid = {'n_neighbors': [3, 5, 7],
-             'p' : [1,2]
-             }
+param_grid = {"n_neighbors": [3, 5, 7], "p": [1, 2]}
 
 # GLCM Classifier Training and Evaluation
 glcm_knn = KNeighborsClassifier()
@@ -173,18 +144,15 @@ print("Best parameters for GLCM KNN:", glcm_grid_search.best_params_)
 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 = 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)
-    
-    # Optionally: Print confusion matrix and precision
-
-    # print(f"Confusion Matrix for GLCM Fold:\n{confusion_matrix(y_test, y_pred)}")
-    # print(f"Classification Report for GLCM Fold:\n{classification_report(y_test, y_pred, zero_division=0)}")
 
 # Print overall GLCM accuracy
 print(f"GLCM Cross-validated accuracy: {np.mean(glcm_accuracy_list) * 100:.2f}%")
@@ -200,113 +168,51 @@ print("Best parameters for LBP KNN:", lbp_grid_search.best_params_)
 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'])
+
+    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)
-    
-    # Optionally: Print confusion matrix and precision
-
-    # print(f"Confusion Matrix for LBP Fold:\n{confusion_matrix(y_test, y_pred)}")
-    # print(f"Classification Report for LBP Fold:\n{classification_report(y_test, y_pred, zero_division=0)}")
 
 # Print overall LBP accuracy
 print(f"LBP Cross-validated accuracy: {np.mean(lbp_accuracy_list) * 100:.2f}%")
 
+# 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
 
-# In[59]:
-
-
-def classify_texture(image, algorithm):
-    # Resize and convert the image to grayscale
-    resized_image = cv2.resize(image, TARGET_SIZE, interpolation=cv2.INTER_AREA)
-    gray_image = cv2.cvtColor(resized_image, cv2.COLOR_BGR2GRAY)  # Convert to grayscale
-
-    # Select the feature extraction method based on the algorithm
-    if algorithm == 'GLCM':
-        features = calc_glcm_features([gray_image])  # Use parentheses, pass as a list
-        prediction = glcm_grid_search.predict(features)
-    elif algorithm == 'LBP':
-        features = extract_lbp_features([gray_image])
-        prediction = lbp_grid_search.predict(features)
+# Define the Gradio interface
+def classify_uploaded_image(image, algorithm):
+    image = preprocess_image(np.array(image, dtype=np.uint8))  # Preprocess uploaded image
+
+    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)
     else:
         raise ValueError(f"Algorithm '{algorithm}' is not recognized.")
 
     return "Grass" if prediction[0] == 0 else "Wood"
 
-# Function to highlight regions
-def highlight_texture(image, result):
-    overlay = image.copy()
-    if result == "Grass":
-        overlay[:, :] = [0, 255, 0]  # Highlight grass regions in green
-    else:
-        overlay[:, :] = [165, 42, 42]  # Highlight wood regions in brown
-    return overlay
-
-
-# Define the Gradio interface
-def classify_uploaded_image(image, algorithm):
-    # Convert the uploaded image to a format that OpenCV can process
-    image = np.array(image, dtype=np.uint8)  # Ensure correct type
-
-    # Call the classify_texture function
-    result = classify_texture(image, algorithm)
-    
-    return result
-
 # Gradio Interface Setup
 iface = gr.Interface(
-    fn=classify_uploaded_image, 
+    fn=classify_uploaded_image,
     inputs=[
-        gr.Image(type="numpy", label="Upload an Image"),  # Image input, passing as NumPy array
-        gr.Dropdown(choices=["GLCM", "LBP"], label="Algorithm")
-    ], 
+        gr.Image(type="numpy", label="Upload an Image"),
+        gr.Dropdown(choices=["GLCM", "LBP"], label="Algorithm"),
+    ],
     outputs="text",
-    title="Texture Classification"
+    title="Texture Classification",
 )
 
 # Launch the interface
 iface.launch()
-
-
-# # Create Gradio interface
-# iface = gr.Interface(
-#     fn=lambda image, algorithm: (result := classify_texture(image, algorithm), highlight_texture(image, result)),
-#     inputs=[
-#         gr.Image(type='numpy', label="Upload Image"),
-#         gr.Radio(choices=['GLCM', 'LBP'], label="Select Algorithm")
-#     ],
-#     outputs=[gr.Textbox(label="Classification Result"), gr.Image(label="Highlighted Result")],
-#     title="Texture Classification",
-#     description="Upload an image and select the classification algorithm (GLCM or LBP). The result will show the classification and highlight the detected texture."
-# )
-
-# # Launch the interface
-# iface.launch()
-
-
-# In[54]:
-
-
-# Example of testing with a specific image
-test_grass_image = cv2.imread('grass.jpg')
-test_wood_image = cv2.imread('wood.jpg')
-
-print("Testing with Grass Image Prediction:", classify_texture(test_grass_image, 'LBP'))
-print("Testing with Wood Image Prediction:", classify_texture(test_wood_image, 'LBP'))
-
-
-# In[ ]:
-
-
-
-
-
-# In[ ]:
-
-
-
-