Add Zonalstats for Buffer

app.py

@@ -1,196 +1,257 @@
-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
-
-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_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
-
-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
-
-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())
-  print(geojson_data)
-
-# 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'])
-
-# Print Number of Images in collection
-# print("Number of images", collection.size().getInfo())
-st.write(f"Number of images: {collection.size().getInfo()}")
-
-# Calculate NDVI as Normalized Index
-def calculate_ndvi(image):
-  ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI')
-  return image.addBands(ndvi)
-
-collection = collection.map(calculate_ndvi)
-
-# Write Zonalstats into csv file
-# out_dir = os.path.join("Output")
-# out_NDVI_stats = os.path.join(out_dir, "tmp.csv")
-
-# if not os.path.exists(out_dir):
-#     os.makedirs(out_dir)
-
-geemap.zonal_stats(collection.select(["NDVI"]), ee_object, "tmp.csv", stat_type="mean", scale=10)
-
-# Show the table
-df = pd.read_csv("tmp.csv")
-df = df.T
-df = df.reset_index()
-df = df.iloc[:-2]
-df['index'] = pd.to_datetime(df['index'].apply(lambda x: x.split('_')[1].split('T')[0])).dt.strftime('%Y-%m-%d')
-df.rename(columns={'index': 'Date', 0: 'Mean NDVI'}, inplace=True)
-st.write(df)
-
-# plot the time series
-st.write("Time Series Plot")
-st.line_chart(df.set_index('Date'))
-
-st.write(f"Overall Mean NDVI: {df['Mean NDVI'].mean():.2f}")
+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.")