update app.py

app.py

@@ -1,3 +1,783 @@
+# import streamlit as st
+# import json
+# import ee
+# import os
+# import pandas as pd
+# import geopandas as gpd
+# from datetime import datetime
+# import leafmap.foliumap as leafmap
+# import re
+# from shapely.geometry import base
+# from lxml import etree
+# from xml.etree import ElementTree as ET
+
+# # Set up the page layout
+# st.set_page_config(layout="wide")
+
+# # Custom button styling
+# m = st.markdown(
+#     """
+#     <style>
+#     div.stButton > button:first-child {
+#         background-color: #006400;
+#         color:#ffffff;
+#     }
+#     </style>""",
+#     unsafe_allow_html=True,
+# )
+
+# # Logo
+# 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;">
+#     </div>
+#     """,
+#     unsafe_allow_html=True,
+# )
+
+# # Title
+# st.markdown(
+#     f"""
+#     <h1 style="text-align: center;">Precision Analysis for Vegetation, Water, and Air Quality</h1>
+#     """,
+#     unsafe_allow_html=True,
+# )
+# st.write("<h2><div style='text-align: center;'>User Inputs</div></h2>", unsafe_allow_html=True)
+
+# # Authenticate and initialize Earth Engine
+# earthengine_credentials = os.environ.get("EE_Authentication")
+
+# # Initialize Earth Engine with secret credentials
+# os.makedirs(os.path.expanduser("~/.config/earthengine/"), exist_ok=True)
+# with open(os.path.expanduser("~/.config/earthengine/credentials"), "w") as f:
+#     f.write(earthengine_credentials)
+
+# ee.Initialize(project='ee-yashsacisro24')
+
+# # 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(f"{imagery_base} Dataset")
+
+# # Select dataset category (main selection)
+# 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(f"Select Specific {imagery_base} Dataset ID", list(sub_options.keys()))
+
+#     # Display the selected dataset ID and its availability 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  # Use the key directly as the dataset ID
+
+#         # Fetch and display dataset availability in green text
+#         try:
+#             # Create an Earth Engine ImageCollection object for the selected dataset
+#             collection = ee.ImageCollection(dataset_id)
+            
+#             # Get the date range of the collection
+#             range_info = collection.reduceColumns(
+#                 reducer=ee.Reducer.minMax(),
+#                 selectors=['system:time_start']
+#             ).getInfo()
+            
+#             # Extract min and max timestamps (in milliseconds) and convert to readable dates
+#             min_time = range_info.get('min', None)
+#             max_time = range_info.get('max', None)
+            
+#             if min_time and max_time:
+#                 start_date = datetime.fromtimestamp(min_time / 1000).strftime('%Y-%m-%d')
+#                 end_date = datetime.fromtimestamp(max_time / 1000).strftime('%Y-%m-%d')
+#                 st.markdown(
+#                     f"<strong>Dataset Availability:</strong> From <span style='color: #fc0101;'>{start_date}</span> to <span style='color: #fc0101;'>{end_date}</span>",
+#                     unsafe_allow_html=True
+#                 )
+#             else:
+#                 st.markdown(
+#                     f"<span style='color: #fc0101;'><strong>Dataset Availability:</strong> Date range not available.</span>",
+#                     unsafe_allow_html=True
+#                 )
+                
+#         except Exception as e:
+#             st.error(f"Error fetching dataset availability: {str(e)}")
+
+# # Earth Engine Index Calculator Section
+# st.header("Earth Engine Index Calculator")
+
+# # Load band information based on selected dataset
+# if main_selection and sub_selection:
+#     dataset_bands = data[main_selection]["bands"].get(sub_selection, [])
+#     st.write(f"Available Bands for {sub_options[sub_selection]}: {', '.join(dataset_bands)}")
+
+#     # Allow user to select 1 or 2 bands
+#     selected_bands = st.multiselect(
+#         "Select 1 or 2 Bands for Calculation",
+#         options=dataset_bands,
+#         default=[dataset_bands[0]] if dataset_bands else [],
+#         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()
+
+#     # 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:  # 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 (B8 - B4) / (B8 + B4) , B4*B3/2)",
+#             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)
+#             st.stop()
+#         elif not custom_formula:
+#             st.warning("Please enter a custom formula to proceed.")
+#             st.stop()
+
+#         # Display the validated formula
+#         st.write(f"Custom Formula: {custom_formula}")
+
+# # Function to get the corresponding reducer based on user input
+# def get_reducer(reducer_name):
+#     reducers = {
+#         'mean': ee.Reducer.mean(),
+#         'sum': ee.Reducer.sum(),
+#         'median': ee.Reducer.median(),
+#         'min': ee.Reducer.min(),
+#         'max': ee.Reducer.max(),
+#         'count': ee.Reducer.count(),
+#     }
+#     return reducers.get(reducer_name.lower(), ee.Reducer.mean())
+
+# # Streamlit selectbox for reducer choice
+# reducer_choice = st.selectbox(
+#     "Select Reducer (e.g, mean , sum , median , min , max , count)",
+#     ['mean', 'sum', 'median', 'min', 'max', 'count'],
+#     index=0  # Default to 'mean'
+# )
+
+# # Function to convert geometry to Earth Engine format
+# def convert_to_ee_geometry(geometry):
+#     if isinstance(geometry, base.BaseGeometry):
+#         if geometry.is_valid:
+#             geojson = geometry.__geo_interface__
+#             return ee.Geometry(geojson)
+#         else:
+#             raise ValueError("Invalid geometry: The polygon geometry is not valid.")
+#     elif isinstance(geometry, dict) or isinstance(geometry, str):
+#         try:
+#             if isinstance(geometry, str):
+#                 geometry = json.loads(geometry)
+#             if 'type' in geometry and 'coordinates' in geometry:
+#                 return ee.Geometry(geometry)
+#             else:
+#                 raise ValueError("GeoJSON format is invalid.")
+#         except Exception as e:
+#             raise ValueError(f"Error parsing GeoJSON: {e}")
+#     elif isinstance(geometry, str) and geometry.lower().endswith(".kml"):
+#         try:
+#             tree = ET.parse(geometry)
+#             kml_root = tree.getroot()
+#             kml_namespace = {'kml': 'http://www.opengis.net/kml/2.2'}
+#             coordinates = kml_root.findall(".//kml:coordinates", kml_namespace)
+#             if coordinates:
+#                 coords_text = coordinates[0].text.strip()
+#                 coords = coords_text.split()
+#                 coords = [tuple(map(float, coord.split(','))) for coord in coords]
+#                 geojson = {"type": "Polygon", "coordinates": [coords]}
+#                 return ee.Geometry(geojson)
+#             else:
+#                 raise ValueError("KML does not contain valid coordinates.")
+#         except Exception as e:
+#             raise ValueError(f"Error parsing KML: {e}")
+#     else:
+#         raise ValueError("Unsupported geometry input type. Supported types are Shapely, GeoJSON, and KML.")
+
+# # Date Input for Start and End Dates
+# start_date = st.date_input("Start Date", value=pd.to_datetime('2024-11-01'))
+# end_date = st.date_input("End Date", value=pd.to_datetime('2024-12-01'))
+
+# # Convert start_date and end_date to string format for Earth Engine
+# start_date_str = start_date.strftime('%Y-%m-%d')
+# end_date_str = end_date.strftime('%Y-%m-%d')
+
+# # 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"])
+
+# # Additional options based on shape type
+# kernel_size = None
+# include_boundary = None
+# if shape_type.lower() == "point":
+#     kernel_size = st.selectbox(
+#         "Select Calculation Area(e.g, Point , 3x3 Kernel , 5x5 Kernel)",
+#         ["Point", "3x3 Kernel", "5x5 Kernel"],
+#         index=0,
+#         help="Choose 'Point' for exact point calculation, or a kernel size for area averaging."
+#     )
+# elif shape_type.lower() == "polygon":
+#     include_boundary = st.checkbox(
+#         "Include Boundary Pixels",
+#         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"])
+
+# if file_upload is not None:
+#     # Read the user-uploaded file
+#     if shape_type.lower() == "point":
+#         if file_upload.name.endswith('.csv'):
+#             locations_df = pd.read_csv(file_upload)
+#         elif file_upload.name.endswith('.geojson'):
+#             locations_df = gpd.read_file(file_upload)
+#         elif file_upload.name.endswith('.kml'):
+#             locations_df = gpd.read_file(file_upload)
+#         else:
+#             st.error("Unsupported file format. Please upload CSV, GeoJSON, or KML.")
+#             locations_df = pd.DataFrame()
+
+#         if 'geometry' in locations_df.columns:
+#             if locations_df.geometry.geom_type.isin(['Polygon', 'MultiPolygon']).any():
+#                 st.warning("The uploaded file contains polygon data. Please select 'Polygon' for processing.")
+#                 st.stop()
+
+#         with st.spinner('Processing Map...'):
+#             if locations_df is not None and not locations_df.empty:
+#                 if 'geometry' in locations_df.columns:
+#                     locations_df['latitude'] = locations_df['geometry'].y
+#                     locations_df['longitude'] = locations_df['geometry'].x
+
+#                 if 'latitude' not in locations_df.columns or 'longitude' not in locations_df.columns:
+#                     st.error("Uploaded file is missing required 'latitude' or 'longitude' columns.")
+#                 else:
+#                     st.write("Preview of the uploaded points data:")
+#                     st.dataframe(locations_df.head())
+#                     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()
+#                     st.session_state.map_data = m
+
+#     elif shape_type.lower() == "polygon":
+#         if file_upload.name.endswith('.csv'):
+#             locations_df = pd.read_csv(file_upload)
+#         elif file_upload.name.endswith('.geojson'):
+#             locations_df = gpd.read_file(file_upload)
+#         elif file_upload.name.endswith('.kml'):
+#             locations_df = gpd.read_file(file_upload)
+#         else:
+#             st.error("Unsupported file format. Please upload CSV, GeoJSON, or KML.")
+#             locations_df = pd.DataFrame()
+
+#         if 'geometry' in locations_df.columns:
+#             if locations_df.geometry.geom_type.isin(['Point', 'MultiPoint']).any():
+#                 st.warning("The uploaded file contains point data. Please select 'Point' for processing.")
+#                 st.stop()
+
+#         with st.spinner('Processing Map...'):
+#             if locations_df is not None and not locations_df.empty:
+#                 if 'geometry' not in locations_df.columns:
+#                     st.error("Uploaded file is missing required 'geometry' column.")
+#                 else:
+#                     st.write("Preview of the uploaded polygons data:")
+#                     st.dataframe(locations_df.head())
+#                     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()
+#                     st.session_state.map_data = m
+
+# # Initialize session state for storing results
+# if 'results' not in st.session_state:
+#     st.session_state.results = []
+# 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():
+#     return (
+#         st.session_state.last_params.get('main_selection') != main_selection or
+#         st.session_state.last_params.get('dataset_id') != dataset_id or
+#         st.session_state.last_params.get('selected_bands') != selected_bands or
+#         st.session_state.last_params.get('custom_formula') != custom_formula or
+#         st.session_state.last_params.get('start_date_str') != start_date_str or
+#         st.session_state.last_params.get('end_date_str') != end_date_str or
+#         st.session_state.last_params.get('shape_type') != shape_type or
+#         st.session_state.last_params.get('file_upload') != file_upload or
+#         st.session_state.last_params.get('kernel_size') != kernel_size or
+#         st.session_state.last_params.get('include_boundary') != include_boundary
+#     )
+
+# # If parameters have changed, reset the results
+# if parameters_changed():
+#     st.session_state.results = []
+#     st.session_state.last_params = {
+#         'main_selection': main_selection,
+#         'dataset_id': dataset_id,
+#         'selected_bands': selected_bands,
+#         'custom_formula': custom_formula,
+#         'start_date_str': start_date_str,
+#         'end_date_str': end_date_str,
+#         'shape_type': shape_type,
+#         'file_upload': file_upload,
+#         'kernel_size': kernel_size,
+#         'include_boundary': include_boundary
+#     }
+
+# # 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:
+#             if band not in band_names:
+#                 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:
+#             value = band_values[band].reduceRegion(
+#                 reducer=reducer,
+#                 geometry=geometry,
+#                 scale=scale
+#             ).get(band).getInfo()
+#             reduced_values[band] = float(value if value is not None else 0)
+
+#         formula = custom_formula
+#         for band in selected_bands:
+#             formula = formula.replace(band, str(reduced_values[band]))
+
+#         result = eval(formula, {"__builtins__": {}}, reduced_values)
+#         if not isinstance(result, (int, float)):
+#             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 in the formula.")
+#         return ee.Image(0).rename('custom_result').set('error', 'Division by zero')
+#     except SyntaxError:
+#         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: {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
+# 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)
+
+# 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):
+#         weekly_collection = collection.filter(ee.Filter.eq('week_start', week_start))
+#         weekly_mean = weekly_collection.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):
+#     collection = collection.filterDate(start_date, end_date)
+#     collection = collection.map(lambda image: image.set('month', ee.Date(image.get('system:time_start')).format('YYYY-MM')))
+#     grouped_by_month = collection.aggregate_array('month').distinct()
+#     def calculate_monthly_mean(month):
+#         monthly_collection = collection.filter(ee.Filter.eq('month', month))
+#         monthly_mean = monthly_collection.mean()
+#         return monthly_mean.set('month', month)
+#     monthly_images = ee.List(grouped_by_month.map(calculate_monthly_mean))
+#     return ee.ImageCollection(monthly_images)
+
+# def aggregate_data_yearly(collection):
+#     collection = collection.map(lambda image: image.set('year', ee.Date(image.get('system:time_start')).format('YYYY')))
+#     grouped_by_year = collection.aggregate_array('year').distinct()
+#     def calculate_yearly_mean(year):
+#         yearly_collection = collection.filter(ee.Filter.eq('year', year))
+#         yearly_mean = yearly_collection.mean()
+#         return yearly_mean.set('year', year)
+#     yearly_images = ee.List(grouped_by_year.map(calculate_yearly_mean))
+#     return ee.ImageCollection(yearly_images)
+
+# # 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 = []
+    
+#     if not custom_formula:
+#         st.error("Custom formula cannot be empty. Please provide a formula.")
+#         return aggregated_results
+    
+#     total_steps = len(locations_df)
+#     progress_bar = st.progress(0)
+#     progress_text = st.empty()
+    
+#     with st.spinner('Processing data...'):
+#         if shape_type.lower() == "point":
+#             for idx, row in locations_df.iterrows():
+#                 latitude = row.get('latitude')
+#                 longitude = row.get('longitude')
+#                 if pd.isna(latitude) or pd.isna(longitude):
+#                     st.warning(f"Skipping location {idx} with missing latitude or longitude")
+#                     continue
+                
+#                 location_name = row.get('name', f"Location_{idx}")
+                
+#                 if kernel_size == "3x3 Kernel":
+#                     buffer_size = 45  # 90m x 90m
+#                     roi = ee.Geometry.Point([longitude, latitude]).buffer(buffer_size).bounds()
+#                 elif kernel_size == "5x5 Kernel":
+#                     buffer_size = 75  # 150m x 150m
+#                     roi = ee.Geometry.Point([longitude, latitude]).buffer(buffer_size).bounds()
+#                 else:  # Point
+#                     roi = ee.Geometry.Point([longitude, latitude])
+                
+#                 collection = ee.ImageCollection(dataset_id) \
+#                     .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':
+#                     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)
+                
+#                 image_list = collection.toList(collection.size())
+#                 processed_weeks = set()
+#                 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)':
+#                         timestamp = image.get('day')
+#                         period_label = 'Date'
+#                         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_weeks):
+#                             continue
+#                         processed_weeks.add(date)
+#                     elif aggregation_period.lower() == 'monthly':
+#                         timestamp = image.get('month')
+#                         period_label = 'Month'
+#                         date = ee.Date(timestamp).format('YYYY-MM').getInfo()
+#                     elif aggregation_period.lower() == 'yearly':
+#                         timestamp = image.get('year')
+#                         period_label = 'Year'
+#                         date = ee.Date(timestamp).format('YYYY').getInfo()
+                    
+#                     index_image = calculate_index_for_period(image, roi, selected_bands, custom_formula, reducer_choice)
+                    
+#                     try:
+#                         index_value = index_image.reduceRegion(
+#                             reducer=get_reducer(reducer_choice),
+#                             geometry=roi,
+#                             scale=30
+#                         ).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,
+#                                 period_label: date,
+#                                 'Start Date': start_date_str,
+#                                 'End Date': end_date_str,
+#                                 'Calculated Value': calculated_value
+#                             })
+#                         else:
+#                             st.warning(f"Skipping invalid value for {location_name} on {date}")
+#                     except Exception as e:
+#                         st.error(f"Error retrieving value for {location_name}: {e}")
+                
+#                 progress_percentage = (idx + 1) / total_steps
+#                 progress_bar.progress(progress_percentage)
+#                 progress_text.markdown(f"Processing: {int(progress_percentage * 100)}%")
+        
+#         elif shape_type.lower() == "polygon":
+#             for idx, row in locations_df.iterrows():
+#                 polygon_name = row.get('name', f"Polygon_{idx}")
+#                 polygon_geometry = row.get('geometry')
+#                 location_name = polygon_name
+                
+#                 try:
+#                     roi = convert_to_ee_geometry(polygon_geometry)
+#                     if not include_boundary:
+#                         roi = roi.buffer(-30).bounds()
+#                 except ValueError as e:
+#                     st.warning(f"Skipping invalid polygon {polygon_name}: {e}")
+#                     continue
+                
+#                 collection = ee.ImageCollection(dataset_id) \
+#                     .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':
+#                     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)
+                
+#                 image_list = collection.toList(collection.size())
+#                 processed_weeks = set()
+#                 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)':
+#                         timestamp = image.get('day')
+#                         period_label = 'Date'
+#                         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_weeks):
+#                             continue
+#                         processed_weeks.add(date)
+#                     elif aggregation_period.lower() == 'monthly':
+#                         timestamp = image.get('month')
+#                         period_label = 'Month'
+#                         date = ee.Date(timestamp).format('YYYY-MM').getInfo()
+#                     elif aggregation_period.lower() == 'yearly':
+#                         timestamp = image.get('year')
+#                         period_label = 'Year'
+#                         date = ee.Date(timestamp).format('YYYY').getInfo()
+                    
+#                     index_image = calculate_index_for_period(image, roi, selected_bands, custom_formula, reducer_choice)
+                    
+#                     try:
+#                         index_value = index_image.reduceRegion(
+#                             reducer=get_reducer(reducer_choice),
+#                             geometry=roi,
+#                             scale=30
+#                         ).get('custom_result')
+                        
+#                         calculated_value = index_value.getInfo()
+                        
+#                         if isinstance(calculated_value, (int, float)):
+#                             aggregated_results.append({
+#                                 'Location Name': location_name,
+#                                 period_label: date,
+#                                 'Start Date': start_date_str,
+#                                 'End Date': end_date_str,
+#                                 'Calculated Value': calculated_value
+#                             })
+#                         else:
+#                             st.warning(f"Skipping invalid value for {location_name} on {date}")
+#                     except Exception as e:
+#                         st.error(f"Error retrieving value for {location_name}: {e}")
+                
+#                 progress_percentage = (idx + 1) / total_steps
+#                 progress_bar.progress(progress_percentage)
+#                 progress_text.markdown(f"Processing: {int(progress_percentage * 100)}%")
+    
+#     if aggregated_results:
+#         result_df = pd.DataFrame(aggregated_results)
+#         if aggregation_period.lower() == 'custom (start date to end date)':
+#             agg_dict = {
+#                 'Start Date': 'first',
+#                 'End Date': 'first',
+#                 'Calculated Value': 'mean'
+#             }
+#             if shape_type.lower() == 'point':
+#                 agg_dict['Latitude'] = 'first'
+#                 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')
+#         else:
+#             return result_df.to_dict(orient='records')
+#     return []
+
+# # Button to trigger calculation
+# if st.button(f"Calculate {custom_formula}"):
+#     if file_upload is not None:
+#         if shape_type.lower() in ["point", "polygon"]:
+#             results = process_aggregation(
+#                 locations_df,
+#                 start_date_str,
+#                 end_date_str,
+#                 dataset_id,
+#                 selected_bands,
+#                 reducer_choice,
+#                 shape_type,
+#                 aggregation_period,
+#                 custom_formula,
+#                 kernel_size=kernel_size,
+#                 include_boundary=include_boundary
+#             )
+#             if results:
+#                 result_df = pd.DataFrame(results)
+#                 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"
+#                 st.download_button(
+#                     label="Download results as CSV",
+#                     data=result_df.to_csv(index=False).encode('utf-8'),
+#                     file_name=filename,
+#                     mime='text/csv'
+#                 )
+#                 # 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. Check your inputs or formula.")
+#         else:
+#             st.warning("Please upload a file to process.")
+#     else:
+#         st.warning("Please upload a file to proceed.")
+
+
+
 import streamlit as st
 import json
 import ee
