Update app.py

app.py

@@ -63,17 +63,13 @@ class DicomAnalyzer:
         self.max_pan_y = 0
         self.CIRCLE_COLOR = (0, 255, 255)  # BGR format
         self.SMALL_CIRCLES_COLOR = (255, 255, 255)  # BGR white
+        
         print("DicomAnalyzer initialized...")
 
-        # If you rely on self.column_groups in your new snippet, define it here:
-        # Adjust the column letters to match how your raw (Mean, StdDev) data are actually laid out.
-        self.column_groups = [
-            # Example: (AreaCol, MeanCol, StdDevCol) if you store area in B, mean in C, std in D, etc.
-            # If you only store mean & std, just treat the first col as a placeholder. 
-            ('B','C','D'),
-        ]
-
     def save_results(self):
+        """
+        Basic method to save raw results to an Excel sheet (one sheet, no formatting).
+        """
         try:
             if not self.results:
                 logger.warning("Attempted to save with no results")
@@ -143,6 +139,9 @@ class DicomAnalyzer:
             return None, f"Error loading DICOM file: {str(e)}"
 
     def normalize_image(self, image):
+        """
+        Normalizes raw pixel data to [0..255], and ensures 3-channel BGR for display.
+        """
         try:
             normalized = cv2.normalize(
                 image, 
@@ -178,6 +177,9 @@ class DicomAnalyzer:
         return self.update_display()
 
     def handle_keyboard(self, key):
+        """
+        Pans the zoomed image with arrow keys.
+        """
         try:
             print(f"Handling key press: {key}")
             pan_amount = int(10 * self.zoom_factor)
@@ -197,6 +199,10 @@ class DicomAnalyzer:
             return self.display_image
 
     def update_display(self):
+        """
+        Returns a version of self.original_display that is zoomed/panned
+        and shows ROI circles. 
+        """
         try:
             if self.original_display is None:
                 return None
@@ -213,12 +219,13 @@ class DicomAnalyzer:
 
             zoomed_bgr = cv2.cvtColor(zoomed, cv2.COLOR_RGB2BGR)
 
+            # Draw circles in the zoomed plane
             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)
                 
-                # Draw the main yellow circle
+                # Draw the main circle in yellow
                 cv2.circle(
                     zoomed_bgr,
                     (zoomed_x, zoomed_y),
@@ -261,6 +268,10 @@ class DicomAnalyzer:
             return self.original_display
 
     def analyze_roi(self, evt: gr.SelectData):
+        """
+        Called when a user clicks on the DICOM image.
+        We create a circular ROI, gather stats, store the results, and draw.
+        """
         try:
             if self.current_image is None:
                 return None, "No image loaded"
@@ -329,80 +340,135 @@ class DicomAnalyzer:
             print(f"Error analyzing ROI: {str(e)}")
             return self.display_image, f"Error analyzing ROI: {str(e)}"
 
-    # -------------------------------------------------------------------
-    # The following two helper methods were in your original code. 
-    # We keep them, in case you still need them. Adjust or remove if needed.
-    # -------------------------------------------------------------------
-    def add_formulas_to_template(self, ws, row_pair, col_group, red_font):
+
+    def format_results(self):
         """
-        Inserts SNR (first row) and CNR (second row) formulas with IFERROR.
+        Returns a simple text version of self.results for the UI.
         """
-        try:
-            base_col = col_group[1]  # Mean column
-            std_col = col_group[2]   # StdDev column
-            
-            row1, row2 = row_pair
-            
-            # 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}"]
-            cell1.value = formula1
-            cell1.font = red_font
-            cell1.alignment = openpyxl.styles.Alignment(horizontal='center')
-            
-            # CNR formula
-            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
-            cell2.alignment = openpyxl.styles.Alignment(horizontal='center')
-            
-            logger.debug(f"Added formulas for rows {row1},{row2} in column {formula_col}")
-        except Exception as e:
-            logger.error(f"Error adding formulas: {str(e)}")
+        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 _write_result_to_cells(self, ws, result, cols, row):
-        center_alignment = openpyxl.styles.Alignment(horizontal='center')
-        
-        value_mapping = {
-            'Area': 'Area (mm²)',
-            'Mean': 'Mean',
-            'StdDev': 'StdDev',
-            'Min': 'Min',
-            'Max': 'Max'
-        }
+    def add_zero_row(self, image):
+        """
+        For testing. Adds a zero row to self.results.
+        """
+        self.results.append({
+            'Area (mm²)': '0.000',
+            'Mean': '0.000',
+            'StdDev': '0.000',
+            'Min': '0.000',
+            'Max': '0.000',
+            'Point': '(0, 0)'
+        })
+        return image, self.format_results()
+
+    def add_two_zero_rows(self, image):
+        """
+        For testing. Adds two zero rows to self.results.
+        """
+        for _ in range(2):
+            self.results.append({
+                'Area (mm²)': '0.000',
+                'Mean': '0.000',
+                'StdDev': '0.000',
+                'Min': '0.000',
+                'Max': '0.000',
+                'Point': '(0, 0)'
+            })
+        return image, self.format_results()
+
+    def undo_last(self, image):
+        """
+        Undoes the last measurement or zero row.
+        If it was a real measurement, remove its circle too.
+        """
+        if not self.results:  
+            return self.update_display(), self.format_results()
+            
+        last_result = self.results[-1]
+        is_measurement = last_result['Point'] != '(0, 0)'
         
-        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
+        self.results.pop()
+        if is_measurement and self.marks:
+            self.marks.pop()
+            
+        return self.update_display(), self.format_results()
 
 
-    # -------------------------------------------------------------------
-    # REPLACEMENT SAVE_FORMATTED_RESULTS (Your updated snippet):
-    # -------------------------------------------------------------------
+    @debug_decorator
     def save_formatted_results(self, output_path):
+        """
+        1) Writes the raw data from self.results into rows (2,3,5,6,8,9,...). 
+        2) Builds the final table at rows 35..45 with merges & red headers, reading
+           from those raw cells to compute AVG MEAN, AVG STDDEV, and AVG CNR.
+        """
         try:
             if not self.results:
                 return None, "No results to save"
 
+            # Create a fresh workbook
             wb = openpyxl.Workbook()
             ws = wb.active
-            
-            # Define styles
+
+            # row_pairs: each pair is (row_for_first_measurement, row_for_second_measurement).
+            # Enough for 10 phantoms (20 measurements).
+            row_pairs = [
+                (2,3), (5,6), (8,9), (11,12), (14,15),
+                (17,18), (20,21), (23,24), (26,27), (29,30)
+            ]
+
+            # We can define the columns for storing data:
+            # For example, B=Area, C=Mean, D=StdDev (Min, Max we skip or store in E,F if you like).
+            # This code snippet only cares about reading from Mean & StdDev eventually.
+            column_groups = [
+                ('B','C','D')  # (Area, Mean, StdDev)
+            ]
+
+            # We'll write up to 2 results in each pair of rows,
+            # then move to the next column group if we have more than 2 results in the same phantom.
+            # For simplicity, we'll assume we only have 1 column group. 
+            # If you had multiple sets of columns, you could do more groups, e.g. ('F','G','H'), etc.
+
+            result_idx = 0
+            pair_idx = 0
+
+            # Step 1: Write the raw data from self.results into these rows/columns.
+            while result_idx < len(self.results) and pair_idx < len(row_pairs):
+                # We'll always write to the same column group here
+                area_col, mean_col, stddev_col = column_groups[0]
+
+                # For each phantom, we expect 2 measurements (row1 = object of interest, row2 = background, etc.)
+                # 1st measurement
+                row1 = row_pairs[pair_idx][0]
+                if result_idx < len(self.results):
+                    r = self.results[result_idx]
+                    self._write_single_result(ws, r, area_col, mean_col, stddev_col, row1)
+                    result_idx += 1
+
+                # 2nd measurement
+                row2 = row_pairs[pair_idx][1]
+                if result_idx < len(self.results):
+                    r = self.results[result_idx]
+                    self._write_single_result(ws, r, area_col, mean_col, stddev_col, row2)
+                    result_idx += 1
+
+                pair_idx += 1
+
+            # Step 2: Build the final merged table at row 35..45.
             red_font = openpyxl.styles.Font(color="FF0000")
             center_alignment = openpyxl.styles.Alignment(horizontal='center', vertical='center')
-            
-            # Start creating the averages table at row 35
+
             start_row = 35
             
             # Write the "1-AVG" header
             ws['C35'] = "1-AVG"
             ws['C35'].alignment = center_alignment
             
-            # Merge cells for headers and add titles
+            # Merge cells for headers and set text
             ws.merge_cells('D35:E35')
             ws.merge_cells('F35:G35')
             ws.merge_cells('H35:I35')
@@ -413,143 +479,118 @@ class DicomAnalyzer:
                 'H35': 'AVG CNR'
             }
             
