Update app.py

app.py

@@ -139,76 +139,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"
+def analyze_roi(self, evt: gr.SelectData):
+    try:
+        if self.current_image is None:
+            return None, "No image loaded"
 
-            # Transform coordinates using ImageJ method
-            x, y = self.transform_coordinates(evt.index[0], evt.index[1])
-            
-            # Get image dimensions
-            height, width = self.current_image.shape[:2]
-            
-            # Create precise circular mask using ImageJ's method
-            Y, X = np.ogrid[:height, :width]
-            
-            # ImageJ's circle creation method
-            radius = (self.circle_diameter - 1) / 2.0
-            
-            # Calculate distances using ImageJ's method
-            dx = X - x
-            dy = Y - y
-            dist_squared = dx*dx + dy*dy
-            mask = dist_squared <= radius*radius
-            
-            # Get ROI pixels using the exact same mask
-            roi_pixels = self.current_image[mask]
-            
-            if len(roi_pixels) == 0:
-                return self.display_image, "Error: No pixels selected"
+        # 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 area exactly as ImageJ does
-            n_pixels = np.sum(mask)
-            area = n_pixels * (pixel_spacing * pixel_spacing)
-            
-            # Calculate statistics exactly as ImageJ does
-            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)
-
-            # Debug print
-            print(f"\nImageJ-compatible Analysis:")
-            print(f"Position: ({x}, {y})")
-            print(f"Radius: {radius}")
-            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))
+        # 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: