Update app.py

app.py

@@ -9,17 +9,17 @@ from matplotlib.colors import Normalize
 from io import BytesIO
 
 # Images path
-path_main = 'Data/'
+path_main = '/content/drive/Othercomputers/False-2-Tesis-Maestria /Phase-3-thesis/'
 images_file = path_main + 'Scennarios init/Scennarios W'
 
 # Load DL models
-modelo_1ap = load_model(path_main + 'Models/modelo_1ap_app.keras')
-modelo_2ap = load_model(path_main + 'Models/modelo_2ap_app.keras')
+modelo_1ap = load_model(path_main + 'Models/SINR-2APs/modelo_1ap_app.keras')
+modelo_2ap = load_model(path_main + 'Models/SINR-2APs/modelo_2ap_app.keras')
 
 plt.rc('font', family='Times New Roman')
 fontsize_t = 15
 
-def coordinates_process(texto):
+def coordinates_process(texto, interference):
     coordinates = texto.split("), ")
 
     resultado = []
@@ -35,64 +35,84 @@ def coordinates_process(texto):
         except ValueError:
             return False
 
-    while len(resultado) < 3:
+    while len(resultado) < 3 and interference == True:
+        resultado.append((0, 0))
+
+    while len(resultado) < 5 and interference == False:
         resultado.append((0, 0))
 
     return resultado
 
 # plan images path
 def plan_images_list():
-    return [file_ for file_ in os.listdir(images_file) if file_.endswith((".JPG", ".jpg", ".jpeg", ".png", "PNG"))]
-
-# Valdate inputs
-def validate_input(value):
-    if value == "" or value is None:
-        return 0
-    elif value >= 0 or value <= 2:
-        return value
+    return [file_ for file_ in os.listdir(images_file) if file_.endswith((".JPG", ".jpg", ".jpeg", ".png", ".PNG"))]
 
 # MAIN FUNCTION ****************************************************************
-def main_function(plan_name, apch1, apch6, apch11, coord1, coord6, coord11):
+def main_function(plan_name, interference, aps_int, aps_coor,
+                  apch1, apch6, apch11, coord1, coord6, coord11):
+
+    # **************************************************************************
+    imagencober = {}
+
+    prediction_rgb = np.zeros((256, 256))
+
+    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.axis("off")
+
+        buf = BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        plt.close()
+
+        imagencober[k] = Image.open(buf)
+    # **************************************************************************
+
+    # Load plan
+    numero = plan_name.split('.')[0]
+    plan_in = np.array(Image.open(f"{path_main}Scennarios init/Scennarios B/{numero}.png")) / 255
+
     image_plan_path = os.path.join(images_file, plan_name)
     imagen1 = Image.open(image_plan_path)
 
-    # No negative number as input
-    if not (0 <= apch1 <= 2):
-        return False
-    if not (0 <= apch6 <= 2):
-        return False
-    if not (0 <= apch11 <= 2):
-        return False
-
     # Some variables init
     deep_count = 0
     deep_coverage = []
-    channels = [1, 6, 11]
-    num_APs = np.zeros(len(channels), dtype=int)
-    num_APs[0] = apch1
-    num_APs[1] = apch6
-    num_APs[2] = apch11
     dimension = 256
-    aps_chs = np.zeros((dimension, dimension, len(channels)))
-
-    # Load plan
-    numero = plan_name.split('.')[0]
-    plan_in = np.array(Image.open(f"{path_main}Scennarios init/Scennarios B/{numero}.png")) / 255
 
-    coords = [coord1, coord6, coord11]
-    for att, channel in enumerate(channels):
-      if num_APs[att] > 0:
-          coordinates = coordinates_process(coords[att])
-          for x, y in coordinates:
+    if interference:
+        # channels_c = [1, 6 , 11]
+        channels = 3
+        num_APs = np.zeros(channels, dtype=int)
+        num_APs[0] = apch1
+        num_APs[1] = apch6
+        num_APs[2] = apch11
+        aps_chs = np.zeros((dimension, dimension, channels))
+        coords = [coord1, coord6, coord11]
+
+        for att, channel in enumerate(range(channels)):
+          if num_APs[att] > 0:
+              coordinates = coordinates_process(coords[att], interference)
+              for x, y in coordinates:
+                if x != 0 and y != 0:
+                  aps_chs[int(y), int(x), att] = 1
+
+    if not interference:
+        channels = aps_int
+        aps_chs = np.zeros((dimension, dimension, channels))  # Crear la matriz
+        coordinates = coordinates_process(aps_coor, interference)
+
+        for att, (x, y) in enumerate(coordinates):
             if x != 0 and y != 0:
-              aps_chs[int(y), int(x), att] = 1
+                aps_chs[int(y), int(x), att] = 1
 
     # Coverage process
     deep_coverage = []
     ap_images = []
     layer_indices = []
-    imagencober = {}
-    for k in range(len(channels)):
+
+    for k in range(channels):
         capa = aps_chs[:, :, k]
         filas, columnas = np.where(capa == 1)
 
@@ -123,14 +143,15 @@ def main_function(plan_name, apch1, apch6, apch11, coord1, coord6, coord11):
         # print(prediction.shape)
         deep_coverage.append(prediction)
         prediction_rgb = np.squeeze((Normalize()(prediction)))
-        ap_images.append(prediction_rgb)  # Guardar la imagen de cobertura del AP
+        ap_images.append(prediction_rgb)
 
         if np.all(prediction == 0):
-            plt.imshow(prediction_rgb)
-            plt.title('No coverage', fontsize=fontsize_t + 2, family='Times New Roman')
+            plt.imshow(prediction_rgb, cmap='gray')
+            plt.title(f'No coverage', fontsize=fontsize_t + 2, family='Times New Roman')
             plt.axis("off")
         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'])
@@ -173,7 +194,9 @@ def main_function(plan_name, apch1, apch6, apch11, coord1, coord6, coord11):
         # Convert buffer to an image
         imagen3 = Image.open(buf)
 
-        if num_APs[0] > 0 and num_APs[1] > 0 and num_APs[2] > 0:
+    # **************************************************************************
+
+        if num_APs[0] > 0 and num_APs[1] > 0 and num_APs[2] > 0 and interference == True:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red', 'green'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
@@ -192,7 +215,7 @@ def main_function(plan_name, apch1, apch6, apch11, coord1, coord6, coord11):
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        elif num_APs[0] > 0 and num_APs[1] > 0:
+        if num_APs[0] > 0 and num_APs[1] > 0 and interference == True:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
@@ -211,7 +234,7 @@ def main_function(plan_name, apch1, apch6, apch11, coord1, coord6, coord11):
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        elif num_APs[0] > 0 and num_APs[2] > 0:
+        if num_APs[0] > 0 and num_APs[2] > 0 and interference == True:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
@@ -230,7 +253,7 @@ def main_function(plan_name, apch1, apch6, apch11, coord1, coord6, coord11):
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        elif num_APs[1] > 0 and num_APs[2] > 0:
+        if num_APs[1] > 0 and num_APs[2] > 0 and interference == True:
             cmap = plt.cm.colors.ListedColormap(['blue', 'red'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
@@ -249,7 +272,27 @@ def main_function(plan_name, apch1, apch6, apch11, coord1, coord6, coord11):
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-        else:
+        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:
             cmap = plt.cm.colors.ListedColormap(['blue'])
             plt.imshow(celdas, cmap=cmap)
             cbar = plt.colorbar()
@@ -268,90 +311,247 @@ def main_function(plan_name, apch1, apch6, apch11, coord1, coord6, coord11):
             # Convert buffer to an image
             imagen4 = Image.open(buf)
 
-    return [imagencober[0], imagencober[1], imagencober[2], imagen3, imagen4]
+    # **************************************************************************
+
+        if aps_int == 5 and interference == False:
+            cmap = plt.cm.colors.ListedColormap(['blue', 'red', 'green', 'yellow', 'green'])
+            plt.imshow(celdas, cmap=cmap)
+            cbar = plt.colorbar()
+            cbar.set_ticks([0, 1, 2])
+            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')
+            plt.axis("off")
+
+            # Save the plot to a buffer
+            buf = BytesIO()
+            plt.savefig(buf, format='png')
+            buf.seek(0)
+            plt.close()
+
+            # Convert buffer to an image
+            imagen4 = Image.open(buf)
 
-# plan visualization
-def load_plan_vi(mapa_seleccionado):
+        if aps_int == 4 and interference == False:
+            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_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')
+            plt.axis("off")
 
-    image_plan_path1 = os.path.join(images_file, mapa_seleccionado)
-    plan_image = Image.open(image_plan_path1)
+            # Save the plot to a buffer
+            buf = BytesIO()
+            plt.savefig(buf, format='png')
+            buf.seek(0)
+            plt.close()
+
+            # Convert buffer to an image
+            imagen4 = Image.open(buf)
+
+        if aps_int == 3 and interference == False:
+            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')
+            plt.axis("off")
+
+            # Save the plot to a buffer
+            buf = BytesIO()
+            plt.savefig(buf, format='png')
+            buf.seek(0)
+            plt.close()
+
+            # Convert buffer to an image
+            imagen4 = Image.open(buf)
+
+        if aps_int == 2 and interference == False:
+            cmap = plt.cm.colors.ListedColormap(['blue', 'red'])
+            plt.imshow(celdas, cmap=cmap)
+            cbar = plt.colorbar()
+            cbar.set_ticks([0, 1, 2])
+            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')
+            plt.axis("off")
+
+            # Save the plot to a buffer
+            buf = BytesIO()
+            plt.savefig(buf, format='png')
+            buf.seek(0)
+            plt.close()
+
+            # Convert buffer to an image
+            imagen4 = Image.open(buf)
+
+        if aps_int == 1 and interference == False:
+            cmap = plt.cm.colors.ListedColormap(['blue'])
+            plt.imshow(celdas, cmap=cmap)
+            cbar = plt.colorbar()
+            cbar.set_ticks([0, 1, 2])
+            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")
+
+            # Save the plot to a buffer
+            buf = BytesIO()
+            plt.savefig(buf, format='png')
+            buf.seek(0)
+            plt.close()
+
+            # Convert buffer to an image
+            imagen4 = Image.open(buf)
+
+    # **************************************************************************
+
+    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.figure(figsize=(3, 3))
+
     plt.imshow(plan_n)
-    plt.xticks(np.arange(0, 256, 50))
-    plt.yticks(np.arange(0, 256, 50))
+    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')
 
-    # Save the plot to a buffer
     buf = BytesIO()
     plt.savefig(buf, format='png')
     buf.seek(0)
     plt.close()
 
-    # Convert buffer to an image
     plan_im = Image.open(buf)
 
-    return plan_im
+    tick_positions = np.linspace(0, 256, 15)
+    tick_labels = np.linspace(0, 20, 15, dtype=int)
 
-with gr.Blocks() as demo:
+    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')
 
-    gr.Markdown("""
-    ## Fast Indoor Radio Propagation Prediction using Deep Learning
-    This app use deep learning models to radio map estimation (RME). RME entails estimating the received RF power based on spatial information maps.
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    plt.close()
 
-    Instructions for use:
+    plan_im_meters = Image.open(buf)
+
+    return plan_im, plan_im_meters
+
+def update_interface(enable_interference):
+    if enable_interference:
+        return {
+            map_dropdown : gr.update(visible=True),
+            upload_image : gr.update(visible=True),
+            ch1_input: gr.update(visible=True),
+            ch6_input: gr.update(visible=True),
+            ch11_input: gr.update(visible=True),
+            coords_ch1_input: gr.update(visible=True),
+            coords_ch6_input: gr.update(visible=True),
+            coords_ch11_input: gr.update(visible=True),
+            button1: gr.update(visible=True),
+            button2: gr.update(visible=True),
+            image_ap1 : gr.update(visible=False),
+            image_ap2 : gr.update(visible=False),
+            image_ch1 : gr.update(visible=True),
+            image_ch6 : gr.update(visible=True),
+            image_ch11 : gr.update(visible=True)
+        }
+    else:
+        return {
+            map_dropdown: gr.update(visible=True),
+            upload_image : gr.update(visible=True),
+            ch1_input: gr.update(visible=False),
+            ch6_input: gr.update(visible=False),
+            ch11_input: gr.update(visible=False),
+            coords_ch1_input: gr.update(visible=False),
+            coords_ch6_input: gr.update(visible=False),
+            coords_ch11_input: gr.update(visible=False),
+            simple_dropdown: gr.update(visible=True, interactive=True),
+            simple_coords: gr.update(visible=True, interactive=True),
+            image_ap1 : gr.update(visible=True),
+            image_ap2 : gr.update(visible=True),
+            image_ch1 : gr.update(visible=True),
+            image_ch6 : gr.update(visible=True),
+            image_ch11 : gr.update(visible=True)
+        }
 
-    - A predefined list of indoor floor plans is available for use.
-    - A maximum of (255,255) pixels is allowed for image size.
-    - Negative numbers are not allowed.
-    - The established format for the coordinates of each access point (AP) must be maintained.
-    - A maximum of 2 APs are allowed per channel.
+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.
     """)
 
+    enable_interference = gr.Checkbox(label="Enable Interference Analysis", value=True)
+
     with gr.Row():
-        # Input left panel
-        with gr.Column(scale=1):  # Scale to resize
-            map_dropdown = gr.Dropdown(choices=plan_images_list(), label="Select indoor plan")
+        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")
-            coords_ch1_input = gr.Textbox(label="Coordinate CH 1", placeholder="Format: (x1, y1), (x2, y2)")
-            coords_ch6_input = gr.Textbox(label="Coordinate CH 6", placeholder="Format: (x1, y1), (x2, y2)")
-            coords_ch11_input = gr.Textbox(label="Coordinate CH 11", placeholder="Format: (x1, y1), (x2, y2)")
+            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)
+
             button1 = gr.Button("Load plan")
             button2 = gr.Button("Predict coverage")
 
-        # Rigth panel
-        a_images = 320 # Size putput images
-
         with gr.Column(scale=3):
-            first_image_output = gr.Image(label="plan image", height=a_images, width=a_images)
-            # with gr.Row():
             with gr.Row():
-                image_ch1 = gr.Image(label="CH 1 coverage", height=a_images, width=a_images)
-                image_ch6 = gr.Image(label="CH 6 coverage", height=a_images, width=a_images)
-                image_ch11 = gr.Image(label="CH 11 coverage", height=a_images, width=a_images)
-
+                first_image_output = gr.Image(label="Plan image pixels")
+                second_image_output = gr.Image(label="Plan image meters")
             with gr.Row():
-                image_cover_final = gr.Image(label="Final coverage", height=a_images, width=a_images)
-                image_cells = gr.Image(label="Cells coverage", height=a_images, width=a_images)
-
-
-    # Buttons
-    button1.click(load_plan_vi, inputs=[map_dropdown], outputs=first_image_output)
-    button2.click(
-    lambda map_dropdown, ch1, ch6, ch11, coords1, coords6, coords11: main_function(
-        map_dropdown,
-        validate_input(ch1),
-        validate_input(ch6),
-        validate_input(ch11),
-        coords1,
-        coords6,
-        coords11,
-    ),
-    inputs=[map_dropdown, ch1_input, ch6_input, ch11_input, coords_ch1_input, coords_ch6_input, coords_ch11_input],
-    outputs=[image_ch1, image_ch6, image_ch11, image_cover_final, image_cells]
-)
+                image_ch1 = gr.Image(label="Coverage 1")
+                image_ch6 = gr.Image(label="Coverage 2")
+                image_ch11 = gr.Image(label="Coverage 3")
 
+                image_ap1 = gr.Image(label="Coverage 4", visible=False)
+                image_ap2 = gr.Image(label="Coverage 5", visible=False)
+            with gr.Row():
+                image_cover_final = gr.Image(label="Final coverage")
+                image_cells = gr.Image(label="Cells coverage")
+
+    enable_interference.change(update_interface, inputs=[enable_interference],
+                               outputs=[map_dropdown, upload_image,
+                                        ch1_input, ch6_input, ch11_input,
+                                        coords_ch1_input, coords_ch6_input, coords_ch11_input,
+                                        button1, button2,
+                                        simple_dropdown, simple_coords,
+                                        image_ch1, image_ch6, image_ch11,
+                                        image_ap1, image_ap2])
+
+    button1.click(load_plan_vi,
+                  inputs=[map_dropdown, upload_image], outputs=[first_image_output, second_image_output])
+
+    # Único bloque para el clic de button2
+    button2.click(main_function,
+                  inputs=[map_dropdown,
+                          enable_interference,
+                          simple_dropdown,
+                          simple_coords,
+                          ch1_input, ch6_input, ch11_input,
+                          coords_ch1_input, coords_ch6_input, coords_ch11_input],
+                  outputs=[image_ch1, image_ch6, image_ch11, image_ap1, image_ap2, image_cover_final, image_cells])
 
 demo.launch()