Update app.py

app.py

@@ -5,51 +5,23 @@ 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
+from io import BytesIO
 
+
+# Enable fiona driver
+gpd.io.file.fiona.drvsupport.supported_drivers['KML'] = 'rw'
+
+#Intialize EE library 
+# Error in EE Authentication 
 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
-
+# Functions
 def convert_to_2d_geometry(geom): #Handles Polygon Only
   if geom is None:
     return None
@@ -69,38 +41,11 @@ def convert_to_2d_geometry(geom): #Handles Polygon Only
   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.")
+def validate_KML_file(gdf):
+    # try:
+    #   gdf = gpd.read_file(BytesIO(uploaded_file.read()), driver='KML')
+    # except Exception as e:
+    #   ValueError("Input must be a valid KML file.")
 
     if gdf.empty:
       return {
@@ -110,12 +55,12 @@ def validate_KML_file(kml_file):
         '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] 
+
+      polygon = convert_to_2d_geometry(gdf.geometry.iloc[0])
 
       # Calculate corner points in GCS projection
       polygon_info['corner_points'] = [
@@ -128,8 +73,8 @@ def validate_KML_file(kml_file):
       # 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 
+      # 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
@@ -144,6 +89,19 @@ def validate_KML_file(kml_file):
 
     return polygon_info
 
+# 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)
+
 # 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))
@@ -153,23 +111,6 @@ def get_zonal_ndvi(collection, geom_ee_object):
   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>
@@ -193,65 +134,58 @@ 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.")
+if uploaded_file is not None:
+    try:
+        if uploaded_file.name.endswith("kml"):
+            gdf = gpd.read_file(BytesIO(uploaded_file.read()), driver='KML')
+        elif uploaded_file.name.endswith("geojson"):
+            gdf = gpd.read_file(uploaded_file)
+    except Exception as e:
+      st.write('ValueError: "Input must be a valid KML file."')
+      st.stop()
+    
+    # Validate KML File
+    polygon_info = validate_KML_file(gdf)
+
+    if polygon_info["is_single_polygon"]==True:
+        st.write("Uploaded KML file has single geometry.")
+        st.write("It has bounds as {0:.6f}, {1:.6f}, {2:.6f}, and {3:.6f}.".format(
+            polygon_info['corner_points'][0][0],
+            polygon_info['corner_points'][0][1],
+            polygon_info['corner_points'][2][0],
+            polygon_info['corner_points'][2][1]
+        ))
+        st.write("It has centroid at ({0:.6f}, {1:.6f}).".format(polygon_info['centroid'][0], polygon_info['centroid'][1]))
+        st.write("It has area of {:.2f} meter squared.".format(polygon_info['area']))
+        st.write("It has perimeter of {:.2f} meters.".format(polygon_info['perimeter']))
+
+        # # Read KML file
+        # geom_ee_object = ee.FeatureCollection(json.loads(gdf.to_json()))
+
+        # # 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").filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', max_cloud_cover)).filter(ee.Filter.date(start_date, end_date)).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', 'Imagery_x': 'Imagery'})
+        # 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', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio']]
+
+        # st.write(resultant_df)
+    
+    else:
+        st.write('ValueError: "Input must have single polygon geometry"')
+        st.write(gdf)
+        st.stop()