try to revert back to old code but keep change in interface

app.py

@@ -1,157 +1,153 @@
 import gradio as gr
 import numpy as np
 import pandas as pd
-from PIL import Image
-import logging
-import os # Import os for path checks
-
-# Placeholder imports for clustering and utils.
-# In a real scenario, these files (clustering.py, utils.py)
-# would contain your actual implementation.
-try:
-    import clustering
-    import utils
-except ImportError as e:
-    logging.error(f"Error importing helper modules: {e}. Using dummy functions.")
-    # Define dummy functions if imports fail, to allow the app to launch.
-    class DummyClustering:
-        def get_centroids(self, *args, **kwargs):
-            logging.warning("Using dummy get_centroids. Provide actual clustering.py.")
-            # Return some dummy centroids for demonstration
-            # In a real scenario, you might want to raise an error or return an empty list
-            # if clustering is critical for app functionality.
-            return [(100, 100), (200, 200)]
-
-    class DummyUtils:
-        def prepare_classifier_input(self, *args, **kwargs):
-            logging.warning("Using dummy prepare_classifier_input. Provide actual utils.py.")
-            # Return dummy data for model input
-            return np.zeros((1, 250, 250, 3)) # Example shape, adjust as per your model input
-
-        def show_boxes(self, image, damage_sites, save_image=False, image_path=None):
-            logging.warning("Using dummy show_boxes. Provide actual utils.py.")
-            # Return the original image for dummy display
-            # In a real app, this would draw boxes
-            if image is None:
-                return Image.new('RGB', (400, 400), color = 'red') # Placeholder if no image provided
-            return image
-
-    clustering = DummyClustering()
-    utils = DummyUtils()
 
+# our own helper tools
+import clustering
+import utils
+
+import logging
+logging.getLogger().setLevel(logging.INFO)
 
 from tensorflow import keras
 
-# --- Basic Setup ---
-logging.getLogger().setLevel(logging.INFO)
+#image_threshold = 20
+
 
 # --- Constants and Model Loading ---
 IMAGE_PATH = "classified_damage_sites.png"
 CSV_PATH = "classified_damage_sites.csv"
 
-# Load models once at startup to improve performance
-model1 = None
-model2 = None
-
-try:
-    # Check if model files exist before attempting to load
-    if os.path.exists('rwthmaterials_dp800_network1_inclusion.h5'):
-        model1 = keras.models.load_model('rwthmaterials_dp800_network1_inclusion.h5')
-        logging.info("Model 1 loaded successfully.")
-    else:
-        logging.warning("Model 1 (rwthmaterials_dp800_network1_inclusion.h5) not found. Classification results may be inaccurate.")
-
-    if os.path.exists('rwthmaterials_dp800_network2_damage.h5'):
-        model2 = keras.models.load_model('rwthmaterials_dp800_network2_damage.h5')
-        logging.info("Model 2 loaded successfully.")
-    else:
-        logging.warning("Model 2 (rwthmaterials_dp800_network2_damage.h5) not found. Classification results may be inaccurate.")
-
-except Exception as e:
-    logging.error(f"Error loading models: {e}")
-    # Models are set to None, and warnings/errors are logged.
-    # The app will still attempt to launch.
-
-damage_classes = {3: "Martensite", 2: "Interface", 0: "Notch", 1: "Shadowing"}
-model1_windowsize = [250, 250]
-model2_windowsize = [100, 100]
-
-# --- Core Processing Function (Your original logic) ---
-def damage_classification(SEM_image, image_threshold, model1_threshold, model2_threshold):
-    """
-    This function contains the core scientific logic for classifying damage sites.
-    It returns the classified image and paths to the output files.
-    """
-    if SEM_image is None:
-        raise gr.Error("Please upload an SEM Image before running classification.")
-
-    if model1 is None or model2 is None:
-        raise gr.Error("Models not loaded. Please ensure model files are present and valid.")
 
-    damage_sites = {}
-    
-    # Step 1: Clustering to find damage centroids
-    # Ensure clustering.get_centroids handles the case of no centroids found
-    all_centroids = clustering.get_centroids(
-        SEM_image,
-        image_threshold=image_threshold,
-        fill_holes=True,
-        filter_close_centroids=True,
-    )
-    
-    for c in all_centroids:
-        damage_sites[(c[0], c[1])] = "Not Classified"
+model1_windowsize = [250,250]
+#model1_threshold = 0.7
 
