voxcity 0.3.13__py3-none-any.whl → 0.3.14__py3-none-any.whl

voxcity/downloader/eubucco.py

@@ -17,6 +17,7 @@ from shapely.ops import transform
 from fiona.transform import transform_geom
 import logging
 import shapely
+import geopandas as gpd
 
 from ..geoprocessor.utils import get_country_name
 
@@ -246,7 +247,7 @@ def download_extract_open_gpkg_from_eubucco(url, output_dir):
     logging.info(f"GeoPackage file found: {gpkg_file}")
     return gpkg_file
 
-def save_geojson_from_eubucco(rectangle_vertices, country_links, output_dir, file_name):
+def get_gdf_from_eubucco(rectangle_vertices, country_links, output_dir, file_name):
     """
     Downloads, extracts, filters, and converts GeoPackage data to GeoJSON based on the rectangle vertices.
 
@@ -270,28 +271,22 @@ def save_geojson_from_eubucco(rectangle_vertices, country_links, output_dir, fil
     # Download and extract GPKG file
     gpkg_file = download_extract_open_gpkg_from_eubucco(url, output_dir)
 
-    # Get first layer from GPKG file
-    with fiona.Env():
-        layers = fiona.listlayers(gpkg_file)
-        if not layers:
-            logging.error("No layers found in the GeoPackage.")
-            return
-        layer_name = layers[0]
-        logging.info(f"Using layer: {layer_name}")
-
-    file_path = f"{output_dir}/{file_name}"
-
-    # Convert GPKG to GeoJSON
-    filter_and_convert_gdf_to_geojson_eubucco(
-        gpkg_file=gpkg_file,
-        layer_name=layer_name,
-        rectangle_vertices=rectangle_vertices,
-        output_geojson=file_path
-    )
-
-    logging.info(f"GeoJSON file has been created at: {file_path}")
-
-def load_geojson_from_eubucco(rectangle_vertices, output_dir):
+    # Read GeoPackage file while preserving its CRS
+    gdf = gpd.read_file(gpkg_file)
+    
+    # Only set CRS if not already set
+    if gdf.crs is None:
+        gdf.set_crs(epsg=4326, inplace=True)
+    # Transform to WGS84 if needed
+    elif gdf.crs != "EPSG:4326":
+        gdf = gdf.to_crs(epsg=4326)
+
+    # Replace id column with index numbers
+    gdf['id'] = gdf.index
+    
+    return gdf
+
+def load_gdf_from_eubucco(rectangle_vertices, output_dir):
     """
     Downloads EUBUCCO data and loads it as GeoJSON.
 
@@ -307,15 +302,6 @@ def load_geojson_from_eubucco(rectangle_vertices, output_dir):
     file_path = f"{output_dir}/{file_name}"
 
     # Download and save GeoJSON
-    save_geojson_from_eubucco(rectangle_vertices, country_links, output_dir, file_name)   
-
-    # Load and return GeoJSON features
-    with open(file_path, 'r') as f:
-        raw_data = json.load(f)
-    geojson_data = raw_data['features']
-
-    # Add id to each building's properties
-    for i, feature in enumerate(geojson_data):
-        feature['properties']['id'] = i + 1
+    gdf = get_gdf_from_eubucco(rectangle_vertices, country_links, output_dir, file_name)   
 
-    return geojson_data
+    return gdf

voxcity/downloader/mbfp.py

@@ -10,7 +10,7 @@ import pandas as pd
 import os
 from .utils import download_file
 from ..geoprocessor.utils import tile_from_lat_lon, quadkey_to_tile
-from ..geoprocessor.polygon import load_geojsons_from_multiple_gz, swap_coordinates
+from ..geoprocessor.polygon import load_gdf_from_multiple_gz, swap_coordinates
 
 def get_geojson_links(output_dir):
     """Download and load the dataset links CSV file containing building footprint URLs.
@@ -68,7 +68,7 @@ def find_row_for_location(df, lon, lat):
             print(f"Error processing row {index}: {e}")
     return None
 
-def get_mbfp_geojson(output_dir, rectangle_vertices):
+def get_mbfp_gdf(output_dir, rectangle_vertices):
     """Download and process building footprint data for a rectangular region.
     
     Args:
