update app.py

app.py

@@ -87,13 +87,6 @@ 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:
@@ -164,29 +157,6 @@ if parameters_changed():
         'file_upload': file_upload
     }
 
-# 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 perform index calculations
 def calculate_ndvi(image, geometry):
     ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI')
@@ -253,19 +223,22 @@ def get_most_recent_image(image_collection):
 # Function to handle the custom formula choice and calculation
 def process_custom_formula(image, roi, custom_formula):
     if custom_formula:
+        # Call the calculate_custom_formula function which processes the custom formula
         result = calculate_custom_formula(image, roi, custom_formula)
         if result:
-            return result.getInfo()
+            # If result is a dictionary (which is likely for custom formula), extract the value
+            if isinstance(result, dict) and 'CustomResult' in result:
+                return result['CustomResult']  # Directly return the value from the dictionary
+            # Otherwise, it's an Earth Engine object, so we get the value with getInfo()
+            else:
+                return result.getInfo()  # Return the result for an Earth Engine object
     return None
 
-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
+    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()
 
@@ -336,8 +309,6 @@ if file_upload:
                 .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
                 .filterBounds(roi)
 
-            # # Apply frequency-based filtering and reduction
-            # result, result_date = calculate_index_by_frequency(collection, frequency_choice, roi, reducer)
             image = get_most_recent_image(collection)
             if not image:
                 st.warning(f"No images found for {location_name}.")
@@ -380,85 +351,90 @@ if file_upload:
                             'Latitude': latitude,
                             'Longitude': longitude,
                             'Calculated Value': calculated_value
-                            # 'Date': result_date  # Add the date of the calculation
                         })
                     else:
                         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
-
-        # Processing for each polygon
-        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)  # Convert to Earth Engine geometry
-            except ValueError as e:
-                st.error(str(e))
-                continue
-        
-            # Load the Sentinel image collection
-            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)  # Get the most recent image from the collection
-        
-            if not image:
-                st.warning(f"No images found for {location_name}.")
-            else:
-                st.write(f"Found an image for {location_name}.")
-                
-                # Perform the calculation based on the selected index
-                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:
-                    # Extract the calculated value (this could be a dictionary or numeric value)
-                    calculated_value = None
-        
-                    # If the result is a dictionary (e.g., custom formula result)
-                    if isinstance(result, dict) and 'CustomResult' in result:
-                        calculated_value = result['CustomResult']
-                    # 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
-                    if calculated_value is not None:
-                        st.session_state.results.append({
-                            'Location Name': location_name,
-                            'Calculated Value': calculated_value
-                        })
+
+
+# Ensure st.session_state.results is initialized
+if 'results' not in st.session_state:
+    st.session_state.results = []
+
+# Check if polygons_df is populated for polygons
+if polygons_df is not None and not polygons_df.empty:
+    st.write("Preview of the uploaded polygons data:")
+    st.dataframe(polygons_df.head())
+
+    # Initialize map and display polygons
+    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
+
+    # Process each polygon
+    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)  # Convert to EE Geometry
+        except ValueError as e:
+            st.error(f"Error converting polygon {location_name}: {str(e)}")
+            continue
+
+        # Fetch image collection
+        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)
+
+        if not image:
+            st.warning(f"No images found for {location_name}.")
+        else:
+            st.write(f"Found an image for {location_name}.")
+            result = None
+
+            # Calculate index based on user's choice
+            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)
+
+            # Ensure result is properly extracted and displayed
+            if result is not None:
+                calculated_value = None
+
+                if isinstance(result, ee.Dictionary):
+                    # Extract the numeric value for custom formula results
+                    calculated_value = result.get('constant').getInfo()
+                elif isinstance(result, ee.Number):
+                    # Direct numeric result
+                    calculated_value = result.getInfo()
+
+                if calculated_value is not None:
+                    st.write(f"Calculated {index_choice.upper()} for {location_name}: {calculated_value}")
+                    st.session_state.results.append({
+                        'Location Name': location_name,
+                        'Calculated Value': calculated_value
+                    })
+                else:
+                    st.error(f"Error extracting the result for {location_name}.")
 
 
 # After processing, show the results
@@ -479,5 +455,4 @@ if st.session_state.results:
         data=result_df.to_csv(index=False).encode('utf-8'),
         file_name=filename,
         mime='text/csv'
-    )
-
+    )