-            for cell, value in headers.items():
-                ws[cell] = value
-                ws[cell].alignment = center_alignment
-                ws[cell].font = red_font
-            
-            # Add phantom sizes in red
+            for cell_ref, hdr_text in headers.items():
+                ws[cell_ref] = hdr_text
+                ws[cell_ref].alignment = center_alignment
+                ws[cell_ref].font = red_font
+
+            # Phantom sizes in red
             phantom_sizes = [
                 '(7.0mm)', '(6.5mm)', '(6.0mm)', '(5.5mm)', '(5.0mm)',
                 '(4.5mm)', '(4.0mm)', '(3.5mm)', '(3.0mm)', '(2.5mm)'
             ]
             
-            for i, size in enumerate(phantom_sizes):
-                row = start_row + i + 1  # Start from row 36
-                
-                # Merge cells for each row
+            for i, size_label in enumerate(phantom_sizes):
+                row = start_row + i + 1  # 36..45
+
+                # Merge the 3 sets of columns for each row
                 ws.merge_cells(f'D{row}:E{row}')
                 ws.merge_cells(f'F{row}:G{row}')
                 ws.merge_cells(f'H{row}:I{row}')
-                
-                cell = ws[f'C{row}']
-                cell.value = size
-                cell.font = red_font
-                cell.alignment = center_alignment
-                
-                # Calculate averages as before
-                mean_values = []
-                stddev_values = []
-                cnr_values = []
-                
-                # For example, row_pair = (2 + i*3, 3 + i*3).
-                row_pair = (2 + i * 3, 3 + i * 3)
-                
-                for cols in self.column_groups:
-                    mean_col = cols[1]
-                    stddev_col = cols[2]
-                    
-                    mean1_val = ws[f"{mean_col}{row_pair[0]}"].value
-                    mean2_val = ws[f"{mean_col}{row_pair[1]}"].value
-                    stddev2_val = ws[f"{stddev_col}{row_pair[1]}"].value
-                    
-                    try:
-                        mean1_val = float(mean1_val) if mean1_val not in [None, ''] else None
-                        mean2_val = float(mean2_val) if mean2_val not in [None, ''] else None
-                        stddev2_val = float(stddev2_val) if stddev2_val not in [None, ''] else None
-                        
-                        if all(v is not None for v in [mean1_val, mean2_val, stddev2_val]):
-                            mean_values.append(mean1_val)
-                            stddev_values.append(stddev2_val)
-                            cnr_values.append((mean1_val - mean2_val) / stddev2_val)
-                    except (ValueError, TypeError):
-                        continue
-                
-                # Write averages to merged cells
-                if mean_values:
-                    ws[f'D{row}'].value = sum(mean_values) / len(mean_values)
+
+                c_cell = ws[f'C{row}']
+                c_cell.value = size_label
+                c_cell.font = red_font
+                c_cell.alignment = center_alignment
+
+                # We'll read from the row_pairs above: row_pair = (2 + i*3, 3 + i*3) 
+                # But we can actually just use the same row_pairs we used above. 
+                # Because we have 10 items in phantom_sizes, each corresponding to row_pairs[i].
+                # We'll do that directly:
+                if i < len(row_pairs):
+                    (raw_row1, raw_row2) = row_pairs[i]
+                else:
+                    # If we have fewer row_pairs than phantom sizes, skip
+                    continue
+
+                # Let's read from the single column group for Mean & StdDev
+                # If you have multiple column groups, you can loop them. For now we use just one:
+                (area_col, mean_col, stddev_col) = column_groups[0]
+
+                # Fetch the data from the sheet:
+                mean1_val = ws[f"{mean_col}{raw_row1}"].value
+                mean2_val = ws[f"{mean_col}{raw_row2}"].value
+                stddev2_val = ws[f"{stddev_col}{raw_row2}"].value
+
+                # Convert them to float or None
+                try:
+                    mean1_val   = float(mean1_val)   if mean1_val   not in [None, ''] else None
+                    mean2_val   = float(mean2_val)   if mean2_val   not in [None, ''] else None
+                    stddev2_val = float(stddev2_val) if stddev2_val not in [None, ''] else None
+                except:
+                    mean1_val, mean2_val, stddev2_val = None, None, None
+
+                # Calculate 
+                if (mean1_val is not None) and (mean2_val is not None) and (stddev2_val is not None) and (stddev2_val != 0):
+                    avg_mean = mean1_val  # or an average of multiple if you want
+                    avg_std  = stddev2_val
+                    cnr      = (mean1_val - mean2_val)/ stddev2_val
+                else:
+                    avg_mean, avg_std, cnr = None, None, None
+
+                # Place the results in the merged cells:
+                if avg_mean is not None:
+                    ws[f'D{row}'].value = avg_mean
                     ws[f'D{row}'].alignment = center_alignment
                     ws[f'D{row}'].number_format = '0.0000'
                 
