Upload 3 files

app.py

@@ -2,8 +2,9 @@ from flask import Flask, jsonify, request, send_file, render_template
 from flask_cors import CORS
 from lrp_pipeline_2 import lrp_main
 from utils import create_folders, delete_folders, create_zip_file
-from cam_pipeline import cam_main
+from cam_pipeline import cam_main, cam_process_single_image
 import os
+import base64
 
 app = Flask(__name__)
 CORS(app)
@@ -36,22 +37,68 @@ def submit_data():
     # then upload the submitted file(s)
     file = list(dict(request.files).values())[0]
     print(file)
-    file.save(os.path.join(uploads_dir, file.filename))  # Save to 'uploads' directory
+    file_path = os.path.join(uploads_dir, file.filename)
+    file.save(file_path)  # Save to 'uploads' directory
 
     # Process data here
-    return jsonify({"message": "Data received successfully!"})
+    return jsonify({
+        "message": "Data received successfully!",
+        "file_path": file_path
+    })
 
 
 @app.route("/api/inputform", methods=["POST"])
 def submit_form():
     data = dict(request.json)  # format of data: {'model': 'VGGNet', 'xaiMethod': 'LRP'}
     print(data)
+    
+    # Check if we have images in the uploads directory
+    uploads_dir = "uploads"
+    image_files = [f for f in os.listdir(uploads_dir) 
+                   if f.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp')) 
+                   and not f.startswith('.')]
+    
+    if not image_files:
+        return jsonify({"error": "No images found in uploads directory"}), 400
+        
+    # Process the first image (or all images based on your requirements)
+    image_path = os.path.join(uploads_dir, image_files[0])
+    
     if "LRP" in data["xaiMethod"]:
-        # pixel_ratio = data['pixelRatio']
-        return lrp_main(float(data["magval"]))  # pixel_ratio
+        result_dict = lrp_main(float(data["magval"]))
+        # Extract relevant results to show in the frontend
+        return jsonify({
+            "success": True,
+            "summary": f"LRP analysis completed with magnification {data['magval']}",
+            "details": "Nucleus and cytoplasm segmented successfully",
+            "results": result_dict
+        })
+        
     elif "GradCAM++" in data["xaiMethod"]:
-        # pixel_ratio = data['pixelRatio']
-        return cam_main(float(data["magval"]))  # pixel_ratio
+        # Process single image with GradCAM++
+        result_dict, output_paths = cam_process_single_image(image_path, float(data["magval"]))
+        
+        # Read and encode the output files for display
+        original_image = base64.b64encode(open(image_path, "rb").read()).decode("utf-8")
+        heatmap_image = base64.b64encode(open(output_paths["heatmap"], "rb").read()).decode("utf-8")
+        mask_image = base64.b64encode(open(output_paths["mask"], "rb").read()).decode("utf-8")
+        table_image = base64.b64encode(open(output_paths["table"], "rb").read()).decode("utf-8")
+
+        # include predicted class from the pipeline result
+        predicted_class = result_dict.get("class1")
+        
+        return jsonify({
+            "success": True,
+            "summary": f"GradCAM++ analysis completed with magnification {data['magval']}",
+            "details": "Nucleus and cytoplasm segmented successfully",
+            "classification": predicted_class,
+            "results": {
+                "originalImage": original_image,
+                "heatmapImage": heatmap_image,
+                "maskImage": mask_image,
+                "tableImage": table_image
+            }
+        })
 
 
 @app.route("/api/zip", methods=["GET"])
@@ -61,4 +108,4 @@ def get_csv():
 
 
 if __name__ == "__main__":
-    app.run(debug=True)
+    app.run(host="0.0.0.0",debug=True)

cam_pipeline.py

@@ -7,7 +7,8 @@ import cv2
 from sklearn.mixture import GaussianMixture
 import base64
 import csv
-from tensorflow.keras.applications.efficientnet import preprocess_input
+from simple_lama_inpainting import SimpleLama
+from tensorflow.keras.applications.xception import preprocess_input as xception_preprocess
 from tensorflow.keras.preprocessing import image
 from tensorflow.keras.models import Model
 from tensorflow.keras.layers import Lambda
@@ -16,6 +17,7 @@ from utils import (
     select_sample_images,
     create_cell_descriptors_table,
     calculate_cell_descriptors,
+    create_folders,
 )
 
 preprocessed_folder = 'uploads/'
