Update app.py

app.py

@@ -66,8 +66,12 @@ class DicomAnalyzer:
         print("DicomAnalyzer initialized...")
 
     def save_results(self):
+        """
+        Saves raw ROI data as an Excel file with minimal formatting.
+        """
         try:
             if not self.results:
+                logger.warning("Attempted to save with no results")
                 return None, "No results to save"
 
             df = pd.DataFrame(self.results)
@@ -104,6 +108,9 @@ class DicomAnalyzer:
         return self.update_display(), "All data has been reset"
 
     def load_dicom(self, file):
+        """
+        Loads DICOM from user file and normalizes for display.
+        """
         try:
             if file is None:
                 return None, "No file uploaded"
@@ -134,6 +141,9 @@ class DicomAnalyzer:
             return None, f"Error loading DICOM file: {str(e)}"
 
     def normalize_image(self, image):
+        """
+        Converts raw data to 0..255 range for display. 
+        """
         try:
             normalized = cv2.normalize(
                 image, 
@@ -151,6 +161,9 @@ class DicomAnalyzer:
             return None
 
     def reset_view(self):
+        """
+        Resets zoom and pan to defaults.
+        """
         self.zoom_factor = 1.0
         self.pan_x = 0
         self.pan_y = 0
@@ -167,6 +180,9 @@ class DicomAnalyzer:
         return self.update_display()
 
     def handle_keyboard(self, key):
+        """
+        Pans image with arrow keys.
+        """
         try:
             pan_amount = int(10 * self.zoom_factor)
             if key == 'ArrowLeft':
@@ -183,6 +199,9 @@ class DicomAnalyzer:
             return self.display_image
 
     def update_display(self):
+        """
+        Returns a zoomed/panned copy of original_display with circles drawn.
+        """
         try:
             if self.original_display is None:
                 return None
@@ -191,15 +210,10 @@ 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)
 
-            # Draw circles
+            # Draw ROI marks
             for x, y, diameter in self.marks:
                 zoomed_x = int(x * self.zoom_factor)
                 zoomed_y = int(y * self.zoom_factor)
@@ -207,13 +221,13 @@ class DicomAnalyzer:
                 
                 cv2.circle(zoomed_bgr, (zoomed_x, zoomed_y), zoomed_radius, self.CIRCLE_COLOR, 1, lineType=cv2.LINE_AA)
                 
-                # 8 small circles
+                # 8 small circles around
                 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)
+                    px = int(zoomed_x + zoomed_radius * np.cos(angle))
+                    py = int(zoomed_y + zoomed_radius * np.sin(angle))
+                    cv2.circle(zoomed_bgr, (px, py), 1, self.SMALL_CIRCLES_COLOR, -1, lineType=cv2.LINE_AA)
 
             zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
 
@@ -222,16 +236,16 @@ class DicomAnalyzer:
             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)
-            ]
-
+            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:
             return self.original_display
 
     def analyze_roi(self, evt: gr.SelectData):
+        """
+        Called when user clicks the image. We gather ROI stats and store them.
+        """
         try:
             if self.current_image is None:
                 return None, "No image loaded"
@@ -243,8 +257,8 @@ class DicomAnalyzer:
             y = clicked_y + self.pan_y
 
             if self.zoom_factor != 1.0:
-                x = x / self.zoom_factor
-                y = y / self.zoom_factor
+                x /= self.zoom_factor
+                y /= self.zoom_factor
             
             x = int(round(x))
             y = int(round(y))
@@ -298,14 +312,35 @@ class DicomAnalyzer:
         except Exception as e:
             return self.display_image, f"Error analyzing ROI: {str(e)}"
 
+    def _write_result_to_cells(self, ws, result, cols, row):
+        """
+        Writes one ROI measurement into the given row/columns. 
+        (If you still want to store raw data in some pattern, you can keep this.)
+        """
+        center_alignment = openpyxl.styles.Alignment(horizontal='center')
+        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}"]
+            val = result[key]
+            cell.value = float(val) if val not in ['', None] else ''
+            cell.alignment = center_alignment
+
     def add_formulas_to_template(self, ws, row_pair, col_group, red_font):
