Update app.py

app.py

@@ -61,11 +61,10 @@ class DicomAnalyzer:
         self.pan_y = 0
         self.max_pan_x = 0
         self.max_pan_y = 0
-
-        # Main circle color remains yellow (BGR):
-        self.CIRCLE_COLOR = (0, 255, 255)
-        # Small circles inside the main circle will be white (BGR):
-        self.SMALL_CIRCLES_COLOR = (255, 255, 255)
+        # Main circle color remains yellow:
+        self.CIRCLE_COLOR = (0, 255, 255)  # BGR format
+        # Small circles inside the main circle will be white:
+        self.SMALL_CIRCLES_COLOR = (255, 255, 255)  # BGR white
         print("DicomAnalyzer initialized...")
 
     def save_results(self):
@@ -296,7 +295,7 @@ class DicomAnalyzer:
             
             dx = X - x
             dy = Y - y
-            dist_squared = dx*dx + dy*dy
+            dist_squared = dx * dx + dy * dy
             
             mask = np.zeros((height, width), dtype=bool)
             mask[dist_squared <= r_squared] = True
@@ -377,15 +376,195 @@ class DicomAnalyzer:
         try:
             if not self.results:
                 return None, "No results to save"
-            # ... your existing logic ...
+
+            wb = openpyxl.Workbook()
+            ws = wb.active
+            red_font = openpyxl.styles.Font(color="FF0000")
+            center_alignment = openpyxl.styles.Alignment(horizontal='center')
+            
+            # Column group headers
+            headers = ['Area', 'Mean', 'StdDev', 'Min', 'Max']
+
+            column_groups = [
+                ('B', 'C', 'D', 'E', 'F'), ('H', 'I', 'J', 'K', 'L'),
+                ('N', 'O', 'P', 'Q', 'R'), ('T', 'U', 'V', 'W', 'X'),
+                ('Z', 'AA', 'AB', 'AC', 'AD'), ('AF', 'AG', 'AH', 'AI', 'AJ'),
+                ('AL', 'AM', 'AN', 'AO', 'AP'), ('AR', 'AS', 'AT', 'AU', 'AV'),
+                ('AX', 'AY', 'AZ', 'BA', 'BB'), ('BD', 'BE', 'BF', 'BG', 'BH'),
+                ('BJ', 'BK', 'BL', 'BM', 'BN'), ('BP', 'BQ', 'BR', 'BS', 'BT'),
+                ('BV', 'BW', 'BX', 'BY', 'BZ')
+            ]
+
+            for cols in column_groups:
+                for i, header in enumerate(headers):
+                    cell = ws[f"{cols[i]}1"]
+                    cell.value = header
+                    cell.alignment = center_alignment
+
+            row_pairs = [
+                (2, 3), (5, 6), (8, 9), (11, 12), (14, 15),
+                (17, 18), (20, 21), (23, 24), (26, 27), (29, 30)
+            ]
+
+            phantom_sizes = [
+                '(7mm)', '(6.5mm)', '(6mm)', '(5.5mm)', '(5mm)',
+                '(4.5mm)', '(4mm)', '(3.5mm)', '(3mm)', '(2.5mm)'
+            ]
+            
+            # Set the phantom size row 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 the data from self.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]
+                
+                # First row
+                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
+                if result_idx < len(self.results):
+                    result = self.results[result_idx]
+                    self._write_result_to_cells(ws, result, cols, rows[1])
+                    result_idx += 1
+                
+                # Add SNR/CNR formulas
+                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
+
+            # Center align all data cells
+            for cols in column_groups:
+                for col in cols:
+                    for row in range(2, 31):
+                        cell = ws[f"{col}{row}"]
+                        if cell.value is not None:
+                            cell.alignment = center_alignment
+
+            # Additional tables: StdDev Averages and CNR Averages
+            current_row = 32
+
+            # StdDev
+            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
+            
+            for i, size in enumerate(phantom_sizes):
+                row_number = row_pairs[i][0]
+                stddev_values = []
+                
+                for cols in column_groups:
+                    stddev_col = cols[2]  # The StdDev column
+                    cell_value = ws[f"{stddev_col}{row_number}"].value
+                    if cell_value not in [0, None, '']:
+                        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_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
+
+            # CNR
+            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
+            
+            for i, size in enumerate(phantom_sizes):
+                row_number = row_pairs[i][1]
+                cnr_cells = []
+
+                for cols in column_groups:
+                    formula_col = get_column_letter(column_index_from_string(cols[-1]) + 1)
+                    cnr_cell_ref = f"{formula_col}{row_number}"
+
+                    # Read Mean1, Mean2, Std2 to skip zeros
+                    mean_col = cols[1]
+                    std_col  = cols[2]
+                    
+                    mean1_val = ws[f"{mean_col}{row_pairs[i][0]}"].value
+                    mean2_val = ws[f"{mean_col}{row_pairs[i][1]}"].value
+                    std2_val  = ws[f"{std_col}{row_pairs[i][1]}"].value
+
+                    try:
+                        mean1_val = float(mean1_val) if mean1_val not in [None, ''] else 0
+                        mean2_val = float(mean2_val) if mean2_val not in [None, ''] else 0
+                        std2_val  = float(std2_val)  if std2_val  not in [None, ''] else 0
+                    except:
+                        mean1_val, mean2_val, std2_val = 0, 0, 0
+
+                    # If not all zero, add the cell reference
+                    if not (mean1_val == 0 and mean2_val == 0 and std2_val == 0):
+                        cnr_cells.append(cnr_cell_ref)
+                
+                size_cell = ws.cell(row=current_row, column=1, value=size)
+                size_cell.alignment = center_alignment
+
+                if cnr_cells:
+                    # Using AVERAGE(...) instead of AVERAGEIF
+                    average_formula = f'=IFERROR(AVERAGE({",".join(cnr_cells)}), "")'
+                    
+                    avg_cell = ws.cell(row=current_row, column=2)
+                    avg_cell.value = average_formula
+                    avg_cell.number_format = '0.000'
+                    avg_cell.alignment = center_alignment
+                
+                current_row += 1
+
+            # Align the extra rows
+            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 ({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):
-        # ... your existing logic ...
-        pass
+        """Helper method to write a single result to worksheet cells."""
+        center_alignment = openpyxl.styles.Alignment(horizontal='center')
+        
+        value_mapping = {
+            'Area': 'Area (mm²)',
+            'Mean': 'Mean',
+            'StdDev': 'StdDev',
+            'Min': 'Min',
+            'Max': 'Max'
+        }
+        
+        for i, (header, key) in enumerate(value_mapping.items()):
+            cell = ws[f"{cols[i]}{row}"]
+            val = result[key]
+            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."""
@@ -436,19 +615,8 @@ class DicomAnalyzer:
 def create_interface():
     print("Creating interface...")
     analyzer = DicomAnalyzer()
-
-    # Instead of just #image_display { outline: none; },
-    # we add custom CSS to set the canvas cursor to your icons8 red crosshair.
-    custom_css = """
-    #image_display {
-        outline: none;
-    }
-    #image_display canvas {
-        cursor: url("https://img.icons8.com/?size=100&id=83985&format=png&color=FA5252"), crosshair !important;
-    }
-    """
-
-    with gr.Blocks(css=custom_css) as interface:
+    
+    with gr.Blocks(css="#image_display { outline: none; }") as interface:
         gr.Markdown("# DICOM Image Analyzer")
         
         with gr.Row():
@@ -475,6 +643,7 @@ def create_interface():
                     elem_id="image_display"
                 )
                 
+        # Removed the "Add Blank Row" button
         with gr.Row():
             zero_btn = gr.Button("Add Zero Row")
             zero2_btn = gr.Button("Add Two Zero Rows")
@@ -554,6 +723,7 @@ def create_interface():
             outputs=image_display
         )
         
+        # Removed blank_btn
         zero_btn.click(
             fn=analyzer.add_zero_row,
             inputs=image_display,