-    # Step 2: Model 1 to identify inclusions
-    if len(all_centroids) > 0:
-        try:
-            images_model1 = utils.prepare_classifier_input(SEM_image, all_centroids, window_size=model1_windowsize)
-            y1_pred = model1.predict(np.asarray(images_model1, dtype=float))
-            inclusions = np.where(y1_pred[:, 0] > model1_threshold)[0]
-            for idx in inclusions:
-                coord = all_centroids[idx]
-                damage_sites[(coord[0], coord[1])] = "Inclusion"
-        except Exception as e:
-            logging.error(f"Error during Model 1 prediction: {e}")
+model1 = keras.models.load_model('rwthmaterials_dp800_network1_inclusion.h5')
+model1.compile()
+
+damage_classes = {3: "Martensite",2: "Interface",0:"Notch",1:"Shadowing"}
+
+model2_windowsize = [100,100]
+#model2_threshold = 0.5
+
+model2 = keras.models.load_model('rwthmaterials_dp800_network2_damage.h5')
+model2.compile()
 
-    # Step 3: Model 2 to classify remaining damage types
-    centroids_model2 = [list(k) for k, v in damage_sites.items() if v == "Not Classified"]
-    if centroids_model2:
-        try:
-            images_model2 = utils.prepare_classifier_input(SEM_image, centroids_model2, window_size=model2_windowsize)
-            y2_pred = model2.predict(np.asarray(images_model2, dtype=float))
-            # Adjust the thresholding for damage_index to handle potential empty results
-            damage_index = np.asarray(y2_pred > model2_threshold).nonzero()
-            
-            for i in range(len(damage_index[0])):
-                sample_idx = damage_index[0][i]
-                class_idx = damage_index[1][i]
-                label = damage_classes.get(class_idx, "Unknown")
-                coord = centroids_model2[sample_idx]
-                damage_sites[(coord[0], coord[1])] = label
-        except Exception as e:
-            logging.error(f"Error during Model 2 prediction: {e}")
 
-    # Step 4: Draw boxes on image and save output image
-    # The utils.show_boxes function is assumed to return a PIL Image object
-    image_with_boxes = utils.show_boxes(SEM_image, damage_sites, save_image=True, image_path=IMAGE_PATH)
 
