Update app.py

app.py

@@ -28,23 +28,6 @@ class DicomAnalyzer:
         self.CIRCLE_COLOR = (0, 255, 255)  # BGR Yellow
         print("DicomAnalyzer initialized...")
 
-    def transform_coordinates(self, clicked_x, clicked_y):
-        """Transform screen coordinates to image coordinates using ImageJ method"""
-        # Transform from screen to image coordinates
-        x = clicked_x + self.pan_x
-        y = clicked_y + self.pan_y
-        
-        # Apply zoom factor
-        if self.zoom_factor != 1.0:
-            x = x / self.zoom_factor
-            y = y / self.zoom_factor
-        
-        # Round to nearest integer to match ImageJ behavior
-        x = round(x)
-        y = round(y)
-        
-        return x, y
-
     def load_dicom(self, file):
         try:
             if file is None:
@@ -139,89 +122,89 @@ class DicomAnalyzer:
             print(f"Error handling keyboard input: {str(e)}")
             return self.display_image
 
-def analyze_roi(self, evt: gr.SelectData):
-    try:
-        if self.current_image is None:
-            return None, "No image loaded"
-
-        # Get clicked coordinates
-        clicked_x = evt.index[0]
-        clicked_y = evt.index[1]
-        
-        # Transform coordinates to match ImageJ exactly
-        x = clicked_x + self.pan_x
-        y = clicked_y + self.pan_y
-        if self.zoom_factor != 1.0:
-            x = x / self.zoom_factor
-            y = y / self.zoom_factor
-        
-        # ImageJ uses integer coordinates
-        x = int(round(x))
-        y = int(round(y))
-        
-        # Get image dimensions
-        height, width = self.current_image.shape[:2]
-        
-        # Create mask exactly as ImageJ does
-        Y, X = np.ogrid[:height, :width]
-        center_x = x
-        center_y = y
-        
-        # ImageJ uses a specific radius calculation
-        radius = self.circle_diameter / 2.0
-        
-        # Create the mask using ImageJ's method
-        dx = X - center_x
-        dy = Y - center_y
-        dist_squared = dx * dx + dy * dy
-        mask = dist_squared <= (radius * radius)
-        
-        # Get ROI pixels
-        roi_pixels = self.current_image[mask]
-        
-        if len(roi_pixels) == 0:
-            return self.display_image, "Error: No pixels selected"
-
-        # Get pixel spacing (mm/pixel)
-        pixel_spacing = float(self.dicom_data.PixelSpacing[0])
-        
-        # Calculate statistics exactly as ImageJ does
-        n_pixels = np.sum(mask)
-        area = n_pixels * (pixel_spacing ** 2)
-        
-        # Use ImageJ's statistical calculations
-        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)
+    def analyze_roi(self, evt: gr.SelectData):
+        try:
+            if self.current_image is None:
+                return None, "No image loaded"
 
-        # Print debug information
-        print(f"\nDetailed Analysis:")
-        print(f"Coordinates: ({x}, {y})")
-        print(f"Pixel count: {n_pixels}")
-        print(f"Area: {area:.3f} mm²")
-        print(f"Mean: {mean_value:.3f}")
-        print(f"StdDev: {std_dev:.3f}")
-        print(f"Min: {min_val}")
-        print(f"Max: {max_val}")
+            # Get clicked coordinates
+            clicked_x = evt.index[0]
+            clicked_y = evt.index[1]
+            
+            # Transform coordinates to match ImageJ exactly
+            x = clicked_x + self.pan_x
+            y = clicked_y + self.pan_y
+            if self.zoom_factor != 1.0:
+                x = x / self.zoom_factor
+                y = y / self.zoom_factor
+            
+            # ImageJ uses integer coordinates
+            x = int(round(x))
+            y = int(round(y))
+            
+            # Get image dimensions
+            height, width = self.current_image.shape[:2]
+            
+            # Create mask exactly as ImageJ does
+            Y, X = np.ogrid[:height, :width]
+            center_x = x
+            center_y = y
+            
+            # ImageJ uses a specific radius calculation
+            radius = self.circle_diameter / 2.0
+            
+            # Create the mask using ImageJ's method
+            dx = X - center_x
+            dy = Y - center_y
+            dist_squared = dx * dx + dy * dy
+            mask = dist_squared <= (radius * radius)
+            
+            # Get ROI pixels
+            roi_pixels = self.current_image[mask]
+            
+            if len(roi_pixels) == 0:
+                return self.display_image, "Error: No pixels selected"
 
-        # Store results
-        result = {
-            '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}, {y})"
-        }
-        
-        self.results.append(result)
-        self.marks.append((x, y, self.circle_diameter))
+            # Get pixel spacing (mm/pixel)
+            pixel_spacing = float(self.dicom_data.PixelSpacing[0])
+            
+            # Calculate statistics exactly as ImageJ does
+            n_pixels = np.sum(mask)
+            area = n_pixels * (pixel_spacing ** 2)
+            
+            # Use ImageJ's statistical calculations
+            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)
+
+            # Print debug information
+            print(f"\nDetailed Analysis:")
+            print(f"Coordinates: ({x}, {y})")
+            print(f"Pixel count: {n_pixels}")
+            print(f"Area: {area:.3f} mm²")
+            print(f"Mean: {mean_value:.3f}")
+            print(f"StdDev: {std_dev:.3f}")
+            print(f"Min: {min_val}")
+            print(f"Max: {max_val}")
+
+            # Store results
+            result = {
+                '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}, {y})"
+            }
+            
+            self.results.append(result)
+            self.marks.append((x, y, self.circle_diameter))
 
-        return self.update_display(), self.format_results()
-    except Exception as e:
-        print(f"Error analyzing ROI: {str(e)}")
-        return self.display_image, f"Error analyzing ROI: {str(e)}"
+            return self.update_display(), self.format_results()
+        except Exception as e:
+            print(f"Error analyzing ROI: {str(e)}")
+            return self.display_image, f"Error analyzing ROI: {str(e)}"
     def update_display(self):
         try:
             if self.original_display is None:
@@ -242,7 +225,7 @@ def analyze_roi(self, evt: gr.SelectData):
             for x, y, diameter in self.marks:
                 zoomed_x = int(x * self.zoom_factor)
                 zoomed_y = int(y * self.zoom_factor)
-                zoomed_radius = int(((diameter - 1) / 2) * self.zoom_factor)  # ImageJ radius
+                zoomed_radius = int((diameter/2) * self.zoom_factor)
                 
                 # Draw main circle
                 cv2.circle(zoomed_bgr,