update app.py

app.py

@@ -30,8 +30,8 @@ m = st.markdown(
 st.write(
     f"""
     <div style="display: flex; justify-content: space-between; align-items: center;">
-        <img src="https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/ISRO_Logo.png"  style="width: 20%; margin-right: auto;">
-        <img src="https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/SAC_Logo.png"  style="width: 20%; margin-left: auto;">
+        <img src="https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/ISRO_Logo.png" style="width: 20%; margin-right: auto;">
+        <img src="https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/SAC_Logo.png" style="width: 20%; margin-left: auto;">
     </div>
     """,
     unsafe_allow_html=True,
@@ -56,20 +56,63 @@ with open(os.path.expanduser("~/.config/earthengine/credentials"), "w") as f:
 
 ee.Initialize(project='ee-yashsacisro24')
 
-# Load the Sentinel dataset options from JSON file
-with open("sentinel_datasets.json") as f:
-    data = json.load(f)
+# Imagery base selection
+imagery_base = st.selectbox("Select Imagery Base", ["Sentinel", "Landsat", "MODIS", "Custom Input"], index=0)
+
+# Load the appropriate dataset based on imagery base
+if imagery_base == "Sentinel":
+    dataset_file = "sentinel_datasets.json"
+    with open(dataset_file) as f:
+        data = json.load(f)
+elif imagery_base == "Landsat":
+    dataset_file = "landsat_datasets.json"
+    with open(dataset_file) as f:
+        data = json.load(f)
+elif imagery_base == "MODIS":
+    dataset_file = "modis_datasets.json"
+    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="")
+    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}
+                }
+            }
+            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 and ensure it's valid in Google Earth Engine.")
+            data = {}
+    else:
+        st.warning("Please enter a custom dataset ID to proceed.")
+        data = {}
 
 # Display the title for the Streamlit app
-st.title("Sentinel Dataset")
+st.title(f"{imagery_base} Dataset")
 
 # Select dataset category (main selection)
-main_selection = st.selectbox("Select Sentinel Dataset Category", list(data.keys()))
+if data:
+    main_selection = st.selectbox(f"Select {imagery_base} Dataset Category", list(data.keys()))
+else:
+    main_selection = None
+
+# Initialize sub_selection and dataset_id as None
+sub_selection = None
+dataset_id = None
 
 # If a category is selected, display the sub-options (specific datasets)
 if main_selection:
     sub_options = data[main_selection]["sub_options"]
-    sub_selection = st.selectbox("Select Specific Dataset ID", list(sub_options.keys()))
+    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:
@@ -90,41 +133,56 @@ if main_selection and sub_selection:
         "Select 1 or 2 Bands for Calculation",
         options=dataset_bands,
         default=[dataset_bands[0]] if dataset_bands else [],
-        help="Select at least 1 band and up to 2 bands."
+        help=f"Select 1 or 2 bands from: {', '.join(dataset_bands)}"
     )
 
     # Ensure minimum 1 and maximum 2 bands are selected
     if len(selected_bands) < 1:
         st.warning("Please select at least one band.")
         st.stop()
-    # elif len(selected_bands) > 2:
-    #     st.warning("You can select a maximum of 2 bands.")
-    #     st.stop()
 
     # Show custom formula input if bands are selected
     if selected_bands:
-        default_formula = (
-            f"{selected_bands[0]}" if len(selected_bands) == 1 
-            else f"({selected_bands[0]} - {selected_bands[1]}) / ({selected_bands[0]} + {selected_bands[1]})"
-        )
+        # 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:  # 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 {', '.join(selected_bands)} in your formula. Example: 'B3*B5/2'"
+            help=f"Use only these bands: {', '.join(selected_bands)}. Examples: {example}"
         )
 
-        if not custom_formula:
+        # 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)
+            st.stop()
+        elif not custom_formula:
             st.warning("Please enter a custom formula to proceed.")
             st.stop()
 
