Update app.py

app.py

@@ -61,14 +61,11 @@ class DicomAnalyzer:
         self.pan_y = 0
         self.max_pan_x = 0
         self.max_pan_y = 0
-        self.CIRCLE_COLOR = (0, 255, 255)  # BGR
-        self.SMALL_CIRCLES_COLOR = (255, 255, 255)  # BGR
+        self.CIRCLE_COLOR = (0, 255, 255)  # BGR format
+        self.SMALL_CIRCLES_COLOR = (255, 255, 255)  # BGR white
         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")
@@ -108,9 +105,6 @@ 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"
@@ -141,9 +135,6 @@ 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, 
@@ -161,9 +152,6 @@ 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
@@ -172,19 +160,20 @@ 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):
-        """
-        Pans image with arrow keys.
-        """
         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':
@@ -196,12 +185,10 @@ 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):
-        """
-        Returns a zoomed/panned copy of original_display with circles drawn.
-        """
         try:
             if self.original_display is None:
                 return None
@@ -210,24 +197,43 @@ 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 ROI marks
             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)
                 
-                cv2.circle(zoomed_bgr, (zoomed_x, zoomed_y), zoomed_radius, self.CIRCLE_COLOR, 1, lineType=cv2.LINE_AA)
+                # Draw the main yellow circle
+                cv2.circle(
+                    zoomed_bgr,
+                    (zoomed_x, zoomed_y),
+                    zoomed_radius,
+                    self.CIRCLE_COLOR,
+                    1,
+                    lineType=cv2.LINE_AA
+                )
                 
-                # 8 small circles around
+                # Draw 8 small white circles around
                 num_points = 8
                 for i in range(num_points):
                     angle = 2 * np.pi * i / num_points
-                    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)
+                    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
+                    )
 
             zoomed = cv2.cvtColor(zoomed_bgr, cv2.COLOR_BGR2RGB)
 
@@ -236,16 +242,17 @@ 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:
+            print(f"Error updating display: {str(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"
@@ -257,8 +264,8 @@ class DicomAnalyzer:
             y = clicked_y + self.pan_y
 
             if self.zoom_factor != 1.0:
-                x /= self.zoom_factor
-                y /= self.zoom_factor
+                x = x / self.zoom_factor
+                y = y / self.zoom_factor
             
             x = int(round(x))
             y = int(round(y))
@@ -270,7 +277,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
@@ -281,7 +288,8 @@ class DicomAnalyzer:
                 return self.display_image, "Error: No pixels selected"
 
             pixel_spacing = float(self.dicom_data.PixelSpacing[0])
-            area = np.sum(mask) * (pixel_spacing ** 2)
+            n_pixels = np.sum(mask)
+            area = n_pixels * (pixel_spacing ** 2)
             
             mean_value = np.mean(roi_pixels)
             std_dev = np.std(roi_pixels, ddof=1)
@@ -310,63 +318,42 @@ 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 _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):
         """
-        Example function: inserts SNR (row1) and CNR (row2) formulas with IFERROR.
-        If you don't need them, you can keep or remove them.
+        Inserts SNR (first row) and CNR (second row) formulas with IFERROR.
         """
         try:
-            base_col = col_group[1]  # Mean col
-            std_col = col_group[2]   # StdDev col
+            base_col = col_group[1]  # Mean column
+            std_col = col_group[2]   # StdDev column
             
             row1, row2 = row_pair
-            formula_col = get_column_letter(column_index_from_string(col_group[-1]) + 1)
             
-            # SNR in row1
+            # SNR formula in row1
             formula1 = f"=IFERROR({base_col}{row1}/{std_col}{row1},\"\")"
+            formula_col = get_column_letter(column_index_from_string(col_group[-1]) + 1)
             cell1 = ws[f"{formula_col}{row1}"]
             cell1.value = formula1
             cell1.font = red_font
             cell1.alignment = openpyxl.styles.Alignment(horizontal='center')
             