@@ -98,7 +98,6 @@ def get_mbfp_geojson(output_dir, rectangle_vertices):
             print("No matching row found.")
 
     # Load GeoJSON data from downloaded files and fix coordinate ordering
-    geojson_data = load_geojsons_from_multiple_gz(filenames)
-    swap_coordinates(geojson_data)
+    gdf = load_gdf_from_multiple_gz(filenames)    
 
-    return geojson_data
+    return gdf

voxcity/downloader/omt.py

@@ -15,8 +15,8 @@ import shapely.ops
 import json
 from pyproj import Transformer
 import json
-
-def load_geojsons_from_openmaptiles(rectangle_vertices, API_KEY):
+import geopandas as gpd
+def load_gdf_from_openmaptiles(rectangle_vertices, API_KEY):
     """Download and process building footprint data from OpenMapTiles vector tiles.
 
     Args:
@@ -24,7 +24,7 @@ def load_geojsons_from_openmaptiles(rectangle_vertices, API_KEY):
         API_KEY: OpenMapTiles API key for authentication
 
     Returns:
-        list: List of GeoJSON features containing building footprints with standardized properties
+        geopandas.GeoDataFrame: GeoDataFrame containing building footprints with standardized properties
     """
     # Extract longitudes and latitudes from vertices to find bounding box
     lons = [coord[0] for coord in rectangle_vertices]
@@ -112,7 +112,14 @@ def load_geojsons_from_openmaptiles(rectangle_vertices, API_KEY):
 
     # Convert features to standardized format with height information
     converted_geojson_data = convert_geojson_format(building_features)
-    return converted_geojson_data
+
+    gdf = gpd.GeoDataFrame.from_features(converted_geojson_data)
+    gdf.set_crs(epsg=4326, inplace=True)
+    
+    # Replace id column with index numbers
+    gdf['id'] = gdf.index
+    
+    return gdf
 
 def get_height_from_properties(properties):
     """Extract building height from properties, using levels if height is not available.

voxcity/downloader/osm.py

@@ -6,9 +6,6 @@ and other geographic features from OpenStreetMap. It handles downloading data vi
 processing the responses, and converting them to standardized GeoJSON format with proper properties.
 """
 
-import requests
-from shapely.geometry import Polygon
-# Import libraries
 import requests
 from osm2geojson import json2geojson
 from shapely.geometry import Polygon, shape, mapping
@@ -21,15 +18,17 @@ from shapely.geometry import shape, mapping, Polygon
 from shapely.ops import transform
 import pyproj
 from osm2geojson import json2geojson
+import pandas as pd
+import geopandas as gpd
 
-def load_geojsons_from_openstreetmap(rectangle_vertices):
+def load_gdf_from_openstreetmap(rectangle_vertices):
     """Download and process building footprint data from OpenStreetMap.
     
     Args:
         rectangle_vertices: List of (lon, lat) coordinates defining the bounding box
         
     Returns:
-        list: List of GeoJSON features containing building footprints with standardized properties
+        geopandas.GeoDataFrame: GeoDataFrame containing building footprints with standardized properties
     """
     # Create a bounding box from the rectangle vertices
     min_lon = min(v[0] for v in rectangle_vertices)
@@ -61,7 +60,7 @@ def load_geojsons_from_openstreetmap(rectangle_vertices):
     for element in data['elements']:
         id_map[(element['type'], element['id'])] = element
     
-    # Process the response and create GeoJSON features
+    # Process the response and create features list
     features = []
     
     def process_coordinates(geometry):
@@ -210,8 +209,20 @@ def load_geojsons_from_openstreetmap(rectangle_vertices):
                         if feature:
                             feature['properties']['role'] = member['role']
                             features.append(feature)
+    
+    # Convert features list to GeoDataFrame
+    if not features:
+        return gpd.GeoDataFrame()
+        
+    geometries = []
+    properties_list = []
+    
+    for feature in features:
+        geometries.append(shape(feature['geometry']))
+        properties_list.append(feature['properties'])
         
