Update app.py

app.py

@@ -172,6 +172,10 @@ class DicomAnalyzer:
         return self.update_display()
 
     def handle_keyboard(self, key):
+        """
+        Called when the hidden textbox 'key_press' changes value.
+        key is expected to be 'ArrowLeft','ArrowRight','ArrowUp','ArrowDown'.
+        """
         try:
             print(f"Handling key press: {key}")
             pan_amount = int(5 * self.zoom_factor)
@@ -191,6 +195,9 @@ class DicomAnalyzer:
             return self.display_image
 
     def update_display(self):
+        """
+        Updates the displayed image according to the current zoom/pan and draws the ROI circles.
+        """
         try:
             if self.original_display is None:
                 return None
@@ -221,6 +228,7 @@ class DicomAnalyzer:
                     lineType=cv2.LINE_AA
                 )
                 
+                # Draw small points along the circle
                 num_points = 8
                 for i in range(num_points):
                     angle = 2 * np.pi * i / num_points
@@ -253,6 +261,10 @@ class DicomAnalyzer:
             return self.original_display
 
     def analyze_roi(self, evt: gr.SelectData):
+        """
+        Called when user clicks on the displayed image.
+        Extracts the ROI of diameter circle_diameter and computes stats.
+        """
         try:
             if self.current_image is None:
                 return None, "No image loaded"
@@ -260,8 +272,11 @@ class DicomAnalyzer:
             clicked_x = evt.index[0]
             clicked_y = evt.index[1]
             
+            # Adjust by current pan
             x = clicked_x + self.pan_x
             y = clicked_y + self.pan_y
+
+            # Account for zoom
             if self.zoom_factor != 1.0:
                 x = x / self.zoom_factor
                 y = y / self.zoom_factor
@@ -321,13 +336,16 @@ class DicomAnalyzer:
             return self.display_image, f"Error analyzing ROI: {str(e)}"
 
     def add_formulas_to_template(self, ws, row_pair, col_group, red_font):
+        """
+        Inserts SNR (first row) and CNR (second row) formulas with IFERROR.
+        """
         try:
             base_col = col_group[1]  # Mean column
             std_col = col_group[2]   # StdDev column
             
             row1, row2 = row_pair
             
-            # SNR Formula for the first row with IFERROR
+            # SNR Formula
             formula1 = f"=IFERROR({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}"]
@@ -335,7 +353,7 @@ class DicomAnalyzer:
             cell1.font = red_font
             cell1.alignment = openpyxl.styles.Alignment(horizontal='center')
             
-            # CNR Formula for the second row with IFERROR
+            # CNR Formula
             formula2 = f"=IFERROR(({base_col}{row1}-{base_col}{row2})/{std_col}{row2},\"\")"
             cell2 = ws[f"{formula_col}{row2}"]
             cell2.value = formula2
@@ -347,6 +365,10 @@ class DicomAnalyzer:
             logger.error(f"Error adding formulas: {str(e)}")
 
     def save_formatted_results(self, output_path):
+        """
+        Creates an Excel file with results in a formatted table,
+        adding SNR/CNR formulas and averaging blocks for StdDev and CNR.
+        """
         try:
             if not self.results:
                 return None, "No results to save"
@@ -386,11 +408,13 @@ class DicomAnalyzer:
                 '(4.5mm)', '(4mm)', '(3.5mm)', '(3mm)', '(2.5mm)'
             ]
             
+            # Insert Phantom size labels
             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
                 header_cell.alignment = center_alignment
 
+            # Fill data from self.results
             result_idx = 0
             current_col_group = 0
             current_row_pair = 0
@@ -402,16 +426,19 @@ class DicomAnalyzer:
                 cols = column_groups[current_col_group]
                 rows = row_pairs[current_row_pair]
                 
+                # First row in 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
                 
+                # Second row in pair
                 if result_idx < len(self.results):
                     result = self.results[result_idx]
                     self._write_result_to_cells(ws, result, cols, rows[1])
                     result_idx += 1
                 
+                # Insert SNR/CNR formulas for these two rows
                 self.add_formulas_to_template(ws, rows, cols, red_font)
                 
                 current_col_group += 1
@@ -427,18 +454,18 @@ class DicomAnalyzer:
                         if cell.value is not None:
                             cell.alignment = center_alignment
 
-            # Add space before averages tables
+            # ---- Create tables for StdDev Averages and CNR Averages ----
+
             current_row = 32
 
-            # Headers for StdDev Averages
+            # 1) StdDev Averages
             stddev_header = ws.cell(row=current_row, column=1, value="StdDev Averages")
             stddev_header.font = red_font
             stddev_header.alignment = center_alignment
             current_row += 1
             
-            # Calculate StdDev averages for each row pair (top row only)
             for i, size in enumerate(phantom_sizes):
-                row_number = row_pairs[i][0]  # First row
+                row_number = row_pairs[i][0]  # First row only for std
                 stddev_values = []
                 
                 for cols in column_groups:
@@ -447,30 +474,29 @@ class DicomAnalyzer:
                     if cell_value not in [0, None, '']:  # Ignore zeros and empty
                         stddev_values.append(float(cell_value))
                 
+                size_cell = ws.cell(row=current_row, column=1, value=size)
+                size_cell.alignment = center_alignment
+
                 if stddev_values:
-                    avg = sum(stddev_values) / len(stddev_values)
-                    size_cell = ws.cell(row=current_row, column=1, value=size)
-                    size_cell.alignment = center_alignment
-                    
-                    avg_cell = ws.cell(row=current_row, column=2, value=avg)
+                    avg_stddev = sum(stddev_values) / len(stddev_values)
+                    avg_cell = ws.cell(row=current_row, column=2, value=avg_stddev)
                     avg_cell.number_format = '0.000'
                     avg_cell.alignment = center_alignment
                 current_row += 1
 
