Update app.py

app.py

@@ -326,7 +326,7 @@ class DicomAnalyzer:
             cell1.alignment = openpyxl.styles.Alignment(horizontal='center')
             
             # CNR Formula for second row
-            formula2 = f"=({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),0,({base_col}{row1}-{base_col}{row2})/{std_col}{row2})"
             cell2 = ws[f"{formula_col}{row2}"]
             cell2.value = formula2
             cell2.font = red_font
@@ -462,11 +462,22 @@ class DicomAnalyzer:
                 for cols in column_groups:
                     formula_col = get_column_letter(column_index_from_string(cols[-1]) + 1)
                     cnr_cell = f"{formula_col}{row_number}"
-                    cnr_references.append(cnr_cell)
+                    
+                    # Check if the cell would have a valid CNR value
+                    mean_col = cols[1]  # Mean column
+                    mean1 = ws[f"{mean_col}{row_pairs[i][0]}"].value  # First row mean
+                    mean2 = ws[f"{mean_col}{row_pairs[i][1]}"].value  # Second row mean
+                    stddev2 = ws[f"{cols[2]}{row_pairs[i][1]}"].value  # Second row StdDev
+                    
+                    # Only add to references if values are valid
+                    if (mean1 not in [0, None, ''] and 
+                        mean2 not in [0, None, ''] and 
+                        stddev2 not in [0, None, '']):
+                        cnr_references.append(cnr_cell)
                 
                 if cnr_references:
-                    # Create AVERAGE formula using cell references
-                    formula = f"=AVERAGE({','.join(cnr_references)})"
+                    # Create AVERAGE formula excluding zero values
+                    formula = f"=AVERAGEIF({','.join(cnr_references)},\"<>0\")"
                     size_cell = ws.cell(row=current_row, column=1, value=size)
                     size_cell.alignment = center_alignment
                     
@@ -490,234 +501,238 @@ class DicomAnalyzer:
             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')
-        
-        # 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")
+        except Exception as e:
+                    logger.error(f"Error saving formatted results: {str(e)}")
+                    return None, f"Error saving results: {str(e)}"
         
-        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)"
-                )
+            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')
                 
-                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"
-                )
+                # Map the headers to the result keys
+                value_mapping = {
+                    'Area': 'Area (mm²)',
+                    'Mean': 'Mean',
+                    'StdDev': 'StdDev',
+                    'Min': 'Min',
+                    'Max': 'Max'
+                }
                 
-        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"
-
-        def save_formatted():
-            output_path = "analysis_results_formatted.xlsx"
-            return analyzer.save_formatted_results(output_path)
-
-        # 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]
-        )
+                for i, (header, key) in enumerate(value_mapping.items()):
+                    cell = ws[f"{cols[i]}{row}"]
+                    cell.value = float(result[key])
+                    cell.alignment = center_alignment
         
-        diameter_slider.change(
-            fn=update_diameter,
-            inputs=diameter_slider,
-            outputs=gr.Textbox(label="Status")
-        )
+            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)
         
-        zoom_in_btn.click(
-            fn=analyzer.zoom_in,
-            inputs=image_display,
-            outputs=image_display,
-            queue=False
-        )
+            def add_blank_row(self, image):
+                self.results.append({
+                    'Area (mm²)': '',
+                    'Mean': '',
+                    'StdDev': '',
+                    'Min': '',
+                    'Max': '',
+                    'Point': ''
+                })
+                return image, self.format_results()
         
-        zoom_out_btn.click(
-            fn=analyzer.zoom_out,
-            inputs=image_display,
-            outputs=image_display,
-            queue=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()
         
-        reset_btn.click(
-            fn=analyzer.reset_view,
-            outputs=image_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()
         
-        reset_all_btn.click(
-            fn=analyzer.reset_all,
-            inputs=image_display,
-            outputs=[image_display, results_display]
-        )
+        # 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"
         
-        key_press.change(
-            fn=analyzer.handle_keyboard,
-            inputs=key_press,
-            outputs=image_display
-        )
+                def save_formatted():
+                    output_path = "analysis_results_formatted.xlsx"
+                    return analyzer.save_formatted_results(output_path)
         
-        blank_btn.click(
-            fn=analyzer.add_blank_row,
-            inputs=image_display,
-            outputs=[image_display, results_display]
-        )
+                # 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]
+                )
         
-        zero_btn.click(
-            fn=analyzer.add_zero_row,
-            inputs=image_display,
-            outputs=[image_display, results_display]
-        )
+                save_formatted_btn.click(
+                    fn=save_formatted,
+                    outputs=[file_output, results_display]
+                )
         
-        undo_btn.click(
-            fn=analyzer.undo_last,
-            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
         
-        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
+        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