@@ -24,14 +26,19 @@ intermediate_folder = 'heatmaps/'
 tables_folder = "tables/"
 cell_descriptors_path = "cell_descriptors/cell_descriptors.csv"
 saved_model_path = 'xception_model_81.h5'  # Replace with the path to your saved model
+
 model = load_model(saved_model_path)
 
+# add mapping from model output index to human-readable class
+imgclasses = {0: "abnormal", 1: "normal"}
+
 
 def preprocess_image(img_path):
     img = image.load_img(img_path, target_size=(224, 224))
     x = image.img_to_array(img)
     x = np.expand_dims(x, axis=0)
-    x = preprocess_input(x)
+    # Use Xception preprocessing to match the saved Xception model
+    x = xception_preprocess(x)
     return x
 
 def generate_grad_cam_plus_plus(img_path, model, last_conv_layer_name, classifier_layer_names):
@@ -255,31 +262,31 @@ def create_background(img,heatmap,labels):
 
   return output_image
 
-# def remove_nucleus(image, blue_mask):
-#   #expand the nucleus mask
-#   image1 = cv2.resize(image, (224,224))
-#   blue_mask1 = cv2.resize(blue_mask, (224,224))
-#   kernel = np.ones((5, 5), np.uint8)  # Adjust the kernel size as needed
-#   expandedmask = cv2.dilate(blue_mask1, kernel, iterations=1)
-#   simple_lama = SimpleLama()
-#   image_pil = Image.fromarray(cv2.cvtColor(image1, cv2.COLOR_BGR2RGB))
-#   mask_pil = Image.fromarray(expandedmask)
-#   result = simple_lama(image_pil, mask_pil)
-#   result_cv2 = np.array(result)
-#   result_cv2 = cv2.cvtColor(result_cv2, cv2.COLOR_RGB2BGR)
-#   # result_cv2 = cv2.resize(result_cv2, (x,y))
-#   return expandedmask, result_cv2
-
-# def get_nucleus_mask(nucleus): #image_path, x, y
-#   # nucleus = cv2.imread(nucleus)
-#   # Convert image to HSV color space
-#   hsv_image = cv2.cvtColor(nucleus, cv2.COLOR_BGR2HSV)
-#   # Define lower and upper bounds for blue color in HSV
-#   lower_blue = np.array([100, 50, 50])
-#   upper_blue = np.array([130, 255, 255])
-#   # Create a mask for blue color
-#   blue_mask = cv2.inRange(hsv_image, lower_blue, upper_blue)
-#   return blue_mask #, image
+def remove_nucleus(image, blue_mask):
+  #expand the nucleus mask
+  image1 = cv2.resize(image, (224,224))
+  blue_mask1 = cv2.resize(blue_mask, (224,224))
+  kernel = np.ones((5, 5), np.uint8)  # Adjust the kernel size as needed
+  expandedmask = cv2.dilate(blue_mask1, kernel, iterations=1)
+  simple_lama = SimpleLama()
+  image_pil = Image.fromarray(cv2.cvtColor(image1, cv2.COLOR_BGR2RGB))
+  mask_pil = Image.fromarray(expandedmask)
+  result = simple_lama(image_pil, mask_pil)
+  result_cv2 = np.array(result)
+  result_cv2 = cv2.cvtColor(result_cv2, cv2.COLOR_RGB2BGR)
+  # result_cv2 = cv2.resize(result_cv2, (x,y))
+  return expandedmask, result_cv2
+
+def get_nucleus_mask(nucleus): #image_path, x, y
+  # nucleus = cv2.imread(nucleus)
+  # Convert image to HSV color space
+  hsv_image = cv2.cvtColor(nucleus, cv2.COLOR_BGR2HSV)
+  # Define lower and upper bounds for blue color in HSV
+  lower_blue = np.array([100, 50, 50])
+  upper_blue = np.array([130, 255, 255])
+  # Create a mask for blue color
+  blue_mask = cv2.inRange(hsv_image, lower_blue, upper_blue)
+  return blue_mask #, image
 
 def save_heatmap(heatmap,img_path,heatmap_path):
   img = cv2.imread(img_path)
@@ -349,6 +356,7 @@ def cam_main(pixel_conversion):
 
     pred_class = model.predict(preprocess_image(image_path))
     pred_class = pred_class.argmax(axis=1)[0]
+    class_name = imgclasses.get(pred_class, str(pred_class))
 
     # print(pred_class)
 
