Transparent Geometry, Add Colormap, Visualize MaxNDVI

app.py

@@ -15,6 +15,7 @@ import geemap.foliumap as geemapfolium
 from streamlit_folium import st_folium
 from datetime import datetime
 import numpy as np
+import branca.colormap as cm
 
 # Enable fiona driver
 fiona.drvsupport.supported_drivers['LIBKML'] = 'rw'
@@ -98,6 +99,23 @@ def reduce_zonal_ndvi(image, ee_object):
     # Set the reduced NDVI mean as a property on the image
     return ndvi.set('NDVI_mean', reduced.get('NDVI'))
 
+# Function to compute cloud probability and add it as a property to the image
+def reduce_zonal_cloud_probability(image, ee_object):
+    # Compute cloud probability using the SCL band (Scene Classification Layer) in Sentinel-2
+    cloud_probability = image.select('MSK_CLDPRB').rename('cloud_probability')
+
+    # Reduce the region to get the mean cloud probability value for the given geometry
+    reduced = cloud_probability.reduceRegion(
+        reducer=ee.Reducer.mean(),
+        geometry=ee_object.geometry(),
+        scale=10,
+        maxPixels=1e12
+    )
+
+    # Set the reduced cloud probability mean as a property on the image
+    return image.set('cloud_probability_mean', reduced.get('cloud_probability'))
+
+
 # Calculate NDVI
 def calculate_NDVI(image):
     ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI')
@@ -112,15 +130,19 @@ def get_zonal_ndviYoY(collection, ee_object):
         geometry=ee_object.geometry(),
         scale=10,
         maxPixels=1e12)
-    return reduced_max_ndvi.get('NDVI').getInfo()
+    return reduced_max_ndvi.get('NDVI').getInfo(), max_ndvi
+
+
 
 # Get Zonal NDVI
 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))
+  cloud_prob_collection = collection.map(lambda image: reduce_zonal_cloud_probability(image, ee_object=geom_ee_object))
   stats_list = reduced_collection.aggregate_array('NDVI_mean').getInfo()
   filenames = reduced_collection.aggregate_array('system:index').getInfo()
+  cloud_probabilities = cloud_prob_collection.aggregate_array('cloud_probability_mean').getInfo()
   dates = [f.split("_")[0].split('T')[0] for f in filenames]
-  df = pd.DataFrame({'NDVI': stats_list, 'Dates': dates, 'Imagery': filenames, 'Id': filenames})
+  df = pd.DataFrame({'NDVI': stats_list, 'Dates': dates, 'Imagery': filenames, 'Id': filenames, 'CLDPRB': cloud_probabilities})
   if return_ndvi==True:
     return df, reduced_collection
   else:
@@ -199,10 +221,14 @@ st.title("Zonal Average NDVI Trend Calculator")
 input_container = st.container()
 # 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")
+    day_options = list(range(1, 32))
+    if label=='start':
+        day = st.selectbox(f"Select {label} day", day_options, key=f"{label}_day", index=0)
+    else:
+        day = st.selectbox(f"Select {label} day", day_options, key=f"{label}_day", index=14)
+
+    month_options = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
+    month = st.selectbox(f"Select {label} month", month_options, key=f"{label}_month",index=11)
     month = datetime.strptime(month, "%B").month
     try:
         # Try to create a date
@@ -265,14 +291,16 @@ if uploaded_file is not None and submit_button:
         end_year = datetime.now().year
 
         # Create an empty resultant dataframe
