Update app.py

app.py

@@ -3,16 +3,13 @@ import cv2
 import numpy as np
 import pandas as pd
 import pydicom
-import io
-import os
-from PIL import Image
 import tempfile
+import os
 
 class DicomAnalyzer:
     def __init__(self):
         self.results = []
         self.circle_diameter = 9
-        self.zoom_factor = 1.0
         self.current_image1 = None
         self.current_image2 = None
         self.dicom_data1 = None
@@ -24,47 +21,37 @@ class DicomAnalyzer:
 
     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)
-            
+
             # Apply rescale slope and intercept
             rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
             rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
             image = (image * rescale_slope) + rescale_intercept
-            
-            # Store original image for analysis
-            original_image = image.copy()
-            
+
             # Normalize for display
             image_display = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
-            
-            # Convert to BGR for visualization
-            if len(image_display.shape) == 2:
-                image_display = cv2.cvtColor(image_display, cv2.COLOR_GRAY2BGR)
-            
-            return original_image, image_display, dicom_data
+            image_display = cv2.cvtColor(image_display, cv2.COLOR_GRAY2BGR)
+
+            return image, image_display, dicom_data
         except Exception as e:
             print(f"Error loading DICOM file: {str(e)}")
             return None, None, None
 
     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 within the circle
+            # Extract pixel values
             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)
@@ -81,87 +68,75 @@ class DicomAnalyzer:
             print(f"Error analyzing point: {str(e)}")
             return None
 
-def draw_circle(self, image, x, y, is_image1=True):
-    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,  # 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))
-            
-        return image_copy
-    except Exception as e:
-        print(f"Error drawing circle: {str(e)}")
-        return image
-
-
-    def handle_click1(self, evt: gr.SelectData):
-        if self.current_image1 is None:
-            return self.image_display1, "Please load Image 1 first"
-        
+    def draw_circle(self, image, x, y, is_image1=True):
         try:
-            x, y = evt.index
-            marked_image = self.draw_circle(self.image_display1, x, y, is_image1=True)
-            self.image_display1 = marked_image
-            
-            results = self.analyze_point(self.current_image1, self.dicom_data1, x, y)
-            if results:
-                results['Image'] = "Image 1"
-                results['Point'] = f"({x}, {y})"
-                self.results.append(results)
-                
-            return self.image_display1, self.format_results()
+            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
+
+            # Store the new mark
+            if is_image1:
+                self.marks1.append((x, y))
+            else:
+                self.marks2.append((x, y))
+
+            return image_copy
         except Exception as e:
-            print(f"Error in handle_click1: {str(e)}")
-            return self.image_display1, f"Error: {str(e)}"
-
-    def handle_click2(self, evt: gr.SelectData):
-        if self.current_image2 is None:
+            print(f"Error drawing circle: {str(e)}")
+            return image
+
+    def process_image1(self, file):
+        image, image_display, dicom_data = self.load_dicom(file)
+        self.current_image1 = image
+        self.image_display1 = image_display
+        self.dicom_data1 = dicom_data
+        return image_display
+
+    def process_image2(self, file):
+        image, image_display, dicom_data = self.load_dicom(file)
+        self.current_image2 = image
+        self.image_display2 = image_display
+        self.dicom_data2 = dicom_data
+        return image_display
+
+    def handle_click(self, evt: gr.SelectData, is_image1=True):
+        if is_image1 and self.current_image1 is None:
+            return self.image_display1, "Please load Image 1 first"
+        elif not is_image1 and self.current_image2 is None:
             return self.image_display2, "Please load Image 2 first"
-        
+
         try:
             x, y = evt.index
-            marked_image = self.draw_circle(self.image_display2, x, y, is_image1=False)
-            self.image_display2 = marked_image
-            
-            results = self.analyze_point(self.current_image2, self.dicom_data2, x, y)
+            if is_image1:
+                marked_image = self.draw_circle(self.image_display1, x, y, is_image1=True)
+                self.image_display1 = marked_image
+                results = self.analyze_point(self.current_image1, self.dicom_data1, x, y)
+            else:
+                marked_image = self.draw_circle(self.image_display2, x, y, is_image1=False)
+                self.image_display2 = marked_image
+                results = self.analyze_point(self.current_image2, self.dicom_data2, x, y)
+
             if results:
