update app.py

app.py

@@ -12,7 +12,7 @@ import re
 st.set_page_config(layout="wide")
 
 # Custom button styling
-st.markdown(
+m = st.markdown(
     """
     <style>
     div.stButton > button:first-child {
@@ -25,7 +25,7 @@ st.markdown(
 
 # Logo
 st.write(
-    """
+    f"""
     <div style="display: flex; justify-content: space-between; align-items: center;">
         <img src="https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/ISRO_Logo.png"  style="width: 20%; margin-right: auto;">
         <img src="https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/SAC_Logo.png"  style="width: 20%; margin-left: auto;">
@@ -36,7 +36,9 @@ st.write(
 
 # Title
 st.markdown(
-    "<h1 style='text-align: center;'>Precision Analysis for Vegetation, Water, and Air Quality</h1>",
+    f"""
+    <h1 style="text-align: center;">Precision Analysis for Vegetation, Water, and Air Quality</h1>
+    """,
     unsafe_allow_html=True,
 )
 st.write("<h2><div style='text-align: center;'>User  Inputs</div></h2>", unsafe_allow_html=True)
@@ -85,6 +87,13 @@ elif index_choice.lower() == 'custom formula':
     custom_formula = st.text_input("Enter Custom Formula (e.g., '(B5 - B4) / (B5 + B4)')")
     st.write(f"Custom Formula: {custom_formula}")  # Display the custom formula after the user inputs it
 
+# Reducer selection
+reducer_choice = st.selectbox(
+    "Select Reducer",
+    ['mean', 'sum', 'median', 'min', 'max', 'count'],
+    index=0  # Default to 'mean'
+)
+
 # Function to check if the polygon geometry is valid and convert it to the correct format
 def convert_to_ee_geometry(geometry):
     if geometry.is_valid:
@@ -155,65 +164,137 @@ if parameters_changed():
         'file_upload': file_upload
     }
 
-# Function to perform index calculations
+# Function to get the corresponding reducer based on user input
+def get_reducer(reducer_name):
+    """
+    Map user-friendly reducer names to Earth Engine reducer objects.
+
+    Args:
+        reducer_name (str): The name of the reducer (e.g., 'mean', 'sum', 'median').
+
+    Returns:
+        ee.Reducer: The corresponding Earth Engine reducer.
+    """
+    reducers = {
+        'mean': ee.Reducer.mean(),
+        'sum': ee.Reducer.sum(),
+        'median': ee.Reducer.median(),
+        'min': ee.Reducer.min(),
+        'max': ee.Reducer.max(),
+        'count': ee.Reducer.count(),
+    }
+    
+    # Default to 'mean' if the reducer_name is not recognized
+    return reducers.get(reducer_name.lower(), ee.Reducer.mean())
+
+# Function to calculate NDVI
 def calculate_ndvi(image, geometry):
     ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI')
+    
+    # Perform reduction on the region with the selected reducer
     result = ndvi.reduceRegion(
-        reducer=ee.Reducer.mean(),
+        reducer=get_reducer(reducer_choice),
         geometry=geometry,
         scale=30
     )
-    return result.get('NDVI')
+    
+    # Output debugging information
+    result_value = result.get('NDVI')
+    try:
+        calculated_value = result_value.getInfo()
+        st.write(f"NDVI calculation using {reducer_choice}: {calculated_value}")
+    except Exception as e:
+        st.error(f"Error retrieving NDVI result: {e}")
+    
+    return result_value
 
+
+# Function to calculate NDWI
 def calculate_ndwi(image, geometry):
     ndwi = image.normalizedDifference(['B3', 'B8']).rename('NDWI')
     result = ndwi.reduceRegion(
-        reducer=ee.Reducer.mean(),
+        reducer=get_reducer(reducer_choice),
         geometry=geometry,
         scale=30
     )
-    return result.get('NDWI')
+    
+    # Output debugging information
+    result_value = result.get('NDWI')
+    try:
+        calculated_value = result_value.getInfo()
+        st.write(f"NDVI calculation using {reducer_choice}: {calculated_value}")
+    except Exception as e:
+        st.error(f"Error retrieving NDVI result: {e}")
+    
+    return result_value
 
+# Function to calculate Average NO₂ for Sentinel-5P
 def calculate_avg_no2_sentinel5p(image, geometry):
     no2 = image.select('NO2').reduceRegion(
-        reducer=ee.Reducer.mean(),
+        reducer=get_reducer(reducer_choice),
         geometry=geometry,
         scale=1000
-    ).get('NO2')
-    return no2
+       )
+    
+    # Output debugging information
+    result_value = result.get('NDVI')
+    try:
+        calculated_value = result_value.getInfo()
+        st.write(f"NDVI calculation using {reducer_choice}: {calculated_value}")
+    except Exception as e:
+        st.error(f"Error retrieving NDVI result: {e}")
+    
+    return result_value
 
+# Function to calculate Custom Formula
 def calculate_custom_formula(image, geometry, formula, scale=30):
+    """
+    Calculate a custom formula on an image and return the result for a given geometry,
+    using a user-specified reducer.
+    """
+    # Dynamically generate the dictionary of band references from the image
     band_names = image.bandNames().getInfo()
     band_dict = {band: image.select(band) for band in band_names}
     
+    # Use the formula with the bands in the image
     result_image = image.expression(formula, band_dict).rename('CustomResult')
 
+    # Reduce the region to get the result based on the specified reducer
     result = result_image.reduceRegion(
-        reducer=ee.Reducer.mean(),
+        reducer=get_reducer(reducer_choice),
         geometry=geometry,
         scale=scale
-    )
+      )
     
-    return result
+    # Output debugging information
+    result_value = result.get('CustomResult')
+    try:
+        calculated_value = result_value.getInfo()
+        st.write(f"NDVI calculation using {reducer_choice}: {calculated_value}")
+    except Exception as e:
+        st.error(f"Error retrieving NDVI result: {e}")
+    
+    return result_value
 
 # Function to get the most recent image from the collection
 def get_most_recent_image(image_collection):
     image = image_collection.sort('system:time_start', False).first()
     return image
 
-# Function to handle the custom formula choice and calculation
-def process_custom_formula(image, roi, custom_formula):
-    if custom_formula:
-        result = calculate_custom_formula(image, roi, custom_formula)
-        if result:
-            return result.getInfo()
-    return None
+
+# Function to process the custom formula
+def process_custom_formula(image, geometry, formula):
+    return calculate_custom_formula(image, geometry, formula)
 
 locations_df = None  # Initialize locations_df to None
 polygons_df = None   # Ensure polygons_df is initialized at the beginning
 
 # Process each point (with additional checks for file validity)
+# Check the shape type and assign polygons_df only for Polygon data
 if file_upload:
+    # locations_df = None  # Initialize locations_df to None
+    # polygons_df = None   # Ensure polygons_df is initialized at the beginning
+
     file_extension = os.path.splitext(file_upload.name)[1].lower()
 
     # Read file based on shape type
@@ -227,45 +308,58 @@ if file_upload:
         else:
             st.error("Unsupported file type. Please upload a CSV, GeoJSON, or KML file for points.")
     elif shape_type == 'Polygon':
-        if file _extension == '.geojson':
+        if file_extension == '.geojson':
             polygons_df = read_geojson(file_upload)
         elif file_extension == '.kml':
             polygons_df = read_kml(file_upload)
         else:
             st.error("Unsupported file type. Please upload a GeoJSON or KML file for polygons.")
 
+
     if locations_df is not None and not locations_df.empty:
+        # Ensure the necessary columns exist in the dataframe
         if 'latitude' not in locations_df.columns or 'longitude' not in locations_df.columns:
             st.error("Uploaded file is missing required 'latitude' or 'longitude' columns.")
         else:
+            # Display a preview of the points data
             st.write("Preview of the uploaded points data:")
             st.dataframe(locations_df.head())
 
+            # Create a LeafMap object to display the points
             m = leafmap.Map(center=[locations_df['latitude'].mean(), locations_df['longitude'].mean()], zoom=10)
 
+            # Add points to the map using a loop
             for _, row in locations_df.iterrows():
                 latitude = row['latitude']
                 longitude = row['longitude']
                 
+                # Check if latitude or longitude are NaN and skip if they are
                 if pd.isna(latitude) or pd.isna(longitude):
-                    continue
+                    continue  # Skip this row and move to the next one
                 
                 m.add_marker(location=[latitude, longitude], popup=row.get('name', 'No Name'))
 
+            # Display map
             st.write("Map of Uploaded Points:")
             m.to_streamlit()
+
+            # Store the map in session_state
             st.session_state.map_data = m
 
+        # Process each point for index calculation
         for idx, row in locations_df.iterrows():
             latitude = row['latitude']
             longitude = row['longitude']
             location_name = row.get('name', f"Location_{idx}")
 
+            # Skip processing if latitude or longitude is NaN
             if pd.isna(latitude) or pd.isna(longitude):
-                continue
+                continue  # Skip this row and move to the next one
 
+            # Define the region of interest (ROI)
             roi = ee.Geometry.Point([longitude, latitude])
 
+            # Load Sentinel-2 image collection
             collection = ee.ImageCollection(sub_options[sub_selection]) \
                 .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
                 .filterBounds(roi)
@@ -275,6 +369,8 @@ if file_upload:
                 st.warning(f"No images found for {location_name}.")
             else:
                 st.write(f"Found images for {location_name}.")
+                # Perform the calculation based on user selection
+                # Perform the calculation based on user selection
                 result = None
                 if index_choice == 'NDVI':
                     result = calculate_ndvi(image, roi)
@@ -288,17 +384,22 @@ if file_upload:
                 elif index_choice.lower() == 'custom formula' and custom_formula:
                     result = process_custom_formula(image, roi, custom_formula)
 
+                # Validate result before using getInfo
                 if result is not None:
-                    calculated_value = None
+                    calculated_value = None  # Initialize the calculated_value as None
 
+                # Check if the result is a dictionary
                     if isinstance(result, dict):
-                        calculated_value = result.get('CustomResult', None)
+                        # Extract the value using the appropriate key (adjust the key name as needed)
+                        calculated_value = result.get('CustomResult', None)  # Replace 'CustomResult' if using NDVI, NDWI, etc.
                     else:
                         try:
+                            # If it's an Earth Engine object, get the value using getInfo
                             calculated_value = result.getInfo()
                         except Exception as e:
                             st.error(f"Error getting result info: {e}")
-
+    
+                    # If a valid calculated_value is found, append the result to session_state
                     if calculated_value is not None:
                         st.session_state.results.append({
                             'Location Name': location_name,
@@ -310,65 +411,70 @@ if file_upload:
                         st.warning(f"No value calculated for {location_name}.")
                 else:
                     st.warning(f"No value calculated for {location_name}.")
+                    
+    
+    # Check if polygons_df is populated for polygons
+    if polygons_df is not None:
+        st.write("Preview of the uploaded polygons data:")
+        st.dataframe(polygons_df.head())
+
+        m = leafmap.Map(center=[polygons_df.geometry.centroid.y.mean(), polygons_df.geometry.centroid.x.mean()], zoom=10)
+
+        for _, row in polygons_df.iterrows():
+            polygon = row['geometry']
+            if polygon.is_valid:
+                gdf = gpd.GeoDataFrame([row], geometry=[polygon], crs=polygons_df.crs)
+                m.add_gdf(gdf=gdf, layer_name=row.get('name', 'Unnamed Polygon'))
+
+        st.write("Map of Uploaded Polygons:")
+        m.to_streamlit()
+        st.session_state.map_data = m
+
+        for idx, row in polygons_df.iterrows():
+            polygon = row['geometry']
+            location_name = row.get('name', f"Polygon_{idx}")
+
+            try:
+                roi = convert_to_ee_geometry(polygon)
+            except ValueError as e:
+                st.error(str(e))
+                continue
 
-if polygons_df is not None:
-    st.write("Preview of the uploaded polygons data:")
-    st.dataframe(polygons_df.head())
-
-    m = leafmap.Map(center=[polygons_df.geometry.centroid.y.mean(), polygons_df.geometry.centroid.x.mean()], zoom=10)
-
-    for _, row in polygons_df.iterrows():
-        polygon = row['geometry']
-        if polygon.is_valid:
-            gdf = gpd.GeoDataFrame([row], geometry=[polygon], crs=polygons_df.crs)
-            m.add_gdf(gdf=gdf, layer_name=row.get('name', 'Unnamed Polygon'))
-
-    st.write("Map of Uploaded Polygons:")
-    m.to_streamlit()
-    st.session_state.map_data = m
-
-    for idx, row in polygons_df.iterrows():
-        polygon = row['geometry']
-        location_name = row.get('name', f"Polygon_{idx}")
-
-        try:
-            roi = convert_to_ee_geometry(polygon)
-        except ValueError as e:
-            st.error(str(e))
-            continue
-
-        collection = ee.ImageCollection(sub_options[sub_selection]) \
-            .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
-            .filterBounds(roi)
-
-        image = get_most_recent_image(collection)
+            collection = ee.ImageCollection(sub_options[sub_selection]) \
+                .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
+                .filterBounds(roi)
 
-        if not image:
-            st.warning(f"No images found for {location_name}.")
-        else:
-            st.write(f"Found an image for {location_name}.")
-            result = None
-            if index_choice.lower() == 'ndvi':
-                result = calculate_ndvi(image, roi)
-            elif index_choice.lower() ```python
-                == 'ndwi':
-                result = calculate_ndwi(image, roi)
-            elif index_choice.lower() == 'average no₂':
-                if 'NO2' in image.bandNames().getInfo():
-                    result = calculate_avg_no2_sentinel5p(image, roi)
-                else:
-                    st.warning(f"No NO2 band found for {location_name}. Please use Sentinel-5P for NO₂ data.")
-            elif index_choice.lower() == 'custom formula' and custom_formula:
-                result = process_custom_formula(image, roi, custom_formula)
+            image = get_most_recent_image(collection)
 
-            if result is not None:
-                calculated_value = None
+            if not image:
+                st.warning(f"No images found for {location_name}.")
+            else:
+                st.write(f"Found an image for {location_name}.")
+                result = None
+                if index_choice.lower() == 'ndvi':
+                    result = calculate_ndvi(image, roi)
+                elif index_choice.lower() == 'ndwi':
+                    result = calculate_ndwi(image, roi)
+                elif index_choice.lower() == 'average no₂':
+                    if 'NO2' in image.bandNames().getInfo():
+                        result = calculate_avg_no2_sentinel5p(image, roi)
+                    else:
+                        st.warning(f"No NO2 band found for {location_name}. Please use Sentinel-5P for NO₂ data.")
+                elif index_choice.lower() == 'custom formula' and custom_formula:
+                    result = process_custom_formula(image, roi, custom_formula)
 
+                if result is not None:
+                    # Initialize the calculated_value as None
+                    calculated_value = None
+    
+                # Check if the result is a dictionary (e.g., custom formula result)
                 if isinstance(result, dict) and 'CustomResult' in result:
-                    calculated_value = result['CustomResult']
+                    calculated_value = result['CustomResult']  # Extract the numeric value from the dictionary
+                # If the result is a numeric value (e.g., NDVI, NDWI, or NO2)
                 elif isinstance(result, (int, float)):
                     calculated_value = result
-
+    
+                # If a valid calculated_value is found, append the result to session_state
                 if calculated_value is not None:
                     st.session_state.results.append({
                         'Location Name': location_name,
@@ -393,4 +499,4 @@ if st.session_state.results:
         data=result_df.to_csv(index=False).encode('utf-8'),
         file_name=filename,
         mime='text/csv'
-    )
+    )