update app.py

app.py

@@ -143,32 +143,30 @@ 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):
-    collection = collection.map(lambda image: image.set('date', ee.Date(image.get('system:time_start')).format('YYYY-MM-dd')))
-    grouped_by_day = collection.aggregate_array('date').distinct()
-    def calculate_daily_mean(date):
-        daily_collection = collection.filter(ee.Filter.eq('date', date))
+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):
+        daily_collection = collection.filter(ee.Filter.eq('day', day))
         daily_mean = daily_collection.mean()
-        return daily_mean.set('date', date)
+        return daily_mean.set('day', day)
     daily_images = ee.List(grouped_by_day.map(calculate_daily_mean))
     return ee.ImageCollection(daily_images)
 
-def aggregate_data_weekly(collection, start_date_str):
-    start_date = ee.Date(start_date_str)
-    end_date = ee.Date(collection.aggregate_max('system:time_start'))
-    diff = end_date.difference(start_date, 'week').ceil()
-    week_starts = ee.List.sequence(0, diff).map(lambda x: start_date.advance(x, 'week'))
-    
+def aggregate_data_weekly(collection):
+    def set_week_start(image):
+        date = ee.Date(image.get('system:time_start'))
+        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()
     def calculate_weekly_mean(week_start):
-        week_end = ee.Date(week_start).advance(1, 'week')
-        weekly_collection = collection.filterDate(ee.Date(week_start), week_end)
+        weekly_collection = collection.filter(ee.Filter.eq('week_start', week_start))
         weekly_mean = weekly_collection.mean()
-        return weekly_mean.set({
-            'week_start': week_start.format('YYYY-MM-dd'),
-            'system:time_start': week_start.millis()
-        })
-    
-    weekly_images = week_starts.map(calculate_weekly_mean)
+        return weekly_mean.set('week_start', week_start)
+    weekly_images = ee.List(grouped_by_week.map(calculate_weekly_mean))
     return ee.ImageCollection(weekly_images)
 
 def aggregate_data_monthly(collection, start_date, end_date):
@@ -192,18 +190,8 @@ def aggregate_data_yearly(collection):
     yearly_images = ee.List(grouped_by_year.map(calculate_yearly_mean))
     return ee.ImageCollection(yearly_images)
 
-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):
-        daily_collection = collection.filter(ee.Filter.eq('day', day))
-        daily_mean = daily_collection.mean()
-        return daily_mean.set('day', day)
-    daily_images = ee.List(grouped_by_day.map(calculate_daily_mean))
-    return ee.ImageCollection(daily_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')
@@ -233,50 +221,43 @@ 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)
+        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':
         collection = aggregate_data_yearly(collection)
-    elif aggregation_period.lower() == 'custom (start date to end date)':
-        collection = aggregate_data_custom(collection)
 
     # 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':
-            timestamp = image.get('date')
+        if aggregation_period.lower() == 'custom (start date to end date)':
+            timestamp = image.get('day')
             period_label = 'Date'
-            date = ee.String(timestamp).getInfo()
+            date = ee.Date(timestamp).format('YYYY-MM-dd').getInfo()
         elif aggregation_period.lower() == 'weekly':
             timestamp = image.get('week_start')
             period_label = 'Week'
             date = ee.String(timestamp).getInfo()
             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_periods):
+                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'
-            date = ee.String(timestamp).getInfo()
+            date = ee.Date(timestamp).format('YYYY-MM').getInfo()
         elif aggregation_period.lower() == 'yearly':
             timestamp = image.get('year')
             period_label = 'Year'
-            date = ee.String(timestamp).getInfo()
-        elif aggregation_period.lower() == 'custom (start date to end date)':
-            timestamp = image.get('day')
-            period_label = 'Date'
-            date = ee.String(timestamp).getInfo()
+            date = ee.Date(timestamp).format('YYYY').getInfo()
 
         index_image = calculate_custom_formula(image, roi, selected_bands, custom_formula, reducer_choice, scale=30)
         try:
@@ -295,8 +276,8 @@ 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}")
@@ -304,13 +285,13 @@ def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selec
     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_time = time.time()  # Start timing the process
     with ThreadPoolExecutor(max_workers=10) as executor:
         futures = []
         for idx, row in locations_df.iterrows():
@@ -325,6 +306,8 @@ 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
             )
@@ -340,8 +323,9 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
             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
+    processing_time = end_time - start_time  # Calculate total processing time
     
     if aggregated_results:
         result_df = pd.DataFrame(aggregated_results)
@@ -352,8 +336,8 @@ 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
@@ -494,8 +478,8 @@ 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",
-    ["Daily", "Weekly", "Monthly", "Yearly", "Custom (Start Date to End Date)"],
+    "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
 )
 
@@ -520,15 +504,60 @@ 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()
-lat_col = None
-lon_col = None
+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)
+            
+            # 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()
+            
+            # 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()
+            
+            # 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()
         elif file_upload.name.endswith('.kml'):
             kml_string = file_upload.read().decode('utf-8')
             try:
