update app.py

app.py

@@ -7,8 +7,6 @@ import geopandas as gpd
 from datetime import datetime
 import leafmap.foliumap as leafmap
 import re
-from fastkml import kml
-from shapely.geometry import Point, Polygon
 
 # Set up the page layout
 st.set_page_config(layout="wide")
@@ -41,7 +39,8 @@ st.markdown(
     f"""
     <h1 style="text-align: center;">Precision Analysis for Vegetation, Water, and Air Quality</h1>
     """,
-    unsafe_allow_html=True)
+    unsafe_allow_html=True,
+)
 st.write("<h2><div style='text-align: center;'>User  Inputs</div></h2>", unsafe_allow_html=True)
 
 # Authenticate and initialize Earth Engine
@@ -88,74 +87,37 @@ 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
 
-# Aggregation Options
-aggregation_type = st.selectbox("Select Aggregation Type", ["Daily", "Weekly", "Monthly", "Yearly"])
+# Add Aggregation Option (Daily, Weekly, Monthly, Yearly)
+aggregation_choice = st.selectbox("Select Aggregation Period", ['Daily', 'Weekly', 'Monthly', 'Yearly'])
 
-# Function to calculate NDVI and NDWI as before, with added aggregation logic
-def calculate_ndvi(image, geometry):
-    ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI')
-    return ndvi.reduceRegion(reducer=ee.Reducer.mean(), geometry=geometry, scale=30)
+# 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:
+        geojson = geometry.__geo_interface__
+        return ee.Geometry(geojson)
+    else:
+        raise ValueError("Invalid geometry: The polygon geometry is not valid.")
 
-def calculate_ndwi(image, geometry):
-    ndwi = image.normalizedDifference(['B3', 'B8']).rename('NDWI')
-    return ndwi.reduceRegion(reducer=ee.Reducer.mean(), geometry=geometry, scale=30)
-
-# Function to calculate averages for NDVI, NDWI, NO2 based on aggregation type
-def aggregate_data_daily(collection, roi):
-    def daily_average(image):
-        date = ee.Date(image.get('system:time_start')).format('YYYY-MM-dd')
-        mean_ndvi = image.select('NDVI').reduceRegion(reducer=ee.Reducer.mean(), geometry=roi, scale=30)
-        mean_ndwi = image.select('NDWI').reduceRegion(reducer=ee.Reducer.mean(), geometry=roi, scale=30)
-        return ee.Feature(None, {'date': date, 'mean_ndvi': mean_ndvi.get('NDVI'), 'mean_ndwi': mean_ndwi.get('NDWI')})
-    
-    return collection.map(daily_average)
-
-# Process data based on aggregation choice
-def process_aggregation(collection, roi):
-    if aggregation_type.lower() == "daily":
-        return aggregate_data_daily(collection, roi)
-
-# Function to calculate index and return results based on aggregation choice
-def process_index_calculation(image, roi):
-    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₂':
-        result = calculate_avg_no2_sentinel5p(image, roi)
-    elif index_choice.lower() == 'custom formula' and custom_formula:
-        result = process_custom_formula(image, roi, custom_formula)
-    return result
-
-# Function to read CSV files
-def read_csv(file):
-    # Assuming the CSV file has 'latitude' and 'longitude' columns
-    df = pd.read_csv(file)
+# Function to read points from CSV
+def read_csv(file_path):
+    df = pd.read_csv(file_path)
     return df
 
-# Function to read GeoJSON files
-def read_geojson(file):
-    geo_df = gpd.read_file(file)
-    return geo_df
-
-# Function to read KML files
-def read_kml(file):
-    kml_doc = file.read()
-    k = kml.KML()
-    k.from_string(kml_doc)
-    features = list(k.features())
-    geometries = []
-    for feature in features:
-        for geometry in feature.geometry():
-            geometries.append(geometry)
-    return geometries
-
-# User Input for Geometry Type: Point or Polygon
-geometry_type = st.selectbox("Select Geometry Type", ["Point", "Polygon"])
-
-# File upload based on geometry type
-file_upload = st.file_uploader(f"Upload your {geometry_type} data (CSV, GeoJSON, KML)", type=["csv", "geojson", "kml"])
+# Function to read points from GeoJSON
+def read_geojson(file_path):
+    gdf = gpd.read_file(file_path)
+    return gdf
+
+# Function to read points from KML
+def read_kml(file_path):
+    gdf = gpd.read_file(file_path, driver='KML')
+    return gdf
+
+# Ask user whether they want to process 'Point' or 'Polygon' data (case-insensitive)
+shape_type = st.selectbox("Do you want to process 'Point' or 'Polygon' data?", ["Point", "Polygon"])
+
+# Ask user to upload a file based on shape type (case-insensitive)
+file_upload = st.file_uploader(f"Upload your {shape_type} data (CSV, GeoJSON, KML)", type=["csv", "geojson", "kml"])
 
 # Date Input for Start and End Dates
 start_date = st.date_input("Start Date", value=pd.to_datetime('2020-01-01'))
