voxcity 0.3.3__tar.gz → 0.3.5__tar.gz

{voxcity-0.3.3 → voxcity-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: voxcity
-Version: 0.3.3
+Version: 0.3.5
 Summary: voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data
 Author-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>
 Maintainer-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>
@@ -48,6 +48,7 @@ Requires-Dist: overturemaps
 Requires-Dist: protobuf==3.20.3
 Requires-Dist: timezonefinder
 Requires-Dist: astral
+Requires-Dist: osmnx
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
@@ -164,10 +165,10 @@ Define the target area by directly specifying the coordinates of the rectangle v
 
 ```python
 rectangle_vertices = [
-    (47.59830044521263, -122.33587348582083),  # Southwest corner (latitude, longitude)
-    (47.60279755390168, -122.33587348582083),  # Northwest corner (latitude, longitude)
-    (47.60279755390168, -122.32922451417917),  # Northeast corner (latitude, longitude)
-    (47.59830044521263, -122.32922451417917)   # Southeast corner (latitude, longitude)
+    (-122.33587348582083, 47.59830044521263),  # Southwest corner (longitude, latitude)
+    (-122.33587348582083, 47.60279755390168),  # Northwest corner (longitude, latitude) 
+    (-122.32922451417917, 47.60279755390168),  # Northeast corner (longitude, latitude)
+    (-122.32922451417917, 47.59830044521263)   # Southeast corner (longitude, latitude)
 ]
 ```
 

{voxcity-0.3.3 → voxcity-0.3.5}/README.md

@@ -108,10 +108,10 @@ Define the target area by directly specifying the coordinates of the rectangle v
 
 ```python
 rectangle_vertices = [
-    (47.59830044521263, -122.33587348582083),  # Southwest corner (latitude, longitude)
-    (47.60279755390168, -122.33587348582083),  # Northwest corner (latitude, longitude)
-    (47.60279755390168, -122.32922451417917),  # Northeast corner (latitude, longitude)
-    (47.59830044521263, -122.32922451417917)   # Southeast corner (latitude, longitude)
+    (-122.33587348582083, 47.59830044521263),  # Southwest corner (longitude, latitude)
+    (-122.33587348582083, 47.60279755390168),  # Northwest corner (longitude, latitude) 
+    (-122.32922451417917, 47.60279755390168),  # Northeast corner (longitude, latitude)
+    (-122.32922451417917, 47.59830044521263)   # Southeast corner (longitude, latitude)
 ]
 ```
 

{voxcity-0.3.3 → voxcity-0.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "voxcity"
-version = "0.3.3"
+version = "0.3.5"
 requires-python = ">=3.10,<3.13"
 classifiers = [
     "Programming Language :: Python :: 3.10",
@@ -50,6 +50,7 @@ dependencies = [
     "protobuf==3.20.3",
     "timezonefinder",
     "astral",
+    "osmnx",
 ]
 
 [project.optional-dependencies]

{voxcity-0.3.3 → voxcity-0.3.5}/src/voxcity/download/eubucco.py

@@ -68,16 +68,11 @@ def filter_and_convert_gdf_to_geojson_eubucco(gpkg_file, layer_name, rectangle_v
     Parameters:
     - gpkg_file (str): Path to the GeoPackage file.
     - layer_name (str): Name of the layer within the GeoPackage to process.
-    - rectangle_vertices (list of tuples): List of (latitude, longitude) tuples defining the rectangle.
+    - rectangle_vertices (list of tuples): List of (longitude, latitude) tuples defining the rectangle.
     - output_geojson (str): Path to the output GeoJSON file.
     """
-    # Convert rectangle vertices from (lat,lon) to (lon,lat) format and create polygon
-    rectangle_vertices_lonlat = [(lon, lat) for lat, lon in rectangle_vertices]
-    rectangle_polygon = Polygon(rectangle_vertices_lonlat)
-
-    # Helper function to swap coordinate order
-    def swap_coordinates_gdf(x, y, z=None):
-        return y, x
+    # Create polygon from rectangle vertices (already in lon,lat format)
+    rectangle_polygon = Polygon(rectangle_vertices)
 
     # Get Shapely version for compatibility checks
     shapely_version = shapely.__version__
@@ -165,13 +160,10 @@ def filter_and_convert_gdf_to_geojson_eubucco(gpkg_file, layer_name, rectangle_v
                         else:
                             shapely_transformed_poly = poly
 
-                        # Swap coordinates to (lat,lon) format
-                        swapped_poly = transform(swap_coordinates_gdf, shapely_transformed_poly)
-
-                        # Extract polygon coordinates
+                        # Extract polygon coordinates (already in lon,lat format)
                         coords = []
-                        coords.append(list(swapped_poly.exterior.coords))  # Exterior ring
-                        for interior in swapped_poly.interiors:  # Interior rings (holes)
+                        coords.append(list(shapely_transformed_poly.exterior.coords))  # Exterior ring
+                        for interior in shapely_transformed_poly.interiors:  # Interior rings (holes)
                             coords.append(list(interior.coords))
 
                         # Create GeoJSON geometry
@@ -259,7 +251,7 @@ def save_geojson_from_eubucco(rectangle_vertices, country_links, output_dir, fil
     Downloads, extracts, filters, and converts GeoPackage data to GeoJSON based on the rectangle vertices.
 
     Parameters:
-    - rectangle_vertices (list of tuples): List of (latitude, longitude) tuples defining the rectangle.
+    - rectangle_vertices (list of tuples): List of (longitude, latitude) tuples defining the rectangle.
     - country_links (dict): Dictionary mapping country names to their respective GeoPackage URLs.
     - output_dir (str): Directory to save output files
     - file_name (str): Name for output GeoJSON file
@@ -268,7 +260,7 @@ def save_geojson_from_eubucco(rectangle_vertices, country_links, output_dir, fil
     - None: Writes the output to a GeoJSON file.
     """
     # Determine country based on first vertex
-    country_name = get_country_name(rectangle_vertices[0][0], rectangle_vertices[0][1])
+    country_name = get_country_name(rectangle_vertices[0][0], rectangle_vertices[0][1])  # Swap order for get_country_name
     if country_name in country_links:
         url = country_links[country_name]
     else:
@@ -304,7 +296,7 @@ def load_geojson_from_eubucco(rectangle_vertices, output_dir):
     Downloads EUBUCCO data and loads it as GeoJSON.
 
     Parameters:
-    - rectangle_vertices (list of tuples): List of (latitude, longitude) tuples defining the area
+    - rectangle_vertices (list of tuples): List of (longitude, latitude) tuples defining the area
     - output_dir (str): Directory to save intermediate files
 
     Returns:

{voxcity-0.3.3 → voxcity-0.3.5}/src/voxcity/download/gee.py

@@ -11,7 +11,7 @@ import ee
 import geemap
 
 # Local imports
-from ..geo.utils import convert_format_lat_lon
+# from ..geo.utils import convert_format_lat_lon
 
 def initialize_earth_engine():
     """Initialize the Earth Engine API."""
@@ -21,12 +21,13 @@ def get_roi(input_coords):
     """Create an Earth Engine region of interest polygon from coordinates.
     
     Args:
-        input_coords: List of coordinate pairs defining the polygon vertices
+        input_coords: List of coordinate pairs defining the polygon vertices in (lon, lat) format
         
     Returns:
         ee.Geometry.Polygon: Earth Engine polygon geometry
     """
-    coords = convert_format_lat_lon(input_coords)
+    coords = input_coords.copy()
+    coords.append(input_coords[0])
     return ee.Geometry.Polygon(coords)
 
 def get_center_point(roi):

{voxcity-0.3.3 → voxcity-0.3.5}/src/voxcity/download/mbfp.py

@@ -40,13 +40,13 @@ def get_geojson_links(output_dir):
     df_links = pd.read_csv(filepath, dtype=data_types)
     return df_links
 
-def find_row_for_location(df, lat, lon):
-    """Find the dataset row containing building data for a given lat/lon coordinate.
+def find_row_for_location(df, lon, lat):
+    """Find the dataset row containing building data for a given lon/lat coordinate.
     
     Args:
         df: DataFrame containing dataset links
-        lat: Latitude coordinate to search for
         lon: Longitude coordinate to search for
+        lat: Latitude coordinate to search for
         
     Returns:
         pandas.Series: Matching row from DataFrame, or None if no match found
@@ -57,7 +57,7 @@ def find_row_for_location(df, lat, lon):
             continue
             
         try:
-            # Convert lat/lon to tile coordinates at the quadkey's zoom level
+            # Convert lon/lat to tile coordinates at the quadkey's zoom level
             loc_tile_x, loc_tile_y = tile_from_lat_lon(lat, lon, len(quadkey))
             qk_tile_x, qk_tile_y, _ = quadkey_to_tile(quadkey)
             
@@ -73,7 +73,7 @@ def get_mbfp_geojson(output_dir, rectangle_vertices):
     
     Args:
         output_dir: Directory to save downloaded files
-        rectangle_vertices: List of (lat, lon) tuples defining the rectangle corners
+        rectangle_vertices: List of (lon, lat) tuples defining the rectangle corners
         
     Returns:
         dict: GeoJSON data containing building footprints
@@ -84,8 +84,8 @@ def get_mbfp_geojson(output_dir, rectangle_vertices):
     # Find and download files for each vertex of the rectangle
     filenames = []
     for vertex in rectangle_vertices:
-        lat, lon = vertex
-        row = find_row_for_location(df_links, lat, lon)
+        lon, lat = vertex
+        row = find_row_for_location(df_links, lon, lat)
         if row is not None:
             # Construct filename and download if not already downloaded
             location = row["Location"]

{voxcity-0.3.3 → voxcity-0.3.5}/src/voxcity/download/oemj.py

@@ -15,12 +15,12 @@ import numpy as np
 from osgeo import gdal, osr
 import pyproj
 
-def deg2num(lat_deg, lon_deg, zoom):
-    """Convert latitude/longitude coordinates to tile coordinates.
+def deg2num(lon_deg, lat_deg, zoom):
+    """Convert longitude/latitude coordinates to tile coordinates.
     
     Args:
-        lat_deg (float): Latitude in degrees
         lon_deg (float): Longitude in degrees
+        lat_deg (float): Latitude in degrees
         zoom (int): Zoom level
         
     Returns:
@@ -33,7 +33,7 @@ def deg2num(lat_deg, lon_deg, zoom):
     return (xtile, ytile)
 
 def num2deg(xtile, ytile, zoom):
-    """Convert tile coordinates to latitude/longitude coordinates.
+    """Convert tile coordinates to longitude/latitude coordinates.
     
     Args:
         xtile (float): X tile coordinate
@@ -41,19 +41,19 @@ def num2deg(xtile, ytile, zoom):
         zoom (int): Zoom level
         
     Returns:
-        tuple: (latitude, longitude) in degrees
+        tuple: (longitude, latitude) in degrees
     """
     n = 2.0 ** zoom
     lon_deg = xtile / n * 360.0 - 180.0
     lat_rad = math.atan(math.sinh(math.pi * (1 - 2 * ytile / n)))
     lat_deg = math.degrees(lat_rad)
-    return (lat_deg, lon_deg)
+    return (lon_deg, lat_deg)
 
 def download_tiles(polygon, zoom):
     """Download satellite imagery tiles covering a polygon region.
     
     Args:
-        polygon (list): List of (lat, lon) coordinates defining the region
+        polygon (list): List of (lon, lat) coordinates defining the region
         zoom (int): Zoom level for tile detail
         
     Returns:
@@ -62,14 +62,14 @@ def download_tiles(polygon, zoom):
     print(f"Downloading tiles")
 
     # Find bounding box of polygon
-    min_lat = min(p[0] for p in polygon)
-    max_lat = max(p[0] for p in polygon)
-    min_lon = min(p[1] for p in polygon)
-    max_lon = max(p[1] for p in polygon)
+    min_lon = min(p[0] for p in polygon)
+    max_lon = max(p[0] for p in polygon)
+    min_lat = min(p[1] for p in polygon)
+    max_lat = max(p[1] for p in polygon)
     
     # Convert to tile coordinates
-    min_x, max_y = map(math.floor, deg2num(max_lat, min_lon, zoom))
-    max_x, min_y = map(math.ceil, deg2num(min_lat, max_lon, zoom))
+    min_x, max_y = map(math.floor, deg2num(min_lon, max_lat, zoom))
+    max_x, min_y = map(math.ceil, deg2num(max_lon, min_lat, zoom))
     
     # Download tiles within bounds
     tiles = {}
@@ -108,7 +108,7 @@ def crop_image(image, polygon, bounds, zoom):
     
     Args:
         image (Image): PIL Image to crop
-        polygon (list): List of (lat, lon) coordinates
+        polygon (list): List of (lon, lat) coordinates
         bounds (tuple): (min_x, min_y, max_x, max_y) tile bounds
         zoom (int): Zoom level
         
@@ -120,8 +120,8 @@ def crop_image(image, polygon, bounds, zoom):
     
     # Convert polygon coordinates to pixel coordinates
     polygon_pixels = []
-    for lat, lon in polygon:
-        x, y = deg2num(lat, lon, zoom)
+    for lon, lat in polygon:
+        x, y = deg2num(lon, lat, zoom)
         px = (x - min_x) * 256
         py = (y - min_y) * 256
         polygon_pixels.append((px, py))
@@ -143,7 +143,7 @@ def save_as_geotiff(image, polygon, zoom, bbox, bounds, output_path):
     
     Args:
         image (Image): PIL Image to save
-        polygon (list): List of (lat, lon) coordinates
+        polygon (list): List of (lon, lat) coordinates
         zoom (int): Zoom level
         bbox (tuple): Bounding box of cropped image
         bounds (tuple): (min_x, min_y, max_x, max_y) tile bounds
@@ -152,8 +152,8 @@ def save_as_geotiff(image, polygon, zoom, bbox, bounds, output_path):
     min_x, min_y, max_x, max_y = bounds
     
     # Calculate georeferencing coordinates
-    upper_left_lat, upper_left_lon = num2deg(min_x + bbox[0]/256, min_y + bbox[1]/256, zoom)
-    lower_right_lat, lower_right_lon = num2deg(min_x + bbox[2]/256, min_y + bbox[3]/256, zoom)
+    lon_upper_left, lat_upper_left = num2deg(min_x + bbox[0]/256, min_y + bbox[1]/256, zoom)
+    lon_lower_right, lat_lower_right = num2deg(min_x + bbox[2]/256, min_y + bbox[3]/256, zoom)
     
     # Create transformation from WGS84 to Web Mercator
     wgs84 = pyproj.CRS('EPSG:4326')
@@ -161,8 +161,8 @@ def save_as_geotiff(image, polygon, zoom, bbox, bounds, output_path):
     transformer = pyproj.Transformer.from_crs(wgs84, web_mercator, always_xy=True)
     
     # Transform coordinates to Web Mercator
-    upper_left_x, upper_left_y = transformer.transform(upper_left_lon, upper_left_lat)
-    lower_right_x, lower_right_y = transformer.transform(lower_right_lon, lower_right_lat)
+    upper_left_x, upper_left_y = transformer.transform(lon_upper_left, lat_upper_left)
+    lower_right_x, lower_right_y = transformer.transform(lon_lower_right, lat_lower_right)
     
     # Calculate pixel size
     pixel_size_x = (lower_right_x - upper_left_x) / image.width
@@ -190,7 +190,7 @@ def save_oemj_as_geotiff(polygon, filepath, zoom=16):
     """Download and save OpenEarthMap Japan imagery as GeoTIFF.
     
     Args:
-        polygon (list): List of (lat, lon) coordinates defining region
+        polygon (list): List of (lon, lat) coordinates defining region
         filepath (str): Output path for GeoTIFF
         zoom (int, optional): Zoom level for detail. Defaults to 16.
     """

{voxcity-0.3.3 → voxcity-0.3.5}/src/voxcity/download/omt.py

@@ -20,20 +20,20 @@ def load_geojsons_from_openmaptiles(rectangle_vertices, API_KEY):
     """Download and process building footprint data from OpenMapTiles vector tiles.
 
     Args:
-        rectangle_vertices: List of (lat, lon) coordinates defining the bounding box
+        rectangle_vertices: List of (lon, lat) coordinates defining the bounding box
         API_KEY: OpenMapTiles API key for authentication
 
     Returns:
         list: List of GeoJSON features containing building footprints with standardized properties
     """
-    # Extract latitudes and longitudes from vertices to find bounding box
-    lats = [coord[0] for coord in rectangle_vertices]
-    lons = [coord[1] for coord in rectangle_vertices]
+    # Extract longitudes and latitudes from vertices to find bounding box
+    lons = [coord[0] for coord in rectangle_vertices]
+    lats = [coord[1] for coord in rectangle_vertices]
 
-    min_lat = min(lats)
-    max_lat = max(lats)
     min_lon = min(lons)
     max_lon = max(lons)
+    min_lat = min(lats)
+    max_lat = max(lats)
 
     # Use zoom level 15 which provides good detail for buildings while keeping data size manageable
     zoom = 15
@@ -183,10 +183,10 @@ def convert_geojson_format(features):
                     ring_properties['is_inner'] = j > 0
                     ring_properties['role'] = 'inner' if j > 0 else 'outer'
 
-                    # Create new geometry with swapped coordinate order (lon,lat) -> (lat,lon)
+                    # Create new geometry keeping coordinate order as (lon,lat)
                     new_geometry = {
                         'type': 'Polygon',
-                        'coordinates': [[(coord[1], coord[0]) for coord in ring]]
+                        'coordinates': [ring]
                     }
 
                     new_feature = {
@@ -204,10 +204,10 @@ def convert_geojson_format(features):
                 ring_properties['is_inner'] = i > 0
                 ring_properties['role'] = 'inner' if i > 0 else 'outer'
 
-                # Create new geometry with swapped coordinate order
+                # Create new geometry keeping coordinate order as (lon,lat)
                 new_geometry = {
                     'type': 'Polygon',
-                    'coordinates': [[(coord[1], coord[0]) for coord in ring]]
+                    'coordinates': [ring]
                 }
 
                 new_feature = {

{voxcity-0.3.3 → voxcity-0.3.5}/src/voxcity/download/osm.py

@@ -26,16 +26,16 @@ def load_geojsons_from_openstreetmap(rectangle_vertices):
     """Download and process building footprint data from OpenStreetMap.
     
     Args:
-        rectangle_vertices: List of (lat, lon) coordinates defining the bounding box
+        rectangle_vertices: List of (lon, lat) coordinates defining the bounding box
         
     Returns:
         list: List of GeoJSON features containing building footprints with standardized properties
     """
     # Create a bounding box from the rectangle vertices
-    min_lat = min(v[0] for v in rectangle_vertices)
-    max_lat = max(v[0] for v in rectangle_vertices)
-    min_lon = min(v[1] for v in rectangle_vertices)
-    max_lon = max(v[1] for v in rectangle_vertices)
+    min_lon = min(v[0] for v in rectangle_vertices)
+    max_lon = max(v[0] for v in rectangle_vertices)
+    min_lat = min(v[1] for v in rectangle_vertices)
+    max_lat = max(v[1] for v in rectangle_vertices)
     
     # Enhanced Overpass API query with recursive member extraction
     overpass_url = "http://overpass-api.de/api/interpreter"
@@ -73,7 +73,7 @@ def load_geojsons_from_openstreetmap(rectangle_vertices):
         Returns:
             list: Processed coordinate pairs with reversed order
         """
-        return [coord[::-1] for coord in geometry]
+        return [coord for coord in geometry]  # Keep original order since already (lon, lat)
     
     def get_height_from_properties(properties):
         """Helper function to extract height from properties.
@@ -253,7 +253,7 @@ def convert_feature(feature):
         for coord in ring:
             # Swap the order if needed (assuming original is [lat, lon])
             lat, lon = coord
-            new_ring.append((lat, lon))
+            new_ring.append((lon, lat))  # Changed to (lon, lat)
         new_coordinates.append(new_ring)
 
     new_feature['geometry']['type'] = 'Polygon'
@@ -460,9 +460,8 @@ def swap_coordinates(geom_mapping):
         if isinstance(coord_list[0], (list, tuple)):
             return [swap_coords(c) for c in coord_list]
         else:
-            # Swap lon/lat to lat/lon
-            lon, lat = coord_list
-            return [lat, lon]
+            # Keep original order since already (lon, lat)
+            return coord_list
 
     geom_mapping['coordinates'] = swap_coords(coords)
     return geom_mapping
@@ -471,7 +470,7 @@ def load_land_cover_geojson_from_osm(rectangle_vertices_ori):
     """Load land cover data from OpenStreetMap within a given rectangular area.
     
     Args:
-        rectangle_vertices_ori (list): List of (lat, lon) coordinates defining the rectangle
+        rectangle_vertices_ori (list): List of (lon, lat) coordinates defining the rectangle
         
     Returns:
         list: List of GeoJSON features with land cover classifications
@@ -480,8 +479,11 @@ def load_land_cover_geojson_from_osm(rectangle_vertices_ori):
     rectangle_vertices = rectangle_vertices_ori.copy()
     rectangle_vertices.append(rectangle_vertices_ori[0])
 
-    # Convert vertices to space-separated string for Overpass query
-    polygon_coords = ' '.join(f"{lat} {lon}" for lat, lon in rectangle_vertices)
+    # Instead of using poly:"lat lon lat lon...", use area coordinates
+    min_lat = min(lat for lon, lat in rectangle_vertices)
+    max_lat = max(lat for lon, lat in rectangle_vertices)
+    min_lon = min(lon for lon, lat in rectangle_vertices)
+    max_lon = max(lon for lon, lat in rectangle_vertices)
 
     # Initialize dictionary to store OSM keys and their allowed values
     osm_keys_values = defaultdict(list)
@@ -504,16 +506,16 @@ def load_land_cover_geojson_from_osm(rectangle_vertices_ori):
     for key, values in osm_keys_values.items():
         if values:
             if values == ['*']:
-                # Query for any value of this key
-                query_parts.append(f'way["{key}"](poly:"{polygon_coords}");')
-                query_parts.append(f'relation["{key}"](poly:"{polygon_coords}");')
+                # Query for any value of this key using bounding box
+                query_parts.append(f'way["{key}"]({min_lat},{min_lon},{max_lat},{max_lon});')
+                query_parts.append(f'relation["{key}"]({min_lat},{min_lon},{max_lat},{max_lon});')
             else:
                 # Remove duplicate values
                 values = list(set(values))
                 # Build regex pattern for specific values
                 values_regex = '|'.join(values)
-                query_parts.append(f'way["{key}"~"^{values_regex}$"](poly:"{polygon_coords}");')
-                query_parts.append(f'relation["{key}"~"^{values_regex}$"](poly:"{polygon_coords}");')
+                query_parts.append(f'way["{key}"~"^{values_regex}$"]({min_lat},{min_lon},{max_lat},{max_lon});')
+                query_parts.append(f'relation["{key}"~"^{values_regex}$"]({min_lat},{min_lon},{max_lat},{max_lon});')
 
     # Combine query parts into complete Overpass query
     query_body = "\n  ".join(query_parts)
@@ -541,11 +543,11 @@ def load_land_cover_geojson_from_osm(rectangle_vertices_ori):
     geojson_data = json2geojson(data)
 
     # Create shapely polygon from rectangle vertices (in lon,lat order)
-    rectangle_polygon = Polygon([(lon, lat) for lat, lon in rectangle_vertices])
+    rectangle_polygon = Polygon(rectangle_vertices)
 
     # Calculate center point for projection
-    center_lat = sum(lat for lat, lon in rectangle_vertices) / len(rectangle_vertices)
-    center_lon = sum(lon for lat, lon in rectangle_vertices) / len(rectangle_vertices)
+    center_lat = sum(lat for lon, lat in rectangle_vertices) / len(rectangle_vertices)
+    center_lon = sum(lon for lon, lat in rectangle_vertices) / len(rectangle_vertices)
 
     # Set up coordinate reference systems for projection
     wgs84 = pyproj.CRS('EPSG:4326')  # Standard lat/lon

{voxcity-0.3.3 → voxcity-0.3.5}/src/voxcity/download/overture.py

@@ -64,7 +64,7 @@ def is_valid_value(value):
 
 def convert_gdf_to_geojson(gdf):
     """
-    Convert GeoDataFrame to GeoJSON format with coordinates in (lat, lon) order.
+    Convert GeoDataFrame to GeoJSON format with coordinates in (lon, lat) order.
     Extracts all columns as properties except for 'geometry' and 'bbox'.
     Sets height and min_height to 0 if not present and handles arrays.
     
@@ -81,14 +81,6 @@ def convert_gdf_to_geojson(gdf):
         # Convert Shapely geometry to GeoJSON format
         geom = mapping(row['geometry'])
         
-        # Swap coordinate ordering from (lon, lat) to (lat, lon)
-        if geom['type'] == 'Polygon':
-            new_coordinates = []
-            for ring in geom['coordinates']:
-                new_ring = [[coord[1], coord[0]] for coord in ring]
-                new_coordinates.append(new_ring)
-            geom['coordinates'] = new_coordinates
-        
         # Initialize properties dictionary for this feature
         properties = {}
         
@@ -125,18 +117,18 @@ def convert_gdf_to_geojson(gdf):
 
 def rectangle_to_bbox(vertices):
     """
-    Convert rectangle vertices in (lat, lon) format to a GeoDataFrame bbox
+    Convert rectangle vertices in (lon, lat) format to a GeoDataFrame bbox
     with Shapely box geometry in (minx, miny, maxx, maxy) format
     
     Args:
-        vertices (list): List of tuples containing (lat, lon) coordinates
+        vertices (list): List of tuples containing (lon, lat) coordinates
         
     Returns:
         tuple: Bounding box coordinates (min_lon, min_lat, max_lon, max_lat)
     """
-    # Extract lat, lon values from vertices
-    lats = [vertex[0] for vertex in vertices]
-    lons = [vertex[1] for vertex in vertices]
+    # Extract lon, lat values from vertices
+    lons = [vertex[0] for vertex in vertices]
+    lats = [vertex[1] for vertex in vertices]
     
     # Calculate bounding box extents
     min_lat = min(lats)
@@ -192,7 +184,7 @@ def load_geojsons_from_overture(rectangle_vertices):
     Download and process building footprint data from Overture Maps.
     
     Args:
-        rectangle_vertices (list): List of (lat, lon) coordinates defining the bounding box
+        rectangle_vertices (list): List of (lon, lat) coordinates defining the bounding box
         
     Returns:
         list: List of GeoJSON features containing building footprints with standardized properties

{voxcity-0.3.3 → voxcity-0.3.5}/src/voxcity/file/envimet.py

@@ -231,10 +231,10 @@ def create_xml_content(building_height_grid, building_id_grid, land_cover_veg_gr
     city_country_name = get_city_country_name_from_rectangle(rectangle_vertices)
 
     # Calculate center coordinates of the model area
-    latitudes = [coord[0] for coord in rectangle_vertices]
-    longitudes = [coord[1] for coord in rectangle_vertices]
-    center_lat = str(sum(latitudes) / len(latitudes))
-    center_lon = str(sum(longitudes) / len(longitudes))
+    longitudes = [coord[0] for coord in rectangle_vertices]  # Changed order from lat to lon
+    latitudes = [coord[1] for coord in rectangle_vertices]  # Changed order from lat to lon
+    center_lon = str(sum(longitudes) / len(longitudes))  # Changed order
+    center_lat = str(sum(latitudes) / len(latitudes))  # Changed order
     
     timezone_info = get_timezone_info(rectangle_vertices)