Update app.py

app.py

@@ -1,70 +1,99 @@
-import gradio as gr
-import cv2
-import numpy as np
-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()
+    def load_dicom(self, file):
+        try:
+            if file is None:
+                return None, "No file uploaded"
+            
+            if hasattr(file, 'name'):
+                dicom_data = pydicom.dcmread(file.name)
+            else:
+                dicom_data = pydicom.dcmread(file)
+                
+            image = dicom_data.pixel_array.astype(np.float32)
+            
+            # Store original pixel values before any scaling
+            self.original_image = image.copy()
+            
+            # Apply DICOM scaling for display
+            rescale_slope = getattr(dicom_data, 'RescaleSlope', 1)
+            rescale_intercept = getattr(dicom_data, 'RescaleIntercept', 0)
+            image = (image * rescale_slope) + rescale_intercept
+            
+            self.current_image = image
+            self.dicom_data = dicom_data
+            
+            self.display_image = self.normalize_image(image)
+            self.original_display = self.display_image.copy()
+            
+            # Reset view on new image
+            self.reset_view()
+            print("DICOM file loaded successfully")
+            
+            return self.display_image, "DICOM file loaded successfully"
+        except Exception as e:
+            print(f"Error loading DICOM file: {str(e)}")
+            return None, f"Error loading DICOM file: {str(e)}"
+
+    def normalize_image(self, image):
         try:
-            result = func(*args, **kwargs)
-            logger.debug(f"Function {func.__name__} completed successfully")
-            return result
+            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:
-            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 = []
-        self.circle_diameter = 9.0  # Changed to float for precise calculations
+            print(f"Error normalizing image: {str(e)}")
+            return None
+
+    def reset_view(self):
         self.zoom_factor = 1.0
-        self.current_image = None
-        self.dicom_data = None
-        self.display_image = None
-        self.marks = []  # Store (x, y, diameter) for each mark
-        self.original_image = None
-        self.original_display = None
-        # Pan position
         self.pan_x = 0
         self.pan_y = 0
-        self.max_pan_x = 0
-        self.max_pan_y = 0
-        # Circle color in BGR
-        self.CIRCLE_COLOR = (0, 255, 255)  # BGR Yellow
-        print("DicomAnalyzer initialized...")
+        if self.original_display is not None:
+            return self.update_display()
+        return None
 
+    def zoom_in(self, image):
+        print("Zooming in...")
+        self.zoom_factor = min(20.0, self.zoom_factor + 0.5)
+        return self.update_display()
+
+    def zoom_out(self, image):
+        print("Zooming out...")
+        self.zoom_factor = max(1.0, self.zoom_factor - 0.5)
+        return self.update_display()
+
+    def handle_keyboard(self, key):
+        try:
+            print(f"Handling key press: {key}")
+            pan_amount = int(5 * self.zoom_factor)
+            
+            original_pan_x = self.pan_x
+            original_pan_y = self.pan_y
+            
+            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)
+            
+            print(f"Pan X: {self.pan_x} (was {original_pan_x})")
+            print(f"Pan Y: {self.pan_y} (was {original_pan_y})")
+            print(f"Max Pan X: {self.max_pan_x}")
+            print(f"Max Pan Y: {self.max_pan_y}")
+            
+            return self.update_display()
+        except Exception as e:
+            print(f"Error handling keyboard input: {str(e)}")
+            return self.display_image
     def load_dicom(self, file):
         try:
             if file is None:
@@ -294,79 +323,68 @@ class DicomAnalyzer:
         columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
         df = df[columns_order]
         return df.to_string(index=False)
-
-    def save_results(self):
+    def save_results_to_template(self, template_path, output_path):
         try:
             if not self.results:
                 return None, "No results to save"
 
-            # Create a new workbook
-            wb = openpyxl.Workbook()
+            # Load the Excel template
+            wb = openpyxl.load_workbook(template_path)
             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 and phantom sizes