@@ -170,66 +132,197 @@ if 'results' not in st.session_state:
     st.session_state.results = []
 if 'last_params' not in st.session_state:
     st.session_state.last_params = {}
+if 'map_data' not in st.session_state:
+    st.session_state.map_data = None  # Initialize map_data
+
+# Function to check if parameters have changed
+def parameters_changed():
+    return (
+        st.session_state.last_params.get('main_selection') != main_selection or
+        st.session_state.last_params.get('sub_selection') != sub_selection or
+        st.session_state.last_params.get('index_choice') != index_choice or
+        st.session_state.last_params.get('start_date_str') != start_date_str or
+        st.session_state.last_params.get('end_date_str') != end_date_str or
+        st.session_state.last_params.get('shape_type') != shape_type or
+        st.session_state.last_params.get('file_upload') != file_upload or
+        st.session_state.last_params.get('aggregation_choice') != aggregation_choice
+    )
+
+# If parameters have changed, reset the results
+if parameters_changed():
+    st.session_state.results = []  # Clear the previous results
+    st.session_state.last_params = {
+        'main_selection': main_selection,
+        'sub_selection': sub_selection,
+        'index_choice': index_choice,
+        'start_date_str': start_date_str,
+        'end_date_str': end_date_str,
+        'shape_type': shape_type,
+        'file_upload': file_upload,
+        'aggregation_choice': aggregation_choice
+    }
+
+# Function to perform index calculations
+def calculate_ndvi(image, geometry):
+    ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI')
+    result = ndvi.reduceRegion(
+        reducer=ee.Reducer.mean(),
+        geometry=geometry,
+        scale=30
+    )
+    return result.get('NDVI')
+
+def calculate_ndwi(image, geometry):
+    ndwi = image.normalizedDifference(['B3', 'B8']).rename('NDWI')
+    result = ndwi.reduceRegion(
+        reducer=ee.Reducer.mean(),
+        geometry=geometry,
+        scale=30
+    )
+    return result.get('NDWI')
+
+def calculate_avg_no2_sentinel5p(image, geometry):
+    no2 = image.select('NO2').reduceRegion(
+        reducer=ee.Reducer.mean(),
+        geometry=geometry,
+        scale=1000
+    ).get('NO2')
+    return no2
+
+def calculate_custom_formula(image, geometry, formula, scale=30):
+    band_names = image.bandNames().getInfo()
+    band_dict = {band: image.select(band) for band in band_names}
+    result_image = image.expression(formula, band_dict).rename('CustomResult')
+
+    result = result_image.reduceRegion(
+        reducer=ee.Reducer.mean(),
+        geometry=geometry,
+        scale=scale
+    )
+    return result
+
+# Function to aggregate results by day, week, month, or year
+def aggregate_results_by_period(results, aggregation_period):
+    # Convert 'date' column to datetime for proper aggregation
+    results['date'] = pd.to_datetime(results['date'])
+    if aggregation_period == 'Daily':
+        return results.groupby(results['date'].dt.date).mean().reset_index()
+    elif aggregation_period == 'Weekly':
+        return results.groupby(results['date'].dt.to_period('W')).mean().reset_index()
+    elif aggregation_period == 'Monthly':
+        return results.groupby(results['date'].dt.to_period('M')).mean().reset_index()
+    elif aggregation_period == 'Yearly':
+        return results.groupby(results['date'].dt.to_period('A')).mean().reset_index()
+
+# 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
 
-# Process the file based on geometry type (Point or Polygon)
 locations_df = None
+polygons_df = None
+
+# Process each point (with additional checks for file validity)
 if file_upload:
     file_extension = os.path.splitext(file_upload.name)[1].lower()
 
