update app.py

app.py

@@ -12,9 +12,6 @@ from xml.etree import ElementTree as XET
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import time
 
-# Define default scale for calculations (in meters)
-DEFAULT_SCALE = 30
-
 # Set up the page layout
 st.set_page_config(layout="wide")
 
@@ -108,7 +105,7 @@ def convert_to_ee_geometry(geometry):
         raise ValueError("Unsupported geometry input type. Supported types are Shapely, GeoJSON, and KML.")
 
 # Function to calculate custom formula
-def calculate_custom_formula(image, geometry, selected_bands, custom_formula, reducer_choice, scale=DEFAULT_SCALE):
+def calculate_custom_formula(image, geometry, selected_bands, custom_formula, reducer_choice, scale=30):
     try:
         band_values = {}
         band_names = image.bandNames().getInfo()
@@ -145,7 +142,8 @@ def calculate_custom_formula(image, geometry, selected_bands, custom_formula, re
         st.error(f"Unexpected error: {e}")
         return ee.Image(0).rename('custom_result').set('error', str(e))
 
-# Aggregation functions
+# Aggregation functions (unchanged)
+
 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()
@@ -208,7 +206,7 @@ def aggregate_data_daily(collection):
     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, kernel_size=None, include_boundary=None, default_scale=30):
     if shape_type.lower() == "point":
         latitude = row.get('latitude')
         longitude = row.get('longitude')
@@ -232,11 +230,12 @@ def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selec
                 roi = roi.buffer(-30).bounds()
         except ValueError:
             return None  # Skip invalid polygons
-    # Filter and aggregate the image collection
+
     collection = ee.ImageCollection(dataset_id) \
         .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
         .filterBounds(roi) \
-        .select(selected_bands)  # Filter bands here
+        .select(selected_bands)
+
     if aggregation_period.lower() == 'custom (start date to end date)':
         collection = aggregate_data_custom(collection)
     elif aggregation_period.lower() == 'daily':
@@ -247,10 +246,11 @@ def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selec
         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_days = set()
     aggregated_results = []
+
     for i in range(image_list.size().getInfo()):
         image = ee.Image(image_list.get(i))
         if aggregation_period.lower() == 'custom (start date to end date)':
@@ -273,12 +273,14 @@ def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selec
             timestamp = image.get('year')
             period_label = 'Year'
             date = ee.Date(timestamp).format('YYYY').getInfo()
-        index_image = calculate_custom_formula(image, roi, selected_bands, custom_formula, reducer_choice, scale=DEFAULT_SCALE)
+
+        index_image = calculate_custom_formula(image, roi, selected_bands, custom_formula, reducer_choice, scale=default_scale)
+
         try:
             index_value = index_image.reduceRegion(
                 reducer=get_reducer(reducer_choice),
                 geometry=roi,
-                scale=DEFAULT_SCALE
+                scale=default_scale
             ).get('custom_result')
             calculated_value = index_value.getInfo()
             if isinstance(calculated_value, (int, float)):
@@ -295,15 +297,17 @@ def process_single_geometry(row, start_date_str, end_date_str, dataset_id, selec
                 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, custom_formula="", kernel_size=None, include_boundary=None, default_scale=30):
     aggregated_results = []
     total_steps = len(locations_df)
     progress_bar = st.progress(0)
     progress_text = st.empty()
-    start_time = time.time()  # Start timing the process
+    start_time = time.time()
+
     with ThreadPoolExecutor(max_workers=10) as executor:
         futures = []
         for idx, row in locations_df.iterrows():
@@ -319,9 +323,11 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 aggregation_period,
                 custom_formula,
                 kernel_size,
-                include_boundary
+                include_boundary,
+                default_scale
             )
             futures.append(future)
+
         completed = 0
         for future in as_completed(futures):
             result = future.result()
@@ -331,9 +337,10 @@ 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
+    processing_time = end_time - start_time
+
     if aggregated_results:
         result_df = pd.DataFrame(aggregated_results)
         if aggregation_period.lower() == 'custom (start date to end date)':
@@ -347,10 +354,10 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 agg_dict['Longitude'] = '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  
+            return result_df.to_dict(orient='records'), processing_time
+    return [], processing_time
 
 # Streamlit App Logic
 st.markdown("<h5>Image Collection</h5>", unsafe_allow_html=True)
@@ -662,7 +669,8 @@ if st.button(f"Calculate {custom_formula}"):
                     aggregation_period,
                     custom_formula,
                     kernel_size,
-                    include_boundary
+                    include_boundary,
+                    default_scale
                 )
                 # Check if results were generated
                 if results: