Update app.py

app.py

@@ -4,23 +4,21 @@ import numpy as np
 import pandas as pd
 import pydicom
 import tempfile
-import os
 
 class DicomAnalyzer:
     def __init__(self):
         self.results = []
         self.circle_diameter = 9
-        self.current_image1 = None
-        self.current_image2 = None
-        self.dicom_data1 = None
-        self.dicom_data2 = None
-        self.image_display1 = None
-        self.image_display2 = None
-        self.marks1 = []
-        self.marks2 = []
+        self.current_image = None
+        self.dicom_data = None
+        self.image_display = None
+        self.marks = []
 
     def load_dicom(self, file):
         try:
+            if file is None:
+                return None, None, None
+
             dicom_data = pydicom.dcmread(file.name)
             image = dicom_data.pixel_array.astype(np.float32)
 
@@ -31,7 +29,10 @@ class DicomAnalyzer:
 
             # Normalize for display
             image_display = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
-            image_display = cv2.cvtColor(image_display, cv2.COLOR_GRAY2BGR)
+
+            # Convert to BGR for visualization
+            if len(image_display.shape) == 2:
+                image_display = cv2.cvtColor(image_display, cv2.COLOR_GRAY2BGR)
 
             return image, image_display, dicom_data
         except Exception as e:
@@ -40,18 +41,19 @@ class DicomAnalyzer:
 
     def analyze_point(self, image, dicom_data, x, y):
         try:
+            # Create a circular mask
             mask = np.zeros_like(image, dtype=np.uint8)
             y_indices, x_indices = np.ogrid[:image.shape[0], :image.shape[1]]
-            distance_from_center = np.sqrt((x_indices - x) ** 2 + (y_indices - y) ** 2)
+            distance_from_center = np.sqrt((x_indices - x)**2 + (y_indices - y)**2)
             mask[distance_from_center <= self.circle_diameter / 2] = 1
 
-            # Extract pixel values
+            # Extract pixel values within the circle
             pixels = image[mask == 1]
 
             # Calculate metrics
             area_pixels = np.sum(mask)
             pixel_spacing = float(dicom_data.PixelSpacing[0])
-            area_mm2 = area_pixels * (pixel_spacing ** 2)
+            area_mm2 = area_pixels * (pixel_spacing**2)
             mean = np.mean(pixels)
             stddev = np.std(pixels)
             min_val = np.min(pixels)
@@ -68,39 +70,108 @@ class DicomAnalyzer:
             print(f"Error analyzing point: {str(e)}")
             return None
 
-    def draw_circle(self, image, x, y, is_image1=True):
+    def draw_circle(self, image, x, y):
         try:
             image_copy = image.copy()
 
             # Draw all previous marks
-            marks = self.marks1 if is_image1 else self.marks2
-            for mark_x, mark_y in marks:
-                cv2.circle(image_copy, (int(mark_x), int(mark_y)), int(self.circle_diameter / 2),
-                           (0, 255, 255), 2, lineType=cv2.LINE_AA)  # Yellow outer ring
-                cv2.circle(image_copy, (int(mark_x), int(mark_y)), int(self.circle_diameter / 2) - 2,
-                           (255, 255, 255), 1, lineType=cv2.LINE_AA)  # White inner ring
-
-            # Draw new mark
-            cv2.circle(image_copy, (int(x), int(y)), int(self.circle_diameter / 2),
-                       (0, 255, 255), 2, lineType=cv2.LINE_AA)  # Yellow outer ring
-            cv2.circle(image_copy, (int(x), int(y)), int(self.circle_diameter / 2) - 2,
-                       (255, 255, 255), 1, lineType=cv2.LINE_AA)  # White inner ring
+            for mark_x, mark_y in self.marks:
+                cv2.circle(image_copy, 
+                          (int(mark_x), int(mark_y)), 
+                          int(self.circle_diameter / 2), 
+                          (0, 255, 255), 2,  # Yellow outer ring
+                          lineType=cv2.LINE_AA)
+                cv2.circle(image_copy,
+                          (int(mark_x), int(mark_y)),
+                          int(self.circle_diameter / 2) - 2,
+                          (255, 255, 255), 1,  # White inner ring
+                          lineType=cv2.LINE_AA)
+
+            # Draw the new mark
+            cv2.circle(image_copy, 
+                      (int(x), int(y)), 
+                      int(self.circle_diameter / 2), 
+                      (0, 255, 255), 2,  # Yellow outer ring
+                      lineType=cv2.LINE_AA)
+            cv2.circle(image_copy, 
+                      (int(x), int(y)), 
+                      int(self.circle_diameter / 2) - 2, 
+                      (255, 255, 255), 1,  # White inner ring
+                      lineType=cv2.LINE_AA)
 
             # Store the new mark
