voxcity 0.6.25__tar.gz → 0.6.27__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voxcity
-Version: 0.6.25
+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.25 → voxcity-0.6.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "voxcity"
-version = "0.6.25"
+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.25 → 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.25 → voxcity-0.6.27}/src/voxcity/exporter/cityles.py

@@ -36,126 +36,107 @@ VOXCITY_STANDARD_CLASSES = {
 }
 
 ## Source-specific class name to CityLES land use mappings
-# CityLES land use codes (updated to match provided definitions):
-# 1: High reflective ASPHALT, 2: High reflective ASPHALT without AH,
-# 3: CONCRETE (proxy of jari), 4: CONCRETE building,
-# 5: Slate roof (Ordinal wooden house), 6: PADDY,
-# 7: Dryland Cropland and Pasture, 8: Barren or Sparsely Vegetated,
-# 9: WATER, 10: Grassland, 11: CONCRETE (proxy of block),
-# 12: ASPHALT without AH, 13: ASPHALT,
-# 14-17: Deciduous Broadleaf Forest
-
-# OpenStreetMap / Standard (mapped to updated CityLES landuse codes)
+# CityLES land use codes: 1=Water, 2=Rice Paddy, 3=Crops, 4=Grassland, 5=Deciduous Broadleaf Forest,
+# 9=Bare Land, 10=Building, 16=Asphalt (road), etc.
+
+# OpenStreetMap / Standard
 OSM_CLASS_TO_CITYLES = {
-    'Bareland': 8,
-    'Rangeland': 10,
-    'Shrub': 10,
-    'Moss and lichen': 10,
-    'Agriculture land': 7,
-    'Tree': 14,
-    'Wet land': 6,
-    'Mangroves': 14,
-    'Water': 9,
-    'Snow and ice': 8,
-    'Developed space': 4,
-    'Road': 13,
-    'Building': 4,
-    'No Data': 10
+    'Bareland': 9,
+    'Rangeland': 4,
+    'Shrub': 4,
+    'Moss and lichen': 4,
+    'Agriculture land': 3,
+    'Tree': 5,
+    'Wet land': 2,
+    'Mangroves': 5,
+    'Water': 1,
+    'Snow and ice': 9,
+    'Developed space': 10,
+    'Road': 16,
+    'Building': 10,
+    'No Data': 4
 }
 
 # Urbanwatch
 URBANWATCH_CLASS_TO_CITYLES = {
-    'Building': 4,
-    'Road': 13,
-    'Parking Lot': 13,
-    'Tree Canopy': 14,
-    'Grass/Shrub': 10,
-    'Agriculture': 7,
-    'Water': 9,
-    'Barren': 8,
-    'Unknown': 10,
-    'Sea': 9
+    'Building': 10,
+    'Road': 16,
+    'Parking Lot': 16,
+    'Tree Canopy': 5,
+    'Grass/Shrub': 4,
+    'Agriculture': 3,
+    'Water': 1,
+    'Barren': 9,
+    'Unknown': 4,
+    'Sea': 1
 }
 
 # OpenEarthMapJapan
 OEMJ_CLASS_TO_CITYLES = {
-    'Bareland': 8,
-    'Rangeland': 10,
-    'Developed space': 4,
-    'Road': 13,
-    'Tree': 14,
-    'Water': 9,
-    'Agriculture land': 7,
-    'Building': 4
+    'Bareland': 9,
+    'Rangeland': 4,
+    'Developed space': 10,
+    'Road': 16,
+    'Tree': 5,
+    'Water': 1,
+    'Agriculture land': 3,
+    'Building': 10
 }
 
 # ESA WorldCover
 ESA_CLASS_TO_CITYLES = {
-    'Trees': 14,
-    'Shrubland': 10,
-    'Grassland': 10,
-    'Cropland': 7,
-    'Built-up': 4,
-    'Barren / sparse vegetation': 8,
-    'Snow and ice': 8,
-    'Open water': 9,
-    'Herbaceous wetland': 6,
-    'Mangroves': 14,
-    'Moss and lichen': 10
+    'Trees': 5,
+    'Shrubland': 4,
+    'Grassland': 4,
+    'Cropland': 3,
+    'Built-up': 10,
+    'Barren / sparse vegetation': 9,
+    'Snow and ice': 9,
+    'Open water': 1,
+    'Herbaceous wetland': 2,
+    'Mangroves': 5,
+    'Moss and lichen': 9
 }
 
 # ESRI 10m Annual Land Cover
 ESRI_CLASS_TO_CITYLES = {
-    'No Data': 10,
-    'Water': 9,
-    'Trees': 14,
-    'Grass': 10,
-    'Flooded Vegetation': 6,
-    'Crops': 7,
-    'Scrub/Shrub': 10,
-    'Built Area': 4,
-    'Bare Ground': 8,
-    'Snow/Ice': 8,
-    'Clouds': 10
+    'No Data': 4,
+    'Water': 1,
+    'Trees': 5,
+    'Grass': 4,
+    'Flooded Vegetation': 2,
+    'Crops': 3,
+    'Scrub/Shrub': 4,
+    'Built Area': 10,
+    'Bare Ground': 9,
+    'Snow/Ice': 9,
+    'Clouds': 4
 }
 
 # Dynamic World V1
 DYNAMIC_WORLD_CLASS_TO_CITYLES = {
-    'Water': 9,
-    'Trees': 14,
-    'Grass': 10,
-    'Flooded Vegetation': 6,
-    'Crops': 7,
-    'Shrub and Scrub': 10,
-    'Built': 4,
-    'Bare': 8,
-    'Snow and Ice': 8
+    'Water': 1,
+    'Trees': 5,
+    'Grass': 4,
+    'Flooded Vegetation': 2,
+    'Crops': 3,
+    'Shrub and Scrub': 4,
+    'Built': 10,
+    'Bare': 9,
+    'Snow and Ice': 9
 }
 
