Update app.py

app.py

@@ -61,14 +61,13 @@ class DicomAnalyzer:
         self.pan_y = 0
         self.max_pan_x = 0
         self.max_pan_y = 0
-        self.CIRCLE_COLOR = (0, 255, 255)  # BGR format
-        self.SMALL_CIRCLES_COLOR = (255, 255, 255)  # BGR white
+        self.CIRCLE_COLOR = (0, 255, 255)  # BGR
+        self.SMALL_CIRCLES_COLOR = (255, 255, 255)  # BGR
         print("DicomAnalyzer initialized...")
 
     def save_results(self):
         try:
             if not self.results:
-                logger.warning("Attempted to save with no results")
                 return None, "No results to save"
 
             df = pd.DataFrame(self.results)
@@ -160,20 +159,16 @@ class DicomAnalyzer:
         return None
 
     def zoom_in(self, image):
-        print("Zooming in...")
         self.zoom_factor = min(20.0, self.zoom_factor + 0.5)
         return self.update_display()
 
     def zoom_out(self, image):
-        print("Zooming out...")
         self.zoom_factor = max(1.0, self.zoom_factor - 0.5)
         return self.update_display()
 
     def handle_keyboard(self, key):
         try:
-            print(f"Handling key press: {key}")
             pan_amount = int(10 * self.zoom_factor)
-            
             if key == 'ArrowLeft':
                 self.pan_x = max(0, self.pan_x - pan_amount)
             elif key == 'ArrowRight':
@@ -185,7 +180,6 @@ class DicomAnalyzer:
             
             return self.update_display()
         except Exception as e:
-            print(f"Error handling keyboard input: {str(e)}")
             return self.display_image
 
     def update_display(self):
@@ -205,35 +199,21 @@ class DicomAnalyzer:
 
             zoomed_bgr = cv2.cvtColor(zoomed, cv2.COLOR_RGB2BGR)
 
+            # Draw circles
             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
-                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)
                 
-                # Draw 8 small white circles around
+                # 8 small circles
                 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.SMALL_CIRCLES_COLOR,
-                        -1,
-                        lineType=cv2.LINE_AA
-                    )
+                    cv2.circle(zoomed_bgr, (point_x, point_y), 1, self.SMALL_CIRCLES_COLOR, -1, lineType=cv2.LINE_AA)
 
             zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
 
@@ -249,7 +229,6 @@ class DicomAnalyzer:
 
             return visible
         except Exception as e:
-            print(f"Error updating display: {str(e)}")
             return self.original_display
 
     def analyze_roi(self, evt: gr.SelectData):
@@ -277,7 +256,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
@@ -288,8 +267,7 @@ class DicomAnalyzer:
                 return self.display_image, "Error: No pixels selected"
 
             pixel_spacing = float(self.dicom_data.PixelSpacing[0])
-            n_pixels = np.sum(mask)
-            area = n_pixels * (pixel_spacing ** 2)
+            area = np.sum(mask) * (pixel_spacing ** 2)
             
             mean_value = np.mean(roi_pixels)
             std_dev = np.std(roi_pixels, ddof=1)
@@ -318,47 +296,40 @@ class DicomAnalyzer:
 
             return self.update_display(), self.format_results()
         except Exception as e:
-            print(f"Error analyzing ROI: {str(e)}")
             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.