-    return features
+    gdf = gpd.GeoDataFrame(properties_list, geometry=geometries, crs="EPSG:4326")
+    return gdf
 
 def convert_feature(feature):
     """Convert a GeoJSON feature to the desired format with height information.
@@ -466,14 +477,14 @@ def swap_coordinates(geom_mapping):
     geom_mapping['coordinates'] = swap_coords(coords)
     return geom_mapping
 
-def load_land_cover_geojson_from_osm(rectangle_vertices_ori):
+def load_land_cover_gdf_from_osm(rectangle_vertices_ori):
     """Load land cover data from OpenStreetMap within a given rectangular area.
     
     Args:
         rectangle_vertices_ori (list): List of (lon, lat) coordinates defining the rectangle
         
     Returns:
-        list: List of GeoJSON features with land cover classifications
+        GeoDataFrame: GeoDataFrame containing land cover classifications
     """
     # Close the rectangle polygon by adding first vertex at the end
     rectangle_vertices = rectangle_vertices_ori.copy()
@@ -558,8 +569,9 @@ def load_land_cover_geojson_from_osm(rectangle_vertices_ori):
     project = pyproj.Transformer.from_crs(wgs84, aea, always_xy=True).transform
     project_back = pyproj.Transformer.from_crs(aea, wgs84, always_xy=True).transform
 
-    # Process and filter features
-    filtered_features = []
+    # Lists to store geometries and properties for GeoDataFrame
+    geometries = []
+    properties = []
 
     for feature in geojson_data['features']:
         # Convert feature geometry to shapely object
@@ -621,31 +633,15 @@ def load_land_cover_geojson_from_osm(rectangle_vertices_ori):
         if geom.is_empty:
             continue
 
-        # Convert geometry to GeoJSON feature
+        # Add geometries and properties
         if geom.geom_type == 'Polygon':
-            # Create single polygon feature
-            geom_mapping = mapping(geom)
-            geom_mapping = swap_coordinates(geom_mapping)
-            new_feature = {
-                'type': 'Feature',
-                'properties': {
-                    'class': classification_name
-                },
-                'geometry': geom_mapping
-            }
-            filtered_features.append(new_feature)
+            geometries.append(geom)
+            properties.append({'class': classification_name})
         elif geom.geom_type == 'MultiPolygon':
-            # Split into separate polygon features
             for poly in geom.geoms:
-                geom_mapping = mapping(poly)
-                geom_mapping = swap_coordinates(geom_mapping)
-                new_feature = {
-                    'type': 'Feature',
-                    'properties': {
-                        'class': classification_name
-                    },
-                    'geometry': geom_mapping
-                }
-                filtered_features.append(new_feature)
+                geometries.append(poly)
+                properties.append({'class': classification_name})
 
-    return filtered_features
+    # Create GeoDataFrame
+    gdf = gpd.GeoDataFrame(properties, geometry=geometries, crs="EPSG:4326")
+    return gdf

voxcity/downloader/overture.py

@@ -179,7 +179,7 @@ def join_gdfs_vertically(gdf1, gdf2):
     
     return combined_gdf
 
-def load_geojsons_from_overture(rectangle_vertices):
+def load_gdf_from_overture(rectangle_vertices):
     """
     Download and process building footprint data from Overture Maps.
     
@@ -199,7 +199,10 @@ def load_geojsons_from_overture(rectangle_vertices):
     # Combine building and building part data into single dataset
     joined_building_gdf = join_gdfs_vertically(building_gdf, building_part_gdf)
 
-    # Convert combined dataset to GeoJSON format
-    geojson_features = convert_gdf_to_geojson(joined_building_gdf)
+    # # Convert combined dataset to GeoJSON format
+    # geojson_features = convert_gdf_to_geojson(joined_building_gdf)
 
-    return geojson_features
+    # Replace id column with index numbers
+    joined_building_gdf['id'] = joined_building_gdf.index
+
+    return joined_building_gdf

voxcity/generator.py

@@ -18,12 +18,12 @@ import numpy as np
 import os
 
 # Local application/library specific imports
-from .downloader.mbfp import get_mbfp_geojson
-from .downloader.osm import load_geojsons_from_openstreetmap, load_land_cover_geojson_from_osm
+from .downloader.mbfp import get_mbfp_gdf
+from .downloader.osm import load_gdf_from_openstreetmap, load_land_cover_gdf_from_osm
 from .downloader.oemj import save_oemj_as_geotiff