-        columns = ['Dates', 'Imagery', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio', 'Id']
+        columns = ['Dates', 'Imagery', 'AvgNDVI_Inside', 'CLDPRB', 'Avg_NDVI_Buffer', 'CLDPRB_Buffer', 'Ratio', 'Id' ]
         combined_df = pd.DataFrame(columns=columns)
         
+        # Create empty lists of parameters
         max_ndvi_geoms = []
         max_ndvi_buffered_geoms = []
         years=[]
         ndvi_collections = []
         df_geoms = []
+        max_ndvis = []
         for year in range(start_year, end_year+1):
             try:
                 # Construct start and end dates for every year
@@ -280,95 +308,122 @@ if uploaded_file is not None and submit_button:
                 end_ddmm = str(year)+pd.to_datetime(end_date).strftime("-%m-%d")     
             
                 # 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_ddmm, end_ddmm)).select(['B4', 'B8'])
+                collection = ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED").filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', max_cloud_cover)).filter(ee.Filter.date(start_ddmm, end_ddmm))
         
                 # Get Zonal Max composite NDVI based on collection and geometries (Original KML and Buffered KML)
-                max_ndvi_geoms.append(get_zonal_ndviYoY(collection.filterBounds(geom_ee_object), geom_ee_object))
-                max_ndvi_buffered_geoms.append(get_zonal_ndviYoY(collection.filterBounds(buffered_ee_object), buffered_ee_object))
+                max_ndvi_geom, max_ndvi = get_zonal_ndviYoY(collection.filterBounds(geom_ee_object), geom_ee_object) # max_NDVI is image common to both
+                max_ndvi_geoms.append(max_ndvi_geom)
+                max_ndvi_geom, max_ndvi = get_zonal_ndviYoY(collection.filterBounds(buffered_ee_object), buffered_ee_object)
+                max_ndvi_buffered_geoms.append(max_ndvi_geom)
+                max_ndvis.append(max_ndvi)
                 years.append(str(year))
 
                 # Get Zonal NDVI
-                df_geom, ndvi_collection = get_zonal_ndvi(collection.filterBounds(geom_ee_object), geom_ee_object)
+                df_geom, ndvi_collection = get_zonal_ndvi(collection.filterBounds(geom_ee_object), geom_ee_object) # ndvi collection is common to both
                 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
+                # Merge both Zonalstats on ID and create resultant dataframe
                 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 = resultant_df.rename(columns={'NDVI_x': 'AvgNDVI_Inside', 'NDVI_y': 'Avg_NDVI_Buffer', 'Imagery_x': 'Imagery', 'Dates_x': 'Dates', 
+                                                            'CLDPRB_x': 'CLDPRB', 'CLDPRB_y': 'CLDPRB_Buffer'})
                 resultant_df['Ratio'] = resultant_df['AvgNDVI_Inside'] / resultant_df['Avg_NDVI_Buffer']
                 resultant_df.drop(columns=['Imagery_y', 'Dates_y'], inplace=True)
     
                 # Re-order the columns of the resultant dataframe
-                resultant_df = resultant_df[['Dates', 'Imagery', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio', 'Id']]
+                resultant_df = resultant_df[columns]
 
                 # Append to empty dataframe
                 combined_df = pd.concat([combined_df, resultant_df], ignore_index=True)
-            except:
+            except Exception as e:
                 continue
 
-        
-        # Write the final table
-        st.write("NDVI details based on Sentinel-2 Surface Reflectance Bands")
-        st.write(combined_df[['Dates', 'Imagery', 'AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Ratio']])
-
+        if len(combined_df)>1:
+            # Write the final table
+            st.write("NDVI details based on Sentinel-2 Surface Reflectance Bands")
+            st.write(combined_df[columns[:-1]])
 
-        # Plot the multiyear timeseries 
-        st.write("Multiyear Time Series Plot (for given duration)")
-        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(list(range(1, len(years)+1)), yoy_df['NDVI_Inside'], 1)
-
-        # plot the time series
-        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
-        
-        #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
+            # Plot the multiyear timeseries 
+            st.write("Multiyear Time Series Plot (for given duration)")
+            st.line_chart(combined_df[['AvgNDVI_Inside', 'Avg_NDVI_Buffer', 'Dates']].set_index('Dates'))
             
-            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"]
+            # 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(list(range(1, len(years)+1)), yoy_df['NDVI_Inside'], 1)
+
+            # plot the time series
+            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
             
-              # 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, opacity=0.5)
-            
-            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
-
-        # Create Folium Map object
-        if "map" not in st.session_state or submit_button:
-          st.session_state["map"] = create_map()
-
-        # Display the map and allow interactions without triggering reruns
-        with st.container():
-            st_folium(st.session_state["map"], width=725, returned_objects=[])
-    
+            #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
+                
+                vis_params = {'min': -1, 'max': 1, 'palette': ['blue', 'white', 'green']}  # Example visualization for Sentinel-2
+
+                # Create a colormap and name it as NDVI
+                colormap = cm.LinearColormap(
+                    colors=vis_params['palette'], 
+                    vmin=vis_params['min'], 
+                    vmax=vis_params['max']
+                )
+                colormap.caption = 'NDVI'
+
+                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"Sentinel-2 NDVI - {date}"
+                    m.add_layer(ndvi_image, vis_params, layer_name, z_index=i+10, opacity=0.5)
+
+                for i in range(len(max_ndvis)):
+                    layer_name = f"Sentinel-2 MaxNDVI-{years[i]}"
+                    m.add_layer(max_ndvis[i], vis_params, layer_name, z_index=i+20, opacity=0.5)
+                
+                # Add the colormap to the map
+                m.add_child(colormap)   
+                
+                geom_vis_params = {'color': '000000', 'pointSize': 3,'pointShape': 'circle','width': 2,'lineType': 'solid','fillColor': '00000000'}
+                buffer_vis_params = {'color': 'FF0000', 'pointSize': 3,'pointShape': 'circle','width': 2,'lineType': 'solid','fillColor': '00000000'}
+
+                m.add_layer(geom_ee_object.style(**geom_vis_params), {}, 'KML Original', z_index=1, opacity=1)
+                m.add_layer(buffered_ee_object.style(**buffer_vis_params), {}, 'KML Buffered', z_index=2, opacity=1)
+
+                m.add_layer_control()
+                return m
+
+            # Create Folium Map object and store it in streamlit session
+            if "map" not in st.session_state or submit_button:
+                st.session_state["map"] = create_map()
+
+            # Display the map and allow interactions without triggering reruns
+            with st.container():
+                st_folium(st.session_state["map"], width=725, returned_objects=[])
+        else:
+            # Failed to find any Sentinel-2 Image in given period
+            st.write("No Sentinel-2 Imagery found for the given period.")
+            st.stop()
     else:
+        # Failed to have single polygon geometry
         st.write('ValueError: "Input must have single polygon geometry"')
         st.write(gdf)
         st.stop()