-            # CNR in row2
+            # CNR formula 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)}")
 
+    ########################################################################
+    # التعديل الوحيد: في تجميع الـCNR نقرأ من خلية المعادلة بدلا من (m1 - m2)/std2
+    ########################################################################
     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"
@@ -374,60 +361,84 @@ class DicomAnalyzer:
             wb = openpyxl.Workbook()
             ws = wb.active
             red_font = openpyxl.styles.Font(color="FF0000")
-            center_alignment = openpyxl.styles.Alignment(horizontal='center', vertical='center')
+            center_alignment = openpyxl.styles.Alignment(horizontal='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'),
-                # add more if needed
+                ('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')
             ]
+            
+            # Write table headers in row1
             for cols in column_groups:
                 for i, header in enumerate(headers):
-                    ws[f"{cols[i]}1"].value = header
-                    ws[f"{cols[i]}1"].alignment = center_alignment
+                    cell = ws[f"{cols[i]}1"]
+                    cell.value = header
+                    cell.alignment = center_alignment
 
-            row_pairs = [(2, 3), (5, 6), (8, 9), (11, 12)]
-            # (adjust how many pairs you want)
+            row_pairs = [
+                (2, 3), (5, 6), (8, 9), (11, 12), (14, 15),
+                (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)'
+            ]
             
-            # Write each result into these row/columns as a demonstration
+            # Phantom labels 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
+
+            # Write ROI results into the defined rows/columns
             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]
+                rows = row_pairs[current_row_pair]
                 
-                # Write first measurement
                 if result_idx < len(self.results):
-                    r = self.results[result_idx]
-                    self._write_result_to_cells(ws, r, cols, row1)
+                    result = self.results[result_idx]
+                    self._write_result_to_cells(ws, result, cols, rows[0])
                     result_idx += 1
                 
-                # Write second measurement
                 if result_idx < len(self.results):
-                    r = self.results[result_idx]
-                    self._write_result_to_cells(ws, r, cols, row2)
+                    result = self.results[result_idx]
+                    self._write_result_to_cells(ws, result, cols, rows[1])
                     result_idx += 1
-
-                # Insert formulas if you want
-                self.add_formulas_to_template(ws, (row1,row2), cols, red_font)
+                
+                self.add_formulas_to_template(ws, rows, cols, red_font)
                 
                 current_col_group += 1
                 if current_col_group >= len(column_groups):
                     current_col_group = 0
                     current_row_pair += 1
 
-            # (2) Now create the 1-AVG table at row35, but read from self.results directly
+            # Align cells for existing 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:
+                            cell.alignment = center_alignment
+
+            # Now build the "1-AVG" table from row 35
             start_row = 35
             ws['C35'] = "1-AVG"
             ws['C35'].alignment = center_alignment
             
-            # Merge some cells for the headers
             ws.merge_cells('D35:E35')
             ws.merge_cells('F35:G35')
             ws.merge_cells('H35:I35')
@@ -439,86 +450,125 @@ class DicomAnalyzer:
             }
             for c_ref, text_val in avg_headers.items():
                 ws[c_ref] = text_val
-                ws[c_ref].alignment = center_alignment
                 ws[c_ref].font = red_font
+                ws[c_ref].alignment = center_alignment
+            
+            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}')
-            
-            # 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
+            # For each phantom row, gather Mean, STD, and read the CNR from the formula column
+            for i, p_size in enumerate(phantom_sizes2):
+                row = start_row + i + 1  # rows 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}')
+                
+                size_cell = ws[f'C{row}']
+                size_cell.value = p_size
+                size_cell.font = red_font
+                size_cell.alignment = center_alignment
+
+                if i >= len(row_pairs):
+                    continue
+                
+                (raw_row1, raw_row2) = row_pairs[i]
+                
+                mean_values = []
+                stddev_values = []
+                cnr_values = []
+                
+                # بدل ما نحسب (m1 - m2)/std2 مباشرة
+                # سنقرأ خلية المعادلة في row2 لكل مجموعة
+                for group in column_groups:
+                    mean_col = group[1]  # 'C' مثلاً
+                    std_col  = group[2]  # 'D' مثلاً
+
+                    # Read mean from row1 (if you want to average them)
+                    m1_val  = ws[f"{mean_col}{raw_row1}"].value
+                    if m1_val not in [None,'']:
+                        try:
+                            mean_values.append(float(m1_val))
+                        except:
+                            pass
+
+                    # Read std from row1 (if you want to average them)
+                    std_val = ws[f"{std_col}{raw_row1}"].value
+                    if std_val not in [None,'']:
+                        try:
+                            stddev_values.append(float(std_val))
+                        except:
+                            pass
+
+                    # ---- الأهم: CNR يأتي من صيغة المعادلة (العمود الذي يلي group[-1]) في الصف الثاني ----
+                    formula_col_index = column_index_from_string(group[-1]) + 1
+                    formula_col       = get_column_letter(formula_col_index)
+                    cnr_cell_value    = ws[f"{formula_col}{raw_row2}"].value  # حيث توجد =IFERROR((Mean1-Mean2)/Std2,"")
+
+                    if cnr_cell_value not in [None,'']:
+                        try:
+                            cnr_values.append(float(cnr_cell_value))
+                        except:
+                            pass
+                
+                # احسب المتوسطات
+                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
+
+                # اكتبهم في الجدول
+                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'
+
+            # Border around C35..I45
+            thin_side = openpyxl.styles.Side(style='thin')
             border = openpyxl.styles.Border(
-                left=openpyxl.styles.Side(style='thin'),
-                right=openpyxl.styles.Side(style='thin'),
-                top=openpyxl.styles.Side(style='thin'),
-                bottom=openpyxl.styles.Side(style='thin')
+                left=thin_side, right=thin_side, top=thin_side, bottom=thin_side
             )
-            for r in range(35, 37):
+            for r in range(35, 46):
                 for c in ['C','D','E','F','G','H','I']:
                     ws[f'{c}{r}'].border = border
 
+            # Finally save
             wb.save(output_path)
             return output_path, f"Results saved successfully ({len(self.results)} measurements)"
         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',
+            '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)
@@ -527,7 +577,6 @@ 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',
@@ -539,7 +588,6 @@ 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',
@@ -552,21 +600,21 @@ class DicomAnalyzer:
         return image, self.format_results()
 
     def undo_last(self, image):
-        """Removes the last measurement (or zero row)."""
-        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)'
+        
         self.results.pop()
+        
         if is_measurement and self.marks:
             self.marks.pop()
+            
         return self.update_display(), self.format_results()
 
 
 def create_interface():
-    """
-    Creates the Gradio interface.
-    """
     print("Creating interface...")
     analyzer = DicomAnalyzer()
     
@@ -610,10 +658,12 @@ def create_interface():
         
         gr.Markdown("""
         ### Controls:
-        - 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
+        - Use arrow keys to pan when zoomed in. Movement is now larger.
+        - 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 (including correct CNR averaging).
         """)
 
         def update_diameter(x):
@@ -701,19 +751,18 @@ def create_interface():
             outputs=[file_output, results_display]
         )
 
-        # JavaScript 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 el = document.querySelector('#key_press textarea');
-                if (el) {
-                    el.value = e.key;
-                    el.dispatchEvent(new Event('input'));
+                const keyPressElement = document.querySelector('#key_press textarea');
+                if (keyPressElement) {
+                    keyPressElement.value = e.key;
+                    keyPressElement.dispatchEvent(new Event('input'));
                     setTimeout(() => {
-                      el.value = '';
-                      el.dispatchEvent(new Event('input'));
+                      keyPressElement.value = '';
+                      keyPressElement.dispatchEvent(new Event('input'));
                     }, 100);
                 }
             }
@@ -741,6 +790,7 @@ if __name__ == "__main__":
             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