-        """Inserts SNR (row1) and CNR (row2) in the next column after col_group."""
+        """
+        Example function: inserts SNR (row1) and CNR (row2) formulas with IFERROR.
+        If you don't need them, you can keep or remove them.
+        """
         try:
-            base_col = col_group[1]  # Mean column
-            std_col = col_group[2]   # StdDev column
+            base_col = col_group[1]  # Mean col
+            std_col = col_group[2]   # StdDev col
             
             row1, row2 = row_pair
-            
             formula_col = get_column_letter(column_index_from_string(col_group[-1]) + 1)
             
             # SNR in row1
@@ -326,6 +361,12 @@ class DicomAnalyzer:
             logger.error(f"Error adding formulas: {str(e)}")
 
     def save_formatted_results(self, output_path):
+        """
+        Saves an Excel with:
+          1) A normal layout of ROI data if you want (row_pairs, columns).
+          2) A final "1-AVG" table in row35 using *all* measurements in self.results,
+             so you see an average even if you only have 1 measurement.
+        """
         try:
             if not self.results:
                 return None, "No results to save"
@@ -333,63 +374,47 @@ class DicomAnalyzer:
             wb = openpyxl.Workbook()
             ws = wb.active
             red_font = openpyxl.styles.Font(color="FF0000")
-            center_alignment = openpyxl.styles.Alignment(horizontal='center')
+            center_alignment = openpyxl.styles.Alignment(horizontal='center', vertical='center')
             
+            # (1) Optionally store the raw data in some pattern if you want
+            # Example: We define column_groups, row_pairs, etc.
             headers = ['Area', 'Mean', 'StdDev', 'Min', 'Max']
             column_groups = [
                 ('B', 'C', 'D', 'E', 'F'), ('H', 'I', 'J', 'K', 'L'),
                 ('N', 'O', 'P', 'Q', 'R'), ('T', 'U', 'V', 'W', 'X'),
-                ('Z', 'AA', 'AB', 'AC', 'AD'), ('AF', 'AG', 'AH', 'AI', 'AJ'),
-                ('AL', 'AM', 'AN', 'AO', 'AP'), ('AR', 'AS', 'AT', 'AU', 'AV'),
-                ('AX', 'AY', 'AZ', 'BA', 'BB'), ('BD', 'BE', 'BF', 'BG', 'BH'),
-                ('BJ', 'BK', 'BL', 'BM', 'BN'), ('BP', 'BQ', 'BR', 'BS', 'BT'),
-                ('BV', 'BW', 'BX', 'BY', 'BZ')
+                # add more if needed
             ]
-            
-            # 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)
-            ]
+                    ws[f"{cols[i]}1"].value = header
+                    ws[f"{cols[i]}1"].alignment = center_alignment
 
-            phantom_sizes = [
-                '(7mm)', '(6.5mm)', '(6mm)', '(5.5mm)', '(5mm)',
-                '(4.5mm)', '(4mm)', '(3.5mm)', '(3mm)', '(2.5mm)'
-            ]
+            row_pairs = [(2, 3), (5, 6), (8, 9), (11, 12)]
+            # (adjust how many pairs you want)
             
-            # Label each phantom in column A
-            for i, size in enumerate(phantom_sizes):
-                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
-
-            # Fill raw ROI data + formulas
+            # Write each result into these row/columns as a demonstration
             result_idx = 0
             current_col_group = 0
             current_row_pair = 0
-            
             while result_idx < len(self.results):
                 if current_row_pair >= len(row_pairs):
                     break
-                    
                 cols = column_groups[current_col_group]
                 row1, row2 = row_pairs[current_row_pair]
                 
+                # Write first measurement
                 if result_idx < len(self.results):