-from .downloader.omt import load_geojsons_from_openmaptiles
-from .downloader.eubucco import load_geojson_from_eubucco
-from .downloader.overture import load_geojsons_from_overture
+from .downloader.omt import load_gdf_from_openmaptiles
+from .downloader.eubucco import load_gdf_from_eubucco
+from .downloader.overture import load_gdf_from_overture
 from .downloader.gee import (
     initialize_earth_engine,
     get_roi,
@@ -41,13 +41,13 @@ from .geoprocessor.grid import (
     process_grid,
     create_land_cover_grid_from_geotiff_polygon,
     create_height_grid_from_geotiff_polygon,
-    create_building_height_grid_from_geojson_polygon,
+    create_building_height_grid_from_gdf_polygon,
     create_dem_grid_from_geotiff_polygon,
-    create_land_cover_grid_from_geojson_polygon,
+    create_land_cover_grid_from_gdf_polygon,
     create_building_height_grid_from_open_building_temporal_polygon
 )
 from .utils.lc import convert_land_cover, convert_land_cover_array
-from .geoprocessor.polygon import get_geojson_from_gpkg, save_geojson
+from .geoprocessor.polygon import get_gdf_from_gpkg, save_geojson
 from .utils.visualization import (
     get_land_cover_classes,
     visualize_land_cover_grid,
@@ -108,14 +108,14 @@ def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, **kwar
         save_oemj_as_geotiff(rectangle_vertices, geotiff_path)   
     elif source == 'OpenStreetMap':
         # For OSM, we get data directly as GeoJSON instead of GeoTIFF
-        land_cover_geojson = load_land_cover_geojson_from_osm(rectangle_vertices)
+        land_cover_gdf = load_land_cover_gdf_from_osm(rectangle_vertices)
     
     # Get mapping of land cover classes for the selected source
     land_cover_classes = get_land_cover_classes(source)
 
     # Create grid from either GeoJSON (OSM) or GeoTIFF (other sources)
     if source == 'OpenStreetMap':
-        land_cover_grid_str = create_land_cover_grid_from_geojson_polygon(land_cover_geojson, meshsize, source, rectangle_vertices)
+        land_cover_grid_str = create_land_cover_grid_from_gdf_polygon(land_cover_gdf, meshsize, source, rectangle_vertices)
     else:
         land_cover_grid_str = create_land_cover_grid_from_geotiff_polygon(geotiff_path, meshsize, land_cover_classes, rectangle_vertices)
 
@@ -165,23 +165,23 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, *
     
     # Get building data from primary source
     if source == 'Microsoft Building Footprints':
-        geojson_data = get_mbfp_geojson(output_dir, rectangle_vertices)
+        gdf = get_mbfp_gdf(output_dir, rectangle_vertices)
     elif source == 'OpenStreetMap':
-        geojson_data = load_geojsons_from_openstreetmap(rectangle_vertices)
+        gdf = load_gdf_from_openstreetmap(rectangle_vertices)
     elif source == "Open Building 2.5D Temporal":
         # Special case: directly creates grids without intermediate GeoJSON
         building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_open_building_temporal_polygon(meshsize, rectangle_vertices, output_dir)
     elif source == 'EUBUCCO v0.1':
-        geojson_data = load_geojson_from_eubucco(rectangle_vertices, output_dir)
+        gdf = load_gdf_from_eubucco(rectangle_vertices, output_dir)
     elif source == "OpenMapTiles":
-        geojson_data = load_geojsons_from_openmaptiles(rectangle_vertices, kwargs["maptiler_API_key"])
+        gdf = load_gdf_from_openmaptiles(rectangle_vertices, kwargs["maptiler_API_key"])
     elif source == "Overture":
-        geojson_data = load_geojsons_from_overture(rectangle_vertices)
+        gdf = load_gdf_from_overture(rectangle_vertices)
     elif source == "Local file":
         # Handle local GPKG files
         _, extension = os.path.splitext(kwargs["building_path"])
         if extension == ".gpkg":
-            geojson_data = get_geojson_from_gpkg(kwargs["building_path"], rectangle_vertices)
+            gdf = get_gdf_from_gpkg(kwargs["building_path"], rectangle_vertices)
     
     # Check for complementary building data source
     building_complementary_source = kwargs.get("building_complementary_source") 
@@ -189,7 +189,7 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, *
     if (building_complementary_source is None) or (building_complementary_source=='None'):
         # Use only primary source
         if source != "Open Building 2.5D Temporal":
-            building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_geojson_polygon(geojson_data, meshsize, rectangle_vertices)
+            building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(gdf, meshsize, rectangle_vertices)
     else:
         # Handle complementary source
         if building_complementary_source == "Open Building 2.5D Temporal":
@@ -198,29 +198,29 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, *
             os.makedirs(output_dir, exist_ok=True)
             geotiff_path_comp = os.path.join(output_dir, "building_height.tif")
             save_geotiff_open_buildings_temporal(roi, geotiff_path_comp)
-            building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_geojson_polygon(geojson_data, meshsize, rectangle_vertices, geotiff_path_comp=geotiff_path_comp)   
+            building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(gdf, meshsize, rectangle_vertices, geotiff_path_comp=geotiff_path_comp)   
         else:
             # Get complementary data from other sources
             if building_complementary_source == 'Microsoft Building Footprints':
-                geojson_data_comp = get_mbfp_geojson(output_dir, rectangle_vertices)
+                gdf_comp = get_mbfp_gdf(output_dir, rectangle_vertices)
             elif building_complementary_source == 'OpenStreetMap':
-                geojson_data_comp = load_geojsons_from_openstreetmap(rectangle_vertices)
+                gdf_comp = load_gdf_from_openstreetmap(rectangle_vertices)
             elif building_complementary_source == 'OSM Buildings':
-                geojson_data_comp = load_geojsons_from_osmbuildings(rectangle_vertices)
+                gdf_comp = load_gdf_from_osmbuildings(rectangle_vertices)
             elif building_complementary_source == 'EUBUCCO v0.1':
-                geojson_data_comp = load_geojson_from_eubucco(rectangle_vertices, output_dir)
+                gdf_comp = load_gdf_from_eubucco(rectangle_vertices, output_dir)
             elif building_complementary_source == "OpenMapTiles":
-                geojson_data_comp = load_geojsons_from_openmaptiles(rectangle_vertices, kwargs["maptiler_API_key"])
+                gdf_comp = load_gdf_from_openmaptiles(rectangle_vertices, kwargs["maptiler_API_key"])
             elif building_complementary_source == "Overture":
-                geojson_data_comp = load_geojsons_from_overture(rectangle_vertices)
+                gdf_comp = load_gdf_from_overture(rectangle_vertices)
             elif building_complementary_source == "Local file":
                 _, extension = os.path.splitext(kwargs["building_complementary_path"])
                 if extension == ".gpkg":
-                    geojson_data_comp = get_geojson_from_gpkg(kwargs["building_complementary_path"], rectangle_vertices)
+                    gdf_comp = get_gdf_from_gpkg(kwargs["building_complementary_path"], rectangle_vertices)
             
             # Option to complement footprints only or both footprints and heights
             complement_building_footprints = kwargs.get("complement_building_footprints")
-            building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_geojson_polygon(geojson_data, meshsize, rectangle_vertices, geojson_data_comp=geojson_data_comp, complement_building_footprints=complement_building_footprints)
+            building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(gdf, meshsize, rectangle_vertices, gdf_comp=gdf_comp, complement_building_footprints=complement_building_footprints)
 
     # Visualize grid if requested
     grid_vis = kwargs.get("gridvis", True)    
@@ -552,11 +552,12 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
 
     # Generate all required 2D grids
     land_cover_grid = get_land_cover_grid(rectangle_vertices, meshsize, land_cover_source, output_dir, **kwargs)
-    building_height_grid, building_min_height_grid, building_id_grid, building_geojson = get_building_height_grid(rectangle_vertices, meshsize, building_source, output_dir, **kwargs)
+    building_height_grid, building_min_height_grid, building_id_grid, building_gdf = get_building_height_grid(rectangle_vertices, meshsize, building_source, output_dir, **kwargs)
     
     # Save building data to GeoJSON
-    save_path = f"{output_dir}/building.geojson"
-    save_geojson(building_geojson, save_path)
+    if not building_gdf.empty:
+        save_path = f"{output_dir}/building.gpkg"
+        building_gdf.to_file(save_path, driver='GPKG')
     
     # Get canopy height data
     canopy_height_grid = get_canopy_height_grid(rectangle_vertices, meshsize, canopy_height_source, output_dir, **kwargs)
@@ -662,7 +663,7 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
         voxcity_grid_vis[-1, -1, -1] = -99  # Add marker to fix camera location and angle of view
         visualize_3d_voxel(voxcity_grid_vis, voxel_size=meshsize, save_path=kwargs["voxelvis_img_save_path"])
 
-    return voxcity_grid, building_height_grid, building_min_height_grid, building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, building_geojson
+    return voxcity_grid, building_height_grid, building_min_height_grid, building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, building_gdf
 
 def replace_nan_in_nested(arr, replace_value=10.0):
     """Replace NaN values in a nested array structure with a specified value.

voxcity/geoprocessor/draw.py

@@ -223,15 +223,15 @@ def center_location_map_cityname(cityname, east_west_length, north_south_length,
 
     return m, rectangle_vertices
 
-def display_buildings_and_draw_polygon(building_geojson, zoom=17):
+def display_buildings_and_draw_polygon(building_gdf, zoom=17):
     """
     Displays building footprints (in Lon-Lat order) on an ipyleaflet map,
     and allows the user to draw a polygon whose vertices are returned
     in a Python list (also in Lon-Lat).
 
     Args:
-        building_geojson (list): A list of GeoJSON features (Polygons),
-                                 with coordinates in [lon, lat] order.
+        building_gdf (GeoDataFrame): A GeoDataFrame containing building footprints,
+                                   with geometry in [lon, lat] order.
         zoom (int): Initial zoom level for the map. Default=17.
 
     Returns:
@@ -243,22 +243,13 @@ def display_buildings_and_draw_polygon(building_geojson, zoom=17):
     # ---------------------------------------------------------
     # 1. Determine a suitable map center via bounding box logic
     # ---------------------------------------------------------
-    all_lons = []
-    all_lats = []
-    for feature in building_geojson:
-        # Handle only Polygons here; skip MultiPolygon if present
-        if feature['geometry']['type'] == 'Polygon':
-            # Coordinates in this data are [ [lon, lat], [lon, lat], ... ]
-            coords = feature['geometry']['coordinates'][0]  # outer ring
-            all_lons.extend(pt[0] for pt in coords)
-            all_lats.extend(pt[1] for pt in coords)
-
-    if not all_lats or not all_lons:
+    if len(building_gdf) == 0:
         # Fallback: If no footprints or invalid data, pick a default
         center_lon, center_lat = -100.0, 40.0
     else:
-        min_lon, max_lon = min(all_lons), max(all_lons)
-        min_lat, max_lat = min(all_lats), max(all_lats)
+        # Get bounds from GeoDataFrame
+        bounds = building_gdf.total_bounds  # Returns [minx, miny, maxx, maxy]
+        min_lon, min_lat, max_lon, max_lat = bounds
         center_lon = (min_lon + max_lon) / 2
         center_lat = (min_lat + max_lat) / 2
 
@@ -268,12 +259,13 @@ def display_buildings_and_draw_polygon(building_geojson, zoom=17):
     # -----------------------------------------
     # 2. Add each building footprint to the map
     # -----------------------------------------
-    for feature in building_geojson:
+    for idx, row in building_gdf.iterrows():
         # Only handle simple Polygons
-        if feature['geometry']['type'] == 'Polygon':
-            coords = feature['geometry']['coordinates'][0]
-            # Convert to (lat,lon) for ipyleaflet
-            lat_lon_coords = [(c[1], c[0]) for c in coords]
+        if isinstance(row.geometry, geom.Polygon):
+            # Get coordinates from geometry
+            coords = list(row.geometry.exterior.coords)
+            # Convert to (lat,lon) for ipyleaflet, skip last repeated coordinate
+            lat_lon_coords = [(c[1], c[0]) for c in coords[:-1]]
 
             # Create the polygon layer
             bldg_layer = LeafletPolygon(