mvp of flood map connected to GFM with some local storage for earlier requested areas

app/pages/1_🌍_Flood_extent_analysis.py

@@ -1,10 +1,11 @@
-"""Flood extent analysis page for Streamlit app."""
+import json
+from pathlib import Path
 
 import folium
 import streamlit as st
-from folium.plugins import Draw, Geocoder, MiniMap
+from folium.plugins import Draw
 from src.config_parameters import params
-from src.gfm import download_stuff, visualise_stuff
+from src.gfm import download_gfm_geojson, get_existing_flood_geojson
 from src.utils import (
     add_about,
     set_tool_page_style,
@@ -27,98 +28,115 @@ st.markdown("# Flood extent analysis")
 # Set page style
 set_tool_page_style()
 
-# Output_created is useful to decide whether the bottom panel with the
-# output map should be visualised or not
-if "output_created" not in st.session_state:
-    st.session_state.output_created = True
-
-
-# Function to be used to hide bottom panel (when setting parameters for a
-# new analysis)
-def callback():
-    """Set output created to zero: reset tool."""
-    st.session_state.output_created = True
-
-
 # Create two rows: top and bottom panel
 row1 = st.container()
-row2 = st.container()
 # Crate two columns in the top panel: input map and paramters
 col1, col2 = row1.columns([2, 1])
+feat_group_selected_area = folium.FeatureGroup(name="selected_area")
 with col1:
+    area_type = st.radio(label="", options=["Existing area", "New area"])
+    if area_type == "Existing area":
+        with open("./bboxes/bboxes.json", "r") as f:
+            bboxes = json.load(f)
+        selected_area = st.selectbox("Select saved area", options=bboxes.keys())
+        geojson_selected_area = folium.GeoJson(bboxes[selected_area])
+        feat_group_selected_area.add_child(geojson_selected_area)
+        geojson_flood_area = get_existing_flood_geojson(selected_area)
+        feat_group_selected_area.add_child(geojson_flood_area)
+
+    elif area_type == "New area":
+        new_area_name = st.text_input("Area name")
     # Add collapsable container for input map
     with st.expander("Input map", expanded=True):
         # Create folium map
-        Map = folium.Map(
-            location=[52.205276, 0.119167],
-            zoom_start=3,
-            control_scale=True,
-        )
+        # call to render Folium map in Streamlit
+        folium_map = folium.Map([39, 0], zoom_start=8)
         # Add drawing tools to map
-        Draw(
-            export=False,
-            draw_options={
-                "circle": False,
-                "polyline": False,
-                "polygon": False,
-                "rectangle": True,
-                "marker": False,
-                "circlemarker": False,
-            },
-        ).add_to(Map)
-        # Add search bar with geocoder to map
-        Geocoder(add_marker=False).add_to(Map)
-        # Add minimap to map
-        MiniMap().add_to(Map)
-        # Export map to Streamlit
-        input_map = st_folium(Map, width=800, height=600)
+        if area_type == "New area":
+            Draw(
+                export=False,
+                draw_options={
+                    "circle": False,
+                    "polyline": False,
+                    "polygon": False,
+                    "rectangle": True,
+                    "marker": False,
+                    "circlemarker": False,
+                },
+            ).add_to(folium_map)
+
+        m = st_folium(
+            folium_map,
+            width=800,
+            height=450,
+            feature_group_to_add=feat_group_selected_area,
+        )
 with col2:
     # Add collapsable container for image dates
     with st.expander("Choose Image Dates"):
-        # Callback is added, so that, every time a parameters is changed,
-        # the bottom panel containing the output map is hidden
-        start_date = st.date_input(
-            "Start date",
-            on_change=callback,
-        )
-        end_date = st.date_input(
-            "End date",
-            on_change=callback,
-        )
+        start_date = st.date_input("Start date")
+        end_date = st.date_input("End date")
     # Add collapsable container for parameters
     with st.expander("Choose Parameters"):
         # Add slider for threshold
         st.text("Add relevant (API) parameters here")
-    # Button for computation
-    submitted = st.button("Get flood extent")
-    # Introduce date validation
-    check_dates = start_date <= end_date
-    # Introduce drawing validation (a polygon needs to exist)
-    check_drawing = (
-        input_map["all_drawings"] != [] and input_map["all_drawings"] is not None
-    )
-# What happens when button is clicked on?
+
+    # Button to trigger GFM data retrieval
+    if area_type == "New area":
+        button_text = "Get new flood extent"
+    else:
+        button_text = "Update flood extent"
+    submitted = st.button(button_text)
+
+
+# If the button is clicked do the following
 if submitted:
     with col2:
+        # Some basic validation on dates and that there's an area if relevant
+        get_gfm = True
+        check_dates = start_date <= end_date
+        if area_type == "New area":
+            check_drawing = m["all_drawings"] != [] and m["all_drawings"] is not None
+
         # Output error if dates are not valid
         if not check_dates:
             st.error("Make sure that the dates were inserted correctly")
+            get_gfm = False
         # Output error if no polygons were drawn
-        elif not check_drawing:
-            st.error("No region selected.")
-        else:
-            # Add output for computation
-            with st.spinner("Computing... Please wait..."):
-                # Extract coordinates from drawn polygon
-                coords = input_map["all_drawings"][-1]["geometry"]["coordinates"][0]
-                print(f"Coords: {coords}")
-                # Create geometry from coordinates
-                download_stuff(coords)
-                st.session_state.output_created = True
-
-# If computation was successful, create output map in bottom panel
-if st.session_state.output_created:
-    with row2:
-        # Add collapsable container for output map
-        with st.expander("Output map", expanded=True):
-            visualise_stuff()
+        if area_type == "New area":
+            if not check_drawing:
+                st.error("Please create a region using the rectangle tool on the map.")
+                get_gfm = False
+            elif new_area_name == "":
+                st.error("Please provide a name for the new area")
+                get_gfm = False
+
+        # Only if checks pass go and get the GFM data
+        if get_gfm:
+            if area_type == "Existing area":
+                area_name = selected_area
+            elif area_type == "New area":
+                area_name = new_area_name
+
+            # Show loader because it will take a while
+            with st.spinner("Getting GFM files... Please wait..."):
+                # If a new area save the bounding box
+                if area_type == "New area":
+                    # Save bounding box
+                    with open("./bboxes/bboxes.json", "r") as f:
+                        bboxes = json.load(f)
+                        selected_area_geojson = m["all_drawings"][-1]
+                        bboxes[new_area_name] = selected_area_geojson
+                    with open("./bboxes/bboxes.json", "w") as f:
+                        json.dump(bboxes, f)
+
+                    # Download files, for a new area also get coordinates to save to GFM
+                    coords = selected_area_geojson["geometry"]["coordinates"][0]
+                    download_gfm_geojson(area_name, new_coordinates=coords)
+
+                # For an existing area just get the latest update from GFM
+                if area_type == "Existing area":
+                    download_gfm_geojson(area_name)
+
+            # Display that getting the files is finished
+            st.markdown("Getting GFM files finished")

app/src/gfm.py

@@ -7,12 +7,14 @@ from pathlib import Path
 import folium
 import requests
 from dotenv import load_dotenv
-from streamlit_folium import st_folium
 
 load_dotenv()
 
 
-def download_stuff(coordinates):
+def download_gfm_geojson(area_name, new_coordinates=None, output_file_path=None):
+    """
+    Should provide an existing area name or a new area name with new_coordinates
+    """
     username = os.environ["gfm_username"]
     password = os.environ["gfm_password"]
     base_url = "https://api.gfm.eodc.eu/v1"
@@ -28,25 +30,28 @@ def download_stuff(coordinates):
     header = {"Authorization": f"bearer {access_token}"}
     print("logged in")
 
-    # Create area of impact
-    create_aoi_url = f"{base_url}/aoi/create"
+    # Only if new coordinates are provided create the AOI in GFM
+    if new_coordinates:
+        # Create area of impact
+        create_aoi_url = f"{base_url}/aoi/create"
 
-    payload = {
-        "aoi_name": "new_area",
-        "description": "new_area",
-        "user_id": user_id,
-        "geoJSON": {"type": "Polygon", "coordinates": [coordinates]},
-    }
+        payload = {
+            "aoi_name": area_name,
+            "description": area_name,
+            "user_id": user_id,
+            "geoJSON": {"type": "Polygon", "coordinates": [new_coordinates]},
+        }
+
+        r = requests.post(url=create_aoi_url, json=payload, headers=header)
+        print("Posted new AOI")
 
-    r = requests.post(url=create_aoi_url, json=payload, headers=header)
-    print(r.text)
-    print("Posted new AOI")
     # Get Area of Impact
     aoi_url = f"{base_url}/aoi/user/{user_id}"
-
     response = requests.get(aoi_url, headers=header)
+
+    # TODO: now only getting the first AOI, should extend to getting the whole list and unioning the geojsons
     for aoi in response.json()["aois"]:
-        if aoi["aoi_name"] == "new_area":
+        if aoi["aoi_name"] == area_name:
             aoi_id = aoi["aoi_id"]
             break
 
@@ -62,24 +67,31 @@ def download_stuff(coordinates):
     download_link = response.json()["download_link"]
     print("Got download link")
 
+    # Set output file path and create directory if it doesn't exist
+    if not output_file_path:
+        output_file_path = f"./output/{area_name}"
+
+    Path(output_file_path).mkdir(parents=True, exist_ok=True)
+
     # Download and unzip file
-    for f in Path("./output").glob("*"):
+    for f in Path(output_file_path).glob("*"):
         f.unlink()
     r = requests.get(download_link)
     with zipfile.ZipFile(io.BytesIO(r.content)) as z:
-        z.extractall(str(Path("./output")))
+        z.extractall(str(Path(output_file_path)))
+
 
+def get_existing_flood_geojson(area_name, output_file_path=None):
+    """
+    Getting a saved GFM flood geojson in an output folder of GFM files
+    """
+    if not output_file_path:
+        output_file_path = f"./output/{area_name}"
 
-def visualise_stuff():
-    # get geosjon with floods
-    for f in Path("./output").glob("*"):
+    for f in Path(output_file_path).glob("*"):
         if "FLOOD" in str(f) and "geojson" in str(f):
             geojson_path = f
+            break
 
-    # Create map
-    flood_geojson = json.load(open(geojson_path))
-
-    m = folium.Map([54, -2], zoom_start=7)
-    folium.GeoJson(flood_geojson, name="geojson").add_to(m)
-    m
-    st_folium(m, width=800, height=450, returned_objects=[])
+    flood_geojson = folium.GeoJson(json.load(open(geojson_path)))
+    return flood_geojson

bboxes/bboxes.json

@@ -0,0 +1 @@
+{"Denia": {"type": "Feature", "properties": {}, "geometry": {"type": "Polygon", "coordinates": [[[-0.387268, 38.786204], [-0.387268, 38.967951], [0.222473, 38.967951], [0.222473, 38.786204], [-0.387268, 38.786204]]]}}, "Test": {"type": "Feature", "properties": {}, "geometry": {"type": "Polygon", "coordinates": [[[-1.779785, 39.656456], [-1.779785, 39.888665], [-0.977783, 39.888665], [-0.977783, 39.656456], [-1.779785, 39.656456]]]}}, "Gambia": {"type": "Feature", "properties": {}, "geometry": {"type": "Polygon", "coordinates": [[[-16.864014, 12.972442], [-16.864014, 13.83808], [-13.370361, 13.83808], [-13.370361, 12.972442], [-16.864014, 12.972442]]]}}}