Update app.py

app.py

@@ -59,24 +59,21 @@ class DicomAnalyzer:
             return None, f"Error loading DICOM file: {str(e)}"
 
     def normalize_image(self, image):
-        try:
-            # Improve image normalization
-            normalized = cv2.normalize(
-                image, 
-                None, 
-                alpha=0,
-                beta=255,
-                norm_type=cv2.NORM_MINMAX,
-                dtype=cv2.CV_8U
-            )
-            if len(normalized.shape) == 2:
-                normalized = cv2.cvtColor(normalized, cv2.COLOR_GRAY2RGB)
-            else:
-                normalized = cv2.cvtColor(normalized, cv2.COLOR_BGR2RGB)
-            return normalized
-        except Exception as e:
-            print(f"Error normalizing image: {str(e)}")
-            return None
+    try:
+        normalized = cv2.normalize(
+            image, 
+            None, 
+            alpha=0,
+            beta=255,
+            norm_type=cv2.NORM_MINMAX,
+            dtype=cv2.CV_8U
+        )
+        if len(normalized.shape) == 2:
+            normalized = cv2.cvtColor(normalized, cv2.COLOR_GRAY2BGR)
+        return normalized
+    except Exception as e:
+        print(f"Error normalizing image: {str(e)}")
+        return None
 
     def reset_view(self):
         self.zoom_factor = 1.0
@@ -97,23 +94,28 @@ class DicomAnalyzer:
         return self.update_display()
 
     def handle_keyboard(self, key):
-        try:
-            print(f"Handling key press: {key}")
-            pan_amount = int(10 * self.zoom_factor)
-            
-            if key == 'ArrowLeft':
-                self.pan_x = max(0, self.pan_x - pan_amount)
-            elif key == 'ArrowRight':
-                self.pan_x = min(self.max_pan_x, self.pan_x + pan_amount)
-            elif key == 'ArrowUp':
-                self.pan_y = max(0, self.pan_y - pan_amount)
-            elif key == 'ArrowDown':
-                self.pan_y = min(self.max_pan_y, self.pan_y + pan_amount)
-            
-            return self.update_display()
-        except Exception as e:
-            print(f"Error handling keyboard input: {str(e)}")
-            return self.display_image
+    try:
+        print(f"Handling key press: {key}")
+        # Smaller pan amount for smoother movement
+        pan_amount = int(5 * self.zoom_factor)
+        
+        if key == 'ArrowLeft':
+            self.pan_x = max(0, self.pan_x - pan_amount)
+            print(f"Pan X: {self.pan_x}")
+        elif key == 'ArrowRight':
+            self.pan_x = min(self.max_pan_x, self.pan_x + pan_amount)
+            print(f"Pan X: {self.pan_x}")
+        elif key == 'ArrowUp':
+            self.pan_y = max(0, self.pan_y - pan_amount)
+            print(f"Pan Y: {self.pan_y}")
+        elif key == 'ArrowDown':
+            self.pan_y = min(self.max_pan_y, self.pan_y + pan_amount)
+            print(f"Pan Y: {self.pan_y}")
+        
+        return self.update_display()
+    except Exception as e:
+        print(f"Error handling keyboard input: {str(e)}")
+        return self.display_image
 
     def analyze_roi(self, evt: gr.SelectData):
         try:
@@ -165,75 +167,68 @@ class DicomAnalyzer:
             return self.display_image, f"Error analyzing ROI: {str(e)}"
 
     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)
-
-            # Convert to BGR for drawing
-            zoomed_bgr = cv2.cvtColor(zoomed, cv2.COLOR_RGB2BGR)
+    try:
+        if self.original_display is None:
+            return None
 
-            # 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_bgr,
-                          (zoomed_x, zoomed_y),
-                          zoomed_diameter // 2,
-                          (255, 255, 0),  # 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_bgr,
-                              (point_x, point_y),
-                              1,
-                              (255, 255, 0),  # BGR: Pure yellow
-                              -1,
-                              lineType=cv2.LINE_AA)
+        # Calculate zoomed size
+        height, width = self.original_display.shape[:2]
+        new_height = int(height * self.zoom_factor)
+        new_width = int(width * self.zoom_factor)
 
-            # Convert back to RGB for display
-            zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
+        # Create zoomed image
+        zoomed = cv2.resize(self.original_display, (new_width, new_height), 
+                          interpolation=cv2.INTER_CUBIC)
 
-            # 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)
+        # 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)
             
-            # 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)
+            # Draw yellow circle (BGR format)
+            cv2.circle(zoomed,
+                      (zoomed_x, zoomed_y),
+                      zoomed_diameter // 2,
+                      (0, 255, 255),  # BGR: Yellow
+                      1,
+                      lineType=cv2.LINE_AA)
             
-            # Extract correct portion of zoomed image
-            visible = zoomed[
-                self.pan_y:self.pan_y + visible_height,
-                self.pan_x:self.pan_x + visible_width
-            ]
+            # Draw yellow dots
+            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: Yellow
+                          -1,
+                          lineType=cv2.LINE_AA)
 
-            return visible
-        except Exception as e:
-            print(f"Error updating display: {str(e)}")
-            return self.original_display
+        # Extract visible portion
+        visible_height = min(height, new_height)
+        visible_width = min(width, new_width)
+        
+        # Update max pan values
+        self.max_pan_x = new_width - width
+        self.max_pan_y = 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 with pan
+        start_y = int(self.pan_y)
+        start_x = int(self.pan_x)
+        visible = zoomed[start_y:start_y + visible_height, 
+                        start_x:start_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: