Update app.py

app.py

@@ -45,42 +45,6 @@ def debug_decorator(func):
             logger.debug(f"Execution time: {end_time - start_time:.4f} seconds")
     return wrapper
 
-def save_results(self):
-    """
-    Basic save function for raw results with improved error handling and logging
-    """
-    try:
-        if not self.results:
-            logger.warning("Attempted to save with no results")
-            return None, "No results to save"
-
-        df = pd.DataFrame(self.results)
-        columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
-        df = df[columns_order]
-
-        timestamp = time.strftime("%Y%m%d_%H%M%S")
-        output_file = f"analysis_results_{timestamp}.xlsx"
-
-        with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
-            df.to_excel(writer, index=False, sheet_name='Results')
-            
-            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}"
-
-    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
-
 
 class DicomAnalyzer:
     def __init__(self):
@@ -99,6 +63,43 @@ class DicomAnalyzer:
         self.max_pan_y = 0
         self.CIRCLE_COLOR = (0, 255, 255)  # BGR Yellow
         print("DicomAnalyzer initialized...")
+
+    def save_results(self):
+        """
+        Basic save function for raw results with improved error handling and logging
+        """
+        try:
+            if not self.results:
+                logger.warning("Attempted to save with no results")
+                return None, "No results to save"
+
+            df = pd.DataFrame(self.results)
+            columns_order = ['Area (mm²)', 'Mean', 'StdDev', 'Min', 'Max', 'Point']
+            df = df[columns_order]
+
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            output_file = f"analysis_results_{timestamp}.xlsx"
+
+            with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
+                df.to_excel(writer, index=False, sheet_name='Results')
+                
+                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}"
+
+        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
+
     def reset_all(self, image):
         self.results = []
         self.marks = []
@@ -198,8 +199,11 @@ class DicomAnalyzer:
             new_height = int(height * self.zoom_factor)
             new_width = int(width * self.zoom_factor)
 
-            zoomed = cv2.resize(self.original_display, (new_width, new_height), 
-                              interpolation=cv2.INTER_CUBIC)
+            zoomed = cv2.resize(
+                self.original_display,
+                (new_width, new_height),
+                interpolation=cv2.INTER_CUBIC
+            )
 
             zoomed_bgr = cv2.cvtColor(zoomed, cv2.COLOR_RGB2BGR)
 
@@ -208,24 +212,28 @@ class DicomAnalyzer:
                 zoomed_y = int(y * self.zoom_factor)
                 zoomed_radius = int((diameter/2.0) * self.zoom_factor)
                 
-                cv2.circle(zoomed_bgr,
-                          (zoomed_x, zoomed_y),
-                          zoomed_radius,
-                          self.CIRCLE_COLOR,
-                          1,
-                          lineType=cv2.LINE_AA)
+                cv2.circle(
+                    zoomed_bgr,
+                    (zoomed_x, zoomed_y),
+                    zoomed_radius,
+                    self.CIRCLE_COLOR,
+                    1,
+                    lineType=cv2.LINE_AA
+                )
                 
                 num_points = 8
                 for i in range(num_points):
                     angle = 2 * np.pi * i / num_points
                     point_x = int(zoomed_x + zoomed_radius * np.cos(angle))
                     point_y = int(zoomed_y + zoomed_radius * np.sin(angle))
-                    cv2.circle(zoomed_bgr,
-                              (point_x, point_y),
-                              1,
-                              self.CIRCLE_COLOR,
-                              -1,
-                              lineType=cv2.LINE_AA)
+                    cv2.circle(
+                        zoomed_bgr,
+                        (point_x, point_y),
+                        1,
+                        self.CIRCLE_COLOR,
+                        -1,
+                        lineType=cv2.LINE_AA
+                    )
 
             zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
 
@@ -243,6 +251,7 @@ class DicomAnalyzer:
         except Exception as e:
             print(f"Error updating display: {str(e)}")
             return self.original_display
+
     def analyze_roi(self, evt: gr.SelectData):
         try:
             if self.current_image is None:
@@ -318,7 +327,7 @@ class DicomAnalyzer:
             
             row1, row2 = row_pair
             
