Spaces:
Sleeping
Sleeping
| import os | |
| import ee | |
| import geemap | |
| import json | |
| import geopandas as gpd | |
| import streamlit as st | |
| import pandas as pd | |
| from fastkml import kml | |
| import geojson | |
| from shapely.geometry import Polygon, MultiPolygon, shape, Point | |
| ee_credentials = os.environ.get("EE") | |
| os.makedirs(os.path.expanduser("~/.config/earthengine/"), exist_ok=True) | |
| with open(os.path.expanduser("~/.config/earthengine/credentials"), "w") as f: | |
| f.write(ee_credentials) | |
| ee.Initialize() | |
| def convert_3d_to_2d(geometry): | |
| """ | |
| Recursively convert any 3D coordinates in a geometry to 2D. | |
| """ | |
| if geometry.is_empty: | |
| return geometry | |
| if geometry.geom_type == 'Polygon': | |
| return geojson.Polygon([[(x, y) for x, y, *_ in ring] for ring in geometry.coordinates]) | |
| elif geometry.geom_type == 'MultiPolygon': | |
| return geojson.MultiPolygon([ | |
| [[(x, y) for x, y, *_ in ring] for ring in poly] | |
| for poly in geometry.coordinates | |
| ]) | |
| elif geometry.geom_type == 'LineString': | |
| return geojson.LineString([(x, y) for x, y, *_ in geometry.coordinates]) | |
| elif geometry.geom_type == 'MultiLineString': | |
| return geojson.MultiLineString([ | |
| [(x, y) for x, y, *_ in line] | |
| for line in geometry.coordinates | |
| ]) | |
| elif geometry.geom_type == 'Point': | |
| x, y, *_ = geometry.coordinates | |
| return geojson.Point((x, y)) | |
| elif geometry.geom_type == 'MultiPoint': | |
| return geojson.MultiPoint([(x, y) for x, y, *_ in geometry.coordinates]) | |
| return geometry # Return unchanged if not a supported geometry type | |
| def convert_to_2d_geometry(geom): #Handles Polygon Only | |
| if geom is None: | |
| return None | |
| elif geom.has_z: | |
| # Extract exterior coordinates and convert to 2D | |
| exterior_coords = geom.exterior.coords[:] # Get all coordinates of the exterior ring | |
| exterior_coords_2d = [(x, y) for x, y, *_ in exterior_coords] # Keep only the x and y coordinates, ignoring z | |
| # Handle interior rings (holes) if any | |
| interior_coords_2d = [] | |
| for interior in geom.interiors: | |
| interior_coords = interior.coords[:] | |
| interior_coords_2d.append([(x, y) for x, y, *_ in interior_coords]) | |
| # Create a new Polygon with 2D coordinates | |
| return type(geom)(exterior_coords_2d, interior_coords_2d) | |
| else: | |
| return geom | |
| def kml_to_geojson(kml_string): | |
| k = kml.KML() | |
| k.from_string(kml_string.encode('utf-8')) # Convert the string to bytes | |
| features = list(k.features()) | |
| geojson_features = [] | |
| for feature in features: | |
| geometry_2d = convert_3d_to_2d(feature.geometry) | |
| geojson_features.append(geojson.Feature(geometry=geometry_2d)) | |
| geojson_data = geojson.FeatureCollection(geojson_features) | |
| return geojson_data | |
| # Calculate NDVI as Normalized Index | |
| def reduce_zonal_ndvi(image, ee_object): | |
| ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI') | |
| image = image.addBands(ndvi) | |
| image = image.select('NDVI') | |
| reduced = image.reduceRegion( | |
| reducer=ee.Reducer.mean(), | |
| geometry=ee_object.geometry(), | |
| scale=10, | |
| maxPixels=1e12 | |
| ) | |
| return image.set(reduced) | |
| # Validate KML File for Single Polygon and return polygon information | |
| def validate_KML_file(kml_file): | |
| try: | |
| gdf = gpd.read_file(kml_file) | |
| except Exception as e: | |
| ValueError("Input must be a valid KML file.") | |
| if gdf.empty: | |
| return { | |
| 'corner_points': None, | |
| 'area': None, | |
| 'perimeter': None, | |
| 'is_single_polygon': False} | |
| polygon_info = {} | |
| # Check if it's a single polygon or multipolygon | |
| if isinstance(gdf.iloc[0].geometry, Polygon): | |
| polygon_info['is_single_polygon'] = True | |
| polygon = gdf.geometry.iloc[0] | |
| # Calculate corner points in GCS projection | |
| polygon_info['corner_points'] = [ | |
| (polygon.bounds[0], polygon.bounds[1]), | |
| (polygon.bounds[2], polygon.bounds[1]), | |
| (polygon.bounds[2], polygon.bounds[3]), | |
| (polygon.bounds[0], polygon.bounds[3]) | |
| ] | |
| # Calculate Centroids in GCS projection | |
| polygon_info['centroid'] = polygon.centroid.coords[0] | |
| # Calculate area and perimeter in EPSG:7761 projection | |
| # It is a local projection defined for Gujarat as per NNRMS | |
| polygon = gdf.to_crs(epsg=7761).geometry.iloc[0] | |
| polygon_info['area'] = polygon.area | |
| polygon_info['perimeter'] = polygon.length | |
| else: | |
| polygon_info['is_single_polygon'] = False | |
| polygon_info['corner_points'] = None | |
| polygon_info['area'] = None | |
| polygon_info['perimeter'] = None | |
| polygon_info['centroid'] = None | |
| ValueError("Input must be a single Polygon.") | |
| return polygon_info | |
| # Get Zonal NDVI | |
| def get_zonal_ndvi(collection, geom_ee_object): | |
| reduced_collection = collection.map(lambda image: reduce_zonal_ndvi(image, ee_object=geom_ee_object)) | |
| stats_list = reduced_collection.aggregate_array('NDVI').getInfo() | |
| filenames = reduced_collection.aggregate_array('system:index').getInfo() | |
| dates = [f.split("_")[0].split('T')[0] for f in reduced_collection.aggregate_array('system:index').getInfo()] | |
| df = pd.DataFrame({'NDVI': stats_list, 'Date': dates, 'Imagery': filenames}) | |
| return df | |
| def geojson_to_ee(geojson_data): | |
| ee_object = ee.FeatureCollection(geojson_data) | |
| return ee_object | |
| def kml_to_gdf(kml_file): | |
| try: | |
| gdf = gpd.read_file(kml_file) | |
| for i in range(len(gdf)): | |
| geom = gdf.iloc[i].geometry | |
| new_geom = convert_to_2d_geometry(geom) | |
| gdf.loc[i, 'geometry'] = new_geom | |
| print(gdf.iloc[i].geometry) | |
| print(f"KML file '{kml_file}' successfully read") | |
| except Exception as e: | |
| print(f"Error: {e}") | |
| return gdf | |
| # put title in center | |
| st.markdown(""" | |
| <style> | |
| h1 { | |
| text-align: center; | |
| } | |
| </style> | |
| """, unsafe_allow_html=True) | |
| st.title("Mean NDVI Calculator") | |
| # get the start and end date from the user | |
| col = st.columns(2) | |
| start_date = col[0].date_input("Start Date", value=pd.to_datetime('2021-01-01')) | |
| end_date = col[1].date_input("End Date", value=pd.to_datetime('2021-01-30')) | |
| start_date = start_date.strftime("%Y-%m-%d") | |
| end_date = end_date.strftime("%Y-%m-%d") | |
| max_cloud_cover = st.number_input("Max Cloud Cover", value=20) | |
| # Get the geojson file from the user | |
| uploaded_file = st.file_uploader("Upload KML/GeoJSON file", type=["geojson", "kml"]) | |
| # Read the KML file | |
| if uploaded_file is None: | |
| file_name = "Bhankhara_Df_11_he_5_2020-21.geojson" | |
| st.write(f"Using default file: {file_name}") | |
| data = gpd.read_file(file_name) | |
| with open(file_name) as f: | |
| str_data = f.read() | |
| else: | |
| st.write(f"Using uploaded file: {uploaded_file.name}") | |
| file_name = uploaded_file.name | |
| bytes_data = uploaded_file.getvalue() | |
| str_data = bytes_data.decode("utf-8") | |
| if file_name.endswith(".geojson"): | |
| geojson_data = json.loads(str_data) | |
| elif file_name.endswith(".kml"): | |
| geojson_data = json.loads(kml_to_gdf(str_data).to_json()) | |
| # Read Geojson File | |
| ee_object = geojson_to_ee(geojson_data) | |
| # Filter data based on the date, bounds, cloud coverage and select NIR and Red Band | |
| collection = ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED").filterBounds(ee_object).filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', max_cloud_cover)).filter(ee.Filter.date(start_date, end_date)).select(['B4', 'B8']) | |
| polygon_info = validate_KML_file(str_data) | |
| if polygon_info['is_single_polygon']: | |
| # Read KML file | |
| geom_ee_object = ee.FeatureCollection(geojson_data) | |
| # Add buffer of 100m to ee_object | |
| buffered_ee_object = geom_ee_object.map(lambda feature: feature.buffer(100)) | |
| # Filter data based on the date, bounds, cloud coverage and select NIR and Red Band | |
| collection = ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED").filterBounds(geom_ee_object).filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 20)).filter(ee.Filter.date('2022-01-01', '2023-01-01')).select(['B4', 'B8']) | |
| # Get Zonal NDVI based on collection and geometries (Original KML and Buffered KML) | |
| df_geom = get_zonal_ndvi(collection, geom_ee_object) | |
| df_buffered_geom = get_zonal_ndvi(collection, buffered_ee_object) | |
| # Merge both Zonalstats and create resultant dataframe | |
| resultant_df = pd.merge(df_geom, df_buffered_geom, on='Date', how='inner') | |
| resultant_df = resultant_df.rename(columns={'NDVI_x': 'AvgNDVI_Inside', 'NDVI_y': 'Avg_NDVI_Buffer'}) | |
| resultant_df['Ratio'] = resultant_df['AvgNDVI_Inside'] / resultant_df['Avg_NDVI_Buffer'] | |
| resultant_df.drop(columns=['Imagery_y'], inplace=True) | |
| # Re-order the columns of the resultant dataframe | |
| resultant_df = resultant_df[['Date', 'Imagery_x', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio']] | |
| # Map = geemap.Map(center=(polygon_info['centroid'][1],polygon_info['centroid'][0]) , zoom=12) | |
| # Map.addLayer(geom_ee_object, {}, 'Layer1') | |
| # Map.addLayer(buffered_ee_object, {}, 'Layer2') | |
| # plot the time series | |
| st.write("Time Series Plot") | |
| st.line_chart(resultant_df.set_index('Date')) | |
| #st.write(f"Overall Mean NDVI: {resultant_df['Mean NDVI'].mean():.2f}") | |
| else: | |
| print("Input must be a single Polygon.") |