-        # Display the formula
+        # 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):
-    """
-    Map user-friendly reducer names to Earth Engine reducer objects.
-    """
     reducers = {
         'mean': ee.Reducer.mean(),
         'sum': ee.Reducer.sum(),
@@ -187,8 +245,12 @@ end_date = st.date_input("End Date", value=pd.to_datetime('2024-12-01'))
 start_date_str = start_date.strftime('%Y-%m-%d')
 end_date_str = end_date.strftime('%Y-%m-%d')
 
-# Aggregation period selection (changed "Daily" to "Custom (Start Date to End Date)")
-aggregation_period = st.selectbox("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)
+# Aggregation period selection
+aggregation_period = st.selectbox(
+    "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
+)
 
 # Ask user whether they want to process 'Point' or 'Polygon' data
 shape_type = st.selectbox("Do you want to process 'Point' or 'Polygon' data?", ["Point", "Polygon"])
@@ -209,7 +271,7 @@ elif shape_type.lower() == "polygon":
         value=True,
         help="Check to include pixels on the polygon boundary; uncheck to exclude them."
     )
-    
+
 # Ask user to upload a file based on shape type
 file_upload = st.file_uploader(f"Upload your {shape_type} data (CSV, GeoJSON, KML)", type=["csv", "geojson", "kml"])
 
@@ -295,6 +357,8 @@ if 'last_params' not in st.session_state:
     st.session_state.last_params = {}
 if 'map_data' not in st.session_state:
     st.session_state.map_data = None
+if 'show_example' not in st.session_state:
+    st.session_state.show_example = True
 
 # Function to check if parameters have changed
 def parameters_changed():
@@ -327,27 +391,26 @@ if parameters_changed():
         'include_boundary': include_boundary
     }
 
-# Function to calculate custom formula using eval safely
+# Function to calculate custom formula
 def calculate_custom_formula(image, geometry, selected_bands, custom_formula, reducer_choice, scale=30):
     try:
         band_values = {}
+        band_names = image.bandNames().getInfo()
+        
         for band in selected_bands:
-            band_names = image.bandNames().getInfo()
             if band not in band_names:
-                raise ValueError(f"The band '{band}' does not exist in the image.")
+                raise ValueError(f"Band '{band}' not found in the dataset.")
             band_values[band] = image.select(band)
 
         reducer = get_reducer(reducer_choice)
         reduced_values = {}
         for band in selected_bands:
-            reduced_value = band_values[band].reduceRegion(
+            value = band_values[band].reduceRegion(
                 reducer=reducer,
                 geometry=geometry,
                 scale=scale
             ).get(band).getInfo()
-            if reduced_value is None:
-                reduced_value = 0
-            reduced_values[band] = float(reduced_value)
+            reduced_values[band] = float(value if value is not None else 0)
 
         formula = custom_formula
         for band in selected_bands:
@@ -355,27 +418,28 @@ def calculate_custom_formula(image, geometry, selected_bands, custom_formula, re
 
         result = eval(formula, {"__builtins__": {}}, reduced_values)
         if not isinstance(result, (int, float)):
-            raise ValueError("Formula evaluation did not result in a numeric value.")
+            raise ValueError("Formula did not result in a numeric value.")
+        
         return ee.Image.constant(result).rename('custom_result')
     
     except ZeroDivisionError:
-        st.error("Error: Division by zero occurred in the formula.")
+        st.error("Error: Division by zero in the formula.")
         return ee.Image(0).rename('custom_result').set('error', 'Division by zero')
     except SyntaxError:
-        st.error(f"Error: Invalid formula syntax in '{custom_formula}'.")
+        st.error(f"Error: Invalid syntax in formula '{custom_formula}'.")
         return ee.Image(0).rename('custom_result').set('error', 'Invalid syntax')
     except ValueError as e:
         st.error(f"Error: {str(e)}")
         return ee.Image(0).rename('custom_result').set('error', str(e))
     except Exception as e:
-        st.error(f"Unexpected error evaluating formula: {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)
 
-# Aggregation functions (renamed aggregate_data_daily to aggregate_data_custom)
+# Aggregation functions
 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()
@@ -423,7 +487,7 @@ def aggregate_data_yearly(collection):
     yearly_images = ee.List(grouped_by_year.map(calculate_yearly_mean))
     return ee.ImageCollection(yearly_images)
 
-# Process aggregation function with kernel and boundary options
+# Process aggregation 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):
     aggregated_results = []
     
@@ -446,14 +510,11 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 
                 location_name = row.get('name', f"Location_{idx}")
                 
-                # Define the region of interest based on kernel size
                 if kernel_size == "3x3 Kernel":
-                    # Assuming 30m resolution, 3x3 kernel = 90m x 90m
-                    buffer_size = 45  # Half of 90m to center the square
+                    buffer_size = 45  # 90m x 90m
                     roi = ee.Geometry.Point([longitude, latitude]).buffer(buffer_size).bounds()
                 elif kernel_size == "5x5 Kernel":
-                    # 5x5 kernel = 150m x 150m
-                    buffer_size = 75  # Half of 150m
+                    buffer_size = 75  # 150m x 150m
                     roi = ee.Geometry.Point([longitude, latitude]).buffer(buffer_size).bounds()
                 else:  # Point
                     roi = ee.Geometry.Point([longitude, latitude])
@@ -462,7 +523,6 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                     .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
                     .filterBounds(roi)
                 
-                # Changed 'daily' to 'custom (start date to end date)'
                 if aggregation_period.lower() == 'custom (start date to end date)':
                     collection = aggregate_data_custom(collection)
                 elif aggregation_period.lower() == 'weekly':
@@ -477,7 +537,6 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 for i in range(image_list.size().getInfo()):
                     image = ee.Image(image_list.get(i))
                     
-                    # Changed 'daily' to 'custom (start date to end date)'
                     if aggregation_period.lower() == 'custom (start date to end date)':
                         timestamp = image.get('day')
                         period_label = 'Date'
@@ -539,7 +598,6 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 try:
                     roi = convert_to_ee_geometry(polygon_geometry)
                     if not include_boundary:
-                        # Erode the polygon by a small buffer (e.g., 1 pixel = 30m) to exclude boundary
                         roi = roi.buffer(-30).bounds()
                 except ValueError as e:
                     st.warning(f"Skipping invalid polygon {polygon_name}: {e}")
@@ -549,7 +607,6 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                     .filterDate(ee.Date(start_date_str), ee.Date(end_date_str)) \
                     .filterBounds(roi)
                 
-                # Changed 'daily' to 'custom (start date to end date)'
                 if aggregation_period.lower() == 'custom (start date to end date)':
                     collection = aggregate_data_custom(collection)
                 elif aggregation_period.lower() == 'weekly':
@@ -564,7 +621,6 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
                 for i in range(image_list.size().getInfo()):
                     image = ee.Image(image_list.get(i))
                     
-                    # Changed 'daily' to 'custom (start date to end date)'
                     if aggregation_period.lower() == 'custom (start date to end date)':
                         timestamp = image.get('day')
                         period_label = 'Date'
@@ -617,7 +673,6 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
     
     if aggregated_results:
         result_df = pd.DataFrame(aggregated_results)
-        # Changed 'daily' to 'custom (start date to end date)'
         if aggregation_period.lower() == 'custom (start date to end date)':
             agg_dict = {
                 'Start Date': 'first',
@@ -635,7 +690,7 @@ def process_aggregation(locations_df, start_date_str, end_date_str, dataset_id,
     return []
 
 # Button to trigger calculation
-if st.button(f"Calculate({custom_formula})"):
+if st.button(f"Calculate {custom_formula}"):
     if file_upload is not None:
         if shape_type.lower() in ["point", "polygon"]:
             results = process_aggregation(
@@ -653,19 +708,41 @@ if st.button(f"Calculate({custom_formula})"):
             )
             if results:
                 result_df = pd.DataFrame(results)
-                st.write(f"Processed Results Table ({aggregation_period}):")
+                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"
+                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",
                     data=result_df.to_csv(index=False).encode('utf-8'),
                     file_name=filename,
                     mime='text/csv'
                 )
-                st.spinner('')
+                # Show an example calculation
+                if st.session_state.show_example and results:
+                    example_result = results[0]
+                    example_image = ee.ImageCollection(dataset_id).filterDate(start_date_str, end_date_str).first()
+                    example_roi = (
+                        ee.Geometry.Point([example_result['Longitude'], example_result['Latitude']]) 
+                        if shape_type.lower() == 'point' 
+                        else convert_to_ee_geometry(locations_df['geometry'].iloc[0])
+                    )
+                    example_values = {}
+                    for band in selected_bands:
+                        value = example_image.select(band).reduceRegion(
+                            reducer=get_reducer(reducer_choice),
+                            geometry=example_roi,
+                            scale=30
+                        ).get(band).getInfo()
+                        example_values[band] = float(value if value is not None else 0)
+                    example_formula = custom_formula
+                    for band in selected_bands:
+                        example_formula = example_formula.replace(band, str(example_values[band]))
+                    # st.write(f"Example Calculation: {custom_formula} -> {example_formula} = {example_result.get('Calculated Value', example_result.get('Aggregated Value'))}")
+                    st.session_state.show_example = False
                 st.success('Processing complete!')
             else:
-                st.warning("No results were generated.")
+                st.warning("No results were generated. Check your inputs or formula.")
         else:
-            st.warning("Please upload a file.")
-
+            st.warning("Please upload a file to process.")
+    else:
+        st.warning("Please upload a file to proceed.")