-    # Step 5: Export CSV file
-    data = [[x, y, label] for (x, y), label in damage_sites.items()]
-    df = pd.DataFrame(data, columns=["x", "y", "damage_type"])
-    df.to_csv(CSV_PATH, index=False)
+##
+## Function to do the actual damage classification
+##
+def damage_classification(SEM_image,image_threshold, model1_threshold, model2_threshold):
+
+    damage_sites = {}
+    ##
+    ## clustering
+    ##
+    logging.debug('---------------: clustering :=====================')
+    all_centroids = clustering.get_centroids(SEM_image, image_threshold=image_threshold,
+                                            fill_holes=True, filter_close_centroids=True)
+    
+    for i in range(len(all_centroids)) :
+        key = (all_centroids[i][0],all_centroids[i][1])
+        damage_sites[key] = 'Not Classified'
+    
+    ##
+    ## Inclusions vs the rest
+    ##
+    logging.debug('---------------: prepare model 1 :=====================')
+    images_model1 = utils.prepare_classifier_input(SEM_image, all_centroids, window_size=model1_windowsize)
+    
+    logging.debug('---------------: run model 1 :=====================')
+    y1_pred = model1.predict(np.asarray(images_model1, float))
+
+    logging.debug('---------------: model1 threshold :=====================')
+    inclusions = y1_pred[:,0].reshape(len(y1_pred),1)
+    inclusions = np.where(inclusions > model1_threshold)
+
+    logging.debug('---------------: model 1 update dict :=====================')
+    for i in range(len(inclusions[0])):
+        centroid_id = inclusions[0][i]
+        coordinates = all_centroids[centroid_id]
+        key = (coordinates[0], coordinates[1])
+        damage_sites[key] = 'Inclusion'
+    logging.debug('Damage sites after model 1')
+    logging.debug(damage_sites)
+
+    ##
+    ## Martensite cracking, etc
+    ##
+    logging.debug('---------------: prepare model 2 :=====================')
+    centroids_model2 = []
+    for key, value in damage_sites.items():
+        if value == 'Not Classified':
+            coordinates = list([key[0],key[1]])
+            centroids_model2.append(coordinates)
+    logging.debug('Centroids model 2')
+    logging.debug(centroids_model2)
+
+    logging.debug('---------------: prepare model 2 :=====================')
+    images_model2 = utils.prepare_classifier_input(SEM_image, centroids_model2, window_size=model2_windowsize)
+    logging.debug('Images model 2')
+    logging.debug(images_model2)
+    
+    logging.debug('---------------: run model 2 :=====================')
+    y2_pred = model2.predict(np.asarray(images_model2, float))
+
+    damage_index = np.asarray(y2_pred > model2_threshold).nonzero()
+
+
+    for i in range(len(damage_index[0])):
+        index = damage_index[0][i]
+        identified_class = damage_index[1][i]
+        label = damage_classes[identified_class]
+        coordinates = centroids_model2[index]
+        #print('Damage {} \t identified as {}, \t coordinates {}'.format(i, label, coordinates))   
+        key = (coordinates[0], coordinates[1])
+        damage_sites[key] = label
+
+    ##
+    ## show the damage sites on the image
+    ##
+    logging.debug("-----------------: final damage sites :=================")
+    logging.debug(damage_sites)
+
+    image_path = 'classified_damage_sites.png'
+    image = utils.show_boxes(SEM_image, damage_sites, 
+                             save_image=True, 
+                             image_path=image_path)
+
+    ##
+    ## export data
+    ##
+    csv_path = 'classified_damage_sites.csv'
+    cols = ['x', 'y', 'damage_type']
+    
+    data = []
+    for key, value in damage_sites.items():
+        data.append([key[0], key[1], value])
+
+    df = pd.DataFrame(columns=cols, data=data)
+    
+    df.to_csv(csv_path)
 
-    # Log file paths to ensure they are correct
-    logging.info(f"Generated Image Path: {IMAGE_PATH}")
-    logging.info(f"Generated CSV Path: {CSV_PATH}")
 
-    return image_with_boxes, IMAGE_PATH, CSV_PATH
+    return  image, image_path, csv_path
 
-# --- Gradio Interface Definition ---
+## ---------------------------------------------------------------------------------------------------------------
+## main app interface
+## -----------------------------------------------------------------------------------------------------------------
 with gr.Blocks() as app:
-    gr.Markdown("# Damage Classification in Dual Phase Steels")
-    gr.Markdown("Upload a Scanning Electron Microscope (SEM) image and set the thresholds to classify material damage.")
+    gr.Markdown('# Damage Classification in Dual Phase Steels')
+    gr.Markdown('This app classifies damage types in dual phase steels. Two models are used. The first model is used to identify inclusions in the steel. The second model is used to identify the remaining damage types: Martensite cracking, Interface Decohesion, Notch effect and Shadows.')
+
+    gr.Markdown('The models used in this app are based on the following papers:')
+    gr.Markdown('Kusche, C., Reclik, T., Freund, M., Al-Samman, T., Kerzel, U., & Korte-Kerzel, S. (2019). Large-area, high-resolution characterisation and classification of damage mechanisms in dual-phase steel using deep learning. PloS one, 14(5), e0216493. [Link](https://doi.org/10.1371/journal.pone.0216493)')
+    #gr.Markdown('Medghalchi, S., Kusche, C. F., Karimi, E., Kerzel, U., & Korte-Kerzel, S. (2020). Damage analysis in dual-phase steel using deep learning: transfer from uniaxial to biaxial straining conditions by image data augmentation. Jom, 72, 4420-4430. [Link](https://link.springer.com/article/10.1007/s11837-020-04404-0)')
+    gr.Markdown('Setareh Medghalchi, Ehsan Karimi, Sang-Hyeok Lee, Benjamin Berkels, Ulrich Kerzel, Sandra Korte-Kerzel, Three-dimensional characterisation of deformation-induced damage in dual phase steel using deep learning, Materials & Design, Volume 232, 2023, 112108, ISSN 0264-1275, [link] (https://doi.org/10.1016/j.matdes.2023.112108')
+    gr.Markdown('Original data and code, including the network weights,  can be found at Zenodo [link](https://zenodo.org/records/8065752)')
 