-    if geometry_type == 'Point':
+    if shape_type == 'Point':
         if file_extension == '.csv':
             locations_df = read_csv(file_upload)
         elif file_extension == '.geojson':
             locations_df = read_geojson(file_upload)
         elif file_extension == '.kml':
             locations_df = read_kml(file_upload)
-
-    elif geometry_type == 'Polygon':
+        else:
+            st.error("Unsupported file type. Please upload a CSV, GeoJSON, or KML file for points.")
+    elif shape_type == 'Polygon':
         if file_extension == '.geojson':
-            locations_df = read_geojson(file_upload)
+            polygons_df = read_geojson(file_upload)
         elif file_extension == '.kml':
-            locations_df = read_kml(file_upload)
+            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:
-        for idx, row in locations_df.iterrows():
-            if geometry_type == 'Point':
+        # 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())
+
+            # 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}")
+
+                # Define the region of interest (ROI)
                 roi = ee.Geometry.Point([longitude, latitude])
-            elif geometry_type == 'Polygon':
-                # For Polygon, create a geometry object directly from GeoJSON or KML
-                roi = ee.Geometry.Polygon(row['geometry']['coordinates'])
-
-            collection = ee.ImageCollection(sub_options[sub_selection]) \
-                .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
-                .filterBounds(roi)
-
-            # Apply aggregation based on user's selection
-            aggregated_data = process_aggregation(collection, roi)
-
-            # Convert the aggregated data to a list of dictionaries (to show in DataFrame)
-            aggregated_data_list = aggregated_data.getInfo()
-
-            # Further processing on the aggregated data (e.g., storing results)
-            for data in aggregated_data_list:
-                st.session_state.results.append({
-                    'Location Name': row.get('name', f"Location_{idx}"),
-                    'Date': data['date'],
-                    'Mean NDVI': data['mean_ndvi'],
-                    'Mean NDWI': data['mean_ndwi']
-                })
-
-# After processing, show the results (same as your previous implementation)
+
+                # 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)
+
+                # Aggregate results by the chosen period
+                if aggregation_choice == 'Daily':
+                    collection = collection.filterDate(ee.Date(start_date_str), ee.Date(end_date_str))
+                elif aggregation_choice == 'Weekly':
+                    collection = collection.filterDate(ee.Date(start_date_str), ee.Date(end_date_str))
+                elif aggregation_choice == 'Monthly':
+                    collection = collection.filterDate(ee.Date(start_date_str), ee.Date(end_date_str))
+                elif aggregation_choice == 'Yearly':
+                    collection = collection.filterDate(ee.Date(start_date_str), ee.Date(end_date_str))
+
+                # Get the most recent image in the collection
+                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
+                    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 = calculate_custom_formula(image, roi, custom_formula)
+
+                    if result is not None:
+                        # Get the date from the image's metadata
+                        date = image.date().format().getInfo()
+                        # Append the result with date to the results list
+                        st.session_state.results.append({
+                            'Location Name': location_name,
+                            'Latitude': latitude,
+                            'Longitude': longitude,
+                            'Date': date,
+                            'Calculated Value': result.getInfo()
+                        })
+
+# After processing, show the results
 if st.session_state.results:
     result_df = pd.DataFrame(st.session_state.results)
-    st.write("Processed Results Table:")
-    st.dataframe(result_df)
 
-    filename = f"{main_selection}_{sub_selection}_{start_date.strftime('%Y/%m/%d')}_{end_date.strftime('%Y/%m/%d')}_{geometry_type}_daily.csv"
+    # Aggregate by the selected period
+    aggregated_results = aggregate_results_by_period(result_df, aggregation_choice)
+
+    st.write(f"Processed Results Table ({aggregation_choice}):")
+    st.dataframe(aggregated_results)
+
+    filename = f"{main_selection}_{sub_selection}_{start_date.strftime('%Y/%m/%d')}_{end_date.strftime('%Y/%m/%d')}_{shape_type}_{aggregation_choice}.csv"
 
     st.download_button(
         label="Download results as CSV",
-        data=result_df.to_csv(index=False).encode('utf-8'),
+        data=aggregated_results.to_csv(index=False).encode('utf-8'),
         file_name=filename,
         mime='text/csv'
     )