Add Comparison Map

app.py

@@ -179,23 +179,19 @@ def get_wayback_data():
         root = ET.fromstring(response.content)
 
         ns = {
-            "wmts": "https://www.opengis.net/wmts/1.0",
-            "ows": "https://www.opengis.net/ows/1.1",
-            "xlink": "https://www.w3.org/1999/xlink",
+            "wmts": "http://www.opengis.net/wmts/1.0",
+            "ows": "http://www.opengis.net/ows/1.1",
+            "xlink": "http://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)
-            identifier = layer.find("ows:Identifier", ns)
-            resource = layer.find("wmts:ResourceURL", ns)  # Tile URL template
+            resource = layer.find("wmts:ResourceURL", ns)
 
             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})
@@ -203,17 +199,11 @@ def get_wayback_data():
         wayback_df = pd.DataFrame(layer_data)
         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
+        return wayback_df.sort_index(ascending=False)
 
-    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"An unexpected error occurred in get_wayback_data: {e}")
-        return pd.DataFrame() 
+        print(f"Could not fetch or parse Wayback data: {e}")
+        return pd.DataFrame()
 
 
 def get_dem_slope_maps(ee_geometry, map_bounds, zoom=12, wayback_url=None, wayback_title=None):
@@ -274,63 +264,39 @@ def get_dem_slope_maps(ee_geometry, map_bounds, zoom=12, wayback_url=None, wayba
 
 def add_indices(image, nir_band, red_band, blue_band, green_band, evi_vars):
     """Calculates and adds multiple vegetation indices to an Earth Engine image."""
-    # It's safer to work with the image bands directly
     nir = image.select(nir_band).divide(10000)
     red = image.select(red_band).divide(10000)
     blue = image.select(blue_band).divide(10000)
     green = image.select(green_band).divide(10000)
-
-    # NDVI
     ndvi = image.normalizedDifference([nir_band, red_band]).rename('NDVI')
-
-    # EVI
     evi = image.expression(
         'G * ((NIR - RED) / (NIR + C1 * RED - C2 * BLUE + L))', {
             'NIR': nir, 'RED': red, 'BLUE': blue,
             'G': evi_vars['G'], 'C1': evi_vars['C1'], 'C2': evi_vars['C2'], 'L': evi_vars['L']
         }).rename('EVI')
-
-    # EVI2
     evi2 = image.expression(
         'G * (NIR - RED) / (NIR + L + C * RED)', {
             'NIR': nir, 'RED': red,
             'G': evi_vars['G'], 'L': evi_vars['L'], 'C': evi_vars['C']
         }).rename('EVI2')
-
-    # RandomForest (This part requires a pre-trained model asset in GEE)
     try:
         table = ee.FeatureCollection('projects/in793-aq-nb-24330048/assets/cleanedVDI').select(
-            ["B2", "B4", "B8", "cVDI"],
-            ["Blue", "Red", "NIR", 'cVDI']
-        )
-        
-        bands = ['Blue', 'Red', 'NIR']
-        label = 'cVDI'
-        
+            ["B2", "B4", "B8", "cVDI"], ["Blue", "Red", "NIR", 'cVDI'])
         classifier = ee.Classifier.smileRandomForest(50).train(
-            features=table,
-            classProperty=label,
-            inputProperties=bands,
-        )
+            features=table, classProperty='cVDI', inputProperties=['Blue', 'Red', 'NIR'])
         rf = image.classify(classifier).multiply(ee.Number(0.2)).add(ee.Number(0.1)).rename('RandomForest')
     except Exception as e:
         print(f"Random Forest calculation failed: {e}")
-        rf = ee.Image.constant(0).rename('RandomForest') # Return a constant image on failure
-
-
-    # Cubic Function Index (CI)
+        rf = ee.Image.constant(0).rename('RandomForest')
     ci = image.expression(
         '(-3.98 * (BLUE/NIR) + 12.54 * (GREEN/NIR) - 5.49 * (RED/NIR) - 0.19) / ' +
         '(-21.87 * (BLUE/NIR) + 12.4 * (GREEN/NIR) + 19.98 * (RED/NIR) + 1) * 2.29', {
             'NIR': nir, 'RED': red, 'BLUE': blue, 'GREEN': green
         }).rename('CI')
-
-    # GujVDI
     gujvdi = image.expression(
         '0.5 * (NIR - RED) / (NIR + 6 * RED - 8.25 * BLUE - 0.01)', {
             'NIR': nir, 'RED': red, 'BLUE': blue
         }).rename('GujVDI')