-                if stddev_values:
-                    ws[f'F{row}'].value = sum(stddev_values) / len(stddev_values)
+                if avg_std is not None:
+                    ws[f'F{row}'].value = avg_std
                     ws[f'F{row}'].alignment = center_alignment
                     ws[f'F{row}'].number_format = '0.0000'
                 
-                if cnr_values:
-                    ws[f'H{row}'].value = sum(cnr_values) / len(cnr_values)
+                if cnr is not None:
+                    ws[f'H{row}'].value = cnr
                     ws[f'H{row}'].alignment = center_alignment
                     ws[f'H{row}'].number_format = '0.0000'
+
+            # Add borders around the block C35..I45
+            thin_side = openpyxl.styles.Side(style='thin')
+            border = openpyxl.styles.Border(left=thin_side, right=thin_side, top=thin_side, bottom=thin_side)
             
-            # Add borders to the table including merged cells
-            border = openpyxl.styles.Border(
-                left=openpyxl.styles.Side(style='thin'),
-                right=openpyxl.styles.Side(style='thin'),
-                top=openpyxl.styles.Side(style='thin'),
-                bottom=openpyxl.styles.Side(style='thin')
-            )
-            
-            for row in range(35, 46):  # From row 35 to 45
-                for col in ['C', 'D', 'E', 'F', 'G', 'H', 'I']:
-                    ws[f'{col}{row}'].border = border
-            
-            # Save the workbook
+            for r in range(35, 46):
+                for c in ['C','D','E','F','G','H','I']:
+                    ws[f'{c}{r}'].border = border
+
             wb.save(output_path)
-            return output_path, "Results saved successfully with formatted averages table"
-            
+            return output_path, "Results saved successfully with formatted table"
         except Exception as e:
             logger.error(f"Error saving formatted results: {str(e)}")
+            logger.error(traceback.format_exc())
             return None, f"Error saving results: {str(e)}"
 
-
-    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_zero_row(self, image):
-        self.results.append({
-            'Area (mm²)': '0.000',
-            'Mean': '0.000',
-            'StdDev': '0.000',
-            'Min': '0.000',
-            'Max': '0.000',
-            'Point': '(0, 0)'
-        })
-        return image, self.format_results()
-
-    def add_two_zero_rows(self, image):
-        for _ in range(2):
-            self.results.append({
-                'Area (mm²)': '0.000',
-                'Mean': '0.000',
-                'StdDev': '0.000',
-                'Min': '0.000',
-                'Max': '0.000',
-                'Point': '(0, 0)'
-            })
-        return image, self.format_results()
-
-    def undo_last(self, image):
-        if not self.results:  # لو مفيش نتائج أصلاً
-            return self.update_display(), self.format_results()
-            
-        last_result = self.results[-1]
-        # نتحقق إذا كان آخر إجراء قياس حقيقي أم صف صفري
-        is_measurement = last_result['Point'] != '(0, 0)'
+    def _write_single_result(self, ws, result, area_col, mean_col, stddev_col, row):
+        """
+        Helper to write one measurement to a given row in columns for Area, Mean, StdDev, etc.
+        """
+        # Convert text to float if possible
+        def as_float(v):
+            try:
+                return float(v)
+            except:
+                return None
         
-        # نمسح آخر نتيجة
-        self.results.pop()
+        area_val   = as_float(result.get('Area (mm²)', None))
+        mean_val   = as_float(result.get('Mean', None))
+        stddev_val = as_float(result.get('StdDev', None))
+        
+        if area_val is not None:
+            ws[f"{area_col}{row}"].value = area_val
+        if mean_val is not None:
+            ws[f"{mean_col}{row}"].value = mean_val
+        if stddev_val is not None:
+            ws[f"{stddev_col}{row}"].value = stddev_val
         
-        # لو كان قياس حقيقي، نمسح العلامة المقابلة له
-        if is_measurement and self.marks:
-            self.marks.pop()
-            
-        return self.update_display(), self.format_results()
-
 
 def create_interface():
     print("Creating interface...")
@@ -688,6 +729,7 @@ def create_interface():
             outputs=[file_output, results_display]
         )
 
+        # Capture arrow keys for panning
         js = """
         <script>
         document.addEventListener('keydown', function(e) {