Update app.py

app.py

@@ -4,15 +4,16 @@ 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_image = None
-        self.dicom_data = None
-        self.image_display = None
-        self.marks = []
+        self.current_image1 = None
+        self.image_display1 = None
+        self.dicom_data1 = None
+        self.marks1 = []
 
     def load_dicom(self, file):
         try:
@@ -27,6 +28,9 @@ class DicomAnalyzer:
             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)
 
@@ -34,7 +38,7 @@ class DicomAnalyzer:
             if len(image_display.shape) == 2:
                 image_display = cv2.cvtColor(image_display, cv2.COLOR_GRAY2BGR)
 
-            return image, image_display, dicom_data
+            return original_image, image_display, dicom_data
         except Exception as e:
             print(f"Error loading DICOM file: {str(e)}")
             return None, None, None
@@ -70,72 +74,68 @@ 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:
+    def draw_circle(self, image, x, y):
+        try:
+            image_copy = image.copy()
+
+            # Draw all previous marks
+            for mark_x, mark_y in self.marks1:
+                cv2.circle(image_copy, 
+                          (int(mark_x), int(mark_y)), 
+                          int(self.circle_diameter / 2), 
+                          (255, 255, 0), 1,  # Yellow outer ring (thin)
+                          lineType=cv2.LINE_AA)
+                cv2.circle(image_copy,
+                          (int(mark_x), int(mark_y)),
+                          int(self.circle_diameter / 2) - 1,
+                          (255, 255, 255), 1,  # White inner ring (thin)
+                          lineType=cv2.LINE_AA)
+
+            # Draw the new mark
             cv2.circle(image_copy, 
-                      (int(mark_x), int(mark_y)), 
+                      (int(x), int(y)), 
                       int(self.circle_diameter / 2), 
                       (255, 255, 0), 1,  # Yellow outer ring (thin)
                       lineType=cv2.LINE_AA)
-            cv2.circle(image_copy,
-                      (int(mark_x), int(mark_y)),
-                      int(self.circle_diameter / 2) - 1,  # Slightly smaller radius
+            cv2.circle(image_copy, 
+                      (int(x), int(y)), 
+                      int(self.circle_diameter / 2) - 1, 
                       (255, 255, 255), 1,  # White inner ring (thin)
                       lineType=cv2.LINE_AA)
 
-        # Draw the new mark
-        cv2.circle(image_copy, 
-                  (int(x), int(y)), 
-                  int(self.circle_diameter / 2), 
-                  (255, 255, 0), 1,  # Yellow outer ring (thin)
-                  lineType=cv2.LINE_AA)
-        cv2.circle(image_copy, 
-                  (int(x), int(y)), 
-                  int(self.circle_diameter / 2) - 1, 
-                  (255, 255, 255), 1,  # White inner ring (thin)
-                  lineType=cv2.LINE_AA)
-        
-        # Store the new mark
-        if is_image1:
+            # Store the new mark
             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
+
+            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
+        self.current_image1 = image
+        self.image_display1 = image_display
+        self.dicom_data1 = 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"
+        if self.current_image1 is None:
+            return self.image_display1, "Please load an image first"
 
         try:
             x, y = evt.index
-            marked_image = self.draw_circle(self.image_display, x, y)
-            self.image_display = marked_image
+            marked_image = self.draw_circle(self.image_display1, x, y)
+            self.image_display1 = marked_image
 
-            results = self.analyze_point(self.current_image, self.dicom_data, x, y)
+            results = self.analyze_point(self.current_image1, self.dicom_data1, x, y)
             if results:
                 results['Point'] = f"({x}, {y})"
                 self.results.append(results)
 
-            return self.image_display, self.format_results()
+            return self.image_display1, self.format_results()
         except Exception as e:
             print(f"Error in handle_click: {str(e)}")
-            return self.image_display, f"Error: {str(e)}"
+            return self.image_display1, f"Error: {str(e)}"
 
     def format_results(self):
         if not self.results:
@@ -145,13 +145,13 @@ class DicomAnalyzer:
 
     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),
+        self.marks1 = []
+        if self.current_image1 is not None:
+            self.image_display1 = cv2.cvtColor(
+                cv2.normalize(self.current_image1, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8),
                 cv2.COLOR_GRAY2BGR
             )
-        return "Results cleared", self.image_display
+        return "Results cleared", self.image_display1
 
     def update_circle_diameter(self, value):
         self.circle_diameter = value
@@ -183,16 +183,17 @@ def create_interface():
         gr.Markdown("# CT DICOM Image Analyzer")
 
         with gr.Row():
-            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)
+            with gr.Column():
+                file1 = gr.File(label="Upload DICOM file")
+                image1 = gr.Image(label="DICOM Image", interactive=True, type="numpy")
+                file1.change(fn=analyzer.process_image, inputs=file1, outputs=image1)
 
         with gr.Row():
             circle_diameter = gr.Slider(
-                minimum=1,
-                maximum=20,
-                value=9,
-                step=1,
+                minimum=1, 
+                maximum=20, 
+                value=9, 
+                step=1, 
                 label="Circle Diameter"
             )
 
@@ -206,23 +207,23 @@ def create_interface():
 
         # Connect events
         circle_diameter.change(
-            fn=analyzer.update_circle_diameter,
-            inputs=circle_diameter,
+            fn=analyzer.update_circle_diameter, 
+            inputs=circle_diameter, 
             outputs=status
         )
 
-        image.select(
-            fn=analyzer.handle_click,
-            outputs=[image, results]
+        image1.select(
+            fn=analyzer.handle_click, 
+            outputs=[image1, results]
         )
 
         clear_btn.click(
-            fn=analyzer.clear_results,
-            outputs=[status, image]
+            fn=analyzer.clear_results, 
+            outputs=[status, image1]
         )
 
         save_btn.click(
-            fn=analyzer.save_results,
+            fn=analyzer.save_results, 
             outputs=[file_output, status]
         )