update app.py

app.py

@@ -7,6 +7,9 @@ import geopandas as gpd
 from datetime import datetime
 import leafmap.foliumap as leafmap
 import re
+from shapely.geometry import base
+from lxml import etree
+from xml.etree import ElementTree as ET
 
 # Set up the page layout
 st.set_page_config(layout="wide")
@@ -92,12 +95,20 @@ elif index_choice.lower() == 'ndwi':
 elif index_choice.lower() == 'average no₂':
     st.write("Formula for Average NO₂: Average NO₂ = Mean(NO2 band)")
 elif index_choice.lower() == 'custom formula':
-    custom_formula = st.text_input("Enter Custom Formula (e.g., B5,B4)")
+    custom_formula = st.text_input("Enter Custom Formula (e.g., B5,B4 for two bands or B3 for one band)")
     # Check if custom formula is empty and show warning
     if not custom_formula:
         st.warning("Please enter a custom formula before proceeding.")
     else:
-        st.write(f"Custom Formula: (band1 - band2) / (band1 + band2)")  # Display the custom formula after the user inputs it
+        # Check if the input contains a comma (indicating two bands)
+        if ',' in custom_formula:
+            # Split the input into two bands and strip whitespace
+            band1, band2 = [b.strip() for b in custom_formula.split(',', 1)]
+            st.write(f"Custom Formula: ({band1} - {band2}) / ({band1} + {band2})")
+        else:
+            # Single band case
+            band = custom_formula.strip()
+            st.write(f"Custom Formula: {band}")
 
 # Function to get the corresponding reducer based on user input
 def get_reducer(reducer_name):
