Update app.py

app.py

@@ -5,9 +5,46 @@ import pandas as pd
 import pydicom
 import io
 from PIL import Image
+import openpyxl
+from openpyxl.utils import get_column_letter, column_index_from_string
+import logging
+import time
+import traceback
+from functools import wraps
+import sys
 
 print("Starting imports completed...")
 
+# Set up logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('dicom_analyzer_debug.log'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+def debug_decorator(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        logger.debug(f"Entering {func.__name__}")
+        start_time = time.time()
+        try:
+            result = func(*args, **kwargs)
+            logger.debug(f"Function {func.__name__} completed successfully")
+            return result
+        except Exception as e:
+            logger.error(f"Error in {func.__name__}: {str(e)}")
+            logger.error(traceback.format_exc())
+            raise
+        finally:
+            end_time = time.time()
+            logger.debug(f"Execution time: {end_time - start_time:.4f} seconds")
+    return wrapper
+
 class DicomAnalyzer:
     def __init__(self):
         self.results = []
@@ -124,17 +161,14 @@ class DicomAnalyzer:
         except Exception as e:
             print(f"Error handling keyboard input: {str(e)}")
             return self.display_image
-
     def analyze_roi(self, evt: gr.SelectData):
         try:
             if self.current_image is None:
                 return None, "No image loaded"
 
-            # Get clicked coordinates
             clicked_x = evt.index[0]
             clicked_y = evt.index[1]
             
-            # Transform coordinates
             x = clicked_x + self.pan_x
             y = clicked_y + self.pan_y
             if self.zoom_factor != 1.0:
@@ -144,63 +178,43 @@ class DicomAnalyzer:
             x = int(round(x))
             y = int(round(y))
             
-            # Get image dimensions
             height, width = self.original_image.shape[:2]
             
-            # Create mask using ImageJ's exact method
             Y, X = np.ogrid[:height, :width]
             
-            # Use exact 9-pixel diameter
             radius = self.circle_diameter / 2.0
             r_squared = radius * radius
             
-            # Calculate distances exactly as ImageJ does
             dx = X - x
             dy = Y - y
             dist_squared = dx*dx + dy*dy
             
-            # Create mask with ImageJ's method
             mask = np.zeros((height, width), dtype=bool)
             mask[dist_squared <= r_squared] = True
             
-            # Get ROI pixels from original DICOM values
             roi_pixels = self.original_image[mask]
             
             if len(roi_pixels) == 0:
                 return self.display_image, "Error: No pixels selected"
 
-            # Get pixel spacing (mm/pixel)
             pixel_spacing = float(self.dicom_data.PixelSpacing[0])
             
-            # Calculate area (this part is correct)
             n_pixels = np.sum(mask)
             area = n_pixels * (pixel_spacing ** 2)
             
-            # Calculate statistics using ImageJ's methods
             mean_value = np.mean(roi_pixels)
-            std_dev = np.std(roi_pixels, ddof=1)  # ImageJ uses n-1
+            std_dev = np.std(roi_pixels, ddof=1)
             min_val = np.min(roi_pixels)
             max_val = np.max(roi_pixels)
 
-            # Apply any necessary scaling from DICOM
             rescale_slope = getattr(self.dicom_data, 'RescaleSlope', 1)
             rescale_intercept = getattr(self.dicom_data, 'RescaleIntercept', 0)
             
-            # Adjust values using DICOM scaling
             mean_value = (mean_value * rescale_slope) + rescale_intercept
             std_dev = std_dev * rescale_slope
             min_val = (min_val * rescale_slope) + rescale_intercept
             max_val = (max_val * rescale_slope) + rescale_intercept
 
-            print(f"\nImageJ-compatible Analysis:")
-            print(f"Position: ({x}, {y})")
-            print(f"Pixel count: {n_pixels}")
-            print(f"Area: {area:.3f} mm²")
-            print(f"Mean: {mean_value:.3f}")
-            print(f"StdDev: {std_dev:.3f}")
-            print(f"Min: {min_val}")
-            print(f"Max: {max_val}")
-
             result = {
                 'Area (mm²)': f"{area:.3f}",
                 'Mean': f"{mean_value:.3f}",
@@ -217,6 +231,7 @@ class DicomAnalyzer:
         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:
@@ -226,29 +241,23 @@ class DicomAnalyzer:
             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 with ImageJ-style dots
             for x, y, diameter in self.marks:
                 zoomed_x = int(x * self.zoom_factor)
                 zoomed_y = int(y * self.zoom_factor)
-                # Use exact radius without any additions
                 zoomed_radius = int((diameter/2.0) * self.zoom_factor)
                 
-                # Draw main circle
                 cv2.circle(zoomed_bgr,
                           (zoomed_x, zoomed_y),
                           zoomed_radius,
-                          self.CIRCLE_COLOR,  # BGR Yellow
+                          self.CIRCLE_COLOR,
                           1,
                           lineType=cv2.LINE_AA)
                 
-                # Draw dots like ImageJ
                 num_points = 8
                 for i in range(num_points):
                     angle = 2 * np.pi * i / num_points
@@ -261,16 +270,13 @@ class DicomAnalyzer:
                               -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)
             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)
@@ -289,6 +295,79 @@ class DicomAnalyzer:
         df = df[columns_order]
         return df.to_string(index=False)
 
