Fix EE and Wayback Imagery

app.py

@@ -78,7 +78,7 @@ def get_gdf_from_url(url):
     """Downloads and reads a KML/GeoJSON from a URL."""
     if not url or not url.strip():
         return None
-    
+
     # Handle Google Drive URLs
     if "drive.google.com" in url:
         if "/file/d/" in url:
@@ -153,7 +153,7 @@ def is_valid_polygon(geometry_gdf):
     geometry = geometry_gdf.geometry.item()
     return (geometry.type == 'Polygon') and (not geometry.is_empty)
 
-def add_geometry_to_map(m, geometry_gdf, buffer_geometry_gdf, opacity=0.0):
+def add_geometry_to_map(m, geometry_gdf, buffer_geometry_gdf, opacity=0.3):
     """Adds geometry and its buffer to a folium map."""
     if buffer_geometry_gdf is not None and not buffer_geometry_gdf.empty:
         folium.GeoJson(
@@ -174,28 +174,46 @@ def get_wayback_data():
     try:
         url = "https://wayback.maptiles.arcgis.com/arcgis/rest/services/World_Imagery/MapServer/WMTS/1.0.0/WMTSCapabilities.xml"
         response = requests.get(url)
-        response.raise_for_status()
+        response.raise_for_status()  # Ensure request was successful
+
+        # Parse XML
         root = ET.fromstring(response.content)
+
         ns = {
-            "wmts": "http://www.opengis.net/wmts/1.0",
-            "ows": "http://www.opengis.net/ows/1.1",
+            "wmts": "https://www.opengis.net/wmts/1.0",
+            "ows": "https://www.opengis.net/ows/1.1",
+            "xlink": "https://www.w3.org/1999/xlink",
         }
+
+        # Use a robust XPath to find all 'Layer' elements anywhere in the document.
+        # This is less brittle than specifying the full path.
         layers = root.findall(".//wmts:Contents/wmts:Layer", ns)
+
         layer_data = []
         for layer in layers:
             title = layer.find("ows:Title", ns)
-            resource = layer.find("wmts:ResourceURL", ns)
-            if title is not None and resource is not None:
-                layer_data.append({
-                    "Title": title.text,
-                    "ResourceURL_Template": resource.get("template")
-                })
+            identifier = layer.find("ows:Identifier", ns)
+            resource = layer.find("wmts:ResourceURL", ns)  # Tile URL template
+
+            title_text = title.text if title is not None else "N/A"
+            identifier_text = identifier.text if identifier is not None else "N/A"
+            url_template = resource.get("template") if resource is not None else "N/A"
+
+            layer_data.append({"Title": title_text, "ResourceURL_Template": url_template})
+
         wayback_df = pd.DataFrame(layer_data)
-        wayback_df["date"] = pd.to_datetime(wayback_df["Title"].str.extract(r"(\d{4}-\d{2}-\d{2})")[0], errors="coerce")
+        wayback_df["date"] = pd.to_datetime(wayback_df["Title"].str.extract(r"(\d{4}-\d{2}-\d{2})").squeeze(), errors="coerce")
         wayback_df.set_index("date", inplace=True)
-        return wayback_df.sort_index()
+        return wayback_df
+
+    except requests.exceptions.RequestException as e:
+        print(f"Could not fetch Wayback data from URL: {e}")
+        return pd.DataFrame()
+    except ET.ParseError as e:
+        print(f"Could not parse Wayback XML data: {e}")
+        return pd.DataFrame()
     except Exception as e:
-        print(f"Could not fetch Wayback data: {e}")
+        print(f"An unexpected error occurred in get_wayback_data: {e}")
         return pd.DataFrame() # Return empty dataframe on failure
 
 def add_indices(image, nir_band, red_band, blue_band, green_band, evi_vars):
@@ -301,12 +319,15 @@ def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
 
     progress(0.5, desc="Generating map and stats...")
 
-    # Create map
-    m = folium.Map(location=[geometry_gdf.to_crs(4326).centroid.y.iloc[0], geometry_gdf.to_crs(4326).centroid.x.iloc[0]], zoom_start=15)
+    # Create map - initialize without a specific location
+    m = folium.Map()
+
     if not WAYBACK_DF.empty:
-        first_item = WAYBACK_DF.iloc[0]
+        # Select the last row, which is the most recent date after sorting
+        latest_item = WAYBACK_DF.iloc[0]
+        print(latest_item)
         wayback_url = (
-            first_item["ResourceURL_Template"]
+            latest_item["ResourceURL_Template"]
             .replace("{TileMatrixSet}", "GoogleMapsCompatible")
             .replace("{TileMatrix}", "{z}")
             .replace("{TileRow}", "{y}")
@@ -314,12 +335,22 @@ def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
         )
         folium.TileLayer(
             tiles=wayback_url,
-            attr='Esri, i-cubed, USDA, USGS, AEX, GeoEye, Getmapping, Aerogrid, IGN, IGP, UPR-EGP, and the GIS User Community',
-            name="Esri Satellite"
+            attr=f"Esri, i-cubed, USDA, USGS, AEX, GeoEye, Getmapping, Aerogrid, IGN, IGP, UPR-EGP, and the GIS User Community | Imagery Date: {latest_item.name.strftime('%Y-%m-%d')}",
+            name="Latest Esri Satellite"
         ).add_to(m)
-    m.add_child(folium.LayerControl())
+
+    # Add geometries to the map
     m = add_geometry_to_map(m, geometry_gdf, buffer_geometry_gdf, opacity=0.3)
 
+    # Add a layer control panel
+    m.add_child(folium.LayerControl())
+
+    # Fit the map view to the bounds of the geometry
+    bounds = geometry_gdf.to_crs(epsg=4326).total_bounds
+    map_bounds = [[bounds[1], bounds[0]], [bounds[3], bounds[2]]] # Format: [[south, west], [north, east]]
+    m.fit_bounds(map_bounds, padding=(10, 10))
+
+
     # Generate stats
     stats_df = pd.DataFrame({
         "Area (ha)": [geometry_gdf.area.item() / 10000],
@@ -334,7 +365,6 @@ def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
     progress(1, desc="Done!")
     return m._repr_html_(), None, stats_df, geometry_json, buffer_geometry_json
 
-
 def calculate_indices(
     geometry_json, buffer_geometry_json, veg_indices, evi_vars, date_range,
     min_year, max_year, progress=gr.Progress()
@@ -351,7 +381,7 @@ def calculate_indices(
         # Convert to EE geometry
         ee_geometry = ee.Geometry(json.loads(geometry_gdf.to_crs(4326).to_json())['features'][0]['geometry'])
         buffer_ee_geometry = ee.Geometry(json.loads(buffer_geometry_gdf.to_crs(4326).to_json())['features'][0]['geometry'])
-        
+
         # Date ranges
         start_day, start_month = date_range[0].day, date_range[0].month
         end_day, end_month = date_range[1].day, date_range[1].month
@@ -468,7 +498,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
 
 
     # --- Event Handlers ---
-    
+
     def process_on_load(request: gr.Request):
         """Checks for a 'file_url' query parameter when the app loads and populates the URL input field."""
         file_url = request.query_params.get("file_url")
@@ -485,22 +515,34 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
     def calculate_wrapper(geometry_json, buffer_geometry_json, veg_indices,
                           g, c1, c2, l, c, start_date_str, end_date_str,
                           min_year, max_year, progress=gr.Progress()):
-        """Wrapper to parse inputs before calling the main calculation function."""
+        """Wrapper to parse inputs and handle outputs for the main calculation function."""
         try:
+            # Prepare inputs for the main function
             evi_vars = {'G': g, 'C1': c1, 'C2': c2, 'L': l, 'C': c}
             start_month, start_day = map(int, start_date_str.split('-'))
             end_month, end_day = map(int, end_date_str.split('-'))
             date_range = (datetime(2000, start_month, start_day), datetime(2000, end_month, end_day))
 
-            error, df, plots, msg = calculate_indices(
+            # Call the main calculation function
+            error_msg, df, plots, success_msg = calculate_indices(
                 geometry_json, buffer_geometry_json, veg_indices,
                 evi_vars, date_range, int(min_year), int(max_year), progress
             )
+
+            # Determine the final status message to display
+            status_message = error_msg if error_msg else success_msg
+            
+            # Select the first plot to display, if any exist
             first_plot = plots[0] if plots else None
-            return error, df, first_plot, msg
+            
+            # Return a clean set of outputs for the UI
+            return status_message, df, first_plot
+
         except Exception as e:
-            return f"Input error: {e}", None, None, "Failed"
+            # Catch any other unexpected errors during the process
+            return f"An error occurred in the calculation wrapper: {e}", None, None
 
+    # **FIX**: Cleaned up the outputs to have a direct one-to-one mapping.
     calculate_button.click(
         fn=calculate_wrapper,
         inputs=[
@@ -509,9 +551,10 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
             date_start_input, date_end_input,
             min_year_input, max_year_input
         ],
-        outputs=[results_info_box, timeseries_table, plot_output, results_info_box]
+        outputs=[results_info_box, timeseries_table, plot_output]
     )
 
+
     gr.HTML("""
         <div style="text-align: center; margin-top: 20px;">
             <p>Developed by <a href="https://sustainability-lab.github.io/">Sustainability Lab</a>, <a href="https://www.iitgn.ac.in/">IIT Gandhinagar</a></p>
@@ -520,4 +563,4 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
     """)
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch(debug=True)