update app.py

app.py

@@ -493,6 +493,12 @@ if shape_type.lower() == "point":
         index=0,
         help="Choose 'Point' for exact point calculation, or a kernel size for area averaging."
     )
+    
+    # Initialize column names in session state
+    if 'lat_col' not in st.session_state:
+        st.session_state.lat_col = None
+    if 'lon_col' not in st.session_state:
+        st.session_state.lon_col = None
 elif shape_type.lower() == "polygon":
     include_boundary = st.checkbox(
         "Include Boundary Pixels",
@@ -503,102 +509,51 @@ elif shape_type.lower() == "polygon":
 file_upload = st.file_uploader(f"Upload your {shape_type} data (CSV, GeoJSON, KML)", type=["csv", "geojson", "kml"])
 locations_df = pd.DataFrame()
 
-# if file_upload is not None:
-#     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'):
-#             kml_string = file_upload.read().decode('utf-8')
-#             try:
-#                 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()
-#                         coords = [c.strip() for c in coords_text.split(',')]
-#                         if len(coords) >= 2:
-#                             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.")
-#                 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)}")
-#     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'):
-#             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())
-#                         coord_pairs = [pair.split(',')[:2] for pair in coords_text.split() if pair]
-#                         if len(coord_pairs) >= 4:
-#                             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.")
-#                 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)}")
-
-#     # Display uploaded data preview and map
-#     if not locations_df.empty:
-#         st.write("Preview of Uploaded Data:")
-#         st.dataframe(locations_df.head())
-
-#         if 'geometry' in locations_df.columns:
-#             if shape_type.lower() == "point":
-#                 locations_df['latitude'] = locations_df['geometry'].y
-#                 locations_df['longitude'] = locations_df['geometry'].x
-#                 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()
-#             elif shape_type.lower() == "polygon":
-#                 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()
-
 if file_upload is not None:
-    # Read the user-uploaded file
     if shape_type.lower() == "point":
         if file_upload.name.endswith('.csv'):
+            # Read the CSV file
             locations_df = pd.read_csv(file_upload)
+            
+            # Get numeric columns for coordinate selection
+            numeric_cols = locations_df.select_dtypes(include=['number']).columns.tolist()
+            
+            if numeric_cols:
+                # Let user select latitude and longitude columns
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.session_state.lat_col = st.selectbox(
+                        "Select Latitude Column",
+                        options=numeric_cols,
+                        index=numeric_cols.index(st.session_state.lat_col) if st.session_state.lat_col in numeric_cols else 0,
+                        key="lat_col_select"
+                    )
+                with col2:
+                    st.session_state.lon_col = st.selectbox(
+                        "Select Longitude Column",
+                        options=numeric_cols,
+                        index=numeric_cols.index(st.session_state.lon_col) if st.session_state.lon_col in numeric_cols else 0,
+                        key="lon_col_select"
+                    )
+                
+                # Update the dataframe with selected columns
+                if st.session_state.lat_col and st.session_state.lon_col:
+                    locations_df = locations_df.rename(columns={
+                        st.session_state.lat_col: 'latitude',
+                        st.session_state.lon_col: 'longitude'
+                    })
+            else:
+                st.error("No numeric columns found in the CSV file for coordinates.")
+                locations_df = pd.DataFrame()
+                
         elif file_upload.name.endswith('.geojson'):
             locations_df = gpd.read_file(file_upload)
+            if 'geometry' in locations_df.columns:
+                locations_df['latitude'] = locations_df['geometry'].y
+                locations_df['longitude'] = locations_df['geometry'].x
         elif file_upload.name.endswith('.kml'):
-            # 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 = []
@@ -607,57 +562,40 @@ if file_upload is not None:
                     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
+                        if len(coords) >= 2:
                             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()
-
-        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
-
+            except Exception as e:
+                st.error(f"Error parsing KML file: {str(e)}")
+        
+        # Display map for points
+        if not locations_df.empty and 'latitude' in locations_df.columns and 'longitude' in locations_df.columns:
+            st.write("Preview of 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()
+            
     elif shape_type.lower() == "polygon":
         if file_upload.name.endswith('.csv'):
-            locations_df = pd.read_csv(file_upload)
+            st.error("CSV upload not supported for polygons. Please upload a GeoJSON or KML file.")
         elif file_upload.name.endswith('.geojson'):
             locations_df = gpd.read_file(file_upload)
         elif file_upload.name.endswith('.kml'):
-            # Parse KML file for polygon data
             kml_string = file_upload.read().decode('utf-8')
             try:
                 root = XET.fromstring(kml_string)
@@ -667,89 +605,38 @@ if file_upload is not None:
                     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
+                        coords_text = ' '.join(coords_elem.text.split())
                         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
+                        if len(coord_pairs) >= 4:
                             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()
-
-        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
-
-# if st.button(f"Calculate {custom_formula}"):
-#     if not locations_df.empty:
-#         with st.spinner("Processing Data..."):
-#         results, processing_time = process_aggregation(  # Capture results and processing time
-#             locations_df,
-#             start_date_str,
-#             end_date_str,
-#             dataset_id,
-#             selected_bands,
-#             reducer_choice,
-#             shape_type,
-#             aggregation_period,
-#             custom_formula,
-#             kernel_size,
-#             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'
-#             )
-#             # Display processing time
-#             st.success(f"Processing complete! Total processing time: {processing_time:.2f} seconds.")
-#         else:
-#             st.warning("No results were generated. Check your inputs or formula.")
-#             st.info(f"Total processing time: {processing_time:.2f} seconds.")  # Show processing time even if no results
-#     else:
-#         st.warning("Please upload a file to proceed.")
+        
+        # Display map for polygons
+        if not locations_df.empty and 'geometry' in locations_df.columns:
+            st.write("Preview of 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()
 
 if st.button(f"Calculate {custom_formula}"):
     if not locations_df.empty:
-        # Use a spinner to indicate data processing
         with st.spinner("Processing Data..."):
             try:
-                # Call the aggregation function and capture results and processing time
                 results, processing_time = process_aggregation(
                     locations_df,
                     start_date_str,
@@ -764,13 +651,11 @@ if st.button(f"Calculate {custom_formula}"):
                     include_boundary
                 )
                 
-                # Check if results were generated
                 if results:
                     result_df = pd.DataFrame(results)
                     st.write(f"Processed Results Table ({aggregation_period}) for Formula: {custom_formula}")
                     st.dataframe(result_df)
                     
-                    # Generate a downloadable CSV file
                     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",
@@ -779,11 +664,10 @@ if st.button(f"Calculate {custom_formula}"):
                         mime='text/csv'
                     )
                     
-                    # Display processing time
                     st.success(f"Processing complete! Total processing time: {processing_time:.2f} seconds.")
                 else:
                     st.warning("No results were generated. Check your inputs or formula.")
-                    st.info(f"Total processing time: {processing_time:.2f} seconds.")  # Show processing time even if no results
+                    st.info(f"Total processing time: {processing_time:.2f} seconds.")
             
             except Exception as e:
                 st.error(f"An error occurred during processing: {str(e)}")