+    def save_results(self):
+        try:
+            if not self.results:
+                return None, "No results to save"
+
+            # Create a new workbook
+            wb = openpyxl.Workbook()
+            ws = wb.active
+
+            # Define the equation slots
+            equation_slots = [
+                ('B', 'F'), ('H', 'L'), ('N', 'R'), ('T', 'X'), ('Z', 'AD'),
+                ('AF', 'AJ'), ('AL', 'AP'), ('AR', 'AV'), ('AX', 'BB'), ('BD', 'BH'),
+                ('BJ', 'BN'), ('BP', 'BT'), ('BV', 'BZ'),
+            ]
+
+            # Define row groups
+            row_groups = [
+                (2, 3), (5, 6), (8, 9), (11, 12), (14, 15), 
+                (17, 18), (20, 21), (23, 24), (26, 27), (29, 30),
+            ]
+
+            # Add headers for different phantom sizes
+            phantom_sizes = ['(7mm)', '(6.5mm)', '(6mm)', '(5.5mm)', '(5mm)', '(4.5mm)']
+            for i, size in enumerate(phantom_sizes):
+                row_index = row_groups[i][0] - 1
+                ws.cell(row=row_index, column=1, value=size)
+
+            # Process results in pairs
+            result_pairs = [self.results[i:i+2] for i in range(0, len(self.results), 2)]
+            
+            for pair_idx, result_pair in enumerate(result_pairs):
+                if pair_idx >= len(equation_slots) * len(row_groups):
+                    break
+
+                slot_idx = pair_idx % len(equation_slots)
+                group_idx = pair_idx // len(equation_slots)
+                
+                if group_idx >= len(row_groups):
+                    break
+
+                start_col, _ = equation_slots[slot_idx]
+                dest_rows = row_groups[group_idx]
+
+                # Fill data for the pair
+                for row_idx, result in enumerate(result_pair):
+                    if row_idx < 2:  # Only process up to 2 rows
+                        dest_row = dest_rows[row_idx]
+                        
+                        # Write row number
+                        ws.cell(row=dest_row, column=1, value=row_idx + 1)
+                        
+                        # Write values in correct columns
+                        ws.cell(row=dest_row, column=openpyxl.utils.column_index_from_string(start_col),
+                               value=float(result['Area (mm²)']))
+                        ws.cell(row=dest_row, column=openpyxl.utils.column_index_from_string(start_col) + 1,
+                               value=float(result['Mean']))
+                        ws.cell(row=dest_row, column=openpyxl.utils.column_index_from_string(start_col) + 2,
+                               value=float(result['StdDev']))
+                        ws.cell(row=dest_row, column=openpyxl.utils.column_index_from_string(start_col) + 3,
+                               value=float(result['Min']))
+                        ws.cell(row=dest_row, column=openpyxl.utils.column_index_from_string(start_col) + 4,
+                               value=float(result['Max']))
+
+            # Save the workbook
+            output_file = "analysis_results.xlsx"
+            wb.save(output_file)
+            
+            return output_file, "Results saved successfully in the required format"
+        except Exception as e:
+            print(f"Error saving results: {str(e)}")
+            return None, f"Error saving results: {str(e)}"
+
     def add_blank_row(self, image):
         self.results.append({
             'Area (mm²)': '',
@@ -318,22 +397,7 @@ class DicomAnalyzer:
             self.marks.pop()
         return self.update_display(), self.format_results()
 
-    def save_results(self):
-        try:
-            if not self.results:
-                return None, "No results to save"
-            
-            df = pd.DataFrame(self.results)
-            columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
-            df = df[columns_order]
-            
-            temp_file = "analysis_results.xlsx"
-            df.to_excel(temp_file, index=False)
-            
-            return temp_file, "Results saved successfully"
-        except Exception as e:
-            return None, f"Error saving results: {str(e)}"
-
+# ... (rest of the code with create_interface and main remains the same)
 def create_interface():
     print("Creating interface...")
     analyzer = DicomAnalyzer()
@@ -358,7 +422,11 @@ def create_interface():
                     reset_btn = gr.Button("Reset View")
                 
             with gr.Column():
-                image_display = gr.Image(label="DICOM Image", interactive=True, elem_id="image_display")
+                image_display = gr.Image(
+                    label="DICOM Image",
+                    interactive=True,
+                    elem_id="image_display"
+                )
                 
         with gr.Row():
             blank_btn = gr.Button("Add Blank Row")
@@ -375,6 +443,7 @@ def create_interface():
         - Use arrow keys to pan when zoomed in
         - Click points to measure
         - Use Zoom In/Out buttons or Reset View to adjust zoom level
+        - Results will be saved in ImageJ-compatible format
         """)
         
         def update_diameter(x):
@@ -403,13 +472,15 @@ def create_interface():
         zoom_in_btn.click(
             fn=analyzer.zoom_in,
             inputs=image_display,
-            outputs=image_display
+            outputs=image_display,
+            queue=False  # Allow continuous clicking
         )
         
         zoom_out_btn.click(
             fn=analyzer.zoom_out,
             inputs=image_display,
-            outputs=image_display
+            outputs=image_display,
+            queue=False  # Allow continuous clicking
         )
         
         reset_btn.click(
@@ -478,4 +549,6 @@ if __name__ == "__main__":
         )
     except Exception as e:
         print(f"Error launching application: {str(e)}")
+        logger.error(f"Error launching application: {str(e)}")
+        logger.error(traceback.format_exc())
         raise e