Update app.py

app.py

@@ -61,6 +61,12 @@ class DicomAnalyzer:
         self.max_pan_x = 0
         self.max_pan_y = 0
         
+        # Constants
+        self.CIRCLE_COLOR = (0, 255, 255)  # BGR Yellow
+        self.MIN_ZOOM = 1.0
+        self.MAX_ZOOM = 20.0
+        self.ZOOM_STEP = 1.2
+        
         # Debug state
         self.debug_info = {
             'last_click': None,
@@ -82,7 +88,6 @@ class DicomAnalyzer:
             
             image = dicom_data.pixel_array.astype(float)
             
-            # Apply rescale parameters if available
             rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
             rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
             image = (image * rescale_slope) + rescale_intercept
@@ -91,7 +96,6 @@ class DicomAnalyzer:
             self.original_image = image.copy()
             self.dicom_data = dicom_data
             
-            # Normalize and prepare display image
             self.display_image = self.normalize_image(image)
             self.original_display = self.display_image.copy()
             
@@ -123,60 +127,83 @@ class DicomAnalyzer:
 
     @debug_decorator
     def zoom_in(self, image):
-        self.zoom_factor = min(20.0, self.zoom_factor * 1.2)
-        self.debug_info['zoom_history'].append(('in', self.zoom_factor))
-        return self.update_display()
+        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}")
+                self.debug_info['zoom_history'].append(('in', self.zoom_factor))
+                return self.update_display()
+            return image
+        except Exception as e:
+            logger.error(f"Error in zoom_in: {str(e)}")
+            return image
 
     @debug_decorator
     def zoom_out(self, image):
-        self.zoom_factor = max(1.0, self.zoom_factor / 1.2)
-        self.debug_info['zoom_history'].append(('out', self.zoom_factor))
-        return self.update_display()
-
+        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}")
+                self.debug_info['zoom_history'].append(('out', self.zoom_factor))
+                return self.update_display()
+            return image
+        except Exception as e:
+            logger.error(f"Error in zoom_out: {str(e)}")
+            return 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 coordinates
             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 mask for ROI
             height, width = self.current_image.shape[:2]
             mask = np.zeros((height, width), dtype=np.uint8)
             cv2.circle(mask, (int(image_x), int(image_y)), 
                       self.circle_diameter // 2, 1, -1)
 
-            # Calculate statistics
             roi_pixels = self.current_image[mask == 1]
             
             if len(roi_pixels) == 0:
                 return self.display_image, "Error: No pixels selected"
 
-            # Get pixel spacing
             pixel_spacing = getattr(self.dicom_data, 'PixelSpacing', [1.0, 1.0])[0]
 
-            # Store results
+            mean_value = np.mean(roi_pixels)
+            std_dev = np.std(roi_pixels, ddof=1)
+            min_val = np.min(roi_pixels)
+            max_val = np.max(roi_pixels)
+            area = len(roi_pixels) * (pixel_spacing ** 2)
+
             result = {
-                'Area (mm²)': f"{len(roi_pixels) * (pixel_spacing ** 2):.3f}",
-                'Mean': f"{np.mean(roi_pixels):.3f}",
-                'StdDev': f"{np.std(roi_pixels):.3f}",
-                'Min': f"{np.min(roi_pixels):.3f}",
-                'Max': f"{np.max(roi_pixels):.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"({image_x:.1f}, {image_y:.1f})"
             }
             
             self.results.append(result)
             self.marks.append((image_x, image_y, self.circle_diameter))
 
+            logger.debug(f"ROI Analysis Results:")
+            logger.debug(f"Position: ({image_x:.1f}, {image_y:.1f})")
+            logger.debug(f"Area: {area:.3f} mm²")
+            logger.debug(f"Mean: {mean_value:.3f}")
+            logger.debug(f"StdDev: {std_dev:.3f}")
+            logger.debug(f"Min: {min_val:.3f}")
+            logger.debug(f"Max: {max_val:.3f}")
+
             return self.update_display(), self.format_results()
         except Exception as e:
             logger.error(f"Error in ROI analysis: {str(e)}")
@@ -189,22 +216,18 @@ class DicomAnalyzer:
                 return None
 
             height, width = self.original_display.shape[:2]
-            
-            # Create working copy
             display_image = self.original_display.copy()
 
-            # Draw all marks
             for x, y, diameter in self.marks:
                 cv2.circle(
                     display_image,
                     (int(x), int(y)),
                     diameter // 2,
-                    (0, 255, 255),
+                    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)
@@ -214,15 +237,12 @@ class DicomAnalyzer:
                     interpolation=cv2.INTER_LINEAR
                 )
 
-            # Calculate 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
             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[
                 int(self.pan_y):int(self.pan_y + height),
                 int(self.pan_x):int(self.pan_x + width)
@@ -332,13 +352,15 @@ def create_interface():
         zoom_in_btn.click(
             fn=analyzer.zoom_in,
             inputs=image_display,
-            outputs=image_display
+            outputs=image_display,
+            queue=False
         )
         
         zoom_out_btn.click(
             fn=analyzer.zoom_out,
             inputs=image_display,
-            outputs=image_display
+            outputs=image_display,
+            queue=False
         )
         
         reset_btn.click(
@@ -361,7 +383,6 @@ def create_interface():
             fn=lambda: logger.debug(f"Debug Info: {analyzer.debug_info}")
         )
 
-        # Add keyboard handling JavaScript
         gr.HTML("""
         <script>
         document.addEventListener('keydown', function(e) {