-# Building material mapping based on corrected definitions (101-117)
+# Building material mapping based on corrected documentation
 BUILDING_MATERIAL_MAPPING = {
-    'building': 104,         # CONCRETE building
-    'concrete': 104,         # CONCRETE building
-    'residential': 105,      # Slate roof (Ordinal wooden house)
-    'wooden': 105,           # Slate roof (Ordinal wooden house)
-    'commercial': 104,       # CONCRETE building
-    'industrial': 104,       # CONCRETE building
-    'default': 104           # Default to CONCRETE building
+    'building': 110,         # Building (general)
+    'concrete': 110,         # Building (concrete)
+    'residential': 111,      # Old wooden house
+    'wooden': 111,           # Old wooden house
+    'commercial': 110,       # Building (commercial)
+    'industrial': 110,       # Building (industrial)
+    'default': 110           # Default to general building
 }
 
-# Helper to convert landuse code (1-17) to building material code (101-117)
-def landuse_to_building_material_code(landuse_code: int) -> int:
-    """Map landuse code to building-material code with required adjustments.
-
-    The general rule is 100 + landuse_code, except for ASPHALT classes where
-    landuse 12 (ASPHALT without AH) maps to 113 and landuse 13 (ASPHALT) maps to 112.
-    """
-    # if landuse_code == 12:
-    #     return 113
-    # if landuse_code == 13:
-    #     return 112
-    return 100 + int(landuse_code)
-
 # Tree type mapping for vmap.txt
 TREE_TYPE_MAPPING = {
     'deciduous': 101,        # Leaf
@@ -248,7 +229,7 @@ def export_topog(building_height_grid, building_id_grid, output_path,
                 # Decide material code per cell
                 if cityles_landuse_grid is not None:
                     cell_lu = int(cityles_landuse_grid[j, i])
-                    material_code_cell = landuse_to_building_material_code(cell_lu)
+                    material_code_cell = cell_lu + 100
                 else:
                     if height > 0:
                         material_code_cell = material_code

{voxcity-0.6.25 → 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: