voxcity 0.6.28__tar.gz → 0.6.29__tar.gz

{voxcity-0.6.28 → voxcity-0.6.29}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "voxcity"
-version = "0.6.28"
+version = "0.6.29"
 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.28 → voxcity-0.6.29}/src/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-0.6.28 → voxcity-0.6.29}/src/voxcity/exporter/obj.py

@@ -681,6 +681,7 @@ def export_netcdf_to_obj(
     classes_to_show=None,
     voxel_color_scheme="default",
     max_faces_warn=1_000_000,
+    export_vox_base=True,
 ):
     """
     Export two OBJ/MTL files using the same local meter frame:
@@ -718,6 +719,8 @@ def export_netcdf_to_obj(
         classes_to_show (set[int]|None): Optional subset of voxel classes to export; None -> all present (except 0).
         voxel_color_scheme (str): Color scheme name passed to get_voxel_color_map.
         max_faces_warn (int): Warn if a single class exceeds this many faces.
+        export_vox_base (bool): If False, skip exporting VoxCity OBJ/MTL; VoxCity input
+            is still used to define the shared coordinate system for scalar OBJ.
 
     Returns:
         dict: Paths of written files: keys 'vox_obj','vox_mtl','tm_obj','tm_mtl' (values may be None).
@@ -1345,27 +1348,28 @@ def export_netcdf_to_obj(
     vox_meshes = {}
     tm_meshes = {}
 
-    present = set(np.unique(Av_kji))
-    present.discard(0)
-    if classes_to_show is not None:
-        present &= set(classes_to_show)
-    present = sorted(present)
-
-    faces_total = 0
-    voxel_color_map = get_voxel_color_map(color_scheme=voxel_color_scheme)
-    for cls in present:
-        mask = Av_kji == cls
-        if not np.any(mask):
-            continue
-        rgb = voxel_color_map.get(int(cls), [200, 200, 200])
-        if greedy_vox:
-            m_cls, faces = make_voxel_mesh_uniform_color_greedy(mask, Xv_s, Yv_s, Zv_s, rgb=rgb, name=f"class_{int(cls)}")
-        else:
-            m_cls, faces = make_voxel_mesh_uniform_color(mask, Xv_s, Yv_s, Zv_s, rgb=rgb, name=f"class_{int(cls)}")
-        if m_cls is not None:
-            vox_meshes[f"voxclass_{int(cls)}"] = m_cls
-            faces_total += faces
-    print(f"[VoxCity] total voxel faces: {faces_total:,}")
+    if export_vox_base:
+        present = set(np.unique(Av_kji))
+        present.discard(0)
+        if classes_to_show is not None:
+            present &= set(classes_to_show)
+        present = sorted(present)
+
+        faces_total = 0
+        voxel_color_map = get_voxel_color_map(color_scheme=voxel_color_scheme)
+        for cls in present:
+            mask = Av_kji == cls
+            if not np.any(mask):
+                continue
+            rgb = voxel_color_map.get(int(cls), [200, 200, 200])
+            if greedy_vox:
+                m_cls, faces = make_voxel_mesh_uniform_color_greedy(mask, Xv_s, Yv_s, Zv_s, rgb=rgb, name=f"class_{int(cls)}")
+            else:
+                m_cls, faces = make_voxel_mesh_uniform_color(mask, Xv_s, Yv_s, Zv_s, rgb=rgb, name=f"class_{int(cls)}")
+            if m_cls is not None:
+                vox_meshes[f"voxclass_{int(cls)}"] = m_cls
+                faces_total += faces
+        print(f"[VoxCity] total voxel faces: {faces_total:,}")
 
     iso_meshes = build_tm_isosurfaces_regular_grid(
         A_scalar=A_s,
@@ -1390,7 +1394,7 @@ def export_netcdf_to_obj(
 
     os.makedirs(output_dir, exist_ok=True)
     obj_vox = mtl_vox = obj_tm = mtl_tm = None
-    if vox_meshes:
+    if export_vox_base and vox_meshes:
         obj_vox, mtl_vox = save_obj_with_mtl_and_normals(vox_meshes, output_dir, vox_base_filename)
     if tm_meshes:
         obj_tm, mtl_tm = save_obj_with_mtl_and_normals(tm_meshes, output_dir, tm_base_filename)

{voxcity-0.6.28 → voxcity-0.6.29}/src/voxcity/generator.py

@@ -147,7 +147,26 @@ def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, **kwar
         save_geotiff_dynamic_world_v1(roi, geotiff_path, dynamic_world_date)
     elif source == 'OpenEarthMapJapan':
         # Japan-specific land cover dataset
-        save_oemj_as_geotiff(rectangle_vertices, geotiff_path)   
+        # Allow SSL/HTTP options to be passed through kwargs
+        ssl_verify = kwargs.get('ssl_verify', kwargs.get('verify', True))
+        allow_insecure_ssl = kwargs.get('allow_insecure_ssl', False)
+        allow_http_fallback = kwargs.get('allow_http_fallback', False)
+        timeout_s = kwargs.get('timeout', 30)
+
+        save_oemj_as_geotiff(
+            rectangle_vertices,
+            geotiff_path,
+            ssl_verify=ssl_verify,
+            allow_insecure_ssl=allow_insecure_ssl,
+            allow_http_fallback=allow_http_fallback,
+            timeout_s=timeout_s,
+        )
+        # Ensure the file was actually created before proceeding
+        if not os.path.exists(geotiff_path):
+            raise FileNotFoundError(
+                f"OEMJ download failed; expected GeoTIFF not found: {geotiff_path}. "
+                "You can try setting ssl_verify=False or allow_http_fallback=True in kwargs."
+            )   
     elif source == 'OpenStreetMap':
         # Vector-based land cover from OpenStreetMap
         # This bypasses the GeoTIFF workflow and gets data directly as GeoJSON