+    image_input = gr.Image(value='data/X4-Aligned_cropped_upperleft_small.png', label='Example SEM Image (DP800 steel)',)
     with gr.Row():
         with gr.Column(scale=1):
             image_input = gr.Image(type="pil", label="Upload SEM Image")

clustering.py

@@ -5,19 +5,21 @@
 """
 
 import numpy as np
+
+
 import scipy.ndimage as ndi
 from scipy.spatial import KDTree
+
 from sklearn.cluster import DBSCAN
+
 import logging
-from PIL import Image # Import PIL for type checking/conversion if necessary
 
 
-def get_centroids(image, image_threshold=20,
+def get_centroids(image : np.ndarray, image_threshold = 20,
                   eps=1, min_samples=5, metric='euclidean',
-                  min_size=20, fill_holes=False,
-                  filter_close_centroids=False, filter_radius=50) -> list:
-    """ 
-    Determine centroids of clusters corresponding to potential damage sites.
+                  min_size = 20, fill_holes = False,
+                  filter_close_centroids = False, filter_radius = 50) -> list:
+    """    Determine centroids of clusters corresponding to potential damage sites.
     In a first step, a threshold is applied to the input image to identify areas of potential damage sites.
     Using DBSCAN, these agglomerations of pixels are fitted into clusters. Then, the mean x/y values are determined
     from pixels belonging to one cluster. If the number of pixels in a given cluster excees the threshold given by min_size, this cluster is added
@@ -29,48 +31,27 @@ def get_centroids(image, image_threshold=20,
     DBScan documentation: https://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html
 
     Args:
-        image: Input SEM image. Can be a PIL Image or NumPy array.
+        image (np.ndarray): Input SEM image 
         image_threshold (int, optional): Threshold to be applied to the image to identify candidates for damage sites. Defaults to 20.
         eps (int, optional): parameter eps of DBSCAN: The maximum distance between two samples for one to be considered as in the neighborhood of the other. Defaults to 1.
         min_samples (int, optional): parameter min_samples of DBSCAN: The number of samples (or total weight) in a neighborhood for a point to be considered as a core point. Defaults to 5.
         metric (str, optional): parameter metric of DBSCAN. Defaults to 'euclidean'.
         min_size (int, optional): Minimum number of pixels in a cluster for the damage site candidate to be considered in the final list. Defaults to 20.
         fill_holes (bool, optional): Fill small holes in damage sites clusters using binary_fill_holes. Defaults to False.
-        filter_close_centroids (bool, optional): Filter cluster centroids within a given radius. Defaults to False
+        filter_close_centroids (book optional): Filter cluster centroids within a given radius. Defaults to False
         filter_radius (float, optional): Radius within which centroids are considered to be the same. Defaults to 50
 
     Returns:
         list: list of (x,y) coordinates of the centroids of the clusters of accepted damage site candidates.
     """
 
-    centroids = []
-    logging.info(f"get_centroids: Input image type: {type(image)}")
-
-    # Convert PIL Image to NumPy array if necessary
-    if isinstance(image, Image.Image):
-        # Convert to grayscale if it's an RGB image, as thresholding is usually on single channel
-        if image.mode == 'RGB':
-            image_array = np.array(image.convert('L'))
-            logging.info("get_centroids: Converted RGB PIL Image to grayscale NumPy array.")
-        else:
-            image_array = np.array(image)
-            logging.info("get_centroids: Converted PIL Image to NumPy array.")
-    elif isinstance(image, np.ndarray):
-        # Ensure it's grayscale if it's a multi-channel numpy array
-        if image.ndim == 3 and image.shape[2] in [3, 4]: # RGB or RGBA
-            image_array = np.mean(image, axis=2).astype(image.dtype) # Convert to grayscale by averaging channels
-            logging.info("get_centroids: Converted multi-channel NumPy array to grayscale NumPy array.")
-        else:
-            image_array = image
-            logging.info("get_centroids: Image is already a NumPy array.")
-    else:
-        logging.error("get_centroids: Unsupported image format received.")
-        raise ValueError("Unsupported image format. Expected PIL Image or NumPy array.")
 
