Correct DEM and Slope

app.py

@@ -25,7 +25,7 @@ def one_time_setup():
     try:
         # Attempt to initialize with default credentials
         ee.Initialize()
-    except Exception as e:
+    except Exception:
         try:
             # Fallback to service account credentials if default init fails
             credentials_path = os.path.expanduser("~/.config/earthengine/credentials.json")
@@ -36,9 +36,6 @@ def one_time_setup():
                     f.write(ee_credentials)
                 credentials = ee.ServiceAccountCredentials('ujjwal@ee-ujjwaliitd.iam.gserviceaccount.com', credentials_path)
                 ee.Initialize(credentials, project='ee-ujjwaliitd')
-            else:
-                # If no credentials are found, re-raise the original exception
-                raise e
         except Exception as inner_e:
             # If the fallback also fails, print the error
             print(f"Earth Engine initialization failed: {inner_e}")
@@ -180,25 +177,20 @@ def get_wayback_data():
 
         # Parse XML
         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
 
             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})
@@ -206,57 +198,65 @@ 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)
+        wayback_df.sort_index(ascending=False, inplace=True) # Sort with the latest first
         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"An unexpected error occurred in get_wayback_data: {e}")
+    except (requests.exceptions.RequestException, ET.ParseError, Exception) as e:
+        print(f"Could not fetch or parse Wayback data: {e}")
         return pd.DataFrame() # Return empty dataframe on failure
 
-def get_dem_slope_maps(ee_geometry):
-    """Creates DEM and Slope maps from SRTM data."""
-    one_time_setup() # Ensure GEE is initialized
-    
-    # --- DEM Map ---
-    dem_map = gee_folium.Map(add_google_map=True) # Add basemap for context
-    dem_map.centerObject(ee_geometry)
-
-    dem_image = ee.Image("USGS/SRTMGL1_003").clip(ee_geometry)
+def get_dem_slope_maps(ee_geometry, wayback_url=None, wayback_title=None):
+    """Creates DEM and Slope maps from SRTM data, using wayback tiles as a basemap if available."""
+    one_time_setup()
 
-    stats = dem_image.reduceRegion(reducer=ee.Reducer.minMax(), geometry=ee_geometry, scale=30, maxPixels=1e9).getInfo()
-    
-    # Check if data is available
-    if not stats or stats.get('elevation_max') is None:
-        dem_map_html = "<div>No DEM data available for this area.</div>"
-        slope_map_html = "<div>No Slope data available for this area.</div>"
-        return dem_map_html, slope_map_html
+    # --- DEM Map ---
+    dem_map = gee_folium.Map(center_object=ee_geometry, zoom_start=12)
+    if wayback_url:
+        dem_map.add_tile_layer(wayback_url, name=wayback_title, attribution="Esri")
+    else:
+        dem_map.add_basemap("SATELLITE")
 
-    min_elev, max_elev = stats['elevation_min'], stats['elevation_max']
-    vis_params = {"min": min_elev, "max": max_elev, "palette": ["blue", "green", "yellow", "red"]}
+    try:
+        dem_layer = ee.Image("USGS/SRTMGL1_003").resample("bilinear").reproject(crs="EPSG:4326", scale=30).clip(ee_geometry)
+        stats = dem_layer.reduceRegion(reducer=ee.Reducer.minMax(), geometry=ee_geometry, scale=30, maxPixels=1e9).getInfo()
+        
+        if stats and stats.get('elevation_min') is not None:
+            min_val, max_val = stats['elevation_min'], stats['elevation_max']
+            vis_params = {"min": min_val, "max": max_val, "palette": ['#0000FF', '#00FF00', '#FFFF00', '#FF0000']} # Blue to Red
+            dem_map.addLayer(dem_layer, vis_params, "Elevation")
+            dem_map.add_colorbar(vis_params=vis_params, label="Elevation (m)")
+        else:
+            dem_map_html = "<div>No DEM data available for this area.</div>"
+    except Exception as e:
+        print(f"Error creating DEM map: {e}")
+        dem_map_html = f"<div>Error creating DEM map: {e}</div>"
 
-    dem_map.addLayer(dem_image, vis_params, "DEM")
-    dem_map.add_colorbar(vis_params=vis_params, label="Elevation (m)")
     dem_map.addLayerControl()
+    dem_map_html = dem_map._repr_html_()
 
     # --- Slope Map ---
-    slope_map = gee_folium.Map(add_google_map=True) # Add basemap for context
-    slope_map.centerObject(ee_geometry)
+    slope_map = gee_folium.Map(center_object=ee_geometry, zoom_start=12)
+    if wayback_url:
+        slope_map.add_tile_layer(wayback_url, name=wayback_title, attribution="Esri")
+    else:
+        slope_map.add_basemap("SATELLITE")
 
-    slope_image = ee.Terrain.slope(dem_image)
-    slope_vis_params = {"min": 0, "max": 60, "palette": ["blue", "green", "yellow", "red"]}
+    try:
+        slope_layer = ee.Terrain.slope(dem_layer)
+        slope_vis_params = {"min": 0, "max": 60, "palette": ['#00FF00', '#FFFF00', '#FFA500', '#FF0000']} # Green to Red
+        slope_map.addLayer(slope_layer, slope_vis_params, "Slope")
+        slope_map.add_colorbar(vis_params=slope_vis_params, label="Slope (degrees)")
+    except Exception as e:
+        print(f"Error creating Slope map: {e}")
+        slope_map_html = f"<div>Error creating Slope map: {e}</div>"
 
-    slope_map.addLayer(slope_image, slope_vis_params, "Slope")
-    slope_map.add_colorbar(vis_params=slope_vis_params, label="Slope (degrees)")
     slope_map.addLayerControl()
+    slope_map_html = slope_map._repr_html_()
+
+    return dem_map_html, slope_map_html
 
-    return dem_map._repr_html_(), slope_map._repr_html_()
 
-def add_indices(image, nir_band, red_band, blue_band, green_band, swir1_band, swir2_band, evi_vars):
+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)
@@ -283,7 +283,6 @@ def add_indices(image, nir_band, red_band, blue_band, green_band, swir1_band, sw
 
     # RandomForest (This part requires a pre-trained model asset in GEE)
     try:
-        # FIX: Select and rename bands from the training data to match what the classifier expects.
         table = ee.FeatureCollection('projects/in793-aq-nb-24330048/assets/cleanedVDI').select(
             ["B2", "B4", "B8", "cVDI"],
             ["Blue", "Red", "NIR", 'cVDI']
@@ -297,11 +296,10 @@ def add_indices(image, nir_band, red_band, blue_band, green_band, swir1_band, sw
             classProperty=label,
             inputProperties=bands,
         )
-        # Classify the image. The image already has bands named 'Blue', 'Red', 'NIR' from the previous select.
         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}") # More specific error message
-        rf = ee.Image.constant(0).rename('RandomForest')
+        print(f"Random Forest calculation failed: {e}")
+        rf = ee.Image.constant(0).rename('RandomForest') # Return a constant image on failure
 
 
     # Cubic Function Index (CI)
@@ -333,25 +331,14 @@ def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
 
     progress(0, desc="Reading and processing geometry...")
     try:
-        if file_obj is not None:
-            # Prioritize file upload
-            input_gdf = get_gdf_from_file(file_obj)
-        else:
-            # Use URL if file is not provided
-            input_gdf = get_gdf_from_url(url_str)
-
+        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)
 
         # Find the first valid polygon
-        geometry_gdf = None
-        for i in range(len(input_gdf)):
-            temp_gdf = input_gdf.iloc[[i]]
-            if is_valid_polygon(temp_gdf):
-                geometry_gdf = temp_gdf
-                break
+        geometry_gdf = next((input_gdf.iloc[[i]] for i in range(len(input_gdf)) if is_valid_polygon(input_gdf.iloc[[i]])), None)
 
         if geometry_gdf is None:
-            return None, "No valid polygon found in the provided file or URL.", None, None, None, None, None
+            return None, "No valid polygon found in the provided file.", None, None, None, None, None
 
         geometry_gdf = to_best_crs(geometry_gdf)
 
@@ -368,19 +355,11 @@ def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
 
     progress(0.5, desc="Generating maps and stats...")
     
-    # Convert to EE geometry
-    ee_geometry = ee.Geometry(json.loads(geometry_gdf.to_crs(4326).to_json())['features'][0]['geometry'])
-
-    # Generate DEM and Slope maps
-    dem_html, slope_html = get_dem_slope_maps(ee_geometry)
-
-
-    # Create main map
-    m = folium.Map()
-    
+    # --- Generate Maps ---
+    wayback_url, wayback_title = None, None
     if not WAYBACK_DF.empty:
-        # The DataFrame is already sorted by date, so the last item is the latest.
         latest_item = WAYBACK_DF.iloc[0]
+        wayback_title = f"Esri Wayback ({latest_item.name.strftime('%Y-%m-%d')})"
         wayback_url = (
             latest_item["ResourceURL_Template"]
             .replace("{TileMatrixSet}", "GoogleMapsCompatible")
@@ -388,28 +367,27 @@ def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
             .replace("{TileRow}", "{y}")
             .replace("{TileCol}", "{x}")
         )
-        folium.TileLayer(
-            tiles=wayback_url,
-            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)
         
-    # Add geometries to the map
-    m = add_geometry_to_map(m, geometry_gdf, buffer_geometry_gdf, opacity=0.3)
+    # Convert to EE geometry for DEM/Slope maps
+    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, wayback_url, wayback_title)
+
+    # Create main map with folium
+    bounds = geometry_gdf.to_crs(epsg=4326).total_bounds
+    map_center = [(bounds[1] + bounds[3]) / 2, (bounds[0] + bounds[2]) / 2]
+    m = folium.Map(location=map_center)
     
-    # Add a layer control panel
+    if wayback_url:
+        folium.TileLayer(tiles=wayback_url, attr="Esri", name=wayback_title).add_to(m)
+        
+    m = add_geometry_to_map(m, geometry_gdf, buffer_geometry_gdf)
     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))
-
+    m.fit_bounds([[bounds[1], bounds[0]], [bounds[3], bounds[2]]])
 
     # Generate stats
     stats_df = pd.DataFrame({
-        "Area (ha)": [geometry_gdf.area.item() / 10000],
-        "Perimeter (m)": [geometry_gdf.length.item()],
+        "Area (ha)": [f"{geometry_gdf.area.item() / 10000:.2f}"],
+        "Perimeter (m)": [f"{geometry_gdf.length.item():.2f}"],
         "Centroid (Lat, Lon)": [f"({geometry_gdf.to_crs(4326).centroid.y.iloc[0]:.6f}, {geometry_gdf.to_crs(4326).centroid.x.iloc[0]:.6f})"]
     })
 
@@ -426,7 +404,6 @@ def calculate_indices(
     min_year, max_year, progress=gr.Progress()
 ):
     """Calculates vegetation indices based on user inputs."""
-    # **FIX**: Ensure GEE is initialized before making any calls.
     one_time_setup()
     
     if not all([geometry_json, buffer_geometry_json, veg_indices]):
@@ -435,7 +412,7 @@ def calculate_indices(
     try:
         # Recreate GDFs from JSON
         geometry_gdf = gpd.read_file(geometry_json)
-        buffer_geometry_gdf = gpd.read_file(buffer_geometry_json)
+        buffer_geometry_gdf = gpd.read_file(buffer_json)
 
         # Convert to EE geometry
         ee_geometry = ee.Geometry(json.loads(geometry_gdf.to_crs(4326).to_json())['features'][0]['geometry'])
@@ -453,51 +430,42 @@ def calculate_indices(
         collection = (
             ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
             .select(
-                ["B2", "B3", "B4", "B8", "B11", "B12", "MSK_CLDPRB"],
-                ["Blue", "Green", "Red", "NIR", "SWIR1", "SWIR2",  "MSK_CLDPRB"]
+                ["B2", "B3", "B4", "B8", "MSK_CLDPRB"],
+                ["Blue", "Green", "Red", "NIR", "MSK_CLDPRB"]
             )
-            .map(lambda img: add_indices(img, 'NIR', 'Red', 'Blue', 'Green', "SWIR1", "SWIR2", evi_vars))
+            .map(lambda img: add_indices(img, 'NIR', 'Red', 'Blue', 'Green', evi_vars))
         )
 
         result_rows = []
-        total_dates = len(dates)
         for i, (start_date, end_date) in enumerate(dates):
-            progress((i + 1) / total_dates, desc=f"Processing {start_date} to {end_date}")
+            progress((i + 1) / len(dates), desc=f"Processing {start_date} to {end_date}")
             filtered_collection = collection.filterDate(start_date, end_date).filterBounds(ee_geometry)
             if filtered_collection.size().getInfo() == 0:
                 continue
 
-            row = {'daterange': f"{start_date}_to_{end_date}"}
+            row = {'daterange': f"{start_date.split('-')[0]}"}
             for veg_index in veg_indices:
                 mosaic = filtered_collection.qualityMosaic(veg_index)
                 
-                mean_dict = mosaic.reduceRegion(reducer=ee.Reducer.mean(), geometry=ee_geometry, scale=10, maxPixels=1e9).getInfo()
-                mean_val = mean_dict.get(veg_index) if mean_dict else None
+                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()
 
-                buffer_mean_dict = mosaic.reduceRegion(reducer=ee.Reducer.mean(), geometry=buffer_ee_geometry, scale=10, maxPixels=1e9).getInfo()
-                buffer_mean_val = buffer_mean_dict.get(veg_index) if buffer_mean_dict else None
-
-                row[veg_index] = mean_val if mean_val is not None else np.nan
-                row[f"{veg_index}_buffer"] = buffer_mean_val if buffer_mean_val is not None else np.nan
-                
-                if mean_val is not None and buffer_mean_val is not None and buffer_mean_val != 0:
-                    row[f"{veg_index}_ratio"] = mean_val / buffer_mean_val
-                else:
-                    row[f"{veg_index}_ratio"] = np.nan
-                    
+                row[veg_index] = mean_val
+                row[f"{veg_index}_buffer"] = buffer_mean_val
+                row[f"{veg_index}_ratio"] = (mean_val / buffer_mean_val) if buffer_mean_val else np.nan
             result_rows.append(row)
 
         if not result_rows:
             return "No satellite imagery found for the selected dates.", None, None, None
 
         result_df = pd.DataFrame(result_rows).set_index('daterange')
-        result_df.index = result_df.index.str.split('-').str[0] # Use start year as index for plotting
         result_df = result_df.round(3)
 
         # Create plots
         plots = []
         for veg_index in veg_indices:
-            plot_df = result_df[[veg_index, f"{veg_index}_buffer", f"{veg_index}_ratio"]].dropna()
+            plot_cols = [col for col in [veg_index, f"{veg_index}_buffer", f"{veg_index}_ratio"] if col in result_df.columns]
+            plot_df = result_df[plot_cols].dropna()
             if not plot_df.empty:
                 fig = px.line(plot_df, x=plot_df.index, y=plot_df.columns, markers=True, title=f"{veg_index} Time Series")
                 fig.update_layout(xaxis_title="Year", yaxis_title="Index Value")
@@ -510,9 +478,7 @@ def calculate_indices(
         traceback.print_exc()
         return f"An error occurred during calculation: {e}", None, None, None
 
-
 # --- Gradio UI Definition ---
-
 with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
     # Hidden state to store geometry data
     geometry_data = gr.State()
@@ -534,8 +500,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
             url_input = gr.Textbox(label="Or Provide File URL", placeholder="e.g., https://.../my_file.kml")
             buffer_input = gr.Number(label="Buffer (meters)", value=50)
             process_button = gr.Button("Process Input", variant="primary")
-            info_box = gr.Textbox(label="Status", interactive=False)
-
+            
             with gr.Accordion("Advanced Settings", open=False):
                 gr.Markdown("### Select Vegetation Indices")
                 all_veg_indices = ["GujVDI", "NDVI", "EVI", "EVI2", "RandomForest", "CI"]
@@ -560,28 +525,28 @@ with gr.Blocks(theme=gr.themes.Soft(), 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")
-            stats_output = gr.DataFrame(label="Geometry Metrics")
             map_output = gr.HTML(label="Map View")
+            stats_output = gr.DataFrame(label="Geometry Metrics")
             
             gr.Markdown("### Digital Elevation Model (DEM) and Slope")
             with gr.Row():
                 dem_map_output = gr.HTML(label="DEM Map")
                 slope_map_output = gr.HTML(label="Slope Map")
 
-            results_info_box = gr.Textbox(label="Calculation Status", interactive=False)
-            timeseries_table = gr.DataFrame(label="Time Series Data")
-            plot_output = gr.Plot(label="Time Series Plot")
-
+            with gr.Tabs():
+                with gr.TabItem("Time Series Plot"):
+                    plot_output = gr.Plot(label="Time Series Plot")
+                with gr.TabItem("Time Series Data"):
+                    timeseries_table = gr.DataFrame(label="Time Series Data")
 
     # --- 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")
-        return file_url if file_url else ""
+        return request.query_params.get("file_url", "")
 
     demo.load(process_on_load, None, url_input)
 
@@ -591,39 +556,30 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
         outputs=[map_output, info_box, stats_output, dem_map_output, slope_map_output, geometry_data, buffer_geometry_data]
     )
 
-    def calculate_wrapper(geometry_json, buffer_geometry_json, veg_indices,
+    def calculate_wrapper(geometry_json, buffer_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 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('-'))
+            # 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))
 
-            # Call the main calculation function
             error_msg, df, plots, success_msg = calculate_indices(
-                geometry_json, buffer_geometry_json, veg_indices,
+                geometry_json, buffer_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
+            status_message = error_msg or success_msg
             first_plot = plots[0] if plots else None
+            df_display = df.round(3) if df is not None else None
             
-            # Round the dataframe to 3 decimal places for display
-            if df is not None:
-                df = df.round(3)
-
-            # Return a clean set of outputs for the UI
-            return status_message, df, first_plot
+            return status_message, df_display, first_plot
 
         except Exception as e:
-            # Catch any other unexpected errors during the process
-            return f"An error occurred in the calculation wrapper: {e}", None, None
+            return f"An error occurred in the wrapper: {e}", None, None
 
     calculate_button.click(
         fn=calculate_wrapper,
@@ -633,7 +589,7 @@ 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]
+        outputs=[info_box, timeseries_table, plot_output]
     )
 
     gr.HTML("""
@@ -645,4 +601,3 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
 
 if __name__ == "__main__":
     demo.launch(debug=True)
-