Update app.py

app.py

@@ -48,28 +48,25 @@ def debug_decorator(func):
 class DicomAnalyzer:
     def __init__(self):
         self.results = []
-        self.circle_diameter = 9.0  # Changed to float for precise calculations
+        self.circle_diameter = 9.0
         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.marks = []
         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...")
 
     def reset_all(self, image):
-        """Reset all data and view settings"""
-        self.results = []  # Clear all results
-        self.marks = []    # Clear all marks
-        self.reset_view()  # Reset view settings
+        self.results = []
+        self.marks = []
+        self.reset_view()
         return self.update_display(), "All data has been reset"
 
     def load_dicom(self, file):
@@ -83,22 +80,17 @@ class DicomAnalyzer:
                 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 all data when loading new image
             self.reset_all(None)
             print("DICOM file loaded successfully")
             
@@ -159,11 +151,6 @@ class DicomAnalyzer:
             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)}")
@@ -189,7 +176,6 @@ class DicomAnalyzer:
             height, width = self.original_image.shape[:2]
             
             Y, X = np.ogrid[:height, :width]
-            
             radius = self.circle_diameter / 2.0
             r_squared = radius * radius
             
@@ -206,7 +192,6 @@ class DicomAnalyzer:
                 return self.display_image, "Error: No pixels selected"
 
             pixel_spacing = float(self.dicom_data.PixelSpacing[0])
-            
             n_pixels = np.sum(mask)
             area = n_pixels * (pixel_spacing ** 2)
             
@@ -239,7 +224,6 @@ 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:
@@ -295,161 +279,110 @@ class DicomAnalyzer:
             print(f"Error updating display: {str(e)}")
             return self.original_display
 
-    def save_results(self):
-        """
-        Basic save function for raw results with improved error handling and logging
-        
-        Returns:
-            tuple: (str, str) - (filepath, message) or (None, error_message)
-        """
+    def add_formulas_to_template(self, ws, row_pair, col_group, red_font):
+        """Add formulas for each row pair and column group"""
+        try:
+            base_col = col_group[1]  # Mean column
+            std_col = col_group[2]   # StdDev column
+            
+            row1, row2 = row_pair
+            
+            # Formula for first row: =Mean/StdDev
+            formula1 = f"={base_col}{row1}/{std_col}{row1}"
+            formula_col = get_column_letter(column_index_from_string(col_group[-1]) + 1)
+            cell1 = ws[f"{formula_col}{row1}"]
+            cell1.value = formula1
+            cell1.font = red_font
+            
+            # Formula for second row: =(Mean1-Mean2)/StdDev2
+            formula2 = f"=({base_col}{row1}-{base_col}{row2})/{std_col}{row2}"
+            cell2 = ws[f"{formula_col}{row2}"]
+            cell2.value = formula2
+            cell2.font = red_font
+            
+            logger.debug(f"Added formulas for rows {row1},{row2} in column {formula_col}")
+        except Exception as e:
+            logger.error(f"Error adding formulas: {str(e)}")
+
+    def save_formatted_results(self, output_path):
         try:
             if not self.results:
-                logger.warning("Attempted to save with no results")
                 return None, "No results to save"
 
-            # Create DataFrame with ordered columns
-            df = pd.DataFrame(self.results)
-            columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
-            df = df[columns_order]
-
-            # Generate timestamp for unique filename
-            timestamp = time.strftime("%Y%m%d_%H%M%S")
-            output_file = f"analysis_results_{timestamp}.xlsx"
-
-            # Save with Excel writer to properly format columns
-            with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
-                df.to_excel(writer, index=False, sheet_name='Results')
-                
-                # Auto-adjust column widths
-                worksheet = writer.sheets['Results']
-                for idx, col in enumerate(df.columns):
-                    max_length = max(
-                        df[col].astype(str).apply(len).max(),
-                        len(str(col))
-                    ) + 2
-                    worksheet.column_dimensions[get_column_letter(idx + 1)].width = max_length
-
-            logger.info(f"Results saved successfully to {output_file}")
-            return output_file, f"Results saved successfully to {output_file}"
+            wb = openpyxl.Workbook()
+            ws = wb.active
+
+            red_font = openpyxl.styles.Font(color="FF0000")
+
+            column_groups = [
+                ('B', 'C', 'D', 'E', 'F'),      # First group
+                ('H', 'I', 'J', 'K', 'L'),      # Second group
+                ('N', 'O', 'P', 'Q', 'R'),      # Third group
+                ('T', 'U', 'V', 'W', 'X'),      # Fourth group
+                ('Z', 'AA', 'AB', 'AC', 'AD'),  # Fifth group
+                ('AF', 'AG', 'AH', 'AI', 'AJ'), # Sixth group
+                ('AL', 'AM', 'AN', 'AO', 'AP'), # Seventh group
+                ('AR', 'AS', 'AT', 'AU', 'AV'), # Eighth group
+                ('AX', 'AY', 'AZ', 'BA', 'BB'), # Ninth group
+                ('BD', 'BE', 'BF', 'BG', 'BH'), # Tenth group
+                ('BJ', 'BK', 'BL', 'BM', 'BN'), # Eleventh group
+                ('BP', 'BQ', 'BR', 'BS', 'BT'), # Twelfth group
+                ('BV', 'BW', 'BX', 'BY', 'BZ')  # Thirteenth group
+            ]
 