+    centroids = []
+    #print('Threshold: ', image_threshold)
 
     # apply the threshold to identify regions of "dark" pixels
     # the result is a binary mask (true/false) whether a given pixel is above or below the threshold
-    cluster_candidates_mask = image_array < image_threshold # FIXED: Use image_array here
+    cluster_candidates = image < image_threshold
 
     # sometimes the clusters have small holes in them, for example, individual pixels
     # inside a region below the threshold. This may confuse the clustering algorith later on
@@ -78,22 +59,20 @@ def get_centroids(image, image_threshold=20,
     # https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.binary_fill_holes.html
     # N.B. the algorith only works on binay data
     if fill_holes:
-        cluster_candidates_mask = ndi.binary_fill_holes(cluster_candidates_mask)
+        cluster_candidates = ndi.binary_fill_holes(cluster_candidates)
+
+    # apply the treshold to the image to identify regions of "dark" pixels
+    #cluster_candidates = np.asarray(image < image_threshold).nonzero()
 
     # transform image format into a numpy array to pass on to DBSCAN clustering
-    # Use the mask directly to get non-zero coordinates
-    cluster_candidates = np.asarray(cluster_candidates_mask).nonzero()
+    cluster_candidates = np.asarray(cluster_candidates).nonzero()
     cluster_candidates = np.transpose(cluster_candidates)
 
-    # Handle case where no candidates are found after thresholding
-    if cluster_candidates.size == 0:
-        logging.warning("No cluster candidates found after thresholding. Returning empty centroids list.")
-        return []
 
     # run the DBSCAN clustering algorithm, candidate sites that are not attributed to a cluster are labelled as "-1", i.e. "noise"
     # (e.g. they are too small, etc)
     # For the remaining pixels, a label is assigned to each pixel, indicating to which cluster (or noise) they belong to.
-    dbscan = DBSCAN(eps=eps, min_samples=min_samples, metric=metric) # Use metric parameter
+    dbscan = DBSCAN(eps=eps, min_samples=min_samples, metric='euclidean')
 
     dbscan.fit(cluster_candidates)
 
@@ -101,37 +80,32 @@ def get_centroids(image, image_threshold=20,
     # Number of clusters in labels, ignoring noise if present.
     n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
     n_noise = list(labels).count(-1)
-    logging.info(f'# clusters {n_clusters}, #noise {n_noise}')
+    logging.debug('# clusters {}, #noise {}'.format(n_clusters, n_noise))
 
 
     # now loop over all labels found by DBSCAN, i.e. all identified clusters and the noise
     # we use "set" here, as the labels are attributed to individual pixels, i.e. they appear as often as we have pixels
     # in the cluster candidates
     for i in set(labels):
-        if i > -1: # Ensure it's not noise
+        if i>-1:
             # all points belonging to a given cluster
-            cluster_points = cluster_candidates[labels == i, :]
+            cluster_points = cluster_candidates[labels==i, :]
             if len(cluster_points) > min_size:
-                x_mean = np.mean(cluster_points, axis=0)[0]
-                y_mean = np.mean(cluster_points, axis=0)[1]
-                centroids.append([x_mean, y_mean])
+                x_mean=np.mean(cluster_points, axis=0)[0]
+                y_mean=np.mean(cluster_points, axis=0)[1]
+                centroids.append([x_mean,y_mean])
 
-    if filter_close_centroids and len(centroids) > 1: # Only filter if there's more than one centroid
+    if filter_close_centroids:
         proximity_tree = KDTree(centroids)
         pairs = proximity_tree.query_pairs(filter_radius)
-        
-        # Use a set to mark indices for removal to avoid modifying list during iteration
-        indices_to_remove = set()
-        for p1_idx, p2_idx in pairs:
-            # Decide which one to remove. For simplicity, remove the one with the higher index
-            # This ensures you don't try to remove an index that might have already been removed
-            indices_to_remove.add(max(p1_idx, p2_idx)) 
-        
-        # Rebuild the centroids list, excluding the marked ones
-        filtered_centroids = [centroid for i, centroid in enumerate(centroids) if i not in indices_to_remove]
-        centroids = filtered_centroids
-        logging.info(f"Filtered {len(indices_to_remove)} close centroids. Remaining: {len(centroids)}")
-
-
-    return centroids
-
+        for p in pairs:
+            #print('pair: ', p, ' p[0]: ', p[0], ' p[1]:', p[1])
+            #print('coords: ', proximity_tree.data[p[0]], '  ', proximity_tree.data[p[1]])
+            coords_to_remove = [proximity_tree.data[p[0]][0], proximity_tree.data[p[0]][1]]
+            try:
+                idx = centroids.index(coords_to_remove)
+                centroids.pop(idx)
+            except ValueError:
+                pass
+
+    return centroids

utils.py

@@ -1,160 +1,163 @@
+"""
+Collection of various utils 
+"""
+
 import numpy as np
-from PIL import Image, ImageDraw
-import logging
 
-def prepare_classifier_input(image, centroids, window_size):
-    """
-    Extracts image patches around centroids and prepares them as input for Keras models.
+import imageio.v3 as iio
+from PIL import Image
+# we may have very large images (e.g. panoramic SEM images), allow to read them w/o warnings
+Image.MAX_IMAGE_PIXELS = 933120000
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from matplotlib.lines import Line2D
+
+
+import math
+
+
+###
+### load SEM images
+### 
+def load_image(filename : str) -> np.ndarray :
+    """Load an SEM image 
 
     Args:
-        image: The input SEM image (PIL Image or NumPy array).
-        centroids (list): List of (x,y) coordinates of damage site centroids.
-        window_size (list): [height, width] of the square window to extract around each centroid.
+        filename (str): full path and name of the image file to be loaded
 
     Returns:
-        np.ndarray: A batch of image patches, ready for model prediction.
+        np.ndarray: file as numpy ndarray
     """
-    logging.info(f"prepare_classifier_input: Input image type: {type(image)}")
-
-    # Convert PIL Image to NumPy array if necessary
-    if isinstance(image, Image.Image):
-        # Convert to RGB first to ensure 3 channels for consistent model input
-        image_array = np.array(image.convert('RGB'))
-        logging.info("prepare_classifier_input: Converted PIL Image to RGB NumPy array.")
-    elif isinstance(image, np.ndarray):
-        # Ensure it's a 3-channel array for consistency if it's already NumPy
-        if image.ndim == 2: # Grayscale NumPy array
-            image_array = np.stack([image, image, image], axis=-1) # Convert to 3 channels
-            logging.info("prepare_classifier_input: Converted grayscale NumPy array to 3-channel.")
-        elif image.ndim == 3 and image.shape[2] == 4: # RGBA NumPy array
-            image_array = image[:, :, :3] # Drop alpha channel
-            logging.info("prepare_classifier_input: Dropped alpha channel from RGBA NumPy array.")
-        else: # Already RGB or similar 3-channel NumPy array
-            image_array = image
-            logging.info("prepare_classifier_input: Image is already a suitable NumPy array.")
-    else:
-        logging.error("prepare_classifier_input: Unsupported image format received. Expected PIL Image or NumPy array.")
-        raise ValueError("Unsupported image format for classifier input.")
-
-    if not centroids:
-        logging.warning("No centroids provided for prepare_classifier_input. Returning empty array.")
-        return np.empty((0, window_size[0], window_size[1], image_array.shape[2]), dtype=np.float32)
-
-    patches = []
-    img_height, img_width, _ = image_array.shape # Get dimensions from the now-guaranteed NumPy array
-    half_window_h, half_window_w = window_size[0] // 2, window_size[1] // 2
-
-    for c_y, c_x in centroids: # Centroids are (y, x) from clustering
-        # Ensure coordinates are integers
-        c_y, c_x = int(round(c_y)), int(round(c_x))
-
-        # Calculate bounding box for the patch
-        # Handle boundary conditions by clamping coordinates
-        y1 = max(0, c_y - half_window_h)
-        y2 = min(img_height, c_y + half_window_h)
-        x1 = max(0, c_x - half_window_w)
-        x2 = min(img_width, c_x + half_window_w)
-
-        # Extract patch
-        patch = image_array[y1:y2, x1:x2, :]
-
-        # Pad if the patch is smaller than window_size (due to boundary clamping)
-        if patch.shape[0] != window_size[0] or patch.shape[1] != window_size[1]:
-            padded_patch = np.zeros((window_size[0], window_size[1], image_array.shape[2]), dtype=patch.dtype)
-            padded_patch[0:patch.shape[0], 0:patch.shape[1], :] = patch
-            patch = padded_patch
-
-        patches.append(patch)
-    
-    # Normalize pixel values if your model expects it (e.g., to 0-1)
-    # This is a common step, adjust if your model's training pre-processing was different
-    # Assuming images are 0-255, converting to float 0-1
-    return np.array(patches, dtype=np.float32) / 255.0
+    image =  iio.imread(filename,mode='F')
 
+    return image
 
-def show_boxes(image, damage_sites, save_image=False, image_path="output_image.png"):
-    """
-    Draws bounding boxes or markers on the image based on the classified damage sites.
+
+
+###
+### show SEM image with boxes in various colours around each damage site
+###
+def show_boxes(image : np.ndarray, damage_sites : dict, box_size = [250,250],
+               save_image = False, image_path : str = None) :
+    """_summary_
 
     Args:
-        image: The input SEM image (PIL Image or NumPy array).
-        damage_sites (dict): Dictionary with (x,y) coordinates as keys and classification labels as values.
-        save_image (bool, optional): Whether to save the image to disk. Defaults to False.
-        image_path (str, optional): Path to save the image. Defaults to "output_image.png".
+        image (np.ndarray): SEM image to be shown
+        damage_sites (dict): python dictionary using the coordinates as key (x,y), and the label as value
+        box_size (list, optional): size of the rectangle drawn around each centroid. Defaults to [250,250].
+        save_image (bool, optional): save the image with the boxes or not. Defaults to False.
+        image_path (str, optional) : Full path and name of the output file to be saved
+    """
 
-    Returns:
-        PIL.Image.Image: The image with drawn boxes/markers.
+    _, ax = plt.subplots(1)
+    ax.imshow(image, cmap='gray')  # show image on correct axis
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+    for key, label in damage_sites.items():
+        position = [key[0], key[1]]
+        edgecolor = {
+            'Inclusion': 'b',
+            'Interface': 'g',
+            'Martensite': 'r',
+            'Notch': 'y',
+            'Shadowing': 'm'
+        }.get(label, 'k')  # default: black
+
+        rect = patches.Rectangle((position[1] - box_size[1] / 2., position[0] - box_size[0] / 2),
+                                 box_size[1], box_size[0],
+                                 linewidth=1, edgecolor=edgecolor, facecolor='none')
+        ax.add_patch(rect)
+
+    legend_elements = [
+        Line2D([0], [0], color='b', lw=4, label='Inclusion'),
+        Line2D([0], [0], color='g', lw=4, label='Interface'),
+        Line2D([0], [0], color='r', lw=4, label='Martensite'),
+        Line2D([0], [0], color='y', lw=4, label='Notch'),
+        Line2D([0], [0], color='m', lw=4, label='Shadow'),
+        Line2D([0], [0], color='k', lw=4, label='Not Classified')
+    ]
+    ax.legend(handles=legend_elements, bbox_to_anchor=(1.04, 1), loc="upper left")
+
+    fig = ax.figure
+    fig.tight_layout(pad=0)
+
+    if save_image and image_path:
+        fig.savefig(image_path, dpi=1200, bbox_inches='tight')
+
+    canvas = fig.canvas
+    canvas.draw()
+
+    data = np.frombuffer(canvas.buffer_rgba(), dtype=np.uint8).reshape(
+        canvas.get_width_height()[::-1] + (4,))
+    data = data[:, :, :3]  # RGB only
+
+    plt.close(fig)
+
+    return data 
+
+
+###
+### cut out small images from panorama, append colour information
+###
+def prepare_classifier_input(panorama: np.ndarray, centroids: list, window_size=[250, 250]) -> list:
     """
-    logging.info(f"show_boxes: Input image type: {type(image)}")
-
-    if image is None:
-        logging.warning("show_boxes received no image. Returning a blank image.")
-        img = Image.new('RGB', (500, 500), color = 'black')
-    else:
-        # Ensure image is a PIL Image for drawing operations
-        if isinstance(image, np.ndarray):
-            # Convert NumPy array to PIL Image. Assuming input is 0-255.
-            if image.dtype == np.float32 and np.max(image) <= 1.0: # If normalized 0-1 float
-                image_for_pil = (image * 255).astype(np.uint8)
-            else: # Assume 0-255 uint8
-                image_for_pil = image.astype(np.uint8)
-
-            if image_for_pil.ndim == 2: # Grayscale numpy
-                img = Image.fromarray(image_for_pil, mode='L').convert("RGB")
-            elif image_for_pil.ndim == 3 and image_for_pil.shape[2] in [3,4]: # RGB or RGBA
-                 img = Image.fromarray(image_for_pil).convert("RGB")
-            else:
-                 logging.error("Unsupported numpy image format for show_boxes.")
-                 img = Image.new('RGB', (500, 500), color = 'black') # Fallback
-        else: # Assume it's already a PIL Image
-            img = image.copy().convert("RGB") # Use a copy to avoid modifying original
-
-    draw = ImageDraw.Draw(img)
+    Extracts square image patches centered at each given centroid from a grayscale panoramic SEM image.
     
-    # Define some colors for drawing boxes
-    colors = {
-        "Inclusion": "red",
-        "Martensite": "blue",
-        "Interface": "green",
-        "Notch": "yellow",
-        "Shadowing": "purple",
-        "Not Classified": "gray", # Should ideally not appear on final image
-        "Unknown": "white"
-    }
+    Each extracted patch is resized to the specified window size and converted into a 3-channel (RGB-like)
+    normalized image suitable for use with classification neural networks that expect color input.
+
+    Parameters
+    ----------
+    panorama : np.ndarray
+        Input SEM image. Should be a 2D array (H, W) or a 3D array (H, W, 1) representing grayscale data.
     
-    for (x, y), label in damage_sites.items():
-        # Centroid coordinates from clustering (y,x) might be float
-        center_x = int(round(y)) # Note: (y,x) from clustering means y is row (height), x is column (width)
-        center_y = int(round(x)) # PIL expects (x, y) for drawing, so swap
+    centroids : list of [int, int]
+        List of (y, x) coordinates marking the centers of regions of interest. These are typically damage sites
+        identified in preprocessing (e.g., clustering).
+
+    window_size : list of int, optional
+        Size [height, width] of each extracted image patch. Defaults to [250, 250].
+
+    Returns
+    -------
+    list of np.ndarray
+        List of extracted and normalized 3-channel image patches, each with shape (height, width, 3). Only
+        centroids that allow full window extraction within image bounds are used.
+    """
+    if panorama.ndim == 2:
+        panorama = np.expand_dims(panorama, axis=-1)  # (H, W, 1)
 
-        box_size = 10 # Smaller box for clarity
-        
-        # Calculate box corners, clamping to image boundaries
-        x1 = max(0, center_x - box_size)
-        y1 = max(0, center_y - box_size)
-        x2 = min(img.width, center_x + box_size)
-        y2 = min(img.height, center_y + box_size)
+    H, W, _ = panorama.shape
+    win_h, win_w = window_size
+    images = []
 
-        fill_color = colors.get(label, "white")
-        outline_color = "black"
+    for (cy, cx) in centroids:
+        x1 = int(cx - win_w / 2)
+        y1 = int(cy - win_h / 2)
+        x2 = x1 + win_w
+        y2 = y1 + win_h
 
-        draw.rectangle([x1, y1, x2, y2], fill=fill_color, outline=outline_color, width=2)
-        
-        # Draw text label slightly offset
-        text_offset_x = 5
-        text_offset_y = -15
-        try:
-            draw.text((x1 + text_offset_x, y1 + text_offset_y), label, fill=outline_color)
-        except Exception as e:
-            logging.warning(f"Could not draw text label '{label}': {e}")
+        # Skip if patch would go out of bounds
+        if x1 < 0 or y1 < 0 or x2 > W or y2 > H:
+            continue
 
+        # Extract and normalize patch
+        patch = panorama[y1:y2, x1:x2, 0].astype(np.float32)
+        patch = patch * 2. / 255. - 1.
 
-    if save_image and image_path:
-        try:
-            img.save(image_path)
-            logging.info(f"Image saved to {image_path}")
-        except Exception as e:
-            logging.error(f"Could not save image to {image_path}: {e}")
+        # Replicate grayscale channel to simulate RGB
+        patch_color = np.repeat(patch[:, :, np.newaxis], 3, axis=2)
+        images.append(patch_color)
+
+    return images
+
+
+
+
+
+
+        
     
-    return img