-                    self._write_result_to_cells(ws, self.results[result_idx], cols, row1)
+                    r = self.results[result_idx]
+                    self._write_result_to_cells(ws, r, cols, row1)
                     result_idx += 1
                 
+                # Write second measurement
                 if result_idx < len(self.results):
-                    self._write_result_to_cells(ws, self.results[result_idx], cols, row2)
+                    r = self.results[result_idx]
+                    self._write_result_to_cells(ws, r, cols, row2)
                     result_idx += 1
-                
+
+                # Insert formulas if you want
                 self.add_formulas_to_template(ws, (row1,row2), cols, red_font)
                 
                 current_col_group += 1
@@ -397,20 +422,12 @@ class DicomAnalyzer:
                     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 not in [None, '']:
-                            cell.alignment = center_alignment
-
-            # Now the 1-AVG table from row35..45
+            # (2) Now create the 1-AVG table at row35, but read from self.results directly
             start_row = 35
             ws['C35'] = "1-AVG"
             ws['C35'].alignment = center_alignment
             
-            # Merge headers
+            # Merge some cells for the headers
             ws.merge_cells('D35:E35')
             ws.merge_cells('F35:G35')
             ws.merge_cells('H35:I35')
@@ -422,90 +439,75 @@ class DicomAnalyzer:
             }
             for c_ref, text_val in avg_headers.items():
                 ws[c_ref] = text_val
-                ws[c_ref].font = red_font
                 ws[c_ref].alignment = center_alignment
+                ws[c_ref].font = red_font
             
-            # 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)'
-            ]
+            # We just put everything in row 36 for demonstration. 
+            # Or you could put phantom sizes if you want multiple lines. 
+            row = 36
+            ws.merge_cells(f'D{row}:E{row}')
+            ws.merge_cells(f'F{row}:G{row}')
+            ws.merge_cells(f'H{row}:I{row}')
             
-            for i, p_size in enumerate(phantom_sizes2):
-                row = start_row + i + 1  # 36..45
-                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_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 = []
-                
-                # Read from the same column groups
-                for group in column_groups:
-                    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
-                    
-                    # 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:
-                        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:
-                        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
-                    ws[f'D{row}'].number_format = '0.0000'
-                
-                if final_std is not None:
-                    ws[f'F{row}'].value = final_std
-                    ws[f'F{row}'].alignment = center_alignment
-                    ws[f'F{row}'].number_format = '0.0000'
-                
-                if final_cnr is not None:
-                    ws[f'H{row}'].value = final_cnr
-                    ws[f'H{row}'].alignment = center_alignment
-                    ws[f'H{row}'].number_format = '0.0000'
-
-            # Put borders
-            thin_side = openpyxl.styles.Side(style='thin')
+            # Now gather *all* results from self.results
+            all_means  = []
+            all_stds   = []
+            # We'll do CNR from first two if we have at least 2 measurements
+            # Or you can define your own logic if you want multiple pairs
+            cnr_value = None
+
+            for i, r in enumerate(self.results):
+                try:
+                    m = float(r["Mean"])
+                    s = float(r["StdDev"])
+                    all_means.append(m)
+                    all_stds.append(s)
+                except:
+                    pass
+            
+            # If you only have 1 measurement, you still get an average = same value
+            avg_mean = sum(all_means)/len(all_means) if all_means else None
+            avg_std  = sum(all_stds)/len(all_stds)   if all_stds else None
+
+            # For CNR, let's just do a simple logic: if we have >=2 measurements,
+            # we do (mean1 - mean2) / std2 as an example
+            # or you can define your own approach
+            if len(self.results) >= 2:
+                try:
+                    r1 = self.results[0]
+                    r2 = self.results[1]
+                    m1 = float(r1["Mean"])
+                    m2 = float(r2["Mean"])
+                    s2 = float(r2["StdDev"])
+                    if s2 != 0:
+                        cnr_value = (m1 - m2)/s2
+                except:
+                    cnr_value = None
+
+            # Write them in row 36
+            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 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_value is not None:
+                ws[f'H{row}'].value = cnr_value
+                ws[f'H{row}'].alignment = center_alignment
+                ws[f'H{row}'].number_format = '0.0000'
+
+            # Add thin border to the table
             border = openpyxl.styles.Border(
-                left=thin_side, right=thin_side, top=thin_side, bottom=thin_side
+                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 r in range(35, 46):
+            for r in range(35, 37):
                 for c in ['C','D','E','F','G','H','I']:
                     ws[f'{c}{r}'].border = border
 
@@ -515,22 +517,8 @@ 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):
-        center_alignment = openpyxl.styles.Alignment(horizontal='center')
-        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}"]
-            val = result[key]
-            cell.value = float(val) if val not in ['', None] else ''
-            cell.alignment = center_alignment
-
     def format_results(self):
