Create app

app.py

@@ -0,0 +1,497 @@
+import os
+from datetime import datetime
+import ee
+import json
+import numpy as np
+import geemap.foliumap as gee_folium
+import leafmap.foliumap as leaf_folium
+import gradio as gr
+import pandas as pd
+import geopandas as gpd
+import plotly.express as px
+import branca.colormap as cm
+from shapely.ops import transform
+import pyproj
+from io import BytesIO
+import requests
+import kml2geojson
+import folium
+import xml.etree.ElementTree as ET
+
+# --- Helper Functions from functions.py ---
+
+def one_time_setup():
+    """Initializes the Earth Engine API."""
+    try:
+        ee.Initialize()
+    except Exception as e:
+        try:
+            # Fallback to service account credentials if default init fails
+            credentials_path = os.path.expanduser("~/.config/earthengine/credentials.json")
+            ee_credentials = os.environ.get("EE")
+            if ee_credentials:
+                os.makedirs(os.path.dirname(credentials_path), exist_ok=True)
+                with open(credentials_path, "w") as f:
+                    f.write(ee_credentials)
+                credentials = ee.ServiceAccountCredentials('ujjwal@ee-ujjwaliitd.iam.gserviceaccount.com', credentials_path)
+                ee.Initialize(credentials, project='ee-ujjwaliitd')
+            else:
+                raise e
+        except Exception as inner_e:
+            print(f"Earth Engine initialization failed: {inner_e}")
+            # In a real app, you might want to show an error to the user here
+            # For this Gradio app, we'll let it proceed and fail gracefully later if EE is needed.
+
+
+def get_gdf_from_file(file_obj):
+    """Reads a KML or GeoJSON file and returns a GeoDataFrame."""
+    bytes_data = BytesIO(file_obj)
+    # Read the start of the file to check if it's XML (KML)
+    # We need to be careful not to consume the stream
+    start_of_file = bytes_data.read(100)
+    bytes_data.seek(0) # Reset pointer
+
+    if start_of_file.strip().startswith(b'<?xml'):
+        try:
+            # Use a temporary file to work with kml2geojson which might expect a file path
+            with open("temp.kml", "wb") as f:
+                f.write(bytes_data.read())
+            geojson = kml2geojson.convert("temp.kml")
+            features = geojson[0]["features"]
+            epsg = 4326
+            input_gdf = gpd.GeoDataFrame.from_features(features, crs=f"EPSG:{epsg}")
+            os.remove("temp.kml")
+        except Exception as e:
+            raise ValueError(f"Failed to process KML file: {e}")
+    else:
+        try:
+            input_gdf = gpd.read_file(bytes_data)
+        except Exception as e:
+            raise ValueError(f"Failed to read GeoJSON/Shapefile: {e}")
+
+    return input_gdf
+
+
+def find_best_epsg(geometry):
+    """Finds the most suitable EPSG code for a given geometry based on its centroid."""
+    if geometry.geom_type == "Polygon":
+        centroid = geometry.centroid
+    else:
+        raise ValueError("Geometry is not a Polygon.")
+
+    common_epsg_codes = [
+        7761,  # Gujarat
+        7774,  # Rajasthan
+        7766,  # MadhyaPradesh
+        7767,  # Maharastra
+        7755,  # India
+        # Add other relevant state/country EPSG codes here
+    ]
+
+    for epsg in common_epsg_codes:
+        try:
+            crs = pyproj.CRS.from_epsg(epsg)
+            area_of_use = crs.area_of_use.bounds
+            if (area_of_use[0] <= centroid.x <= area_of_use[2]) and \
+               (area_of_use[1] <= centroid.y <= area_of_use[3]):
+                return epsg
+        except pyproj.exceptions.CRSError:
+            continue
+    return 4326 # Default to WGS84 if no suitable projection is found
+
+def shape_3d_to_2d(shape):
+    """Converts a 3D geometry to 2D."""
+    if shape.has_z:
+        return transform(lambda x, y, z: (x, y), shape)
+    return shape
+
+def preprocess_gdf(gdf):
+    """Preprocesses a GeoDataFrame by converting geometries to 2D and fixing invalid ones."""
+    gdf["geometry"] = gdf["geometry"].apply(shape_3d_to_2d)
+    gdf["geometry"] = gdf.buffer(0)
+    return gdf
+
+def to_best_crs(gdf):
+    """Converts a GeoDataFrame to the most suitable CRS."""
+    if not gdf.empty and gdf["geometry"].iloc[0] is not None:
+        best_epsg_code = find_best_epsg(gdf.to_crs(epsg=4326)["geometry"].iloc[0])
+        return gdf.to_crs(epsg=best_epsg_code)
+    return gdf
+
+def is_valid_polygon(geometry_gdf):
+    """Checks if the geometry in a GeoDataFrame is a valid, non-empty Polygon."""
+    if geometry_gdf.empty:
+        return False
+    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):
+    """Adds geometry and its buffer to a folium map."""
+    if buffer_geometry_gdf is not None and not buffer_geometry_gdf.empty:
+        folium.GeoJson(
+            buffer_geometry_gdf.to_crs(epsg=4326),
+            name="Geometry Buffer",
+            style_function=lambda x: {"color": "red", "fillOpacity": opacity, "fillColor": "red"}
+        ).add_to(m)
+    if geometry_gdf is not None and not geometry_gdf.empty:
+        folium.GeoJson(
+            geometry_gdf.to_crs(epsg=4326),
+            name="Geometry",
+            style_function=lambda x: {"color": "blue", "fillOpacity": opacity, "fillColor": "blue"}
+        ).add_to(m)
+    return m
+
+def get_wayback_data():
+    """Fetches and parses Wayback imagery data from ArcGIS."""
+    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()
+        root = ET.fromstring(response.content)
+        ns = {
+            "wmts": "http://www.opengis.net/wmts/1.0",
+            "ows": "http://www.opengis.net/ows/1.1",
+        }
+        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")
+                })
+        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.set_index("date", inplace=True)
+        return wayback_df.sort_index()
+    except Exception as e:
+        print(f"Could not fetch 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):
+    """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)
+    # For demonstration, we'll return a constant image if asset is not available
+    try:
+        table = ee.FeatureCollection('projects/in793-aq-nb-24330048/assets/cleanedVDI')
+        classifier = ee.Classifier.smileRandomForest(50).train(
+            features=table,
+            classProperty='cVDI',
+            inputProperties=['Blue', 'Red', 'NIR']
+        )
+        rf = image.select(['Blue', 'Red', 'NIR']).classify(classifier).multiply(0.2).add(0.1).rename('RandomForest')
+    except Exception:
+        rf = ee.Image.constant(0).rename('RandomForest')
+
+
+    # Cubic Function Index (CI)
+    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])
+
+
+# --- Gradio App Logic ---
+
+# Initialize GEE and fetch wayback data once
+one_time_setup()
+WAYBACK_DF = get_wayback_data()
+
+def process_and_display(file_obj, buffer_m, progress=gr.Progress()):
+    """Main function to process the uploaded file and generate initial outputs."""
+    if file_obj is None:
+        return None, "Please upload a KML or GeoJSON file.", None, None, None
+
+    progress(0, desc="Reading and processing geometry...")
+    try:
+        input_gdf = get_gdf_from_file(file_obj)
+        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
+
+        if geometry_gdf is None:
+            return None, "No valid polygon found in the uploaded file.", None, None, None
+
+        geometry_gdf = to_best_crs(geometry_gdf)
+
+        # Create buffer
+        outer_geometry_gdf = geometry_gdf.copy()
+        outer_geometry_gdf["geometry"] = outer_geometry_gdf["geometry"].buffer(buffer_m)
+        buffer_geometry_gdf = gpd.GeoDataFrame(
+            geometry=[outer_geometry_gdf.unary_union.difference(geometry_gdf.unary_union)],
+            crs=geometry_gdf.crs
+        )
+
+    except Exception as e:
+        return None, f"Error processing file: {e}", None, None, None
+
+    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)
+    if not WAYBACK_DF.empty:
+        first_item = WAYBACK_DF.iloc[0]
+        wayback_url = (
+            first_item["ResourceURL_Template"]
+            .replace("{TileMatrixSet}", "GoogleMapsCompatible")
+            .replace("{TileMatrix}", "{z}")
+            .replace("{TileRow}", "{y}")
+            .replace("{TileCol}", "{x}")
+        )
+        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"
+        ).add_to(m)
+    m.add_child(folium.LayerControl())
+    m = add_geometry_to_map(m, geometry_gdf, buffer_geometry_gdf, opacity=0.3)
+
+    # Generate stats
+    stats_df = pd.DataFrame({
+        "Area (ha)": [geometry_gdf.area.item() / 10000],
+        "Perimeter (m)": [geometry_gdf.length.item()],
+        "Centroid (Lat, Lon)": [f"({geometry_gdf.to_crs(4326).centroid.y.iloc[0]:.6f}, {geometry_gdf.to_crs(4326).centroid.x.iloc[0]:.6f})"]
+    })
+
+    # Save geometry data for later use
+    # In Gradio, we pass data between functions instead of using session state
+    geometry_json = geometry_gdf.to_json()
+    buffer_geometry_json = buffer_geometry_gdf.to_json()
+
+    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()
+):
+    """Calculates vegetation indices based on user inputs."""
+    if not all([geometry_json, buffer_geometry_json, veg_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
+        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'])
+        ee_fc = ee.FeatureCollection(ee_geometry)
+        buffer_ee_fc = ee.FeatureCollection(buffer_ee_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 = [
+            (f"{year}-{start_month:02d}-{start_day:02d}", f"{year}-{end_month:02d}-{end_day:02d}")
+            for year in range(min_year, max_year + 1)
+        ]
+
+        # GEE processing
+        collection = (
+            ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
+            .select(
+                ["B2", "B3", "B4", "B8", "MSK_CLDPRB"],
+                ["Blue", "Green", "Red", "NIR", "MSK_CLDPRB"]
+            )
+            .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}")
+            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}"}
+            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()
+                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 0
+            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
+
+        # Create plots
+        plots = []
+        for veg_index in veg_indices:
+            plot_df = result_df[[veg_index, f"{veg_index}_buffer", f"{veg_index}_ratio"]]
+            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")
+            plots.append(fig)
+
+        return None, result_df, plots, "Calculation complete."
+
+    except Exception as e:
+        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()
+    buffer_geometry_data = gr.State()
+
+    gr.HTML("""
+        <div style="display: flex; justify-content: space-between; align-items: center;">
+            <img src="https://huggingface.co/spaces/SustainabilityLabIITGN/NDVI_PERG/resolve/main/Final_IITGN-Logo-symmetric-Color.png" style="width: 10%; margin-right: auto;">
+            <h1 style="text-align: center;">Kamlan: KML Analyzer</h1>
+            <img src="https://huggingface.co/spaces/SustainabilityLabIITGN/NDVI_PERG/resolve/main/IFS.jpg" style="width: 10%; margin-left: auto;">
+        </div>
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## 1. Upload Geometry")
+            file_input = gr.File(label="Upload KML/GeoJSON File", file_types=[".kml", ".geojson"])
+            buffer_input = gr.Number(label="Buffer (meters)", value=50)
+            process_button = gr.Button("Process File", 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"]
+                veg_indices_checkboxes = gr.CheckboxGroup(all_veg_indices, label="Indices", value=["NDVI"])
+
+                gr.Markdown("### EVI/EVI2 Parameters")
+                with gr.Row():
+                    evi_g = gr.Number(label="G", value=2.5)
+                    evi_c1 = gr.Number(label="C1", value=6.0)
+                    evi_c2 = gr.Number(label="C2", value=7.5)
+                with gr.Row():
+                    evi_l = gr.Number(label="L", value=1.0)
+                    evi_c = gr.Number(label="C", value=2.4)
+
+                gr.Markdown("### Date Range")
+                # Gradio doesn't have a direct date range picker, so we use two date inputs
+                today = datetime.now()
+                date_start_input = gr.Textbox(label="Start Date (MM-DD)", value="11-15")
+                date_end_input = gr.Textbox(label="End Date (MM-DD)", value="12-15")
+
+                with gr.Row():
+                    min_year_input = gr.Number(label="Start Year", value=2019, precision=0)
+                    max_year_input = gr.Number(label="End Year", value=today.year, precision=0)
+
+
+            calculate_button = gr.Button("Calculate Vegetation Indices", variant="primary")
+
+
+        with gr.Column(scale=2):
+            gr.Markdown("## 2. Results")
+            stats_output = gr.DataFrame(label="Geometry Metrics")
+            map_output = gr.HTML(label="Map View")
+            results_info_box = gr.Textbox(label="Calculation Status", interactive=False)
+            timeseries_table = gr.DataFrame(label="Time Series Data")
+            with gr.Blocks() as plot_output_blocks:
+                 gr.Markdown("### Time Series Plots")
+                 # This will be populated dynamically
+            # We will handle plot display logic in the backend
+
+    # --- Event Handlers ---
+    process_button.click(
+        fn=process_and_display,
+        inputs=[file_input, buffer_input],
+        outputs=[map_output, info_box, stats_output, geometry_data, buffer_geometry_data]
+    )
+
+    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."""
+        try:
+            # Parse EVI vars
+            evi_vars = {'G': g, 'C1': c1, 'C2': c2, 'L': l, 'C': c}
+            # Parse dates - we ignore the year part from the string
+            start_month, start_day = map(int, start_date_str.split('-'))
+            end_month, end_day = map(int, end_date_str.split('-'))
+            # Use a dummy year, the actual year is handled in the loop
+            date_range = (datetime(2000, start_month, start_day), datetime(2000, end_month, end_day))
+
+            error, df, plots, msg = calculate_indices(
+                geometry_json, buffer_geometry_json, veg_indices,
+                evi_vars, date_range, int(min_year), int(max_year), progress
+            )
+            # Gradio can't directly update a variable number of plots.
+            # A workaround is to return a list and handle it, or create a fixed number of plot outputs.
+            # For simplicity, we'll return the first plot if it exists.
+            first_plot = plots[0] if plots else None
+            return error, df, first_plot, msg
+        except Exception as e:
+            return f"Input error: {e}", None, None, "Failed"
+
+
+    # We create a single plot output for simplicity. For multiple plots, a dynamic UI update is more complex.
+    plot_output = gr.Plot(label="Time Series Plot")
+
+    calculate_button.click(
+        fn=calculate_wrapper,
+        inputs=[
+            geometry_data, buffer_geometry_data, veg_indices_checkboxes,
+            evi_g, evi_c1, evi_c2, evi_l, evi_c,
+            date_start_input, date_end_input,
+            min_year_input, max_year_input
+        ],
+        outputs=[results_info_box, timeseries_table, plot_output, results_info_box]
+    )
+
+    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>
+            <p>Supported by <a href="https://forests.gujarat.gov.in/">Gujarat Forest Department</a></p>
+        </div>
+    """)
+
+if __name__ == "__main__":
+    demo.launch(debug=True)