@@ -543,39 +572,38 @@ if file_upload is not None:
                         coords = [c.strip() for c in coords_text.split(',')]
                         if len(coords) >= 2:
                             lon, lat = float(coords[0]), float(coords[1])
-                            points.append({'name': name, 'latitude': lat, 'longitude': lon})
+                            points.append({'name': name, 'geometry': f"POINT ({lon} {lat})"})
                 if not points:
                     st.error("No valid Point data found in the KML file.")
-                    locations_df = pd.DataFrame()
                 else:
-                    locations_df = pd.DataFrame(points)
+                    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)}")
-                locations_df = pd.DataFrame()
-
-        # Add column selection for latitude and longitude
-        if not locations_df.empty:
-            numeric_columns = locations_df.select_dtypes(include=['number']).columns.tolist()
+        
+        # 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():
+                latitude = row['latitude']
+                longitude = row['longitude']
+                if pd.isna(latitude) or pd.isna(longitude):
+                    continue
+                m.add_marker(location=[latitude, longitude], popup=row.get('name', 'No Name'))
+            st.write("Map of Uploaded Points:")
+            m.to_streamlit()
             
-            if len(numeric_columns) >= 2:
-                col1, col2 = st.columns(2)
-                with col1:
-                    lat_col = st.selectbox("Select Latitude Column", numeric_columns, 
-                                         index=numeric_columns.index('latitude') if 'latitude' in numeric_columns else 0)
-                with col2:
-                    lon_col = st.selectbox("Select Longitude Column", numeric_columns, 
-                                         index=numeric_columns.index('longitude') if 'longitude' in numeric_columns else 1)
-                
-                # Create geometry column from selected lat/lon columns
-                locations_df['geometry'] = gpd.points_from_xy(locations_df[lon_col], locations_df[lat_col])
-            else:
-                st.error("Not enough numeric columns found for latitude/longitude selection.")
-
     elif shape_type.lower() == "polygon":
         if file_upload.name.endswith('.csv'):
-            locations_df = pd.read_csv(file_upload)
+            st.error("CSV upload not supported for polygons. Please upload a GeoJSON or KML file.")
         elif file_upload.name.endswith('.geojson'):
             locations_df = gpd.read_file(file_upload)
+            if 'geometry' not in locations_df.columns:
+                st.error("GeoJSON file doesn't contain geometry column")
+                st.stop()
         elif file_upload.name.endswith('.kml'):
             kml_string = file_upload.read().decode('utf-8')
             try:
@@ -593,42 +621,23 @@ if file_upload is not None:
                             polygons.append({'name': name, 'geometry': f"POLYGON (({coords_str}))"})
                 if not polygons:
                     st.error("No valid Polygon data found in the KML file.")
-                    locations_df = pd.DataFrame()
                 else:
                     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)}")
-                locations_df = pd.DataFrame()
-
-    # Display uploaded data preview and map
-    if not locations_df.empty:
-        st.write("Preview of Uploaded Data:")
-        st.dataframe(locations_df.head())
-
-        if 'geometry' in locations_df.columns:
-            if shape_type.lower() == "point":
-                locations_df['latitude'] = locations_df['geometry'].y
-                locations_df['longitude'] = locations_df['geometry'].x
-                m = leafmap.Map(center=[locations_df['latitude'].mean(), locations_df['longitude'].mean()], zoom=10)
-                for _, row in locations_df.iterrows():
-                    latitude = row['latitude']
-                    longitude = row['longitude']
-                    if pd.isna(latitude) or pd.isna(longitude):
-                        continue
-                    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":
-                centroid_lat = locations_df.geometry.centroid.y.mean()
-                centroid_lon = locations_df.geometry.centroid.x.mean()
-                m = leafmap.Map(center=[centroid_lat, centroid_lon], zoom=10)
-                for _, row in locations_df.iterrows():
-                    polygon = row['geometry']
-                    if polygon.is_valid:
-                        gdf = gpd.GeoDataFrame([row], geometry=[polygon], crs=locations_df.crs)
-                        m.add_gdf(gdf=gdf, layer_name=row.get('name', 'Unnamed Polygon'))
-                st.write("Map of Uploaded Polygons:")
-                m.to_streamlit()
+        
+        # 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()
+            m = leafmap.Map(center=[centroid_lat, centroid_lon], zoom=10)
+            for _, row in locations_df.iterrows():
+                polygon = row['geometry']
+                if polygon.is_valid:
+                    gdf = gpd.GeoDataFrame([row], geometry=[polygon], crs=locations_df.crs)
+                    m.add_gdf(gdf=gdf, layer_name=row.get('name', 'Unnamed Polygon'))
+            st.write("Map of Uploaded Polygons:")
+            m.to_streamlit()
 
 if st.button(f"Calculate {custom_formula}"):
     if not locations_df.empty:
@@ -643,6 +652,8 @@ 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
@@ -669,4 +680,4 @@ if st.button(f"Calculate {custom_formula}"):
             except Exception as e:
                 st.error(f"An error occurred during processing: {str(e)}")
     else:
-        st.warning("Please upload a file to proceed.")
+        st.warning("Please upload a valid file to proceed.")