changes silvia date ranges and aoi merging

app/pages/1_🌍_Flood_extent_analysis.py

@@ -5,7 +5,7 @@ import folium
 import streamlit as st
 from folium.plugins import Draw
 from src.config_parameters import params
-from src.gfm import download_gfm_geojson, get_existing_flood_geojson
+from src.gfm import download_gfm_geojson, get_existing_flood_geojson, sync_cached_data
 from src.utils import (
     add_about,
     set_tool_page_style,
@@ -28,21 +28,46 @@ st.markdown("# Flood extent analysis")
 # Set page style
 set_tool_page_style()
 
+# Sync cached data
+# ! WARNING: will erase your output folder
+# # # sync_cached_data()
+
 # Create two rows: top and bottom panel
 row1 = 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"])
+    area_type = st.radio(
+        label="Area Type",
+        options=["Existing area", "New area"],
+        label_visibility="hidden",
+    )
     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)
+
+        # retrieve and select available dates
+        if selected_area:
+            available_date_ranges = list(
+                bboxes[selected_area].keys()
+            )  # will be used again below
+            selected_date_range = st.selectbox(
+                "Select available date range", options=available_date_ranges
+            )
+
+            # display the bounding box
+            bounding_box = bboxes[selected_area][selected_date_range]["bounding_box"]
+            geojson_selected_area = folium.GeoJson(bounding_box)
+            feat_group_selected_area.add_child(geojson_selected_area)
+
+            # 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, selected_date_range
+            )
+            feat_group_selected_area.add_child(geojson_flood_area)
 
     elif area_type == "New area":
         new_area_name = st.text_input("Area name")
@@ -51,6 +76,15 @@ with col1:
         # Create folium map
         # call to render Folium map in Streamlit
         folium_map = folium.Map([39, 0], zoom_start=8)