-                results['Image'] = "Image 2"
+                results['Image'] = "Image 1" if is_image1 else "Image 2"
                 results['Point'] = f"({x}, {y})"
                 self.results.append(results)
-                
-            return self.image_display2, self.format_results()
+
+            return marked_image, self.format_results()
         except Exception as e:
-            print(f"Error in handle_click2: {str(e)}")
-            return self.image_display2, f"Error: {str(e)}"
+            print(f"Error in handle_click: {str(e)}")
+            return (self.image_display1 if is_image1 else self.image_display2), f"Error: {str(e)}"
 
     def format_results(self):
         if not self.results:
@@ -185,36 +160,14 @@ def draw_circle(self, image, x, y, is_image1=True):
             )
         return "Results cleared", self.image_display1, self.image_display2
 
-    def add_blank_row(self):
-        self.results.append({
-            'Image': '',
-            'Point': '',
-            'Area (mm²)': '',
-            'Mean': '',
-            'StdDev': '',
-            'Min': '',
-            'Max': ''
-        })
-        return self.format_results()
-
-    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
+            temp_file = os.path.join(tempfile.gettempdir(), "analysis_results.xlsx")
             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)}")
@@ -222,73 +175,33 @@ def draw_circle(self, image, x, y, is_image1=True):
 
 def create_interface():
     analyzer = DicomAnalyzer()
-    
+
     with gr.Blocks() as interface:
         gr.Markdown("# CT DICOM Image Analyzer")
-        
-        with gr.Row():
-            with gr.Column():
-                file1 = gr.File(label="Upload first DICOM file")
-                image1 = gr.Image(label="Image 1", interactive=True, type="numpy")
-                file1.change(fn=analyzer.process_image1, inputs=file1, outputs=image1)
-            
-            with gr.Column():
-                file2 = gr.File(label="Upload second DICOM file")
-                image2 = gr.Image(label="Image 2", interactive=True, type="numpy")
-                file2.change(fn=analyzer.process_image2, inputs=file2, outputs=image2)
-        
-        with gr.Row():
-            circle_diameter = gr.Slider(
-                minimum=1, 
-                maximum=20, 
-                value=9, 
-                step=1, 
-                label="Circle Diameter"
-            )
-        
+
         with gr.Row():
-            clear_btn = gr.Button("Clear Results")
-            blank_row_btn = gr.Button("Add Blank Row")
-            save_btn = gr.Button("Save Results")
-        
+            file1 = gr.File(label="Upload first DICOM file")
+            image1 = gr.Image(label="Image 1", interactive=True, type="numpy")
+            file1.change(fn=analyzer.process_image1, inputs=file1, outputs=image1)
+
+            file2 = gr.File(label="Upload second DICOM file")
+            image2 = gr.Image(label="Image 2", interactive=True, type="numpy")
+            file2.change(fn=analyzer.process_image2, inputs=file2, outputs=image2)
+
+        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=None)
+
         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
-        )
-        
-        image1.select(
-            fn=analyzer.handle_click1, 
-            outputs=[image1, results]
-        )
-        
-        image2.select(
-            fn=analyzer.handle_click2, 
-            outputs=[image2, results]
-        )
-        
-        clear_btn.click(
-            fn=analyzer.clear_results, 
-            outputs=[status, image1, image2]
-        )
-        
-        blank_row_btn.click(
-            fn=analyzer.add_blank_row, 
-            outputs=results
-        )
-        
-        save_btn.click(
-            fn=analyzer.save_results, 
-            outputs=[file_output, status]
-        )
+        clear_btn = gr.Button("Clear Results")
+        save_btn = gr.Button("Save Results")
+
+        image1.select(fn=lambda evt: analyzer.handle_click(evt, is_image1=True), outputs=[image1, results])
+        image2.select(fn=lambda evt: analyzer.handle_click(evt, is_image1=False), outputs=[image2, results])
+        clear_btn.click(fn=analyzer.clear_results, outputs=[results, image1, image2])
+        save_btn.click(fn=analyzer.save_results, outputs=["file", results])
 
     return interface
 
 if __name__ == "__main__":
     interface = create_interface()
-    interface.launch()
+    interface.launch()