Update app.py

app.py

@@ -3,13 +3,12 @@ import cv2
 import numpy as np
 import pandas as pd
 import pydicom
-from PIL import Image
 import logging
 import time
 import traceback
 from functools import wraps
 import sys
-import os
+from PIL import Image
 
 # Set up logging
 logging.basicConfig(
@@ -27,7 +26,6 @@ def debug_decorator(func):
     @wraps(func)
     def wrapper(*args, **kwargs):
         logger.debug(f"Entering {func.__name__}")
-        logger.debug(f"Arguments: args={args}, kwargs={kwargs}")
         start_time = time.time()
         try:
             result = func(*args, **kwargs)
@@ -44,10 +42,6 @@ def debug_decorator(func):
 
 class DicomAnalyzer:
     def __init__(self):
-        self.logger = logging.getLogger(__name__)
-        self.logger.debug("Initializing DicomAnalyzer")
-        
-        # Initialize state variables
         self.results = []
         self.circle_diameter = 9
         self.zoom_factor = 1.0
@@ -63,19 +57,12 @@ class DicomAnalyzer:
         self.max_pan_y = 0
         
         # Constants
-        self.CIRCLE_COLOR = (255, 255, 0)  # BGR Yellow (corrected)
+        self.CIRCLE_COLOR = (255, 255, 0)  # BGR Yellow
         self.MIN_ZOOM = 1.0
         self.MAX_ZOOM = 20.0
-        self.ZOOM_STEP = 1.2
+        self.ZOOM_STEP = 0.5
         
-        # Debug state
-        self.debug_info = {
-            'last_click': None,
-            'last_transformed_coords': None,
-            'zoom_history': [],
-            'pan_history': [],
-            'measurements': []
-        }
+        logger.info("DicomAnalyzer initialized")
 
     @debug_decorator
     def load_dicom(self, file):
@@ -87,11 +74,9 @@ class DicomAnalyzer:
                 dicom_data = pydicom.dcmread(file.name)
             else:
                 dicom_data = pydicom.dcmread(file)
+                
+            image = dicom_data.pixel_array.astype(np.float32)
             
-            # Convert to float for accurate calculations
-            image = dicom_data.pixel_array.astype(float)
-            
-            # Apply DICOM rescale parameters
             rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
             rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
             image = (image * rescale_slope) + rescale_intercept
@@ -100,20 +85,10 @@ class DicomAnalyzer:
             self.original_image = image.copy()
             self.dicom_data = dicom_data
             
-            # Prepare display image
             self.display_image = self.normalize_image(image)
             self.original_display = self.display_image.copy()
             
-            # Reset view settings
             self.reset_view()
-            
-            # Log DICOM info for comparison
-            self.logger.debug(f"DICOM Info:")
-            self.logger.debug(f"Image Size: {image.shape}")
-            self.logger.debug(f"Pixel Spacing: {getattr(dicom_data, 'PixelSpacing', [1.0, 1.0])}")
-            self.logger.debug(f"Rescale Slope: {rescale_slope}")
-            self.logger.debug(f"Rescale Intercept: {rescale_intercept}")
-            
             return self.display_image, "DICOM file loaded successfully"
         except Exception as e:
             logger.error(f"Error loading DICOM: {str(e)}")
@@ -122,7 +97,14 @@ class DicomAnalyzer:
     @debug_decorator
     def normalize_image(self, image):
         try:
-            normalized = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+            normalized = cv2.normalize(
+                image, 
+                None, 
+                alpha=0,
+                beta=255,
+                norm_type=cv2.NORM_MINMAX,
+                dtype=cv2.CV_8U
+            )
             if len(normalized.shape) == 2:
                 normalized = cv2.cvtColor(normalized, cv2.COLOR_GRAY2BGR)
             return normalized
@@ -142,11 +124,10 @@ class DicomAnalyzer:
     @debug_decorator
     def zoom_in(self, image):
         try:
-            new_zoom = self.zoom_factor * self.ZOOM_STEP
+            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}")
-                self.debug_info['zoom_history'].append(('in', self.zoom_factor))
             return self.update_display()
         except Exception as e:
             logger.error(f"Error in zoom_in: {str(e)}")
@@ -155,97 +136,90 @@ class DicomAnalyzer:
     @debug_decorator
     def zoom_out(self, image):
         try:
