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

voxcity/utils/__init__.py

@@ -1,3 +1,14 @@
 from .lc import *
 from .weather import *
 from .material import *
+from .classes import (
+    VOXEL_CODES,
+    LAND_COVER_CLASSES,
+    print_voxel_codes,
+    print_land_cover_classes,
+    print_class_definitions,
+    get_land_cover_name,
+    get_voxel_code_name,
+    summarize_voxel_grid,
+    summarize_land_cover_grid,
+)

voxcity/utils/classes.py

@@ -0,0 +1,194 @@
+"""
+VoxCity Class Definitions
+
+This module provides standard class definitions for voxel grid semantics
+and land cover classification used throughout VoxCity.
+
+Voxel Grid Semantics:
+    The 3D voxel grid uses integer codes to represent different urban elements.
+    Negative values represent structural elements, while positive values 
+    represent land cover classes at the ground surface layer.
+
+Land Cover Classes:
+    Land cover is standardized to a 1-based indexing system (1-14) for 
+    consistency across different data sources. This standard classification
+    is used in the voxel representation and exports.
+"""
+
+import numpy as np
+from typing import Dict, Optional
+
+
+# =============================================================================
+# Voxel Semantic Codes
+# =============================================================================
+
+VOXEL_CODES = {
+    -3: "Building",
+    -2: "Tree Canopy",
+    -1: "Ground/Subsurface",
+    # Positive values (>=1) represent land cover classes at ground surface
+}
+
+VOXEL_CODE_DESCRIPTIONS = """
+Voxel Grid Semantic Codes:
+  -3 : Building volume
+  -2 : Tree canopy (vegetation)
+  -1 : Ground/Subsurface
+  >=1: Land cover class at ground surface (see Land Cover Classes)
+"""
+
+
+# =============================================================================
+# Standard Land Cover Classes (1-based indices)
+# =============================================================================
+
+LAND_COVER_CLASSES = {
+    1: "Bareland",
+    2: "Rangeland",
+    3: "Shrub",
+    4: "Agriculture land",
+    5: "Tree",
+    6: "Moss and lichen",
+    7: "Wet land",
+    8: "Mangrove",
+    9: "Water",
+    10: "Snow and ice",
+    11: "Developed space",
+    12: "Road",
+    13: "Building",
+    14: "No Data",
+}
+
+LAND_COVER_DESCRIPTIONS = """
+VoxCity Standard Land Cover Classes (1-based indices, used in voxel grids):
+--------------------------------------------------
+   1: Bareland           - Bare soil, rocks, desert
+   2: Rangeland          - Grassland, pasture
+   3: Shrub              - Shrubland, bushes
+   4: Agriculture land   - Cropland, farmland
+   5: Tree               - Forest, tree cover
+   6: Moss and lichen    - Moss, lichen cover
+   7: Wet land           - Wetland, marsh
+   8: Mangrove           - Mangrove forest
+   9: Water              - Water bodies
+  10: Snow and ice       - Snow, ice, glaciers
+  11: Developed space    - Urban areas, parking
+  12: Road               - Roads, paved surfaces
+  13: Building           - Building footprints
+  14: No Data            - Missing or invalid data
+--------------------------------------------------
+Note: Source-specific land cover classes are converted to these
+      standard classes during voxelization.
+"""
+
+
+# =============================================================================
+# Print Helper Functions
+# =============================================================================
+
+def print_voxel_codes() -> None:
+    """Print voxel semantic codes to console."""
+    print(VOXEL_CODE_DESCRIPTIONS)
+
+
+def print_land_cover_classes() -> None:
+    """Print standard land cover class definitions to console."""
+    print(LAND_COVER_DESCRIPTIONS)
+
+
+def print_class_definitions() -> None:
+    """Print both voxel codes and land cover class definitions."""
+    print("\n" + "=" * 60)
+    print("VoxCity Class Definitions")
+    print("=" * 60)
+    print(VOXEL_CODE_DESCRIPTIONS)
+    print(LAND_COVER_DESCRIPTIONS)
+    print("=" * 60 + "\n")
+
+
+def get_land_cover_name(index: int) -> str:
+    """
+    Get the land cover class name for a given index.
+    
+    Args:
+        index: Land cover class index (1-14)
+        
+    Returns:
+        Class name string, or "Unknown" if index is invalid
+    """
+    return LAND_COVER_CLASSES.get(index, "Unknown")
+
+
+def get_voxel_code_name(code: int) -> str:
+    """
+    Get the semantic name for a voxel code.
+    
+    Args:
+        code: Voxel code (negative for structures, positive for land cover)
+        
+    Returns:
+        Semantic name string
+    """
+    if code in VOXEL_CODES:
+        return VOXEL_CODES[code]
+    elif code >= 1:
+        return f"Land Cover: {get_land_cover_name(code)}"
+    elif code == 0:
+        return "Empty/Air"
+    else:
+        return "Unknown"
+
+
+def summarize_voxel_grid(voxel_grid: np.ndarray, print_output: bool = True) -> Dict[int, int]:
+    """
+    Summarize the contents of a voxel grid.
+    
+    Args:
+        voxel_grid: 3D numpy array of voxel codes
+        print_output: Whether to print the summary
+        
+    Returns:
+        Dictionary mapping voxel codes to counts
+    """
+    unique, counts = np.unique(voxel_grid, return_counts=True)
+    summary = dict(zip(unique.tolist(), counts.tolist()))
+    
+    if print_output:
+        print("\nVoxel Grid Summary:")
+        print("-" * 40)
+        for code in sorted(summary.keys()):
+            name = get_voxel_code_name(code)
+            count = summary[code]
+            percentage = 100.0 * count / voxel_grid.size
+            print(f"  {code:4d}: {name:25s} - {count:,} voxels ({percentage:.2f}%)")
+        print("-" * 40)
+    
+    return summary
+
+
+def summarize_land_cover_grid(land_cover_grid: np.ndarray, print_output: bool = True) -> Dict[int, int]:
+    """
+    Summarize the contents of a land cover grid.
+    
+    Args:
+        land_cover_grid: 2D numpy array of land cover class indices
+        print_output: Whether to print the summary
+        
+    Returns:
+        Dictionary mapping class indices to counts
+    """
+    unique, counts = np.unique(land_cover_grid, return_counts=True)
+    summary = dict(zip(unique.tolist(), counts.tolist()))
+    
+    if print_output:
+        print("\nLand Cover Grid Summary:")
+        print("-" * 40)
+        for idx in sorted(summary.keys()):
+            name = get_land_cover_name(idx) if idx >= 1 else f"Source-specific ({idx})"
+            count = summary[idx]
+            percentage = 100.0 * count / land_cover_grid.size
+            print(f"  {idx:4d}: {name:25s} - {count:,} cells ({percentage:.2f}%)")
+        print("-" * 40)
+    
+    return summary

voxcity/utils/lc.py

@@ -34,21 +34,22 @@ def rgb_distance(color1, color2):
     return np.sqrt(np.sum((np.array(color1) - np.array(color2))**2))  
 
 
-# Legacy land cover classes mapping - kept for reference
+# Standard land cover classes mapping (1-based indices for voxel representation)
 # land_cover_classes = {
-#     (128, 0, 0): 'Bareland',              0         
-#     (0, 255, 36): 'Rangeland',            1
-#     (97, 140, 86): 'Shrub',               2
-#     (75, 181, 73): 'Agriculture land',    3
-#     (34, 97, 38): 'Tree',                 4
-#     (77, 118, 99): 'Wet land',            5
-#     (22, 61, 51): 'Mangrove',             6
-#     (0, 69, 255): 'Water',                7
-#     (205, 215, 224): 'Snow and ice',      8
-#     (148, 148, 148): 'Developed space',   9
-#     (255, 255, 255): 'Road',              10
-#     (222, 31, 7): 'Building',             11
-#     (128, 0, 0): 'No Data',               12
+#     (128, 0, 0): 'Bareland',              1         
+#     (0, 255, 36): 'Rangeland',            2
+#     (97, 140, 86): 'Shrub',               3
+#     (75, 181, 73): 'Agriculture land',    4
+#     (34, 97, 38): 'Tree',                 5
+#     (255, 255, 0): 'Moss and lichen',     6
+#     (77, 118, 99): 'Wet land',            7
+#     (22, 61, 51): 'Mangrove',             8
+#     (0, 69, 255): 'Water',                9
+#     (205, 215, 224): 'Snow and ice',      10
+#     (148, 148, 148): 'Developed space',   11
+#     (255, 255, 255): 'Road',              12
+#     (222, 31, 7): 'Building',             13
+#     (128, 0, 0): 'No Data',               14
 # }
 
 def get_land_cover_classes(source):
@@ -161,22 +162,58 @@ def get_land_cover_classes(source):
         }
     return land_cover_classes
 
-# Legacy land cover classes with numeric indices - kept for reference
+
+def get_source_class_descriptions(source):
+    """
+    Get a formatted string describing land cover classes for a specific source.
+    
+    Args:
+        source (str): Name of the land cover data source.
+        
+    Returns:
+        str: Formatted string describing the source's land cover classes.
+    """
+    land_cover_classes = get_land_cover_classes(source)
+    # Get unique class names (values from the dict)
+    class_names = list(dict.fromkeys(land_cover_classes.values()))
+    
+    lines = [f"\n{source} Land Cover Classes (source-specific, 0-based indices):"]
+    lines.append("-" * 55)
+    for idx, name in enumerate(class_names):
+        lines.append(f"  {idx:2d}: {name}")
+    lines.append("-" * 55)
+    
+    # Special note for OpenStreetMap/Standard which uses same class names
+    if source in ("OpenStreetMap", "Standard"):
+        lines.append("Note: OpenStreetMap uses VoxCity Standard class names.")
+        lines.append("      Indices shift from 0-based to 1-based during voxelization.")
+    else:
+        lines.append("Note: These source-specific classes will be converted to")
+        lines.append("      VoxCity Standard Classes (1-14) during voxelization.")
+    
+    lines.append("")
+    lines.append("Access 2D land cover grid from VoxCity object:")
+    lines.append("  land_cover_grid = voxcity.land_cover.classes")
+    lines.append("")
+    return "\n".join(lines)
+
+
+# Standard land cover classes with numeric indices (1-based for voxel representation)
 # land_cover_classes = {
-#     (128, 0, 0): 'Bareland',              0         
-#     (0, 255, 36): 'Rangeland',            1
-#     (97, 140, 86): 'Shrub',               2
-#     (75, 181, 73): 'Agriculture land',    3
-#     (34, 97, 38): 'Tree',                 4
-#     (34, 97, 38): 'Moss and lichen',      5
-#     (77, 118, 99): 'Wet land',            6
-#     (22, 61, 51): 'Mangrove',             7
-#     (0, 69, 255): 'Water',                8
-#     (205, 215, 224): 'Snow and ice',      9
-#     (148, 148, 148): 'Developed space',   10
-#     (255, 255, 255): 'Road',              11
-#     (222, 31, 7): 'Building',             12
-#     (128, 0, 0): 'No Data',               13
+#     (128, 0, 0): 'Bareland',              1         
+#     (0, 255, 36): 'Rangeland',            2
+#     (97, 140, 86): 'Shrub',               3
+#     (75, 181, 73): 'Agriculture land',    4
+#     (34, 97, 38): 'Tree',                 5
+#     (255, 255, 0): 'Moss and lichen',     6
+#     (77, 118, 99): 'Wet land',            7
+#     (22, 61, 51): 'Mangrove',             8
+#     (0, 69, 255): 'Water',                9
+#     (205, 215, 224): 'Snow and ice',      10
+#     (148, 148, 148): 'Developed space',   11
+#     (255, 255, 255): 'Road',              12
+#     (222, 31, 7): 'Building',             13
+#     (128, 0, 0): 'No Data',               14
 # }
 
 
@@ -185,21 +222,23 @@ def convert_land_cover(input_array, land_cover_source='Urbanwatch'):
     """
     Optimized version using direct numpy array indexing instead of np.vectorize.
     This is 10-100x faster than the original.
+    
+    Returns 1-based class indices (1-14) for consistency with voxel representations.
     """
-    # Define mappings
+    # Define mappings (1-based indices: 1=Bareland, 2=Rangeland, ..., 14=No Data)
     if land_cover_source == 'Urbanwatch':
-        mapping = {0: 12, 1: 11, 2: 10, 3: 4, 4: 1, 5: 3, 6: 8, 7: 0, 8: 13, 9: 8}
+        mapping = {0: 13, 1: 12, 2: 11, 3: 5, 4: 2, 5: 4, 6: 9, 7: 1, 8: 14, 9: 9}
     elif land_cover_source == 'ESA WorldCover':
-        mapping = {0: 4, 1: 2, 2: 1, 3: 3, 4: 10, 5: 0, 6: 9, 7: 8, 8: 6, 9: 7, 10: 5}
+        mapping = {0: 5, 1: 3, 2: 2, 3: 4, 4: 11, 5: 1, 6: 10, 7: 9, 8: 7, 9: 8, 10: 6}
     elif land_cover_source == "ESRI 10m Annual Land Cover":
-        mapping = {0: 13, 1: 8, 2: 4, 3: 1, 4: 6, 5: 3, 6: 2, 7: 10, 8: 0, 9: 9, 10: 13}
+        mapping = {0: 14, 1: 9, 2: 5, 3: 2, 4: 7, 5: 4, 6: 3, 7: 11, 8: 1, 9: 10, 10: 14}
     elif land_cover_source == "Dynamic World V1":
-        mapping = {0: 8, 1: 4, 2: 1, 3: 6, 4: 3, 5: 2, 6: 10, 7: 0, 8: 9}    
+        mapping = {0: 9, 1: 5, 2: 2, 3: 7, 4: 4, 5: 3, 6: 11, 7: 1, 8: 10}    
     elif land_cover_source == "OpenEarthMapJapan":
-        mapping = {0: 0, 1: 1, 2: 10, 3: 11, 4: 4, 5: 8, 6: 3, 7: 12}
+        mapping = {0: 1, 1: 2, 2: 11, 3: 12, 4: 5, 5: 9, 6: 4, 7: 13}
     else:
-        # If unknown source, return as-is
-        return input_array.copy()
+        # If unknown source, return as-is with +1 offset for consistency
+        return input_array.copy() + 1
     
     # Create a full mapping array for all possible values (0-255 for uint8)
     max_val = max(max(mapping.keys()), input_array.max()) + 1
@@ -374,12 +413,14 @@ def convert_land_cover_array(input_array, land_cover_classes):
         land_cover_classes (dict): Dictionary mapping RGB tuples to class names
         
     Returns:
-        numpy.ndarray: Array with integer indices corresponding to land cover classes
+        numpy.ndarray: Array with 0-based integer indices corresponding to land cover classes
         
     Note:
         Classes not found in the mapping are assigned index -1
+        Indices are 0-based as source-specific indices. Use convert_land_cover() to 
+        remap to standard 1-based indices for voxel representation.
     """
-    # Create a mapping of class names to integers
+    # Create a mapping of class names to integers (0-based, source-specific order)
     class_to_int = {name: i for i, name in enumerate(land_cover_classes.values())}
 
     # Create a vectorized function to map string values to integers

voxcity/utils/shape.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+from typing import Tuple, Optional, Dict, Any, Callable
+
+import numpy as np
+
+from ..models import VoxCity, VoxelGrid, BuildingGrid, LandCoverGrid, DemGrid, CanopyGrid
+
+
+def _compute_center_crop_indices(size: int, target: int) -> Tuple[int, int]:
+    if size <= target:
+        return 0, size
+    start = max(0, (size - target) // 2)
+    end = start + target
+    return start, end
+
+
+def _pad_split(total_pad: int) -> Tuple[int, int]:
+    # Split padding for centering; put extra on the bottom/right side
+    a = total_pad // 2
+    b = total_pad - a
+    return a, b
+
+
+def _pad_crop_2d(
+    arr: np.ndarray,
+    target_xy: Tuple[int, int],
+    pad_value: Any,
+    align_xy: str = "center",
+    allow_crop_xy: bool = True,
+) -> np.ndarray:
+    x, y = arr.shape[:2]
+    tx, ty = int(target_xy[0]), int(target_xy[1])
+
+    # Crop (center) if needed and allowed
+    if allow_crop_xy and (x > tx or y > ty):
+        if align_xy == "center":
+            xs, xe = _compute_center_crop_indices(x, tx) if x > tx else (0, x)
+            ys, ye = _compute_center_crop_indices(y, ty) if y > ty else (0, y)
+        else:
+            # top-left alignment: crop from bottom/right only
+            xs, xe = (0, tx) if x > tx else (0, x)
+            ys, ye = (0, ty) if y > ty else (0, y)
+        arr = arr[xs:xe, ys:ye]
+        x, y = arr.shape[:2]
+
+    # Pad to target
+    px = max(0, tx - x)
+    py = max(0, ty - y)
+
+    if px == 0 and py == 0:
+        return arr
+
+    if align_xy == "center":
+        px0, px1 = _pad_split(px)
+        py0, py1 = _pad_split(py)
+    else:
+        # top-left: pad only on bottom/right
+        px0, px1 = 0, px
+        py0, py1 = 0, py
+
+    if arr.ndim == 2:
+        pad_width = ((px0, px1), (py0, py1))
+    else:
+        # Preserve trailing dims (e.g., channels)
+        pad_width = ((px0, px1), (py0, py1)) + tuple((0, 0) for _ in range(arr.ndim - 2))
+
+    return np.pad(arr, pad_width, mode="constant", constant_values=pad_value)
+
+
+def _pad_crop_3d_zbottom(
+    arr: np.ndarray,
+    target_shape: Tuple[int, int, int],
+    pad_value: Any,
+    align_xy: str = "center",
+    allow_crop_xy: bool = True,
+    allow_crop_z: bool = False,
+) -> np.ndarray:
+    nx, ny, nz = arr.shape
+    tx, ty, tz = int(target_shape[0]), int(target_shape[1]), int(target_shape[2])
+
+    # XY crop/pad
+    arr_xy = _pad_crop_2d(arr, (tx, ty), pad_value, align_xy=align_xy, allow_crop_xy=allow_crop_xy)
+    nx, ny, nz = arr_xy.shape
+
+    # Z handling: keep ground at z=0; pad only at the top by default
+    if nz > tz:
+        if allow_crop_z:
+            arr_xy = arr_xy[:, :, :tz]
+        else:
+            tz = nz  # expand target to avoid cropping
+    elif nz < tz:
+        pad_top = tz - nz  # add empty air above
+        arr_xy = np.pad(arr_xy, ((0, 0), (0, 0), (0, pad_top)), mode="constant", constant_values=pad_value)
+
+    return arr_xy
+
+
+def normalize_voxcity_shape(
+    city: VoxCity,
+    target_shape: Tuple[int, int, int],
+    *,
+    align_xy: str = "center",
+    pad_values: Optional[Dict[str, Any]] = None,
+    allow_crop_xy: bool = True,
+    allow_crop_z: bool = False,
+) -> VoxCity:
+    """
+    Return a new VoxCity with arrays padded/cropped to target (x, y, z).
+
+    - XY alignment can be 'center' (default) or 'top-left'.
+    - Z padding is added at the TOP to preserve ground level at z=0.
+    - By default, Z is never cropped (allow_crop_z=False). If target z is smaller than current,
+      target z is expanded to current to avoid losing data.
+    """
+    if pad_values is None:
+        pad_values = {}
+
+    # Resolve pad values for each layer
+    pv_vox = pad_values.get("voxels", 0)
+    pv_lc = pad_values.get("land_cover", 0)
+    pv_dem = pad_values.get("dem", 0.0)
+    pv_bh = pad_values.get("building_heights", 0.0)
+    pv_bid = pad_values.get("building_ids", 0)
+    pv_canopy = pad_values.get("canopy", 0.0)
+    pv_bmin = pad_values.get("building_min_heights_factory", None)  # callable creating empty cell, default []
+    if pv_bmin is None:
+        def _empty_list() -> list:
+            return []
+        pv_bmin = _empty_list
+    elif not callable(pv_bmin):
+        const_val = pv_bmin
+        pv_bmin = (lambda v=const_val: v)
+
+    # Source arrays
+    vox = city.voxels.classes
+    bh = city.buildings.heights
+    bmin = city.buildings.min_heights
+    bid = city.buildings.ids
+    lc = city.land_cover.classes
+    dem = city.dem.elevation
+    can_top = city.tree_canopy.top
+    can_bot = city.tree_canopy.bottom if city.tree_canopy.bottom is not None else None
+
+    # Normalize shapes
+    vox_n = _pad_crop_3d_zbottom(
+        vox.astype(vox.dtype, copy=False),
+        target_shape,
+        pad_value=np.array(pv_vox, dtype=vox.dtype),
+        align_xy=align_xy,
+        allow_crop_xy=allow_crop_xy,
+        allow_crop_z=allow_crop_z,
+    )
+    tx, ty, tz = vox_n.shape
+
+    def _pad2d(a: np.ndarray, pad_val: Any) -> np.ndarray:
+        return _pad_crop_2d(
+            a.astype(a.dtype, copy=False),
+            (tx, ty),
+            pad_value=np.array(pad_val, dtype=a.dtype) if not isinstance(pad_val, (list, tuple, dict)) else pad_val,
+            align_xy=align_xy,
+            allow_crop_xy=allow_crop_xy,
+        )
+
+    bh_n = _pad2d(bh, pv_bh)
+    bid_n = _pad2d(bid, pv_bid)
+    lc_n = _pad2d(lc, pv_lc)
+    dem_n = _pad2d(dem, pv_dem)
+    can_top_n = _pad2d(can_top, pv_canopy)
+    can_bot_n = _pad2d(can_bot, pv_canopy) if can_bot is not None else None  # type: ignore
+
+    # Object-dtype 2D padding/cropping for min_heights
+    # Center-crop if needed, then pad with empty lists
+    bx, by = bmin.shape
+    if bx > tx or by > ty:
+        if align_xy == "center":
+            xs, xe = _compute_center_crop_indices(bx, tx) if bx > tx else (0, bx)
+            ys, ye = _compute_center_crop_indices(by, ty) if by > ty else (0, by)
+        else:
+            xs, xe = (0, tx) if bx > tx else (0, bx)
+            ys, ye = (0, ty) if by > ty else (0, by)
+        bmin_c = bmin[xs:xe, ys:ye]
+    else:
+        bmin_c = bmin
+    bx, by = bmin_c.shape
+    px = max(0, tx - bx)
+    py = max(0, ty - by)
+    if px or py:
+        out = np.empty((tx, ty), dtype=object)
+        # Fill with empty factory values
+        for i in range(tx):
+            for j in range(ty):
+                out[i, j] = pv_bmin()
+        if align_xy == "center":
+            px0, px1 = _pad_split(px)
+            py0, py1 = _pad_split(py)
+        else:
+            px0, py0 = 0, 0
+            px1, py1 = px, py
+        out[px0:px0 + bx, py0:py0 + by] = bmin_c
+        bmin_n = out
+    else:
+        bmin_n = bmin_c
+
+    # Rebuild VoxCity with normalized arrays and same metadata (meshsize/bounds)
+    meta = city.voxels.meta
+    voxels_new = VoxelGrid(classes=vox_n, meta=meta)
+    buildings_new = BuildingGrid(heights=bh_n, min_heights=bmin_n, ids=bid_n, meta=meta)
+    land_new = LandCoverGrid(classes=lc_n, meta=meta)
+    dem_new = DemGrid(elevation=dem_n, meta=meta)
+    canopy_new = CanopyGrid(top=can_top_n, bottom=can_bot_n, meta=meta)
+
+    city_new = VoxCity(
+        voxels=voxels_new,
+        buildings=buildings_new,
+        land_cover=land_new,
+        dem=dem_new,
+        tree_canopy=canopy_new,
+        extras=dict(city.extras) if city.extras is not None else {},
+    )
+    # Keep extras canopy mirrors in sync if present
+    try:
+        city_new.extras["canopy_top"] = can_top_n
+        if can_bot_n is not None:
+            city_new.extras["canopy_bottom"] = can_bot_n
+    except Exception:
+        pass
+    return city_new
+
+

voxcity/visualizer/__init__.py

@@ -1,24 +1,24 @@
-from .builder import MeshBuilder
-from .renderer import PyVistaRenderer, create_multi_view_scene, visualize_voxcity_plotly, visualize_voxcity
-from .palette import get_voxel_color_map
-from .grids import visualize_landcover_grid_on_basemap, visualize_numerical_grid_on_basemap, visualize_numerical_gdf_on_basemap, visualize_point_gdf_on_basemap
-from .maps import plot_grid, visualize_land_cover_grid_on_map, visualize_building_height_grid_on_map, visualize_numerical_grid_on_map
-
-__all__ = [
-    "MeshBuilder",
-    "PyVistaRenderer",
-    "create_multi_view_scene",
-    "visualize_voxcity_plotly",
-    "visualize_voxcity",
-    "get_voxel_color_map",
-    "visualize_landcover_grid_on_basemap",
-    "visualize_numerical_grid_on_basemap",
-    "visualize_numerical_gdf_on_basemap",
-    "visualize_point_gdf_on_basemap",
-    "plot_grid",
-    "visualize_land_cover_grid_on_map",
-    "visualize_building_height_grid_on_map",
-    "visualize_numerical_grid_on_map",
-]
-
-
+from .builder import MeshBuilder
+from .renderer import PyVistaRenderer, create_multi_view_scene, visualize_voxcity_plotly, visualize_voxcity
+from .palette import get_voxel_color_map
+from .grids import visualize_landcover_grid_on_basemap, visualize_numerical_grid_on_basemap, visualize_numerical_gdf_on_basemap, visualize_point_gdf_on_basemap
+from .maps import plot_grid, visualize_land_cover_grid_on_map, visualize_building_height_grid_on_map, visualize_numerical_grid_on_map
+
+__all__ = [
+    "MeshBuilder",
+    "PyVistaRenderer",
+    "create_multi_view_scene",
+    "visualize_voxcity_plotly",
+    "visualize_voxcity",
+    "get_voxel_color_map",
+    "visualize_landcover_grid_on_basemap",
+    "visualize_numerical_grid_on_basemap",
+    "visualize_numerical_gdf_on_basemap",
+    "visualize_point_gdf_on_basemap",
+    "plot_grid",
+    "visualize_land_cover_grid_on_map",
+    "visualize_building_height_grid_on_map",
+    "visualize_numerical_grid_on_map",
+]
+
+