Update app.py

app.py

@@ -26,6 +26,7 @@ TARGET_SIZE = (30, 30)
 distances = [1]
 angles = [0]
 
+
 def load_and_convert_images(directory):
     """Load images from a specified directory using glob and convert them to grayscale.
 
@@ -36,49 +37,23 @@ def load_and_convert_images(directory):
         list: A list of resized grayscale images.
     """
     dataset = []
-    # 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)
+                resized_image = cv2.resize(
+                    gray_image, TARGET_SIZE, interpolation=cv2.INTER_AREA
+                )
                 dataset.append(resized_image)
     return dataset
 
-# Ensure that both datasets contain 2D arrays (grayscale images)
-def check_and_reshape(dataset):
-    """Ensure all images in the dataset are 2D arrays.
-    
-    Args:
-        dataset (list): A list of images.
-        
-    Returns:
-        list: A list of reshaped images to ensure they are all 2D.
-    """
-    reshaped_dataset = []
-    for img in dataset:
-        if img.ndim == 3:  # If the image has 3 dimensions (like RGB), convert it to grayscale
-            gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-            reshaped_dataset.append(gray_img)
-        elif img.ndim == 2:  # If it's already grayscale (2D), just append it
-            reshaped_dataset.append(img)
-        else:
-            raise ValueError("Unexpected image dimension: {}".format(img.ndim))
-    return reshaped_dataset
 
 # Load datasets using glob
 grass_dataset = load_and_convert_images(grass_dir)
 wood_dataset = load_and_convert_images(wood_dir)
 
-# Apply the reshaping to both datasets
-grass_dataset = check_and_reshape(grass_dataset)
-wood_dataset = check_and_reshape(wood_dataset)
-
-# Now concatenate the datasets
-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
 
 def calc_glcm_features(images):
     """Calculate GLCM features for a list of images.
@@ -90,48 +65,181 @@ def calc_glcm_features(images):
         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]
+    for img in images:
+        glcm = graycomatrix(img, distances, angles, symmetric=True, normed=True)
+
+        # Calculate GLCM properties
+        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
 
+
+# Calculate GLCM features for grass and wood datasets
+grass_glcm_features = calc_glcm_features(grass_dataset)
+wood_glcm_features = calc_glcm_features(wood_dataset)
+
+
 def extract_lbp_features(images):
-    """Extract LBP features for a list of images.
+    """Extract LBP features from a list of images.
 
     Args:
         images (list): A list of grayscale images.
 
     Returns:
-        list: A list of LBP features for each image.
+        list: A list of LBP histograms for each image.
     """
-    features = []
+    lbp_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
+        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
+
+
+# Extract LBP features for grass and wood datasets
+grass_lbp_features = extract_lbp_features(grass_dataset)
+wood_lbp_features = extract_lbp_features(wood_dataset)
+
+# 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
+
+# Combine features and labels for GLCM classifier
+glcm_features = np.array(grass_glcm_features + wood_glcm_features)
+glcm_labels = grass_labels + wood_labels
+
+# Prepare labels and features for LBP classifier
+lbp_features = np.array(grass_lbp_features + wood_lbp_features)
+lbp_labels = grass_labels + wood_labels
+
+# Number of images
+num_grass = len(grass_dataset)
+num_wood = len(wood_dataset)
+
+# Define labels for classification
+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)
 
-# Train classifiers (for example purposes, using KNN)
-glcm_features = calc_glcm_features(X)
-lbp_features = extract_lbp_features(X)
+# Store results for GLCM and LBP classifiers
+glcm_metrics = {"accuracy": [], "precision": [], "recall": [], "f1_score": []}
+lbp_metrics = {"accuracy": [], "precision": [], "recall": [], "f1_score": []}
+y_true_glcm, y_true_lbp = [], []
+y_pred_glcm, y_pred_lbp = [], []
 
-# KFold cross-validation
-kf = KFold(n_splits=5)
+# Parameter tuning using GridSearchCV for KNN classifier
+param_grid = {"n_neighbors": [3, 5, 7], "p": [1, 2]}
 