+        # check if the FeatureGroup has any children (i.e., layers added)
+        if len(feat_group_selected_area._children) > 0:
+            # if there is data, fit the map to the bounds
+            folium_map.fit_bounds(feat_group_selected_area.get_bounds())
+        else:
+            # if there is no data, set a default view
+            # this is necessary to start up the page
+            folium_map = folium.Map(location=[39, 0], zoom_start=8)
+
         # Add drawing tools to map
         if area_type == "New area":
             Draw(
@@ -120,23 +154,47 @@ if submitted:
 
             # 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
+                    # Convert date input into a string format for JSON storage
+                    date_range_str = f"{start_date}_to_{end_date}"
+
+                    # Load existing bboxes
                     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
+
+                    # Get the drawn area
+                    selected_area_geojson = m["all_drawings"][-1]
+
+                    # If the area doesn't exist, create it
+                    if new_area_name not in bboxes:
+                        bboxes[new_area_name] = {}
+
+                    # Save the new bounding box under the date range key
+                    bboxes[new_area_name][date_range_str] = {
+                        "bounding_box": selected_area_geojson,
+                        "flood_files": [],  # Will be populated when files are downloaded
+                    }
+
+                    # Write the updated data back to file
                     with open("./bboxes/bboxes.json", "w") as f:
-                        json.dump(bboxes, f)
+                        json.dump(bboxes, f, indent=4)
 
-                    # Download files, for a new area also get coordinates to save to GFM
+                    # Download files, also getting coordinates for GFM
                     coords = selected_area_geojson["geometry"]["coordinates"][0]
-                    download_gfm_geojson(area_name, new_coordinates=coords)
+                    # download_gfm_geojson(area_name, new_coordinates=coords)
+                    download_gfm_geojson(
+                        area_name,
+                        bbox=bboxes[new_area_name][date_range_str]["bounding_box"],
+                        new_coordinates=coords,
+                    )
 
                 # For an existing area just get the latest update from GFM
                 if area_type == "Existing area":
-                    download_gfm_geojson(area_name)
+                    # download_gfm_geojson(area_name)
+                    download_gfm_geojson(
+                        selected_area,
+                        bbox=bboxes[selected_area][selected_date_range]["bounding_box"],
+                    )
 
             # Display that getting the files is finished
             st.markdown("Getting GFM files finished")

app/src/gfm.py

@@ -1,17 +1,60 @@
 import io
 import json
 import os
+import warnings
 import zipfile
 from pathlib import Path
 
 import folium
 import requests
 from dotenv import load_dotenv
+from shapely.geometry import MultiPolygon, shape
+from shapely.ops import unary_union
 
 load_dotenv()
 
 
-def download_gfm_geojson(area_name, new_coordinates=None, output_file_path=None):
+class FloodGeoJsonError(Exception):
+    """Custom exception for errors in fetching flood GeoJSON files."""
+
+    pass
+
+
+def sync_cached_data(bboxes_path="./bboxes/bboxes.json", output_dir="./output"):
+    """
+    Ensures that all areas in bboxes.json have a corresponding folder in ./output/.
+    Removes any area entry from bboxes.json that does not have an output folder.
+    """
+    try:
+        # Load existing bounding boxes
+        with open(bboxes_path, "r") as f:
+            bboxes = json.load(f)
+
+        # Get a set of existing output folders
+        existing_folders = {
+            folder.name for folder in Path(output_dir).iterdir() if folder.is_dir()
+        }
+
+        # Remove entries from bboxes.json if the folder does not exist
+        updated_bboxes = {
+            area: data for area, data in bboxes.items() if area in existing_folders
+        }
+
+        # If changes were made, overwrite bboxes.json
+        if len(updated_bboxes) != len(bboxes):
+            with open(bboxes_path, "w") as f:
+                json.dump(updated_bboxes, f, indent=4)
+            print(f"Updated {bboxes_path}: Removed missing areas.")
+        else:
+            print("All areas have matching folders.")
+
+    except FileNotFoundError:
+        print(f"Error: {bboxes_path} not found.")
+    except json.JSONDecodeError:
+        print(f"Error: {bboxes_path} is not a valid JSON file.")
+
+
+def download_gfm_geojson(area_name, bbox, new_coordinates=None, output_file_path=None):
     """
     Should provide an existing area name or a new area name with new_coordinates
     """
@@ -54,6 +97,35 @@ def download_gfm_geojson(area_name, new_coordinates=None, output_file_path=None)
         if aoi["aoi_name"] == area_name:
             aoi_id = aoi["aoi_id"]
             break
+    #         print(aoi)
+
+    # # Collect all matching AOIs (same name)
+    # matching_geometries = []
+    # for aoi in response.json()["aois"]:
+    #     if aoi["aoi_name"] == area_name:
+    #         geojson_geometry = aoi["geoJSON"]["geometry"]
+    #         matching_geometries.append(shape(geojson_geometry))
+
+    # if not matching_geometries:
+    #     raise ValueError(f"No AOIs found for area name: {area_name}")
+
+    # # Merge all matching AOI geometries into a single unified polygon
+    # merged_geometry = unary_union(matching_geometries)
+
+    # # Handle MultiPolygon cases (if AOIs are disjointed)
+    # if merged_geometry.geom_type == "MultiPolygon":
+    #     merged_geometry = MultiPolygon([p for p in merged_geometry])
+
+    # # Convert back to GeoJSON
+    # merged_geojson = {
+    #     "type": "Feature",
+    #     "properties": {"aoi_name": area_name},
+    #     "geometry": json.loads(json.dumps(merged_geometry.__geo_interface__)),
+    # }
+
+    # print(f"Merged {len(matching_geometries)} AOIs into one for '{area_name}'.")
+
+    # return merged_geojson
 
     # Get product id
     prod_url = f"{base_url}/aoi/{aoi_id}/products"
@@ -76,22 +148,41 @@ def download_gfm_geojson(area_name, new_coordinates=None, output_file_path=None)
     # Download and unzip file
     for f in Path(output_file_path).glob("*"):
         f.unlink()
+    print("Donwloading...")
     r = requests.get(download_link)
+    print("Extracting zip...")
     with zipfile.ZipFile(io.BytesIO(r.content)) as z:
         z.extractall(str(Path(output_file_path)))
+    print("Done!")
 
 
-def get_existing_flood_geojson(area_name, output_file_path=None):
+def get_existing_flood_geojson(area_name, date_range, output_file_path=None):
     """
-    Getting a saved GFM flood geojson in an output folder of GFM files
+    Getting a saved GFM flood geojson in an output folder of GFM files. Merge in one feature group if multiple.
     """
+
     if not output_file_path:
-        output_file_path = f"./output/{area_name}"
+        output_file_path = f"./output/{area_name}/{date_range}"
+
+    # Ensure the output directory exists
+    # if not Path(output_file_path).exists():
+    #     raise FloodGeoJsonError(f"Error: Output folder '{output_file_path}' does not exist.")
+
+    # Combine multiple flood files into a FeatureGroup
+    flood_geojson_group = folium.FeatureGroup(name=f"{area_name} Floods {date_range}")
+
+    for flood_file in Path(output_file_path).glob("*FLOOD*.geojson"):
+        with open(flood_file, "r") as f:
+            geojson_data = json.load(f)
+            flood_layer = folium.GeoJson(geojson_data)
+            flood_geojson_group.add_child(flood_layer)
+
+    # TODO: consider merging multiple flood layers into one, to avoid overlap
+
+    return flood_geojson_group
 
-    for f in Path(output_file_path).glob("*"):
-        if "FLOOD" in str(f) and "geojson" in str(f):
-            geojson_path = f
-            break
 
-    flood_geojson = folium.GeoJson(json.load(open(geojson_path)))
-    return flood_geojson
+if __name__ == "__main__":
+    # download_gfm_geojson('Catania')
+    gj = get_existing_flood_geojson("Albufera Floods")
+    print(type(gj))