@@ -123,13 +134,63 @@ reducer_choice = st.selectbox(
     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:
-        geojson = geometry.__geo_interface__
-        return ee.Geometry(geojson)
+    # Handle Shapely geometry
+    if isinstance(geometry, base.BaseGeometry):
+        if geometry.is_valid:
+            geojson = geometry.__geo_interface__
+            print("Shapely GeoJSON:", geojson)  # Debugging: Inspect the GeoJSON structure
+            return ee.Geometry(geojson)
+        else:
+            raise ValueError("Invalid geometry: The polygon geometry is not valid.")
+    
+    # Handle GeoJSON input (string or dictionary)
+    elif isinstance(geometry, dict) or isinstance(geometry, str):
+        try:
+            if isinstance(geometry, str):
+                geometry = json.loads(geometry)
+            if 'type' in geometry and 'coordinates' in geometry:
+                print("GeoJSON Geometry:", geometry)  # Debugging: Inspect the GeoJSON structure
+                return ee.Geometry(geometry)
+            else:
+                raise ValueError("GeoJSON format is invalid.")
+        except Exception as e:
+            raise ValueError(f"Error parsing GeoJSON: {e}")
+
+    # Handle KML input (string or file path)
+    elif isinstance(geometry, str) and geometry.lower().endswith(".kml"):
+        try:
+            # Parse the KML file
+            tree = ET.parse(geometry)
+            kml_root = tree.getroot()
+
+            # Extract coordinates from KML geometry (assuming it's a Polygon or MultiPolygon)
+            # KML coordinates are usually within the <coordinates> tag
+            kml_namespace = {'kml': 'http://www.opengis.net/kml/2.2'}
+            coordinates = kml_root.findall(".//kml:coordinates", kml_namespace)
+            
+            if coordinates:
+                # Extract and format coordinates
+                coords_text = coordinates[0].text.strip()
+                coords = coords_text.split()
+                # Convert KML coordinates (comma-separated) into a list of tuples
+                coords = [tuple(map(float, coord.split(','))) for coord in coords]
+                geojson = {
+                    "type": "Polygon",  # Make sure the GeoJSON type is Polygon
+                    "coordinates": [coords]  # Wrap the coordinates in a list (required by GeoJSON format)
+                }
+
+                # Debugging: Inspect the KML-to-GeoJSON structure
+                print("KML GeoJSON:", geojson)
+                
+                return ee.Geometry(geojson)
+            else:
+                raise ValueError("KML does not contain valid coordinates.")
+        except Exception as e:
+            raise ValueError(f"Error parsing KML: {e}")
+
     else:
-        raise ValueError("Invalid geometry: The polygon geometry is not valid.")
+        raise ValueError("Unsupported geometry input type. Supported types are Shapely, GeoJSON, and KML.")
 
 # Function to read points from CSV
 def read_csv(file_path):
@@ -146,6 +207,18 @@ def read_kml(file_path):
     gdf = gpd.read_file(file_path, driver='KML')
     return gdf
 
+
+# Date Input for Start and End Dates
+start_date = st.date_input("Start Date", value=pd.to_datetime('2024-11-01'))
+end_date = st.date_input("End Date", value=pd.to_datetime('2024-12-01'))
+
+# Convert start_date and end_date to string format for Earth Engine
+start_date_str = start_date.strftime('%Y-%m-%d')
+end_date_str = end_date.strftime('%Y-%m-%d')
+
+# Aggregation period selection
+aggregation_period = st.selectbox("Select Aggregation Period", ["Daily", "Weekly", "Monthly", "Yearly"], index=0)
+
 # 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"])
 
@@ -174,7 +247,7 @@ if file_upload is not None:
                 st.stop()  # Stop further processing if polygons are detected
 
         # Processing the point data
-        with st.spinner('Processing data...'):
+        with st.spinner('Processing Map...'):
             if locations_df is not None and not locations_df.empty:
                 # For GeoJSON data, the coordinates are in the geometry column
                 if 'geometry' in locations_df.columns:
@@ -231,7 +304,7 @@ if file_upload is not None:
                 st.stop()  # Stop further processing if point data is detected
 
         # Processing the polygon data
-        with st.spinner('Processing data...'):
+        with st.spinner('Processing Map...'):
             if locations_df is not None and not locations_df.empty:
                 # Ensure the 'geometry' column exists in the dataframe
                 if 'geometry' not in locations_df.columns:
@@ -263,18 +336,6 @@ if file_upload is not None:
                     # Store the map in session_state
                     st.session_state.map_data = m
 
-
-# Date Input for Start and End Dates
-start_date = st.date_input("Start Date", value=pd.to_datetime('2020-01-01'))
-end_date = st.date_input("End Date", value=pd.to_datetime('2020-12-31'))
-
-# Convert start_date and end_date to string format for Earth Engine
-start_date_str = start_date.strftime('%Y-%m-%d')
-end_date_str = end_date.strftime('%Y-%m-%d')
-
-# Aggregation period selection
-aggregation_period = st.selectbox("Select Aggregation Period", ["Daily", "Weekly", "Monthly", "Yearly"], index=0)
-
 # Initialize session state for storing results if not already done
 if 'results' not in st.session_state:
     st.session_state.results = []
@@ -318,14 +379,24 @@ def calculate_ndwi(image, geometry, reducer_choice):
     ndwi = image.normalizedDifference(['B3', 'B8']).rename('NDWI')
     return ndwi
 
-def calculate_custom_formula(image, geometry, custom_formula, reducer_choice, scale=30):    
-    
-    # Calculate NDWI using the user-specified bands
-    band1 = custom_formula[:custom_formula.find(",")]
-    band2 = custom_formula[custom_formula.find(",")+1:]
-    custom_formula = image.normalizedDifference([band1, band2]).rename('custom formula')
-    return custom_formula
-    
+def calculate_custom_formula(image, geometry, custom_formula, reducer_choice, scale=30):
+    try:
+        if "," in custom_formula:
+            band1, band2 = [b.strip() for b in custom_formula.split(",")]
+            band_names = image.bandNames().getInfo()
+            if band1 not in band_names or band2 not in band_names:
+                raise ValueError(f"One or both bands ({band1}, {band2}) do not exist in the image.")
+            result = image.normalizedDifference([band1, band2]).rename('custom_formula')
+        else:
+            band = custom_formula.strip()
+            band_names = image.bandNames().getInfo()
+            if band not in band_names:
+                raise ValueError(f"The band '{band}' does not exist in the image.")
+            result = image.select(band).rename('custom_formula')
+        return result
+    except Exception as e:
+        return ee.Image(0).rename('custom_formula').set('error', str(e))
+        
 # Modify aggregation functions to return the correct time period and aggregated results
 def aggregate_data_daily(collection):
     # Extract day from the image date (using the exact date)
@@ -346,23 +417,28 @@ def aggregate_data_daily(collection):
     return ee.ImageCollection(daily_images)
 
 def aggregate_data_weekly(collection):
-    # Extract week and year from the image date
-    collection = collection.map(lambda image: image.set('week', ee.Date(image.get('system:time_start')).format('YYYY-ww')))
+    # Extract the start date of the week from the image date
+    collection = collection.map(lambda image: image.set(
+        'week_start', ee.Date(image.get('system:time_start'))
+            .advance(-ee.Date(image.get('system:time_start')).getRelative('day', 'week'), 'day')
+    ))
+    # Group images by week start date
+    grouped_by_week = collection.aggregate_array('week_start').distinct()
+    
+    def calculate_weekly_mean(week_start):
+        # Filter the collection by the specific week start date
+        weekly_collection = collection.filter(ee.Filter.eq('week_start', week_start))
+        weekly_mean = weekly_collection.mean()  # Calculate mean for the week
+        return weekly_mean.set('week_start', week_start)
     
-    # Group images by week
-    grouped_by_week = collection.aggregate_array('week').distinct()
-
-    def calculate_weekly_mean(week):
-        weekly_collection = collection.filter(ee.Filter.eq('week', week))
-        weekly_mean = weekly_collection.mean()
-        return weekly_mean.set('week', week)
-
     # Calculate the weekly mean for each week
     weekly_images = ee.List(grouped_by_week.map(calculate_weekly_mean))
-    
     return ee.ImageCollection(weekly_images)
-
-def aggregate_data_monthly(collection):
+    
+def aggregate_data_monthly(collection, start_date, end_date):
+    # Filter the collection for the specific date range
+    collection = collection.filterDate(start_date, end_date)
+    
     # Extract month and year from the image date
     collection = collection.map(lambda image: image.set('month', ee.Date(image.get('system:time_start')).format('YYYY-MM')))
     
@@ -378,7 +454,7 @@ def aggregate_data_monthly(collection):
     monthly_images = ee.List(grouped_by_month.map(calculate_monthly_mean))
     
     return ee.ImageCollection(monthly_images)
-
+    
 def aggregate_data_yearly(collection):
     # Extract year from the image date
     collection = collection.map(lambda image: image.set('year', ee.Date(image.get('system:time_start')).format('YYYY')))
@@ -411,189 +487,236 @@ def calculate_index_for_period(image, roi, index_choice, reducer_choice, custom_
     else:
         st.write("Please Select any one option...."+ index_choice.lower())
 
+def aggregate_data_weekly(collection):
+    def set_week_start(image):
+        # Get the image timestamp
+        date = ee.Date(image.get('system:time_start'))
+        # Calculate days since the start of the week (0 = Monday, 6 = Sunday)
+        days_since_week_start = date.getRelative('day', 'week')
+        # Convert to ee.Number and negate it to get the offset to the week start
+        offset = ee.Number(days_since_week_start).multiply(-1)
+        # Advance the date by the negative offset to get the week start
+        week_start = date.advance(offset, 'day')
+        return image.set('week_start', week_start.format('YYYY-MM-dd'))  # Ensure string format
+    
+    # Apply the week start calculation to each image
+    collection = collection.map(set_week_start)
+    
+    # Group images by week start date
+    grouped_by_week = collection.aggregate_array('week_start').distinct()
+    
+    def calculate_weekly_mean(week_start):
+        # Filter the collection by the specific week start date
+        weekly_collection = collection.filter(ee.Filter.eq('week_start', week_start))
+        weekly_mean = weekly_collection.mean()  # Calculate mean for the week
+        return weekly_mean.set('week_start', week_start)
+    
+    # Calculate the weekly mean for each week
+    weekly_images = ee.List(grouped_by_week.map(calculate_weekly_mean))
+    return ee.ImageCollection(weekly_images)
+
 def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id, index_choice, reducer_choice, shape_type, aggregation_period, custom_formula=""):
     aggregated_results = []
-
-    # Check if the index_choice is 'custom formula' and the custom formula is empty
+    
     if index_choice.lower() == 'custom_formula' and not custom_formula:
         st.error("Custom formula cannot be empty. Please provide a formula.")
-        return aggregated_results  # Return early to avoid further processing
+        return aggregated_results
     
-    # Initialize progress bar
     total_steps = len(locations_df)
     progress_bar = st.progress(0)
     progress_text = st.empty()
-
+    
     with st.spinner('Processing data...'):
         if shape_type.lower() == "point":
             for idx, row in locations_df.iterrows():
-                # Check if the latitude and longitude columns exist and have values
                 latitude = row.get('latitude')
                 longitude = row.get('longitude')
-
                 if pd.isna(latitude) or pd.isna(longitude):
                     st.warning(f"Skipping location {idx} with missing latitude or longitude")
                     continue
-
+                
                 location_name = row.get('name', f"Location_{idx}")
-
                 roi = ee.Geometry.Point([longitude, latitude])
-
+                
                 collection = ee.ImageCollection(dataset_id) \
                     .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
                     .filterBounds(roi)
-
+                
                 # Aggregate data based on the selected period
                 if aggregation_period.lower() == 'daily':
                     collection = aggregate_data_daily(collection)
                 elif aggregation_period.lower() == 'weekly':
                     collection = aggregate_data_weekly(collection)
                 elif aggregation_period.lower() == 'monthly':
-                    collection = aggregate_data_monthly(collection)
+                    collection = aggregate_data_monthly(collection, start_date_str, end_date_str)
                 elif aggregation_period.lower() == 'yearly':
                     collection = aggregate_data_yearly(collection)
-
+                
                 # Process each image in the collection
                 image_list = collection.toList(collection.size())
-
+                processed_weeks = set()  # Track processed weeks to avoid duplicates
                 for i in range(image_list.size().getInfo()):
                     image = ee.Image(image_list.get(i))
-
+                    
                     if aggregation_period.lower() == 'daily':
                         timestamp = image.get('day')
+                        period_label = 'Date'
+                        date = ee.Date(timestamp).format('YYYY-MM-dd').getInfo()
                     elif aggregation_period.lower() == 'weekly':
-                        timestamp = image.get('week')
+                        timestamp = image.get('week_start')
+                        period_label = 'Week'
+                        date = ee.String(timestamp).getInfo()  # Already formatted as YYYY-MM-dd
+                        # Skip if week is outside the date range or already processed
+                        if (pd.to_datetime(date) < pd.to_datetime(start_date_str) or 
+                            pd.to_datetime(date) > pd.to_datetime(end_date_str) or 
+                            date in processed_weeks):
+                            continue
+                        processed_weeks.add(date)
                     elif aggregation_period.lower() == 'monthly':
                         timestamp = image.get('month')
+                        period_label = 'Month'
+                        date = ee.Date(timestamp).format('YYYY-MM').getInfo()
                     elif aggregation_period.lower() == 'yearly':
                         timestamp = image.get('year')
-
-                    date = ee.Date(timestamp).format('YYYY-MM-dd').getInfo()
-
-                    # Calculate the index for each period
+                        period_label = 'Year'
+                        date = ee.Date(timestamp).format('YYYY').getInfo()
+                    
                     index_image = calculate_index_for_period(image, roi, index_choice, reducer_choice, custom_formula)
-
-                    # Skip if index_image is None
-                    if index_image is None:
-                        st.warning(f"Index calculation failed for {location_name} on {date}. Skipping this entry.")
-                        continue
                     
-                    # Reduce the region to get the aggregated value
                     try:
                         index_value = index_image.reduceRegion(
                             reducer=get_reducer(reducer_choice),
                             geometry=roi,
                             scale=30
                         ).get(index_image.bandNames().get(0))
-
+                        
                         calculated_value = index_value.getInfo()
-
-                        # Append the results if valid
+                        
                         if isinstance(calculated_value, (int, float)):
                             aggregated_results.append({
                                 'Location Name': location_name,
                                 'Latitude': latitude,
                                 'Longitude': longitude,
-                                'Date': date,
+                                period_label: date,
+                                'Start Date': start_date_str,
+                                'End Date': end_date_str,
                                 'Calculated Value': calculated_value
                             })
                         else:
                             st.warning(f"Skipping invalid value for {location_name} on {date}")
                     except Exception as e:
                         st.error(f"Error retrieving value for {location_name}: {e}")
-
-                # Update progress bar
+                
                 progress_percentage = (idx + 1) / total_steps
                 progress_bar.progress(progress_percentage)
                 progress_text.markdown(f"Processing: {int(progress_percentage * 100)}%")
-
+        
         elif shape_type.lower() == "polygon":
             for idx, row in locations_df.iterrows():
                 polygon_name = row.get('name', f"Polygon_{idx}")
                 polygon_geometry = row.get('geometry')
-
                 location_name = polygon_name
-
+                
                 try:
                     roi = convert_to_ee_geometry(polygon_geometry)
                 except ValueError as e:
                     st.warning(f"Skipping invalid polygon {polygon_name}: {e}")
                     continue
-
+                
                 collection = ee.ImageCollection(dataset_id) \
                     .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
                     .filterBounds(roi)
-
+                
                 # Aggregate data based on the selected period
                 if aggregation_period.lower() == 'daily':
                     collection = aggregate_data_daily(collection)
                 elif aggregation_period.lower() == 'weekly':
                     collection = aggregate_data_weekly(collection)
                 elif aggregation_period.lower() == 'monthly':
-                    collection = aggregate_data_monthly(collection)
+                    collection = aggregate_data_monthly(collection, start_date_str, end_date_str)
                 elif aggregation_period.lower() == 'yearly':
                     collection = aggregate_data_yearly(collection)
-
+                
                 # Process each image in the collection
                 image_list = collection.toList(collection.size())
-
+                processed_weeks = set()  # Track processed weeks to avoid duplicates
                 for i in range(image_list.size().getInfo()):
                     image = ee.Image(image_list.get(i))
-
+                    
                     if aggregation_period.lower() == 'daily':
                         timestamp = image.get('day')
+                        period_label = 'Date'
+                        date = ee.Date(timestamp).format('YYYY-MM-dd').getInfo()
                     elif aggregation_period.lower() == 'weekly':
-                        timestamp = image.get('week')
+                        timestamp = image.get('week_start')
+                        period_label = 'Week'
+                        date = ee.String(timestamp).getInfo()  # Already formatted as YYYY-MM-dd
+                        # Skip if week is outside the date range or already processed
+                        if (pd.to_datetime(date) < pd.to_datetime(start_date_str) or 
+                            pd.to_datetime(date) > pd.to_datetime(end_date_str) or 
+                            date in processed_weeks):
+                            continue
+                        processed_weeks.add(date)
                     elif aggregation_period.lower() == 'monthly':
                         timestamp = image.get('month')
+                        period_label = 'Month'
+                        date = ee.Date(timestamp).format('YYYY-MM').getInfo()
                     elif aggregation_period.lower() == 'yearly':
                         timestamp = image.get('year')
-
-                    date = ee.Date(timestamp).format('YYYY-MM-dd').getInfo()
-
-                    # Calculate the index for each period
-                    index_image = calculate_index_for_period(image, roi, index_choice, reducer_choice, custom_formula)
+                        period_label = 'Year'
+                        date = ee.Date(timestamp).format('YYYY').getInfo()
                     
-                    # Skip if index_image is None
-                    if index_image is None:
-                        st.warning(f"Index calculation failed for {location_name} on {date}. Skipping this entry.")
-                        continue
+                    index_image = calculate_index_for_period(image, roi, index_choice, reducer_choice, custom_formula)
                     
-                    # Reduce the region to get the aggregated value
                     try:
                         index_value = index_image.reduceRegion(
                             reducer=get_reducer(reducer_choice),
                             geometry=roi,
                             scale=30
                         ).get(index_image.bandNames().get(0))
-
+                        
                         calculated_value = index_value.getInfo()
-
-                        # Append the results if valid
+                        
                         if isinstance(calculated_value, (int, float)):
                             aggregated_results.append({
                                 'Location Name': location_name,
-                                'Date': date,
+                                period_label: date,
+                                'Start Date': start_date_str,
+                                'End Date': end_date_str,
                                 'Calculated Value': calculated_value
                             })
                         else:
                             st.warning(f"Skipping invalid value for {location_name} on {date}")
                     except Exception as e:
                         st.error(f"Error retrieving value for {location_name}: {e}")
-
-                # Update progress bar
+                
                 progress_percentage = (idx + 1) / total_steps
                 progress_bar.progress(progress_percentage)
                 progress_text.markdown(f"Processing: {int(progress_percentage * 100)}%")
-
-        return aggregated_results
+    
+    if aggregated_results:
+        result_df = pd.DataFrame(aggregated_results)
+        if aggregation_period.lower() == 'daily':
+            aggregated_output = result_df.groupby('Location Name').agg({
+                'Latitude': 'first' if shape_type.lower() == 'point' else None,
+                'Longitude': 'first' if shape_type.lower() == 'point' else None,
+                'Start Date': 'first',
+                'End Date': 'first',
+                'Calculated Value': 'mean'
+            }).reset_index()
+            # Remove None columns (for polygons)
+            aggregated_output = aggregated_output[[col for col in aggregated_output.columns if col is not None]]
+            aggregated_output.rename(columns={'Calculated Value': 'Aggregated Value'}, inplace=True)
+            return aggregated_output.to_dict(orient='records')
+        else:
+            return result_df.to_dict(orient='records')
+    
+    return []
 
 # When the user clicks the process button, start the calculation
 if st.button(f"Calculate ({index_choice})"):
     if file_upload is not None:
-        # Read the user-uploaded file
-        if shape_type.lower() == "point":            
-            # Process results for the selected aggregation period
+        if shape_type.lower() == "point":
             results = process_aggregation(
                 locations_df,
                 start_date_str,
@@ -605,14 +728,10 @@ if st.button(f"Calculate ({index_choice})"):
                 aggregation_period,
                 custom_formula
             )
-        
-            # Display the results in a DataFrame
             if results:
                 result_df = pd.DataFrame(results)
                 st.write(f"Processed Results Table ({aggregation_period}):")
                 st.dataframe(result_df)
-        
-                # Provide a download button for the result CSV file
                 filename = f"{main_selection}_{dataset_id}_{start_date.strftime('%Y/%m/%d')}_{end_date.strftime('%Y/%m/%d')}_{aggregation_period.lower()}.csv"
                 st.download_button(
                     label="Download results as CSV",
@@ -620,15 +739,12 @@ if st.button(f"Calculate ({index_choice})"):
                     file_name=filename,
                     mime='text/csv'
                 )
-
-                 # Once processing is complete, hide the spinner
-                st.spinner('')  # This will stop the spinner
+                st.spinner('')
                 st.success('Processing complete!')
             else:
                 st.warning("No results were generated.")
         
         elif shape_type.lower() == "polygon":
-            # Process results for the selected aggregation period
             results = process_aggregation(
                 locations_df,
                 start_date_str,
@@ -640,14 +756,10 @@ if st.button(f"Calculate ({index_choice})"):
                 aggregation_period,
                 custom_formula
             )
-            
-            # Display the results in a DataFrame
             if results:
                 result_df = pd.DataFrame(results)
                 st.write(f"Processed Results Table ({aggregation_period}):")
                 st.dataframe(result_df)
-        
-                # Provide a download button for the result CSV file
                 filename = f"{main_selection}_{dataset_id}_{start_date.strftime('%Y/%m/%d')}_{end_date.strftime('%Y/%m/%d')}_{aggregation_period.lower()}.csv"
                 st.download_button(
                     label="Download results as CSV",
@@ -655,12 +767,10 @@ if st.button(f"Calculate ({index_choice})"):
                     file_name=filename,
                     mime='text/csv'
                 )
-                # Once processing is complete, hide the spinner
-                st.spinner('')  # This will stop the spinner
+                st.spinner('')
                 st.success('Processing complete!')
             else:
                 st.warning("No results were generated.")
         
-        else:   
-            st.warning("Please upload a file.")
-
+        else:
+            st.warning("Please upload a file.")