Update app.py

app.py

@@ -131,141 +131,72 @@ class DicomAnalyzer:
             # Get image dimensions
             height, width = raw_image.shape[:2]
 
-            # Get clicked coordinates
+            # Get clicked coordinates and adjust for ImageJ alignment
             clicked_x = evt.index[0]
             clicked_y = evt.index[1]
 
-            # ImageJ coordinate system conversion
+            # Convert coordinates with ImageJ offset correction
             if self.zoom_factor != 1.0:
-                # Convert from display coordinates to image coordinates
+                # For zoomed image
                 x = int((clicked_x + self.pan_x) / self.zoom_factor)
                 y = int((clicked_y + self.pan_y) / self.zoom_factor)
             else:
-                # Direct mapping for no zoom
-                x = int(clicked_x)
-                y = int(clicked_y)
+                x = clicked_x
+                y = clicked_y
 
-            # Offset correction for ImageJ compatibility
-            x = x + 4  # Adjust these offset values based on testing
-            y = y + 4  # Adjust these offset values based on testing
-
-            # Ensure coordinates are within bounds
-            x = max(0, min(x, width-1))
-            y = max(0, min(y, height-1))
-
-            # Create circular mask
-            mask = np.zeros_like(raw_image, dtype=np.uint8)
-            y_indices, x_indices = np.ogrid[:height, :width]
-            radius = self.circle_diameter / 2
-            distance_from_center = np.sqrt(
-                (x_indices - x)**2 + (y_indices - y)**2
-            )
-            mask[distance_from_center <= radius] = 1
-
-            # Get ROI pixels directly from raw image
-            roi_pixels = raw_image[mask == 1]
-
-            # Calculate statistics from raw values
-            pixel_spacing = float(self.dicom_data.PixelSpacing[0])
-            area_pixels = np.sum(mask)
-            area_mm2 = area_pixels * (pixel_spacing ** 2)
-            
-            # Calculate statistics
-            mean = np.mean(roi_pixels)
-            stddev = np.std(roi_pixels)
-            min_val = np.min(roi_pixels)
-            max_val = np.max(roi_pixels)
-
-            # Store results
-            result = {
-                'Area (mm²)': f"{area_mm2:.3f}",
-                'Mean': f"{mean:.3f}",
-                'StdDev': f"{stddev:.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))
-            
-            # Debug information
-            print(f"Original click: ({clicked_x}, {clicked_y})")
-            print(f"Adjusted coordinates: ({x}, {y})")
-            print(f"Zoom factor: {self.zoom_factor}")
-            print(f"Pan: ({self.pan_x}, {self.pan_y})")
-            print(f"ROI Statistics: Mean={mean:.3f}, StdDev={stddev:.3f}")
-            print(f"Min={min_val:.3f}, Max={max_val:.3f}")
-
-            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:
-                return None
-
-            height, width = self.original_display.shape[:2]
-            new_height = int(height * self.zoom_factor)
-            new_width = int(width * self.zoom_factor)
-
-            # Create zoomed image
-            zoomed = cv2.resize(self.original_display, (new_width, new_height), 
-                              interpolation=cv2.INTER_CUBIC)
-
-            # Convert to BGR for drawing
-            zoomed_bgr = cv2.cvtColor(zoomed, cv2.COLOR_RGB2BGR)
-
-            # Draw marks
-            for x, y, diameter in self.marks:
-                zoomed_x = int(x * self.zoom_factor)
-                zoomed_y = int(y * self.zoom_factor)
-                zoomed_diameter = int(diameter * self.zoom_factor)
-                
-                # Draw main circle in BGR color space
-                cv2.circle(zoomed_bgr,
-                          (zoomed_x, zoomed_y),
-                          zoomed_diameter // 2,
-                          (0, 255, 255),  # BGR: Yellow
-                          1,
-                          lineType=cv2.LINE_AA)
-                
-                # Draw dots on circle
-                num_points = 8
-                for i in range(num_points):
-                    angle = 2 * np.pi * i / num_points
-                    point_x = int(zoomed_x + (zoomed_diameter/2) * np.cos(angle))
-                    point_y = int(zoomed_y + (zoomed_diameter/2) * np.sin(angle))
-                    cv2.circle(zoomed_bgr,
-                              (point_x, point_y),
-                              1,
-                              (0, 255, 255),  # BGR: Yellow
-                              -1,
-                              lineType=cv2.LINE_AA)
+        # Apply ImageJ coordinate system correction
+        # These offset values might need fine-tuning based on testing
+        x_offset = -2  # Adjust this value
+        y_offset = -2  # Adjust this value
+        
+        x = x + x_offset
+        y = y + y_offset
+
+        # Ensure coordinates are within bounds
+        x = max(0, min(x, width-1))
+        y = max(0, min(y, height-1))
+
+        # Create circular mask with adjusted coordinates
+        mask = np.zeros_like(raw_image, dtype=np.uint8)
+        y_indices, x_indices = np.ogrid[:height, :width]
+        radius = self.circle_diameter / 2
+        distance_from_center = np.sqrt(
+            (x_indices - x)**2 + (y_indices - y)**2
+        )
+        mask[distance_from_center <= radius] = 1
 
-            # Convert back to RGB for display
-            zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
+        # Get ROI pixels using ImageJ-aligned coordinates
+        roi_pixels = raw_image[mask == 1]
 
-            # Calculate pan limits
-            self.max_pan_x = max(0, new_width - width)
-            self.max_pan_y = max(0, new_height - height)
-            
-            # Ensure pan values are within bounds
-            self.pan_x = min(max(0, self.pan_x), self.max_pan_x)
-            self.pan_y = min(max(0, self.pan_y), self.max_pan_y)
-            
-            # Extract visible portion
-            visible = zoomed[
-                int(self.pan_y):int(self.pan_y + height),
-                int(self.pan_x):int(self.pan_x + width)
-            ]
+        # Calculate statistics using ImageJ scaling
+        pixel_spacing = float(self.dicom_data.PixelSpacing[0])
+        area_pixels = np.sum(mask)
+        area_mm2 = area_pixels * (pixel_spacing ** 2)
+        
+        # Apply ImageJ-like scaling to match results
+        scaling_factor = 1.0  # Adjust this value to match ImageJ scaling
+        mean = np.mean(roi_pixels) * scaling_factor
+        stddev = np.std(roi_pixels) * scaling_factor
+        min_val = np.min(roi_pixels)
+        max_val = np.max(roi_pixels)
+
+        # Store results
+        result = {
+            'Area (mm²)': f"{area_mm2:.3f}",
+            'Mean': f"{mean:.3f}",
+            'StdDev': f"{stddev:.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 visible
-        except Exception as e:
-            print(f"Error updating display: {str(e)}")
-            return self.original_display
+        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 format_results(self):
         if not self.results: