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

voxcity/generator/pipeline.py

@@ -0,0 +1,282 @@
+import os
+from ..utils.logging import get_logger
+from typing import Optional
+import numpy as np
+
+from ..models import (
+    GridMetadata,
+    BuildingGrid,
+    LandCoverGrid,
+    DemGrid,
+    VoxelGrid,
+    CanopyGrid,
+    VoxCity,
+    PipelineConfig,
+)
+
+from .grids import (
+    get_land_cover_grid,
+    get_building_height_grid,
+    get_canopy_height_grid,
+    get_dem_grid,
+)
+from .voxelizer import Voxelizer
+
+
+class VoxCityPipeline:
+    def __init__(self, meshsize: float, rectangle_vertices, crs: str = "EPSG:4326") -> None:
+        self.meshsize = float(meshsize)
+        self.rectangle_vertices = rectangle_vertices
+        self.crs = crs
+
+    def _bounds(self):
+        xs = [p[0] for p in self.rectangle_vertices]
+        ys = [p[1] for p in self.rectangle_vertices]
+        return (min(xs), min(ys), max(xs), max(ys))
+
+    def _meta(self) -> GridMetadata:
+        return GridMetadata(crs=self.crs, bounds=self._bounds(), meshsize=self.meshsize)
+
+    def assemble_voxcity(
+        self,
+        voxcity_grid: np.ndarray,
+        building_height_grid: np.ndarray,
+        building_min_height_grid: np.ndarray,
+        building_id_grid: np.ndarray,
+        land_cover_grid: np.ndarray,
+        dem_grid: np.ndarray,
+        canopy_height_top: Optional[np.ndarray] = None,
+        canopy_height_bottom: Optional[np.ndarray] = None,
+        extras: Optional[dict] = None,
+    ) -> VoxCity:
+        meta = self._meta()
+        buildings = BuildingGrid(
+            heights=building_height_grid,
+            min_heights=building_min_height_grid,
+            ids=building_id_grid,
+            meta=meta,
+        )
+        land = LandCoverGrid(classes=land_cover_grid, meta=meta)
+        dem = DemGrid(elevation=dem_grid, meta=meta)
+        voxels = VoxelGrid(classes=voxcity_grid, meta=meta)
+        canopy = CanopyGrid(top=canopy_height_top if canopy_height_top is not None else np.zeros_like(land_cover_grid, dtype=float),
+                            bottom=canopy_height_bottom,
+                            meta=meta)
+        _extras = {
+            "rectangle_vertices": self.rectangle_vertices,
+            "canopy_top": canopy.top,
+            "canopy_bottom": canopy.bottom,
+        }
+        if extras:
+            _extras.update(extras)
+        return VoxCity(voxels=voxels, buildings=buildings, land_cover=land, dem=dem, tree_canopy=canopy, extras=_extras)
+
+    def run(self, cfg: PipelineConfig, building_gdf=None, terrain_gdf=None, **kwargs) -> VoxCity:
+        os.makedirs(cfg.output_dir, exist_ok=True)
+        land_strategy = LandCoverSourceFactory.create(cfg.land_cover_source)
+        build_strategy = BuildingSourceFactory.create(cfg.building_source)
+        canopy_strategy = CanopySourceFactory.create(cfg.canopy_height_source, cfg)
+        dem_strategy = DemSourceFactory.create(cfg.dem_source)
+
+        # Prefer structured options from cfg; allow legacy kwargs for back-compat
+        land_cover_grid = land_strategy.build_grid(
+            cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
+            **{**cfg.land_cover_options, **kwargs}
+        )
+        # Detect effective land cover source (e.g., Urbanwatch -> OpenStreetMap fallback)
+        try:
+            from .grids import get_last_effective_land_cover_source
+            lc_src_effective = get_last_effective_land_cover_source() or cfg.land_cover_source
+        except Exception:
+            lc_src_effective = cfg.land_cover_source
+        bh, bmin, bid, building_gdf_out = build_strategy.build_grids(
+            cfg.rectangle_vertices, cfg.meshsize, cfg.output_dir,
+            building_gdf=building_gdf,
+            **{**cfg.building_options, **kwargs}
+        )
+        canopy_top, canopy_bottom = canopy_strategy.build_grids(
+            cfg.rectangle_vertices, cfg.meshsize, land_cover_grid, cfg.output_dir,
+            land_cover_source=lc_src_effective,
+            **{**cfg.canopy_options, **kwargs}
+        )
+        dem = dem_strategy.build_grid(
+            cfg.rectangle_vertices, cfg.meshsize, land_cover_grid, cfg.output_dir,
+            terrain_gdf=terrain_gdf,
+            land_cover_like=land_cover_grid,
+            **{**cfg.dem_options, **kwargs}
+        )
+
+        ro = cfg.remove_perimeter_object
+        if (ro is not None) and (ro > 0):
+            w_peri = int(ro * bh.shape[0] + 0.5)
+            h_peri = int(ro * bh.shape[1] + 0.5)
+            canopy_top[:w_peri, :] = canopy_top[-w_peri:, :] = canopy_top[:, :h_peri] = canopy_top[:, -h_peri:] = 0
+            canopy_bottom[:w_peri, :] = canopy_bottom[-w_peri:, :] = canopy_bottom[:, :h_peri] = canopy_bottom[:, -h_peri:] = 0
+            ids1 = np.unique(bid[:w_peri, :][bid[:w_peri, :] > 0]); ids2 = np.unique(bid[-w_peri:, :][bid[-w_peri:, :] > 0])
+            ids3 = np.unique(bid[:, :h_peri][bid[:, :h_peri] > 0]); ids4 = np.unique(bid[:, -h_peri:][bid[:, -h_peri:] > 0])
+            for rid in np.concatenate((ids1, ids2, ids3, ids4)):
+                pos = np.where(bid == rid)
+                bh[pos] = 0
+                bmin[pos] = [[] for _ in range(len(bmin[pos]))]
+
+        voxelizer = Voxelizer(
+            voxel_size=cfg.meshsize,
+            land_cover_source=lc_src_effective,
+            trunk_height_ratio=cfg.trunk_height_ratio,
+            voxel_dtype=kwargs.get("voxel_dtype", np.int8),
+            max_voxel_ram_mb=kwargs.get("max_voxel_ram_mb"),
+        )
+        vox = voxelizer.generate_combined(
+            building_height_grid_ori=bh,
+            building_min_height_grid_ori=bmin,
+            building_id_grid_ori=bid,
+            land_cover_grid_ori=land_cover_grid,
+            dem_grid_ori=dem,
+            tree_grid_ori=canopy_top,
+            canopy_bottom_height_grid_ori=canopy_bottom,
+        )
+        return self.assemble_voxcity(
+            voxcity_grid=vox,
+            building_height_grid=bh,
+            building_min_height_grid=bmin,
+            building_id_grid=bid,
+            land_cover_grid=land_cover_grid,
+            dem_grid=dem,
+            canopy_height_top=canopy_top,
+            canopy_height_bottom=canopy_bottom,
+            extras={
+                "building_gdf": building_gdf_out,
+                "land_cover_source": lc_src_effective,
+                "building_source": cfg.building_source,
+                "dem_source": cfg.dem_source,
+            },
+        )
+
+
+class LandCoverSourceStrategy:  # ABC simplified to avoid dependency in split
+    def build_grid(self, rectangle_vertices, meshsize: float, output_dir: str, **kwargs):  # pragma: no cover - interface
+        raise NotImplementedError
+
+
+class DefaultLandCoverStrategy(LandCoverSourceStrategy):
+    def __init__(self, source: str) -> None:
+        self.source = source
+
+    def build_grid(self, rectangle_vertices, meshsize: float, output_dir: str, **kwargs):
+        return get_land_cover_grid(rectangle_vertices, meshsize, self.source, output_dir, **kwargs)
+
+
+class LandCoverSourceFactory:
+    @staticmethod
+    def create(source: str) -> LandCoverSourceStrategy:
+        return DefaultLandCoverStrategy(source)
+
+
+class BuildingSourceStrategy:  # ABC simplified
+    def build_grids(self, rectangle_vertices, meshsize: float, output_dir: str, **kwargs):  # pragma: no cover - interface
+        raise NotImplementedError
+
+
+class DefaultBuildingSourceStrategy(BuildingSourceStrategy):
+    def __init__(self, source: str) -> None:
+        self.source = source
+
+    def build_grids(self, rectangle_vertices, meshsize: float, output_dir: str, **kwargs):
+        return get_building_height_grid(rectangle_vertices, meshsize, self.source, output_dir, **kwargs)
+
+
+class BuildingSourceFactory:
+    @staticmethod
+    def create(source: str) -> BuildingSourceStrategy:
+        return DefaultBuildingSourceStrategy(source)
+
+
+class CanopySourceStrategy:  # ABC simplified
+    def build_grids(self, rectangle_vertices, meshsize: float, land_cover_grid: np.ndarray, output_dir: str, **kwargs):  # pragma: no cover
+        raise NotImplementedError
+
+
+class StaticCanopyStrategy(CanopySourceStrategy):
+    def __init__(self, cfg: PipelineConfig) -> None:
+        self.cfg = cfg
+
+    def build_grids(self, rectangle_vertices, meshsize: float, land_cover_grid: np.ndarray, output_dir: str, **kwargs):
+        canopy_top = np.zeros_like(land_cover_grid, dtype=float)
+        static_h = self.cfg.static_tree_height if self.cfg.static_tree_height is not None else kwargs.get("static_tree_height", 10.0)
+        from ..utils.lc import get_land_cover_classes
+        _classes = get_land_cover_classes(self.cfg.land_cover_source)
+        _class_to_int = {name: i for i, name in enumerate(_classes.values())}
+        _tree_labels = ["Tree", "Trees", "Tree Canopy"]
+        _tree_idx = [_class_to_int[label] for label in _tree_labels if label in _class_to_int]
+        tree_mask = np.isin(land_cover_grid, _tree_idx) if _tree_idx else np.zeros_like(land_cover_grid, dtype=bool)
+        canopy_top[tree_mask] = static_h
+        tr = self.cfg.trunk_height_ratio if self.cfg.trunk_height_ratio is not None else (11.76 / 19.98)
+        canopy_bottom = canopy_top * float(tr)
+        return canopy_top, canopy_bottom
+
+
+class SourceCanopyStrategy(CanopySourceStrategy):
+    def __init__(self, source: str) -> None:
+        self.source = source
+
+    def build_grids(self, rectangle_vertices, meshsize: float, land_cover_grid: np.ndarray, output_dir: str, **kwargs):
+        # Provide land_cover_like for graceful fallback sizing without EE
+        return get_canopy_height_grid(
+            rectangle_vertices,
+            meshsize,
+            self.source,
+            output_dir,
+            land_cover_like=land_cover_grid,
+            **kwargs,
+        )
+
+
+class CanopySourceFactory:
+    @staticmethod
+    def create(source: str, cfg: PipelineConfig) -> CanopySourceStrategy:
+        if source == "Static":
+            return StaticCanopyStrategy(cfg)
+        return SourceCanopyStrategy(source)
+
+
+class DemSourceStrategy:  # ABC simplified
+    def build_grid(self, rectangle_vertices, meshsize: float, land_cover_grid: np.ndarray, output_dir: str, **kwargs):  # pragma: no cover
+        raise NotImplementedError
+
+
+class FlatDemStrategy(DemSourceStrategy):
+    def build_grid(self, rectangle_vertices, meshsize: float, land_cover_grid: np.ndarray, output_dir: str, **kwargs):
+        return np.zeros_like(land_cover_grid)
+
+
+class SourceDemStrategy(DemSourceStrategy):
+    def __init__(self, source: str) -> None:
+        self.source = source
+
+    def build_grid(self, rectangle_vertices, meshsize: float, land_cover_grid: np.ndarray, output_dir: str, **kwargs):
+        terrain_gdf = kwargs.get("terrain_gdf")
+        if terrain_gdf is not None:
+            from ..geoprocessor.raster import create_dem_grid_from_gdf_polygon
+            return create_dem_grid_from_gdf_polygon(terrain_gdf, meshsize, rectangle_vertices)
+        try:
+            return get_dem_grid(rectangle_vertices, meshsize, self.source, output_dir, **kwargs)
+        except Exception as e:
+            # Fallback to flat DEM if source fails or unsupported
+            logger = get_logger(__name__)
+            logger.warning("DEM source '%s' failed (%s). Falling back to flat DEM.", self.source, e)
+            return np.zeros_like(land_cover_grid)
+
+
+class DemSourceFactory:
+    @staticmethod
+    def create(source: str) -> DemSourceStrategy:
+        # Normalize and auto-fallback: None/"none" -> Flat
+        try:
+            src_norm = (source or "").strip().lower()
+        except Exception:
+            src_norm = ""
+        if (not source) or (src_norm in {"flat", "none", "null"}):
+            return FlatDemStrategy()
+        return SourceDemStrategy(source)
+
+

voxcity/generator/voxelizer.py

@@ -0,0 +1,380 @@
+import numpy as np
+from typing import Optional
+
+try:
+    from numba import jit, prange
+    import numba  # noqa: F401
+    NUMBA_AVAILABLE = True
+except ImportError:  # pragma: no cover - optional accel
+    NUMBA_AVAILABLE = False
+    print("Numba not available. Using optimized version without JIT compilation.")
+
+    def jit(*args, **kwargs):
+        def decorator(func):
+            return func
+        return decorator
+
+    prange = range
+
+from ..geoprocessor.raster import (
+    group_and_label_cells,
+    process_grid,
+)
+from ..utils.orientation import ensure_orientation, ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP
+from ..utils.lc import convert_land_cover
+
+
+# -----------------------------
+# Voxel class codes (semantics)
+# -----------------------------
+GROUND_CODE = -1
+TREE_CODE = -2
+BUILDING_CODE = -3
+
+
+@jit(nopython=True, parallel=True)
+def _voxelize_kernel(
+    voxel_grid,
+    land_cover_grid,
+    dem_grid,
+    tree_grid,
+    canopy_bottom_grid,
+    has_canopy_bottom,
+    seg_starts,
+    seg_ends,
+    seg_offsets,
+    seg_counts,
+    trunk_height_ratio,
+    voxel_size,
+):
+    rows, cols = land_cover_grid.shape
+    for i in prange(rows):
+        for j in range(cols):
+            ground_level = int(dem_grid[i, j] / voxel_size + 0.5) + 1
+
+            # ground and land cover layer
+            if ground_level > 0:
+                voxel_grid[i, j, :ground_level] = GROUND_CODE
+                voxel_grid[i, j, ground_level - 1] = land_cover_grid[i, j]
+
+            # trees
+            tree_height = tree_grid[i, j]
+            if tree_height > 0.0:
+                if has_canopy_bottom:
+                    crown_base_height = canopy_bottom_grid[i, j]
+                else:
+                    crown_base_height = tree_height * trunk_height_ratio
+                crown_base_level = int(crown_base_height / voxel_size + 0.5)
+                crown_top_level = int(tree_height / voxel_size + 0.5)
+                if (crown_top_level == crown_base_level) and (crown_base_level > 0):
+                    crown_base_level -= 1
+                tree_start = ground_level + crown_base_level
+                tree_end = ground_level + crown_top_level
+                if tree_end > tree_start:
+                    voxel_grid[i, j, tree_start:tree_end] = TREE_CODE
+
+            # buildings (packed segments)
+            base = seg_offsets[i, j]
+            count = seg_counts[i, j]
+            for k in range(count):
+                s = seg_starts[base + k]
+                e = seg_ends[base + k]
+                start = ground_level + s
+                end = ground_level + e
+                if end > start:
+                    voxel_grid[i, j, start:end] = BUILDING_CODE
+
+
+def _flatten_building_segments(building_min_height_grid: np.ndarray, voxel_size: float):
+    rows, cols = building_min_height_grid.shape
+    counts = np.zeros((rows, cols), dtype=np.int32)
+    # First pass: count segments per cell
+    for i in range(rows):
+        for j in range(cols):
+            cell = building_min_height_grid[i, j]
+            n = 0
+            if isinstance(cell, list):
+                n = len(cell)
+            counts[i, j] = np.int32(n)
+
+    # Prefix sum to compute offsets
+    offsets = np.zeros((rows, cols), dtype=np.int32)
+    total = 0
+    for i in range(rows):
+        for j in range(cols):
+            offsets[i, j] = total
+            total += int(counts[i, j])
+
+    seg_starts = np.zeros(total, dtype=np.int32)
+    seg_ends = np.zeros(total, dtype=np.int32)
+
+    # Second pass: fill flattened arrays
+    for i in range(rows):
+        for j in range(cols):
+            base = offsets[i, j]
+            n = counts[i, j]
+            if n == 0:
+                continue
+            cell = building_min_height_grid[i, j]
+            for k in range(int(n)):
+                mh = cell[k][0]
+                mx = cell[k][1]
+                seg_starts[base + k] = int(mh / voxel_size + 0.5)
+                seg_ends[base + k] = int(mx / voxel_size + 0.5)
+
+    return seg_starts, seg_ends, offsets, counts
+
+
+class Voxelizer:
+    def __init__(
+        self,
+        voxel_size: float,
+        land_cover_source: str,
+        trunk_height_ratio: Optional[float] = None,
+        voxel_dtype=np.int8,
+        max_voxel_ram_mb: Optional[float] = None,
+    ) -> None:
+        self.voxel_size = float(voxel_size)
+        self.land_cover_source = land_cover_source
+        self.trunk_height_ratio = float(trunk_height_ratio) if trunk_height_ratio is not None else (11.76 / 19.98)
+        self.voxel_dtype = voxel_dtype
+        self.max_voxel_ram_mb = max_voxel_ram_mb
+
+    def _estimate_and_allocate(self, rows: int, cols: int, max_height: int) -> np.ndarray:
+        try:
+            bytes_per_elem = np.dtype(self.voxel_dtype).itemsize
+            est_mb = rows * cols * max_height * bytes_per_elem / (1024 ** 2)
+            print(f"Voxel grid shape: ({rows}, {cols}, {max_height}), dtype: {self.voxel_dtype}, ~{est_mb:.1f} MB")
+            if (self.max_voxel_ram_mb is not None) and (est_mb > self.max_voxel_ram_mb):
+                raise MemoryError(
+                    f"Estimated voxel grid memory {est_mb:.1f} MB exceeds limit {self.max_voxel_ram_mb} MB. Increase mesh size or restrict ROI."
+                )
+        except Exception:
+            pass
+        return np.zeros((rows, cols, max_height), dtype=self.voxel_dtype)
+
+    def _convert_land_cover(self, land_cover_grid_ori: np.ndarray) -> np.ndarray:
+        if self.land_cover_source == 'OpenStreetMap':
+            return land_cover_grid_ori
+        return convert_land_cover(land_cover_grid_ori, land_cover_source=self.land_cover_source)
+
+    def generate_combined(
+        self,
+        building_height_grid_ori: np.ndarray,
+        building_min_height_grid_ori: np.ndarray,
+        building_id_grid_ori: np.ndarray,
+        land_cover_grid_ori: np.ndarray,
+        dem_grid_ori: np.ndarray,
+        tree_grid_ori: np.ndarray,
+        canopy_bottom_height_grid_ori: Optional[np.ndarray] = None,
+        **kwargs,
+    ) -> np.ndarray:
+        print("Generating 3D voxel data")
+
+        land_cover_grid_converted = self._convert_land_cover(land_cover_grid_ori)
+
+        building_height_grid = ensure_orientation(
+            np.nan_to_num(building_height_grid_ori, nan=10.0),
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        )
+        building_min_height_grid = ensure_orientation(
+            replace_nan_in_nested(building_min_height_grid_ori),
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        )
+        building_id_grid = ensure_orientation(
+            building_id_grid_ori,
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        )
+        land_cover_grid = ensure_orientation(
+            land_cover_grid_converted.copy(),
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        ) + 1
+        dem_grid = ensure_orientation(
+            dem_grid_ori.copy(),
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        ) - np.min(dem_grid_ori)
+        dem_grid = process_grid(building_id_grid, dem_grid)
+        tree_grid = ensure_orientation(
+            tree_grid_ori.copy(),
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        )
+        canopy_bottom_grid = None
+        if canopy_bottom_height_grid_ori is not None:
+            canopy_bottom_grid = ensure_orientation(
+                canopy_bottom_height_grid_ori.copy(),
+                ORIENTATION_NORTH_UP,
+                ORIENTATION_SOUTH_UP,
+            )
+
+        assert building_height_grid.shape == land_cover_grid.shape == dem_grid.shape == tree_grid.shape, "Input grids must have the same shape"
+        rows, cols = building_height_grid.shape
+        max_height = int(np.ceil(np.max(building_height_grid + dem_grid + tree_grid) / self.voxel_size)) + 1
+
+        voxel_grid = self._estimate_and_allocate(rows, cols, max_height)
+
+        trunk_height_ratio = float(kwargs.get("trunk_height_ratio", self.trunk_height_ratio))
+
+        if NUMBA_AVAILABLE:
+            has_canopy = canopy_bottom_grid is not None
+            canopy_in = canopy_bottom_grid if has_canopy else np.zeros_like(tree_grid)
+            seg_starts, seg_ends, seg_offsets, seg_counts = _flatten_building_segments(
+                building_min_height_grid, self.voxel_size
+            )
+            _voxelize_kernel(
+                voxel_grid,
+                land_cover_grid.astype(np.int32, copy=False),
+                dem_grid.astype(np.float32, copy=False),
+                tree_grid.astype(np.float32, copy=False),
+                canopy_in.astype(np.float32, copy=False),
+                has_canopy,
+                seg_starts,
+                seg_ends,
+                seg_offsets,
+                seg_counts,
+                float(trunk_height_ratio),
+                float(self.voxel_size),
+            )
+            return voxel_grid
+
+        for i in range(rows):
+            for j in range(cols):
+                ground_level = int(dem_grid[i, j] / self.voxel_size + 0.5) + 1
+                tree_height = tree_grid[i, j]
+                land_cover = land_cover_grid[i, j]
+
+                voxel_grid[i, j, :ground_level] = GROUND_CODE
+                voxel_grid[i, j, ground_level - 1] = land_cover
+
+                if tree_height > 0:
+                    if canopy_bottom_grid is not None:
+                        crown_base_height = canopy_bottom_grid[i, j]
+                    else:
+                        crown_base_height = (tree_height * trunk_height_ratio)
+                    crown_base_height_level = int(crown_base_height / self.voxel_size + 0.5)
+                    crown_top_height_level = int(tree_height / self.voxel_size + 0.5)
+                    if (crown_top_height_level == crown_base_height_level) and (crown_base_height_level > 0):
+                        crown_base_height_level -= 1
+                    tree_start = ground_level + crown_base_height_level
+                    tree_end = ground_level + crown_top_height_level
+                    voxel_grid[i, j, tree_start:tree_end] = TREE_CODE
+
+                for k in building_min_height_grid[i, j]:
+                    building_min_height = int(k[0] / self.voxel_size + 0.5)
+                    building_height = int(k[1] / self.voxel_size + 0.5)
+                    voxel_grid[i, j, ground_level + building_min_height:ground_level + building_height] = BUILDING_CODE
+
+        return voxel_grid
+
+    def generate_components(
+        self,
+        building_height_grid_ori: np.ndarray,
+        land_cover_grid_ori: np.ndarray,
+        dem_grid_ori: np.ndarray,
+        tree_grid_ori: np.ndarray,
+        layered_interval: Optional[int] = None,
+    ):
+        print("Generating 3D voxel data")
+
+        if self.land_cover_source != 'OpenEarthMapJapan':
+            land_cover_grid_converted = convert_land_cover(land_cover_grid_ori, land_cover_source=self.land_cover_source)
+        else:
+            land_cover_grid_converted = land_cover_grid_ori
+
+        building_height_grid = ensure_orientation(
+            building_height_grid_ori.copy(),
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        )
+        land_cover_grid = ensure_orientation(
+            land_cover_grid_converted.copy(),
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        ) + 1
+        dem_grid = ensure_orientation(
+            dem_grid_ori.copy(),
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        ) - np.min(dem_grid_ori)
+        building_nr_grid = group_and_label_cells(
+            ensure_orientation(
+                building_height_grid_ori.copy(),
+                ORIENTATION_NORTH_UP,
+                ORIENTATION_SOUTH_UP,
+            )
+        )
+        dem_grid = process_grid(building_nr_grid, dem_grid)
+        tree_grid = ensure_orientation(
+            tree_grid_ori.copy(),
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        )
+
+        assert building_height_grid.shape == land_cover_grid.shape == dem_grid.shape == tree_grid.shape, "Input grids must have the same shape"
+        rows, cols = building_height_grid.shape
+        max_height = int(np.ceil(np.max(building_height_grid + dem_grid + tree_grid) / self.voxel_size))
+
+        land_cover_voxel_grid = np.zeros((rows, cols, max_height), dtype=np.int32)
+        building_voxel_grid = np.zeros((rows, cols, max_height), dtype=np.int32)
+        tree_voxel_grid = np.zeros((rows, cols, max_height), dtype=np.int32)
+        dem_voxel_grid = np.zeros((rows, cols, max_height), dtype=np.int32)
+
+        for i in range(rows):
+            for j in range(cols):
+                ground_level = int(dem_grid[i, j] / self.voxel_size + 0.5)
+                building_height = int(building_height_grid[i, j] / self.voxel_size + 0.5)
+                tree_height = int(tree_grid[i, j] / self.voxel_size + 0.5)
+                land_cover = land_cover_grid[i, j]
+
+                dem_voxel_grid[i, j, :ground_level + 1] = -1
+                land_cover_voxel_grid[i, j, 0] = land_cover
+                if tree_height > 0:
+                    tree_voxel_grid[i, j, :tree_height] = -2
+                if building_height > 0:
+                    building_voxel_grid[i, j, :building_height] = -3
+
+        if not layered_interval:
+            layered_interval = max(max_height, int(dem_grid.shape[0] / 4 + 0.5))
+
+        extract_height = min(layered_interval, max_height)
+        layered_voxel_grid = np.zeros((rows, cols, layered_interval * 4), dtype=np.int32)
+        layered_voxel_grid[:, :, :extract_height] = dem_voxel_grid[:, :, :extract_height]
+        layered_voxel_grid[:, :, layered_interval:layered_interval + extract_height] = land_cover_voxel_grid[:, :, :extract_height]
+        layered_voxel_grid[:, :, 2 * layered_interval:2 * layered_interval + extract_height] = building_voxel_grid[:, :, :extract_height]
+        layered_voxel_grid[:, :, 3 * layered_interval:3 * layered_interval + extract_height] = tree_voxel_grid[:, :, :extract_height]
+
+        return land_cover_voxel_grid, building_voxel_grid, tree_voxel_grid, dem_voxel_grid, layered_voxel_grid
+
+
+def replace_nan_in_nested(arr, replace_value=10.0):
+    if not isinstance(arr, np.ndarray):
+        return arr
+
+    result = np.empty_like(arr, dtype=object)
+    for i in range(arr.shape[0]):
+        for j in range(arr.shape[1]):
+            cell = arr[i, j]
+            if cell is None or (isinstance(cell, list) and len(cell) == 0):
+                result[i, j] = []
+            elif isinstance(cell, list):
+                new_cell = []
+                for segment in cell:
+                    if isinstance(segment, (list, np.ndarray)):
+                        if isinstance(segment, np.ndarray):
+                            new_segment = np.where(np.isnan(segment), replace_value, segment).tolist()
+                        else:
+                            new_segment = [replace_value if (isinstance(v, float) and np.isnan(v)) else v for v in segment]
+                        new_cell.append(new_segment)
+                    else:
+                        new_cell.append(segment)
+                result[i, j] = new_cell
+            else:
+                result[i, j] = cell
+    return result
+
+