-
     return image.addBands([ndvi, evi, evi2, rf, ci, gujvdi])
 
 
@@ -347,7 +313,6 @@ def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
 
     progress(0, desc="Reading and processing geometry...")
     try:
-        # ... (no changes to the geometry processing part) ...
         input_gdf = get_gdf_from_file(file_obj) if file_obj is not None else get_gdf_from_url(url_str)
         input_gdf = preprocess_gdf(input_gdf)
         geometry_gdf = next((input_gdf.iloc[[i]] for i in range(len(input_gdf)) if is_valid_polygon(input_gdf.iloc[[i]])), None)
@@ -364,16 +329,12 @@ def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
         return None, f"Error processing file: {e}", None, None, None, None, None
 
     progress(0.5, desc="Generating maps and stats...")
-
-    # Create main map with folium using the calculated center
     m = folium.Map()
-
-    # --- Generate Maps ---
+    wayback_url = None
+    wayback_title = "Esri Satellite"
     if not WAYBACK_DF.empty:
-        # Select the first row, which is the most recent date after sorting
         latest_item = WAYBACK_DF.iloc[0]
         wayback_title = f"Esri Wayback ({latest_item.name.strftime('%Y-%m-%d')})"
-        print(wayback_title)
         wayback_url = (
             latest_item["ResourceURL_Template"]
             .replace("{TileMatrixSet}", "GoogleMapsCompatible")
@@ -382,22 +343,16 @@ def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
             .replace("{TileCol}", "{x}")
         )
         folium.TileLayer(tiles=wayback_url, attr="Esri", name=wayback_title).add_to(m)
-                
+            
     m = add_geometry_to_map(m, geometry_gdf, buffer_geometry_gdf, opacity=0.3)
     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]]
+    map_bounds = [[bounds[1], bounds[0]], [bounds[3], bounds[2]]]
     m.fit_bounds(map_bounds, padding=(10, 10))
 
-    # Pass map_center to the function
     ee_geometry = ee.Geometry(json.loads(geometry_gdf.to_crs(4326).to_json())['features'][0]['geometry'])
     dem_html, slope_html = get_dem_slope_maps(ee_geometry, map_bounds, wayback_url=wayback_url, wayback_title=wayback_title)
 
-
-
-    # ... (rest of the function remains the same) ...
     stats_df = pd.DataFrame({
         "Area (ha)": [f"{geometry_gdf.area.item() / 10000:.2f}"],
         "Perimeter (m)": [f"{geometry_gdf.length.item():.2f}"],
@@ -419,15 +374,11 @@ def calculate_indices(
         return "Please process a file and select at least one index first.", None, None, None
 
     try:
-        # Recreate GDFs from JSON
         geometry_gdf = gpd.read_file(geometry_json)
-        buffer_geometry_gdf = gpd.read_file(buffer_geometry_json)
-
-        # Convert to EE geometry
+        buffer_geometry_gdf = gpd.read_file(buffer_json)
         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
         dates = [
@@ -435,7 +386,6 @@ def calculate_indices(
             for year in range(min_year, max_year + 1)
         ]
 
-        # GEE processing
         collection = (
             ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
             .select(
@@ -452,13 +402,11 @@ def calculate_indices(
             if filtered_collection.size().getInfo() == 0:
                 continue
 
-            # **MODIFIED**: Add 'Year' column data to the row
             year_val = int(start_date.split('-')[0])
             row = {'Year': year_val, 'Date Range': f"{start_date}_to_{end_date}"}
 
             for veg_index in veg_indices:
                 mosaic = filtered_collection.qualityMosaic(veg_index)
-
                 mean_val = mosaic.reduceRegion(reducer=ee.Reducer.mean(), geometry=ee_geometry, scale=10, maxPixels=1e9).get(veg_index).getInfo()
                 buffer_mean_val = mosaic.reduceRegion(reducer=ee.Reducer.mean(), geometry=buffer_ee_geometry, scale=10, maxPixels=1e9).get(veg_index).getInfo()
 
@@ -473,10 +421,8 @@ def calculate_indices(
         result_df = pd.DataFrame(result_rows)
         result_df = result_df.round(3)
 
-        # Create plots
         plots = []
         for veg_index in veg_indices:
-            # **MODIFIED**: Plot using the new 'Year' column for the x-axis
             plot_cols = [veg_index, f"{veg_index}_buffer", f"{veg_index}_ratio"]
             existing_plot_cols = [col for col in plot_cols if col in result_df.columns]
             
@@ -485,7 +431,6 @@ def calculate_indices(
             if not plot_df.empty:
                 fig = px.line(plot_df, x='Year', y=existing_plot_cols, markers=True, title=f"{veg_index} Time Series")
                 fig.update_layout(xaxis_title="Year", yaxis_title="Index Value")
-                # Ensure x-axis ticks are whole numbers for years
                 fig.update_xaxes(dtick=1)
                 plots.append(fig)
 
@@ -496,17 +441,69 @@ def calculate_indices(
         traceback.print_exc()
         return f"An error occurred during calculation: {e}", None, None, None
 
-# First, create an instance of the Soft theme
-theme = gr.themes.Soft()
+def generate_comparison_maps(geometry_json, selected_index, selected_years, evi_vars, date_start_str, date_end_str, progress=gr.Progress()):
+    """Generates side-by-side maps for a selected index and two selected years."""
+    if not geometry_json or not selected_index or not selected_years:
+        return "Please process a file and select an index and years first.", "", ""
+    if len(selected_years) != 2:
+        return "Please select exactly two years to compare.", "", ""
+    
+    one_time_setup()
+    geometry_gdf = gpd.read_file(geometry_json).to_crs(4326)
+    ee_geometry = ee.Geometry(json.loads(geometry_gdf.to_json())['features'][0]['geometry'])
+    bounds = geometry_gdf.total_bounds
+    map_bounds = [[bounds[1], bounds[0]], [bounds[3], bounds[2]]]
+    
+    start_month, start_day = map(int, date_start_str.split('-'))
+    end_month, end_day = map(int, date_end_str.split('-'))
+
+    vis_params = {
+        "min": 0.0, "max": 1.0,
+        "palette": ['FFFFFF', 'CE7E45', 'DF923D', 'F1B555', 'FCD163', '99B718', '74A901', '66A000', '529400', '3E8601', '207401', '056201', '004C00', '023B01', '012E01', '011D01', '011301']
+    }
+
+    maps_html = []
+    for i, year in enumerate(selected_years):
+        progress((i + 1) / 2, desc=f"Generating map for {year}")
+        start_date = f"{year}-{start_month:02d}-{start_day:02d}"
+        end_date = f"{year}-{end_month:02d}-{end_day:02d}"
+
+        collection = (ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
+            .filterDate(start_date, end_date)
+            .filterBounds(ee_geometry)
+            .map(lambda img: add_indices(img, 'NIR', 'Red', 'Blue', 'Green', evi_vars)))
+
+        if collection.size().getInfo() == 0:
+            maps_html.append(f"<div style='text-align:center; padding-top: 50px;'>No data found for {year}.</div>")
+            continue
+
+        mosaic = collection.qualityMosaic(selected_index)
+        clipped_image = mosaic.select(selected_index).clip(ee_geometry)
+
+        m = gee_folium.Map(zoom_start=14)
+        m.add_basemap("SATELLITE")
+        m.addLayer(clipped_image, vis_params, f"{selected_index} {year}")
+        m.add_colorbar(vis_params=vis_params, label=f"{selected_index} Value")
+        folium.GeoJson(geometry_gdf, name="Geometry", style_function=lambda x: {"color": "yellow", "fillOpacity": 0, "weight": 2.5}).add_to(m)
+        m.fit_bounds(map_bounds, padding=(10, 10))
+        m.addLayerControl()
+        maps_html.append(m._repr_html_())
+
+    while len(maps_html) < 2:
+        maps_html.append("")
 
-# Then, directly modify the attribute for the primary background color
-theme.background_fill_primary = "white"
+    return f"Comparison generated for {selected_years[0]} and {selected_years[1]}.", maps_html[0], maps_html[1]
+
+# --- Gradio Interface ---
+theme = gr.themes.Soft(primary_hue="teal", secondary_hue="orange").set(
+    background_fill_primary="white"
+)
 
-# Finally, pass the fully customized theme object to your Gradio Blocks
 with gr.Blocks(theme=theme, title="Kamlan: KML Analyzer") as demo:
-    # Hidden state to store geometry data
+    # Hidden state to store data between steps
     geometry_data = gr.State()
     buffer_geometry_data = gr.State()
+    timeseries_df_state = gr.State()
 
     gr.HTML("""
         <div style="display: flex; justify-content: space-between; align-items: center;">
@@ -549,10 +546,11 @@ with gr.Blocks(theme=theme, title="Kamlan: KML Analyzer") as demo:
                     max_year_input = gr.Number(label="End Year", value=today.year, precision=0)
 
             calculate_button = gr.Button("Calculate Vegetation Indices", variant="primary")
-            info_box = gr.Textbox(label="Status", interactive=False)
+            
 
         with gr.Column(scale=2):
             gr.Markdown("## 2. Results")
+            info_box = gr.Textbox(label="Status", interactive=False, placeholder="Status messages will appear here...")
             map_output = gr.HTML(label="Map View")
             stats_output = gr.DataFrame(label="Geometry Metrics")
             
@@ -567,9 +565,22 @@ with gr.Blocks(theme=theme, title="Kamlan: KML Analyzer") as demo:
                 with gr.TabItem("Time Series Data"):
                     timeseries_table = gr.DataFrame(label="Time Series Data")
 
+    gr.Markdown("---") # Visual separator
+    gr.Markdown("## 3. Year-over-Year Index Comparison")
+    with gr.Row():
+        comparison_index_select = gr.Radio(all_veg_indices, label="Select Index for Comparison", value="NDVI")
+        comparison_years_select = gr.CheckboxGroup(label="Select Two Years to Compare", choices=[])
+    
+    compare_button = gr.Button("Generate Comparison Maps", variant="secondary")
+    
+    with gr.Row():
+        map_year_1_output = gr.HTML(label="Comparison Map 1")
+        map_year_2_output = gr.HTML(label="Comparison Map 2")
+
+
     # --- 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."""
+        """Checks for a 'file_url' query parameter when the app loads."""
         return request.query_params.get("file_url", "")
 
     demo.load(process_on_load, None, url_input)
@@ -588,7 +599,6 @@ with gr.Blocks(theme=theme, title="Kamlan: KML Analyzer") as demo:
             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('-'))
-            # Use a placeholder year; the actual year is iterated inside the main function
             date_range = (datetime(2000, start_month, start_day), datetime(2000, end_month, end_day))
 
             error_msg, df, plots, success_msg = calculate_indices(
@@ -600,10 +610,14 @@ with gr.Blocks(theme=theme, title="Kamlan: KML Analyzer") as demo:
             first_plot = plots[0] if plots else None
             df_display = df.round(3) if df is not None else None
             
-            return status_message, df_display, first_plot
+            available_years = []
+            if df is not None and 'Year' in df.columns:
+                available_years = sorted(df['Year'].unique().tolist())
+            
+            return status_message, df_display, df, first_plot, gr.update(choices=available_years, value=[])
 
         except Exception as e:
-            return f"An error occurred in the wrapper: {e}", None, None
+            return f"An error occurred in the wrapper: {e}", None, None, None, gr.update(choices=[], value=[])
 
     calculate_button.click(
         fn=calculate_wrapper,
@@ -613,7 +627,29 @@ with gr.Blocks(theme=theme, title="Kamlan: KML Analyzer") as demo:
             date_start_input, date_end_input,
             min_year_input, max_year_input
         ],
-        outputs=[info_box, timeseries_table, plot_output]
+        outputs=[info_box, timeseries_table, timeseries_df_state, plot_output, comparison_years_select]
+    )
+
+    def comparison_wrapper(geometry_json, selected_index, selected_years, g, c1, c2, l, c, start_date_str, end_date_str, progress=gr.Progress()):
+        """Wrapper for the comparison map generation."""
+        try:
+            evi_vars = {'G': g, 'C1': c1, 'C2': c2, 'L': l, 'C': c}
+            status, map1, map2 = generate_comparison_maps(
+                geometry_json, selected_index, selected_years, evi_vars,
+                start_date_str, end_date_str, progress
+            )
+            return status, map1, map2
+        except Exception as e:
+            return f"Error during comparison: {e}", "", ""
+
+    compare_button.click(
+        fn=comparison_wrapper,
+        inputs=[
+            geometry_data, comparison_index_select, comparison_years_select,
+            evi_g, evi_c1, evi_c2, evi_l, evi_c,
+            date_start_input, date_end_input
+        ],
+        outputs=[info_box, map_year_1_output, map_year_2_output]
     )
 
     gr.HTML("""