remove some debug output

app.py

@@ -57,7 +57,8 @@ def damage_classification(SEM_image,image_threshold, model1_threshold, model2_th
     ##
     logging.debug('---------------: clustering :=====================')
     all_centroids = clustering.get_centroids(SEM_image, image_threshold=image_threshold,
-                                            fill_holes=True, filter_close_centroids=True)
+                                            fill_holes=True, filter_close_centroids=True,
+                                            filter_radius=90)
     
     for i in range(len(all_centroids)) :
         key = (all_centroids[i][0],all_centroids[i][1])
@@ -68,8 +69,10 @@ def damage_classification(SEM_image,image_threshold, model1_threshold, model2_th
     ##
     logging.debug('---------------: prepare model 1 :=====================')
     images_model1 = utils.prepare_classifier_input(SEM_image, all_centroids, window_size=model1_windowsize)
-    from utils import debug_classification_input
-    debug_classification_input(images_model1)
+
+    # debugging function to check the input to the classifier
+    #from utils import debug_classification_input
+    #debug_classification_input(images_model1)
     
     logging.debug('---------------: run model 1 :=====================')
     #y1_pred = model1.predict(np.asarray(images_model1, float))
@@ -89,7 +92,6 @@ def damage_classification(SEM_image,image_threshold, model1_threshold, model2_th
     logging.debug(f"Model 1 predictions shape: {y1_pred.shape}")
     logging.debug(f"Model 1 predictions sample: {y1_pred[:3] if len(y1_pred) > 0 else 'Empty'}")
     
-    logging.info('---------------: model1 threshold :=====================')
     # Handle predictions based on their shape
     if len(y1_pred.shape) == 2:
         # Predictions are 2D: (batch_size, num_classes)
@@ -101,10 +103,10 @@ def damage_classification(SEM_image,image_threshold, model1_threshold, model2_th
         raise ValueError(f"Unexpected prediction shape: {y1_pred.shape}")
 
 
-    logging.info('---------------: model1 threshold :=====================')
+    logging.debug('---------------: model1 threshold :=====================')
     inclusions = np.where(inclusions > model1_threshold)
-    logging.info('Inclusions found at indices:')
-    logging.info(inclusions)
+    logging.debug('Inclusions found at indices:')
+    logging.debug(inclusions)
 
 
     logging.debug('---------------: model 1 update dict :=====================')

utils.py

@@ -48,19 +48,19 @@ def show_boxes(image : np.ndarray, damage_sites : dict, box_size = [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.
     """
-    logging.info(f"show_boxes: Input image type: {type(image)}") # Added logging
+    logging.debug(f"show_boxes: Input image type: {type(image)}") 
 
     # Ensure image is a NumPy array of appropriate type for matplotlib
     if isinstance(image, Image.Image):
         image_to_plot = np.array(image.convert('L')) # Convert to grayscale NumPy array
-        logging.info("show_boxes: Converted PIL Image to grayscale NumPy array for plotting.")
+        logging.debug("show_boxes: Converted PIL Image to grayscale NumPy array for plotting.")
     elif isinstance(image, np.ndarray):
         if image.ndim == 3 and image.shape[2] in [3,4]: # RGB or RGBA NumPy array
             image_to_plot = np.mean(image, axis=2).astype(image.dtype) # Convert to grayscale
-            logging.info("show_boxes: Converted multi-channel NumPy array to grayscale for plotting.")
+            logging.debug("show_boxes: Converted multi-channel NumPy array to grayscale for plotting.")
         else: # Assume grayscale already
             image_to_plot = image
-            logging.info("show_boxes: Image is already a grayscale NumPy array.")
+            logging.debug("show_boxes: Image is already a grayscale NumPy array.")
     else:
         logging.error("show_boxes: Unsupported image format received.")
         image_to_plot = np.zeros((100,100), dtype=np.uint8) # Fallback to black image
@@ -253,7 +253,7 @@ def prepare_classifier_input(
         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.
     """
-    logging.info(f"prepare_classifier_input: Input panorama type: {type(panorama)}")
+    logging.debug(f"prepare_classifier_input: Input panorama type: {type(panorama)}")
 
     # Convert input to standardized NumPy array format
     panorama_array = _convert_to_grayscale_array(panorama)
@@ -261,14 +261,14 @@ def prepare_classifier_input(
     # Ensure we have the correct dimensions
     if panorama_array.ndim == 2:
         H, W = panorama_array.shape
-        logging.info("prepare_classifier_input: Working with 2D grayscale array.")
+        logging.debug("prepare_classifier_input: Working with 2D grayscale array.")
     elif panorama_array.ndim == 3:
         H, W, C = panorama_array.shape
         if C == 1:
             # Squeeze the single channel dimension for easier processing
             panorama_array = panorama_array.squeeze(axis=2)
             H, W = panorama_array.shape
-            logging.info("prepare_classifier_input: Squeezed single channel dimension.")
+            logging.debug("prepare_classifier_input: Squeezed single channel dimension.")
         else:
             logging.error(f"prepare_classifier_input: Unexpected number of channels: {C}")
             raise ValueError(f"Expected 1 channel, got {C}")
@@ -369,20 +369,20 @@ def _convert_to_grayscale_array(panorama: Union[Image.Image, np.ndarray]) -> np.
         if panorama.mode in ['RGB', 'RGBA']:
             # Convert to grayscale
             panorama_array = np.array(panorama.convert('L'))
-            logging.info("_convert_to_grayscale_array: Converted RGB/RGBA PIL Image to grayscale.")
+            logging.debug("_convert_to_grayscale_array: Converted RGB/RGBA PIL Image to grayscale.")
         elif panorama.mode == 'L':
             panorama_array = np.array(panorama)
-            logging.info("_convert_to_grayscale_array: Converted grayscale PIL Image to NumPy array.")
+            logging.debug("_convert_to_grayscale_array: Converted grayscale PIL Image to NumPy array.")
         else:
             # Handle other modes by converting to grayscale
             panorama_array = np.array(panorama.convert('L'))
-            logging.info(f"_convert_to_grayscale_array: Converted PIL Image mode '{panorama.mode}' to grayscale.")
+            logging.debug(f"_convert_to_grayscale_array: Converted PIL Image mode '{panorama.mode}' to grayscale.")
             
     elif isinstance(panorama, np.ndarray):
         if panorama.ndim == 2:
             # Already grayscale
             panorama_array = panorama.copy()
-            logging.info("_convert_to_grayscale_array: Using existing 2D grayscale array.")
+            logging.debug("_convert_to_grayscale_array: Using existing 2D grayscale array.")
         elif panorama.ndim == 3:
             if panorama.shape[2] in [3, 4]:  # RGB or RGBA
                 # Convert to grayscale using luminance weights
@@ -390,11 +390,11 @@ def _convert_to_grayscale_array(panorama: Union[Image.Image, np.ndarray]) -> np.
                     panorama_array = np.dot(panorama, [0.299, 0.587, 0.114]).astype(panorama.dtype)
                 else:  # RGBA
                     panorama_array = np.dot(panorama[:, :, :3], [0.299, 0.587, 0.114]).astype(panorama.dtype)
-                logging.info("_convert_to_grayscale_array: Converted multi-channel NumPy array to grayscale using luminance weights.")
+                logging.debug("_convert_to_grayscale_array: Converted multi-channel NumPy array to grayscale using luminance weights.")
             elif panorama.shape[2] == 1:
                 # Already single channel
                 panorama_array = panorama.copy()
-                logging.info("_convert_to_grayscale_array: Using existing single-channel array.")
+                logging.debug("_convert_to_grayscale_array: Using existing single-channel array.")
             else:
                 raise ValueError(f"Unsupported number of channels: {panorama.shape[2]}")
         else:
@@ -498,7 +498,7 @@ def safe_classify_patches(patches: List[np.ndarray], classify_func, **kwargs) ->
         Classification results or None if error occurred
     """
     try:
-        logging.info("Starting safe classification...")
+        logging.debug("Starting safe classification...")
         
         # Debug the input
         debug_classification_input(patches)
@@ -513,15 +513,15 @@ def safe_classify_patches(patches: List[np.ndarray], classify_func, **kwargs) ->
         for i, patch in enumerate(patches):
             if not patch.flags.c_contiguous:
                 patch_clean = np.ascontiguousarray(patch)
-                logging.info(f"Made patch {i} contiguous")
+                logging.debug(f"Made patch {i} contiguous")
             else:
                 patch_clean = patch
             patches_clean.append(patch_clean)
         
         # Call the actual classification function
-        logging.info("Calling classification function...")
+        logging.debug("Calling classification function...")
         result = classify_func(patches_clean, **kwargs)
-        logging.info("Classification completed successfully")
+        logging.debug("Classification completed successfully")
         
         return result
         
@@ -559,8 +559,8 @@ def extract_predictions_from_tfsm(model_output):
     Helper function to extract predictions from TFSMLayer output.
     TFSMLayer often returns a dictionary with multiple outputs.
     """
-    logging.info(f"Model output type: {type(model_output)}")
-    logging.info(f"Model output keys: {model_output.keys() if isinstance(model_output, dict) else 'Not a dict'}")
+    logging.debug(f"Model output type: {type(model_output)}")
+    logging.debug(f"Model output keys: {model_output.keys() if isinstance(model_output, dict) else 'Not a dict'}")
     
     if isinstance(model_output, dict):
         # Try common output key names
@@ -568,22 +568,22 @@ def extract_predictions_from_tfsm(model_output):
         
         # First, log all available keys
         available_keys = list(model_output.keys())
-        logging.info(f"Available output keys: {available_keys}")
+        logging.debug(f"Available output keys: {available_keys}")
         
         # Try to find the right output
         for key in possible_keys:
             if key in model_output:
-                logging.info(f"Using output key: {key}")
+                logging.debug(f"Using output key: {key}")
                 return model_output[key].numpy()
         
         # If no standard key found, use the first available key
         if available_keys:
             first_key = available_keys[0]
-            logging.info(f"Using first available key: {first_key}")
+            logging.debug(f"Using first available key: {first_key}")
             return model_output[first_key].numpy()
         else:
             raise ValueError("No output keys found in model response")
     else:
         # If it's not a dictionary, assume it's already the tensor we need
-        logging.info("Model output is not a dictionary, using directly")
+        logging.debug("Model output is not a dictionary, using directly")
         return model_output.numpy() if hasattr(model_output, 'numpy') else np.array(model_output)