-            new_zoom = self.zoom_factor / self.ZOOM_STEP
+            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}")
-                self.debug_info['zoom_history'].append(('out', self.zoom_factor))
             return self.update_display()
         except Exception as e:
             logger.error(f"Error in zoom_out: {str(e)}")
             return image
+
+    @debug_decorator
+    def handle_keyboard(self, key):
+        try:
+            pan_amount = int(5 * self.zoom_factor)
+            
+            if key == 'ArrowLeft':
+                self.pan_x = max(0, self.pan_x - pan_amount)
+            elif key == 'ArrowRight':
+                self.pan_x = min(self.max_pan_x, self.pan_x + pan_amount)
+            elif key == 'ArrowUp':
+                self.pan_y = max(0, self.pan_y - pan_amount)
+            elif key == 'ArrowDown':
+                self.pan_y = min(self.max_pan_y, self.pan_y + pan_amount)
+            
+            return self.update_display()
+        except Exception as e:
+            logger.error(f"Error handling keyboard: {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 click coordinates and transform them
             clicked_x, clicked_y = evt.index[0], evt.index[1]
-            self.debug_info['last_click'] = (clicked_x, clicked_y)
             
-            # Transform to image coordinates (ImageJ-compatible)
-            image_x = (clicked_x + self.pan_x) / self.zoom_factor
-            image_y = (clicked_y + self.pan_y) / self.zoom_factor
-            
-            self.debug_info['last_transformed_coords'] = (image_x, image_y)
-            
-            # Create circular ROI mask (ImageJ-compatible method)
+            # Transform coordinates
+            x = (clicked_x + self.pan_x) / self.zoom_factor
+            y = (clicked_y + self.pan_y) / self.zoom_factor
+
+            # Get image dimensions
             height, width = self.current_image.shape[:2]
-            y, x = np.ogrid[:height, :width]
+            
+            # 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
-            mask = ((x - image_x)**2 + (y - image_y)**2 <= radius**2).astype(np.uint8)
+            distance_from_center = np.sqrt(
+                (x_indices - x)**2 + (y_indices - y)**2
+            )
+            mask[distance_from_center <= radius] = 1
 
-            # Get ROI pixels
+            # Calculate statistics
             roi_pixels = self.current_image[mask == 1]
+            pixel_spacing = float(self.dicom_data.PixelSpacing[0])
             
-            if len(roi_pixels) == 0:
-                return self.display_image, "Error: No pixels selected"
-
-            # Get pixel spacing (mm/pixel)
-            pixel_spacing = getattr(self.dicom_data, 'PixelSpacing', [1.0, 1.0])[0]
-
-            # Calculate statistics (ImageJ-compatible)
-            n_pixels = len(roi_pixels)
-            mean_value = np.mean(roi_pixels)
-            std_dev = np.std(roi_pixels, ddof=1)  # ImageJ uses n-1
+            area_pixels = np.sum(mask)
+            area_mm2 = area_pixels * (pixel_spacing ** 2)
+            
+            mean = np.mean(roi_pixels)
+            stddev = np.std(roi_pixels)
             min_val = np.min(roi_pixels)
             max_val = np.max(roi_pixels)
-            
-            # Calculate area (mm²)
-            area = n_pixels * (pixel_spacing ** 2)
 
-            # Store results
             result = {
-                'Area (mm²)': f"{area:.3f}",
-                'Mean': f"{mean_value:.3f}",
-                'StdDev': f"{std_dev:.3f}",
+                'Area (mm²)': f"{area_mm2:.3f}",
+                'Mean': f"{mean:.3f}",
+                'StdDev': f"{stddev:.3f}",
                 'Min': f"{min_val:.3f}",
                 'Max': f"{max_val:.3f}",
-                'Point': f"({image_x:.1f}, {image_y:.1f})"
-            }
-            
-            # Store measurement for ImageJ comparison
-            measurement = {
-                'coordinates': (image_x, image_y),
-                'diameter': self.circle_diameter,
-                'pixel_count': n_pixels,
-                'area': area,
-                'mean': mean_value,
-                'stddev': std_dev,
-                'min': min_val,
-                'max': max_val
+                'Point': f"({x:.1f}, {y:.1f})"
             }
-            self.debug_info['measurements'].append(measurement)
-            
-            # Log for ImageJ comparison
-            logger.debug("\nImageJ Comparison Values:")
-            logger.debug(f"ROI Center: ({image_x:.1f}, {image_y:.1f})")
-            logger.debug(f"Diameter: {self.circle_diameter} pixels")
-            logger.debug(f"Pixel Count: {n_pixels}")
-            logger.debug(f"Area: {area:.6f} mm²")
-            logger.debug(f"Mean: {mean_value:.6f}")
-            logger.debug(f"StdDev: {std_dev:.6f}")
-            logger.debug(f"Min: {min_val:.6f}")
-            logger.debug(f"Max: {max_val:.6f}\n")
             
             self.results.append(result)
-            self.marks.append((image_x, image_y, self.circle_diameter))
+            self.marks.append((x, y, self.circle_diameter))
 
             return self.update_display(), self.format_results()
         except Exception as e:
-            logger.error(f"Error in ROI analysis: {str(e)}")
-            return self.display_image, f"Error in ROI analysis: {str(e)}"
+            logger.error(f"Error analyzing ROI: {str(e)}")
+            return self.display_image, f"Error analyzing ROI: {str(e)}"
 
     @debug_decorator
     def update_display(self):
@@ -254,39 +228,54 @@ class DicomAnalyzer:
                 return None
 
             height, width = self.original_display.shape[:2]
-            display_image = self.original_display.copy()
+            new_height = int(height * self.zoom_factor)
+            new_width = int(width * self.zoom_factor)
+
+            # Create zoomed image
+            zoomed = cv2.resize(self.original_display, (new_width, new_height), 
+                              interpolation=cv2.INTER_CUBIC)
 
-            # Draw all marks with correct yellow color
+            # Convert to BGR for drawing
+            zoomed_bgr = cv2.cvtColor(zoomed, cv2.COLOR_RGB2BGR)
+
+            # Draw marks with dots
             for x, y, diameter in self.marks:
-                cv2.circle(
-                    display_image,
-                    (int(x), int(y)),
-                    diameter // 2,
-                    self.CIRCLE_COLOR,  # BGR Yellow (255, 255, 0)
-                    1,
-                    lineType=cv2.LINE_AA
-                )
+                zoomed_x = int(x * self.zoom_factor)
+                zoomed_y = int(y * self.zoom_factor)
+                zoomed_diameter = int(diameter * self.zoom_factor)
+                
+                # Draw main circle
+                cv2.circle(zoomed_bgr,
+                          (zoomed_x, zoomed_y),
+                          zoomed_diameter // 2,
+                          self.CIRCLE_COLOR,
+                          1,
+                          lineType=cv2.LINE_AA)
+                
+                # Draw dots on circle
+                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))
+                    cv2.circle(zoomed_bgr,
+                              (point_x, point_y),
+                              1,
+                              self.CIRCLE_COLOR,
+                              -1,
+                              lineType=cv2.LINE_AA)
 
