Update app.py

app.py

@@ -115,6 +115,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
@@ -229,8 +230,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)
 
@@ -239,24 +243,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)
 
@@ -310,6 +318,7 @@ class DicomAnalyzer:
             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
@@ -326,7 +335,10 @@ class DicomAnalyzer:
             cell1.alignment = openpyxl.styles.Alignment(horizontal='center')
             
             # CNR Formula for second row
-            formula2 = f"=IF(OR({std_col}{row2}=0,{base_col}{row1}=0,{base_col}{row2}=0),0,({base_col}{row1}-{base_col}{row2})/{std_col}{row2})"
+            formula2 = (
+                f"=IF(OR({std_col}{row2}=0,{base_col}{row1}=0,{base_col}{row2}=0),"
+                f"0,({base_col}{row1}-{base_col}{row2})/{std_col}{row2})"
+            )
             cell2 = ws[f"{formula_col}{row2}"]
             cell2.value = formula2
             cell2.font = red_font
@@ -371,8 +383,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)
@@ -424,15 +438,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 (first 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:
@@ -453,7 +467,7 @@ 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
                 cnr_references = []
@@ -501,238 +515,234 @@ class DicomAnalyzer:
             logger.error(f"Error saving formatted results: {str(e)}")
             return None, f"Error saving results: {str(e)}"
 
-        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')
         
-            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')
+        # Map the headers to the result keys
+        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}"]
+            cell.value = float(result[key])
+            cell.alignment = center_alignment
+
+    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_blank_row(self, image):
+        self.results.append({
+            'Area (mm²)': '',
+            'Mean': '',
+            'StdDev': '',
+            'Min': '',
+            'Max': '',
+            'Point': ''
+        })
+        return image, self.format_results()
+
+    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 undo_last(self, image):
+        if self.results:
+            self.results.pop()
+        if self.marks:
+            self.marks.pop()
+        return self.update_display(), self.format_results()
+
+# Interface Creation and Main Execution
+def create_interface():
+    print("Creating interface...")
+    analyzer = DicomAnalyzer()
+    
+    with gr.Blocks(css="#image_display { outline: none; }") as interface:
+        gr.Markdown("# DICOM Image Analyzer")
+        
+        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)"
+                )
                 
-                # Map the headers to the result keys
-                value_mapping = {
-                    'Area': 'Area (mm²)',
-                    'Mean': 'Mean',
-                    'StdDev': 'StdDev',
-                    'Min': 'Min',
-                    'Max': 'Max'
-                }
+                with gr.Row():
+                    zoom_in_btn = gr.Button("Zoom In (+)")
+                    zoom_out_btn = gr.Button("Zoom Out (-)")
+                    reset_btn = gr.Button("Reset View")
+                    reset_all_btn = gr.Button("Reset All")
                 
-                for i, (header, key) in enumerate(value_mapping.items()):
-                    cell = ws[f"{cols[i]}{row}"]
-                    cell.value = float(result[key])
-                    cell.alignment = center_alignment
+            with gr.Column():
+                image_display = gr.Image(
+                    label="DICOM Image",
+                    interactive=True,
+                    elem_id="image_display"
+                )
+                
+        with gr.Row():
+            blank_btn = gr.Button("Add Blank Row")
+            zero_btn = gr.Button("Add Zero Row")
+            undo_btn = gr.Button("Undo Last")
+            save_btn = gr.Button("Save Results")
+            save_formatted_btn = gr.Button("Save Formatted Results")
+            
+        results_display = gr.Textbox(label="Results", interactive=False)
+        file_output = gr.File(label="Download Results")
+        key_press = gr.Textbox(visible=False, elem_id="key_press")
         
