Update app.py

app.py

@@ -40,12 +40,15 @@ class DicomAnalyzer:
                 
             image = dicom_data.pixel_array.astype(np.float32)
             
+            # Store original pixel values before any scaling
+            self.original_image = image.copy()
+            
+            # Apply DICOM scaling for display
             rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
             rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
             image = (image * rescale_slope) + rescale_intercept
             
             self.current_image = image
-            self.original_image = image.copy()
             self.dicom_data = dicom_data
             
             self.display_image = self.normalize_image(image)
@@ -131,7 +134,7 @@ class DicomAnalyzer:
             clicked_x = evt.index[0]
             clicked_y = evt.index[1]
             
-            # Transform coordinates to match ImageJ exactly
+            # Transform coordinates
             x = clicked_x + self.pan_x
             y = clicked_y + self.pan_y
             if self.zoom_factor != 1.0:
@@ -144,19 +147,23 @@ class DicomAnalyzer:
             # Get image dimensions
             height, width = self.original_image.shape[:2]
             
-            # Create mask using exact ImageJ method
+            # Create mask using ImageJ's exact method
             Y, X = np.ogrid[:height, :width]
             
             # Use exact 9-pixel diameter
             radius = self.circle_diameter / 2.0
+            r_squared = radius * radius
             
-            # Calculate distances using ImageJ's method
+            # Calculate distances exactly as ImageJ does
             dx = X - x
             dy = Y - y
             dist_squared = dx*dx + dy*dy
-            mask = dist_squared <= (radius * radius)
             
-            # Get ROI pixels from original image
+            # Create mask with ImageJ's method
+            mask = np.zeros((height, width), dtype=bool)
+            mask[dist_squared <= r_squared] = True
+            
+            # Get ROI pixels from original DICOM values
             roi_pixels = self.original_image[mask]
             
             if len(roi_pixels) == 0:
@@ -165,19 +172,28 @@ class DicomAnalyzer:
             # Get pixel spacing (mm/pixel)
             pixel_spacing = float(self.dicom_data.PixelSpacing[0])
             
-            # Calculate area using exact pixel count
+            # Calculate area (this part is correct)
             n_pixels = np.sum(mask)
             area = n_pixels * (pixel_spacing ** 2)
             
-            # Calculate statistics
+            # Calculate statistics using ImageJ's methods
             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)
 
+            # Apply any necessary scaling from DICOM
+            rescale_slope = getattr(self.dicom_data, 'RescaleSlope', 1)
+            rescale_intercept = getattr(self.dicom_data, 'RescaleIntercept', 0)
+            
+            # Adjust values using DICOM scaling
+            mean_value = (mean_value * rescale_slope) + rescale_intercept
+            std_dev = std_dev * rescale_slope
+            min_val = (min_val * rescale_slope) + rescale_intercept
+            max_val = (max_val * rescale_slope) + rescale_intercept
+
             print(f"\nImageJ-compatible Analysis:")
             print(f"Position: ({x}, {y})")
-            print(f"Diameter: {self.circle_diameter} pixels")
             print(f"Pixel count: {n_pixels}")
             print(f"Area: {area:.3f} mm²")
             print(f"Mean: {mean_value:.3f}")