update app.py

app.py

@@ -4,7 +4,7 @@ import ee
 import os
 import pandas as pd
 import geopandas as gpd
-from datetime import datetime, timedelta
+from datetime import datetime
 import leafmap.foliumap as leafmap
 import re
 from shapely.geometry import base
@@ -143,7 +143,7 @@ def calculate_custom_formula(image, geometry, selected_bands, custom_formula, re
         return ee.Image(0).rename('custom_result').set('error', str(e))
 
 # Aggregation functions
-def aggregate_data_daily(collection):
+def aggregate_data_custom(collection):
     collection = collection.map(lambda image: image.set('day', ee.Date(image.get('system:time_start')).format('YYYY-MM-dd')))
     grouped_by_day = collection.aggregate_array('day').distinct()
     def calculate_daily_mean(day):
@@ -153,12 +153,12 @@ def aggregate_data_daily(collection):
     daily_images = ee.List(grouped_by_day.map(calculate_daily_mean))
     return ee.ImageCollection(daily_images)
 
-def aggregate_data_weekly(collection, start_date_str, end_date_str):
+def aggregate_data_weekly(collection):
     def set_week_start(image):
         date = ee.Date(image.get('system:time_start'))
-        days_since_start = date.difference(ee.Date(start_date_str), 'day')
-        week_index = days_since_start.divide(7).floor()
-        week_start = ee.Date(start_date_str).advance(week_index.multiply(7), 'day')
+        days_since_week_start = date.getRelative('day', 'week')
+        offset = ee.Number(days_since_week_start).multiply(-1)
+        week_start = date.advance(offset, 'day')
         return image.set('week_start', week_start.format('YYYY-MM-dd'))
     collection = collection.map(set_week_start)
     grouped_by_week = collection.aggregate_array('week_start').distinct()
@@ -191,7 +191,7 @@ def aggregate_data_yearly(collection):
     return ee.ImageCollection(yearly_images)
 
 # Worker function for processing a single geometry
-def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selected_bands, reducer_choice, shape_type, aggregation_period, custom_formula, kernel_size=None, include_boundary=None):
+def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selected_bands, reducer_choice, shape_type, aggregation_period, custom_formula, original_lat_col, original_lon_col, kernel_size=None, include_boundary=None):
     if shape_type.lower() == "point":
         latitude = row.get('latitude')
         longitude = row.get('longitude')
@@ -221,10 +221,10 @@ def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selec
         .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
         .filterBounds(roi)
 
-    if aggregation_period.lower() == 'daily':
-        collection = aggregate_data_daily(collection)
+    if aggregation_period.lower() == 'custom (start date to end date)':
+        collection = aggregate_data_custom(collection)
     elif aggregation_period.lower() == 'weekly':
-        collection = aggregate_data_weekly(collection, start_date_str, end_date_str)
+        collection = aggregate_data_weekly(collection)
     elif aggregation_period.lower() == 'monthly':
         collection = aggregate_data_monthly(collection, start_date_str, end_date_str)
     elif aggregation_period.lower() == 'yearly':
@@ -232,11 +232,12 @@ def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selec
 
     # Process each image in the collection
     image_list = collection.toList(collection.size())
-    processed_periods = set()
+    processed_weeks = set()
     aggregated_results = []
+
     for i in range(image_list.size().getInfo()):
         image = ee.Image(image_list.get(i))
-        if aggregation_period.lower() == 'daily':
+        if aggregation_period.lower() == 'custom (start date to end date)':
             timestamp = image.get('day')
             period_label = 'Date'
             date = ee.Date(timestamp).format('YYYY-MM-dd').getInfo()
@@ -244,9 +245,11 @@ def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selec
             timestamp = image.get('week_start')
             period_label = 'Week'
             date = ee.String(timestamp).getInfo()
-            if date in processed_periods:
+            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_periods.add(date)
+            processed_weeks.add(date)
         elif aggregation_period.lower() == 'monthly':
             timestamp = image.get('month')
             period_label = 'Month'
