update app.py

app.py

@@ -73,48 +73,24 @@ elif imagery_base == "MODIS":
     with open(dataset_file) as f:
         data = json.load(f)
 elif imagery_base == "Custom Input":
-    custom_dataset_id = st.text_input(
-        "Enter Custom Earth Engine Dataset ID (e.g., ee.Image('ACA/reef_habitat/v2_0') or ee.ImageCollection('AHN/AHN4'))",
-        value=""
-    )
+    custom_dataset_id = st.text_input("Enter Custom Earth Engine Dataset ID (e.g., ee.ImageCollection('AHN/AHN4'))", value="")
     if custom_dataset_id:
         try:
-            if custom_dataset_id.startswith("ee.Image("):
-                dataset_id = custom_dataset_id.replace("ee.Image('", "").replace("')", "")
-                is_image = True
-            elif custom_dataset_id.startswith("ee.ImageCollection("):
-                dataset_id = custom_dataset_id.replace("ee.ImageCollection('", "").replace("')", "")
-                is_image = False
-            else:
-                dataset_id = custom_dataset_id
-                try:
-                    ee.Image(dataset_id).getInfo()
-                    is_image = True
-                except:
-                    is_image = False
-
-            if is_image:
-                image = ee.Image(dataset_id)
-                band_names = image.bandNames().getInfo()
-                data = {
-                    f"Custom Image: {dataset_id}": {
-                        "sub_options": {dataset_id: f"Custom Image ({dataset_id})"},
-                        "bands": {dataset_id: band_names}
-                    }
+            # Remove potential "ee.ImageCollection()" wrapper for simplicity
+            if custom_dataset_id.startswith("ee.ImageCollection("):
+                custom_dataset_id = custom_dataset_id.replace("ee.ImageCollection('", "").replace("')", "")
+            # Fetch dataset info from GEE
+            collection = ee.ImageCollection(custom_dataset_id)
+            band_names = collection.first().bandNames().getInfo()
+            data = {
+                f"Custom Dataset: {custom_dataset_id}": {
+                    "sub_options": {custom_dataset_id: f"Custom Dataset ({custom_dataset_id})"},
+                    "bands": {custom_dataset_id: band_names}
                 }
-                st.write(f"Fetched bands for {dataset_id} (Image): {', '.join(band_names)}")
-            else:
-                collection = ee.ImageCollection(dataset_id)
-                band_names = collection.first().bandNames().getInfo()
-                data = {
-                    f"Custom ImageCollection: {dataset_id}": {
-                        "sub_options": {dataset_id: f"Custom ImageCollection ({dataset_id})"},
-                        "bands": {dataset_id: band_names}
-                    }
-                }
-                st.write(f"Fetched bands for {dataset_id} (ImageCollection): {', '.join(band_names)}")
+            }
+            st.write(f"Fetched bands for {custom_dataset_id}: {', '.join(band_names)}")
         except Exception as e:
-            st.error(f"Error fetching dataset: {str(e)}. Please check the dataset ID.")
+            st.error(f"Error fetching dataset: {str(e)}. Please check the dataset ID and ensure it's valid in Google Earth Engine.")
             data = {}
     else:
         st.warning("Please enter a custom dataset ID to proceed.")
@@ -138,25 +114,15 @@ 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()))
 
+    # Display the selected dataset ID based on user input
     if sub_selection:
         st.write(f"You selected: {main_selection} -> {sub_options[sub_selection]}")
         st.write(f"Dataset ID: {sub_selection}")
-        dataset_id = sub_selection
+        dataset_id = sub_selection  # Use the key directly as the dataset ID
 
 # Earth Engine Index Calculator Section
 st.header("Earth Engine Index Calculator")
 
-# Define validate_formula function
-def validate_formula(formula, selected_bands):
-    allowed_chars = set(" +-*/()0123456789.")
-    terms = re.findall(r'[a-zA-Z][a-zA-Z0-9_]*', formula)
-    invalid_terms = [term for term in terms if term not in selected_bands]
-    if invalid_terms:
-        return False, f"Invalid terms in formula: {', '.join(invalid_terms)}. Use only {', '.join(selected_bands)}."
-    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, ""
-
 # Load band information based on selected dataset
 if main_selection and sub_selection:
     dataset_bands = data[main_selection]["bands"].get(sub_selection, [])
@@ -170,27 +136,38 @@ if main_selection and sub_selection:
         help=f"Select 1 or 2 bands from: {', '.join(dataset_bands)}"
     )
 
-    # Ensure minimum 1 
+    # Ensure minimum 1 and maximum 2 bands are selected
     if len(selected_bands) < 1:
         st.warning("Please select at least one band.")
         st.stop()
 
     # Show custom formula input if bands are selected
     if selected_bands:
+        # Provide a default formula based on the number of selected bands
         if len(selected_bands) == 1:
             default_formula = f"{selected_bands[0]}"
             example = f"'{selected_bands[0]} * 2' or '{selected_bands[0]} + 1'"
-        else:
+        else:  # len(selected_bands) == 2
             default_formula = f"({selected_bands[0]} - {selected_bands[1]}) / ({selected_bands[0]} + {selected_bands[1]})"
             example = f"'{selected_bands[0]} * {selected_bands[1]} / 2' or '({selected_bands[0]} - {selected_bands[1]}) / ({selected_bands[0]} + {selected_bands[1]})'"
 
         custom_formula = st.text_input(
-            "Enter Custom Formula (e.g., 'B3*B5/2' or '(B8 - B4) / (B8 + B4)')",
+            "Enter Custom Formula",
             value=default_formula,
             help=f"Use only these bands: {', '.join(selected_bands)}. Examples: {example}"
         )
 
         # Validate the formula
+        def validate_formula(formula, selected_bands):
+            allowed_chars = set(" +-*/()0123456789.")
+            terms = re.findall(r'[a-zA-Z][a-zA-Z0-9_]*', formula)
+            invalid_terms = [term for term in terms if term not in selected_bands]
+            if invalid_terms:
+                return False, f"Invalid terms in formula: {', '.join(invalid_terms)}. Use only {', '.join(selected_bands)}."
+            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)
@@ -199,7 +176,10 @@ if main_selection and sub_selection:
             st.warning("Please enter a custom formula to proceed.")
             st.stop()
 
+        # Display the validated formula
         st.write(f"Custom Formula: {custom_formula}")
+        
+# The rest of your code (reducer, geometry conversion, date input, aggregation, etc.) remains unchanged...
 
 # Function to get the corresponding reducer based on user input
 def get_reducer(reducer_name):
@@ -454,7 +434,7 @@ def calculate_custom_formula(image, geometry, selected_bands, custom_formula, re
     except Exception as e:
         st.error(f"Unexpected error: {e}")
         return ee.Image(0).rename('custom_result').set('error', str(e))
-        
+
 # Function to calculate index for a period
 def calculate_index_for_period(image, roi, selected_bands, custom_formula, reducer_choice):
     return calculate_custom_formula(image, roi, selected_bands, custom_formula, reducer_choice)
@@ -514,30 +494,7 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
     if not custom_formula:
         st.error("Custom formula cannot be empty. Please provide a formula.")
         return aggregated_results
-
-    # Initialize is_image and scale with default values
-    is_image = False  # Default to False, will be updated based on dataset type
-    scale = 30  # Default scale, will be overridden for ee.Image if possible
     
-    # Check if dataset_id is an ee.Image or ee.ImageCollection
-    try:
-        dataset = ee.Image(dataset_id)
-        is_image = True
-        # Try to get the nominal scale from the dataset
-        try:
-            scale = dataset.projection().nominalScale().getInfo()
-        except:
-            st.warning(f"Could not determine nominal scale for {dataset_id}. Using default scale of 30m.")
-            scale = 30
-    except:
-        try:
-            dataset = ee.ImageCollection(dataset_id)
-            is_image = False
-            scale = 30  # Default scale for ImageCollections
-        except Exception as e:
-            st.error(f"Invalid dataset ID '{dataset_id}': {str(e)}. Must be a valid ee.Image or ee.ImageCollection.")
-            return aggregated_results
-            
     total_steps = len(locations_df)
     progress_bar = st.progress(0)
     progress_text = st.empty()
@@ -565,36 +522,7 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 collection = ee.ImageCollection(dataset_id) \
                     .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
                     .filterBounds(roi)
-
-                if is_image:
-                    # Handle any ee.Image dataset
-                    image = dataset
-                    index_image = calculate_custom_formula(image, roi, selected_bands, custom_formula, reducer_choice, scale=scale)
-                    index_value = index_image.reduceRegion(
-                        reducer=get_reducer(reducer_choice),
-                        geometry=roi,
-                        scale=scale  # Use the dataset's native scale or default
-                    ).get('custom_result')
-                    calculated_value = index_value.getInfo()
-                    
-                    if isinstance(calculated_value, (int, float)):
-                        aggregated_results.append({
-                            'Location Name': location_name,
-                            'Latitude': latitude,
-                            'Longitude': longitude,
-                            'Date': 'Static',  # Static image has no time dimension
-                            'Start Date': start_date_str,
-                            'End Date': end_date_str,
-                            'Calculated Value': calculated_value
-                        })
-                    else:
-                        st.warning(f"Skipping invalid value for {location_name}")
-                else:
-                    # Handle ee.ImageCollection (existing logic)
-                    collection = dataset \
-                        .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
-                        .filterBounds(roi)
-                    
+                
                 if aggregation_period.lower() == 'custom (start date to end date)':
                     collection = aggregate_data_custom(collection)
                 elif aggregation_period.lower() == 'weekly':
@@ -674,17 +602,6 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 except ValueError as e:
                     st.warning(f"Skipping invalid polygon {polygon_name}: {e}")
                     continue
-
-                if is_image:
-                    # Handle any ee.Image dataset
-                    image = dataset
-                    index_image = calculate_custom_formula(image, roi, selected_bands, custom_formula, reducer_choice, scale=scale)
-                    index_value = index_image.reduceRegion(
-                        reducer=get_reducer(reducer_choice),
-                        geometry=roi,
-                        scale=scale
-                    ).get('custom_result')
-                    calculated_value = index_value.getInfo()
                 
                 collection = ee.ImageCollection(dataset_id) \
                     .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \