Upload app.py

app.py

@@ -1,191 +1,375 @@
-import os
-import ee
-import geemap
-import json
-import geopandas as gpd
-import streamlit as st
-import pandas as pd
-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()
-
-# Functions
-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 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 {
-        '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 = convert_to_2d_geometry(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
-
-# 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))
-  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
-
-# 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"])
-
-
-
-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()
+import os
+import ee
+import geemap
+import json
+import geopandas as gpd
+import streamlit as st
+import pandas as pd
+<<<<<<< HEAD
+from fastkml import kml
+import geojson
+from shapely.geometry import Polygon, MultiPolygon, shape, Point
+
+=======
+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 
+>>>>>>> 4072fc2e14e38a014c456666d781a212750773a4
+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)
+<<<<<<< HEAD
+
+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
+
+=======
+ee.Initialize()
+
+# Functions
+>>>>>>> 4072fc2e14e38a014c456666d781a212750773a4
+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
+  
+<<<<<<< HEAD
+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.")
+>>>>>>> 4072fc2e14e38a014c456666d781a212750773a4
+
+    if gdf.empty:
+      return {
+        'corner_points': None,
+        'area': None,
+        'perimeter': None,
+        'is_single_polygon': False}
+
+    polygon_info = {}
+<<<<<<< HEAD
+  
+    # 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] 
+=======
+
+    # Check if it's a single polygon or multipolygon
+    if isinstance(gdf.iloc[0].geometry, Polygon):
+      polygon_info['is_single_polygon'] = True
+
+      polygon = convert_to_2d_geometry(gdf.geometry.iloc[0])
+>>>>>>> 4072fc2e14e38a014c456666d781a212750773a4
+
+      # 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]
+
+<<<<<<< HEAD
+      # 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
+>>>>>>> 4072fc2e14e38a014c456666d781a212750773a4
+      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
+
+<<<<<<< HEAD
+=======
+# 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)
+
+>>>>>>> 4072fc2e14e38a014c456666d781a212750773a4
+# 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
+
+<<<<<<< HEAD
+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
+
+=======
+>>>>>>> 4072fc2e14e38a014c456666d781a212750773a4
+# 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"])
+
+<<<<<<< HEAD
+# 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()
+>>>>>>> 4072fc2e14e38a014c456666d781a212750773a4