voxcity 0.6.26__tar.gz → 0.6.27__tar.gz

{voxcity-0.6.26 → voxcity-0.6.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voxcity
-Version: 0.6.26
+Version: 0.6.27
 Summary: voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data
 License: MIT
 License-File: AUTHORS.rst

{voxcity-0.6.26 → voxcity-0.6.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "voxcity"
-version = "0.6.26"
+version = "0.6.27"
 description = "voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data"
 readme = "README.md"
 license = "MIT"

{voxcity-0.6.26 → voxcity-0.6.27}/src/voxcity/downloader/__init__.py

@@ -4,4 +4,5 @@ from .gee import *
 from .osm import *
 from .oemj import *
 from .eubucco import *
-from .overture import *
+from .overture import *
+from .gba import *

voxcity-0.6.27/src/voxcity/downloader/gba.py

@@ -0,0 +1,210 @@
+"""
+Downloader for Global Building Atlas (GBA) LOD1 polygons.
+
+This module downloads GeoParquet tiles from the Global Building Atlas (GBA)
+hosted at data.source.coop, selects tiles intersecting a user-specified
+rectangle, loads them into a GeoDataFrame, and filters features to the
+rectangle extent.
+
+Tile scheme:
+- Global 5x5-degree tiles named like: e010_n50_e015_n45.parquet
+  - longitudes: e/w with 3-digit zero padding (e.g., e010, w060)
+  - latitudes: n/s with 2-digit zero padding (e.g., n50, s25)
+  - filename order: west_lon, north_lat, east_lon, south_lat
+
+Usage:
+    gdf = load_gdf_from_gba(rectangle_vertices=[(lon1, lat1), (lon2, lat2), ...])
+
+Notes:
+- Output CRS is EPSG:4326.
+- Requires pyarrow or fastparquet for parquet reading via GeoPandas.
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import tempfile
+from typing import Iterable, List, Optional, Sequence, Tuple
+
+import geopandas as gpd
+import pandas as pd
+import requests
+from shapely.geometry import Polygon
+
+
+def _bbox_from_rectangle_vertices(vertices: Sequence[Tuple[float, float]]) -> Tuple[float, float, float, float]:
+    """
+    Convert rectangle vertices in (lon, lat) into bbox as (min_lon, min_lat, max_lon, max_lat).
+    """
+    if not vertices:
+        raise ValueError("rectangle_vertices must be a non-empty sequence of (lon, lat)")
+    lons = [v[0] for v in vertices]
+    lats = [v[1] for v in vertices]
+    return (min(lons), min(lats), max(lons), max(lats))
+
+
+def _pad_lon(deg: int) -> str:
+    return f"{abs(deg):03d}"
+
+
+def _pad_lat(deg: int) -> str:
+    return f"{abs(deg):02d}"
+
+
+def _lon_tag(deg: int) -> str:
+    return ("e" if deg >= 0 else "w") + _pad_lon(deg)
+
+
+def _lat_tag(deg: int) -> str:
+    return ("n" if deg >= 0 else "s") + _pad_lat(deg)
+
+
+def _snap_down(value: float, step: int) -> int:
+    return int(math.floor(value / step) * step)
+
+
+def _snap_up(value: float, step: int) -> int:
+    return int(math.ceil(value / step) * step)
+
+
+def _generate_tile_bounds_for_bbox(
+    min_lon: float, min_lat: float, max_lon: float, max_lat: float, tile_size_deg: int = 5
+) -> Iterable[Tuple[int, int, int, int]]:
+    """
+    Generate 5-degree tile bounds (west, south, east, north) covering bbox.
+    All values are integer degrees aligned to tile_size_deg.
+    """
+    west = _snap_down(min_lon, tile_size_deg)
+    east = _snap_up(max_lon, tile_size_deg)
+    south = _snap_down(min_lat, tile_size_deg)
+    north = _snap_up(max_lat, tile_size_deg)
+
+    for lon in range(west, east, tile_size_deg):
+        for lat in range(south, north, tile_size_deg):
+            yield (lon, lat, lon + tile_size_deg, lat + tile_size_deg)
+
+
+def _tile_filename(west: int, south: int, east: int, north: int) -> str:
+    """
+    Construct GBA tile filename for given integer-degree bounds.
+    Naming convention examples:
+      e010_n50_e015_n45.parquet
+      e140_s25_e145_s30.parquet
+      w060_s30_w055_s35.parquet
+    """
+    return f"{_lon_tag(west)}_{_lat_tag(north)}_{_lon_tag(east)}_{_lat_tag(south)}.parquet"
+
+
+def _tile_url(base_url: str, west: int, south: int, east: int, north: int) -> str:
+    filename = _tile_filename(west, south, east, north)
+    return f"{base_url.rstrip('/')}/{filename}"
+
+
+def _download_parquet(url: str, download_dir: str, timeout: int = 60) -> Optional[str]:
+    """
+    Download a parquet file to download_dir. Returns local filepath or None if not found.
+    """
+    try:
+        with requests.get(url, stream=True, timeout=timeout) as r:
+            if r.status_code != 200:
+                return None
+            filename = os.path.basename(url)
+            local_path = os.path.join(download_dir, filename)
+            with open(local_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size=1024 * 1024):
+                    if chunk:
+                        f.write(chunk)
+        return local_path
+    except requests.RequestException:
+        return None
+
+
+def _filter_to_rectangle(gdf: gpd.GeoDataFrame, rectangle: Polygon, clip: bool) -> gpd.GeoDataFrame:
+    gdf = gdf[gdf.geometry.notnull()].copy()
+    # Ensure CRS is WGS84
+    if gdf.crs is None:
+        gdf.set_crs(epsg=4326, inplace=True)
+    elif gdf.crs.to_epsg() != 4326:
+        gdf = gdf.to_crs(epsg=4326)
+
+    intersects = gdf.intersects(rectangle)
+    gdf = gdf[intersects].copy()
+    if clip and not gdf.empty:
+        # GeoPandas clip performs overlay to trim geometries to rectangle
+        gdf = gpd.clip(gdf, gpd.GeoSeries([rectangle], crs="EPSG:4326").to_frame("geometry"))
+    return gdf
+
+
+def load_gdf_from_gba(
+    rectangle_vertices: Sequence[Tuple[float, float]],
+    base_url: str = "https://data.source.coop/tge-labs/globalbuildingatlas-lod1",
+    download_dir: Optional[str] = None,
+    clip_to_rectangle: bool = False,
+) -> Optional[gpd.GeoDataFrame]:
+    """
+    Download GBA tiles intersecting a rectangle and return combined GeoDataFrame.
+
+    Args:
+        rectangle_vertices: Sequence of (lon, lat) defining the area of interest.
+        base_url: Base URL hosting GBA parquet tiles.
+        download_dir: Optional directory to store downloaded tiles. If None, a
+                      temporary directory is used and cleaned up by the OS later.
+        clip_to_rectangle: If True, geometries are clipped to rectangle extent.
+
+    Returns:
+        GeoDataFrame with EPSG:4326 geometry and an 'id' column, or None if no data.
+    """
+    min_lon, min_lat, max_lon, max_lat = _bbox_from_rectangle_vertices(rectangle_vertices)
+    rectangle = Polygon([
+        (min_lon, min_lat),
+        (max_lon, min_lat),
+        (max_lon, max_lat),
+        (min_lon, max_lat),
+        (min_lon, min_lat),
+    ])
+
+    tmp_dir_created = False
+    if download_dir is None:
+        download_dir = tempfile.mkdtemp(prefix="gba_tiles_")
+        tmp_dir_created = True
+    else:
+        os.makedirs(download_dir, exist_ok=True)
+
+    local_files: List[str] = []
+    for west, south, east, north in _generate_tile_bounds_for_bbox(min_lon, min_lat, max_lon, max_lat):
+        url = _tile_url(base_url, west, south, east, north)
+        local = _download_parquet(url, download_dir)
+        if local is not None:
+            local_files.append(local)
+
+    if not local_files:
+        return None
+
+    gdfs: List[gpd.GeoDataFrame] = []
+    for path in local_files:
+        try:
+            # GeoParquet read
+            gdf = gpd.read_parquet(path)
+            if gdf is not None and not gdf.empty:
+                gdfs.append(gdf)
+        except Exception:
+            # Skip unreadable tiles
+            continue
+
+    if not gdfs:
+        return None
+
+    combined = pd.concat(gdfs, ignore_index=True)
+    combined = gpd.GeoDataFrame(combined, geometry="geometry")
+    combined = _filter_to_rectangle(combined, rectangle, clip=clip_to_rectangle)
+
+    if combined.empty:
+        return None
+
+    # Ensure sequential ids
+    combined["id"] = combined.index.astype(int)
+    combined.set_crs(epsg=4326, inplace=True, allow_override=True)
+    return combined
+
+

{voxcity-0.6.26 → voxcity-0.6.27}/src/voxcity/generator.py

@@ -48,6 +48,7 @@ from .downloader.oemj import save_oemj_as_geotiff
 from .downloader.eubucco import load_gdf_from_eubucco
 from .downloader.overture import load_gdf_from_overture
 from .downloader.citygml import load_buid_dem_veg_from_citygml
+from .downloader.gba import load_gdf_from_gba
 
 # Google Earth Engine related imports - for satellite and elevation data
 from .downloader.gee import (
@@ -206,8 +207,9 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
             - list: Filtered building features
     """
 
-    # Initialize Earth Engine for satellite-based building data sources
-    if source not in ["OpenStreetMap", "Overture", "Local file", "GeoDataFrame"]:
+    # Initialize Earth Engine only for building sources that require it
+    ee_required_sources = {"Open Building 2.5D Temporal"}
+    if source in ee_required_sources:
         initialize_earth_engine()
 
     print("Creating Building Height grid\n ")
@@ -243,6 +245,11 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
         elif source == "Overture":
             # Open building dataset from Overture Maps Foundation
             gdf = load_gdf_from_overture(rectangle_vertices, floor_height=floor_height)
+        elif source in ("GBA", "Global Building Atlas"):
+            # Global Building Atlas LOD1 polygons (GeoParquet tiles)
+            clip_gba = kwargs.get("gba_clip", False)
+            gba_download_dir = kwargs.get("gba_download_dir")
+            gdf = load_gdf_from_gba(rectangle_vertices, download_dir=gba_download_dir, clip_to_rectangle=clip_gba)
         elif source == "Local file":
             # Handle user-provided local building data files
             _, extension = os.path.splitext(kwargs["building_path"])
@@ -290,6 +297,10 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, b
             #     gdf_comp = load_gdf_from_openmaptiles(rectangle_vertices, kwargs["maptiler_API_key"])
             elif building_complementary_source == "Overture":
                 gdf_comp = load_gdf_from_overture(rectangle_vertices, floor_height=floor_height)
+            elif building_complementary_source in ("GBA", "Global Building Atlas"):
+                clip_gba = kwargs.get("gba_clip", False)
+                gba_download_dir = kwargs.get("gba_download_dir")
+                gdf_comp = load_gdf_from_gba(rectangle_vertices, download_dir=gba_download_dir, clip_to_rectangle=clip_gba)
             elif building_complementary_source == "Local file":
                 _, extension = os.path.splitext(kwargs["building_complementary_path"])
                 if extension == ".gpkg":
@@ -979,6 +990,10 @@ def get_voxcity_CityGML(rectangle_vertices, land_cover_source, canopy_height_sou
             gdf_comp = load_gdf_from_eubucco(rectangle_vertices, kwargs.get("output_dir", "output"))
         elif building_complementary_source == 'Overture':
             gdf_comp = load_gdf_from_overture(rectangle_vertices, floor_height=floor_height)
+        elif building_complementary_source in ("GBA", "Global Building Atlas"):
+            clip_gba = kwargs.get("gba_clip", False)
+            gba_download_dir = kwargs.get("gba_download_dir")
+            gdf_comp = load_gdf_from_gba(rectangle_vertices, download_dir=gba_download_dir, clip_to_rectangle=clip_gba)
         elif building_complementary_source == 'Local file':
             comp_path = kwargs.get("building_complementary_path")
             if comp_path is not None: