Update app.py

app.py

@@ -1,5 +1,10 @@
+#!/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
@@ -11,13 +16,19 @@ 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)
+        plt.plot(feature, label=f'Feature {i+1}')
     plt.title(title)
+    plt.legend()
     plt.show()
 
 # Define directories for grass and wood images
@@ -27,67 +38,76 @@ 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 using glob and convert them to grayscale."""
+    """Load images from a directory and convert them to grayscale."""
     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}")
-    
+    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)
     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:
+     """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)
+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
 
-# 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)
+wood_lbp_features = extract_lbp_features(wood_dataset) 
+
+####TESTING...
 
 # GLCM features for grass and wood
 plot_features(np.array(grass_glcm_features), "GLCM Features for Grass Images")
@@ -95,24 +115,36 @@ 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")
+plot_features(np.array(wood_lbp_features), "LBP Features for Wood Images") 
+
+
+###MATPLOTLIB....
 
 # 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)
@@ -126,7 +158,9 @@ 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()
@@ -139,15 +173,18 @@ 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}%")
@@ -163,51 +200,113 @@ 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"],
-        p=lbp_grid_search.best_params_["p"]
-    )
+    
+    lbp_classifier = KNeighborsClassifier(n_neighbors=lbp_grid_search.best_params_['n_neighbors'])
     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
 
-# 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)
+# 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)
     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"),
-        gr.Dropdown(choices=["GLCM", "LBP"], label="Algorithm"),
-    ],
+        gr.Image(type="numpy", label="Upload an Image"),  # Image input, passing as NumPy array
+        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[ ]:
+
+
+
+