-            current_row += 2  # Space between tables
+            current_row += 2  # Space between the two tables
 
-            # Headers for CNR Averages
+            # 2) CNR Averages
             cnr_header = ws.cell(row=current_row, column=1, value="CNR Averages")
             cnr_header.font = red_font
             cnr_header.alignment = center_alignment
             current_row += 1
             
-            # Calculate CNR averages for each row pair (second row)
             for i, size in enumerate(phantom_sizes):
                 row_number = row_pairs[i][1]  # second row for CNR
                 valid_cnr_refs = []
                 
-                # Build references only if Mean and StdDev are not all zero
+                # We'll check each column group to see if there's a (Mean1, Mean2, Std2) not all zero
                 for cols in column_groups:
                     formula_col = get_column_letter(column_index_from_string(cols[-1]) + 1)
                     mean_col = cols[1]
@@ -488,42 +514,44 @@ class DicomAnalyzer:
                     except (ValueError, TypeError):
                         continue
                     
-                    # If not all zero, we consider the cell for average
+                    # If not all zero => there's something measured
                     if not (mean1 == 0 and mean2 == 0 and std2 == 0):
-                        valid_cnr_refs.append(f"{formula_col}{row_number}")
+                        cell_ref = f"{formula_col}{row_number}"
+                        valid_cnr_refs.append(cell_ref)
                 
                 size_cell = ws.cell(row=current_row, column=1, value=size)
                 size_cell.alignment = center_alignment
                 
                 if valid_cnr_refs:
-                    refs = ",".join(valid_cnr_refs)
-                    array_formula = f'=IFERROR(AVERAGE(IF(ISNUMBER({refs}),{refs})),"")'
+                    # Use AVERAGEIF to ignore zero or empty cells
+                    # Must wrap references like (A1,A2,A3) not A1,A2,A3 alone
+                    formula_range = f"({','.join(valid_cnr_refs)})"
+                    cnr_formula = f'=IFERROR(AVERAGEIF({formula_range}, "<>0"), "")'
                     
                     avg_cell = ws.cell(row=current_row, column=2)
-                    avg_cell.value = array_formula
+                    avg_cell.value = cnr_formula
                     avg_cell.number_format = '0.000'
                     avg_cell.alignment = center_alignment
                 
                 current_row += 1
 
-            # Format the tables
+            # Final alignment in the last table
             for row in range(32, current_row):
                 for col in range(1, 3):
                     cell = ws.cell(row=row, column=col)
                     cell.alignment = center_alignment
 
             wb.save(output_path)
-            return output_path, f"Results saved successfully ({result_idx} measurements)"
+            return output_path, f"Results saved successfully ({len(self.results)} measurements)"
 
         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"""
+        """Helper method to write a single result (dict) into a row of cells."""
         center_alignment = openpyxl.styles.Alignment(horizontal='center')
         
-        # Map the headers to the result keys
         value_mapping = {
             'Area': 'Area (mm²)',
             'Mean': 'Mean',
@@ -534,10 +562,13 @@ class DicomAnalyzer:
         
         for i, (header, key) in enumerate(value_mapping.items()):
             cell = ws[f"{cols[i]}{row}"]
-            cell.value = float(result[key]) if result[key] != '' else ''
+            val = result[key]
+            # Handle empty strings
+            cell.value = float(val) if val not in ['', None] else ''
             cell.alignment = center_alignment
 
     def format_results(self):
+        """Returns a string representation of self.results for display."""
         if not self.results:
             return "No measurements yet"
         df = pd.DataFrame(self.results)
@@ -619,18 +650,21 @@ def create_interface():
         
         gr.Markdown("""
         ### Controls:
-        - Use arrow keys to pan when zoomed in
-        - Click points to measure
-        - Use Zoom In/Out buttons or Reset View to adjust zoom level
-        - Use Reset All to clear all measurements
-        - Save Formatted Results will create Excel file with formulas
+        - Use arrow keys to pan when zoomed in (multiple times).
+        - Click points to measure ROI.
+        - Use Zoom In/Out buttons or Reset View to adjust zoom level.
+        - Use Reset All to clear all measurements.
+        - "Save Results" => Basic Excel with raw data.
+        - "Save Formatted Results" => Excel with advanced formatting & formulas.
         """)
 
+        # Update diameter callback
         def update_diameter(x):
             analyzer.circle_diameter = float(x)
             print(f"Diameter updated to: {x}")
             return f"Diameter set to {x} pixels"
 
+        # Save formatted callback
         def save_formatted():
             output_path = "analysis_results_formatted.xlsx"
             return analyzer.save_formatted_results(output_path)
@@ -712,6 +746,8 @@ def create_interface():
             outputs=[file_output, results_display]
         )
 
+        # JavaScript snippet to allow multiple arrow key presses
+        # by resetting the value in key_press.
         js = """
         <script>
         document.addEventListener('keydown', function(e) {
@@ -719,8 +755,15 @@ def create_interface():
                 e.preventDefault();
                 const keyPressElement = document.querySelector('#key_press textarea');
                 if (keyPressElement) {
+                    // Set the value to the pressed key and dispatch
                     keyPressElement.value = e.key;
                     keyPressElement.dispatchEvent(new Event('input'));
+
+                    // Clear value after short delay so next press is recognized
+                    setTimeout(() => {
+                      keyPressElement.value = '';
+                      keyPressElement.dispatchEvent(new Event('input'));
+                    }, 100);
                 }
             }
         });
@@ -731,6 +774,7 @@ def create_interface():
     print("Interface created successfully")
     return interface
 
+
 if __name__ == "__main__":
     try:
         print("Starting application...")