voxcity 0.6.17__tar.gz → 0.6.18__tar.gz

{voxcity-0.6.17 → voxcity-0.6.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: voxcity
-Version: 0.6.17
+Version: 0.6.18
 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
 Author: Kunihiko Fujiwara
@@ -27,6 +27,7 @@ Requires-Dist: ipyleaflet
 Requires-Dist: joblib
 Requires-Dist: lxml
 Requires-Dist: matplotlib
+Requires-Dist: netCDF4
 Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: osmnx
@@ -51,6 +52,7 @@ Requires-Dist: timezonefinder
 Requires-Dist: tqdm
 Requires-Dist: trimesh
 Requires-Dist: typer
+Requires-Dist: xarray
 Project-URL: bugs, https://github.com/kunifujiwara/voxcity/issues
 Project-URL: changelog, https://github.com/kunifujiwara/voxcity/blob/master/changelog.md
 Project-URL: homepage, https://github.com/kunifujiwara/voxcity
@@ -232,7 +234,7 @@ Generate voxel data grids and corresponding building geoJSON:
 from voxcity.generator import get_voxcity
 
 voxcity_grid, building_height_grid, building_min_height_grid, \
-building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, \
+building_id_grid, canopy_height_grid, canopy_bottom_height_grid, land_cover_grid, dem_grid, \
 building_gdf = get_voxcity(
     rectangle_vertices,
     building_source,

{voxcity-0.6.17 → voxcity-0.6.18}/README.md

@@ -174,7 +174,7 @@ Generate voxel data grids and corresponding building geoJSON:
 from voxcity.generator import get_voxcity
 
 voxcity_grid, building_height_grid, building_min_height_grid, \
-building_id_grid, canopy_height_grid, land_cover_grid, dem_grid, \
+building_id_grid, canopy_height_grid, canopy_bottom_height_grid, land_cover_grid, dem_grid, \
 building_gdf = get_voxcity(
     rectangle_vertices,
     building_source,

{voxcity-0.6.17 → voxcity-0.6.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "voxcity"
-version = "0.6.17"
+version = "0.6.18"
 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"
@@ -56,6 +56,8 @@ pyvista = "*"
 IPython = "*"
 lxml = "*"
 scikit-learn = "*"
+xarray = "*"
+netCDF4 = "*"
 
 [tool.poetry.group.dev.dependencies]
 coverage = "*"

{voxcity-0.6.17 → voxcity-0.6.18}/src/voxcity/exporter/__init__.py

@@ -1,4 +1,5 @@
 from .envimet import *
 from .magicavoxel import *
 from .obj import *
-from .cityles import *
+from .cityles import *
+from .netcdf import *

voxcity-0.6.18/src/voxcity/exporter/netcdf.py

@@ -0,0 +1,211 @@
+"""
+NetCDF export utilities for VoxCity.
+
+This module provides functions to convert a 3D voxel grid produced by
+`voxcity.generator.get_voxcity` into a NetCDF file for portable storage
+and downstream analysis.
+
+The voxel values follow VoxCity conventions (see generator.create_3d_voxel):
+- -3: built structures (buildings)
+- -2: vegetation canopy
+- -1: subsurface/underground
+- >= 1: ground-surface land cover code (offset by +1 from source classes)
+
+Notes
+-----
+- This writer prefers xarray for NetCDF export. If xarray is not installed,
+  a clear error is raised with installation hints.
+- Coordinates are stored as index-based distances in meters from the grid
+  origin along the y, x, and z axes. Geographic metadata such as the
+  `rectangle_vertices` and `meshsize_m` are stored as global attributes to
+  avoid making assumptions about map projection or geodesic conversions.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Mapping, MutableMapping, Optional, Sequence, Tuple
+import json
+
+import numpy as np
+
+try:  # xarray is the preferred backend for NetCDF writing
+    import xarray as xr  # type: ignore
+    XR_AVAILABLE = True
+except Exception:  # pragma: no cover - optional dependency
+    XR_AVAILABLE = False
+
+__all__ = [
+    "voxel_to_xarray_dataset",
+    "save_voxel_netcdf",
+]
+
+
+def _ensure_parent_dir(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+def voxel_to_xarray_dataset(
+    voxcity_grid: np.ndarray,
+    voxel_size_m: float,
+    rectangle_vertices: Optional[Sequence[Tuple[float, float]]] = None,
+    extra_attrs: Optional[Mapping[str, Any]] = None,
+) -> "xr.Dataset":
+    """Create an xarray Dataset from a VoxCity voxel grid.
+
+    Parameters
+    ----------
+    voxcity_grid
+        3D numpy array with shape (rows, cols, levels) as returned by
+        `get_voxcity` (first element of the returned tuple).
+    voxel_size_m
+        Voxel size (mesh size) in meters.
+    rectangle_vertices
+        Optional polygon vertices defining the area of interest in
+        longitude/latitude pairs, typically the same list passed to
+        `get_voxcity`.
+    extra_attrs
+        Optional mapping of additional global attributes to store in the
+        dataset.
+
+    Returns
+    -------
+    xr.Dataset
+        Dataset containing one DataArray named "voxels" with dims (y, x, z)
+        and coordinate variables in meters from origin.
+    """
+    if not XR_AVAILABLE:  # pragma: no cover - optional dependency
+        raise ImportError(
+            "xarray is required to export NetCDF. Install with: \n"
+            "  pip install xarray netCDF4\n"
+            "or: \n"
+            "  pip install xarray h5netcdf"
+        )
+
+    if voxcity_grid.ndim != 3:
+        raise ValueError(
+            f"voxcity_grid must be 3D (rows, cols, levels); got shape={voxcity_grid.shape}"
+        )
+
+    rows, cols, levels = voxcity_grid.shape
+
+    # Coordinate vectors in meters relative to the grid origin
+    # y increases with row index, x increases with column index
+    y_m = np.arange(rows, dtype=float) * float(voxel_size_m)
+    x_m = np.arange(cols, dtype=float) * float(voxel_size_m)
+    z_m = np.arange(levels, dtype=float) * float(voxel_size_m)
+
+    ds_attrs: MutableMapping[str, Any] = {
+        "title": "VoxCity voxel grid",
+        "institution": "VoxCity",
+        "source": "voxcity.generator.create_3d_voxel",
+        "Conventions": "CF-1.10 (partial)",
+        # NetCDF attributes must be basic types; serialize complex structures as strings
+        "vox_value_meanings": [
+            "-3: building",
+            "-2: vegetation_canopy",
+            "-1: subsurface",
+            ">=1: surface_land_cover_code (offset +1)",
+        ],
+        "meshsize_m": float(voxel_size_m),
+        # Store vertices as JSON string for portability
+        "rectangle_vertices_lonlat_json": (
+            json.dumps([[float(v[0]), float(v[1])] for v in rectangle_vertices])
+            if rectangle_vertices is not None else ""
+        ),
+        "vertical_reference": "z=0 corresponds to min(DEM) as used in voxel construction",
+    }
+    if extra_attrs:
+        ds_attrs.update(dict(extra_attrs))
+
+    da = xr.DataArray(
+        voxcity_grid,
+        dims=("y", "x", "z"),
+        coords={
+            "y": ("y", y_m, {"units": "m", "long_name": "row_distance_from_origin"}),
+            "x": ("x", x_m, {"units": "m", "long_name": "col_distance_from_origin"}),
+            "z": ("z", z_m, {"units": "m", "positive": "up", "long_name": "height_above_vertical_origin"}),
+        },
+        name="voxels",
+        attrs={
+            "units": "category",
+            "description": "VoxCity voxel values; see global attribute 'vox_value_meanings'",
+        },
+    )
+
+    ds = xr.Dataset({"voxels": da}, attrs=ds_attrs)
+    return ds
+
+
+def save_voxel_netcdf(
+    voxcity_grid: np.ndarray,
+    output_path: str | Path,
+    voxel_size_m: float,
+    rectangle_vertices: Optional[Sequence[Tuple[float, float]]] = None,
+    extra_attrs: Optional[Mapping[str, Any]] = None,
+    engine: Optional[str] = None,
+) -> str:
+    """Save a VoxCity voxel grid to a NetCDF file.
+
+    Parameters
+    ----------
+    voxcity_grid
+        3D numpy array (rows, cols, levels) of voxel values.
+    output_path
+        Path to the NetCDF file to be written. Parent directories will be
+        created as needed.
+    voxel_size_m
+        Voxel size in meters.
+    rectangle_vertices
+        Optional list of (lon, lat) pairs defining the area of interest.
+        Stored as dataset metadata only.
+    extra_attrs
+        Optional additional global attributes to embed in the dataset.
+    engine
+        Optional xarray engine, e.g., "netcdf4" or "h5netcdf". If not provided,
+        xarray will choose a default; on failure we retry alternate engines.
+
+    Returns
+    -------
+    str
+        The string path to the written NetCDF file.
+    """
+    if not XR_AVAILABLE:  # pragma: no cover - optional dependency
+        raise ImportError(
+            "xarray is required to export NetCDF. Install with: \n"
+            "  pip install xarray netCDF4\n"
+            "or: \n"
+            "  pip install xarray h5netcdf"
+        )
+
+    path = Path(output_path)
+    _ensure_parent_dir(path)
+
+    ds = voxel_to_xarray_dataset(
+        voxcity_grid=voxcity_grid,
+        voxel_size_m=voxel_size_m,
+        rectangle_vertices=rectangle_vertices,
+        extra_attrs=extra_attrs,
+    )
+
+    # Attempt to save with the requested or default engine; on failure, try a fallback
+    tried_engines = []
+    try:
+        ds.to_netcdf(path, engine=engine)  # type: ignore[call-arg]
+    except Exception as e_first:  # pragma: no cover - I/O backend dependent
+        tried_engines.append(engine or "default")
+        for fallback in ("netcdf4", "h5netcdf"):
+            try:
+                ds.to_netcdf(path, engine=fallback)  # type: ignore[call-arg]
+                break
+            except Exception:
+                tried_engines.append(fallback)
+        else:
+            raise RuntimeError(
+                f"Failed to write NetCDF using engines: {tried_engines}. "
+                f"Original error: {e_first}"
+            )
+
+    return str(path)
+
+

{voxcity-0.6.17 → voxcity-0.6.18}/src/voxcity/exporter/obj.py

@@ -652,4 +652,541 @@ def grid_to_obj(value_array_ori, dem_array_ori, output_dir, file_name, cell_size
             f.write(f'd {a:.6f}\n')                     # Transparency (alpha)
             f.write('\n')
 
-    print(f'OBJ and MTL files have been generated in {output_dir} with the base name "{file_name}".')
+    print(f'OBJ and MTL files have been generated in {output_dir} with the base name "{file_name}".')
+
+
+def export_netcdf_to_obj(
+    voxcity_nc,
+    scalar_nc,
+    lonlat_txt,
+    output_dir,
+    vox_base_filename="voxcity_objects",
+    tm_base_filename="tm_isosurfaces",
+    scalar_var="tm",
+    scalar_building_value=-999.99,
+    scalar_building_tol=1e-4,
+    stride_vox=(1, 1, 1),
+    stride_scalar=(1, 1, 1),
+    contour_levels=24,
+    cmap_name="magma",
+    opacity_points=None,
+    max_opacity=0.10,
+    classes_to_show=None,
+    voxel_color_scheme="default",
+    max_faces_warn=1_000_000,
+):
+    """
+    Export two OBJ/MTL files using the same local meter frame:
+    - VoxCity voxels: opaque, per-class color, fixed face winding and normals
+    - Scalar iso-surfaces: colormap colors with variable transparency
+
+    The two outputs share the same XY origin and axes (X east, Y north, Z up),
+    anchored at the minimum lon/lat of the VoxCity bounding rectangle.
+
+    Args:
+        voxcity_nc (str): Path to VoxCity NetCDF (must include variable 'voxels' and coords 'x','y','z').
+        scalar_nc (str): Path to scalar NetCDF containing variable specified by scalar_var.
+        lonlat_txt (str): Text file with columns: i j lon lat (1-based indices) describing the scalar grid georef.
+        output_dir (str): Directory to write results.
+        vox_base_filename (str): Base filename for VoxCity OBJ/MTL.
+        tm_base_filename (str): Base filename for scalar iso-surfaces OBJ/MTL.
+        scalar_var (str): Name of scalar variable in scalar_nc.
+        scalar_building_value (float): Value used in scalar field to mark buildings (to be masked).
+        scalar_building_tol (float): Tolerance for building masking (isclose).
+        stride_vox (tuple[int,int,int]): Downsampling strides for VoxCity (z,y,x) in voxels.
+        stride_scalar (tuple[int,int,int]): Downsampling strides for scalar (k,j,i).
+        contour_levels (int): Number of iso-surface levels between vmin and vmax.
+        cmap_name (str): Matplotlib colormap name for iso-surfaces.
+        opacity_points (list[tuple[float,float]]|None): Transfer function control points (value, alpha in [0..1]).
+        max_opacity (float): Global max opacity multiplier for iso-surfaces (0..1).
+        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.
+
+    Returns:
+        dict: Paths of written files: keys 'vox_obj','vox_mtl','tm_obj','tm_mtl' (values may be None).
+    """
+    import json
+    import numpy as np
+    import os
+    import xarray as xr
+    import trimesh
+
+    try:
+        from skimage import measure as skim
+    except Exception as e:  # pragma: no cover - optional dependency
+        raise ImportError(
+            "scikit-image is required for iso-surface generation. Install 'scikit-image'."
+        ) from e
+
+    from matplotlib import cm
+
+    if opacity_points is None:
+        opacity_points = [(-0.2, 0.00), (2.0, 1.00)]
+
+    def find_dims(ds):
+        lvl = ["k", "level", "lev", "z", "height", "alt", "plev"]
+        yy = ["j", "y", "south_north", "lat", "latitude"]
+        xx = ["i", "x", "west_east", "lon", "longitude"]
+        tt = ["time", "Times"]
+
+        def pick(cands):
+            for c in cands:
+                if c in ds.dims:
+                    return c
+            return None
+
+        t = pick(tt)
+        k = pick(lvl)
+        j = pick(yy)
+        i = pick(xx)
+        if (k is None or j is None or i is None) and len(ds.dims) >= 3:
+            dims = list(ds.dims)
+            k = k or dims[0]
+            j = j or dims[-2]
+            i = i or dims[-1]
+        return t, k, j, i
+
+    def squeeze_to_kji(da, tname, kname, jname, iname, time_index=0):
+        if tname and tname in da.dims:
+            da = da.isel({tname: time_index})
+        for d in list(da.dims):
+            if d not in (kname, jname, iname):
+                da = da.isel({d: 0})
+        return da.transpose(*(d for d in (kname, jname, iname) if d in da.dims))
+
+    def downsample3(a, sk, sj, si):
+        return a[:: max(1, sk), :: max(1, sj), :: max(1, si)]
+
+    def clip_minmax(arr, frac):
+        v = np.asarray(arr)
+        v = v[np.isfinite(v)]
+        if v.size == 0:
+            return 0.0, 1.0
+        if frac <= 0:
+            return float(np.nanmin(v)), float(np.nanmax(v))
+        vmin_ = float(np.nanpercentile(v, 100 * frac))
+        vmax_ = float(np.nanpercentile(v, 100 * (1 - frac)))
+        if vmin_ >= vmax_:
+            vmin_, vmax_ = float(np.nanmin(v)), float(np.nanmax(v))
+        return vmin_, vmax_
+
+    def meters_per_degree(lat_rad):
+        m_per_deg_lat = 111132.92 - 559.82 * np.cos(2 * lat_rad) + 1.175 * np.cos(4 * lat_rad) - 0.0023 * np.cos(6 * lat_rad)
+        m_per_deg_lon = 111412.84 * np.cos(lat_rad) - 93.5 * np.cos(3 * lat_rad) + 0.118 * np.cos(5 * lat_rad)
+        return m_per_deg_lat, m_per_deg_lon
+
+    def opacity_at(v, points):
+        if not points:
+            return 0.0 if np.isscalar(v) else np.zeros_like(v)
+        pts = sorted((float(x), float(a)) for x, a in points)
+        xs = np.array([p[0] for p in pts], dtype=float)
+        as_ = np.array([p[1] for p in pts], dtype=float)
+        v_arr = np.asarray(v, dtype=float)
+        out = np.empty_like(v_arr, dtype=float)
+        out[v_arr <= xs[0]] = as_[0]
+        out[v_arr >= xs[-1]] = as_[-1]
+        idx = np.searchsorted(xs, v_arr, side="right") - 1
+        idx = np.clip(idx, 0, len(xs) - 2)
+        x0, x1 = xs[idx], xs[idx + 1]
+        a0, a1 = as_[idx], as_[idx + 1]
+        t = np.where(x1 > x0, (v_arr - x0) / (x1 - x0), 0.0)
+        mid = (v_arr > xs[0]) & (v_arr < xs[-1])
+        out[mid] = a0[mid] + t[mid] * (a1[mid] - a0[mid])
+        return out.item() if np.isscalar(v) else out
+
+    def _exposed_face_masks(occ):
+        K, J, I = occ.shape
+        p = np.pad(occ, ((0, 0), (0, 0), (0, 1)), constant_values=False)
+        posx = occ & (~p[..., 1:])
+        p = np.pad(occ, ((0, 0), (0, 0), (1, 0)), constant_values=False)
+        negx = occ & (~p[..., :-1])
+        p = np.pad(occ, ((0, 0), (0, 1), (0, 0)), constant_values=False)
+        posy = occ & (~p[:, 1:, :])
+        p = np.pad(occ, ((0, 0), (1, 0), (0, 0)), constant_values=False)
+        negy = occ & (~p[:, :-1, :])
+        p = np.pad(occ, ((0, 1), (0, 0), (0, 0)), constant_values=False)
+        posz = occ & (~p[1:, :, :])
+        p = np.pad(occ, ((1, 0), (0, 0), (0, 0)), constant_values=False)
+        negz = occ & (~p[:-1, :, :])
+        return posx, negx, posy, negy, posz, negz
+
+    def _emit_faces_trimesh(k, j, i, plane, X, Y, Z, start_idx):
+        N = k.size
+        if N == 0:
+            return np.empty((0, 3)), np.empty((0, 3), dtype=np.int64), start_idx
+
+        dx = (X[1] - X[0]) if len(X) > 1 else 1.0
+        dy = (Y[1] - Y[0]) if len(Y) > 1 else 1.0
+        dz = (Z[1] - Z[0]) if len(Z) > 1 else 1.0
+
+        x = X[i].astype(np.float64)
+        y = Y[j].astype(np.float64)
+        z = Z[k].astype(np.float64)
+        hx, hy, hz = dx / 2.0, dy / 2.0, dz / 2.0
+
+        if plane == "+x":
+            P = np.column_stack([x + hx, y - hy, z - hz])
+            Q = np.column_stack([x + hx, y + hy, z - hz])
+            R = np.column_stack([x + hx, y + hy, z + hz])
+            S = np.column_stack([x + hx, y - hy, z + hz])
+            order = "default"
+        elif plane == "-x":
+            P = np.column_stack([x - hx, y - hy, z + hz])
+            Q = np.column_stack([x - hx, y + hy, z + hz])
+            R = np.column_stack([x - hx, y + hy, z - hz])
+            S = np.column_stack([x - hx, y - hy, z - hz])
+            order = "default"
+        elif plane == "+y":
+            P = np.column_stack([x - hx, y + hy, z - hz])
+            Q = np.column_stack([x + hx, y + hy, z - hz])
+            R = np.column_stack([x + hx, y + hy, z + hz])
+            S = np.column_stack([x - hx, y + hy, z + hz])
+            order = "flip"  # enforce outward normals
+        elif plane == "-y":
+            P = np.column_stack([x - hx, y - hy, z + hz])
+            Q = np.column_stack([x + hx, y - hy, z + hz])
+            R = np.column_stack([x + hx, y - hy, z - hz])
+            S = np.column_stack([x - hx, y - hy, z - hz])
+            order = "flip"
+        elif plane == "+z":
+            P = np.column_stack([x - hx, y - hy, z + hz])
+            Q = np.column_stack([x + hx, y - hy, z + hz])
+            R = np.column_stack([x + hx, y + hy, z + hz])
+            S = np.column_stack([x - hx, y + hy, z + hz])
+            order = "default"
+        else:  # "-z"
+            P = np.column_stack([x - hx, y + hy, z - hz])
+            Q = np.column_stack([x + hx, y + hy, z - hz])
+            R = np.column_stack([x + hx, y - hy, z - hz])
+            S = np.column_stack([x - hx, y - hy, z - hz])
+            order = "default"
+
+        verts = np.vstack([P, Q, R, S])
+        a = np.arange(N, dtype=np.int64) + start_idx
+        b = a + N
+        c = a + 2 * N
+        d = a + 3 * N
+
+        if order == "default":
+            tris = np.vstack([np.column_stack([a, b, c]), np.column_stack([a, c, d])])
+        else:
+            tris = np.vstack([np.column_stack([a, c, b]), np.column_stack([a, d, c])])
+
+        return verts, tris, start_idx + 4 * N
+
+    def make_voxel_mesh_uniform_color(occ_mask, X, Y, Z, rgb, name="class"):
+        posx, negx, posy, negy, posz, negz = _exposed_face_masks(occ_mask.astype(bool))
+        total_faces = int(posx.sum() + negx.sum() + posy.sum() + negy.sum() + posz.sum() + negz.sum())
+        if total_faces == 0:
+            return None, 0
+        if total_faces > max_faces_warn:
+            print(f"  Warning: {name} faces={total_faces:,} (> {max_faces_warn:,}). Consider increasing stride.")
+
+        verts_all, tris_all, start_idx = [], [], 0
+        for plane, mask in (("+x", posx), ("-x", negx), ("+y", posy), ("-y", negy), ("+z", posz), ("-z", negz)):
+            idx = np.argwhere(mask)
+            if idx.size == 0:
+                continue
+            k, j, i = idx[:, 0], idx[:, 1], idx[:, 2]
+            Vp, Tp, start_idx = _emit_faces_trimesh(k, j, i, plane, X, Y, Z, start_idx)
+            verts_all.append(Vp)
+            tris_all.append(Tp)
+
+        V = np.vstack(verts_all)
+        F = np.vstack(tris_all)
+        mesh = trimesh.Trimesh(vertices=V, faces=F, process=False)
+        rgba = np.array([int(rgb[0]), int(rgb[1]), int(rgb[2]), 255], dtype=np.uint8)
+        mesh.visual.face_colors = np.tile(rgba, (len(F), 1))
+        return mesh, len(F)
+
+    def build_tm_isosurfaces_regular_grid(A_scalar, vmin, vmax, levels, dx, dy, dz, origin_xyz, cmap_name, opacity_points, max_opacity):
+        cmap = cm.get_cmap(cmap_name)
+        meshes = []
+        if levels <= 0:
+            return meshes
+        iso_vals = np.linspace(vmin, vmax, int(levels))
+        for iso in iso_vals:
+            a_base = float(opacity_at(iso, opacity_points or []))
+            a_base = min(max(a_base, 0.0), 1.0)
+            alpha = a_base * max_opacity
+            if alpha <= 0.0:
+                continue
+            try:
+                verts, faces, _, _ = skim.marching_cubes(A_scalar, level=iso, spacing=(dz, dy, dx))
+            except Exception:
+                continue
+            if len(verts) == 0 or len(faces) == 0:
+                continue
+            V = verts[:, [2, 1, 0]].astype(np.float64)
+            V += np.array(origin_xyz, dtype=np.float64)[None, :]
+            m = trimesh.Trimesh(vertices=V, faces=faces.astype(np.int64), process=False)
+            t = 0.0 if vmax <= vmin else (iso - vmin) / (vmax - vmin)
+            r, g, b, _ = cmap(np.clip(t, 0.0, 1.0))
+            rgba = (
+                int(round(255 * r)),
+                int(round(255 * g)),
+                int(round(255 * b)),
+                int(round(255 * alpha)),
+            )
+            m.visual.face_colors = np.tile(np.array(rgba, dtype=np.uint8), (len(m.faces), 1))
+            meshes.append((iso, m, rgba))
+            print(f"Iso {iso:.4f}: faces={len(m.faces):,}, alpha={alpha:.4f}")
+        return meshes
+
+    def save_obj_with_mtl_and_normals(meshes_dict, output_path, base_filename):
+        os.makedirs(output_path, exist_ok=True)
+        obj_path = os.path.join(output_path, f"{base_filename}.obj")
+        mtl_path = os.path.join(output_path, f"{base_filename}.mtl")
+
+        def to_uint8_rgba(arr):
+            arr = np.asarray(arr)
+            if arr.dtype != np.uint8:
+                if arr.dtype.kind == "f":
+                    arr = np.clip(arr, 0.0, 1.0)
+                    arr = (arr * 255.0 + 0.5).astype(np.uint8)
+                else:
+                    arr = arr.astype(np.uint8)
+            if arr.shape[1] == 3:
+                arr = np.concatenate([arr, np.full((arr.shape[0], 1), 255, np.uint8)], axis=1)
+            return arr
+
+        color_to_id, ordered = {}, []
+
+        def mid_of(rgba):
+            if rgba not in color_to_id:
+                color_to_id[rgba] = len(ordered)
+                ordered.append(rgba)
+            return color_to_id[rgba]
+
+        for m in meshes_dict.values():
+            fc = getattr(m.visual, "face_colors", None)
+            if fc is None or len(fc) == 0:
+                mid_of((200, 200, 200, 255))
+                continue
+            for rgba in np.unique(to_uint8_rgba(fc), axis=0):
+                mid_of(tuple(int(x) for x in rgba.tolist()))
+
+        with open(mtl_path, "w") as mtl:
+            for i, (r, g, b, a) in enumerate(ordered):
+                kd = (r / 255.0, g / 255.0, b / 255.0)
+                ka = kd
+                dval = a / 255.0
+                tr = max(0.0, min(1.0, 1.0 - dval))
+                mtl.write(f"newmtl material_{i}\n")
+                mtl.write(f"Kd {kd[0]:.6f} {kd[1]:.6f} {kd[2]:.6f}\n")
+                mtl.write(f"Ka {ka[0]:.6f} {ka[1]:.6f} {ka[2]:.6f}\n")
+                mtl.write("Ks 0.000000 0.000000 0.000000\n")
+                mtl.write("Ns 0.000000\n")
+                mtl.write("illum 1\n")
+                mtl.write(f"d {dval:.6f}\n")
+                mtl.write(f"Tr {tr:.6f}\n\n")
+
+        def face_normals(V, F):
+            v0, v1, v2 = V[F[:, 0]], V[F[:, 1]], V[F[:, 2]]
+            n = np.cross(v1 - v0, v2 - v0)
+            L = np.linalg.norm(n, axis=1)
+            mask = L > 0
+            n[mask] /= L[mask][:, None]
+            if (~mask).any():
+                n[~mask] = np.array([0.0, 0.0, 1.0])
+            return n
+
+        with open(obj_path, "w") as obj:
+            obj.write(f"mtllib {os.path.basename(mtl_path)}\n")
+            v_offset = 0
+            n_offset = 0
+            for name, m in meshes_dict.items():
+                V = np.asarray(m.vertices, dtype=np.float64)
+                F = np.asarray(m.faces, dtype=np.int64)
+                if len(V) == 0 or len(F) == 0:
+                    continue
+                obj.write(f"o {name}\n")
+                obj.write("s off\n")
+                for vx, vy, vz in V:
+                    obj.write(f"v {vx:.6f} {vy:.6f} {vz:.6f}\n")
+
+                fc = getattr(m.visual, "face_colors", None)
+                if fc is None or len(fc) != len(F):
+                    fc = np.tile(np.array([200, 200, 200, 255], dtype=np.uint8), (len(F), 1))
+                else:
+                    fc = to_uint8_rgba(fc)
+                uniq, inv = np.unique(fc, axis=0, return_inverse=True)
+                color2mid = {tuple(int(x) for x in c.tolist()): mid_of(tuple(int(x) for x in c.tolist())) for c in uniq}
+
+                FN = face_normals(V, F)
+                for nx, ny, nz in FN:
+                    obj.write(f"vn {float(nx):.6f} {float(ny):.6f} {float(nz):.6f}\n")
+
+                current_mid = None
+                for i_face, face in enumerate(F):
+                    key = tuple(int(x) for x in uniq[inv[i_face]].tolist())
+                    mid = color2mid[key]
+                    if current_mid != mid:
+                        obj.write(f"usemtl material_{mid}\n")
+                        current_mid = mid
+                    a, b, c = face + 1 + v_offset
+                    ni = n_offset + i_face + 1
+                    obj.write(f"f {a}//{ni} {b}//{ni} {c}//{ni}\n")
+
+                v_offset += len(V)
+                n_offset += len(F)
+
+        return obj_path, mtl_path
+
+    # Load VoxCity
+    dsv = xr.open_dataset(voxcity_nc)
+    if "voxels" not in dsv:
+        raise KeyError("'voxels' not found in VoxCity dataset.")
+    dav = dsv["voxels"]
+    if tuple(dav.dims) != ("y", "x", "z") and all(d in dav.dims for d in ("y", "x", "z")):
+        dav = dav.transpose("y", "x", "z")
+
+    Yv = dsv["y"].values.astype(float)
+    Xv = dsv["x"].values.astype(float)
+    Zv = dsv["z"].values.astype(float)
+
+    Av = dav.values  # (y,x,z)
+    Av_kji = np.transpose(Av, (2, 0, 1))  # (K=z, J=y, I=x)
+    svz, svy, svx = stride_vox
+    Av_kji = downsample3(Av_kji, svz, svy, svx)
+    # Y flip (north-up)
+    Av_kji = Av_kji[:, ::-1, :]
+
+    Zv_s = Zv[:: max(1, svz)].astype(float)
+    Yv_s = (Yv[:: max(1, svy)] - Yv.min()).astype(float)
+    Xv_s = (Xv[:: max(1, svx)] - Xv.min()).astype(float)
+
+    # Load scalar and georeference using lon/lat table
+    dss = xr.open_dataset(scalar_nc, decode_coords="all", decode_times=True)
+    tname, kname, jname, iname = find_dims(dss)
+    if scalar_var not in dss:
+        raise KeyError(f"{scalar_var} not found in scalar dataset")
+
+    A = squeeze_to_kji(dss[scalar_var], tname, kname, jname, iname).values  # (K,J,I)
+    K0, J0, I0 = map(int, A.shape)
+
+    ll = np.loadtxt(lonlat_txt, comments="#")
+    ii = ll[:, 0].astype(int) - 1
+    jj = ll[:, 1].astype(int) - 1
+    lon = ll[:, 2].astype(float)
+    lat = ll[:, 3].astype(float)
+    I_ll = int(ii.max() + 1)
+    J_ll = int(jj.max() + 1)
+    lon_grid = np.full((J_ll, I_ll), np.nan, float)
+    lat_grid = np.full((J_ll, I_ll), np.nan, float)
+    lon_grid[jj, ii] = lon
+    lat_grid[jj, ii] = lat
+
+    Jc = min(J0, J_ll)
+    Ic = min(I0, I_ll)
+    if (Jc != J0) or (Ic != I0):
+        print(
+            f"Warning: scalar (J,I)=({J0},{I0}) vs lonlat ({J_ll},{I_ll}); using common ({Jc},{Ic})."
+        )
+    A = A[:, :Jc, :Ic]
+    lon_grid = lon_grid[:Jc, :Ic]
+    lat_grid = lat_grid[:Jc, :Ic]
+
+    ssk, ssj, ssi = stride_scalar
+    A_s = downsample3(A, ssk, ssj, ssi)
+    lon_s = lon_grid[:: max(1, ssj), :: max(1, ssi)]
+    lat_s = lat_grid[:: max(1, ssj), :: max(1, ssi)]
+    Ks, Js, Is = A_s.shape
+
+    rect = np.array(json.loads(dsv.attrs.get("rectangle_vertices_lonlat_json", "[]")), float)
+    if rect.size == 0:
+        raise RuntimeError("VoxCity attribute 'rectangle_vertices_lonlat_json' missing.")
+    lon0 = float(np.min(rect[:, 0]))
+    lat0 = float(np.min(rect[:, 1]))
+    lat_c = float(np.mean(rect[:, 1]))
+    m_per_deg_lat, m_per_deg_lon = meters_per_degree(np.deg2rad(lat_c))
+    Xs_m = (lon_s - lon0) * m_per_deg_lon
+    Ys_m = (lat_s - lat0) * m_per_deg_lat
+
+    if (kname is not None) and (kname in dss.coords):
+        zc = dss.coords[kname].values
+        if np.issubdtype(zc.dtype, np.number) and zc.ndim == 1 and len(zc) >= Ks:
+            Zk = zc.astype(float)[:: max(1, ssk)][:Ks]
+        else:
+            Zk = np.arange(Ks, dtype=float) * float(dsv.attrs.get("meshsize_m", 1.0))
+    else:
+        Zk = np.arange(Ks, dtype=float) * float(dsv.attrs.get("meshsize_m", 1.0))
+
+    # Mask scalar buildings
+    bmask_scalar = downsample3(
+        np.isclose(A, scalar_building_value, atol=scalar_building_tol), ssk, ssj, ssi
+    )
+    A_s = A_s.astype(float)
+    A_s[bmask_scalar] = np.nan
+
+    finite_vals = A_s[np.isfinite(A_s)]
+    if finite_vals.size == 0:
+        raise RuntimeError("No finite scalar values after masking.")
+    vmin, vmax = clip_minmax(finite_vals, 0.0)
+    A_s[np.isnan(A_s)] = vmin - 1e6
+
+    Xmin, Xmax = np.nanmin(Xs_m), np.nanmax(Xs_m)
+    Ymin, Ymax = np.nanmin(Ys_m), np.nanmax(Ys_m)
+    dx_s = (Xmax - Xmin) / max(1, Is - 1)
+    dy_s = (Ymax - Ymin) / max(1, Js - 1)
+    dz_s = (Zk[-1] - Zk[0]) / max(1, Ks - 1) if Ks > 1 else 1.0
+    origin_xyz = (float(Xmin), float(Ymin), float(Zk[0]))
+
+    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])
+        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,
+        vmin=vmin,
+        vmax=vmax,
+        levels=contour_levels,
+        dx=dx_s,
+        dy=dy_s,
+        dz=dz_s,
+        origin_xyz=origin_xyz,
+        cmap_name=cmap_name,
+        opacity_points=opacity_points,
+        max_opacity=max_opacity,
+    )
+    for iso, m, rgba in iso_meshes:
+        tm_meshes[f"iso_{iso:.6f}"] = m
+
+    if not vox_meshes and not tm_meshes:
+        raise RuntimeError("Nothing to export.")
+
+    os.makedirs(output_dir, exist_ok=True)
+    obj_vox = mtl_vox = obj_tm = mtl_tm = None
+    if 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)
+
+    print("Export finished.")
+    if obj_vox:
+        print(f"VoxCity OBJ: {obj_vox}")
+        print(f"VoxCity MTL: {mtl_vox}")
+    if obj_tm:
+        print(f"Scalar Iso OBJ: {obj_tm}")
+        print(f"Scalar Iso MTL: {mtl_tm}")
+
+    return {"vox_obj": obj_vox, "vox_mtl": mtl_vox, "tm_obj": obj_tm, "tm_mtl": mtl_tm}

{voxcity-0.6.17 → voxcity-0.6.18}/src/voxcity/utils/visualization.py

@@ -111,6 +111,7 @@ def get_voxel_color_map(color_scheme='default'):
         - 'pastel': Softer, muted colors for aesthetic appeal
         - 'dark_mode': Darker colors for dark backgrounds
         - 'grayscale': Black and white gradient with color accents
+        - 'white_mode': Light minimal palette for white backgrounds
         
         Thematic Schemes:
         - 'autumn': Warm reds, oranges, and browns
@@ -329,6 +330,36 @@ def get_voxel_color_map(color_scheme='default'):
             14: [230, 230, 230],  # 'No Data'
         }
 
+    elif color_scheme == 'white_mode':
+        return {
+            -99: [0, 0, 0],          # void (transparent in rendering)
+            -30: [220, 80, 80],      # subtle highlight for landmarks
+            -17: [250, 250, 250],    # plaster (near white)
+            -16: [210, 225, 235],    # glass (light blue-gray)
+            -15: [230, 225, 215],    # stone (warm light gray)
+            -14: [225, 230, 235],    # metal (cool light gray)
+            -13: [236, 236, 236],    # concrete (very light gray)
+            -12: [245, 232, 210],    # wood (light beige)
+            -11: [235, 210, 205],    # brick (light rose)
+            -3: [225, 230, 240],     # Building (soft blue-gray)
+            -2: [190, 210, 190],     # Tree (soft green)
+            -1: [230, 215, 215],     # Underground (soft pinkish)
+            1: [248, 245, 235],      # Bareland
+            2: [225, 235, 215],      # Rangeland
+            3: [220, 235, 220],      # Shrub
+            4: [240, 235, 215],      # Agriculture land
+            5: [210, 230, 210],      # Tree (ground)
+            6: [245, 250, 235],      # Moss and lichen
+            7: [220, 235, 230],      # Wet land
+            8: [205, 215, 210],      # Mangrove
+            9: [200, 220, 245],      # Water (pale blue)
+            10: [252, 252, 252],     # Snow and ice (almost white)
+            11: [230, 230, 230],     # Developed space
+            12: [210, 210, 215],     # Road (light neutral)
+            13: [230, 235, 240],     # Building (ground surface)
+            14: [248, 245, 235],     # No Data
+        }
+
     elif color_scheme == 'autumn':
         return {
             -99: [0, 0, 0],          # void