@@ -363,9 +371,9 @@ def cam_main(pixel_conversion):
 
     nucleus= create_nucelus(image,colored_segmentation_mask)
 
-    # blue_mask = get_nucleus_mask(nucleus)
+    blue_mask = get_nucleus_mask(nucleus)
 
-    # expandedmask, result_cv2 = remove_nucleus(image, blue_mask)
+    expandedmask, result_cv2 = remove_nucleus(image, blue_mask)
 
     background=create_background(image,heatmap,labels)
 
@@ -380,7 +388,7 @@ def cam_main(pixel_conversion):
           elif original_color == (0,0,0):
               combined_mask[i, j] = np.array((128,0,0))
 
-    # combined_mask = cv2.resize(combined_mask, (224,224))
+    combined_mask = cv2.resize(combined_mask, (224,224))
 
     cv2.imwrite(save_path,combined_mask)
 
@@ -412,6 +420,9 @@ def cam_main(pixel_conversion):
         return_dict[f"table{return_dict_count}"] = str(
             base64.b64encode(open(table_path, "rb").read()).decode("utf-8")
         )
+        # add predicted class so frontend can show it
+        return_dict[f"class{return_dict_count}"] = class_name
+
         return_dict_count += 1
 
     count+=1
@@ -429,3 +440,112 @@ def cam_main(pixel_conversion):
     
 
 # cam_main(0.2)
+
+
+# ================= Single Image Entry Point =================
+def cam_process_single_image(image_path: str, pixel_conversion: float):
+  """
+  Run the CAM pipeline on a single image file path.
+
+  Inputs:
+    - image_path: str, path to an image file (jpg/png/bmp...)
+    - pixel_conversion: float, microns-per-pixel (or similar) conversion used in area calculation
+
+  Returns:
+    - return_dict: dict with base64-encoded 'image1', 'inter1', 'mask1', 'table1'
+    - output_paths: dict with file paths for 'heatmap', 'mask', 'table'
+  """
+  # Ensure output folders exist
+  folder_names = [
+      "uploads",
+      "heatmaps",
+      "segmentations",
+      "tables",
+      "cell_descriptors",
+  ]
+  create_folders(folder_names)
+
+  # Derive output file paths
+  base_name = os.path.splitext(os.path.basename(image_path))[0].lower()
+  intermediate_path = os.path.join(intermediate_folder, f"{base_name}_heatmap.png")
+  save_path = os.path.join(segmentation_folder, f"{base_name}_mask.png")
+  table_path = os.path.join(tables_folder, f"{base_name}_table.png")
+
+  # Generate heatmap
+  heatmap = generate_grad_cam_plus_plus(image_path, model, 'block14_sepconv2_act', ['dense_1'])
+  save_heatmap(heatmap, image_path, intermediate_path)
+
+  # Predict class to choose segmentation strategy
+  pred_class = model.predict(preprocess_image(image_path)).argmax(axis=1)[0]
+  class_name = imgclasses.get(pred_class, str(pred_class))
+  if pred_class == 0:
+    labels, colored_segmentation_mask = GMM_abnormal_method(heatmap)
+  else:
+    labels, colored_segmentation_mask = GMM_normal_method(heatmap)
+
+  # Build combined mask
+  image_cv = cv2.imread(image_path)
+  if image_cv is None:
+    raise ValueError(f"Can't read image: {image_path}")
+  original_shape = image_cv.shape
+  image_resized = cv2.resize(image_cv, (224, 224))
+
+  nucleus = create_nucelus(image_resized, colored_segmentation_mask)
+  background = create_background(image_resized, heatmap, labels)
+  combined_mask = background & nucleus
+
+  # Normalize colors to expected values
+  for i in range(combined_mask.shape[0]):
+    for j in range(combined_mask.shape[1]):
+      original_color = tuple(combined_mask[i, j])
+      if original_color == (128, 0, 0):
+        combined_mask[i, j] = np.array((255, 0, 0))
+      elif original_color == (0, 0, 0):
+        combined_mask[i, j] = np.array((128, 0, 0))
+
+  cv2.imwrite(save_path, combined_mask)
+
+  # Compute descriptors and save table and CSV
+  resized_shape = (224, 224)
+  nucleus_area, cytoplasm_area, ratio = calculate_cell_descriptors(
+      original_shape, resized_shape, pixel_conversion, combined_mask
+  )
+
+  # Save table image
+  create_cell_descriptors_table(table_path, nucleus_area, cytoplasm_area, ratio)
+
+  # Save CSV (header + single row)
+  cell_descriptors = [
+      ["Image Name", "Nucleus Area", "Cytoplasm Area", "Nucleus to Cytoplasm Ratio"],
+      [base_name, nucleus_area, cytoplasm_area, ratio],
+  ]
+  with open(cell_descriptors_path, "w", newline="") as csv_file:
+    writer = csv.writer(csv_file)
+    writer.writerows(cell_descriptors)
+
+  # Build return dict with base64-encoded artifacts and class label
+  return_dict = {
+      "image1": str(base64.b64encode(open(image_path, "rb").read()).decode("utf-8")),
+      "inter1": str(base64.b64encode(open(intermediate_path, "rb").read()).decode("utf-8")),
+      "mask1": str(base64.b64encode(open(save_path, "rb").read()).decode("utf-8")),
+      "table1": str(base64.b64encode(open(table_path, "rb").read()).decode("utf-8")),
+      "class1": class_name
+  }
+
+  output_paths = {"heatmap": intermediate_path, "mask": save_path, "table": table_path}
+  return return_dict, output_paths
+
+
+if __name__ == "__main__":
+  import argparse
+
+  parser = argparse.ArgumentParser(description="Run Grad-CAM++ pipeline on a single image.")
+  parser.add_argument("--image", "-i", required=True, help="Path to the input image file")
+  parser.add_argument("--magval", "-m", required=True, type=float, help="Pixel conversion value (e.g., 0.2)")
+  args = parser.parse_args()
+
+  result, paths = cam_process_single_image(args.image, args.magval)
+  print("Processing complete. Outputs:")
+  print(f"  Heatmap:      {paths['heatmap']}")
+  print(f"  Segmentation: {paths['mask']}")
+  print(f"  Table:        {paths['table']}")