-        """
+        """Inserts SNR (row1) and CNR (row2) in the next column after col_group."""
         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)
+            
+            # SNR in row1
+            formula1 = f"=IFERROR({base_col}{row1}/{std_col}{row1},\"\")"
             cell1 = ws[f"{formula_col}{row1}"]
             cell1.value = formula1
             cell1.font = red_font
             cell1.alignment = openpyxl.styles.Alignment(horizontal='center')
             
-            # CNR formula
+            # CNR in row2
             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)}")
 
-    ########################################################################
-    # نفس الدالة الأصلية، لكن نهاية الدالة تضع الجدول في الصف 35 بالشكل المطلوب
-    ########################################################################
     def save_formatted_results(self, output_path):
         try:
             if not self.results:
                 return None, "No results to save"
 
-            # هنا كل شيء مثل كودك: تنشئ Workbook جديد، تصنع الشيت، تضع الهيدرز...
             wb = openpyxl.Workbook()
             ws = wb.active
             red_font = openpyxl.styles.Font(color="FF0000")
@@ -375,12 +346,14 @@ class DicomAnalyzer:
                 ('BV', 'BW', 'BX', 'BY', 'BZ')
             ]
             
+            # Write main headers (Area,Mean,StdDev,Min,Max)
             for cols in column_groups:
                 for i, header in enumerate(headers):
                     cell = ws[f"{cols[i]}1"]
                     cell.value = header
                     cell.alignment = center_alignment
 
+            # Each pair for phantom
             row_pairs = [
                 (2, 3), (5, 6), (8, 9), (11, 12), (14, 15),
                 (17, 18), (20, 21), (23, 24), (26, 27), (29, 30)
@@ -391,13 +364,13 @@ class DicomAnalyzer:
                 '(4.5mm)', '(4mm)', '(3.5mm)', '(3mm)', '(2.5mm)'
             ]
             
-            # كتابة أسماء الفانتوم باللون الأحمر في العمود A (قبل الصف الأول)
+            # Label each phantom in column A
             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
+                label_row = row_pairs[i][0] - 1
+                ws.cell(row=label_row, column=1, value=size).font = red_font
+                ws.cell(row=label_row, column=1).alignment = center_alignment
 
-            # توزيع نتائج ROI في هذه الصفوف والأعمدة كما في كودك
+            # Fill raw ROI data + formulas
             result_idx = 0
             current_col_group = 0
             current_row_pair = 0
@@ -407,51 +380,41 @@ class DicomAnalyzer:
                     break
                     
                 cols = column_groups[current_col_group]
-                rows = row_pairs[current_row_pair]
+                row1, row2 = row_pairs[current_row_pair]
                 
                 if result_idx < len(self.results):
-                    result = self.results[result_idx]
-                    self._write_result_to_cells(ws, result, cols, rows[0])
+                    self._write_result_to_cells(ws, self.results[result_idx], cols, row1)
                     result_idx += 1
                 
                 if result_idx < len(self.results):
-                    result = self.results[result_idx]
-                    self._write_result_to_cells(ws, result, cols, rows[1])
+                    self._write_result_to_cells(ws, self.results[result_idx], cols, row2)
                     result_idx += 1
                 
-                self.add_formulas_to_template(ws, rows, cols, red_font)
+                self.add_formulas_to_template(ws, (row1,row2), cols, red_font)
                 
                 current_col_group += 1
                 if current_col_group >= len(column_groups):
                     current_col_group = 0
                     current_row_pair += 1
 
-            # ضبط المحاذاة للخلايا التي كُتبت بالفعل
+            # Center alignment for the raw data
             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:
+                        if cell.value not in [None, '']:
                             cell.alignment = center_alignment
 
-            ################################################################
-            # وهنا بدلًا من وضع جداول STDDEV/Mean/CNR منفصلة،
-            # نضع الجدول المدمج "1-AVG" من الصف 35 مثل الصورة التي أرسلتها
-            ################################################################
-            
-            # سنستخدم نفس فكرة الجدول بالدمج من D35:E35, F35:G35, H35:I35
+            # Now the 1-AVG table from row35..45
             start_row = 35
-            
-            # ضع عنوان "1-AVG" في C35
             ws['C35'] = "1-AVG"
             ws['C35'].alignment = center_alignment
             
-            # ادمج الخلايا الخاصة بالعناوين
+            # Merge headers
             ws.merge_cells('D35:E35')
             ws.merge_cells('F35:G35')
             ws.merge_cells('H35:I35')
             
-            # ضع العناوين باللون الأحمر
             avg_headers = {
                 'D35': 'AVG MEAN',
                 'F35': 'AVG STDDEV',
@@ -462,7 +425,7 @@ class DicomAnalyzer:
                 ws[c_ref].font = red_font
                 ws[c_ref].alignment = center_alignment
             
-            # نفس أسماء الفانتوم
+            # Phantom sizes in 1-AVG
             phantom_sizes2 = [
                 '(7.0mm)', '(6.5mm)', '(6.0mm)', '(5.5mm)', '(5.0mm)',
                 '(4.5mm)', '(4.0mm)', '(3.5mm)', '(3.0mm)', '(2.5mm)'
@@ -470,73 +433,58 @@ class DicomAnalyzer:
             
             for i, p_size in enumerate(phantom_sizes2):
                 row = start_row + i + 1  # 36..45
-                
-                # ادمج لكل صف: D-E ، F-G ، H-I
                 ws.merge_cells(f'D{row}:E{row}')
                 ws.merge_cells(f'F{row}:G{row}')
                 ws.merge_cells(f'H{row}:I{row}')
                 
-                # اكتب اسم الفانتوم باللون الأحمر في العمود C
-                size_cell = ws[f'C{row}']
-                size_cell.value = p_size
-                size_cell.font = red_font
-                size_cell.alignment = center_alignment
-
-                # لكي نحسب الـAVG الحقيقي من الصفوف 2..3 إلخ،
-                # نستخدم row_pairs[i] إن أردت. أو كما في المثال الأصلي:
-                if i < len(row_pairs):
-                    (raw_row1, raw_row2) = row_pairs[i]
-                else:
-                    continue  # لو عندك 10 فقط
-                
-                # لنفترض أننا نقرأ من نفس الأعمدة اللي فيها mean & std
-                # نفترض عندنا على الأقل عمود mean_col = cols[1], stddev_col = cols[2]
-                # لكن عندك عدة col groups؛ إذا تريد تجمع من الأول فقط:
-                # أو خذ فكرة snippetك السابق:
+                c_cell = ws[f'C{row}']
+                c_cell.value = p_size
+                c_cell.font = red_font
+                c_cell.alignment = center_alignment
+
+                if i >= len(row_pairs):
+                    continue
+                (raw_row1, raw_row2) = row_pairs[i]
                 
                 mean_values = []
                 stddev_values = []
                 cnr_values = []
                 
-                # Example: لو تحب تجمع من نفس الـ column_groups الأولى بس
+                # Read from the same column groups
                 for group in column_groups:
-                    mean_col = group[1]  # 'C','I','O'...الخ
-                    std_col  = group[2]  # 'D','J','P'...الخ
+                    mean_col = group[1]  # e.g. 'C'
+                    std_col  = group[2]  # e.g. 'D'
+                    
+                    # read mean from row1 if you want
+                    val_mean = ws[f"{mean_col}{raw_row1}"].value
+                    # read std from row1 or row2 if you want
+                    val_std  = ws[f"{std_col}{raw_row1}"].value
                     
-                    # raw_row1 = الصف الأول
-                    # raw_row2 = الصف الثاني
-                    m1 = ws[f"{mean_col}{raw_row1}"].value
-                    m2 = ws[f"{mean_col}{raw_row2}"].value
-                    std2 = ws[f"{std_col}{raw_row1}"].value
+                    # Read the actual CNR formula cell from row2 
+                    formula_col = get_column_letter(column_index_from_string(group[-1]) + 1)
+                    val_cnr = ws[f"{formula_col}{raw_row2}"].value
                     
+                    # Convert to float if possible
                     try:
-                        m1   = float(m1)   if m1   not in [None,''] else None
-                        m2   = float(m2)   if m2   not in [None,''] else None
-                        std2 = float(std2) if std2 not in [None,''] else None
+                        val_mean = float(val_mean) if val_mean not in [None, ''] else None
+                        val_std  = float(val_std)  if val_std  not in [None, ''] else None
+                        val_cnr  = float(val_cnr)  if val_cnr  not in [None, ''] else None
                     except:
-                        m1,m2,std2 = None,None,None
-                    if (m1 is not None) and (m2 is not None) and (std2 is not None) and (std2!=0):
-                        mean_values.append(m1)
-                        stddev_values.append(std2)
-                        cnr_values.append((m1 - m2)/std2)
-                
-                # الآن نحسب المتوسط
-                if len(mean_values) > 0:
-                    final_mean = sum(mean_values)/len(mean_values)
-                else:
-                    final_mean = None
-                
-                if len(stddev_values) > 0:
-                    final_std = sum(stddev_values)/len(stddev_values)
-                else:
-                    final_std = None
-                
-                if len(cnr_values) > 0:
-                    final_cnr = sum(cnr_values)/len(cnr_values)
-                else:
-                    final_cnr = None
+                        val_mean,val_std,val_cnr = None,None,None
+                    
+                    if val_mean is not None:
+                        mean_values.append(val_mean)
+                    if val_std is not None:
+                        stddev_values.append(val_std)
+                    if val_cnr is not None:
+                        cnr_values.append(val_cnr)
                 
-                # نكتبها في الخلايا المدمجة
+                # compute final averages
+                final_mean = sum(mean_values)/len(mean_values) if mean_values else None
+                final_std  = sum(stddev_values)/len(stddev_values) if stddev_values else None
+                final_cnr  = sum(cnr_values)/len(cnr_values) if cnr_values else None
+
+                # place them
                 if final_mean is not None:
                     ws[f'D{row}'].value = final_mean
                     ws[f'D{row}'].alignment = center_alignment
@@ -552,7 +500,7 @@ class DicomAnalyzer:
                     ws[f'H{row}'].alignment = center_alignment
                     ws[f'H{row}'].number_format = '0.0000'
 
-            # أخيراً، ضع الحدود حول C35..I45
+            # Put borders
             thin_side = openpyxl.styles.Side(style='thin')
             border = openpyxl.styles.Border(
                 left=thin_side, right=thin_side, top=thin_side, bottom=thin_side
@@ -566,11 +514,9 @@ 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):
         center_alignment = openpyxl.styles.Alignment(horizontal='center')
-        
         value_mapping = {
             'Area': 'Area (mm²)',
             'Mean': 'Mean',
@@ -578,7 +524,6 @@ class DicomAnalyzer:
             'Min': 'Min',
             'Max': 'Max'
         }
-        
         for i, (header, key) in enumerate(value_mapping.items()):
             cell = ws[f"{cols[i]}{row}"]
             val = result[key]
@@ -617,25 +562,17 @@ class DicomAnalyzer:
         return image, self.format_results()
 
     def undo_last(self, image):
-        if not self.results:  # لو مفيش نتائج أصلاً
+        if not self.results:
             return self.update_display(), self.format_results()
-            
         last_result = self.results[-1]
-        # نتحقق إذا كان آخر إجراء قياس حقيقي أم صف صفري
-        is_measurement = last_result['Point'] != '(0, 0)'
-        
-        # نمسح آخر نتيجة
+        is_measurement = (last_result['Point'] != '(0, 0)')
         self.results.pop()
-        
-        # لو كان قياس حقيقي، نمسح العلامة المقابلة له
         if is_measurement and self.marks:
             self.marks.pop()
-            
         return self.update_display(), self.format_results()
 
 
 def create_interface():
-    print("Creating interface...")
     analyzer = DicomAnalyzer()
     
     with gr.Blocks(css="#image_display { outline: none; }") as interface:
@@ -644,13 +581,7 @@ def create_interface():
         with gr.Row():
             with gr.Column():
                 file_input = gr.File(label="Upload DICOM file")
-                diameter_slider = gr.Slider(
-                    minimum=1,
-                    maximum=20,
-                    value=9,
-                    step=1,
-                    label="ROI Diameter (pixels)"
-                )
+                diameter_slider = gr.Slider(1, 20, 9, 1, label="ROI Diameter (pixels)")
                 
                 with gr.Row():
                     zoom_in_btn = gr.Button("Zoom In (+)")
@@ -659,11 +590,7 @@ def create_interface():
                     reset_all_btn = gr.Button("Reset All")
                 
             with gr.Column():
-                image_display = gr.Image(
-                    label="DICOM Image",
-                    interactive=True,
-                    elem_id="image_display"
-                )
+                image_display = gr.Image(label="DICOM Image", interactive=True, elem_id="image_display")
                 
         with gr.Row():
             zero_btn = gr.Button("Add Zero Row")
@@ -678,111 +605,51 @@ def create_interface():
         
         gr.Markdown("""
         ### Controls:
