Initial commit

.gitattributes

@@ -0,0 +1 @@
+*.pkl filter=lfs diff=lfs merge=lfs -text

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

app.py

@@ -0,0 +1,156 @@
+import os
+import cv2
+import numpy as np
+import pickle
+import gradio as gr
+
+# Import the feature extraction function from feature_extractor.py
+from feature_extractor import extract_features_from_image
+
+# Global variables for the classifier, class names, and training log
+classifier = None
+class_names = []
+training_log = ""
+
+# ---------------------------------------------------------------------
+# Model Loading
+# ---------------------------------------------------------------------
+def load_model(model_filename):
+    global classifier, class_names, training_log
+    if os.path.exists(model_filename):
+        print("Found existing SVM model. Loading...")
+        with open(model_filename, "rb") as f:
+            model_data = pickle.load(f)
+        classifier = model_data['classifier']
+        class_names = model_data['class_names']
+        training_log += "Loaded model from disk.\n"
+        print("Loaded SVM model from disk.")
+    else:
+        print(f"Model file {model_filename} not found. Please train the model first.")
+
+def classify_new_image(input_image_path):
+    """
+    Expects input_image_path as a file path. Loads the image,
+    processes it, and returns the final prediction and probabilities.
+    """
+    global classifier, training_log, class_names
+    progress_log = training_log + "\nStarting classification...\n"
+    
+    # Load image using OpenCV from file path
+    image = cv2.imread(input_image_path)
+    if image is None:
+        raise ValueError("Error: Could not load image from the provided file path.")
+    
+    # Resize the image to a fixed width (1000 px) while maintaining aspect ratio
+    fixed_width = 1000
+    height, width = image.shape[:2]
+    aspect_ratio = height / width
+    new_height = int(fixed_width * aspect_ratio)
+    resized_image = cv2.resize(image, (fixed_width, new_height))
+    progress_log += "Resized image to fixed width of 1000 pixels.\n"
+    
+    # The image from cv2.imread is already in BGR format.
+    image_bgr = resized_image
+    progress_log += "Image loaded in BGR format.\n"
+    
+    # Preprocessing – Convert to grayscale, apply Gaussian blur, and compute edges
+    gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
+    blurred = cv2.GaussianBlur(gray, (9, 9), 0)
+    edges = cv2.Canny(blurred, threshold1=0, threshold2=100)
+    progress_log += "Computed edges using Canny edge detection.\n"
+    
+    # Patch extraction parameters
+    patch_size = (100, 100)
+    edge_density_thresh_low = 0.0
+    edge_density_thresh_high = 0.5
+    patch_w, patch_h = patch_size
+    img_h, img_w = gray.shape
+    
+    valid_patch_count = 0
+    summed_probabilities = None
+    
+    # Loop over non-overlapping patches
+    for y in range(0, img_h - patch_h + 1, patch_h):
+        for x in range(0, img_w - patch_w + 1, patch_w):
+            patch_edges = edges[y:y+patch_h, x:x+patch_w]
+            patch = resized_image[y:y+patch_h, x:x+patch_w]
+            num_edge_pixels = np.sum(patch_edges > 0)
+            total_pixels = patch_w * patch_h
+            density = num_edge_pixels / total_pixels
+            progress_log += f"Patch at ({x}, {y}) - edge density: {density:.3f}\n"
+            
+            if edge_density_thresh_low < density < edge_density_thresh_high:
+                valid_patch_count += 1
+                features = extract_features_from_image(patch)
+                feature_vector = features['combined_features'].reshape(1, -1)
+                patch_probabilities = classifier.predict_proba(feature_vector)[0]
+                progress_log += f"Patch at ({x}, {y}) predicted probabilities: {patch_probabilities}\n"
+                
+                if summed_probabilities is None:
+                    summed_probabilities = patch_probabilities
+                else:
+                    summed_probabilities += patch_probabilities
+    
+    # Fallback: if no valid patches are found, classify the whole image.
+    if valid_patch_count == 0:
+        progress_log += "No valid patches found. Falling back to whole image classification.\n"
+        features = extract_features_from_image(image_bgr)
+        feature_vector = features['combined_features'].reshape(1, -1)
+        summed_probabilities = classifier.predict_proba(feature_vector)[0]
+        valid_patch_count = 1
+    
+    # Average the probabilities from all valid patches
+    averaged_probabilities = summed_probabilities / valid_patch_count
+
+    # Normalize the averaged probabilities so they sum to 1
+    normalized_probabilities = averaged_probabilities / np.sum(averaged_probabilities)
+    
+    final_prediction_index = np.argmax(normalized_probabilities)
+    final_prediction = class_names[final_prediction_index]
+    prob_dict = {cls: float(normalized_probabilities[i]) for i, cls in enumerate(class_names)}
+    progress_log += "Classification completed.\n"
+    
+    print(progress_log)
+    print(prob_dict)
+    return final_prediction, prob_dict
+
+    
+# Gradio Interface Setup using file paths
+if __name__ == "__main__":
+    model_filename = "svm_model_color.pkl"
+    load_model(model_filename)
+    
+    iface = gr.Interface(
+        fn=classify_new_image,
+        inputs=gr.Image(type="filepath"),
+        outputs=[
+            gr.Label(label="Predicted Class"),
+            gr.Label(label="Probabilities")
+        ],
+        title="Stone, Wood, Brick Classifier",
+        description=("Upload an image of stone, wood, or brick to classify it.\n\n"
+                     "The image is processed by subdividing it into patches and aggregating the predictions. "
+                     "Progress logs are printed to the terminal.")
+    )
+    iface.launch(share=True)
+
+# ---------------------------------------------------------------------
+# Gradio Interface Setup
+# ---------------------------------------------------------------------
+if __name__ == "__main__":
+    model_filename = "svm_model2.pkl"
+    load_model(model_filename)
+    
+    iface = gr.Interface(
+        fn=classify_new_image,
+        inputs=gr.Image(type="filepath"),
+        outputs=[
+            gr.Label(label="Predicted Class"),
+            gr.Label(label="Probabilities")
+        ],
+        title="Stone, Wood, Brick Classifier",
+        description=("Upload an image of stone, wood, or brick to classify it.\n\n"
+                     "The image is processed by subdividing it into patches and aggregating the predictions. "
+                     "Progress logs are printed to the terminal.")
+    )
+    iface.launch()

