update app.py

app.py

@@ -6,6 +6,7 @@ import pandas as pd
 import geopandas as gpd
 from datetime import datetime
 import leafmap.foliumap as leafmap
+import re
 
 # Set up the page layout
 st.set_page_config(layout="wide")
@@ -191,7 +192,7 @@ def calculate_custom_formula(image, geometry, formula, scale=30):
         image (ee.Image): The input image.
         geometry (ee.Geometry): The region of interest (ROI) geometry.
         formula (str): A string representing the mathematical formula to apply to the image.
-        scale (int): The scale for the reduceRegion operation (default is 30). 
+        scale (int): The scale for the reduceRegion operation (default is 30).
 
     Returns:
         ee.Dictionary: The result of applying the custom formula in the region.
@@ -210,62 +211,84 @@ def calculate_custom_formula(image, geometry, formula, scale=30):
         scale=scale
     )
     
-    return result.get('CustomResult')
-def get_images_by_day(image_collection_filtered, start_date_str, end_date_str, roi, location_name, latitude, longitude, index_choice, custom_formula):
-    # Compute the daily images and their mean
-    days = ee.List.sequence(ee.Date(start_date_str).millis(), ee.Date(end_date_str).millis(), 86400000)
-
-    # This part assumes we process each day individually
-    daily_results = []
-    for day in days.getInfo():
-        # Filter images for this particular day
-        day_images = image_collection_filtered.filterDate(ee.Date(day), ee.Date(day).advance(1, 'day'))
-        
-        # Compute the mean value for this day
-        mean_image = day_images.mean()  # Compute the daily mean image
-        
-        # Perform the index calculation on the mean image
-        result = None
-        if index_choice.lower() == 'ndvi':
-            result = calculate_ndvi(mean_image, roi)
-        elif index_choice.lower() == 'ndwi':
-            result = calculate_ndwi(mean_image, roi)
-        elif index_choice.lower() == 'average no₂':
-            if 'NO2' in mean_image.bandNames().getInfo():
-                result = calculate_avg_no2_sentinel5p(mean_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 = calculate_custom_formula(mean_image, roi, custom_formula)
-        
-        if result is not None:
-            # Extract the calculated value from the result
-            if isinstance(result, ee.Number):
-                calculated_value = result.getInfo()  # For ee.Number, getInfo() is used to get the value
-            elif isinstance(result, ee.Dictionary):
-                calculated_value = result.get('CustomResult', None).getInfo()  # For ee.Dictionary, use get() to access 'CustomResult' and then getInfo()
-
-            if calculated_value is not None:
-                daily_results.append({
-                    'Location Name': location_name,
-                    'Latitude': latitude,
-                    'Longitude': longitude,
-                    'Date': day,
-                    'Calculated Value': calculated_value
-                })
-    
-    return daily_results
+    # Return the result
+    return result
+
+
+# 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
+
+locations_df = None  # Initialize locations_df to None
+polygons_df = None   # Ensure polygons_df is initialized at the beginning
 
-# Process each point for daily index calculation
-if file_upload is not None:
-    if shape_type == "Point":
-        if file_upload.name.endswith(".csv"):
+# 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
+    if shape_type == 'Point':
+        if file_extension == '.csv':
             locations_df = read_csv(file_upload)
-        elif file_upload.name.endswith(".geojson"):
+        elif file_extension == '.geojson':
             locations_df = read_geojson(file_upload)
-        elif file_upload.name.endswith(".kml"):
+        elif file_extension == '.kml':
             locations_df = read_kml(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':
+            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  # 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']
@@ -278,29 +301,144 @@ if file_upload is not None:
             # Define the region of interest (ROI)
             roi = ee.Geometry.Point([longitude, latitude])
 
-            # Load Sentinel-2 image collection for the selected dataset
+            # 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)
 
-            # Get daily results
-            daily_results = get_images_by_day(collection, start_date_str, end_date_str, roi, location_name, latitude, longitude, index_choice, custom_formula)
+            image = get_most_recent_image(collection)
+            if not image:
+                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)
+                elif index_choice == 'NDWI':
+                    result = calculate_ndwi(image, roi)
+                elif index_choice == '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)
+
+                # Validate result before using getInfo
+                if result is not None:
+                    calculated_value = None  # Initialize the calculated_value as None
+
+                # Check if the result is a dictionary
+                    if isinstance(result, dict):
+                        # 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,
+                            'Latitude': latitude,
+                            'Longitude': longitude,
+                            'Calculated Value': calculated_value
+                        })
+                    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)
 
-            # Store the daily results in session state
-            for result in daily_results:
-                st.session_state.results.append(result)
+        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'))
 
-    if st.session_state.results:
-        result_df = pd.DataFrame(st.session_state.results)
+        st.write("Map of Uploaded Polygons:")
+        m.to_streamlit()
+        st.session_state.map_data = m
 
-        st.write("Processed Results Table (Daily):")
-        st.dataframe(result_df[['Location Name', 'Latitude', 'Longitude', 'Date', 'Calculated Value']])
+        for idx, row in polygons_df.iterrows():
+            polygon = row['geometry']
+            location_name = row.get('name', f"Polygon_{idx}")
 
-        filename = f"{main_selection}_{sub_selection}_{start_date.strftime('%Y/%m/%d')}_{end_date.strftime('%Y/%m/%d')}_daily_{shape_type}.csv"
+            try:
+                roi = convert_to_ee_geometry(polygon)
+            except ValueError as e:
+                st.error(str(e))
+                continue
 
-        st.download_button(
-            label="Download daily results as CSV",
-            data=result_df.to_csv(index=False).encode('utf-8'),
-            file_name=filename,
-            mime='text/csv'
-        )
+            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
+                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']  # 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,
+                        'Calculated Value': calculated_value
+                    })
+
+# After processing, show the results
+if st.session_state.results:
+    result_df = pd.DataFrame(st.session_state.results)
+
+    if shape_type.lower() == 'point':
+        st.write("Processed Results Table (Points):")
+        st.dataframe(result_df[['Location Name', 'Latitude', 'Longitude', 'Calculated Value']])
+    else:
+        st.write("Processed Results Table (Polygons):")
+        st.dataframe(result_df[['Location Name', 'Calculated Value']])
+
+    filename = f"{main_selection}_{sub_selection}_{start_date.strftime('%Y/%m/%d')}_{end_date.strftime('%Y/%m/%d')}_{shape_type}.csv"
+
+    st.download_button(
+        label="Download results as CSV",
+        data=result_df.to_csv(index=False).encode('utf-8'),
+        file_name=filename,
+        mime='text/csv'
+    )