Update app.py

app.py

@@ -7,6 +7,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 from matplotlib.colors import Normalize
 from io import BytesIO
+import re
 
 # Images path
 path_main = 'Data/'
@@ -16,40 +17,119 @@ images_file = path_main + 'Scennarios init/Scennarios W'
 modelo_1ap = load_model(path_main + 'Models/modelo_1ap_app.keras')
 modelo_2ap = load_model(path_main + 'Models/modelo_2ap_app.keras')
 
-plt.rc('font', family='Times New Roman')
 fontsize_t = 15
 
+# Plan visualization
+def load_plan_vi(mapa_seleccionado, uploaded_file):
+
+    if mapa_seleccionado == "Upload your own image" and uploaded_file is not None:
+        plan_image = Image.open(uploaded_file.name)
+    elif mapa_seleccionado == "Upload your own image" and uploaded_file is None:
+        image_plan_path1 = os.path.join(images_file, "100.JPG")
+        plan_image = Image.open(image_plan_path1)
+    else:
+        image_plan_path1 = os.path.join(images_file, mapa_seleccionado)
+        plan_image = Image.open(image_plan_path1)
+
+    plan_n = np.array(plan_image.convert('RGB'))
+
+    plt.imshow(plan_n)
+    plt.xticks(np.arange(0, 256, 50), fontsize=fontsize_t)
+    plt.yticks(np.arange(0, 256, 50), fontsize=fontsize_t)
+    plt.xlabel("X Coordinate [Pixels]", fontsize=fontsize_t)
+    plt.ylabel("Y Coordinate [Pixels]", fontsize=fontsize_t)
+    plt.show()
+
+    buf = BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    plt.close()
+
+    plan_im = Image.open(buf)
+
+    tick_positions = np.linspace(0, 256, 15)
+    tick_labels = np.linspace(0, 20, 15, dtype=int)
+
+    buf = BytesIO()
+    plt.imshow(plan_n)
+    plt.xticks(tick_positions, tick_labels, fontsize=fontsize_t)
+    plt.yticks(tick_positions, tick_labels, fontsize=fontsize_t)
+    plt.xlabel("X Coordinate [meters]", fontsize=fontsize_t)
+    plt.ylabel("Y Coordinate [meters]", fontsize=fontsize_t)
+    plt.show()
+
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    plt.close()
+
+    plan_im_meters = Image.open(buf)
+
+    return plan_im, plan_im_meters
+
+def validate_coords(num_aps, coords):
+    matches = re.findall(r"\(\s*\d+\s*,\s*\d+\s*\)", coords) 
+    
+    if len(matches) > int(num_aps):  
+        new_coords = ", ".join(matches[:int(num_aps)])  
+        return new_coords
+    return coords  
+
 def coordinates_process(texto, interference):
+    a = False
+
+    texto = re.sub(r'\s*,\s*', ', ', texto)  
+    texto = re.sub(r'\)\s*,\s*\(', '), (', texto)  
+    texto = texto.strip()  
+
     coordinates = texto.split("), ")
 
     resultado = []
     for coord in coordinates:
         try:
-            coord = coord.replace("(", "").replace(")", "")
-            x, y = map(int, coord.split(","))
-            # Validate range
+            coord = coord.replace("(", "").replace(")", "")  
+            x, y = map(int, coord.split(","))  
+
             if 0 <= x <= 255 and 0 <= y <= 255:
                 resultado.append((x, y))
             else:
-                return False
+                a = True
         except ValueError:
-            return False
+            a = True
+
+    if a:
+        resultado = [(0, 0), (0, 0), (0, 0)]
 
     while len(resultado) < 3 and interference == True:
         resultado.append((0, 0))
-
     while len(resultado) < 5 and interference == False:
         resultado.append((0, 0))
 
-    return resultado
+    resultado_str = ", ".join([f"({x}, {y})" for x, y in resultado])
+    return resultado_str  
 
 # plan images path
 def plan_images_list():
     return [file_ for file_ in os.listdir(images_file) if file_.endswith((".JPG", ".jpg", ".jpeg", ".png", ".PNG"))]
 
 # MAIN FUNCTION ****************************************************************
