Update app.py

app.py

@@ -94,65 +94,6 @@ class DicomAnalyzer:
         self.zoom_factor = max(1.0, self.zoom_factor - 0.5)
         return self.update_display()
 
-    def update_display(self):
-        try:
-            if self.original_display is None:
-                return None
-
-            # Calculate zoomed size
-            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)
-
-            # Draw marks with ImageJ-like yellow circle
-            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 like ImageJ
-                cv2.circle(zoomed,
-                          (zoomed_x, zoomed_y),
-                          zoomed_diameter // 2,
-                          (0, 255, 255),  # Yellow color
-                          1,  # Thinner line
-                          lineType=cv2.LINE_AA)
-                
-                # Add small points around circle perimeter (ImageJ style)
-                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,
-                              (point_x, point_y),
-                              1,
-                              (0, 255, 255),
-                              -1,
-                              lineType=cv2.LINE_AA)
-
-            # Extract visible portion
-            visible_height = min(height, new_height)
-            visible_width = min(width, new_width)
-            
-            # Ensure pan values don't exceed bounds
-            self.pan_x = min(self.pan_x, max(0, new_width - width))
-            self.pan_y = min(self.pan_y, max(0, new_height - height))
-            
-            visible = zoomed[
-                self.pan_y:self.pan_y + visible_height,
-                self.pan_x:self.pan_x + visible_width
-            ]
-
-            return visible
-        except Exception as e:
-            print(f"Error updating display: {str(e)}")
-            return self.original_display
-
     def handle_keyboard(self, key):
         try:
             print(f"Handling key press: {key}")
@@ -177,16 +118,14 @@ class DicomAnalyzer:
             if self.current_image is None:
                 return None, "No image loaded"
 
-            # Adjust coordinates to match ImageJ
+            # Convert clicked coordinates considering zoom and pan
+            x = int((evt.index[0] + self.pan_x) / self.zoom_factor)
+            y = int((evt.index[1] + self.pan_y) / self.zoom_factor)
+
+            # Ensure coordinates are within image bounds
             height, width = self.current_image.shape[:2]
-            x = int(evt.index[0])
-            y = int(evt.index[1])
-            
-            # Convert coordinates to match ImageJ system
-            if hasattr(self.dicom_data, 'PixelSpacing'):
-                pixel_spacing = float(self.dicom_data.PixelSpacing[0])
-                x = int(x)  # Keep original x coordinate
-                y = int(y)  # Keep original y coordinate
+            x = max(0, min(x, width-1))
+            y = max(0, min(y, height-1))
 
             mask = np.zeros_like(self.current_image, dtype=np.uint8)
             y_indices, x_indices = np.ogrid[:self.current_image.shape[0], :self.current_image.shape[1]]
@@ -223,7 +162,71 @@ class DicomAnalyzer:
             print(f"Error analyzing ROI: {str(e)}")
             return self.display_image, f"Error analyzing ROI: {str(e)}"
 
-    def format_results(self):
+    def update_display(self):
+        try:
+            if self.original_display is None:
+                return None
+
+            # Calculate zoomed size
+            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)
+
+            # Draw marks with ImageJ-like yellow circle
+            for x, y, diameter in self.marks:
+                # Calculate zoomed coordinates correctly
+                zoomed_x = int(x * self.zoom_factor)
+                zoomed_y = int(y * self.zoom_factor)
+                zoomed_diameter = int(diameter * self.zoom_factor)
+                
+                # Draw main circle - Pure yellow
+                cv2.circle(zoomed,
+                          (zoomed_x, zoomed_y),
+                          zoomed_diameter // 2,
+                          (0, 255, 255),  # BGR: Pure yellow
+                          1,  # Thin line
+                          lineType=cv2.LINE_AA)
+                
+                # Add small points around circle perimeter
+                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,
+                              (point_x, point_y),
+                              1,
+                              (0, 255, 255),  # BGR: Pure yellow
+                              -1,
+                              lineType=cv2.LINE_AA)
+
+            # Extract visible portion considering pan
+            visible_height = min(height, new_height)
+            visible_width = min(width, new_width)
+            
+            # Calculate pan bounds
+            self.max_pan_x = max(0, new_width - width)
+            self.max_pan_y = max(0, new_height - height)
+            
+            # Ensure pan values don't exceed bounds
+            self.pan_x = min(self.pan_x, self.max_pan_x)
+            self.pan_y = min(self.pan_y, self.max_pan_y)
+            
+            # Extract correct portion of zoomed image
+            visible = zoomed[
+                self.pan_y:self.pan_y + visible_height,
+                self.pan_x:self.pan_x + visible_width
+            ]
+
+            return visible
+        except Exception as e:
+            print(f"Error updating display: {str(e)}")
+            return self.original_display
+        def format_results(self):
         if not self.results:
             return "No measurements yet"
         df = pd.DataFrame(self.results)
@@ -420,4 +423,4 @@ if __name__ == "__main__":
         )
     except Exception as e:
         print(f"Error launching application: {str(e)}")
-        raise e
+        raise e