@@ -273,19 +276,21 @@ def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selec
                     'Calculated Value': calculated_value
                 }
                 if shape_type.lower() == 'point':
-                    result['Latitude'] = latitude
-                    result['Longitude'] = longitude
+                    result[original_lat_col] = latitude  # Use original column name
+                    result[original_lon_col] = longitude  # Use original column name
                 aggregated_results.append(result)
         except Exception as e:
             st.error(f"Error retrieving value for {location_name}: {e}")
+
     return aggregated_results
 
 # Main processing function
-def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id, selected_bands, reducer_choice, shape_type, aggregation_period, custom_formula="", kernel_size=None, include_boundary=None):
+def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id, selected_bands, reducer_choice, shape_type, aggregation_period, original_lat_col, original_lon_col, custom_formula="", kernel_size=None, include_boundary=None):
     aggregated_results = []
     total_steps = len(locations_df)
     progress_bar = st.progress(0)
     progress_text = st.empty()
+    
     start_time = time.time()  # Start timing the process
     with ThreadPoolExecutor(max_workers=10) as executor:
         futures = []
@@ -301,10 +306,13 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 shape_type,
                 aggregation_period,
                 custom_formula,
+                original_lat_col,
+                original_lon_col,
                 kernel_size,
                 include_boundary
             )
             futures.append(future)
+        
         completed = 0
         for future in as_completed(futures):
             result = future.result()
@@ -314,9 +322,11 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
             progress_percentage = completed / total_steps
             progress_bar.progress(progress_percentage)
             progress_text.markdown(f"Processing: {int(progress_percentage * 100)}%")
+    
     # End timing the process
     end_time = time.time()
     processing_time = end_time - start_time  # Calculate total processing time
+    
     if aggregated_results:
         result_df = pd.DataFrame(aggregated_results)
         if aggregation_period.lower() == 'custom (start date to end date)':
@@ -326,11 +336,11 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 'Calculated Value': 'mean'
             }
             if shape_type.lower() == 'point':
-                agg_dict['Latitude'] = 'first'
-                agg_dict['Longitude'] = 'first'
+                agg_dict[original_lat_col] = 'first'
+                agg_dict[original_lon_col] = 'first'
             aggregated_output = result_df.groupby('Location Name').agg(agg_dict).reset_index()
             aggregated_output.rename(columns={'Calculated Value': 'Aggregated Value'}, inplace=True)
-            return aggregated_output.to_dict(orient='records'), processing_time  # Return processing time
+            return aggregated_output.to_dict(orient='records'), processing_time
         else:
             return result_df.to_dict(orient='records'), processing_time 
     return [], processing_time  
@@ -341,6 +351,7 @@ imagery_base = st.selectbox("Select Imagery Base", ["Sentinel", "Landsat", "MODI
 
 # Initialize data as an empty dictionary
 data = {}
+
 if imagery_base == "Sentinel":
     dataset_file = "sentinel_datasets.json"
     try:
@@ -392,9 +403,12 @@ if not data:
     st.stop()
 
 st.markdown("<hr><h5><b>{}</b></h5>".format(imagery_base), unsafe_allow_html=True)
+
 main_selection = st.selectbox(f"Select {imagery_base} Dataset Category", list(data.keys()))
+
 sub_selection = None
 dataset_id = None
+
 if main_selection:
     sub_options = data[main_selection]["sub_options"]
     sub_selection = st.selectbox(f"Select Specific {imagery_base} Dataset ID", list(sub_options.keys()))
@@ -404,6 +418,7 @@ if main_selection:
         dataset_id = sub_selection
 
 st.markdown("<hr><h5><b>Earth Engine Index Calculator</b></h5>", unsafe_allow_html=True)
+
 if main_selection and sub_selection:
     dataset_bands = data[main_selection]["bands"].get(sub_selection, [])
     st.write(f"Available Bands for {sub_options[sub_selection]}: {', '.join(dataset_bands)}")
@@ -413,9 +428,11 @@ if main_selection and sub_selection:
         default=[dataset_bands[0]] if dataset_bands else [],
         help=f"Select 1 or 2 bands from: {', '.join(dataset_bands)}"
     )
+
     if len(selected_bands) < 1:
         st.warning("Please select at least one band.")
         st.stop()
+
     if selected_bands:
         if len(selected_bands) == 1:
             default_formula = f"{selected_bands[0]}"
@@ -428,6 +445,7 @@ if main_selection and sub_selection:
             value=default_formula,
             help=f"Use only these bands: {', '.join(selected_bands)}. Examples: {example}"
         )
+
         def validate_formula(formula, selected_bands):
             allowed_chars = set(" +-*/()0123456789.")
             terms = re.findall(r'[a-zA-Z][a-zA-Z0-9_]*', formula)
@@ -437,6 +455,7 @@ if main_selection and sub_selection:
             if not all(char in allowed_chars or char in ''.join(selected_bands) for char in formula):
                 return False, "Formula contains invalid characters. Use only bands, numbers, and operators (+, -, *, /, ())"
             return True, ""
+
         is_valid, error_message = validate_formula(custom_formula, selected_bands)
         if not is_valid:
             st.error(error_message)
@@ -444,6 +463,7 @@ if main_selection and sub_selection:
         elif not custom_formula:
             st.warning("Please enter a custom formula to proceed.")
             st.stop()
+
         st.write(f"Custom Formula: {custom_formula}")
 
 reducer_choice = st.selectbox(
@@ -458,12 +478,13 @@ start_date_str = start_date.strftime('%Y-%m-%d')
 end_date_str = end_date.strftime('%Y-%m-%d')
 
 aggregation_period = st.selectbox(
-    "Select Aggregation Period (e.g, Daily, Weekly, Monthly, Yearly)",
-    ["Daily", "Weekly", "Monthly", "Yearly"],
+    "Select Aggregation Period (e.g, Custom(Start Date to End Date) , Weekly , Monthly , Yearly)",
+    ["Custom (Start Date to End Date)", "Weekly", "Monthly", "Yearly"],
     index=0
 )
 
 shape_type = st.selectbox("Do you want to process 'Point' or 'Polygon' data?", ["Point", "Polygon"])
+
 kernel_size = None
 include_boundary = None
 
@@ -483,26 +504,57 @@ elif shape_type.lower() == "polygon":
 
 file_upload = st.file_uploader(f"Upload your {shape_type} data (CSV, GeoJSON, KML)", type=["csv", "geojson", "kml"])
 locations_df = pd.DataFrame()
+original_lat_col = None
+original_lon_col = None
 
 if file_upload is not None:
     if shape_type.lower() == "point":
         if file_upload.name.endswith('.csv'):
+            # Read the CSV file
             locations_df = pd.read_csv(file_upload)
-            st.write("Preview of Uploaded Data:")
+            
+            # Show the first few rows to help user identify columns
+            st.write("Preview of your uploaded data (first 5 rows):")
             st.dataframe(locations_df.head())
+            
+            # Get all column names from the uploaded file
             all_columns = locations_df.columns.tolist()
-            lat_col = st.selectbox("Select Latitude Column", options=all_columns)
-            lon_col = st.selectbox("Select Longitude Column", options=all_columns)
-            if not pd.api.types.is_numeric_dtype(locations_df[lat_col]) or not pd.api.types.is_numeric_dtype(locations_df[lon_col]):
-                st.error("Selected Latitude and Longitude columns must contain numeric values.")
+            
+            # Let user select latitude and longitude columns from dropdown
+            col1, col2 = st.columns(2)
+            with col1:
+                original_lat_col = st.selectbox(
+                    "Select Latitude Column",
+                    options=all_columns,
+                    index=all_columns.index('latitude') if 'latitude' in all_columns else 0,
+                    help="Select the column containing latitude values"
+                )
+            with col2:
+                original_lon_col = st.selectbox(
+                    "Select Longitude Column",
+                    options=all_columns,
+                    index=all_columns.index('longitude') if 'longitude' in all_columns else 0,
+                    help="Select the column containing longitude values"
+                )
+            
+            # Validate the selected columns contain numeric data
+            if not pd.api.types.is_numeric_dtype(locations_df[original_lat_col]) or not pd.api.types.is_numeric_dtype(locations_df[original_lon_col]):
+                st.error("Error: Selected Latitude and Longitude columns must contain numeric values")
                 st.stop()
-            locations_df['latitude'] = locations_df[lat_col]
-            locations_df['longitude'] = locations_df[lon_col]
+            
+            # Rename the selected columns to standard names for processing
+            locations_df = locations_df.rename(columns={
+                original_lat_col: 'latitude',
+                original_lon_col: 'longitude'
+            })
+                
         elif file_upload.name.endswith('.geojson'):
             locations_df = gpd.read_file(file_upload)
             if 'geometry' in locations_df.columns:
                 locations_df['latitude'] = locations_df['geometry'].y
                 locations_df['longitude'] = locations_df['geometry'].x
+                original_lat_col = 'latitude'
+                original_lon_col = 'longitude'
             else:
                 st.error("GeoJSON file doesn't contain geometry column")
                 st.stop()
@@ -527,8 +579,12 @@ if file_upload is not None:
                     locations_df = gpd.GeoDataFrame(points, geometry=gpd.GeoSeries.from_wkt([p['geometry'] for p in points]), crs="EPSG:4326")
                     locations_df['latitude'] = locations_df['geometry'].y
                     locations_df['longitude'] = locations_df['geometry'].x
+                    original_lat_col = 'latitude'
+                    original_lon_col = 'longitude'
             except Exception as e:
                 st.error(f"Error parsing KML file: {str(e)}")
+        
+        # Display map for points if we have valid data
         if not locations_df.empty and 'latitude' in locations_df.columns and 'longitude' in locations_df.columns:
             m = leafmap.Map(center=[locations_df['latitude'].mean(), locations_df['longitude'].mean()], zoom=10)
             for _, row in locations_df.iterrows():
@@ -539,7 +595,7 @@ if file_upload is not None:
                 m.add_marker(location=[latitude, longitude], popup=row.get('name', 'No Name'))
             st.write("Map of Uploaded Points:")
             m.to_streamlit()
-
+            
     elif shape_type.lower() == "polygon":
         if file_upload.name.endswith('.csv'):
             st.error("CSV upload not supported for polygons. Please upload a GeoJSON or KML file.")
@@ -569,6 +625,8 @@ if file_upload is not None:
                     locations_df = gpd.GeoDataFrame(polygons, geometry=gpd.GeoSeries.from_wkt([p['geometry'] for p in polygons]), crs="EPSG:4326")
             except Exception as e:
                 st.error(f"Error parsing KML file: {str(e)}")
+        
+        # Display map for polygons if we have valid data
         if not locations_df.empty and 'geometry' in locations_df.columns:
             centroid_lat = locations_df.geometry.centroid.y.mean()
             centroid_lon = locations_df.geometry.centroid.x.mean()
@@ -594,14 +652,18 @@ if st.button(f"Calculate {custom_formula}"):
                     reducer_choice,
                     shape_type,
                     aggregation_period,
+                    original_lat_col,
+                    original_lon_col,
                     custom_formula,
                     kernel_size,
                     include_boundary
                 )
+                
                 if results:
                     result_df = pd.DataFrame(results)
                     st.write(f"Processed Results Table ({aggregation_period}) for Formula: {custom_formula}")
                     st.dataframe(result_df)
+                    
                     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",
@@ -609,10 +671,12 @@ if st.button(f"Calculate {custom_formula}"):
                         file_name=filename,
                         mime='text/csv'
                     )
+                    
                     st.success(f"Processing complete! Total processing time: {processing_time:.2f} seconds.")
                 else:
                     st.warning("No results were generated. Check your inputs or formula.")
                     st.info(f"Total processing time: {processing_time:.2f} seconds.")
+            
             except Exception as e:
                 st.error(f"An error occurred during processing: {str(e)}")
     else: