webtool_online_display_image_interpolation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import geopandas as gpd\n",
    "from ipyleaflet import Map, Marker, basemaps, basemap_to_tiles, GeoJSON\n",
    "from ipywidgets import Output, SelectionSlider, VBox, Image, RadioButtons, Text, Button, Layout\n",
    "from pathlib import Path\n",
    "import numpy as np\n",
    "import pyproj\n",
    "from IPython.display import display #, Image\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "from io import BytesIO\n",
    "from scipy.spatial import distance_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_project = Path().absolute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_save_merged = path_project / \"files/Europe/Europe_IGNF_grid_50km_intersection_tiles_centroid_BT.shp\"\n",
    "merged_tiles_centroid = gpd.read_file(str(path_save_merged))\n",
    "\n",
    "path_gdf_part = path_project /\"files/Europe/Europe_IGNF_grid_50km_all_albedo_final_BT.shp\"\n",
    "gdf = gpd.read_file(path_gdf_part)\n",
    "\n",
    "if gdf.crs != 'EPSG:4326':\n",
    "    gdf = gdf.to_crs('EPSG:4326')\n",
    "nb_tiles_y = 90 \n",
    "nb_tiles_y_French_Alps = 72\n",
    "nb_tiles_y_europe = 90 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_save_merged_bis= path_project / \"files/French_Alps/French_Alps_IGNF_grid_5km_intersection_tiles_centroid_BT.shp\"\n",
    "merged_tiles_centroid_bis = gpd.read_file(str(path_save_merged_bis))\n",
    "\n",
    "\n",
    "path_gdf_french_alps = path_project / \"files/French_Alps/French_Alps_IGNF_grid_5km_all_albedo_final_BT.shp\"\n",
    "gdf_bis = gpd.read_file(path_gdf_french_alps).to_crs(epsg=4326)\n",
    "if gdf_bis.crs != 'EPSG:4326':\n",
    "    gdf_bis = gdf_bis.to_crs('EPSG:4326')\n",
    "\n",
    "style_europe = {'color': 'black', 'weight': 2, 'fillOpacity': 0}\n",
    "style_french_alps = {'color': 'blue', 'weight': 2, 'fillOpacity': 0}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_centroid_Europe = path_project / \"files/Europe/Europe_IGNF_extent_centroid_coordinates.shp\"\n",
    "centroid_Europe = gpd.read_file(str(path_centroid_Europe))\n",
    "center_Europe = [centroid_Europe.loc[0,'latitude'], centroid_Europe.loc[0,'longitude']]\n",
    "zoom_level = 4\n",
    "layout = Layout(width='1000px', height='800px')\n",
    "m = Map(center=center_Europe, zoom=zoom_level, basemap=basemap_to_tiles(basemaps.CartoDB.Positron), layout=layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "geo_json_layer_europe = GeoJSON(data=gdf.__geo_interface__, style=style_europe)\n",
    "geo_json_layer_french_alps = GeoJSON(data=gdf_bis.__geo_interface__, style=style_french_alps)\n",
    "m.add_layer(geo_json_layer_europe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "global_coords = None\n",
    "best_tilt_interpolation = None\n",
    "gcr_value = 0.2\n",
    "albedo_value = 0.2\n",
    "id = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_area_change(change):\n",
    "    global current_tiles_centroid, nb_tiles_y\n",
    "    if change['new'] == 'French Alps':\n",
    "        m.remove_layer(geo_json_layer_europe)\n",
    "        m.add_layer(geo_json_layer_french_alps)\n",
    "        nb_tiles_y =nb_tiles_y_French_Alps\n",
    "        current_tiles_centroid = merged_tiles_centroid_bis\n",
    "    elif change['new'] == 'Europe':\n",
    "        m.remove_layer(geo_json_layer_french_alps)\n",
    "        m.add_layer(geo_json_layer_europe)\n",
    "        current_tiles_centroid = merged_tiles_centroid\n",
    "        nb_tiles_y = nb_tiles_y_europe\n",
    "    if global_coords:\n",
    "        handle_interaction(type='click', coordinates=global_coords)\n",
    "current_tiles_centroid = merged_tiles_centroid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "message_graph= Output()\n",
    "def display_message_graph():\n",
    "    message_graph.clear_output()\n",
    "    with message_graph:\n",
    "        print(f\"Select the parameters (Ground Coverage Ratio (GCR) and albedo), the scalebar normalization and the area \\nfor which the map of optimal tilt angle will be displayed :\")\n",
    "display_message_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "message= Output()\n",
    "def display_initial_message():\n",
    "    message.clear_output()\n",
    "    with message:\n",
    "        print(f\"Click on a location on the map or enter the coordinates to know the optimal tilt angle for south-facing bifacial PV plant \\nfor an albedo value of {albedo_value} and Ground Coverage Ratio of {gcr_value}:\")\n",
    "display_initial_message()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "slider_options = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.7]\n",
    "slider_GCR = SelectionSlider(\n",
    "    options=slider_options,\n",
    "    value=0.2, \n",
    "    description='GCR:', \n",
    "    continuous_update=False, \n",
    "    orientation='horizontal', \n",
    "    readout=True \n",
    ")\n",
    "def on_slider_change_GCR(change):\n",
    "    global gcr_value\n",
    "    gcr_value = slider_GCR.value\n",
    "    display_initial_message()\n",
    "    if global_coords:\n",
    "        handle_interaction(type='click', coordinates=global_coords)\n",
    "slider_GCR.observe(on_slider_change_GCR, names='value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "slider_options_albedo = [0.1, 0.2, 0.3, 0.4, 0.5]\n",
    "slider_albedo = SelectionSlider(\n",
    "    options=slider_options_albedo,\n",
    "    value=0.2,\n",
    "    description='Albedo:', \n",
    "    continuous_update=False, \n",
    "    orientation='horizontal',  \n",
    "    readout=True  \n",
    ")\n",
    "def on_slider_change_albedo(change):\n",
    "    global albedo_value\n",
    "    albedo_value = slider_albedo.value\n",
    "    display_initial_message()\n",
    "    if global_coords:\n",
    "        handle_interaction(type='click', coordinates=global_coords)\n",
    "slider_albedo.observe(on_slider_change_albedo, names='value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform_coordinates(lat, lon, target_proj='IGNF:ETRS89LAEA'):\n",
    "    wgs84 = pyproj.CRS('EPSG:4326')\n",
    "    target = pyproj.CRS(target_proj)\n",
    "    transformer = pyproj.Transformer.from_crs(wgs84, target, always_xy=True)\n",
    "    x, y = transformer.transform(lon, lat)\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_id_tiles(x, y,tiles_centroid ): \n",
    "    id = 0\n",
    "    for i in range(0, len(tiles_centroid)) : \n",
    "        top =  tiles_centroid.loc[i, 'top']\n",
    "        left = tiles_centroid.loc[i, 'left']\n",
    "        right = tiles_centroid.loc[i, 'right']\n",
    "        bottom = tiles_centroid.loc[i, 'bottom']\n",
    "        if x > left and x < right and y< top and y > bottom : \n",
    "            id = tiles_centroid.loc[i, \"id\"]\n",
    "            break\n",
    "    return id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_quarter(id, coords, tiles_centroid) : \n",
    "    index = tiles_centroid[tiles_centroid['id']==id].index\n",
    "    latitude = tiles_centroid.loc[index, 'latitude']\n",
    "    longitude = tiles_centroid.loc[index, 'longitude']\n",
    "    x_center, y_center = transform_coordinates(latitude, longitude, target_proj='IGNF:ETRS89LAEA')\n",
    "\n",
    "    lat_point = coords[0]\n",
    "    long_point = coords[1]\n",
    "    x_point, y_point = transform_coordinates(lat_point, long_point, target_proj='IGNF:ETRS89LAEA')\n",
    "\n",
    "    top = False\n",
    "    right = False\n",
    "    if y_point >  y_center : \n",
    "        top = True\n",
    "\n",
    "    if x_point > x_center : \n",
    "        right = True\n",
    "    \n",
    "    position = \"\"\n",
    "    if top== True and right == True : \n",
    "        position = \"top right\"\n",
    "    if top == True and right == False : \n",
    "        position = \"top left\"\n",
    "    if top == False and right == True : \n",
    "        position = \"bottom right\"\n",
    "    if top == False and right == False: \n",
    "        position = \"bottom left\"\n",
    "\n",
    "    return index, top, right, position, latitude, x_center"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_id_voisin(id, position, nb_tiles_y):\n",
    "    list_id_voisin = []\n",
    "    list_id_voisin.append(id)\n",
    "    if position == \"top right\": \n",
    "        list_id_voisin.append(id+nb_tiles_y)\n",
    "        list_id_voisin.append(id+nb_tiles_y-1)\n",
    "        list_id_voisin.append(id-1)\n",
    "    if position == \"top left\": \n",
    "        list_id_voisin.append(id-nb_tiles_y)\n",
    "        list_id_voisin.append(id-nb_tiles_y-1)\n",
    "        list_id_voisin.append(id-1) \n",
    "    if position == \"bottom right\": \n",
    "        list_id_voisin.append(id+nb_tiles_y)\n",
    "        list_id_voisin.append(id+nb_tiles_y+1)\n",
    "        list_id_voisin.append(id+1)\n",
    "    if position == \"bottom left\": \n",
    "        list_id_voisin.append(id-nb_tiles_y)\n",
    "        list_id_voisin.append(id-nb_tiles_y+1)\n",
    "        list_id_voisin.append(id+1) \n",
    "\n",
    "    return list_id_voisin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def obtain_list_coordinates_and_values(list_id_voisin, tiles_centroid, GCR = \"02\", ALBEDO = \"02\"):\n",
    "    list_index = []\n",
    "    list_best_tilt = []\n",
    "    list_coordinates = []\n",
    "    for id in list_id_voisin :\n",
    "        filtered_df = tiles_centroid[tiles_centroid['id'] == id]\n",
    "        if not filtered_df.empty:\n",
    "            index_temp = filtered_df.index[0]\n",
    "            list_index.append(index_temp)\n",
    "            latitude_temp = filtered_df.loc[index_temp, 'latitude']\n",
    "            longitude_temp = filtered_df.loc[index_temp, 'longitude']\n",
    "            x_temp, y_temp =  transform_coordinates(latitude_temp, longitude_temp, target_proj='IGNF:ETRS89LAEA')\n",
    "            list_coordinates.append([x_temp, y_temp])\n",
    "            list_best_tilt.append(filtered_df.loc[index_temp, f'BT_{GCR}_{ALBEDO}'])\n",
    "        else : \n",
    "            list_index.append(np.nan)\n",
    "            list_coordinates.append([np.nan, np.nan])\n",
    "            list_best_tilt.append(np.nan)\n",
    "    return list_coordinates, list_index, list_best_tilt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def idw_interpolation(list_coordinates, x_point, y_point, list_best_tilt, power=2):\n",
    "\n",
    "    list_coords_clean = [coord for i, coord in enumerate(list_coordinates) if not np.isnan(list_best_tilt[i])]\n",
    "    list_best_tilt_clean = [value for value in list_best_tilt if not np.isnan(value)]\n",
    "    list_coords_clean = np.array(list_coords_clean)\n",
    "    list_best_tilt_clean = np.array(list_best_tilt_clean)\n",
    "    unknown_point = [x_point, y_point]\n",
    "    unknown_point = np.array(unknown_point).reshape(1, -1)\n",
    "    distances = distance_matrix(list_coords_clean, unknown_point).flatten()\n",
    "    distances[distances == 0] = 1e-10\n",
    "    weights = 1 / np.power(distances, power)\n",
    "    interpolated_value = np.sum(weights * list_best_tilt_clean) / np.sum(weights)\n",
    "\n",
    "    return interpolated_value\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "latitude_input = Text(description=\"Latitude:\")\n",
    "longitude_input = Text(description=\"Longitude:\")\n",
    "submit_button = Button(description=\"Submit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "coord_output = Output()\n",
    "markers = []\n",
    "@coord_output.capture()\n",
    "def handle_interaction(**kwargs):\n",
    "    global global_coords, albedo_value, id, best_tilt_interpolation, coord_output\n",
    "\n",
    "    if kwargs.get('type') == 'click':\n",
    "        coords = kwargs.get('coordinates')\n",
    "\n",
    "        global_coords = coords\n",
    "        gcr_value = slider_GCR.value\n",
    "        albedo_value = slider_albedo.value\n",
    "        \n",
    "        if gcr_value != 0.05:\n",
    "            GCR = f\"0{int(gcr_value * 10)}\"\n",
    "        else: \n",
    "            GCR = \"005\"\n",
    "\n",
    "        ALBEDO = f'0{int(albedo_value*10)}'\n",
    "        \n",
    "        x, y = transform_coordinates(coords[0], coords[1])\n",
    "        id = find_id_tiles(x, y, current_tiles_centroid)\n",
    "        index, top, right, position, latitude, x_center = find_quarter(id, coords, current_tiles_centroid)\n",
    "        list_id_voisin = find_id_voisin(id, position, nb_tiles_y)\n",
    "        list_coordinates, list_index, list_best_tilt = obtain_list_coordinates_and_values(list_id_voisin,current_tiles_centroid,  GCR, ALBEDO)\n",
    "        if all(np.isnan(item) for item in list_best_tilt) == False: \n",
    "            best_tilt_interpolation = idw_interpolation(list_coordinates,x,y, list_best_tilt)\n",
    "            only_nan = False\n",
    "        else : \n",
    "            only_nan = True \n",
    "\n",
    "        coord_output.clear_output()\n",
    "        with coord_output:\n",
    "            \n",
    "            print(f'Coordinates clicked: [{coords[0]:.3f},{coords[1]:.3f}]')\n",
    "            if only_nan== False : \n",
    "                print(f'Best tilt of the tile: {list_best_tilt[0]}')\n",
    "                print(f'Best tilt interpolated from 4 nearest points : {best_tilt_interpolation:.3f}')\n",
    "            if only_nan: \n",
    "                print(f'The point is out of bounds!')\n",
    "        for marker in markers:\n",
    "            m.remove_layer(marker)\n",
    "        markers.clear()\n",
    "\n",
    "        marker = Marker(location=coords)\n",
    "        m.add_layer(marker)\n",
    "        markers.append(marker)\n",
    "\n",
    "m.on_interaction(handle_interaction)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "@coord_output.capture()\n",
    "def handle_submit_click(button):\n",
    "    \"\"\"Gère le clic sur le bouton Submit.\"\"\"\n",
    "    global global_coords, albedo_value, id, best_tilt_interpolation, coord_output\n",
    "\n",
    "    try:\n",
    "        lat = float(latitude_input.value)\n",
    "        lon = float(longitude_input.value)\n",
    "        coords = [lat, lon]    \n",
    "        global_coords = coords\n",
    "        \n",
    "        # Traitement similaire à ce que vous avez dans le code original pour un clic sur Submit\n",
    "        gcr_value = slider_GCR.value\n",
    "        albedo_value = slider_albedo.value\n",
    "\n",
    "        if gcr_value != 0.05:\n",
    "            GCR = f\"0{int(gcr_value * 10)}\"\n",
    "        else:\n",
    "            GCR = \"005\"\n",
    "\n",
    "        ALBEDO = f'0{int(albedo_value * 10)}'\n",
    "\n",
    "        x, y = transform_coordinates(coords[0], coords[1])\n",
    "        id = find_id_tiles(x, y, current_tiles_centroid)\n",
    "        index, top, right, position, latitude, x_center = find_quarter(id, coords, current_tiles_centroid)\n",
    "        list_id_voisin = find_id_voisin(id, position, nb_tiles_y)\n",
    "        list_coordinates, list_index, list_best_tilt = obtain_list_coordinates_and_values(list_id_voisin, current_tiles_centroid, GCR, ALBEDO)\n",
    "\n",
    "        if all(np.isnan(item) for item in list_best_tilt) == False:\n",
    "            best_tilt_interpolation = idw_interpolation(list_coordinates, x, y, list_best_tilt)\n",
    "            only_nan = False\n",
    "        else:\n",
    "            only_nan = True\n",
    "\n",
    "        # Mise à jour de la sortie\n",
    "        coord_output.clear_output()\n",
    "        with coord_output:\n",
    "            print(f'Coordinates entered: [{coords[0]:.3f},{coords[1]:.3f}]')\n",
    "            if not only_nan:\n",
    "                print(f'Best tilt of the tile: {list_best_tilt[0]}')\n",
    "                print(f'Best tilt interpolated from 4 nearest points: {best_tilt_interpolation:.3f}')\n",
    "            else:\n",
    "                print(f'The point is out of bounds!')\n",
    "\n",
    "        # Mise à jour du marqueur sur la carte\n",
    "        for marker in markers:\n",
    "            m.remove_layer(marker)\n",
    "        markers.clear()\n",
    "\n",
    "        marker = Marker(location=coords)\n",
    "        m.add_layer(marker)\n",
    "        markers.append(marker)\n",
    "    \n",
    "    except ValueError:\n",
    "        with coord_output:\n",
    "            coord_output.clear_output()\n",
    "            print(\"Please enter valid numeric values for latitude and longitude.\")\n",
    "        return\n",
    "\n",
    "\n",
    "submit_button.on_click(handle_submit_click)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_image(slider1_value, slider2_value, radio_group1_value, radio_group2_value, radio_group3_value):\n",
    "    if radio_group1_value == \"Optimal tilt angle\" :  \n",
    "        variable = \"BT\"\n",
    "    elif radio_group1_value == \"Irradiation gain\" : \n",
    "        variable = \"GI\"\n",
    "    else : \n",
    "        variable = \"Bk\"\n",
    "\n",
    "    if radio_group2_value == \"By GCR\" : \n",
    "        normalisation = \"norm_GCR\"\n",
    "    elif radio_group2_value == \"By albedo\" : \n",
    "        normalisation =\"norm_albedo\"\n",
    "    elif radio_group2_value == \"By all values\" : \n",
    "        normalisation = \"norm_all\"\n",
    "    else : \n",
    "        normalisation = \"normal\"\n",
    "\n",
    "    GCR_value = str(slider1_value)\n",
    "    GCR_value = GCR_value[2:]\n",
    "    albedo_value = str(slider2_value)\n",
    "    albedo_value = albedo_value[2:]\n",
    "    norm = normalisation\n",
    "    if norm == \"normal\" : \n",
    "        norm =\"\"\n",
    "    else : \n",
    "        norm = norm +\"_\"\n",
    "    \n",
    "    if radio_group3_value == \"Europe\" : \n",
    "        img_path = path_project / f'Graphics/Europe/MAP_{variable}/{normalisation}/map_grid_50km_GCR_0{GCR_value}_albedo_0{albedo_value}_{norm}{variable}.png'\n",
    "    else : \n",
    "        img_path = f'Graphics/French_Alps/MAP_{variable}/{normalisation}/map_grid_5km_GCR_0{GCR_value}_albedo_0{albedo_value}_{norm}{variable}_AURA_PACA.png'\n",
    "\n",
    "    img = mpimg.imread(img_path)\n",
    "\n",
    "    buffer = BytesIO()\n",
    "    plt.imsave(buffer, img)\n",
    "    buffer.seek(0)\n",
    "    \n",
    "    return buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "radio_group1 = RadioButtons(\n",
    "    options = ['Optimal tilt angle', 'Irradiation gain', 'Irradiation at best tilt'],\n",
    "    description='Variable',\n",
    "    disabled=False\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "radio_group2 = RadioButtons(\n",
    "    options=['By GCR', 'By albedo', 'By all values', 'No normalisation'],\n",
    "    description='Scalebar normalisation',\n",
    "    disabled=False\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "radio_group3 = RadioButtons(\n",
    "    options=['Europe', 'French Alps'],\n",
    "    description='Area',\n",
    "    disabled=False\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "layout = Layout(width='1000px') \n",
    "image_widget = Image(value=get_image(slider_GCR.value, slider_albedo.value, radio_group1.value, radio_group2.value, radio_group3.value).read(), format='png', layout=layout)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_image(*args):\n",
    "    image_widget.value = get_image(slider_GCR.value, slider_albedo.value, radio_group1.value, radio_group2.value, radio_group3.value).read()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "slider_GCR.observe(update_image, names='value')\n",
    "slider_albedo.observe(update_image, names='value')\n",
    "radio_group1.observe(update_image, names='value')\n",
    "radio_group2.observe(update_image, names='value')\n",
    "radio_group3.observe(update_image, names='value')\n",
    "radio_group3.observe(on_area_change, names='value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "vbox = VBox([message_graph, slider_GCR, slider_albedo, radio_group1, radio_group2, radio_group3, image_widget, m,message, latitude_input, longitude_input, submit_button, coord_output])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bf80fc87ae2849f7af62da8b4cf8b6d6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': 'Select the parameters (Ground Coverage Ratio (GCR) …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(vbox)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}