Update app.py

app.py

@@ -1,142 +1,129 @@
-import gradio as gr
-import numpy as np
-import joblib  # Import directly from joblib
-from sklearn.svm import LinearSVC
-from skimage.feature import local_binary_pattern, graycomatrix, graycoprops
-from PIL import Image
-
-IMAGE_SIZE_GLCM = 256
-IMAGE_SIZE_LBP = 128
-RADIUS = 1
-N_POINTS = 8 * RADIUS
-LBP_METHOD = "uniform"
-
-def get_feature_vector(img, feature_type):
-    
-          
-    img_gray = img.convert("L")
-    if feature_type == "GLCM":
-        img_resized = image_resize(img_gray, IMAGE_SIZE_GLCM)
-        feature_vector = compute_glcm_histogram_pil(img_resized)
-    else:
-        img_resized = image_resize(img_gray, IMAGE_SIZE_LBP)
-        feature_vector = get_lbp_hist(np.array(img_resized), N_POINTS, RADIUS, LBP_METHOD)
-    return [feature_vector]
-
-def compute_glcm_histogram_pil(image, distances=[1], angles=[0], levels=8, symmetric=True):
-    
-     # Step 2: Convert the PIL image to a NumPy array
-    image_np = np.array(image)
-
-    # Step 3: Quantize the grayscale image to the specified number of levels (e.g., 256)
-    image_np = (image_np * (levels - 1) / 255).astype(np.uint8)  # Scale to desired levels
-
-    
-    # Step 4: Compute the GLCM using skimage's graycomatrix function
-    glcm = graycomatrix(image_np, 
-                        distances=distances, 
-                        angles=angles, 
-                        levels=levels, 
-                        symmetric=symmetric, 
-                        normed=True)
-
-    # Extract GLCM properties
-    homogeneity = graycoprops(glcm, 'homogeneity')[0, 0]
-    correlation = graycoprops(glcm, 'correlation')[0, 0]
-
-
-    # Create the feature vector
-    feature_vector = np.array([homogeneity, correlation])
-
-    # feature_vector = np.array([contrast,homogeneity, correlation, energy,  dissimilarity, asm, entropy])
-
-    return feature_vector
-
-def get_lbp_hist(gray_image, n_points, radius, method):
-    # Step 3: Compute LBP for the image
-    lbp = local_binary_pattern(gray_image, n_points, radius, method)
-
-    # Step 4: Compute LBP histogram
-    # The histogram will have 'n_points + 2' bins if using the 'uniform' method.
-    lbp_hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, n_points + 3), range=(0, n_points + 2))
-
-    # Normalize the histogram
-    lbp_hist = lbp_hist.astype("float")
-    lbp_hist /= (lbp_hist.sum() + 1e-6)  # Normalized histogram
-    return lbp_hist
-
-def image_resize(img, n):
-    # Crop the image to a square by finding the minimum dimension
-    min_dimension = min(img.size)
-    left = (img.width - min_dimension) / 2
-    top = (img.height - min_dimension) / 2
-    right = (img.width + min_dimension) / 2
-    bottom = (img.height + min_dimension) / 2
-    img = img.crop((left, top, right, bottom))
-
-    # Resize to 128x128 pixels
-    img = img.resize((n, n))
-    return img
-
-
-def rgb_to_quantized_gray_pil(image, num_levels):
-    """
-    Convert an RGB image to a quantized grayscale image using PIL.
-
-    Parameters:
-    - image: PIL Image object in grayscale format.
-    - num_levels: Number of gray levels for quantization.
-
-    Returns:
-    - quantized_image: PIL Image object in quantized grayscale.
-    """
-    # Convert the grayscale image to a NumPy array for manipulation
-    gray_array = np.array(image)
-
-    # Quantize the grayscale image to the specified number of gray levels
-    max_val = 255  # Max value for an 8-bit grayscale image
-    quantized_array = np.floor(gray_array / (max_val / (num_levels - 1))) * (max_val / (num_levels - 1))
-    quantized_array = quantized_array.astype(np.uint8)  # Convert back to 8-bit values
-
-    # Convert the quantized NumPy array back to a PIL Image
-    quantized_image = Image.fromarray(quantized_array, mode="L")
-
-    return quantized_image
-
-# Function to classify the image
-def classify(img, feature_type):
-
-    # To load the model later
-    loaded_model = joblib.load(feature_type + '_model.joblib')
-
-    feature_vector = get_feature_vector(img, feature_type)
-    # Make predictions with the loaded model
-    label = loaded_model.predict(feature_vector)
-
-    return f"{label[0]}"
-
-def main():
-    # Gradio interface
-    with gr.Blocks() as interface:
-        gr.Markdown("## Image Classifier")
-        
-        # Image upload input
-        img_input = gr.Image(type="pil")
-        
-        # Dropdown for selecting classifier
-        classifier_dropdown = gr.Dropdown(choices=["GLCM", "LBP"], label="Feature Vector Type")
-        
-        # Button for classification
-        classify_button = gr.Button("Classify Image")
-        
-        # Output label
-        output_label = gr.Textbox(label="Predicted Texture")
-
-        # Set up interaction
-        classify_button.click(fn=classify, inputs=[img_input, classifier_dropdown], outputs=output_label)
-
-    # Launch the interface
-    interface.launch()
-
-if __name__ == "__main__":
-    main()
+"""
+CS5330 Fall 2024
+Lab 2 Texture Classification
+Calvin Lo
+"""
+
+import gradio as gr
+import numpy as np
+import joblib 
+from skimage.feature import local_binary_pattern, graycomatrix, graycoprops
+
+IMAGE_SIZE_GLCM = 256
+IMAGE_SIZE_LBP = 128
+RADIUS = 1
+N_POINTS = 8 * RADIUS
+LBP_METHOD = "uniform"
+
+
+def get_feature_vector(img, feature_type):
+
+    # convert to grayscale
+    img_gray = img.convert("L")
+
+    # resize and get feature vector
+    if feature_type == "GLCM":
+        img_resized = image_resize(img_gray, IMAGE_SIZE_GLCM)
+        feature_vector = compute_glcm_histogram_pil(img_resized)
+    else:
+        img_resized = image_resize(img_gray, IMAGE_SIZE_LBP)
+        feature_vector = get_lbp_hist(np.array(img_resized),
+                                      N_POINTS,
+                                      RADIUS,
+                                      LBP_METHOD)
+    return [feature_vector]
+
+
+def compute_glcm_histogram_pil(image, distances=[1],
+                               angles=[0],
+                               levels=8,
+                               symmetric=True):
+
+    # Convert the PIL image to a NumPy array
+    image_np = np.array(image)
+
+    # Quantize the grayscale image to the specified number of levels
+    image_np = (image_np * (levels - 1) / 255).astype(np.uint8)
+
+    # Compute the GLCM using skimage's graycomatrix function
+    glcm = graycomatrix(image_np,
+                        distances=distances,
+                        angles=angles,
+                        levels=levels,
+                        symmetric=symmetric,
+                        normed=True)
+
+    # Extract GLCM properties
+    homogeneity = graycoprops(glcm, 'homogeneity')[0, 0]
+    correlation = graycoprops(glcm, 'correlation')[0, 0]
+
+    # Create the feature vector
+    feature_vector = np.array([homogeneity, correlation])
+
+    return feature_vector
+
+
+def get_lbp_hist(gray_image, n_points, radius, method):
+    # Compute LBP for the image
+    lbp = local_binary_pattern(gray_image, n_points, radius, method)
+    lbp_hist, _ = np.histogram(lbp.ravel(), bins=np.arange(0, n_points + 3),
+                               range=(0, n_points + 2))
+
+    # Normalize the histogram
+    lbp_hist = lbp_hist.astype("float")
+    lbp_hist /= (lbp_hist.sum() + 1e-6)  # Normalized histogram
+    return lbp_hist
+
+
+def image_resize(img, n):
+    # Crop the image to a square by finding the minimum dimension
+    min_dimension = min(img.size)
+    left = (img.width - min_dimension) / 2
+    top = (img.height - min_dimension) / 2
+    right = (img.width + min_dimension) / 2
+    bottom = (img.height + min_dimension) / 2
+    img = img.crop((left, top, right, bottom))
+    img = img.resize((n, n))
+    return img
+
+
+def classify(img, feature_type):
+    # To load the model later
+    loaded_model = joblib.load(feature_type + '_model.joblib')
+
+    feature_vector = get_feature_vector(img, feature_type)
+    # Make predictions with the loaded model
+    label = loaded_model.predict(feature_vector)
+
+    return f"{label[0]}"
+
+
+def main():
+    # Gradio interface
+    with gr.Blocks() as interface:
+        gr.Markdown("## Image Texture Classifier")
+
+        # Image upload input
+        img_input = gr.Image(type="pil")
+
+        # Dropdown for selecting classifier
+        classifier_dropdown = gr.Dropdown(choices=["GLCM", "LBP"],
+                                          label="Feature Vector Type")
+
+        # Button for classification
+        classify_button = gr.Button("Classify Image")
+
+        # Output label
+        output_label = gr.Textbox(label="Predicted Texture")
+
+        # Set up interaction
+        classify_button.click(fn=classify,
+                              inputs=[img_input, classifier_dropdown],
+                              outputs=output_label)
+
+    # Launch the interface
+    interface.launch()
+
+
+if __name__ == "__main__":
+    main()