@@ -8,8 +788,10 @@ from datetime import datetime
 import leafmap.foliumap as leafmap
 import re
 from shapely.geometry import base
-from lxml import etree
-from xml.etree import ElementTree as ET
+# from lxml import etree
+# from xml.etree import ElementTree as ET
+from xml.etree import ElementTree as XET  
+
 
 # Set up the page layout
 st.set_page_config(layout="wide")
@@ -40,12 +822,56 @@ st.write(
 # Title
 st.markdown(
     f"""
-    <h1 style="text-align: center;">Precision Analysis for Vegetation, Water, and Air Quality</h1>
+    <div style="display: flex; flex-direction: column; align-items: center;">
+        <img src="https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/SATRANG.png" style="width: 30%;">
+        <h3 style="text-align: center; margin: 0;">( Spatial and Temporal Aggregation for Remote-sensing and Analysis of Natural Geodata )</h3>
+    </div>
+    <hr>
     """,
     unsafe_allow_html=True,
 )
-st.write("<h2><div style='text-align: center;'>User Inputs</div></h2>", unsafe_allow_html=True)
+# st.markdown(
+#     f"""
+#     <div style="text-align: center; background-image: url('https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/B1.jpg'); background-size: cover; padding: 20px;">
+#         <h1 style="display: inline-block; margin: 0;">
+#             <img src="https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/B1.png" style="width: 20%; vertical-align: middle; margin-right: 10px;">
+#             BHOOMI
+#         </h1>
+#         <h3 style="margin: 0;">(Bandwise Harmonization & Optimized Output for multispectral integration)</h3>
+#     </div>
+#     <hr>
+#     """,
+#     unsafe_allow_html=True,
+# )
+# st.write("<h4><div style='text-align: center;'>User Inputs</div></h4>", unsafe_allow_html=True)
+
+# st.markdown(
+#     f"""
+#     <div style="position: relative; text-align: center; padding: 20px;">
+#         <div style="background-image: url('https://huggingface.co/spaces/YashMK89/GEE_Calculator/resolve/main/B1.jpg'); background-size: cover; position: absolute; top: 0; left: 0; right: 0; bottom: 0; z-index: 1;"></div>
+#         <div style="background-color: rgba(255, 255, 255, 0.2); position: absolute; top: 0; left: 0; right: 0; bottom: 0; z-index: 2;"></div>
+#         <div style="position: relative; z-index: 3;">
+#             <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;">
+#             </div>
+#             <h1 style="display: inline-block; margin: 0;">
+#                 BHOOMI
+#             </h1>
+#             <h3 style="margin: 0;">(Bandwise Harmonization & Optimized Output for multispectral integration)</h3>
+#         </div>
+#     </div>
+#     <hr>
+#     """,
+#     unsafe_allow_html=True,
+# )
 
+st.markdown(
+    f"""
+    <h4 style="text-align: center;">User Inputs</h4>
+    """,
+    unsafe_allow_html=True,
+)
 # Authenticate and initialize Earth Engine
 earthengine_credentials = os.environ.get("EE_Authentication")
 
@@ -56,6 +882,8 @@ with open(os.path.expanduser("~/.config/earthengine/credentials"), "w") as f:
 
 ee.Initialize(project='ee-yashsacisro24')
 
+st.write("<h5>Image Collection</h5>", unsafe_allow_html=True)
+
 # Imagery base selection
 imagery_base = st.selectbox("Select Imagery Base", ["Sentinel", "Landsat", "MODIS", "Custom Input"], index=0)
 
@@ -97,8 +925,14 @@ elif imagery_base == "Custom Input":
         data = {}
 
 # Display the title for the Streamlit app
-st.title(f"{imagery_base} Dataset")
-
+# st.title(f"{imagery_base} Dataset")
+st.markdown(
+    f"""
+    <hr>
+    <h5><b>{imagery_base} Dataset</b></h5>
+    """,
+    unsafe_allow_html=True,
+)
 # Select dataset category (main selection)
 if data:
     main_selection = st.selectbox(f"Select {imagery_base} Dataset Category", list(data.keys()))
@@ -114,46 +948,22 @@ 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 and its availability based on user input
+    # 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  # Use the key directly as the dataset ID
 
-        # Fetch and display dataset availability in green text
-        try:
-            # Create an Earth Engine ImageCollection object for the selected dataset
-            collection = ee.ImageCollection(dataset_id)
-            
-            # Get the date range of the collection
-            range_info = collection.reduceColumns(
-                reducer=ee.Reducer.minMax(),
-                selectors=['system:time_start']
-            ).getInfo()
-            
-            # Extract min and max timestamps (in milliseconds) and convert to readable dates
-            min_time = range_info.get('min', None)
-            max_time = range_info.get('max', None)
-            
-            if min_time and max_time:
-                start_date = datetime.fromtimestamp(min_time / 1000).strftime('%Y-%m-%d')
-                end_date = datetime.fromtimestamp(max_time / 1000).strftime('%Y-%m-%d')
-                st.markdown(
-                    f"<strong>Dataset Availability:</strong> From <span style='color: #fc0101;'>{start_date}</span> to <span style='color: #fc0101;'>{end_date}</span>",
-                    unsafe_allow_html=True
-                )
-            else:
-                st.markdown(
-                    f"<span style='color: #fc0101;'><strong>Dataset Availability:</strong> Date range not available.</span>",
-                    unsafe_allow_html=True
-                )
-                
-        except Exception as e:
-            st.error(f"Error fetching dataset availability: {str(e)}")
-
 # Earth Engine Index Calculator Section
-st.header("Earth Engine Index Calculator")
+# st.header("Earth Engine Index Calculator")
 
+st.markdown(
+    f"""
+    <hr>
+    <h5><b>Earth Engine Index Calculator</b></h5>
+    """,
+    unsafe_allow_html=True,
+)
 # Load band information based on selected dataset
 if main_selection and sub_selection:
     dataset_bands = data[main_selection]["bands"].get(sub_selection, [])
@@ -209,6 +1019,8 @@ if main_selection and sub_selection:
 
         # 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):
@@ -229,43 +1041,85 @@ reducer_choice = st.selectbox(
     index=0  # Default to 'mean'
 )
 
+# # Function to convert geometry to Earth Engine format
+# def convert_to_ee_geometry(geometry):
+#     if isinstance(geometry, base.BaseGeometry):
+#         if geometry.is_valid:
+#             geojson = geometry.__geo_interface__
+#             return ee.Geometry(geojson)
+#         else:
+#             raise ValueError("Invalid geometry: The polygon geometry is not valid.")
+#     elif isinstance(geometry, dict) or isinstance(geometry, str):
+#         try:
+#             if isinstance(geometry, str):
+#                 geometry = json.loads(geometry)
+#             if 'type' in geometry and 'coordinates' in geometry:
+#                 return ee.Geometry(geometry)
+#             else:
+#                 raise ValueError("GeoJSON format is invalid.")
+#         except Exception as e:
+#             raise ValueError(f"Error parsing GeoJSON: {e}")
+#     elif isinstance(geometry, str) and geometry.lower().endswith(".kml"):
+#         try:
+#             tree = ET.parse(geometry)
+#             kml_root = tree.getroot()
+#             kml_namespace = {'kml': 'http://www.opengis.net/kml/2.2'}
+#             coordinates = kml_root.findall(".//kml:coordinates", kml_namespace)
+#             if coordinates:
+#                 coords_text = coordinates[0].text.strip()
+#                 coords = coords_text.split()
+#                 coords = [tuple(map(float, coord.split(','))) for coord in coords]
+#                 geojson = {"type": "Polygon", "coordinates": [coords]}
+#                 return ee.Geometry(geojson)
+#             else:
+#                 raise ValueError("KML does not contain valid coordinates.")
+#         except Exception as e:
+#             raise ValueError(f"Error parsing KML: {e}")
+#     else:
+#         raise ValueError("Unsupported geometry input type. Supported types are Shapely, GeoJSON, and KML.")
+
 # Function to convert geometry to Earth Engine format
 def convert_to_ee_geometry(geometry):
+    st.write(f"Debug: convert_to_ee_geometry called with type - {type(geometry)}")  # Debug input type
     if isinstance(geometry, base.BaseGeometry):
         if geometry.is_valid:
             geojson = geometry.__geo_interface__
+            st.write(f"Debug: Converting Shapely geometry to GeoJSON - {geojson}")  # Debug GeoJSON
             return ee.Geometry(geojson)
         else:
             raise ValueError("Invalid geometry: The polygon geometry is not valid.")
-    elif isinstance(geometry, dict) or isinstance(geometry, str):
-        try:
-            if isinstance(geometry, str):
-                geometry = json.loads(geometry)
-            if 'type' in geometry and 'coordinates' in geometry:
-                return ee.Geometry(geometry)
-            else:
-                raise ValueError("GeoJSON format is invalid.")
-        except Exception as e:
-            raise ValueError(f"Error parsing GeoJSON: {e}")
-    elif isinstance(geometry, str) and geometry.lower().endswith(".kml"):
+    elif isinstance(geometry, dict):
+        if 'type' in geometry and 'coordinates' in geometry:
+            return ee.Geometry(geometry)
+        else:
+            raise ValueError("GeoJSON format is invalid.")
+    elif isinstance(geometry, str):
         try:
-            tree = ET.parse(geometry)
-            kml_root = tree.getroot()
-            kml_namespace = {'kml': 'http://www.opengis.net/kml/2.2'}
-            coordinates = kml_root.findall(".//kml:coordinates", kml_namespace)
-            if coordinates:
-                coords_text = coordinates[0].text.strip()
-                coords = coords_text.split()
-                coords = [tuple(map(float, coord.split(','))) for coord in coords]
-                geojson = {"type": "Polygon", "coordinates": [coords]}
-                return ee.Geometry(geojson)
+            # If it’s a JSON string, parse it
+            parsed = json.loads(geometry)
+            if 'type' in parsed and 'coordinates' in parsed:
+                return ee.Geometry(parsed)
             else:
-                raise ValueError("KML does not contain valid coordinates.")
-        except Exception as e:
-            raise ValueError(f"Error parsing KML: {e}")
+                raise ValueError("GeoJSON string format is invalid.")
+        except json.JSONDecodeError:
+            # If it’s a KML string (not a file path)
+            try:
+                root = XET.fromstring(geometry)
+                ns = {'kml': 'http://www.opengis.net/kml/2.2'}
+                coords_elem = root.find('.//kml:Polygon//kml:coordinates', ns)
+                if coords_elem is not None:
+                    coords_text = ' '.join(coords_elem.text.split())
+                    st.write(f"Debug: KML string coordinates - {coords_text}")  # Debug KML parsing
+                    coords = [tuple(map(float, coord.split(','))) for coord in coords_text.split()]
+                    geojson = {"type": "Polygon", "coordinates": [coords]}
+                    return ee.Geometry(geojson)
+                else:
+                    raise ValueError("KML string does not contain valid coordinates.")
+            except Exception as e:
+                raise ValueError(f"Error parsing KML string: {e}")
     else:
-        raise ValueError("Unsupported geometry input type. Supported types are Shapely, GeoJSON, and KML.")
-
+        raise ValueError(f"Unsupported geometry input type: {type(geometry)}. Supported types are Shapely, GeoJSON, and KML string.")
+        
 # Date Input for Start and End Dates
 start_date = st.date_input("Start Date", value=pd.to_datetime('2024-11-01'))
 end_date = st.date_input("End Date", value=pd.to_datetime('2024-12-01'))
@@ -301,6 +1155,85 @@ elif shape_type.lower() == "polygon":
         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"])
+
+# if file_upload is not None:
+#     # Read the user-uploaded file
+#     if shape_type.lower() == "point":
+#         if file_upload.name.endswith('.csv'):
+#             locations_df = pd.read_csv(file_upload)
+#         elif file_upload.name.endswith('.geojson'):
+#             locations_df = gpd.read_file(file_upload)
+#         elif file_upload.name.endswith('.kml'):
+#             locations_df = gpd.read_file(file_upload)
+#         else:
+#             st.error("Unsupported file format. Please upload CSV, GeoJSON, or KML.")
+#             locations_df = pd.DataFrame()
+
+#         if 'geometry' in locations_df.columns:
+#             if locations_df.geometry.geom_type.isin(['Polygon', 'MultiPolygon']).any():
+#                 st.warning("The uploaded file contains polygon data. Please select 'Polygon' for processing.")
+#                 st.stop()
+
+#         with st.spinner('Processing Map...'):
+#             if locations_df is not None and not locations_df.empty:
+#                 if 'geometry' in locations_df.columns:
+#                     locations_df['latitude'] = locations_df['geometry'].y
+#                     locations_df['longitude'] = locations_df['geometry'].x
+
+#                 if 'latitude' not in locations_df.columns or 'longitude' not in locations_df.columns:
+#                     st.error("Uploaded file is missing required 'latitude' or 'longitude' columns.")
+#                 else:
+#                     st.write("Preview of the uploaded points data:")
+#                     st.dataframe(locations_df.head())
+#                     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()
+#                     st.session_state.map_data = m
+
+#     elif shape_type.lower() == "polygon":
+#         if file_upload.name.endswith('.csv'):
+#             locations_df = pd.read_csv(file_upload)
+#         elif file_upload.name.endswith('.geojson'):
+#             locations_df = gpd.read_file(file_upload)
+#         elif file_upload.name.endswith('.kml'):
+#             locations_df = gpd.read_file(file_upload)
+#         else:
+#             st.error("Unsupported file format. Please upload CSV, GeoJSON, or KML.")
+#             locations_df = pd.DataFrame()
+
+#         if 'geometry' in locations_df.columns:
+#             if locations_df.geometry.geom_type.isin(['Point', 'MultiPoint']).any():
+#                 st.warning("The uploaded file contains point data. Please select 'Point' for processing.")
+#                 st.stop()
+
+#         with st.spinner('Processing Map...'):
+#             if locations_df is not None and not locations_df.empty:
+#                 if 'geometry' not in locations_df.columns:
+#                     st.error("Uploaded file is missing required 'geometry' column.")
+#                 else:
+#                     st.write("Preview of the uploaded polygons data:")
+#                     st.dataframe(locations_df.head())
+#                     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()
+#                     st.session_state.map_data = m
+
+
 # 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"])
 
@@ -312,7 +1245,31 @@ if file_upload is not None:
         elif file_upload.name.endswith('.geojson'):
             locations_df = gpd.read_file(file_upload)
         elif file_upload.name.endswith('.kml'):
-            locations_df = gpd.read_file(file_upload)
+            # Parse KML file for point data
+            kml_string = file_upload.read().decode('utf-8')
+            try:
+                # Use xml.etree.ElementTree with unique alias
+                root = XET.fromstring(kml_string)
+                ns = {'kml': 'http://www.opengis.net/kml/2.2'}
+                points = []
+                for placemark in root.findall('.//kml:Placemark', ns):
+                    name = placemark.findtext('kml:name', default=f"Point_{len(points)}", namespaces=ns)
+                    coords_elem = placemark.find('.//kml:Point/kml:coordinates', ns)
+                    if coords_elem is not None:
+                        coords_text = coords_elem.text.strip()
+                        st.write(f"Debug: Point coordinates found - {coords_text}")  # Debug output
+                        coords = [c.strip() for c in coords_text.split(',')]
+                        if len(coords) >= 2:  # Ensure at least lon, lat
+                            lon, lat = float(coords[0]), float(coords[1])
+                            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 = gpd.GeoDataFrame(points, geometry=gpd.GeoSeries.from_wkt([p['geometry'] for p in points]), crs="EPSG:4326")
+            except Exception as e:
+                st.error(f"Error parsing KML file: {str(e)}")
+                locations_df = pd.DataFrame()
         else:
             st.error("Unsupported file format. Please upload CSV, GeoJSON, or KML.")
             locations_df = pd.DataFrame()
@@ -350,7 +1307,30 @@ if file_upload is not None:
         elif file_upload.name.endswith('.geojson'):
             locations_df = gpd.read_file(file_upload)
         elif file_upload.name.endswith('.kml'):
-            locations_df = gpd.read_file(file_upload)
+            # Parse KML file for polygon data
+            kml_string = file_upload.read().decode('utf-8')
+            try:
+                root = XET.fromstring(kml_string)
+                ns = {'kml': 'http://www.opengis.net/kml/2.2'}
+                polygons = []
+                for placemark in root.findall('.//kml:Placemark', ns):
+                    name = placemark.findtext('kml:name', default=f"Polygon_{len(polygons)}", namespaces=ns)
+                    coords_elem = placemark.find('.//kml:Polygon//kml:coordinates', ns)
+                    if coords_elem is not None:
+                        coords_text = ' '.join(coords_elem.text.split())  # Normalize whitespace
+                        st.write(f"Debug: Polygon coordinates found - {coords_text}")  # Debug output
+                        coord_pairs = [pair.split(',')[:2] for pair in coords_text.split() if pair]
+                        if len(coord_pairs) >= 4:  # Minimum 4 points for a closed polygon
+                            coords_str = " ".join([f"{float(lon)} {float(lat)}" for lon, lat in coord_pairs])
+                            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()
         else:
             st.error("Unsupported file format. Please upload CSV, GeoJSON, or KML.")
             locations_df = pd.DataFrame()
@@ -379,6 +1359,7 @@ if file_upload is not None:
                     m.to_streamlit()
                     st.session_state.map_data = m
 
+# ... (Rest of the code until convert_to_ee_geometry) ...
 # Initialize session state for storing results
 if 'results' not in st.session_state:
     st.session_state.results = []