Update app.py

app.py

@@ -144,59 +144,131 @@ class DicomAnalyzer:
                 x = clicked_x
                 y = clicked_y
 
-        # 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
+            # Apply ImageJ coordinate system correction
+            x_offset = -2  # Adjust this value
+            y_offset = -2  # Adjust this value
+            
+            x = x + x_offset
+            y = y + y_offset
 
-        # Get ROI pixels using ImageJ-aligned coordinates
-        roi_pixels = raw_image[mask == 1]
+            # Ensure coordinates are within bounds
+            x = max(0, min(x, width-1))
+            y = max(0, min(y, height-1))
 
-        # 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))
+            # 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
 
-        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)}"
+            # Get ROI pixels using ImageJ-aligned coordinates
+            roi_pixels = raw_image[mask == 1]
+
+            # 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 = 0.3  # 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))
+
+            # 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)
+
+            # Convert back to RGB for display
+            zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
+
+            # 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)
+            ]
+
+            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: