Visualize Latest NDVI on map

app.py

@@ -19,7 +19,7 @@ import numpy as np
 # Enable fiona driver
 fiona.drvsupport.supported_drivers['LIBKML'] = 'rw'
 
-#Intialize EE library  
+# Intialize EE library  
 # Access secret
 earthengine_credentials = os.environ.get("EE_Authentication")
 
@@ -82,18 +82,21 @@ def validate_KML_file(gdf):
 
     return polygon_info
 
-# Calculate NDVI as Normalized Index
+# Function to compute zonal NDVI and add it as a property to the image
 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)
+    # Compute NDVI using Sentinel-2 bands (B8 - NIR, B4 - Red)
+    ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI')
+    
+    # Reduce the region to get the mean NDVI value for the given geometry
+    reduced = ndvi.reduceRegion(
+        reducer=ee.Reducer.mean(),
+        geometry=ee_object.geometry(),
+        scale=10,
+        maxPixels=1e12
+    )
+    
+    # Set the reduced NDVI mean as a property on the image
+    return ndvi.set('NDVI_mean', reduced.get('NDVI'))
 
 # Calculate NDVI
 def calculate_NDVI(image):
@@ -112,38 +115,108 @@ def get_zonal_ndviYoY(collection, ee_object):
     return reduced_max_ndvi.get('NDVI').getInfo()
 
 # Get Zonal NDVI
-def get_zonal_ndvi(collection, geom_ee_object):
+def get_zonal_ndvi(collection, geom_ee_object, return_ndvi=True):
   reduced_collection = collection.map(lambda image: reduce_zonal_ndvi(image, ee_object=geom_ee_object))
-  stats_list = reduced_collection.aggregate_array('NDVI').getInfo()
+  stats_list = reduced_collection.aggregate_array('NDVI_mean').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
-
+  dates = [f.split("_")[0].split('T')[0] for f in filenames]
+  df = pd.DataFrame({'NDVI': stats_list, 'Dates': dates, 'Imagery': filenames, 'Id': filenames})
+  if return_ndvi==True:
+    return df, reduced_collection
+  else:
+    return df
 
-# put title in center
+# Apply custom CSS for a visually appealing layout
 st.markdown("""
-<style>
-h1 {
-    text-align: center;
-}
-</style>
+    <style>
+    /* General body styling */
+    body {
+        background-color: #f9f9f9;  /* Light gray background */
+        color: #333;                /* Dark text color */
+        font-family: 'Arial', sans-serif;  /* Clean font */
+        line-height: 1.6;           /* Improved line spacing */
+    }
+
+    /* Center title */
+    h1 {
+        text-align: center;
+        color: #2c3e50;            /* Darker blue for headings */
+        margin-bottom: 20px;       /* Spacing below heading */
+    }
+
+    /* Subheading styling */
+    h2, h3 {
+        color: #2980b9;            /* Blue color for subheadings */
+    }
+
+    /* Paragraph and list styling */
+    p, li {
+        margin-bottom: 15px;       /* Spacing between paragraphs and list items */
+    }
+
+    /* Link styling */
+    a {
+        color: #2980b9;            /* Blue links */
+        text-decoration: none;      /* Remove underline */
+    }
+    
+    a:hover {
+        text-decoration: underline; /* Underline on hover */
+    }
+
+    /* Button styling */
+    .stButton {
+        background-color: #2980b9; /* Blue button */
+        color: white;              /* White text */
+        border: none;              /* No border */
+        border-radius: 5px;       /* Rounded corners */
+        padding: 10px 20px;       /* Padding */
+        cursor: pointer;           /* Pointer cursor */
+    }
+
+    .stButton:hover {
+        background-color: #1c6690; /* Darker blue on hover */
+    }
+
+    /* Adjust layout for printing */
+    @media print {
+        body {
+            background-color: white; /* White background for printing */
+            color: black;            /* Black text for printing */
+        }
+        h1, h2, h3 {
+            color: black;            /* Black headings for printing */
+        }
+        .stButton {
+            display: none;           /* Hide buttons on print */
+        }
+    }
+    </style>
 """, unsafe_allow_html=True)
 
-st.title("Mean NDVI Calculator")
+st.title("Zonal Average NDVI Trend 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'))
-# Check if start and end dates are valid
-if start_date>end_date:
-    st.write('ValueError: "Incorrect start and/or end dates."')
-    st.stop()
+# Function to create dropdowns for date input
+def date_selector(label):
+    day = st.selectbox(f"Select {label} day", list(range(1, 32)), key=f"{label}_day")
+    month = st.selectbox(f"Select {label} month", 
+                         ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], 
+                         key=f"{label}_month")
+    month = datetime.strptime(month, "%B").month
+    try:
+        # Try to create a date
+        datetime(year=2024, month=month, day=day)  # Using a leap year for completeness
+        return (day, month)
+    except ValueError:
+        st.write("Invalid date and month !")
+        st.stop()
 
-start_date = start_date.strftime("%Y-%m-%d")
-end_date = end_date.strftime("%Y-%m-%d")
+# Create date selectors for start date and end date
+(start_day, start_month), start_year = date_selector("start"), datetime.now().year
+(end_day, end_month), end_year = date_selector("end"), datetime.now().year
 
+start_date = datetime(day=start_day, month=start_month, year=start_year)
+end_date = datetime(day=end_day, month=end_month, year=end_year)
 
 max_cloud_cover = st.number_input("Max Cloud Cover", value=20)
 
@@ -184,40 +257,19 @@ if uploaded_file is not None:
         # 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.filterBounds(geom_ee_object), geom_ee_object)
-        # df_buffered_geom = get_zonal_ndvi(collection.filterBounds(buffered_ee_object), 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']]
-
-        # # Write the final table
-        # st.write(resultant_df)
-        
-        # # plot the time series
-        # st.write("Time Series Plot")
-        # st.line_chart(resultant_df[['AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Date']].set_index('Date'))
-
         ####### YoY Profile ########
         start_year = 2019
         end_year = datetime.now().year
 
         # Create an empty resultant dataframe
-        columns = ['Date', 'Imagery', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio']
+        columns = ['Dates', 'Imagery', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio', 'Id']
         combined_df = pd.DataFrame(columns=columns)
         
         max_ndvi_geoms = []
         max_ndvi_buffered_geoms = []
         years=[]
+        ndvi_collections = []
+        df_geoms = []
         for year in range(start_year, end_year+1):
             try:
                 # Construct start and end dates for every year
@@ -233,56 +285,96 @@ if uploaded_file is not None:
                 years.append(str(year))
 
                 # Get Zonal NDVI
-                df_geom = get_zonal_ndvi(collection.filterBounds(geom_ee_object), geom_ee_object)
-                df_buffered_geom = get_zonal_ndvi(collection.filterBounds(buffered_ee_object), buffered_ee_object)
+                df_geom, ndvi_collection = get_zonal_ndvi(collection.filterBounds(geom_ee_object), geom_ee_object)
+                df_buffered_geom, ndvi_collection = get_zonal_ndvi(collection.filterBounds(buffered_ee_object), buffered_ee_object)
+                ndvi_collections.append(ndvi_collection)
+                df_geoms.append(df_geom)
+
 
                 # 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 = pd.merge(df_geom, df_buffered_geom, on='Id', how='inner')
+                resultant_df = resultant_df.rename(columns={'NDVI_x': 'AvgNDVI_Inside', 'NDVI_y': 'Avg_NDVI_Buffer', 'Imagery_x': 'Imagery', 'Dates_x': 'Dates'})
                 resultant_df['Ratio'] = resultant_df['AvgNDVI_Inside'] / resultant_df['Avg_NDVI_Buffer']
-                resultant_df.drop(columns=['Imagery_y'], inplace=True)
+                resultant_df.drop(columns=['Imagery_y', 'Dates_y'], inplace=True)
     
                 # Re-order the columns of the resultant dataframe
-                resultant_df = resultant_df[['Date', 'Imagery', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio']]
+                resultant_df = resultant_df[['Dates', 'Imagery', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio', 'Id']]
 
                 # Append to empty dataframe
                 combined_df = pd.concat([combined_df, resultant_df], ignore_index=True)
             except:
                 continue
 
-            
+        
         # Write the final table
-        st.write(combined_df)
+        st.write("NDVI details based on Sentinel-2 Surface Reflectance Bands")
+        st.write(combined_df[['Dates', 'Imagery', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio']])
+
 
         # Plot the multiyear timeseries 
         st.write("Multiyear Time Series Plot (for given duration)")
-        st.line_chart(combined_df[['AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Date']].set_index('Date'))
+        st.line_chart(combined_df[['AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Dates']].set_index('Dates'))
         
         # Create a DataFrame for YoY profile
         yoy_df = pd.DataFrame({'Year': years, 'NDVI_Inside': max_ndvi_geoms, 'NDVI_Buffer': max_ndvi_buffered_geoms})
         yoy_df['Ratio'] = yoy_df['NDVI_Inside'] / yoy_df['NDVI_Buffer']
-        slope, intercept = np.polyfit(yoy_df['Year'].astype(int), yoy_df['NDVI_Inside'], 1)
+        slope, intercept = np.polyfit(list(range(1, len(years)+1)), yoy_df['NDVI_Inside'], 1)
 
         # plot the time series
-        st.write("Year on Year Plot using Maximum NDVI Composite (computed for given duration)")
+        st.write("Year on Year Profile using Maximum NDVI Composite (computed for given duration)")
         st.line_chart(yoy_df[['NDVI_Inside', 'NDVI_Buffer', 'Ratio', 'Year']].set_index('Year'))
         st.write("Slope (trend) and Intercept are {}, {} respectively. ".format(np.round(slope, 4), np.round(intercept, 4)))
 
+        #Get Latest NDVI Collection with completeness
+        ndvi_collection = None
+        for i in range(len(ndvi_collections)):
+          #Check size of NDVI collection
+          ndvi_collection = ndvi_collections[len(ndvi_collections)-i-1]
+          df_geom = df_geoms[len(ndvi_collections)-i-1]
+          if ndvi_collection.size().getInfo()>0:
+            break
         
-        # Visualize map on ESRI basemap
+        #Map Visualization
         st.write("Map Visualization")
 
+        # Function to create the map
+        def create_map():
+            m = geemapfolium.Map(center=(polygon_info['centroid'][1],polygon_info['centroid'][0]), zoom=14)  # Create a Folium map
+            
+            n_layers = 4 #controls the number of images to be displayed
+            for i in range(min(n_layers, ndvi_collection.size().getInfo())):
+              ndvi_image = ee.Image(ndvi_collection.toList(ndvi_collection.size()).get(i))
+              date = df_geom.iloc[i]["Dates"]
+            
+              # Add the image to the map as a layer
+              layer_name = f"Image {i+1} - {date}"
+              vis_params = {'min': -1, 'max': 1, 'palette': ['blue', 'white', 'green']}  # Example visualization for Sentinel-2
+              m.add_layer(ndvi_image, vis_params, layer_name, z_index=i+10)
+            
+            m.add_layer(geom_ee_object, {}, 'KML Original', z_index=1)
+            m.add_layer(buffered_ee_object, {}, 'KML Buffered', z_index=2)
+            
+            m.add_layer_control()
+            return m
+
+        # Cache the map to avoid recomputation on interaction (faster)
+        @st.cache_resource
+        def get_map():
+            return create_map()
+
         # Create Folium Map object
-        m = geemapfolium.Map(center=(polygon_info['centroid'][1],polygon_info['centroid'][0]), zoom=14)
-        # Center the map and display the image.
-        m.add_layer(geom_ee_object, {}, 'KML Original')
-        m.add_layer(buffered_ee_object, {}, 'KML Buffered')
-        m.add_layer_control()
-        st_folium(m)
-        
+        if "map" not in st.session_state:
+          st.session_state["map"] = get_map()
+
+        # Display the map and allow interactions without triggering reruns
+        with st.container():
+            # st_folium should not cause reruns, just return user interactions
+            st_folium(st.session_state["map"], width=725, returned_objects=[])
     
     else:
         st.write('ValueError: "Input must have single polygon geometry"')
         st.write(gdf)
         st.stop()
 
+
+