Update app.py

app.py

@@ -9,6 +9,7 @@ import time
 import traceback
 from functools import wraps
 import sys
+import os
 
 # Set up logging
 logging.basicConfig(
@@ -38,7 +39,7 @@ def debug_decorator(func):
             raise
         finally:
             end_time = time.time()
-            logger.debug(f"Exiting {func.__name__}. Execution time: {end_time - start_time:.4f} seconds")
+            logger.debug(f"Execution time: {end_time - start_time:.4f} seconds")
     return wrapper
 
 class DicomAnalyzer:
@@ -62,7 +63,7 @@ class DicomAnalyzer:
         self.max_pan_y = 0
         
         # Constants
-        self.CIRCLE_COLOR = (0, 255, 255)  # BGR Yellow
+        self.CIRCLE_COLOR = (255, 255, 0)  # BGR Yellow (corrected)
         self.MIN_ZOOM = 1.0
         self.MAX_ZOOM = 20.0
         self.ZOOM_STEP = 1.2
@@ -72,7 +73,8 @@ class DicomAnalyzer:
             'last_click': None,
             'last_transformed_coords': None,
             'zoom_history': [],
-            'pan_history': []
+            'pan_history': [],
+            'measurements': []
         }
 
     @debug_decorator
@@ -86,8 +88,10 @@ class DicomAnalyzer:
             else:
                 dicom_data = pydicom.dcmread(file)
             
+            # Convert to float for accurate calculations
             image = dicom_data.pixel_array.astype(float)
             
+            # Apply DICOM rescale parameters
             rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
             rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
             image = (image * rescale_slope) + rescale_intercept
@@ -96,10 +100,20 @@ class DicomAnalyzer:
             self.original_image = image.copy()
             self.dicom_data = dicom_data
             
+            # Prepare display image
             self.display_image = self.normalize_image(image)
             self.original_display = self.display_image.copy()
             
+            # Reset view settings
             self.reset_view()
+            
+            # Log DICOM info for comparison
+            self.logger.debug(f"DICOM Info:")
+            self.logger.debug(f"Image Size: {image.shape}")
+            self.logger.debug(f"Pixel Spacing: {getattr(dicom_data, 'PixelSpacing', [1.0, 1.0])}")
+            self.logger.debug(f"Rescale Slope: {rescale_slope}")
+            self.logger.debug(f"Rescale Intercept: {rescale_intercept}")
+            
             return self.display_image, "DICOM file loaded successfully"
         except Exception as e:
             logger.error(f"Error loading DICOM: {str(e)}")
@@ -133,8 +147,7 @@ class DicomAnalyzer:
                 self.zoom_factor = new_zoom
                 logger.debug(f"Zooming in. New zoom factor: {self.zoom_factor}")
                 self.debug_info['zoom_history'].append(('in', self.zoom_factor))
-                return self.update_display()
-            return image
+            return self.update_display()
         except Exception as e:
             logger.error(f"Error in zoom_in: {str(e)}")
             return image
@@ -147,8 +160,7 @@ class DicomAnalyzer:
                 self.zoom_factor = new_zoom
                 logger.debug(f"Zooming out. New zoom factor: {self.zoom_factor}")
                 self.debug_info['zoom_history'].append(('out', self.zoom_factor))
-                return self.update_display()
-            return image
+            return self.update_display()
         except Exception as e:
             logger.error(f"Error in zoom_out: {str(e)}")
             return image
@@ -158,32 +170,42 @@ class DicomAnalyzer:
             if self.current_image is None:
                 return None, "No image loaded"
 
+            # Get click coordinates and transform them
             clicked_x, clicked_y = evt.index[0], evt.index[1]
             self.debug_info['last_click'] = (clicked_x, clicked_y)
             
+            # Transform to image coordinates (ImageJ-compatible)
             image_x = (clicked_x + self.pan_x) / self.zoom_factor
             image_y = (clicked_y + self.pan_y) / self.zoom_factor
             
             self.debug_info['last_transformed_coords'] = (image_x, image_y)
             
+            # Create circular ROI mask (ImageJ-compatible method)
             height, width = self.current_image.shape[:2]
