Update app.py

app.py

@@ -65,6 +65,13 @@ class DicomAnalyzer:
         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
+        return self.update_display(), "All data has been reset"
+
     def load_dicom(self, file):
         try:
             if file is None:
@@ -91,15 +98,14 @@ class DicomAnalyzer:
             self.display_image = self.normalize_image(image)
             self.original_display = self.display_image.copy()
             
-            # Reset view on new image
-            self.reset_view()
+            # Reset all data when loading new image
+            self.reset_all(None)
             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:
             normalized = cv2.normalize(
@@ -161,6 +167,7 @@ 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:
@@ -287,41 +294,38 @@ class DicomAnalyzer:
             print(f"Error updating display: {str(e)}")
             return self.original_display
 
-    def format_results(self):
-        if not self.results:
-            return "No measurements yet"
-        df = pd.DataFrame(self.results)
-        columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
-        df = df[columns_order]
-        return df.to_string(index=False)
-
-    def save_results(self):
+    def add_formulas_to_template(self, ws, row_pair, col_group):
+        """Add formulas for each row pair and column group"""
         try:
-            if not self.results:
-                return None, "No results to save"
+            # Get base column for formulas
+            base_col = col_group[1]  # Mean column
+            std_col = col_group[2]   # StdDev column
+            
+            row1, row2 = row_pair
             
-            df = pd.DataFrame(self.results)
-            columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
-            df = df[columns_order]
+            # 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)
+            ws[f"{formula_col}{row1}"] = formula1
             
-            temp_file = "analysis_results.xlsx"
-            df.to_excel(temp_file, index=False)
+            # Formula for second row: =(Mean1-Mean2)/StdDev2
+            formula2 = f"=({base_col}{row1}-{base_col}{row2})/{std_col}{row2}"
+            ws[f"{formula_col}{row2}"] = formula2
             
-            return temp_file, "Results saved successfully"
+            logger.debug(f"Added formulas for rows {row1},{row2} in column {formula_col}")
         except Exception as e:
-            print(f"Error saving results: {str(e)}")
-            return None, f"Error saving results: {str(e)}"
+            logger.error(f"Error adding formulas: {str(e)}")
 
-    def save_results_to_template(self, template_path, output_path):
+    def save_formatted_results(self, output_path):
         try:
             if not self.results:
                 return None, "No results to save"
 
-            # Load the template while preserving formulas
-            wb = openpyxl.load_workbook(template_path, data_only=False)
+            # Create new workbook
+            wb = openpyxl.Workbook()
             ws = wb.active
 
-            # Define the column groups for horizontal saving (13 groups)
+            # Define column groups and row pairs
             column_groups = [
                 ('B', 'C', 'D', 'E', 'F'),      # First group
                 ('H', 'I', 'J', 'K', 'L'),      # Second group
@@ -338,7 +342,6 @@ class DicomAnalyzer:
                 ('BV', 'BW', 'BX', 'BY', 'BZ')  # Thirteenth group
             ]
 
-            # Define row pairs
             row_pairs = [
                 (2, 3),      # 7mm
                 (5, 6),      # 6.5mm
@@ -352,6 +355,12 @@ class DicomAnalyzer:
                 (29, 30)     # 2.5mm
             ]
 
+            # Add headers
+            phantom_sizes = ['(7mm)', '(6.5mm)', '(6mm)', '(5.5mm)', '(5mm)', 
+                           '(4.5mm)', '(4mm)', '(3.5mm)', '(3mm)', '(2.5mm)']
+            for i, size in enumerate(phantom_sizes):
+                ws.cell(row=row_pairs[i][0]-1, column=1, value=size)
+
             # Process results
             result_idx = 0
             current_col_group = 0
@@ -361,60 +370,50 @@ class DicomAnalyzer:
                 if current_row_pair >= len(row_pairs):
                     break
                     
-                # Get current positions
                 cols = column_groups[current_col_group]
                 rows = row_pairs[current_row_pair]
                 
-                # Write first row if available
+                # Write data and add formulas
                 if result_idx < len(self.results):
                     result = self.results[result_idx]
-                    # Write Area
-                    ws[f"{cols[0]}{rows[0]}"] = float(result['Area (mm²)'])
-                    # Write Mean
-                    ws[f"{cols[1]}{rows[0]}"] = float(result['Mean'])
-                    # Write StdDev
-                    ws[f"{cols[2]}{rows[0]}"] = float(result['StdDev'])
-                    # Write Min
-                    ws[f"{cols[3]}{rows[0]}"] = float(result['Min'])
-                    # Write Max
-                    ws[f"{cols[4]}{rows[0]}"] = float(result['Max'])
+                    self._write_result_to_cells(ws, result, cols, rows[0])
                     result_idx += 1
                 
-                # Write second row if available
                 if result_idx < len(self.results):
                     result = self.results[result_idx]
-                    # Write Area
-                    ws[f"{cols[0]}{rows[1]}"] = float(result['Area (mm²)'])
-                    # Write Mean
-                    ws[f"{cols[1]}{rows[1]}"] = float(result['Mean'])
-                    # Write StdDev
-                    ws[f"{cols[2]}{rows[1]}"] = float(result['StdDev'])
-                    # Write Min
-                    ws[f"{cols[3]}{rows[1]}"] = float(result['Min'])
-                    # Write Max
-                    ws[f"{cols[4]}{rows[1]}"] = float(result['Max'])
+                    self._write_result_to_cells(ws, result, cols, rows[1])
                     result_idx += 1
                 
-                # Move to next column group
-                current_col_group += 1
+                # Add formulas for this group
+                self.add_formulas_to_template(ws, rows, cols)
                 
-                # If we've used all 13 column groups, move to next row pair
+                current_col_group += 1
                 if current_col_group >= len(column_groups):
                     current_col_group = 0
                     current_row_pair += 1
 
-                print(f"Processed results {result_idx-2}-{result_idx-1} in columns {cols[0]}-{cols[4]} rows {rows[0]}-{rows[1]}")
-
-            # Save while preserving formulas
             wb.save(output_path)
-            print(f"Saved {result_idx} results to template")
-            return output_path, f"Results saved successfully in template format ({result_idx} measurements)"
+            return output_path, f"Results saved successfully ({result_idx} measurements)"
 
         except Exception as e:
-            print(f"Error saving results to template: {str(e)}")
-            logger.error(f"Error saving results to template: {str(e)}")
-            logger.error(traceback.format_exc())
-            return None, f"Error saving results to template: {str(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"""
+        ws[f"{cols[0]}{row}"] = float(result['Area (mm²)'])
+        ws[f"{cols[1]}{row}"] = float(result['Mean'])
+        ws[f"{cols[2]}{row}"] = float(result['StdDev'])
+        ws[f"{cols[3]}{row}"] = float(result['Min'])
+        ws[f"{cols[4]}{row}"] = float(result['Max'])
+
+    def format_results(self):
+        if not self.results:
+            return "No measurements yet"
+        df = pd.DataFrame(self.results)
+        columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
+        df = df[columns_order]
+        return df.to_string(index=False)
 
     def add_blank_row(self, image):
         self.results.append({
@@ -454,7 +453,6 @@ 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,
@@ -467,6 +465,7 @@ def create_interface():
                     zoom_in_btn = gr.Button("Zoom In (+)")
                     zoom_out_btn = gr.Button("Zoom Out (-)")
                     reset_btn = gr.Button("Reset View")
+                    reset_all_btn = gr.Button("Reset All")  # New reset all button
                 
             with gr.Column():
                 image_display = gr.Image(
@@ -480,7 +479,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")
+            save_formatted_btn = gr.Button("Save Formatted Results")  # Renamed button
             
         results_display = gr.Textbox(label="Results", interactive=False)
         file_output = gr.File(label="Download Results")
@@ -491,7 +490,8 @@ 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
-        - Upload template and use Save to Template for formatted results
+        - Use Reset All to clear all measurements
+        - Save Formatted Results will create Excel file with formulas
         """)
         
         def update_diameter(x):
@@ -499,12 +499,9 @@ def create_interface():
             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)
+        def save_formatted():
+            output_path = "analysis_results_formatted.xlsx"
+            return analyzer.save_formatted_results(output_path)
 
         # Event handlers
         file_input.change(
@@ -543,6 +540,13 @@ def create_interface():
             outputs=image_display
         )
         
+        # New reset all button handler
+        reset_all_btn.click(
+            fn=analyzer.reset_all,
+            inputs=image_display,
+            outputs=[image_display, results_display]
+        )
+        
         key_press.change(
             fn=analyzer.handle_keyboard,
             inputs=key_press,
@@ -572,9 +576,8 @@ def create_interface():
             outputs=[file_output, results_display]
         )
 
-        save_template_btn.click(
-            fn=save_to_template,
-            inputs=[template_input],
+        save_formatted_btn.click(
+            fn=save_formatted,
             outputs=[file_output, results_display]
         )