Update app.py

app.py

@@ -28,6 +28,23 @@ 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:
@@ -127,28 +144,25 @@ class DicomAnalyzer:
             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 to match ImageJ
-            x = (clicked_x + self.pan_x) / self.zoom_factor
-            y = (clicked_y + self.pan_y) / self.zoom_factor
+            # 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]
             
-            # ImageJ-style circle creation
+            # Create precise circular mask using ImageJ's method
             Y, X = np.ogrid[:height, :width]
             
-            # ImageJ uses a specific method for radius calculation
-            radius = self.circle_diameter / 2.0
+            # ImageJ's circle creation method
+            radius = (self.circle_diameter - 1) / 2.0
             
-            # Create the circular ROI mask using ImageJ's method
-            # ImageJ considers pixels as 1x1 squares centered on integer coordinates
-            dist_squared = (X - x)**2 + (Y - y)**2
-            mask = dist_squared <= (radius * radius)
+            # 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
+            # Get ROI pixels using the exact same mask
             roi_pixels = self.current_image[mask]
             
             if len(roi_pixels) == 0:
@@ -158,15 +172,26 @@ class DicomAnalyzer:
             pixel_spacing = float(self.dicom_data.PixelSpacing[0])
             
             # Calculate area exactly as ImageJ does
-            n_pixels = np.sum(mask)  # Total number of pixels in ROI
-            area = n_pixels * (pixel_spacing * pixel_spacing)  # Area in mm²
+            n_pixels = np.sum(mask)
+            area = n_pixels * (pixel_spacing * pixel_spacing)
             
-            # Calculate other statistics
+            # Calculate statistics exactly as ImageJ does
             mean_value = np.mean(roi_pixels)
-            std_dev = np.std(roi_pixels, ddof=1)  # ImageJ uses n-1 for standard deviation
+            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}",
@@ -174,17 +199,9 @@ class DicomAnalyzer:
                 'StdDev': f"{std_dev:.3f}",
                 'Min': f"{min_val:.3f}",
                 'Max': f"{max_val:.3f}",
-                'Point': f"({x:.1f}, {y:.1f})"
+                'Point': f"({x}, {y})"
             }
             
-            print(f"ROI Analysis Results:")
-            print(f"Number of pixels: {n_pixels}")
-            print(f"Pixel spacing: {pixel_spacing} mm")
-            print(f"Area: {area:.3f} mm²")
-            print(f"Mean: {mean_value:.3f}")
-            print(f"StdDev: {std_dev:.3f}")
-            print(f"Position: ({x:.1f}, {y:.1f})")
-            
             self.results.append(result)
             self.marks.append((x, y, self.circle_diameter))
 
@@ -212,7 +229,7 @@ class DicomAnalyzer:
             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/2) * self.zoom_factor)
+                zoomed_radius = int(((diameter - 1) / 2) * self.zoom_factor)  # ImageJ radius
                 
                 # Draw main circle
                 cv2.circle(zoomed_bgr,