-            # Apply zoom
-            if self.zoom_factor != 1.0:
-                new_width = int(width * self.zoom_factor)
-                new_height = int(height * self.zoom_factor)
-                display_image = cv2.resize(
-                    display_image,
-                    (new_width, new_height),
-                    interpolation=cv2.INTER_LINEAR
-                )
+            # Convert back to RGB for display
+            zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
 
-            # Update pan limits
-            self.max_pan_x = max(0, display_image.shape[1] - width)
-            self.max_pan_y = max(0, display_image.shape[0] - height)
-            
-            # Apply panning with bounds checking
+            # Calculate pan limits
+            self.max_pan_x = max(0, new_width - width)
+            self.max_pan_y = max(0, new_height - height)
             self.pan_x = min(max(0, self.pan_x), self.max_pan_x)
             self.pan_y = min(max(0, self.pan_y), self.max_pan_y)
 
             # Extract visible portion
-            visible = display_image[
+            visible = zoomed[
                 int(self.pan_y):int(self.pan_y + height),
                 int(self.pan_x):int(self.pan_x + width)
             ]
@@ -296,26 +285,6 @@ class DicomAnalyzer:
             logger.error(f"Error updating display: {str(e)}")
             return self.original_display
 
-    @debug_decorator
-    def handle_keyboard(self, key):
-        try:
-            pan_amount = int(20 * self.zoom_factor)
-            
-            if key == 'ArrowLeft':
-                self.pan_x = max(0, self.pan_x - pan_amount)
-            elif key == 'ArrowRight':
-                self.pan_x = min(self.max_pan_x, self.pan_x + pan_amount)
-            elif key == 'ArrowUp':
-                self.pan_y = max(0, self.pan_y - pan_amount)
-            elif key == 'ArrowDown':
-                self.pan_y = min(self.max_pan_y, self.pan_y + pan_amount)
-            
-            self.debug_info['pan_history'].append((self.pan_x, self.pan_y))
-            return self.update_display()
-        except Exception as e:
-            logger.error(f"Error handling keyboard input: {str(e)}")
-            return self.display_image
-
     def format_results(self):
         if not self.results:
             return "No measurements yet"
@@ -323,6 +292,35 @@ class DicomAnalyzer:
         columns = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
         return df[columns].to_string(index=False)
 
+    def add_blank_row(self, image):
+        self.results.append({
+            'Area (mm²)': '',
+            'Mean': '',
+            'StdDev': '',
+            'Min': '',
+            'Max': '',
+            'Point': ''
+        })
+        return image, self.format_results()
+
+    def add_zero_row(self, image):
+        self.results.append({
+            'Area (mm²)': '0.000',
+            'Mean': '0.000',
+            'StdDev': '0.000',
+            'Min': '0.000',
+            'Max': '0.000',
+            'Point': '(0, 0)'
+        })
+        return image, self.format_results()
+
+    def undo_last(self, image):
+        if self.results:
+            self.results.pop()
+        if self.marks:
+            self.marks.pop()
+        return self.update_display(), self.format_results()
+
     @debug_decorator
     def save_results(self):
         try:
@@ -330,13 +328,12 @@ class DicomAnalyzer:
                 return None, "No results to save"
             
             df = pd.DataFrame(self.results)
+            columns = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
+            df = df[columns]
+            
             temp_file = "analysis_results.xlsx"
             df.to_excel(temp_file, index=False)
             
-            # Also save detailed results for ImageJ comparison
-            detailed_results = pd.DataFrame(self.debug_info['measurements'])
-            detailed_results.to_excel("detailed_results.xlsx", index=False)
-            
             return temp_file, "Results saved successfully"
         except Exception as e:
             return None, f"Error saving results: {str(e)}"
@@ -344,7 +341,7 @@ class DicomAnalyzer:
 def create_interface():
     analyzer = DicomAnalyzer()
     
-    with gr.Blocks() as interface:
+    with gr.Blocks(css="#image_display { outline: none; }") as interface:
         gr.Markdown("# DICOM Image Analyzer")
         
         with gr.Row():
@@ -371,8 +368,10 @@ def create_interface():
                 )
                 
         with gr.Row():
+            blank_btn = gr.Button("Add Blank Row")
+            zero_btn = gr.Button("Add Zero Row")
+            undo_btn = gr.Button("Undo Last")
             save_btn = gr.Button("Save Results")
-            debug_btn = gr.Button("Print Debug Info")
             
         results_display = gr.Textbox(label="Results", interactive=False)
         file_output = gr.File(label="Download Results")
@@ -400,16 +399,14 @@ def create_interface():
             fn=analyzer.zoom_in,
             inputs=image_display,
             outputs=image_display,
-            queue=False,
-            api_name="zoom_in"
+            queue=False
         )
         
         zoom_out_btn.click(
             fn=analyzer.zoom_out,
             inputs=image_display,
             outputs=image_display,
-            queue=False,
-            api_name="zoom_out"
+            queue=False
         )
         
         reset_btn.click(
@@ -423,14 +420,28 @@ def create_interface():
             outputs=image_display
         )
         
+        blank_btn.click(
+            fn=analyzer.add_blank_row,
+            inputs=image_display,
+            outputs=[image_display, results_display]
+        )
+        
+        zero_btn.click(
+            fn=analyzer.add_zero_row,
+            inputs=image_display,
+            outputs=[image_display, results_display]
+        )
+        
+        undo_btn.click(
+            fn=analyzer.undo_last,
+            inputs=image_display,
+            outputs=[image_display, results_display]
+        )
+        
         save_btn.click(
             fn=analyzer.save_results,
             outputs=[file_output, results_display]
         )
-        
-        debug_btn.click(
-            fn=lambda: logger.debug(f"Debug Info: {analyzer.debug_info}")
-        )
 
         gr.HTML("""
         <script>