feature_extractor.py

@@ -0,0 +1,201 @@
+import os
+import cv2
+import numpy as np
+from skimage.feature import local_binary_pattern, graycomatrix, graycoprops
+
+# ---------------------------------------------------------------------
+# 1. Color Features
+# ---------------------------------------------------------------------
+def get_average_color(image):
+    """
+    Compute the average color in BGR format (3 values).
+    """
+    return np.mean(image, axis=(0, 1))  # shape: (3,)
+
+def get_small_color_hist(image, h_bins=8, s_bins=2, v_bins=2):
+    """
+    Compute a *reduced* color histogram in HSV space:
+      - h_bins: number of bins for Hue
+      - s_bins: number of bins for Saturation
+      - v_bins: number of bins for Value
+    
+    Total bins = h_bins * s_bins * v_bins.
+    """
+    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+    hist = cv2.calcHist(
+        [hsv], 
+        [0, 1, 2], 
+        None, 
+        [h_bins, s_bins, v_bins], 
+        [0, 180, 0, 256, 0, 256]
+    )
+    cv2.normalize(hist, hist)
+    return hist.flatten()  # shape: (h_bins*s_bins*v_bins,)
+
+# ---------------------------------------------------------------------
+# 2. LBP (Local Binary Patterns)
+# ---------------------------------------------------------------------
+def get_lbp_histogram(image, num_points, radius):
+    # Ensure the image is grayscale: only convert if it has more than one channel.
+    if len(image.shape) > 2 and image.shape[2] != 1:
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = image
+
+    # Compute the LBP representation of the image.
+    # (Assuming you're using skimage's local_binary_pattern)
+    from skimage.feature import local_binary_pattern
+    lbp = local_binary_pattern(gray, num_points, radius, method="uniform")
+
+    # Build the histogram of the LBP.
+    n_bins = int(num_points + 2)
+    hist, _ = np.histogram(lbp.ravel(), bins=n_bins, range=(0, n_bins))
+
+    # Normalize the histogram.
+    hist = hist.astype("float")
+    hist /= (hist.sum() + 1e-6)
+    
+    return hist
+
+# ---------------------------------------------------------------------
+# 3. GLCM (Gray Level Co-occurrence Matrix)
+# ---------------------------------------------------------------------
+def get_glcm_features(image,
+                      distance=1,
+                      angles=[0],
+                      properties=('contrast', 'homogeneity', 'energy', 'correlation')):
+    """
+    Compute a small set of GLCM features:
+      - distance=1, angles=[0]  (or [0, np.pi/2] if you want more orientations)
+      - properties = a reduced subset for simpler texture capture
+    
+    Returns a flattened array of property values across all angles.
+    """
+    glcm = graycomatrix(
+        image,
+        distances=[distance],
+        angles=angles,
+        levels=256,
+        symmetric=True,
+        normed=True
+    )
+    feats = []
+    for prop in properties:
+        vals = graycoprops(glcm, prop)
+        feats.append(vals.ravel())  # Flatten N-dim array
+    glcm_features = np.concatenate(feats)
+    return glcm_features  # shape: (len(properties)*len(angles),)
+
+# ---------------------------------------------------------------------
+# 4. Combined Feature Extraction
+# ---------------------------------------------------------------------
+def extract_features_from_image(image):
+    """
+    Returns a DICTIONARY of feature sets:
+      - 'average_color': 3 values (B, G, R) from the original image.
+      - 'lbp_hist': Histogram from Local Binary Patterns (texture).
+      - 'glcm_features': GLCM features (contrast, homogeneity, energy, correlation).
+      - 'edge_density': Scalar representing the fraction of edge pixels.
+      - 'edge_orient_hist': Normalized histogram (8 bins) of edge orientations.
+      - 'combined_features': Concatenation of all the above features.
+      
+    This function supports both color and grayscale images.
+    """
+    import cv2
+    import numpy as np
+
+    # --- (A) Color Features ---
+    # Ensure a 3-channel image for color feature extraction.
+    if len(image.shape) == 2 or image.shape[2] == 1:
+        image_color = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+    else:
+        image_color = image
+    avg_color = get_average_color(image_color)  # Expected shape: (3,)
+
+    # --- (B) Texture Features: LBP and GLCM ---
+    # Use grayscale image for texture features.
+    if len(image.shape) == 2:
+        gray_image = image
+    else:
+        gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+    lbp_hist = get_lbp_histogram(gray_image, num_points=8, radius=1)  # e.g., shape = (10,)
+    glcm_feats = get_glcm_features(
+        gray_image,
+        distance=1,
+        angles=[0],  # Single orientation
+        properties=('contrast', 'homogeneity', 'energy', 'correlation')
+    )  # e.g., shape = (4,)
+
+    # --- (C) Edge-Related Features ---
+    # Preprocessing: Blur to reduce noise before edge detection.
+    blurred = cv2.GaussianBlur(gray_image, (9, 9), 0)
+    
+    # Compute Canny edges using fixed thresholds (these might be adapted based on context).
+    threshold1, threshold2 = 0, 100
+    edges = cv2.Canny(blurred, threshold1=threshold1, threshold2=threshold2)
+    
+    # Edge Density: Ratio of edge pixels to total pixels.
+    edge_density = np.sum(edges > 0) / float(edges.size)
+    
+    # Compute gradient orientations using Sobel operators.
+    grad_x = cv2.Sobel(blurred, cv2.CV_64F, 1, 0, ksize=3)
+    grad_y = cv2.Sobel(blurred, cv2.CV_64F, 0, 1, ksize=3)
+    magnitude, angle = cv2.cartToPolar(grad_x, grad_y, angleInDegrees=True)
+    
+    # Use only edge pixels for orientation histogram.
+    angles = angle[edges > 0]
+    hist_bins = 8
+    if angles.size > 0:
+        edge_orient_hist, _ = np.histogram(angles, bins=hist_bins, range=(0, 360))
+        edge_orient_hist = edge_orient_hist.astype("float")
+        edge_orient_hist /= (edge_orient_hist.sum() + 1e-6)  # Normalize histogram.
+    else:
+        edge_orient_hist = np.zeros(hist_bins, dtype="float")
+
+    # --- (D) Combine All Features ---
+    combined_features = np.concatenate([
+        avg_color,                       # 3 values
+        lbp_hist,                        # e.g., 10 values
+        glcm_feats,                      # e.g., 4 values
+        np.array([edge_density]),        # 1 value
+        edge_orient_hist                 # 8 values
+    ])
+
+    return {
+        'average_color': avg_color,
+        'lbp_hist': lbp_hist,
+        'glcm_features': glcm_feats,
+        'edge_density': edge_density,
+        'edge_orient_hist': edge_orient_hist,
+        'combined_features': combined_features
+    }
+
+
+# ---------------------------------------------------------------------
+# 5. Example Usage
+# ---------------------------------------------------------------------
+if __name__ == "__main__":
+    import sys
+
+    # Provide the path to an image file
+    # e.g., python feature_extractor_min.py images/wood_example.jpg
+
+    
+    image_path = './wood_patches/patch_012.png'
+    image = cv2.imread(image_path, cv2.IMREAD_COLOR)
+
+    if image is None:
+        print(f"Error: Unable to read image at {image_path}")
+    else:
+        feats = extract_features_from_image(image)
+        print("Feature Shapes:")
+        for k, v in feats.items():
+            if isinstance(v, np.ndarray):
+                print(f"  {k}: shape={v.shape}")
+            else:
+                print(f"  {k}: {v}")
+        
+        print("\nCombined Feature Vector:")
+        print(feats['combined'])
+        print("Combined Feature Length:", len(feats['combined']))

svm_model_color.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:421f593486e03e780e4376677331aa39bc65dc7d128152e19f9f6178ad9e4a69
+size 23294