+            row_groups = {
+                "7mm": [41, 42],
+                "6.5mm": [67, 68],
+                "6mm": [93, 94],
+                "5.5mm": [119, 120],
+                "5mm": [145, 146],
+                "4.5mm": [171, 172],
+                "4mm": [197, 198],
+                "3.5mm": [223, 224],
+                "3mm": [249, 250],
+                "2.5mm": [275, 276]
+            }
 
-            # 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),
-            ]
+            # Define columns for measurements
+            columns = {
+                'Area (mm²)': "B",
+                'Mean': "C",
+                'StdDev': "D",
+                'Min': "E",
+                'Max': "F"
+            }
 
-            # 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)
+            # Map results to phantom sizes (assuming results are ordered for each size)
+            result_idx = 0
 
-            # 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
+            for size, rows in row_groups.items():
+                for row in rows:
+                    if result_idx >= len(self.results):
+                        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']))
+                    result = self.results[result_idx]
+
+                    # Write each metric to the appropriate cell
+                    for metric, col in columns.items():
+                        cell = f"{col}{row}"
+                        value = result.get(metric, '')
+                        if value:
+                            try:
+                                ws[cell] = float(value)
+                            except ValueError:
+                                ws[cell] = value
+
+                    result_idx += 1
 
             # Save the workbook
-            output_file = "analysis_results.xlsx"
-            wb.save(output_file)
-            
-            return output_file, "Results saved successfully in the required format"
+            wb.save(output_path)
+
+            return output_path, "Results saved successfully in the template format"
+
         except Exception as e:
-            print(f"Error saving results: {str(e)}")
-            return None, f"Error saving results: {str(e)}"
+            print(f"Error saving results to template: {str(e)}")
+            return None, f"Error saving results to template: {str(e)}"
 
     def add_blank_row(self, image):
         self.results.append({
@@ -397,7 +415,6 @@ class DicomAnalyzer:
             self.marks.pop()
         return self.update_display(), self.format_results()
 
-# ... (rest of the code with create_interface and main remains the same)
 def create_interface():
     print("Creating interface...")
     analyzer = DicomAnalyzer()
@@ -408,6 +425,7 @@ def create_interface():
         with gr.Row():
             with gr.Column():
                 file_input = gr.File(label="Upload DICOM file")
+                template_input = gr.File(label="Upload Excel Template")
                 diameter_slider = gr.Slider(
                     minimum=1,
                     maximum=20,
@@ -433,6 +451,7 @@ def create_interface():
             zero_btn = gr.Button("Add Zero Row")
             undo_btn = gr.Button("Undo Last")
             save_btn = gr.Button("Save Results")
+            save_template_btn = gr.Button("Save to Template")
             
         results_display = gr.Textbox(label="Results", interactive=False)
         file_output = gr.File(label="Download Results")
@@ -443,14 +462,21 @@ 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
+        - Upload template and use Save to Template for formatted results
         """)
         
         def update_diameter(x):
-            analyzer.circle_diameter = float(x)  # Convert to float
+            analyzer.circle_diameter = float(x)
             print(f"Diameter updated to: {x}")
             return f"Diameter set to {x} pixels"
 
+        def save_to_template(template_file):
+            if template_file is None:
+                return None, "No template file provided"
+            
+            output_path = "analysis_results_from_template.xlsx"
+            return analyzer.save_results_to_template(template_file.name, output_path)
+
         # Event handlers
         file_input.change(
             fn=analyzer.load_dicom,
@@ -473,14 +499,14 @@ def create_interface():
             fn=analyzer.zoom_in,
             inputs=image_display,
             outputs=image_display,
-            queue=False  # Allow continuous clicking
+            queue=False
         )
         
         zoom_out_btn.click(
             fn=analyzer.zoom_out,
             inputs=image_display,
             outputs=image_display,
-            queue=False  # Allow continuous clicking
+            queue=False
         )
         
         reset_btn.click(
@@ -517,6 +543,12 @@ def create_interface():
             outputs=[file_output, results_display]
         )
 
+        save_template_btn.click(
+            fn=save_to_template,
+            inputs=[template_input],
+            outputs=[file_output, results_display]
+        )
+
         js = """
         <script>
         document.addEventListener('keydown', function(e) {