-            # SNR Formula for first row with error handling
+            # SNR Formula for the first row with IFERROR
             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}"]
@@ -326,7 +335,7 @@ class DicomAnalyzer:
             cell1.font = red_font
             cell1.alignment = openpyxl.styles.Alignment(horizontal='center')
             
-            # CNR Formula for second row with error handling
+            # CNR Formula for the second row with IFERROR
             formula2 = f"=IFERROR(({base_col}{row1}-{base_col}{row2})/{std_col}{row2},\"\")"
             cell2 = ws[f"{formula_col}{row2}"]
             cell2.value = formula2
@@ -372,8 +381,10 @@ class DicomAnalyzer:
                 (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)']
+            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)
@@ -425,15 +436,15 @@ class DicomAnalyzer:
             stddev_header.alignment = center_alignment
             current_row += 1
             
-            # Calculate StdDev averages for each row pair
+            # 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 only
+                row_number = row_pairs[i][0]  # First row
                 stddev_values = []
                 
                 for cols in column_groups:
                     stddev_col = cols[2]  # StdDev column
                     cell_value = ws[f"{stddev_col}{row_number}"].value
-                    if cell_value not in [0, None, '']:  # Ignore zeros and empty values
+                    if cell_value not in [0, None, '']:  # Ignore zeros and empty
                         stddev_values.append(float(cell_value))
                 
                 if stddev_values:
@@ -454,23 +465,22 @@ class DicomAnalyzer:
             cnr_header.alignment = center_alignment
             current_row += 1
             
-            # Calculate CNR averages for each row pair
+            # 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
+                row_number = row_pairs[i][1]  # second row for CNR
                 valid_cnr_refs = []
                 
-                # Get all CNR cells for this row
+                # Build references only if Mean and StdDev are not all zero
                 for cols in column_groups:
                     formula_col = get_column_letter(column_index_from_string(cols[-1]) + 1)
                     mean_col = cols[1]
                     std_col = cols[2]
                     
-                    # Check values used in CNR calculation
                     mean1 = ws[f"{mean_col}{row_pairs[i][0]}"].value
                     mean2 = ws[f"{mean_col}{row_pairs[i][1]}"].value
                     std2 = ws[f"{std_col}{row_pairs[i][1]}"].value
                     
-                    # Convert values to float if they're strings
+                    # Convert potential string values to float
                     try:
                         mean1 = float(mean1) if mean1 not in [None, ''] else 0
                         mean2 = float(mean2) if mean2 not in [None, ''] else 0
@@ -478,16 +488,14 @@ class DicomAnalyzer:
                     except (ValueError, TypeError):
                         continue
                     
-                    # Only skip if ALL values are zero
+                    # If not all zero, we consider the cell for average
                     if not (mean1 == 0 and mean2 == 0 and std2 == 0):
                         valid_cnr_refs.append(f"{formula_col}{row_number}")
                 
-                # Add row to the averages table
                 size_cell = ws.cell(row=current_row, column=1, value=size)
                 size_cell.alignment = center_alignment
                 
                 if valid_cnr_refs:
-                    # Create array formula for average that handles errors
                     refs = ",".join(valid_cnr_refs)
                     array_formula = f'=IFERROR(AVERAGE(IF(ISNUMBER({refs}),{refs})),"")'
                     
@@ -510,6 +518,7 @@ class DicomAnalyzer:
         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"""
         center_alignment = openpyxl.styles.Alignment(horizontal='center')
@@ -565,6 +574,7 @@ class DicomAnalyzer:
             self.marks.pop()
         return self.update_display(), self.format_results()
 
+
 def create_interface():
     print("Creating interface...")
     analyzer = DicomAnalyzer()
@@ -615,7 +625,7 @@ def create_interface():
         - Use Reset All to clear all measurements
         - Save Formatted Results will create Excel file with formulas
         """)
-        
+
         def update_diameter(x):
             analyzer.circle_diameter = float(x)
             print(f"Diameter updated to: {x}")
@@ -739,4 +749,4 @@ if __name__ == "__main__":
         print(f"Error launching application: {str(e)}")
         logger.error(f"Error launching application: {str(e)}")
         logger.error(traceback.format_exc())
-        raise e
+        raise e