import streamlit as st from streamlit_folium import st_folium import folium from folium.plugins import Draw import pandas as pd import geopandas as gpd from shapely.geometry import Polygon, Point import numpy as np import re # For parsing STATEDAREA st.set_page_config(layout="wide", page_title="Multiplex Coop Housing Filter") st.title("🗺️ Multiplex Coop Housing Filter (Hugging Face Data)") st.write("This app uses the `ProjectMultiplexCoop/PropertyBoundaries` dataset from Hugging Face. Draw a polygon on the map to spatially filter properties. Use the form below to apply additional filters based on property attributes. **Note: FSI, Building Coverage, Height, and Stories are synthetic for demonstration as they are not directly available in the dataset.**") # --- Configuration Constants --- MAX_ROWS_DATAFRAME_DISPLAY = 1000 # Max rows to show in st.dataframe MAX_MAP_FEATURES_DISPLAY = 5000 # Max features to plot on the Folium map to prevent MessageSizeError # --- 1. Load Data from Hugging Face and Process --- @st.cache_data def load_and_process_data(): """ Loads the geospatial data from Hugging Face, processes relevant columns, generates synthetic data for missing attributes, and re-projects for centroid calculation. """ try: gdf = gpd.read_parquet("hf://datasets/ProjectMultiplexCoop/PropertyBoundaries/Property_Boundaries_4326.parquet") except Exception as e: st.error(f"Failed to load data from Hugging Face. Please ensure `huggingface_hub`, `geopandas`, `fiona`, and `pyproj` are installed. Error: {e}") st.stop() # Process STATEDAREA to numeric (Lot Area in Sq Metres) def parse_stated_area(area_str): if pd.isna(area_str): return np.nan match = re.search(r'(\d+\.?\d*)\s*sq\.m', str(area_str)) if match: return float(match.group(1)) return np.nan gdf['zn_area'] = gdf['STATEDAREA'].apply(parse_stated_area) # Map FEATURE_TYPE to zn_type (Zoning Type) gdf['zn_type'] = gdf['FEATURE_TYPE'] # Generate synthetic data for attributes not present in the Hugging Face dataset num_rows = len(gdf) gdf['fsi_total'] = np.round(np.random.uniform(0.5, 3.0, num_rows), 2) gdf['prcnt_cver'] = np.random.randint(20, 70, num_rows) gdf['height_metres'] = np.round(np.random.uniform(5, 30, num_rows), 1) gdf['stories'] = np.random.randint(2, 10, num_rows) # Add unique ID and a display name gdf['id'] = range(1, num_rows + 1) gdf['name'] = gdf['PARCELID'].apply(lambda x: f"Parcel {x}") # Ensure geometries are valid for centroid calculation and plotting gdf['geometry'] = gdf['geometry'].buffer(0) # --- IMPORTANT: Re-project for accurate centroid calculation --- # Convert to a projected CRS (e.g., Web Mercator EPSG:3857) for accurate centroid calculation gdf_projected = gdf.to_crs(epsg=3857) # Calculate centroids on the projected CRS gdf['centroid_x_proj'] = gdf_projected.geometry.centroid.x gdf['centroid_y_proj'] = gdf_projected.geometry.centroid.y # Convert centroids back to geographic CRS (EPSG:4326) for Folium plotting centroids_gdf = gpd.GeoDataFrame( gdf.index, geometry=gpd.points_from_xy(gdf['centroid_x_proj'], gdf['centroid_y_proj'], crs="EPSG:3857") ).to_crs(epsg=4326) gdf['latitude'] = centroids_gdf.geometry.y gdf['longitude'] = centroids_gdf.geometry.x # Select and reorder relevant columns for display and filtering df_processed = gdf[[ 'id', 'name', 'latitude', 'longitude', 'geometry', 'zn_type', 'zn_area', 'fsi_total', 'prcnt_cver', 'height_metres', 'stories', 'PARCELID', # Original Parcel ID for reference 'ADDRESS_NUMBER', 'LINEAR_NAME_FULL' # For detailed address in tooltips ]].copy() return df_processed df = load_and_process_data() # Initialize filtered_df with the full dataframe for initial state # This will be updated based on spatial and attribute filters filtered_df = df.copy() # --- 2. Map for Drawing (now in an expander) --- with st.expander("Draw a Polygon on the Map", expanded=False): # Center the map around the mean of the actual data's centroids m = folium.Map(location=[df['latitude'].mean(), df['longitude'].mean()], zoom_start=12) # Add drawing tools to the map draw = Draw( export=True, filename="drawn_polygon.geojson", position="topleft", draw_options={ "polyline": False, "rectangle": False, "circlemarker": False, "circle": False, "marker": False, "polygon": { "allowIntersection": False, "drawError": {"color": "#e0115f", "message": "Oups!"}, "shapeOptions": {"color": "#ef233c", "fillOpacity": 0.5}, }, }, edit_options={"edit": False, "remove": True}, ) m.add_child(draw) st.info("Draw a polygon on the map to spatially filter properties. The filtered results will appear below.") output = st_folium(m, width=1000, height=600, returned_objects=["all_draw_features"]) polygon_drawn = False shapely_polygon = None polygon_coords = None if output and output["all_draw_features"]: polygons = [ feature["geometry"]["coordinates"] for feature in output["all_draw_features"] if feature["geometry"]["type"] == "Polygon" ] if polygons: polygon_coords = polygons[-1][0] # Get the coordinates of the last drawn polygon # Shapely Polygon expects (lon, lat) tuples, Folium provides (lat, lon) shapely_polygon = Polygon([(lon, lat) for lat, lon in polygon_coords]) polygon_drawn = True # Apply spatial filter to the full dataframe based on centroid containment filtered_df = df[ df.apply( lambda row: shapely_polygon.contains(Point(row['longitude'], row['latitude'])), axis=1 ) ].copy() st.success(f"Initially filtered {len(filtered_df)} properties within the drawn polygon.") else: st.info("No polygon drawn yet. Draw a polygon on the map to spatially filter properties.") else: st.info("No polygon drawn yet. Draw a polygon on the map to spatially filter properties.") # --- 3. Attribute Filtering Form --- st.subheader("Filter Property Attributes") with st.form("attribute_filters"): col1, col2 = st.columns(2) with col1: all_zoning_types = ['All Resdidential Zoning (0, 101, 6)'] + sorted(df['zn_type'].unique().tolist()) selected_zn_type = st.selectbox("Zoning Type", all_zoning_types, key="zn_type_select") min_zn_area = st.number_input( "Minimum Lot Area in Sq Metres", min_value=float(df['zn_area'].min() if pd.notna(df['zn_area'].min()) else 0), value=float(df['zn_area'].min() if pd.notna(df['zn_area'].min()) else 0), step=100.0, key="zn_area_input" ) min_fsi_total = st.number_input("Minimum Floor Space Index (FSI)", min_value=0.0, value=0.0, step=0.1, format="%.2f", key="fsi_total_input") with col2: max_prcnt_cver = st.number_input("Maximum Building Percent Coverage (%)", min_value=0, value=100, step=1, key="prcnt_cver_input") height_stories_option = st.radio( "Filter by", ("Height", "Stories"), index=0, key="height_stories_radio" ) if height_stories_option == "Height": min_height_value = st.number_input("Minimum Height in Metres", min_value=0.0, value=0.0, step=0.1, format="%.1f", key="height_input") else: min_stories_value = st.number_input("Minimum Stories", min_value=0, value=0, step=1, key="stories_input") submitted = st.form_submit_button("Apply Attribute Filters") if submitted: if selected_zn_type != 'All Resdidential Zoning (0, 101, 6)': filtered_df = filtered_df[filtered_df['zn_type'] == selected_zn_type] filtered_df = filtered_df[filtered_df['zn_area'].fillna(0) >= min_zn_area] if min_fsi_total > 0: filtered_df = filtered_df[filtered_df['fsi_total'] >= min_fsi_total] if max_prcnt_cver < 100: filtered_df = filtered_df[filtered_df['prcnt_cver'] <= max_prcnt_cver] if height_stories_option == "Height" and min_height_value > 0: filtered_df = filtered_df[filtered_df['height_metres'] >= min_height_value] elif height_stories_option == "Stories" and min_stories_value > 0: filtered_df = filtered_df[filtered_df['stories'] >= min_stories_value] st.success(f"Applied attribute filters. Total properties after all filters: {len(filtered_df)}") else: st.info("Adjust filters and click 'Apply Attribute Filters'.") # --- 4. Display Filtered Data on a New Map and as a Table --- with st.expander("Filtered Properties Display", expanded=True): if not filtered_df.empty: # Calculate bounds for filtered data to set appropriate zoom min_lat, max_lat = filtered_df['latitude'].min(), filtered_df['latitude'].max() min_lon, max_lon = filtered_df['longitude'].min(), filtered_df['longitude'].max() if min_lat == max_lat and min_lon == max_lon: # Single point case filtered_map_center = [min_lat, min_lon] filtered_map_zoom = 18 else: filtered_map_center = [filtered_df['latitude'].mean(), filtered_df['longitude'].mean()] lat_diff = max_lat - min_lat lon_diff = max_lon - min_lon # Heuristic for zoom level if max(lat_diff, lon_diff) < 0.001: filtered_map_zoom = 18 elif max(lat_diff, lon_diff) < 0.01: filtered_map_zoom = 16 elif max(lat_diff, lon_diff) < 0.1: filtered_map_zoom = 14 else: filtered_map_zoom = 12 filtered_m = folium.Map(location=filtered_map_center, zoom_start=filtered_map_zoom) # Add the drawn polygon to the new map if it exists if polygon_drawn and polygon_coords: folium.Polygon( locations=polygon_coords, color="#ef233c", fill=True, fill_color="#ef233c", fill_opacity=0.5 ).add_to(filtered_m) # Convert filtered_df to GeoDataFrame for plotting filtered_gdf = gpd.GeoDataFrame(filtered_df, geometry='geometry') # --- Apply map display limit --- features_to_plot_count = len(filtered_gdf) if features_to_plot_count > MAX_MAP_FEATURES_DISPLAY: st.warning(f"Displaying a random sample of {MAX_MAP_FEATURES_DISPLAY} properties on the map (out of {features_to_plot_count} total filtered) to prevent performance issues.") filtered_gdf_for_map = filtered_gdf.sample(MAX_MAP_FEATURES_DISPLAY, random_state=42) else: filtered_gdf_for_map = filtered_gdf # Add filtered polygons to the map as GeoJSON layer folium.GeoJson( filtered_gdf_for_map.to_json(), style_function=lambda x: { 'fillColor': 'green', 'color': 'darkgreen', 'weight': 1, 'fillOpacity': 0.7 }, tooltip=folium.GeoJsonTooltip( fields=['PARCELID', 'zn_type', 'zn_area', 'fsi_total', 'prcnt_cver', 'height_metres', 'stories', 'ADDRESS_NUMBER', 'LINEAR_NAME_FULL'], aliases=['Parcel ID:', 'Zoning Type:', 'Lot Area (m²):', 'FSI:', 'Coverage (%):', 'Height (m):', 'Stories:', 'Address Num:', 'Street:'], localize=True ) ).add_to(filtered_m) st_folium(filtered_m, width=1000, height=500) st.subheader("Filtered Properties Table") display_cols = ['PARCELID', 'zn_type', 'zn_area', 'fsi_total', 'prcnt_cver', 'height_metres', 'stories', 'ADDRESS_NUMBER', 'LINEAR_NAME_FULL'] if len(filtered_df) > MAX_ROWS_DATAFRAME_DISPLAY: st.warning(f"Displaying only the first {MAX_ROWS_DATAFRAME_DISPLAY} rows of the filtered data ({len(filtered_df)} total properties). Download the full dataset below.") st.dataframe(filtered_df[display_cols].head(MAX_ROWS_DATAFRAME_DISPLAY)) else: st.dataframe(filtered_df[display_cols]) # --- 5. Export Data Button --- csv = filtered_df.to_csv(index=False).encode('utf-8') st.download_button( label="Export Full Filtered Data to CSV", data=csv, file_name="multiplex_coop_filtered_properties.csv", mime="text/csv", ) else: st.warning("No properties match the current filters. Adjust your criteria or draw a polygon on the map.") # Add a note about the MessageSizeError and config option st.markdown("---") st.markdown( """ **Troubleshooting Large Data:** If you still encounter a `MessageSizeError` despite the display limits, it means the data size still exceeds Streamlit's internal limit, or the sampled data is still too complex. You can try decreasing `MAX_MAP_FEATURES_DISPLAY` and `MAX_ROWS_DATAFRAME_DISPLAY` further. Alternatively, you can increase Streamlit's default message size limit by adding `server.maxMessageSize = ` (e.g., `server.maxMessageSize = 500`) to your Streamlit `config.toml` file. However, be aware that increasing this limit can lead to longer loading times and higher memory consumption in your browser and on the Streamlit server. """ ) st.markdown("This app demonstrates spatial and attribute filtering on the ProjectMultiplexCoop/PropertyBoundaries dataset from Hugging Face. FSI, Building Coverage, Height, and Stories are synthetic for demonstration.")