-        except Exception as e:
-            error_msg = f"Error saving results: {str(e)}"
-            logger.error(error_msg)
-            logger.error(traceback.format_exc())
-            return None, error_msg
+            row_pairs = [
+                (2, 3),      # 7mm
+                (5, 6),      # 6.5mm
+                (8, 9),      # 6mm
+                (11, 12),    # 5.5mm
+                (14, 15),    # 5mm
+                (17, 18),    # 4.5mm
+                (20, 21),    # 4mm
+                (23, 24),    # 3.5mm
+                (26, 27),    # 3mm
+                (29, 30)     # 2.5mm
+            ]
 
-def add_formulas_to_template(self, ws, row_pair, col_group, red_font):
-    """Add formulas for each row pair and column group"""
-    try:
-        # Get base column for formulas
-        base_col = col_group[1]  # Mean column
-        std_col = col_group[2]   # StdDev column
-        
-        row1, row2 = row_pair
-        
-        # Formula for first row: =Mean/StdDev
-        formula1 = f"={base_col}{row1}/{std_col}{row1}"
-        formula_col = get_column_letter(column_index_from_string(col_group[-1]) + 1)
-        cell1 = ws[f"{formula_col}{row1}"]  # Get cell reference first
-        cell1.value = formula1
-        cell1.font = red_font
-        
-        # Formula for second row: =(Mean1-Mean2)/StdDev2
-        formula2 = f"=({base_col}{row1}-{base_col}{row2})/{std_col}{row2}"
-        cell2 = ws[f"{formula_col}{row2}"]  # Get cell reference first
-        cell2.value = formula2
-        cell2.font = red_font
-        
-        logger.debug(f"Added formulas for rows {row1},{row2} in column {formula_col}")
-    except Exception as e:
-        logger.error(f"Error adding formulas: {str(e)}")
+            phantom_sizes = ['(7mm)', '(6.5mm)', '(6mm)', '(5.5mm)', '(5mm)', 
+                           '(4.5mm)', '(4mm)', '(3.5mm)', '(3mm)', '(2.5mm)']
+            for i, size in enumerate(phantom_sizes):
+                header_cell = ws.cell(row=row_pairs[i][0]-1, column=1, value=size)
+                header_cell.font = red_font
 
-def save_formatted_results(self, output_path):
-    try:
-        if not self.results:
-            return None, "No results to save"
-
-        # Create new workbook
-        wb = openpyxl.Workbook()
-        ws = wb.active
-
-        # Create font styles
-        red_font = openpyxl.styles.Font(color="FF0000")  # Red color in RGB
-
-        # Define column groups and row pairs
-        column_groups = [
-            ('B', 'C', 'D', 'E', 'F'),      # First group
-            ('H', 'I', 'J', 'K', 'L'),      # Second group
-            ('N', 'O', 'P', 'Q', 'R'),      # Third group
-            ('T', 'U', 'V', 'W', 'X'),      # Fourth group
-            ('Z', 'AA', 'AB', 'AC', 'AD'),  # Fifth group
-            ('AF', 'AG', 'AH', 'AI', 'AJ'), # Sixth group
-            ('AL', 'AM', 'AN', 'AO', 'AP'), # Seventh group
-            ('AR', 'AS', 'AT', 'AU', 'AV'), # Eighth group
-            ('AX', 'AY', 'AZ', 'BA', 'BB'), # Ninth group
-            ('BD', 'BE', 'BF', 'BG', 'BH'), # Tenth group
-            ('BJ', 'BK', 'BL', 'BM', 'BN'), # Eleventh group
-            ('BP', 'BQ', 'BR', 'BS', 'BT'), # Twelfth group
-            ('BV', 'BW', 'BX', 'BY', 'BZ')  # Thirteenth group
-        ]
-
-        row_pairs = [
-            (2, 3),      # 7mm
-            (5, 6),      # 6.5mm
-            (8, 9),      # 6mm
-            (11, 12),    # 5.5mm
-            (14, 15),    # 5mm
-            (17, 18),    # 4.5mm
-            (20, 21),    # 4mm
-            (23, 24),    # 3.5mm
-            (26, 27),    # 3mm
-            (29, 30)     # 2.5mm
-        ]
-
-        # Add headers with red font
-        phantom_sizes = ['(7mm)', '(6.5mm)', '(6mm)', '(5.5mm)', '(5mm)', 
-                       '(4.5mm)', '(4mm)', '(3.5mm)', '(3mm)', '(2.5mm)']
-        for i, size in enumerate(phantom_sizes):
-            header_cell = ws.cell(row=row_pairs[i][0]-1, column=1, value=size)
-            header_cell.font = red_font
-
-        # Process results
-        result_idx = 0
-        current_col_group = 0
-        current_row_pair = 0
-        
-        while result_idx < len(self.results):
-            if current_row_pair >= len(row_pairs):
-                break
-                
-            cols = column_groups[current_col_group]
-            rows = row_pairs[current_row_pair]
-            
-            # Write data and add formulas
-            if result_idx < len(self.results):
-                result = self.results[result_idx]
-                self._write_result_to_cells(ws, result, cols, rows[0])
-                result_idx += 1
-            
-            if result_idx < len(self.results):
-                result = self.results[result_idx]
-                self._write_result_to_cells(ws, result, cols, rows[1])
-                result_idx += 1
+            result_idx = 0
+            current_col_group = 0
+            current_row_pair = 0
             
-            # Add formulas for this group
-            self.add_formulas_to_template(ws, rows, cols, red_font)
-            
-            current_col_group += 1
-            if current_col_group >= len(column_groups):
-                current_col_group = 0
-                current_row_pair += 1
+            while result_idx < len(self.results):
+                if current_row_pair >= len(row_pairs):
+                    break
+                    
+                cols = column_groups[current_col_group]
+                rows = row_pairs[current_row_pair]
+                
+                if result_idx < len(self.results):
+                    result = self.results[result_idx]
+                    self._write_result_to_cells(ws, result, cols, rows[0])
+                    result_idx += 1
+                
+                if result_idx < len(self.results):
+                    result = self.results[result_idx]
+                    self._write_result_to_cells(ws, result, cols, rows[1])
+                    result_idx += 1
+                
+                self.add_formulas_to_template(ws, rows, cols, red_font)
+                
+                current_col_group += 1
+                if current_col_group >= len(column_groups):
+                    current_col_group = 0
+                    current_row_pair += 1
 
-        wb.save(output_path)
-        return output_path, f"Results saved successfully ({result_idx} measurements)"
+            wb.save(output_path)
+            return output_path, f"Results saved successfully ({result_idx} measurements)"
 
-    except Exception as e:
-        logger.error(f"Error saving formatted results: {str(e)}")
-        return None, f"Error saving results: {str(e)}"
+        except Exception as e:
+            logger.error(f"Error saving formatted results: {str(e)}")
+            return None, f"Error saving results: {str(e)}"
 
     def _write_result_to_cells(self, ws, result, cols, row):
         """Helper method to write a single result to worksheet cells"""
@@ -468,6 +401,7 @@ def save_formatted_results(self, output_path):
         return df.to_string(index=False)
 
     def add_blank_row(self, image):
+        """Add a blank row to the results"""
         self.results.append({
             'Area (mm²)': '',
             'Mean': '',
@@ -479,6 +413,7 @@ def save_formatted_results(self, output_path):
         return image, self.format_results()
 
     def add_zero_row(self, image):
+        """Add a row of zeros to the results"""
         self.results.append({
             'Area (mm²)': '0.000',
             'Mean': '0.000',
@@ -490,12 +425,12 @@ def save_formatted_results(self, output_path):
         return image, self.format_results()
 
     def undo_last(self, image):
+        """Remove the last measurement"""
         if self.results:
             self.results.pop()
         if self.marks:
             self.marks.pop()
         return self.update_display(), self.format_results()
-
 def create_interface():
     print("Creating interface...")
     analyzer = DicomAnalyzer()