voxcity 0.6.15__py3-none-any.whl → 0.7.0__py3-none-any.whl

voxcity/__init__.py

@@ -1,8 +1,14 @@
-__author__ = """Kunihiko Fujiwara"""
-__email__ = 'kunihiko@nus.edu.sg'
-__version__ = '0.1.0'
-
-# from .generator import *
-# from .download import mbfp
-# # from .utils.draw import rotate_rectangle, draw_rectangle_map
-# from .geo import draw, utils
+__author__ = """Kunihiko Fujiwara"""
+__email__ = 'kunihiko@nus.edu.sg'
+__version__ = '0.1.0'
+
+# Keep package __init__ lightweight to avoid import-time failures.
+# Re-exports of heavy modules/classes are intentionally omitted here.
+# Downstream modules should import directly from their subpackages, e.g.:
+#   from voxcity.geoprocessor.draw import draw_rectangle_map_cityname
+
+__all__ = [
+    "__author__",
+    "__email__",
+    "__version__",
+]

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/downloader/citygml.py

@@ -156,13 +156,16 @@ def get_tile_polygon_from_filename(filename):
 # Original script logic
 # --------------------------------------------------------------------
 
-def download_and_extract_zip(url, extract_to='.'):
+def download_and_extract_zip(url, extract_to='.', ssl_verify=True, ca_bundle=None, timeout=60):
     """
     Download and extract a zip file from a URL to specified directory.
 
     Args:
         url (str): URL of the zip file to download.
         extract_to (str): Directory to extract files to (default: current directory).
+        ssl_verify (bool): Whether to verify SSL certificates (default: True).
+        ca_bundle (str|None): Path to a CA bundle file. Overrides verify when provided.
+        timeout (int|float): Request timeout in seconds (default: 60).
 
     Returns:
         tuple: (extraction_path, folder_name) where files were extracted.
@@ -171,21 +174,27 @@ def download_and_extract_zip(url, extract_to='.'):
         - Creates a subdirectory named after the zip file (without .zip)
         - Prints status messages for success/failure
     """
-    response = requests.get(url)
-    if response.status_code == 200:
-        parsed_url = urlparse(url)
-        zip_filename = os.path.basename(parsed_url.path)
-        folder_name = os.path.splitext(zip_filename)[0]  # Remove the .zip extension
-
-        extraction_path = os.path.join(extract_to, folder_name)
-        os.makedirs(extraction_path, exist_ok=True)
-
-        zip_file = io.BytesIO(response.content)
-        with zipfile.ZipFile(zip_file) as z:
-            z.extractall(extraction_path)
-            print(f"Extracted to {extraction_path}")
-    else:
-        print(f"Failed to download the file. Status code: {response.status_code}")
+    verify_arg = ca_bundle if ca_bundle else ssl_verify
+    try:
+        response = requests.get(url, verify=verify_arg, timeout=timeout)
+        if response.status_code == 200:
+            parsed_url = urlparse(url)
+            zip_filename = os.path.basename(parsed_url.path)
+            folder_name = os.path.splitext(zip_filename)[0]  # Remove the .zip extension
+
+            extraction_path = os.path.join(extract_to, folder_name)
+            os.makedirs(extraction_path, exist_ok=True)
+
+            zip_file = io.BytesIO(response.content)
+            with zipfile.ZipFile(zip_file) as z:
+                z.extractall(extraction_path)
+                print(f"Extracted to {extraction_path}")
+        else:
+            print(f"Failed to download the file. Status code: {response.status_code}")
+    except requests.exceptions.SSLError as e:
+        print("SSL error when downloading CityGML zip. You can pass 'ssl_verify=False' to skip verification, "
+              "or provide a CA bundle path via 'ca_bundle'. Error:", e)
+        raise
 
     return extraction_path, folder_name
 