-            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)
+        gr.Markdown("""
+        ### Controls:
+        - Use arrow keys to pan when zoomed in
+        - Click points to measure
+        - Use Zoom In/Out buttons or Reset View to adjust zoom level
+        - 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}")
+            return f"Diameter set to {x} pixels"
+
+        def save_formatted():
+            output_path = "analysis_results_formatted.xlsx"
+            return analyzer.save_formatted_results(output_path)
         
-            def add_blank_row(self, image):
-                self.results.append({
-                    'Area (mm²)': '',
-                    'Mean': '',
-                    'StdDev': '',
-                    'Min': '',
-                    'Max': '',
-                    'Point': ''
-                })
-                return image, self.format_results()
+        # Event handlers
+        file_input.change(
+            fn=analyzer.load_dicom,
+            inputs=file_input,
+            outputs=[image_display, results_display]
+        )
         
-            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()
+        image_display.select(
+            fn=analyzer.analyze_roi,
+            outputs=[image_display, results_display]
+        )
         
-            def undo_last(self, image):
-                if self.results:
-                    self.results.pop()
-                if self.marks:
-                    self.marks.pop()
-                return self.update_display(), self.format_results()
+        diameter_slider.change(
+            fn=update_diameter,
+            inputs=diameter_slider,
+            outputs=gr.Textbox(label="Status")
+        )
         
-        # Interface Creation and Main Execution
-        def create_interface():
-            print("Creating interface...")
-            analyzer = DicomAnalyzer()
-            
-            with gr.Blocks(css="#image_display { outline: none; }") as interface:
-                gr.Markdown("# DICOM Image Analyzer")
-                
-                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)"
-                        )
-                        
-                        with gr.Row():
-                            zoom_in_btn = gr.Button("Zoom In (+)")
-                            zoom_out_btn = gr.Button("Zoom Out (-)")
-                            reset_btn = gr.Button("Reset View")
-                            reset_all_btn = gr.Button("Reset All")
-                        
-                    with gr.Column():
-                        image_display = gr.Image(
-                            label="DICOM Image",
-                            interactive=True,
-                            elem_id="image_display"
-                        )
-                        
-                with gr.Row():
-                    blank_btn = gr.Button("Add Blank Row")
-                    zero_btn = gr.Button("Add Zero Row")
-                    undo_btn = gr.Button("Undo Last")
-                    save_btn = gr.Button("Save Results")
-                    save_formatted_btn = gr.Button("Save Formatted Results")
-                    
-                results_display = gr.Textbox(label="Results", interactive=False)
-                file_output = gr.File(label="Download Results")
-                key_press = gr.Textbox(visible=False, elem_id="key_press")
-                
-                gr.Markdown("""
-                ### Controls:
-                - Use arrow keys to pan when zoomed in
-                - Click points to measure
-                - Use Zoom In/Out buttons or Reset View to adjust zoom level
-                - 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}")
-                    return f"Diameter set to {x} pixels"
+        zoom_in_btn.click(
+            fn=analyzer.zoom_in,
+            inputs=image_display,
+            outputs=image_display,
+            queue=False
+        )
         
-                def save_formatted():
-                    output_path = "analysis_results_formatted.xlsx"
-                    return analyzer.save_formatted_results(output_path)
+        zoom_out_btn.click(
+            fn=analyzer.zoom_out,
+            inputs=image_display,
+            outputs=image_display,
+            queue=False
+        )
         
-                # Event handlers
-                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]
-                )
-                
-                key_press.change(
-                    fn=analyzer.handle_keyboard,
-                    inputs=key_press,
-                    outputs=image_display
-                )
-                
-                blank_btn.click(
-                    fn=analyzer.add_blank_row,
-                    inputs=image_display,
-                    outputs=[image_display, results_display]
-                )
-                
-                zero_btn.click(
-                    fn=analyzer.add_zero_row,
-                    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]
-                )
+        reset_btn.click(
+            fn=analyzer.reset_view,
+            outputs=image_display
+        )
         
-                save_formatted_btn.click(
-                    fn=save_formatted,
-                    outputs=[file_output, results_display]
-                )
+        reset_all_btn.click(
+            fn=analyzer.reset_all,
+            inputs=image_display,
+            outputs=[image_display, results_display]
+        )
         
-                js = """
-                <script>
-                document.addEventListener('keydown', function(e) {
-                    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'));
-                        }
-                    }
-                });
-                </script>
-                """
-                gr.HTML(js)
-            
-            print("Interface created successfully")
-            return interface
+        key_press.change(
+            fn=analyzer.handle_keyboard,
+            inputs=key_press,
+            outputs=image_display
+        )
         
-        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
-                )
-            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
+        blank_btn.click(
+            fn=analyzer.add_blank_row,
+            inputs=image_display,
+            outputs=[image_display, results_display]
+        )
+        
+        zero_btn.click(
+            fn=analyzer.add_zero_row,
+            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]
+        )
+
+        js = """
+        <script>
+        document.addEventListener('keydown', function(e) {
+            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'));
+                }
+            }
+        });
+        </script>
+        """
+        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
+        )
+    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