Update app.py

app.py

@@ -11,7 +11,7 @@ print("Starting imports completed...")
 class DicomAnalyzer:
     def __init__(self):
         self.results = []
-        self.circle_diameter = 9
+        self.circle_diameter = 9.0  # Changed to float for precise calculations
         self.zoom_factor = 1.0
         self.current_image = None
         self.dicom_data = None
@@ -134,18 +134,16 @@ class DicomAnalyzer:
             x = (clicked_x + self.pan_x) / self.zoom_factor
             y = (clicked_y + self.pan_y) / self.zoom_factor
             
-            # ImageJ coordinate correction
-            x = x - 0.5  # ImageJ starts from 0.5, not 0
-            y = y - 0.5
-            
             # Get image dimensions
             height, width = self.current_image.shape[:2]
             
             # Create precise circular mask (ImageJ method)
             y_coords, x_coords = np.ogrid[:height, :width]
-            radius = self.circle_diameter / 2.0
             
-            # Use exact ImageJ distance calculation
+            # ImageJ uses diameter/2 for radius calculation
+            radius = (self.circle_diameter - 1) / 2.0  # Adjust radius calculation
+            
+            # Calculate distances using ImageJ method
             dist_squared = (x_coords - x)**2 + (y_coords - y)**2
             mask = dist_squared <= radius**2
             
@@ -158,28 +156,36 @@ class DicomAnalyzer:
             # Get pixel spacing (mm/pixel)
             pixel_spacing = float(self.dicom_data.PixelSpacing[0])
             
-            # Calculate statistics exactly like ImageJ
-            n_pixels = len(roi_pixels)
+            # Calculate area using ImageJ method
+            n_pixels = np.sum(mask)  # Count of pixels in mask
+            area = n_pixels * (pixel_spacing ** 2)
+            
+            # Calculate other statistics
             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)
-            
-            # Calculate area using ImageJ method
-            area = n_pixels * (pixel_spacing ** 2)
 
-            # Store results with ImageJ precision
+            # 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+0.5:.1f}, {y+0.5:.1f})"  # Add 0.5 back for display
+                'Point': f"({x:.1f}, {y:.1f})"
             }
             
+            print(f"ROI Analysis Results:")
+            print(f"Area: {area:.3f} mm²")
+            print(f"Mean: {mean_value:.3f}")
+            print(f"StdDev: {std_dev:.3f}")
+            print(f"Min: {min_val:.3f}")
+            print(f"Max: {max_val:.3f}")
+            print(f"Position: ({x:.1f}, {y:.1f})")
+            
             self.results.append(result)
-            self.marks.append((x+0.5, y+0.5, self.circle_diameter))
+            self.marks.append((x, y, self.circle_diameter))
 
             return self.update_display(), self.format_results()
         except Exception as e:
@@ -205,13 +211,13 @@ 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)  # Adjusted radius calculation
                 
                 # Draw main circle
                 cv2.circle(zoomed_bgr,
                           (zoomed_x, zoomed_y),
                           zoomed_radius,
-                          self.CIRCLE_COLOR,  # BGR Yellow (0, 255, 255)
+                          self.CIRCLE_COLOR,  # BGR Yellow
                           1,
                           lineType=cv2.LINE_AA)
                 
@@ -224,7 +230,7 @@ class DicomAnalyzer:
                     cv2.circle(zoomed_bgr,
                               (point_x, point_y),
                               1,
-                              self.CIRCLE_COLOR,  # BGR Yellow (0, 255, 255)
+                              self.CIRCLE_COLOR,
                               -1,
                               lineType=cv2.LINE_AA)
 
@@ -345,7 +351,7 @@ def create_interface():
         """)
         
         def update_diameter(x):
-            analyzer.circle_diameter = x
+            analyzer.circle_diameter = float(x)  # Convert to float
             print(f"Diameter updated to: {x}")
             return f"Diameter set to {x} pixels"