@@ -848,7 +857,10 @@ def swap_coordinates_if_needed(gdf, geometry_col='geometry'):
 def load_buid_dem_veg_from_citygml(url=None, 
                               base_dir='.', 
                               citygml_path=None,
-                              rectangle_vertices=None):
+                              rectangle_vertices=None,
+                              ssl_verify=True,
+                              ca_bundle=None,
+                              timeout=60):
     """
     Load and process PLATEAU data from URL or local files.
 
@@ -879,7 +891,9 @@ def load_buid_dem_veg_from_citygml(url=None,
         rectangle_polygon = Polygon(rectangle_vertices)
     
     if url:
-        citygml_path, foldername = download_and_extract_zip(url, extract_to=base_dir)
+        citygml_path, foldername = download_and_extract_zip(
+            url, extract_to=base_dir, ssl_verify=ssl_verify, ca_bundle=ca_bundle, timeout=timeout
+        )
     elif citygml_path:
         foldername = os.path.basename(citygml_path)
     else:

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/downloader/gee.py

@@ -217,7 +217,11 @@ def get_dem_image(roi_buffered, source):
     #     dem = collection.mosaic() 
 
     # elif source == 'FABDEM':
-    return dem.clip(roi_buffered)
+    # If we reach here without assigning `dem`, the source is unsupported
+    try:
+        return dem.clip(roi_buffered)
+    except UnboundLocalError:
+        raise ValueError(f"Unsupported or unimplemented DEM source: {source}")
 
 def save_geotiff_esa_land_cover(roi, geotiff_path):
     """Save ESA WorldCover land cover data as a colored GeoTIFF.

voxcity/downloader/mbfp.py

@@ -20,7 +20,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_gdf_from_multiple_gz, swap_coordinates
+from ..geoprocessor.io 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.

voxcity/downloader/oemj.py

@@ -19,6 +19,7 @@ Example Usage:
 """
 
 import requests
+import os
 from PIL import Image, ImageDraw
 from io import BytesIO
 import math
@@ -73,7 +74,7 @@ def num2deg(xtile, ytile, zoom):
     lat_deg = math.degrees(lat_rad)
     return (lon_deg, lat_deg)
 
-def download_tiles(polygon, zoom):
+def download_tiles(polygon, zoom, *, ssl_verify=True, allow_insecure_ssl=False, allow_http_fallback=False, timeout_s=30):
     """Download satellite imagery tiles covering a polygon region.
     
     Downloads all tiles that intersect with the given polygon at the specified zoom level
@@ -112,11 +113,70 @@ def download_tiles(polygon, zoom):
     for x in range(min(min_x, max_x), max(min_x, max_x) + 1):
         for y in range(min(min_y, max_y), max(min_y, max_y) + 1):
             url = f"https://www.open-earth-map.org/demo/Japan/{zoom}/{x}/{y}.png"
-            response = requests.get(url)
-            if response.status_code == 200:
-                tiles[(x, y)] = Image.open(BytesIO(response.content))
-            else:
-                print(f"Failed to download tile: {url}")
+            # Try secure HTTPS first with user-provided verification option
+            content = None
+            try:
+                resp = requests.get(url, timeout=timeout_s, verify=ssl_verify)
+                if resp.status_code == 200:
+                    content = resp.content
+                else:
+                    print(f"Failed to download tile (status {resp.status_code}): {url}")
+            except requests.exceptions.SSLError:
+                # Optionally retry with certificate verification disabled
+                if allow_insecure_ssl:
+                    try:
+                        resp = requests.get(url, timeout=timeout_s, verify=False)
+                        if resp.status_code == 200:
+                            content = resp.content
+                        else:
+                            print(f"Failed to download tile (status {resp.status_code}) with insecure SSL: {url}")
+                    except requests.exceptions.RequestException as e:
+                        # Optionally try HTTP fallback
+                        if allow_http_fallback and url.lower().startswith("https://"):
+                            http_url = "http://" + url.split("://", 1)[1]
+                            try:
+                                resp = requests.get(http_url, timeout=timeout_s)
+                                if resp.status_code == 200:
+                                    content = resp.content
+                                else:
+                                    print(f"Failed to download tile over HTTP (status {resp.status_code}): {http_url}")
+                            except requests.exceptions.RequestException as e2:
+                                print(f"HTTP fallback failed for tile: {http_url} ({e2})")
+                        else:
+                            print(f"SSL error downloading tile: {url} ({e})")
+                else:
+                    if allow_http_fallback and url.lower().startswith("https://"):
+                        http_url = "http://" + url.split("://", 1)[1]
+                        try:
+                            resp = requests.get(http_url, timeout=timeout_s)
+                            if resp.status_code == 200:
+                                content = resp.content
+                            else:
+                                print(f"Failed to download tile over HTTP (status {resp.status_code}): {http_url}")
+                        except requests.exceptions.RequestException as e:
+                            print(f"HTTP fallback failed for tile: {http_url} ({e})")
+                    else:
+                        print(f"SSL error downloading tile: {url}")
+            except requests.exceptions.RequestException as e:
+                # Network error (timeout/connection). Try HTTP if allowed.
+                if allow_http_fallback and url.lower().startswith("https://"):
+                    http_url = "http://" + url.split("://", 1)[1]
+                    try:
+                        resp = requests.get(http_url, timeout=timeout_s)
+                        if resp.status_code == 200:
+                            content = resp.content
+                        else:
+                            print(f"Failed to download tile over HTTP (status {resp.status_code}): {http_url}")
+                    except requests.exceptions.RequestException as e2:
+                        print(f"HTTP fallback failed for tile: {http_url} ({e2})")
+                else:
+                    print(f"Error downloading tile: {url} ({e})")
+
+            if content is not None:
+                try:
+                    tiles[(x, y)] = Image.open(BytesIO(content))
+                except Exception as e:
+                    print(f"Error decoding tile image for {url}: {e}")
     
     return tiles, (min(min_x, max_x), min(min_y, max_y), max(min_x, max_x), max(min_y, max_y))
 
@@ -231,6 +291,11 @@ def save_as_geotiff(image, polygon, zoom, bbox, bounds, output_path):
     pixel_size_x = (lower_right_x - upper_left_x) / image.width
     pixel_size_y = (upper_left_y - lower_right_y) / image.height
     
+    # Ensure output directory exists
+    out_dir = os.path.dirname(output_path)
+    if out_dir:
+        os.makedirs(out_dir, exist_ok=True)
+
     # Create GeoTIFF
     driver = gdal.GetDriverByName('GTiff')
     dataset = driver.Create(output_path, image.width, image.height, 3, gdal.GDT_Byte)
@@ -249,7 +314,7 @@ def save_as_geotiff(image, polygon, zoom, bbox, bounds, output_path):
     
     dataset = None
 
-def save_oemj_as_geotiff(polygon, filepath, zoom=16):
+def save_oemj_as_geotiff(polygon, filepath, zoom=16, *, ssl_verify=True, allow_insecure_ssl=False, allow_http_fallback=False, timeout_s=30):
     """Download and save OpenEarthMap Japan imagery as a georeferenced GeoTIFF file.
     
     This is the main function that orchestrates the entire process of downloading,
@@ -281,7 +346,14 @@ def save_oemj_as_geotiff(polygon, filepath, zoom=16):
         - The output GeoTIFF will be in Web Mercator projection (EPSG:3857)
     """
     try:
-        tiles, bounds = download_tiles(polygon, zoom)
+        tiles, bounds = download_tiles(
+            polygon,
+            zoom,
+            ssl_verify=ssl_verify,
+            allow_insecure_ssl=allow_insecure_ssl,
+            allow_http_fallback=allow_http_fallback,
+            timeout_s=timeout_s,
+        )
         if not tiles:
             raise ValueError("No tiles were downloaded. Please check the polygon coordinates and zoom level.")
 

voxcity/downloader/osm.py

@@ -370,7 +370,7 @@ def create_rings_from_ways(way_ids, ways, nodes):
     
     return rings
 
-def load_gdf_from_openstreetmap(rectangle_vertices):
+def load_gdf_from_openstreetmap(rectangle_vertices, floor_height=3.0):
     """Download and process building footprint data from OpenStreetMap.
     
     This function:
@@ -471,7 +471,7 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
         """
         return [coord for coord in geometry]  # Keep original order since already (lon, lat)
     