-        - Use arrow keys to pan when zoomed in. Movement is now larger.
+        - Arrow keys to pan when zoomed in.
         - 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 & the 1-AVG table.
+        - Zoom In/Out, Reset, etc.
+        - "Save Results": raw data
+        - "Save Formatted Results": advanced table
         """)
 
         def update_diameter(x):
             analyzer.circle_diameter = float(x)
-            print(f"Diameter updated to: {x}")
             return f"Diameter set to {x} pixels"
 
         def save_formatted():
-            output_path = "analysis_results_formatted.xlsx"
-            return analyzer.save_formatted_results(output_path)
-
-        file_input.change(
-            fn=analyzer.load_dicom,
-            inputs=file_input,
-            outputs=[image_display, results_display]
-        )
-        
-        image_display.select(
-            fn=analyzer.analyze_roi,
-            outputs=[image_display, results_display]
-        )
-        
-        diameter_slider.change(
-            fn=update_diameter,
-            inputs=diameter_slider,
-            outputs=gr.Textbox(label="Status")
-        )
-        
-        zoom_in_btn.click(
-            fn=analyzer.zoom_in,
-            inputs=image_display,
-            outputs=image_display,
-            queue=False
-        )
-        
-        zoom_out_btn.click(
-            fn=analyzer.zoom_out,
-            inputs=image_display,
-            outputs=image_display,
-            queue=False
-        )
-        
-        reset_btn.click(
-            fn=analyzer.reset_view,
-            outputs=image_display
-        )
-        
-        reset_all_btn.click(
-            fn=analyzer.reset_all,
-            inputs=image_display,
-            outputs=[image_display, results_display]
-        )
+            return analyzer.save_formatted_results("analysis_results_formatted.xlsx")
+
+        file_input.change(fn=analyzer.load_dicom, inputs=file_input, outputs=[image_display, results_display])
+        image_display.select(fn=analyzer.analyze_roi, outputs=[image_display, results_display])
+        diameter_slider.change(fn=update_diameter, inputs=diameter_slider, outputs=gr.Textbox(label="Status"))
         
-        key_press.change(
-            fn=analyzer.handle_keyboard,
-            inputs=key_press,
-            outputs=image_display
-        )
+        zoom_in_btn.click(fn=analyzer.zoom_in, inputs=image_display, outputs=image_display, queue=False)
+        zoom_out_btn.click(fn=analyzer.zoom_out, inputs=image_display, outputs=image_display, queue=False)
+        reset_btn.click(fn=analyzer.reset_view, outputs=image_display)
+        reset_all_btn.click(fn=analyzer.reset_all, inputs=image_display, outputs=[image_display, results_display])
         
-        zero_btn.click(
-            fn=analyzer.add_zero_row,
-            inputs=image_display,
-            outputs=[image_display, results_display]
-        )
+        key_press.change(fn=analyzer.handle_keyboard, inputs=key_press, outputs=image_display)
         
-        zero2_btn.click(
-            fn=analyzer.add_two_zero_rows,
-            inputs=image_display,
-            outputs=[image_display, results_display]
-        )
-
-        undo_btn.click(
-            fn=analyzer.undo_last,
-            inputs=image_display,
-            outputs=[image_display, results_display]
-        )
+        zero_btn.click(fn=analyzer.add_zero_row, inputs=image_display, outputs=[image_display, results_display])
+        zero2_btn.click(fn=analyzer.add_two_zero_rows, inputs=image_display, outputs=[image_display, results_display])
+        undo_btn.click(fn=analyzer.undo_last, inputs=image_display, outputs=[image_display, results_display])
         
-        save_btn.click(
-            fn=analyzer.save_results,
-            outputs=[file_output, results_display]
-        )
-
-        save_formatted_btn.click(
-            fn=save_formatted,
-            outputs=[file_output, results_display]
-        )
+        save_btn.click(fn=analyzer.save_results, outputs=[file_output, results_display])
+        save_formatted_btn.click(fn=save_formatted, outputs=[file_output, results_display])
 
+        # JS to capture arrow keys
         js = """
         <script>
         document.addEventListener('keydown', function(e) {
-            if (['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(e.key)) {
+            if (['ArrowUp','ArrowDown','ArrowLeft','ArrowRight'].includes(e.key)) {
                 e.preventDefault();
-                const keyPressElement = document.querySelector('#key_press textarea');
-                if (keyPressElement) {
-                    keyPressElement.value = e.key;
-                    keyPressElement.dispatchEvent(new Event('input'));
+                const el = document.querySelector('#key_press textarea');
+                if (el) {
+                    el.value = e.key;
+                    el.dispatchEvent(new Event('input'));
                     setTimeout(() => {
-                      keyPressElement.value = '';
-                      keyPressElement.dispatchEvent(new Event('input'));
+                      el.value = '';
+                      el.dispatchEvent(new Event('input'));
                     }, 100);
                 }
             }
@@ -791,26 +658,16 @@ def create_interface():
         """
         gr.HTML(js)
     
-    print("Interface created successfully")
     return interface
 
 
 if __name__ == "__main__":
     try:
-        print("Starting application...")
         interface = create_interface()
-        print("Launching interface...")
         interface.queue()
-        interface.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=True,
-            debug=True,
-            show_error=True,
-            quiet=False
-        )
+        interface.launch(server_name="0.0.0.0", server_port=7860, share=True,
+                         debug=True, show_error=True, quiet=False)
     except Exception as e:
-        print(f"Error launching application: {str(e)}")
         logger.error(f"Error launching application: {str(e)}")
         logger.error(traceback.format_exc())
         raise e