Update app.py

app.py

@@ -3,42 +3,10 @@ import cv2
 import numpy as np
 import pandas as pd
 import pydicom
-import logging
-import time
-import traceback
-from functools import wraps
-import sys
+import io
 from PIL import Image
 
-# Set up logging
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler('dicom_analyzer_debug.log'),
-        logging.StreamHandler(sys.stdout)
-    ]
-)
-
-logger = logging.getLogger(__name__)
-
-def debug_decorator(func):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        logger.debug(f"Entering {func.__name__}")
-        start_time = time.time()
-        try:
-            result = func(*args, **kwargs)
-            logger.debug(f"Function {func.__name__} completed successfully")
-            return result
-        except Exception as e:
-            logger.error(f"Error in {func.__name__}: {str(e)}")
-            logger.error(traceback.format_exc())
-            raise
-        finally:
-            end_time = time.time()
-            logger.debug(f"Execution time: {end_time - start_time:.4f} seconds")
-    return wrapper
+print("Starting imports completed...")
 
 class DicomAnalyzer:
     def __init__(self):
@@ -48,23 +16,18 @@ class DicomAnalyzer:
         self.current_image = None
         self.dicom_data = None
         self.display_image = None
-        self.marks = []
+        self.marks = []  # Store (x, y, diameter) for each mark
         self.original_image = None
         self.original_display = None
+        # Pan position
         self.pan_x = 0
         self.pan_y = 0
         self.max_pan_x = 0
         self.max_pan_y = 0
-        
-        # Constants
-        self.CIRCLE_COLOR = (255, 255, 0)  # BGR Yellow
-        self.MIN_ZOOM = 1.0
-        self.MAX_ZOOM = 20.0
-        self.ZOOM_STEP = 0.5
-        
-        logger.info("DicomAnalyzer initialized")
+        # Circle color in BGR
+        self.CIRCLE_COLOR = (0, 255, 255)  # BGR Yellow
+        print("DicomAnalyzer initialized...")
 
-    @debug_decorator
     def load_dicom(self, file):
         try:
             if file is None:
@@ -88,13 +51,15 @@ class DicomAnalyzer:
             self.display_image = self.normalize_image(image)
             self.original_display = self.display_image.copy()
             
+            # Reset view on new image
             self.reset_view()
+            print("DICOM file loaded successfully")
+            
             return self.display_image, "DICOM file loaded successfully"
         except Exception as e:
-            logger.error(f"Error loading DICOM: {str(e)}")
-            return None, f"Error loading DICOM: {str(e)}"
+            print(f"Error loading DICOM file: {str(e)}")
+            return None, f"Error loading DICOM file: {str(e)}"
 
-    @debug_decorator
     def normalize_image(self, image):
         try:
             normalized = cv2.normalize(
@@ -109,10 +74,9 @@ class DicomAnalyzer:
                 normalized = cv2.cvtColor(normalized, cv2.COLOR_GRAY2BGR)
             return normalized
         except Exception as e:
-            logger.error(f"Error normalizing image: {str(e)}")
+            print(f"Error normalizing image: {str(e)}")
             return None
 
-    @debug_decorator
     def reset_view(self):
         self.zoom_factor = 1.0
         self.pan_x = 0
@@ -121,35 +85,24 @@ class DicomAnalyzer:
             return self.update_display()
         return None
 
-    @debug_decorator
     def zoom_in(self, image):
-        try:
-            new_zoom = self.zoom_factor + self.ZOOM_STEP
-            if new_zoom <= self.MAX_ZOOM:
-                self.zoom_factor = new_zoom
-                logger.debug(f"Zooming in. New zoom factor: {self.zoom_factor}")
-            return self.update_display()
-        except Exception as e:
-            logger.error(f"Error in zoom_in: {str(e)}")
-            return image
+        print("Zooming in...")
+        self.zoom_factor = min(20.0, self.zoom_factor + 0.5)
+        return self.update_display()
 
-    @debug_decorator
     def zoom_out(self, image):
-        try:
-            new_zoom = self.zoom_factor - self.ZOOM_STEP
-            if new_zoom >= self.MIN_ZOOM:
-                self.zoom_factor = new_zoom
-                logger.debug(f"Zooming out. New zoom factor: {self.zoom_factor}")
-            return self.update_display()
-        except Exception as e:
-            logger.error(f"Error in zoom_out: {str(e)}")
-            return image
+        print("Zooming out...")
+        self.zoom_factor = max(1.0, self.zoom_factor - 0.5)
+        return self.update_display()
 
-    @debug_decorator
     def handle_keyboard(self, key):
         try:
+            print(f"Handling key press: {key}")
             pan_amount = int(5 * self.zoom_factor)
             
+            original_pan_x = self.pan_x
+            original_pan_y = self.pan_y
+            
             if key == 'ArrowLeft':
                 self.pan_x = max(0, self.pan_x - pan_amount)
             elif key == 'ArrowRight':
@@ -159,69 +112,79 @@ class DicomAnalyzer:
             elif key == 'ArrowDown':
                 self.pan_y = min(self.max_pan_y, self.pan_y + pan_amount)
             
+            print(f"Pan X: {self.pan_x} (was {original_pan_x})")
+            print(f"Pan Y: {self.pan_y} (was {original_pan_y})")
+            print(f"Max Pan X: {self.max_pan_x}")
+            print(f"Max Pan Y: {self.max_pan_y}")
+            
             return self.update_display()
         except Exception as e:
-            logger.error(f"Error handling keyboard: {str(e)}")
+            print(f"Error handling keyboard input: {str(e)}")
             return self.display_image
 
-    @debug_decorator
     def analyze_roi(self, evt: gr.SelectData):
         try:
             if self.current_image is None:
                 return None, "No image loaded"
 
+            # Get clicked coordinates
             clicked_x, clicked_y = evt.index[0], evt.index[1]
             
-            # Transform coordinates
+            # Transform coordinates to match ImageJ
             x = (clicked_x + self.pan_x) / self.zoom_factor
             y = (clicked_y + self.pan_y) / self.zoom_factor
-
+            
+            # ImageJ coordinate correction
+            x = x - 0.5  # ImageJ starts from 0.5, not 0
+            y = y - 0.5
+            
             # Get image dimensions
             height, width = self.current_image.shape[:2]
             
-            # Ensure coordinates are within bounds
-            x = max(0, min(x, width-1))
-            y = max(0, min(y, height-1))
-
-            # Create circular mask
-            mask = np.zeros_like(self.current_image, dtype=np.uint8)
-            y_indices, x_indices = np.ogrid[:height, :width]
-            radius = self.circle_diameter / 2
-            distance_from_center = np.sqrt(
-                (x_indices - x)**2 + (y_indices - y)**2
-            )
-            mask[distance_from_center <= radius] = 1
+            # Create precise circular mask (ImageJ method)
+            y_coords, x_coords = np.ogrid[:height, :width]
+            radius = self.circle_diameter / 2.0
+            
+            # Use exact ImageJ distance calculation
+            dist_squared = (x_coords - x)**2 + (y_coords - y)**2
+            mask = dist_squared <= radius**2
+            
+            # Get ROI pixels
+            roi_pixels = self.current_image[mask]
+            
+            if len(roi_pixels) == 0:
+                return self.display_image, "Error: No pixels selected"
 
-            # Calculate statistics
-            roi_pixels = self.current_image[mask == 1]
+            # Get pixel spacing (mm/pixel)
             pixel_spacing = float(self.dicom_data.PixelSpacing[0])
             
-            area_pixels = np.sum(mask)
-            area_mm2 = area_pixels * (pixel_spacing ** 2)
-            
-            mean = np.mean(roi_pixels)
-            stddev = np.std(roi_pixels)
+            # Calculate statistics exactly like ImageJ
+            n_pixels = len(roi_pixels)
+            mean_value = np.mean(roi_pixels)
+            std_dev = np.std(roi_pixels, ddof=1)  # ImageJ uses n-1
             min_val = np.min(roi_pixels)
             max_val = np.max(roi_pixels)
+            
+            # Calculate area using ImageJ method
+            area = n_pixels * (pixel_spacing ** 2)
 
+            # Store results with ImageJ precision
             result = {
-                'Area (mm²)': f"{area_mm2:.3f}",
-                'Mean': f"{mean:.3f}",
-                'StdDev': f"{stddev:.3f}",
+                'Area (mm²)': f"{area:.3f}",
+                'Mean': f"{mean_value:.3f}",
+                'StdDev': f"{std_dev:.3f}",
                 'Min': f"{min_val:.3f}",
                 'Max': f"{max_val:.3f}",
-                'Point': f"({x:.1f}, {y:.1f})"
+                'Point': f"({x+0.5:.1f}, {y+0.5:.1f})"  # Add 0.5 back for display
             }
             
             self.results.append(result)
-            self.marks.append((x, y, self.circle_diameter))
+            self.marks.append((x+0.5, y+0.5, self.circle_diameter))
 
             return self.update_display(), self.format_results()
         except Exception as e:
-            logger.error(f"Error analyzing ROI: {str(e)}")
+            print(f"Error analyzing ROI: {str(e)}")
             return self.display_image, f"Error analyzing ROI: {str(e)}"
-
-    @debug_decorator
     def update_display(self):
         try:
             if self.original_display is None:
@@ -238,30 +201,30 @@ class DicomAnalyzer:
             # Convert to BGR for drawing
             zoomed_bgr = cv2.cvtColor(zoomed, cv2.COLOR_RGB2BGR)
 
-            # Draw marks with dots
+            # Draw marks with ImageJ-style dots
             for x, y, diameter in self.marks:
                 zoomed_x = int(x * self.zoom_factor)
                 zoomed_y = int(y * self.zoom_factor)
-                zoomed_diameter = int(diameter * self.zoom_factor)
+                zoomed_radius = int((diameter/2) * self.zoom_factor)
                 
                 # Draw main circle
                 cv2.circle(zoomed_bgr,
                           (zoomed_x, zoomed_y),
-                          zoomed_diameter // 2,
-                          self.CIRCLE_COLOR,
+                          zoomed_radius,
+                          self.CIRCLE_COLOR,  # BGR Yellow (0, 255, 255)
                           1,
                           lineType=cv2.LINE_AA)
                 
-                # Draw dots on circle
+                # Draw dots like ImageJ
                 num_points = 8
                 for i in range(num_points):
                     angle = 2 * np.pi * i / num_points
-                    point_x = int(zoomed_x + (zoomed_diameter/2) * np.cos(angle))
-                    point_y = int(zoomed_y + (zoomed_diameter/2) * np.sin(angle))
+                    point_x = int(zoomed_x + zoomed_radius * np.cos(angle))
+                    point_y = int(zoomed_y + zoomed_radius * np.sin(angle))
                     cv2.circle(zoomed_bgr,
                               (point_x, point_y),
                               1,
-                              self.CIRCLE_COLOR,
+                              self.CIRCLE_COLOR,  # BGR Yellow (0, 255, 255)
                               -1,
                               lineType=cv2.LINE_AA)
 
@@ -282,15 +245,16 @@ class DicomAnalyzer:
 
             return visible
         except Exception as e:
-            logger.error(f"Error updating display: {str(e)}")
+            print(f"Error updating display: {str(e)}")
             return self.original_display
 
     def format_results(self):
         if not self.results:
             return "No measurements yet"
         df = pd.DataFrame(self.results)
-        columns = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
-        return df[columns].to_string(index=False)
+        columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
+        df = df[columns_order]
+        return df.to_string(index=False)
 
     def add_blank_row(self, image):
         self.results.append({
@@ -321,15 +285,14 @@ class DicomAnalyzer:
             self.marks.pop()
         return self.update_display(), self.format_results()
 
-    @debug_decorator
     def save_results(self):
         try:
             if not self.results:
                 return None, "No results to save"
             
             df = pd.DataFrame(self.results)
-            columns = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
-            df = df[columns]
+            columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
+            df = df[columns_order]
             
             temp_file = "analysis_results.xlsx"
             df.to_excel(temp_file, index=False)
@@ -339,6 +302,7 @@ class DicomAnalyzer:
             return None, f"Error saving results: {str(e)}"
 
 def create_interface():
+    print("Creating interface...")
     analyzer = DicomAnalyzer()
     
     with gr.Blocks(css="#image_display { outline: none; }") as interface:
@@ -361,11 +325,7 @@ def create_interface():
                     reset_btn = gr.Button("Reset View")
                 
             with gr.Column():
-                image_display = gr.Image(
-                    label="DICOM Image",
-                    interactive=True,
-                    elem_id="image_display"
-                )
+                image_display = gr.Image(label="DICOM Image", interactive=True, elem_id="image_display")
                 
         with gr.Row():
             blank_btn = gr.Button("Add Blank Row")
@@ -377,6 +337,18 @@ def create_interface():
         file_output = gr.File(label="Download Results")
         key_press = gr.Textbox(visible=False, elem_id="key_press")
         
+        gr.Markdown("""
+        ### Controls:
+        - Use arrow keys to pan when zoomed in
+        - Click points to measure
+        - Use Zoom In/Out buttons or Reset View to adjust zoom level
+        """)
+        
+        def update_diameter(x):
+            analyzer.circle_diameter = x
+            print(f"Diameter updated to: {x}")
+            return f"Diameter set to {x} pixels"
+
         # Event handlers
         file_input.change(
             fn=analyzer.load_dicom,
@@ -390,23 +362,21 @@ def create_interface():
         )
         
         diameter_slider.change(
-            fn=lambda x: setattr(analyzer, 'circle_diameter', x),
+            fn=update_diameter,
             inputs=diameter_slider,
-            outputs=None
+            outputs=gr.Textbox(label="Status")
         )
         
         zoom_in_btn.click(
             fn=analyzer.zoom_in,
             inputs=image_display,
-            outputs=image_display,
-            queue=False
+            outputs=image_display
         )
         
         zoom_out_btn.click(
             fn=analyzer.zoom_out,
             inputs=image_display,
-            outputs=image_display,
-            queue=False
+            outputs=image_display
         )
         
         reset_btn.click(
@@ -443,7 +413,7 @@ def create_interface():
             outputs=[file_output, results_display]
         )
 
-        gr.HTML("""
+        js = """
         <script>
         document.addEventListener('keydown', function(e) {
             if (['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(e.key)) {
@@ -456,14 +426,17 @@ def create_interface():
             }
         });
         </script>
-        """)
-
+        """
+        gr.HTML(js)
+    
+    print("Interface created successfully")
     return interface
 
 if __name__ == "__main__":
     try:
-        logger.info("Starting DICOM Analyzer application")
+        print("Starting application...")
         interface = create_interface()
+        print("Launching interface...")
         interface.launch(
             server_name="0.0.0.0",
             server_port=7860,
@@ -471,6 +444,5 @@ if __name__ == "__main__":
             debug=True
         )
     except Exception as e:
-        logger.error(f"Error launching application: {str(e)}")
-        logger.error(traceback.format_exc())
+        print(f"Error launching application: {str(e)}")
         raise e