-    def get_height_from_properties(properties):
+    def get_height_from_properties(properties, floor_height=3.0):
         """Helper function to extract height from properties.
         
         Args:
@@ -487,9 +487,25 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
             except ValueError:
                 pass
         
+        # Infer from floors when available
+        floors_candidates = [
+            properties.get('building:levels'),
+            properties.get('levels'),
+            properties.get('num_floors')
+        ]
+        for floors in floors_candidates:
+            if floors is None:
+                continue
+            try:
+                floors_val = float(floors)
+                if floors_val > 0:
+                    return float(floor_height) * floors_val
+            except ValueError:
+                continue
+        
         return 0  # Default height if no valid height found
     
-    def extract_properties(element):
+    def extract_properties(element, floor_height=3.0):
         """Helper function to extract and process properties from an element.
         
         Args:
@@ -501,7 +517,7 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
         properties = element.get('tags', {})
         
         # Get height (now using the helper function)
-        height = get_height_from_properties(properties)
+        height = get_height_from_properties(properties, floor_height=floor_height)
             
         # Get min_height and min_level
         min_height = properties.get('min_height', '0')
@@ -526,7 +542,7 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
             "is_inner": False,
             "levels": levels,
             "height_source": "explicit" if properties.get('height') or properties.get('building:height') 
-                               else "levels" if levels is not None 
+                               else "levels" if (levels is not None) or (properties.get('num_floors') is not None)
                                else "default",
             "min_level": min_level if min_level != '0' else None,
             "building": properties.get('building', 'no'),
@@ -584,13 +600,13 @@ def load_gdf_from_openstreetmap(rectangle_vertices):
         if element['type'] == 'way':
             if 'geometry' in element:
                 coords = [(node['lon'], node['lat']) for node in element['geometry']]
-                properties = extract_properties(element)
+                properties = extract_properties(element, floor_height=floor_height)
                 feature = create_polygon_feature(coords, properties)
                 if feature:
                     features.append(feature)
                     
         elif element['type'] == 'relation':
-            properties = extract_properties(element)
+            properties = extract_properties(element, floor_height=floor_height)
             
             # Process each member of the relation
             for member in element['members']:

voxcity/downloader/overture.py

@@ -254,7 +254,7 @@ def join_gdfs_vertically(gdf1, gdf2):
     
     return combined_gdf
 
-def load_gdf_from_overture(rectangle_vertices):
+def load_gdf_from_overture(rectangle_vertices, floor_height=3.0):
     """
     Download and process building footprint data from Overture Maps.
     
@@ -287,6 +287,31 @@ def load_gdf_from_overture(rectangle_vertices):
     # Combine both datasets into a single comprehensive building dataset
     joined_building_gdf = join_gdfs_vertically(building_gdf, building_part_gdf)
 
+    # Ensure numeric height and infer from floors when missing
+    try:
+        joined_building_gdf['height'] = pd.to_numeric(joined_building_gdf.get('height', None), errors='coerce')
+    except Exception:
+        # Create height column if missing
+        joined_building_gdf['height'] = None
+        joined_building_gdf['height'] = pd.to_numeric(joined_building_gdf['height'], errors='coerce')
+
+    # Combine possible floors columns (first non-null among candidates)
+    floors_candidates = []
+    for col in ['building:levels', 'levels', 'num_floors', 'floors']:
+        if col in joined_building_gdf.columns:
+            floors_candidates.append(pd.to_numeric(joined_building_gdf[col], errors='coerce'))
+    if floors_candidates:
+        floors_series = floors_candidates[0]
+        for s in floors_candidates[1:]:
+            floors_series = floors_series.combine_first(s)
+        # Infer height where height is NaN/<=0 and floors > 0
+        mask_missing_height = (~joined_building_gdf['height'].notna()) | (joined_building_gdf['height'] <= 0)
+        if isinstance(floor_height, (int, float)):
+            inferred = floors_series * float(floor_height)
+        else:
+            inferred = floors_series * 3.0
+        joined_building_gdf.loc[mask_missing_height & (floors_series > 0), 'height'] = inferred
+
     # Assign sequential IDs based on the final dataset index
     joined_building_gdf['id'] = joined_building_gdf.index