+        """Just prints self.results as a string in the UI."""
         if not self.results:
             return "No measurements yet"
         df = pd.DataFrame(self.results)
@@ -539,6 +527,7 @@ class DicomAnalyzer:
         return df.to_string(index=False)
 
     def add_zero_row(self, image):
+        """Test function to push a zero row into self.results."""
         self.results.append({
             'Area (mm²)': '0.000',
             'Mean': '0.000',
@@ -550,6 +539,7 @@ class DicomAnalyzer:
         return image, self.format_results()
 
     def add_two_zero_rows(self, image):
+        """Adds 2 zero rows for testing."""
         for _ in range(2):
             self.results.append({
                 'Area (mm²)': '0.000',
@@ -562,10 +552,11 @@ class DicomAnalyzer:
         return image, self.format_results()
 
     def undo_last(self, image):
+        """Removes the last measurement (or zero row)."""
         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()
@@ -573,6 +564,10 @@ class DicomAnalyzer:
 
 
 def create_interface():
+    """
+    Creates the Gradio interface.
+    """
+    print("Creating interface...")
     analyzer = DicomAnalyzer()
     
     with gr.Blocks(css="#image_display { outline: none; }") as interface:
@@ -581,7 +576,13 @@ def create_interface():
         with gr.Row():
             with gr.Column():
                 file_input = gr.File(label="Upload DICOM file")
-                diameter_slider = gr.Slider(1, 20, 9, 1, label="ROI Diameter (pixels)")
+                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 (+)")
@@ -590,7 +591,11 @@ 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")
@@ -605,39 +610,98 @@ def create_interface():
         
         gr.Markdown("""
         ### Controls:
-        - Arrow keys to pan when zoomed in.
-        - Click points to measure ROI.
-        - Zoom In/Out, Reset, etc.
-        - "Save Results": raw data
-        - "Save Formatted Results": advanced table
+        - Use arrow keys to pan when zoomed in. 
+        - Click on the image to analyze ROI.
+        - "Save Results": basic raw data Excel
+        - "Save Formatted Results": advanced table with 1-AVG, even if 1 measurement only
         """)
 
         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():
-            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"))
+            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])
+        zoom_in_btn.click(
+            fn=analyzer.zoom_in,
+            inputs=image_display,
+            outputs=image_display,
+            queue=False
+        )
         
-        key_press.change(fn=analyzer.handle_keyboard, inputs=key_press, outputs=image_display)
+        zoom_out_btn.click(
+            fn=analyzer.zoom_out,
+            inputs=image_display,
+            outputs=image_display,
+            queue=False
+        )
         
-        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])
+        reset_btn.click(
+            fn=analyzer.reset_view,
+            outputs=image_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])
+        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
+        )
+        
+        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]
+        )
 
-        # JS to capture arrow keys
+        # JavaScript to capture arrow keys
         js = """
         <script>
         document.addEventListener('keydown', function(e) {
@@ -658,15 +722,24 @@ 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:
         logger.error(f"Error launching application: {str(e)}")
         logger.error(traceback.format_exc())