-# Example: KNN classifier for GLCM features
-knn_glcm = KNeighborsClassifier(n_neighbors=3)
-knn_glcm.fit(glcm_features, y)
+# 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)
+
+# 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)
+
+    # Collect true and predicted labels
+    y_true_glcm.extend(y_test)
+    y_pred_glcm.extend(y_pred)
+
+    # Calculate and store metrics
+    accuracy = accuracy_score(y_test, y_pred)
+    precision = precision_score(y_test, y_pred, average="macro")
+    recall = recall_score(y_test, y_pred, average="macro")
+    f1 = f1_score(y_test, y_pred, average="macro")
+
+    glcm_metrics["accuracy"].append(accuracy)
+    glcm_metrics["precision"].append(precision)
+    glcm_metrics["recall"].append(recall)
+    glcm_metrics["f1_score"].append(f1)
+
+    # Print metrics for this fold
+    print(
+        f"GLCM Fold Metrics: Accuracy={accuracy:.2f}, Precision={precision:.2f}, Recall={recall:.2f}, F1-Score={f1:.2f}"
+    )
+
+# Print average metrics for GLCM classifier
+print("\nAverage GLCM Classifier Metrics:")
+for metric in glcm_metrics:
+    avg_metric = np.mean(glcm_metrics[metric])
+    print(f"{metric.capitalize()}: {avg_metric:.2f}")
+
+# Confusion Matrix for GLCM
+glcm_conf_matrix = confusion_matrix(y_true_glcm, y_pred_glcm)
+print("\nConfusion Matrix for GLCM Classifier:")
+print(glcm_conf_matrix)
+
+# Classification Report for GLCM
+print("\nClassification Report for GLCM Classifier:")
+print(classification_report(y_true_glcm, y_pred_glcm))
+
+# 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)
+
+# 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"]
+    )
+    lbp_classifier.fit(x_train, y_train)
+    y_pred = lbp_classifier.predict(x_test)
+
+    # Collect true and predicted labels
+    y_true_lbp.extend(y_test)
+    y_pred_lbp.extend(y_pred)
+
+    # Calculate and store metrics
+    accuracy = accuracy_score(y_test, y_pred)
+    precision = precision_score(y_test, y_pred, average="macro")
+    recall = recall_score(y_test, y_pred, average="macro")
+    f1 = f1_score(y_test, y_pred, average="macro")
+
+    lbp_metrics["accuracy"].append(accuracy)
+    lbp_metrics["precision"].append(precision)
+    lbp_metrics["recall"].append(recall)
+    lbp_metrics["f1_score"].append(f1)
+
+    # Print metrics for this fold
+    print(
+        f"LBP Fold Metrics: Accuracy={accuracy:.2f}, Precision={precision:.2f}, Recall={recall:.2f}, F1-Score={f1:.2f}"
+    )
+
+# Print average metrics for LBP classifier
+print("\nAverage LBP Classifier Metrics:")
+for metric in lbp_metrics:
+    avg_metric = np.mean(lbp_metrics[metric])
+    print(f"{metric.capitalize()}: {avg_metric:.2f}")
+
+# Confusion Matrix for LBP
+lbp_conf_matrix = confusion_matrix(y_true_lbp, y_pred_lbp)
+print("\nConfusion Matrix for LBP Classifier:")
+print(lbp_conf_matrix)
+
+# Classification Report for LBP
+print("\nClassification Report for LBP Classifier:")
+print(classification_report(y_true_lbp, y_pred_lbp))
 
-# 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.
@@ -150,10 +258,10 @@ def classify_texture(image, method):
     # Extract features based on the selected method
     if method == "GLCM":
         feature = calc_glcm_features([resized_image])
-        prediction = knn_glcm.predict(feature)
+        prediction = glcm_classifier.predict(feature)
     elif method == "LBP":
         feature = extract_lbp_features([resized_image])
-        prediction = knn_lbp.predict(feature)
+        prediction = lbp_classifier.predict(feature)
     else:
         raise ValueError("The method is not recognized")
 
@@ -162,7 +270,9 @@ def classify_texture(image, method):
 
     # 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 = cv2.cvtColor(
+            image, cv2.COLOR_BGR2RGB
+        )  # Convert to RGB for displaying
         highlighted_image[:] = [0, 255, 0]  # Highlight in green
     else:
         highlighted_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
@@ -170,6 +280,7 @@ def classify_texture(image, method):
 
     return result, highlighted_image
 
+
 # Gradio interface setup with a dropdown for method selection
 iface = gr.Interface(
     fn=classify_texture,