Update app.py

app.py

@@ -62,7 +62,6 @@ class DicomAnalyzer:
         self.max_pan_y = 0
         self.CIRCLE_COLOR = (0, 255, 255)  # BGR Yellow
         print("DicomAnalyzer initialized...")
-
     def reset_all(self, image):
         self.results = []
         self.marks = []
@@ -115,6 +114,7 @@ class DicomAnalyzer:
         except Exception as e:
             print(f"Error normalizing image: {str(e)}")
             return None
+
     def reset_view(self):
         self.zoom_factor = 1.0
         self.pan_x = 0
@@ -152,6 +152,60 @@ class DicomAnalyzer:
             print(f"Error handling keyboard input: {str(e)}")
             return self.display_image
 
+    def update_display(self):
+        try:
+            if self.original_display is None:
+                return None
+
+            height, width = self.original_display.shape[:2]
+            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_bgr = cv2.cvtColor(zoomed, cv2.COLOR_RGB2BGR)
+
+            for x, y, diameter in self.marks:
+                zoomed_x = int(x * self.zoom_factor)
+                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)
+                
+                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)
+
+            zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
+
+            self.max_pan_x = max(0, new_width - width)
+            self.max_pan_y = max(0, new_height - height)
+            self.pan_x = min(max(0, self.pan_x), self.max_pan_x)
+            self.pan_y = min(max(0, self.pan_y), self.max_pan_y)
+
+            visible = zoomed[
+                int(self.pan_y):int(self.pan_y + height),
+                int(self.pan_x):int(self.pan_x + width)
+            ]
+
+            return visible
+        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:
@@ -220,96 +274,6 @@ class DicomAnalyzer:
             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:
-                return None
-
-            height, width = self.original_display.shape[:2]
-            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_bgr = cv2.cvtColor(zoomed, cv2.COLOR_RGB2BGR)
-
-            for x, y, diameter in self.marks:
-                zoomed_x = int(x * self.zoom_factor)
-                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)
-                
-                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)
-
-            zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
-
-            self.max_pan_x = max(0, new_width - width)
-            self.max_pan_y = max(0, new_height - height)
-            self.pan_x = min(max(0, self.pan_x), self.max_pan_x)
-            self.pan_y = min(max(0, self.pan_y), self.max_pan_y)
-
-            visible = zoomed[
-                int(self.pan_y):int(self.pan_y + height),
-                int(self.pan_x):int(self.pan_x + width)
-            ]
-
-            return visible
-        except Exception as e:
-            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
-        """
-        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 add_formulas_to_template(self, ws, row_pair, col_group, red_font):
         try:
             base_col = col_group[1]  # Mean column
@@ -317,16 +281,16 @@ class DicomAnalyzer:
             
             row1, row2 = row_pair
             
-            # SNR Formula for first row
-            formula1 = f"={base_col}{row1}/{std_col}{row1}"
+            # SNR Formula for first row with error handling
+            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}"]
             cell1.value = formula1
             cell1.font = red_font
             cell1.alignment = openpyxl.styles.Alignment(horizontal='center')
             
-            # CNR Formula for second row with zero handling
-            formula2 = f"=IF(OR({std_col}{row2}=0,{base_col}{row1}=0,{base_col}{row2}=0),\"\",({base_col}{row1}-{base_col}{row2})/{std_col}{row2})"
+            # CNR Formula for second row with error handling
+            formula2 = f"=IFERROR(({base_col}{row1}-{base_col}{row2})/{std_col}{row2},\"\")"
             cell2 = ws[f"{formula_col}{row2}"]
             cell2.value = formula2
             cell2.font = red_font
@@ -458,32 +422,42 @@ class DicomAnalyzer:
                 row_number = row_pairs[i][1]  # Second row for CNR
                 valid_cnr_refs = []
                 
+                # Get all CNR cells for this row
                 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 if the values used in CNR calculation are valid
+                    # 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
                     
-                    if (mean1 not in [0, None, ''] and 
-                        mean2 not in [0, None, ''] and 
-                        std2 not in [0, None, '']):
+                    # Convert values to float if they're strings
+                    try:
+                        mean1 = float(mean1) if mean1 not in [None, ''] else 0
+                        mean2 = float(mean2) if mean2 not in [None, ''] else 0
+                        std2 = float(std2) if std2 not in [None, ''] else 0
+                    except (ValueError, TypeError):
+                        continue
+                    
+                    # Only skip if ALL values are zero
+                    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
                 
-                avg_cell = ws.cell(row=current_row, column=2)
                 if valid_cnr_refs:
-                    # Create average formula that ignores blank cells
+                    # Create array formula for average that handles errors
                     refs = ",".join(valid_cnr_refs)
-                    avg_cell.value = f'=AVERAGE(IF(LEN({refs})>0,{refs}))'
+                    array_formula = f'=IFERROR(AVERAGE(IF(ISNUMBER({refs}),{refs})),"")'
+                    
+                    avg_cell = ws.cell(row=current_row, column=2)
+                    avg_cell.value = array_formula
                     avg_cell.number_format = '0.000'
-                avg_cell.alignment = center_alignment
+                    avg_cell.alignment = center_alignment
                 
                 current_row += 1
 
@@ -499,8 +473,6 @@ 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')