-            mask = np.zeros((height, width), dtype=np.uint8)
-            cv2.circle(mask, (int(image_x), int(image_y)), 
-                      self.circle_diameter // 2, 1, -1)
+            y, x = np.ogrid[:height, :width]
+            radius = self.circle_diameter / 2
+            mask = ((x - image_x)**2 + (y - image_y)**2 <= radius**2).astype(np.uint8)
 
+            # Get ROI pixels
             roi_pixels = self.current_image[mask == 1]
             
             if len(roi_pixels) == 0:
                 return self.display_image, "Error: No pixels selected"
 
+            # Get pixel spacing (mm/pixel)
             pixel_spacing = getattr(self.dicom_data, 'PixelSpacing', [1.0, 1.0])[0]
 
+            # Calculate statistics (ImageJ-compatible)
+            n_pixels = len(roi_pixels)
             mean_value = np.mean(roi_pixels)
-            std_dev = np.std(roi_pixels, ddof=1)
+            std_dev = np.std(roi_pixels, ddof=1)  # ImageJ uses n-1
             min_val = np.min(roi_pixels)
             max_val = np.max(roi_pixels)
-            area = len(roi_pixels) * (pixel_spacing ** 2)
+            
+            # Calculate area (mm²)
+            area = n_pixels * (pixel_spacing ** 2)
 
+            # Store results
             result = {
                 'Area (mm²)': f"{area:.3f}",
                 'Mean': f"{mean_value:.3f}",
@@ -193,17 +215,33 @@ class DicomAnalyzer:
                 'Point': f"({image_x:.1f}, {image_y:.1f})"
             }
             
+            # Store measurement for ImageJ comparison
+            measurement = {
+                'coordinates': (image_x, image_y),
+                'diameter': self.circle_diameter,
+                'pixel_count': n_pixels,
+                'area': area,
+                'mean': mean_value,
+                'stddev': std_dev,
+                'min': min_val,
+                'max': max_val
+            }
+            self.debug_info['measurements'].append(measurement)
+            
+            # Log for ImageJ comparison
+            logger.debug("\nImageJ Comparison Values:")
+            logger.debug(f"ROI Center: ({image_x:.1f}, {image_y:.1f})")
+            logger.debug(f"Diameter: {self.circle_diameter} pixels")
+            logger.debug(f"Pixel Count: {n_pixels}")
+            logger.debug(f"Area: {area:.6f} mm²")
+            logger.debug(f"Mean: {mean_value:.6f}")
+            logger.debug(f"StdDev: {std_dev:.6f}")
+            logger.debug(f"Min: {min_val:.6f}")
+            logger.debug(f"Max: {max_val:.6f}\n")
+            
             self.results.append(result)
             self.marks.append((image_x, image_y, self.circle_diameter))
 
-            logger.debug(f"ROI Analysis Results:")
-            logger.debug(f"Position: ({image_x:.1f}, {image_y:.1f})")
-            logger.debug(f"Area: {area:.3f} mm²")
-            logger.debug(f"Mean: {mean_value:.3f}")
-            logger.debug(f"StdDev: {std_dev:.3f}")
-            logger.debug(f"Min: {min_val:.3f}")
-            logger.debug(f"Max: {max_val:.3f}")
-
             return self.update_display(), self.format_results()
         except Exception as e:
             logger.error(f"Error in ROI analysis: {str(e)}")
@@ -218,16 +256,18 @@ class DicomAnalyzer:
             height, width = self.original_display.shape[:2]
             display_image = self.original_display.copy()
 
+            # Draw all marks with correct yellow color
             for x, y, diameter in self.marks:
                 cv2.circle(
                     display_image,
                     (int(x), int(y)),
                     diameter // 2,
-                    self.CIRCLE_COLOR,
+                    self.CIRCLE_COLOR,  # BGR Yellow (255, 255, 0)
                     1,
                     lineType=cv2.LINE_AA
                 )
 
+            # Apply zoom
             if self.zoom_factor != 1.0:
                 new_width = int(width * self.zoom_factor)
                 new_height = int(height * self.zoom_factor)
@@ -237,12 +277,15 @@ class DicomAnalyzer:
                     interpolation=cv2.INTER_LINEAR
                 )
 
+            # Update pan limits
             self.max_pan_x = max(0, display_image.shape[1] - width)
             self.max_pan_y = max(0, display_image.shape[0] - height)
             
+            # Apply panning with bounds checking
             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 = display_image[
                 int(self.pan_y):int(self.pan_y + height),
                 int(self.pan_x):int(self.pan_x + width)
@@ -290,6 +333,10 @@ class DicomAnalyzer:
             temp_file = "analysis_results.xlsx"
             df.to_excel(temp_file, index=False)
             
+            # Also save detailed results for ImageJ comparison
+            detailed_results = pd.DataFrame(self.debug_info['measurements'])
+            detailed_results.to_excel("detailed_results.xlsx", index=False)
+            
             return temp_file, "Results saved successfully"
         except Exception as e:
             return None, f"Error saving results: {str(e)}"
@@ -353,14 +400,16 @@ def create_interface():
             fn=analyzer.zoom_in,
             inputs=image_display,
             outputs=image_display,
-            queue=False
+            queue=False,
+            api_name="zoom_in"
         )
         
         zoom_out_btn.click(
             fn=analyzer.zoom_out,
             inputs=image_display,
             outputs=image_display,
-            queue=False
+            queue=False,
+            api_name="zoom_out"
         )
         
         reset_btn.click(