-def main_function(plan_name, interference, aps_int, aps_coor,
-                  apch1, apch6, apch11, coord1, coord6, coord11):
+def main_function(plan_name, interference = True, aps_int = 0, aps_coor = '(0,0)',
+                  apch1  = 0, apch6 = 0, apch11 = 0, coord1 = '(0,0)', coord6 = '(0,0)', coord11 = '(0,0)'):
+  
+    plan_name = str(plan_name)
+    interference = bool(interference)
+    aps_int = int(aps_int)
+    aps_coor = str(aps_coor)
+    apch1 = int(apch1)
+    apch6 = int(apch6)
+    apch11 = int(apch11)
+    coord1 = str(coord1)
+    coord6 = str(coord6)
+    coord11 = str(coord11)
+
+    aps_coor = validate_coords(aps_int, aps_coor)
+    coord1 = validate_coords(apch1, coord1)
+    coord6 = validate_coords(apch6, coord6)
+    coord11 = validate_coords(apch11, coord11)
 
     # **************************************************************************
     imagencober = {}
@@ -58,8 +138,9 @@ def main_function(plan_name, interference, aps_int, aps_coor,
 
     for k in range(5):
         plt.imshow(prediction_rgb, cmap='gray')
-        plt.title(f'No coverage', fontsize=fontsize_t + 2, family='Times New Roman')
+        plt.title(f'No coverage', fontsize=fontsize_t + 2)
         plt.axis("off")
+        # plt.show()
 
         buf = BytesIO()
         plt.savefig(buf, format='png')
@@ -82,7 +163,7 @@ def main_function(plan_name, interference, aps_int, aps_coor,
     dimension = 256
 
     if interference:
-        # channels_c = [1, 6 , 11]
+        channels_c = [1, 6 , 11]
         channels = 3
         num_APs = np.zeros(channels, dtype=int)
         num_APs[0] = apch1
@@ -100,7 +181,7 @@ def main_function(plan_name, interference, aps_int, aps_coor,
 
     if not interference:
         channels = aps_int
-        aps_chs = np.zeros((dimension, dimension, channels))  # Crear la matriz
+        aps_chs = np.zeros((dimension, dimension, 5))  # Crear la matriz
         coordinates = coordinates_process(aps_coor, interference)
 
         for att, (x, y) in enumerate(coordinates):
@@ -147,16 +228,24 @@ def main_function(plan_name, interference, aps_int, aps_coor,
 
         if np.all(prediction == 0):
             plt.imshow(prediction_rgb, cmap='gray')
-            plt.title(f'No coverage', fontsize=fontsize_t + 2, family='Times New Roman')
+            plt.title(f'No coverage', fontsize=fontsize_t)
             plt.axis("off")
+            plt.show()
         else:
             plt.imshow(prediction_rgb, cmap='jet')
-            # plt.title(f'Coverage CH {channels_c[k]}', fontsize=fontsize_t + 2, family='Times New Roman')
-            cbar = plt.colorbar(ticks=np.linspace(0, 1, num=6),)
-            cbar.set_label('SINR [dB]', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.set_ticklabels(['-3.01', '20.29', '43.60', '66.90', '90.20', '113.51'])
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            if interference:
+                plt.title(f'Coverage CH {channels_c[k]}', fontsize=fontsize_t)
+                cbar = plt.colorbar(ticks=np.linspace(0, 1, num=6),)
+                cbar.set_label('SINR [dB]', fontsize=fontsize_t)
+                cbar.set_ticklabels(['-3.01', '20.29', '43.60', '66.90', '90.20', '113.51'])
+            if not interference:
+                plt.title(f'Coverage AP {k}', fontsize=fontsize_t)
+                cbar = plt.colorbar(ticks=np.linspace(0, 1, num=6),)
+                cbar.set_label('Power [dBm]', fontsize=fontsize_t)
+                cbar.set_ticklabels(['-94.94', '-70.75', '-46.56', '-22.38', '1.81', '26.00'])
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
         # Save the plot to a buffer
         buf = BytesIO()
@@ -167,9 +256,6 @@ def main_function(plan_name, interference, aps_int, aps_coor,
         # Convert buffer to an image
         imagencober[k] = Image.open(buf)
 
-        # Cell map estimation
-        layer_indices.append(np.argmax(prediction, axis=0))
-
     # Final coverage
     if deep_coverage:
         deep_coverage = np.array(deep_coverage)
@@ -180,10 +266,15 @@ def main_function(plan_name, interference, aps_int, aps_coor,
 
         plt.imshow(resultado_rgb, cmap='jet')
         cbar = plt.colorbar(ticks=np.linspace(0, 1, num=6))
-        cbar.set_label('SINR [dB]', fontsize=fontsize_t, fontname='Times New Roman')
-        cbar.set_ticklabels(['-3.01', '20.29', '43.60', '66.90', '90.20', '113.51'])
-        cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+        if interference:
+            cbar.set_label('SINR [dB]', fontsize=fontsize_t)
+            cbar.set_ticklabels(['-3.01', '20.29', '43.60', '66.90', '90.20', '113.51'])
+        if not interference:
+            cbar.set_label('Power [dBm]', fontsize=fontsize_t)
+            cbar.set_ticklabels(['-94.94', '-70.75', '-46.56', '-22.38', '1.81', '26.00'])
+        cbar.ax.tick_params(labelsize=fontsize_t)
         plt.axis("off")
+        plt.show()
 
         # Save the plot to a buffer
         buf = BytesIO()
@@ -195,16 +286,17 @@ def main_function(plan_name, interference, aps_int, aps_coor,
         imagen3 = Image.open(buf)
 
     # **************************************************************************
-
-        if num_APs[0] > 0 and num_APs[1] > 0 and num_APs[2] > 0 and interference == True:
+    if interference == True:
+        if num_APs[0] > 0 and num_APs[1] > 0 and num_APs[2] > 0:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red', 'green'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
             cbar.set_ticks([0, 1, 2])
             cbar.set_ticklabels(['1', '6', '11'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -215,15 +307,16 @@ def main_function(plan_name, interference, aps_int, aps_coor,
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        if num_APs[0] > 0 and num_APs[1] > 0 and interference == True:
+        elif num_APs[0] > 0 and num_APs[1] > 0:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
             cbar.set_ticks([0, 1])
             cbar.set_ticklabels(['1', '6'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -234,15 +327,16 @@ def main_function(plan_name, interference, aps_int, aps_coor,
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        if num_APs[0] > 0 and num_APs[2] > 0 and interference == True:
+        elif num_APs[0] > 0 and num_APs[2] > 0:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
             cbar.set_ticks([0, 1])
             cbar.set_ticklabels(['1', '11'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -253,15 +347,16 @@ def main_function(plan_name, interference, aps_int, aps_coor,
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        if num_APs[1] > 0 and num_APs[2] > 0 and interference == True:
+        elif num_APs[1] > 0 and num_APs[2] > 0:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
             cbar.set_ticks([0, 1])
             cbar.set_ticklabels(['6', '11'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -272,35 +367,16 @@ def main_function(plan_name, interference, aps_int, aps_coor,
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        if num_APs[0] > 0 and num_APs[1] == 0 and num_APs[2] == 0 and interference == True:
-            cmap = plt.cm.colors.ListedColormap(['blue'])
-            plt.imshow(celdas, cmap=cmap)
-            cbar = plt.colorbar()
-            cbar.set_ticks([0])
-            cbar.set_ticklabels(['1'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
-            plt.axis("off")
-
-        if num_APs[0] == 0 and num_APs[1] > 0 and num_APs[2] == 0 and interference == True:
-            cmap = plt.cm.colors.ListedColormap(['blue'])
-            plt.imshow(celdas, cmap=cmap)
-            cbar = plt.colorbar()
-            cbar.set_ticks([0])
-            cbar.set_ticklabels(['1'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
-            plt.axis("off")
-
-        if num_APs[0] == 0 and num_APs[1] == 0 and num_APs[2] > 0 and interference == True:
+        else:
             cmap = plt.cm.colors.ListedColormap(['blue'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
             cbar.set_ticks([0])
             cbar.set_ticklabels(['1'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -313,15 +389,17 @@ def main_function(plan_name, interference, aps_int, aps_coor,
 
     # **************************************************************************
 
-        if aps_int == 5 and interference == False:
-            cmap = plt.cm.colors.ListedColormap(['blue', 'red', 'green', 'yellow', 'green'])
+    if interference == False:
+        if aps_int == 5:
+            cmap = plt.cm.colors.ListedColormap(['blue', 'red', 'green', 'yellow', 'violet'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
-            cbar.set_ticks([0, 1, 2])
+            cbar.set_ticks([0, 1, 2, 3, 4])
             cbar.set_ticklabels(['1', '2', '3', '4', '5'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -332,15 +410,16 @@ def main_function(plan_name, interference, aps_int, aps_coor,
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        if aps_int == 4 and interference == False:
+        elif aps_int == 4:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red', 'green', 'yellow'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
-            cbar.set_ticks([0, 1, 2])
+            cbar.set_ticks([0, 1, 2, 3])
             cbar.set_ticklabels(['1', '2', '3', '4'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -351,15 +430,16 @@ def main_function(plan_name, interference, aps_int, aps_coor,
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        if aps_int == 3 and interference == False:
+        elif aps_int == 3:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red', 'green'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
             cbar.set_ticks([0, 1, 2])
-            cbar.set_ticklabels(['1', '2', '3',])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_ticklabels(['1', '2', '3'])
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -370,15 +450,16 @@ def main_function(plan_name, interference, aps_int, aps_coor,
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        if aps_int == 2 and interference == False:
+        elif aps_int == 2:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
-            cbar.set_ticks([0, 1, 2])
+            cbar.set_ticks([0, 1])
             cbar.set_ticklabels(['1', '2'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -389,15 +470,16 @@ def main_function(plan_name, interference, aps_int, aps_coor,
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        if aps_int == 1 and interference == False:
+        else:
             cmap = plt.cm.colors.ListedColormap(['blue'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
-            cbar.set_ticks([0, 1, 2])
+            cbar.set_ticks([0])
             cbar.set_ticklabels(['1'])
-            cbar.set_label('Cell ID', fontsize=fontsize_t, fontname='Times New Roman')
-            cbar.ax.tick_params(labelsize=fontsize_t, labelfontfamily = 'Times New Roman')
+            cbar.set_label('Cell ID', fontsize=fontsize_t)
+            cbar.ax.tick_params(labelsize=fontsize_t)
             plt.axis("off")
+            plt.show()
 
             # Save the plot to a buffer
             buf = BytesIO()
@@ -412,48 +494,6 @@ def main_function(plan_name, interference, aps_int, aps_coor,
 
     return [imagencober[0], imagencober[1], imagencober[2], imagencober[3], imagencober[4], imagen3, imagen4]
 
-# Plan visualization
-def load_plan_vi(mapa_seleccionado, uploaded_file):
-
-    if mapa_seleccionado == "Upload your own image":
-        plan_image = Image.open(uploaded_file.name)
-    else:
-        image_plan_path1 = os.path.join(images_file, mapa_seleccionado)
-        plan_image = Image.open(image_plan_path1)
-
-    plan_n = np.array(plan_image.convert('RGB'))
-
-    plt.imshow(plan_n)
-    plt.xticks(np.arange(0, 256, 50), fontsize=fontsize_t, fontname='Times New Roman')
-    plt.yticks(np.arange(0, 256, 50), fontsize=fontsize_t, fontname='Times New Roman')
-    plt.xlabel("X Coordinate [Pixels]", fontsize=fontsize_t, fontname='Times New Roman')
-    plt.ylabel("Y Coordinate [Pixels]", fontsize=fontsize_t, fontname='Times New Roman')
-
-    buf = BytesIO()
-    plt.savefig(buf, format='png')
-    buf.seek(0)
-    plt.close()
-
-    plan_im = Image.open(buf)
-
-    tick_positions = np.linspace(0, 256, 15)
-    tick_labels = np.linspace(0, 20, 15, dtype=int)
-
-    buf = BytesIO()
-    plt.imshow(plan_n)
-    plt.xticks(tick_positions, tick_labels, fontsize=fontsize_t, fontname='Times New Roman')
-    plt.yticks(tick_positions, tick_labels, fontsize=fontsize_t, fontname='Times New Roman')
-    plt.xlabel("X Coordinate [meters]", fontsize=fontsize_t, fontname='Times New Roman')
-    plt.ylabel("Y Coordinate [meters]", fontsize=fontsize_t, fontname='Times New Roman')
-
-    plt.savefig(buf, format='png')
-    buf.seek(0)
-    plt.close()
-
-    plan_im_meters = Image.open(buf)
-
-    return plan_im, plan_im_meters
-
 def update_interface(enable_interference):
     if enable_interference:
         return {
@@ -471,7 +511,9 @@ def update_interface(enable_interference):
             image_ap2 : gr.update(visible=False),
             image_ch1 : gr.update(visible=True),
             image_ch6 : gr.update(visible=True),
-            image_ch11 : gr.update(visible=True)
+            image_ch11 : gr.update(visible=True),
+            simple_dropdown: gr.update(visible=False),
+            simple_coords: gr.update(visible=False)
         }
     else:
         return {
@@ -495,7 +537,17 @@ def update_interface(enable_interference):
 with gr.Blocks() as demo:
     gr.Markdown("""
     ## Fast Indoor Radio Propagation Prediction using Deep Learning
-    This app uses deep learning models for radio map estimation (RME). RME entails estimating the received RF power based on spatial information maps.
+    This app uses deep learning models for radio map estimation (RME) with and without interference, simulating 2.4 GHz and 5 GHz bands. RME involves estimating the received RF power based on spatial information maps.
+
+    Instructions for use:
+
+    - A predefined list of indoor floor plans is available for use.
+    - You can upload your own indoor floor plan.
+    - A maximum image size of 255x255 pixels is allowed.
+    - Negative numbers are not allowed.
+    - The established format for the coordinates of each access point (AP) must be followed.
+    - A maximum of 2 APs per channel is allowed for the interference case.
+    - A maximum of 5 APs is allowed for the non-interference case.
     """)
 
     enable_interference = gr.Checkbox(label="Enable Interference Analysis", value=True)
@@ -504,15 +556,15 @@ with gr.Blocks() as demo:
         with gr.Column(scale=1):
             map_dropdown = gr.Dropdown(choices=plan_images_list() + ["Upload your own image"], label="Select indoor plan")
             upload_image = gr.File(label="Or upload your own image", file_types=[".JPG", ".jpg", ".jpeg", ".png", ".PNG"])
-            ch1_input = gr.Dropdown(choices=[i for i in range(0, 3)], label="Select APs CH 1")
-            ch6_input = gr.Dropdown(choices=[i for i in range(0, 3)], label="Select APs CH 6")
-            ch11_input = gr.Dropdown(choices=[i for i in range(0, 3)], label="Select APs CH 11")
+            ch1_input = gr.Dropdown(choices=[i for i in range(0, 3)], label="Select APs CH 1", value=0)
+            ch6_input = gr.Dropdown(choices=[i for i in range(0, 3)], label="Select APs CH 6", value=0)
+            ch11_input = gr.Dropdown(choices=[i for i in range(0, 3)], label="Select APs CH 11", value=0)
             coords_ch1_input = gr.Textbox(label="Coordinate CH 1", placeholder="Format (Pixels): (x1, y1), (x2, y2)")
             coords_ch6_input = gr.Textbox(label="Coordinate CH 6", placeholder="Format (Pixels): (x1, y1), (x2, y2)")
             coords_ch11_input = gr.Textbox(label="Coordinate CH 11", placeholder="Format (Pixels): (x1, y1), (x2, y2)")
 
             simple_dropdown = gr.Dropdown(choices=[str(i) for i in range(1, 6)], label="Select APs number", visible=False)
-            simple_coords = gr.Textbox(label="Enter APs coordinates", placeholder="Format (Pixels): (x1, y1), (x1, y1)...", visible=False)
+            simple_coords = gr.Textbox(label="Enter APs coordinates", placeholder="Format (Pixels): (x1, y1), (x1, y1)...", visible=False,)
 
             button1 = gr.Button("Load plan")
             button2 = gr.Button("Predict coverage")