update app.py

app.py

@@ -73,22 +73,50 @@ 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.ImageCollection('AHN/AHN4'))", value="")
+    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=""
+    )
     if custom_dataset_id:
         try:
-            # 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}
+            # Clean up the input by removing "ee.Image(" or "ee.ImageCollection(" prefixes
+            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
+                # Attempt to infer type by trying ee.Image first, then ee.ImageCollection
+                try:
+                    ee.Image(dataset_id).getInfo()
+                    is_image = True
+                except:
+                    is_image = False
+
+            # Fetch dataset info from GEE based on type
+            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}
+                    }
                 }
-            }
-            st.write(f"Fetched bands for {custom_dataset_id}: {', '.join(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)}")
+
         except Exception as e:
             st.error(f"Error fetching dataset: {str(e)}. Please check the dataset ID and ensure it's valid in Google Earth Engine.")
             data = {}
@@ -157,17 +185,7 @@ if main_selection and sub_selection:
             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, ""
-
+        # Validate the formula (existing validate_formula function remains unchanged)
         is_valid, error_message = validate_formula(custom_formula, selected_bands)
         if not is_valid:
             st.error(error_message)
@@ -176,8 +194,9 @@ 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}")
+
+# Rest of your code (reducers, geometry conversion, aggregation, etc.) remains unchanged...
         
 # The rest of your code (reducer, geometry conversion, date input, aggregation, etc.) remains unchanged...
 
@@ -494,6 +513,21 @@ 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
+
+        # 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 (default to 30m if unavailable)
+            try:
+                scale = dataset.projection().nominalScale().getInfo()
+            except:
+                scale = 30  
+                st.warning(f"Could not determine nominal scale for {dataset_id}. Using default scale of 30m.")
+        except:
+            dataset = ee.ImageCollection(dataset_id)
+            is_image = False
+            scale = 30
     
     total_steps = len(locations_df)
     progress_bar = st.progress(0)
@@ -522,7 +556,36 @@ 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':
@@ -602,6 +665,17 @@ 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)) \