-            if is_image1:
-                self.marks1.append((x, y))
-            else:
-                self.marks2.append((x, y))
-
+            self.marks.append((x, y))
+            
             return image_copy
         except Exception as e:
             print(f"Error drawing circle: {str(e)}")
             return image
 
+    def process_image(self, file):
+        image, image_display, dicom_data = self.load_dicom(file)
+        self.current_image = image
+        self.image_display = image_display
+        self.dicom_data = dicom_data
+        return image_display
+
+    def handle_click(self, evt: gr.SelectData):
+        if self.current_image is None:
+            return self.image_display, "Please load the DICOM file first"
+
+        try:
+            x, y = evt.index
+            marked_image = self.draw_circle(self.image_display, x, y)
+            self.image_display = marked_image
+
+            results = self.analyze_point(self.current_image, self.dicom_data, x, y)
+            if results:
+                results['Point'] = f"({x}, {y})"
+                self.results.append(results)
+
+            return self.image_display, self.format_results()
+        except Exception as e:
+            print(f"Error in handle_click: {str(e)}")
+            return self.image_display, f"Error: {str(e)}"
+
+    def format_results(self):
+        if not self.results:
+            return "No results yet"
+        df = pd.DataFrame(self.results)
+        return df.to_string()
+
+    def clear_results(self):
+        self.results = []
+        self.marks = []
+        if self.current_image is not None:
+            self.image_display = cv2.cvtColor(
+                cv2.normalize(self.current_image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8),
+                cv2.COLOR_GRAY2BGR
+            )
+        return "Results cleared", self.image_display
+
     def update_circle_diameter(self, value):
         self.circle_diameter = value
         return f"Circle diameter set to {value}"
 
+    def save_results(self):
+        try:
+            if not self.results:
+                return None, "No results to save"
+
+            df = pd.DataFrame(self.results)
+
+            # Create temporary file
+            temp_dir = tempfile.gettempdir()
+            temp_file = os.path.join(temp_dir, "analysis_results.xlsx")
+
+            # Save to Excel
+            df.to_excel(temp_file, index=False, engine='openpyxl')
+
+            return temp_file, "Results saved successfully. Click to download."
+        except Exception as e:
+            print(f"Error saving results: {str(e)}")
+            return None, f"Error saving results: {str(e)}"
+
 def create_interface():
     analyzer = DicomAnalyzer()
 
@@ -108,14 +179,48 @@ def create_interface():
         gr.Markdown("# CT DICOM Image Analyzer")
 
         with gr.Row():
-            file1 = gr.File(label="Upload DICOM file")
-            image1 = gr.Image(label="DICOM Image", interactive=True, type="numpy")
-            file1.change(fn=analyzer.load_dicom, inputs=file1, outputs=image1)
+            file = gr.File(label="Upload DICOM File")
+            image = gr.Image(label="DICOM Image", interactive=True, type="numpy")
+            file.change(fn=analyzer.process_image, inputs=file, outputs=image)
 
-        circle_diameter = gr.Slider(minimum=1, maximum=20, value=9, step=1, label="Circle Diameter")
-        status = gr.Textbox(label="Status", interactive=False)
+        with gr.Row():
+            circle_diameter = gr.Slider(
+                minimum=1,
+                maximum=20,
+                value=9,
+                step=1,
+                label="Circle Diameter"
+            )
 
-        circle_diameter.change(fn=analyzer.update_circle_diameter, inputs=circle_diameter, outputs=status)
+        with gr.Row():
+            clear_btn = gr.Button("Clear Results")
+            save_btn = gr.Button("Save Results")
+
+        results = gr.Textbox(label="Results", interactive=False)
+        file_output = gr.File(label="Download Results")
+        status = gr.Textbox(label="Status")
+
+        # Connect events
+        circle_diameter.change(
+            fn=analyzer.update_circle_diameter,
+            inputs=circle_diameter,
+            outputs=status
+        )
+
+        image.select(
+            fn=analyzer.handle_click,
+            outputs=[image, results]
+        )
+
+        clear_btn.click(
+            fn=analyzer.clear_results,
+            outputs=[status, image]
+        )
+
+        save_btn.click(
+            fn=analyzer.save_results,
+            outputs=[file_output, status]
+        )
 
     return interface