lrp_pipeline_2.py

@@ -94,8 +94,10 @@ def get_LRP_heatmap(image, L, layers, imgclasses, intermediate_path):
     for i in ind[:2]:
         print("%20s (%3d): %6.3f" % (imgclasses[i], i, scores[i]))
 
+    pred_idx = int(ind[0])  # predicted class index
+
     T = torch.FloatTensor(
-        (1.0 * (np.arange(2) == ind[0]).reshape([1, 2, 1, 1]))
+        (1.0 * (np.arange(2) == pred_idx).reshape([1, 2, 1, 1]))
     )  # SET FOR THE HIGHEST SCORE CLASS
     R = [None] * L + [(A[-1] * T).data]
     for l in range(1, L)[::-1]:
@@ -139,7 +141,7 @@ def get_LRP_heatmap(image, L, layers, imgclasses, intermediate_path):
     heatmap(
         np.array(R[0][0].cpu()).sum(axis=0), 2, 2, intermediate_path
     )  # HEATMAPPING TO SEE LRP MAPS WITH NEW RULE
-    return R[0][0].cpu()
+    return R[0][0].cpu(), pred_idx
 
 
 def get_nucleus_mask_for_graphcut(R):
@@ -339,7 +341,7 @@ def lrp_main(pixel_conversion):
             print(imagefile)
             continue
         image_path = (
-            preprocessed_folder + os.path.splitext(imagefile)[0].lower() + ".png"
+            preprocessed_folder + os.path.splitext(imagefile)[0].lower() + ".jpg"
         )
         intermediate_path = (
             intermediate_folder
@@ -360,7 +362,7 @@ def lrp_main(pixel_conversion):
         image = cv2.resize(image, (128, 128))
 
         layers_copy = copy.deepcopy(layers)
-        R = get_LRP_heatmap(image, L, layers_copy, imgclasses, intermediate_path)
+        R, pred_idx = get_LRP_heatmap(image, L, layers_copy, imgclasses, intermediate_path)
 
         rel_grouping = get_nucleus_mask_for_graphcut(R)
 
@@ -401,6 +403,9 @@ def lrp_main(pixel_conversion):
             return_dict[f"table{return_dict_count}"] = str(
                 base64.b64encode(open(table_path, "rb").read()).decode("utf-8")
             )
+            # include class label for frontend
+            return_dict[f"class{return_dict_count}"] = imgclasses.get(pred_idx, str(pred_idx))
+
             return_dict_count += 1
 
         i += 1