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

voxcity/visualizer/__init__.py

@@ -0,0 +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",
+]
+
+

voxcity/visualizer/builder.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import numpy as np
+import trimesh
+
+from ..models import MeshModel, MeshCollection, VoxelGrid
+from ..geoprocessor.mesh import create_city_meshes
+from .palette import get_voxel_color_map
+
+
+class MeshBuilder:
+    """Build mesh collections from voxel grids for rendering/export."""
+
+    @staticmethod
+    def from_voxel_grid(voxel_grid: VoxelGrid, meshsize: float, voxel_color_map: "str|dict" = "default",
+                        include_classes=None, exclude_classes=None) -> MeshCollection:
+        if isinstance(voxel_color_map, dict):
+            vox_dict = voxel_color_map
+        else:
+            vox_dict = get_voxel_color_map(voxel_color_map)
+
+        meshes = create_city_meshes(
+            voxel_grid.classes,
+            vox_dict,
+            meshsize=meshsize,
+            include_classes=include_classes,
+            exclude_classes=exclude_classes,
+        )
+
+        collection = MeshCollection()
+        for key, m in meshes.items():
+            if m is None:
+                continue
+            colors = getattr(m.visual, 'face_colors', None)
+            collection.add(str(key), MeshModel(
+                vertices=m.vertices.copy(),
+                faces=m.faces.copy(),
+                colors=colors.copy() if colors is not None else None,
+                name=str(key)
+            ))
+        return collection
+
+

voxcity/visualizer/grids.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+from matplotlib.colors import ListedColormap, BoundaryNorm
+import contextily as ctx
+
+from ..geoprocessor.raster import grid_to_geodataframe
+from ..utils.lc import get_land_cover_classes
+
+
+def visualize_landcover_grid_on_basemap(landcover_grid, rectangle_vertices, meshsize, source='Standard', alpha=0.6, figsize=(12, 8), basemap='CartoDB light', show_edge=False, edge_color='black', edge_width=0.5):
+    land_cover_classes = get_land_cover_classes(source)
+    gdf = grid_to_geodataframe(landcover_grid, rectangle_vertices, meshsize)
+    colors = [(r/255, g/255, b/255) for (r,g,b) in land_cover_classes.keys()]
+    cmap = ListedColormap(colors)
+    bounds = np.arange(len(colors) + 1)
+    norm = BoundaryNorm(bounds, cmap.N)
+    gdf_web = gdf.to_crs(epsg=3857)
+    fig, ax = plt.subplots(figsize=figsize)
+    gdf_web.plot(column='value', ax=ax, alpha=alpha, cmap=cmap, norm=norm, legend=True,
+                 legend_kwds={'label': 'Land Cover Class', 'ticks': bounds[:-1] + 0.5, 'boundaries': bounds,
+                              'format': lambda x, p: list(land_cover_classes.values())[int(x)]},
+                 edgecolor=edge_color if show_edge else 'none', linewidth=edge_width if show_edge else 0)
+    basemaps = {
+        'CartoDB dark': ctx.providers.CartoDB.DarkMatter,
+        'CartoDB light': ctx.providers.CartoDB.Positron,
+        'CartoDB voyager': ctx.providers.CartoDB.Voyager,
+        'CartoDB light no labels': ctx.providers.CartoDB.PositronNoLabels,
+        'CartoDB dark no labels': ctx.providers.CartoDB.DarkMatterNoLabels,
+    }
+    ctx.add_basemap(ax, source=basemaps[basemap])
+    ax.set_axis_off()
+    plt.tight_layout(); plt.show()
+
+
+def visualize_numerical_grid_on_basemap(grid, rectangle_vertices, meshsize, value_name="value", cmap='viridis', vmin=None, vmax=None,
+                                        alpha=0.6, figsize=(12, 8), basemap='CartoDB light', show_edge=False, edge_color='black', edge_width=0.5):
+    gdf = grid_to_geodataframe(grid, rectangle_vertices, meshsize)
+    gdf_web = gdf.to_crs(epsg=3857)
+    fig, ax = plt.subplots(figsize=figsize)
+    gdf_web.plot(column='value', ax=ax, alpha=alpha, cmap=cmap, vmin=vmin, vmax=vmax, legend=True,
+                 legend_kwds={'label': value_name}, edgecolor=edge_color if show_edge else 'none', linewidth=edge_width if show_edge else 0)
+    basemaps = {
+        'CartoDB dark': ctx.providers.CartoDB.DarkMatter,
+        'CartoDB light': ctx.providers.CartoDB.Positron,
+        'CartoDB voyager': ctx.providers.CartoDB.Voyager,
+        'CartoDB light no labels': ctx.providers.CartoDB.PositronNoLabels,
+        'CartoDB dark no labels': ctx.providers.CartoDB.DarkMatterNoLabels,
+    }
+    ctx.add_basemap(ax, source=basemaps[basemap])
+    ax.set_axis_off()
+    plt.tight_layout(); plt.show()
+
+
+def visualize_numerical_gdf_on_basemap(gdf, value_name="value", cmap='viridis', vmin=None, vmax=None,
+                                       alpha=0.6, figsize=(12, 8), basemap='CartoDB light',
+                                       show_edge=False, edge_color='black', edge_width=0.5, input_crs=None):
+    if gdf.crs is None:
+        if input_crs is not None:
+            gdf = gdf.set_crs(input_crs, allow_override=True)
+        else:
+            try:
+                minx, miny, maxx, maxy = gdf.total_bounds
+                looks_like_lonlat = (-180.0 <= minx <= 180.0 and -180.0 <= maxx <= 180.0 and -90.0 <= miny <= 90.0 and -90.0 <= maxy <= 90.0)
+            except Exception:
+                looks_like_lonlat = False
+            if looks_like_lonlat:
+                gdf = gdf.set_crs("EPSG:4326", allow_override=True)
+            else:
+                raise ValueError("Input GeoDataFrame has no CRS. Provide 'input_crs' or set gdf.crs.")
+
+    gdf_web = gdf.to_crs(epsg=3857) if str(gdf.crs) != 'EPSG:3857' else gdf
+    fig, ax = plt.subplots(figsize=figsize)
+    gdf_web.plot(column=value_name, ax=ax, alpha=alpha, cmap=cmap, vmin=vmin, vmax=vmax, legend=True,
+                 legend_kwds={'label': value_name}, edgecolor=edge_color if show_edge else 'none', linewidth=edge_width if show_edge else 0)
+    basemaps = {
+        'CartoDB dark': ctx.providers.CartoDB.DarkMatter,
+        'CartoDB light': ctx.providers.CartoDB.Positron,
+        'CartoDB voyager': ctx.providers.CartoDB.Voyager,
+        'CartoDB light no labels': ctx.providers.CartoDB.PositronNoLabels,
+        'CartoDB dark no labels': ctx.providers.CartoDB.DarkMatterNoLabels,
+    }
+    ctx.add_basemap(ax, source=basemaps[basemap])
+    ax.set_axis_off()
+    plt.tight_layout(); plt.show()
+
+
+def visualize_point_gdf_on_basemap(point_gdf, value_name='value', **kwargs):
+    import contextily as ctx
+    defaults = {
+        'figsize': (12, 8),
+        'colormap': 'viridis',
+        'markersize': 20,
+        'alpha': 0.7,
+        'vmin': None,
+        'vmax': None,
+        'title': None,
+        'basemap_style': ctx.providers.CartoDB.Positron,
+        'zoom': 15
+    }
+    settings = {**defaults, **kwargs}
+    fig, ax = plt.subplots(figsize=settings['figsize'])
+    point_gdf_web = point_gdf.to_crs(epsg=3857)
+    point_gdf_web.plot(column=value_name, ax=ax, cmap=settings['colormap'], markersize=settings['markersize'], alpha=settings['alpha'], vmin=settings['vmin'], vmax=settings['vmax'], legend=True, legend_kwds={'label': value_name})
+    ctx.add_basemap(ax, source=settings['basemap_style'], zoom=settings['zoom'])
+    if settings['title']:
+        plt.title(settings['title'])
+    ax.set_axis_off(); plt.tight_layout(); plt.show()
+
+
+def visualize_land_cover_grid(grid, mesh_size, color_map, land_cover_classes):
+    all_classes = list(land_cover_classes.values())
+    unique_classes = list(dict.fromkeys(all_classes))
+    colors = [color_map[cls] for cls in unique_classes]
+    cmap = mcolors.ListedColormap(colors)
+    bounds = np.arange(len(unique_classes) + 1)
+    norm = mcolors.BoundaryNorm(bounds, cmap.N)
+    class_to_num = {cls: i for i, cls in enumerate(unique_classes)}
+    numeric_grid = np.vectorize(class_to_num.get)(grid)
+    plt.figure(figsize=(10, 10))
+    im = plt.imshow(numeric_grid, cmap=cmap, norm=norm, interpolation='nearest')
+    cbar = plt.colorbar(im, ticks=bounds[:-1] + 0.5)
+    cbar.set_ticklabels(unique_classes)
+    plt.title(f'Land Use/Land Cover Grid (Mesh Size: {mesh_size}m)')
+    plt.xlabel('Grid Cells (X)')
+    plt.ylabel('Grid Cells (Y)')
+    plt.show()
+
+
+def visualize_numerical_grid(grid, mesh_size, title, cmap='viridis', label='Value', vmin=None, vmax=None):
+    plt.figure(figsize=(10, 10))
+    plt.imshow(grid, cmap=cmap, vmin=vmin, vmax=vmax)
+    plt.colorbar(label=label)
+    plt.title(f'{title} (Mesh Size: {mesh_size}m)')
+    plt.xlabel('Grid Cells (X)')
+    plt.ylabel('Grid Cells (Y)')
+    plt.show()
+
+

voxcity/visualizer/maps.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+import seaborn as sns
+import contextily as ctx
+from shapely.geometry import Polygon
+from pyproj import CRS
+
+from ..geoprocessor.raster import (
+    calculate_grid_size,
+    create_coordinate_mesh,
+)
+from ..geoprocessor.utils import (
+    initialize_geod,
+    calculate_distance,
+    normalize_to_one_meter,
+    setup_transformer,
+    transform_coords,
+)
+from ..utils.lc import get_land_cover_classes
+
+
+def plot_grid(grid, origin, adjusted_meshsize, u_vec, v_vec, transformer, vertices, data_type, vmin=None, vmax=None, color_map=None, alpha=0.5, buf=0.2, edge=True, basemap='CartoDB light', **kwargs):
+    fig, ax = plt.subplots(figsize=(12, 12))
+
+    if data_type == 'land_cover':
+        land_cover_classes = kwargs.get('land_cover_classes')
+        colors = [mcolors.to_rgb(f'#{r:02x}{g:02x}{b:02x}') for r, g, b in land_cover_classes.keys()]
+        cmap = mcolors.ListedColormap(colors)
+        norm = mcolors.BoundaryNorm(range(len(land_cover_classes)+1), cmap.N)
+    elif data_type == 'building_height':
+        masked_grid = np.ma.masked_array(grid, mask=(np.isnan(grid) | (grid == 0)))
+        cmap = plt.cm.viridis
+        if vmin is None:
+            vmin = np.nanmin(masked_grid[masked_grid > 0])
+        if vmax is None:
+            vmax = np.nanmax(masked_grid)
+        norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
+    elif data_type == 'dem':
+        cmap = plt.cm.terrain
+        if vmin is None:
+            vmin = np.nanmin(grid)
+        if vmax is None:
+            vmax = np.nanmax(grid)
+        norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
+    elif data_type == 'canopy_height':
+        cmap = plt.cm.Greens
+        if vmin is None:
+            vmin = np.nanmin(grid)
+        if vmax is None:
+            vmax = np.nanmax(grid)
+        norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
+    elif data_type in ('green_view_index', 'sky_view_index'):
+        cmap = plt.cm.get_cmap('BuPu_r').copy() if data_type == 'sky_view_index' else plt.cm.Greens
+        if vmin is None:
+            vmin = np.nanmin(grid)
+        if vmax is None:
+            vmax = np.nanmax(grid)
+        norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
+    else:
+        cmap = plt.cm.viridis
+        if vmin is None:
+            vmin = np.nanmin(grid)
+        if vmax is None:
+            vmax = np.nanmax(grid)
+        norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
+
+    if color_map:
+        cmap = sns.color_palette(color_map, as_cmap=True).copy()
+
+    grid = grid.T
+
+    for i in range(grid.shape[0]):
+        for j in range(grid.shape[1]):
+            cell = create_cell_polygon(origin, j, i, adjusted_meshsize, u_vec, v_vec)  # type: ignore[name-defined]
+            x, y = cell.exterior.xy
+            x, y = zip(*[transformer.transform(lon, lat) for lat, lon in zip(x, y)])
+            value = grid[i, j]
+            if data_type == 'building_height':
+                if np.isnan(value):
+                    ax.fill(x, y, alpha=alpha, fc='gray', ec='black' if edge else None, linewidth=0.1)
+                elif value == 0:
+                    if edge:
+                        ax.plot(x, y, color='black', linewidth=0.1)
+                elif value > 0:
+                    ax.fill(x, y, alpha=alpha, fc=cmap(norm(value)), ec='black' if edge else None, linewidth=0.1)
+            elif data_type == 'canopy_height':
+                color = cmap(norm(value))
+                if value == 0:
+                    if edge:
+                        ax.plot(x, y, color='black', linewidth=0.1)
+                else:
+                    ax.fill(x, y, alpha=alpha, fc=color, ec='black' if edge else None, linewidth=0.1)
+            elif 'view' in data_type:
+                if np.isnan(value):
+                    if edge:
+                        ax.plot(x, y, color='black', linewidth=0.1)
+                elif value >= 0:
+                    ax.fill(x, y, alpha=alpha, fc=cmap(norm(value)), ec='black' if edge else None, linewidth=0.1)
+            else:
+                color = cmap(norm(value))
+                ax.fill(x, y, alpha=alpha, fc=color, ec='black' if edge else None, linewidth=0.1)
+
+    crs_epsg_3857 = CRS.from_epsg(3857)
+    basemaps = {
+      'CartoDB dark': ctx.providers.CartoDB.DarkMatter,
+      'CartoDB light': ctx.providers.CartoDB.Positron,
+      'CartoDB voyager': ctx.providers.CartoDB.Voyager,
+      'CartoDB light no labels': ctx.providers.CartoDB.PositronNoLabels,
+      'CartoDB dark no labels': ctx.providers.CartoDB.DarkMatterNoLabels,
+    }
+    ctx.add_basemap(ax, crs=crs_epsg_3857, source=basemaps[basemap])
+
+    all_coords = np.array(vertices)
+    x, y = zip(*[transformer.transform(lon, lat) for lat, lon in all_coords])
+    x_min, x_max = min(x), max(x)
+    y_min, y_max = min(y), max(y)
+    if x_min != x_max and y_min != y_max and buf != 0:
+        dist_x = x_max - x_min
+        dist_y = y_max - y_min
+        ax.set_xlim(x_min - buf * dist_x, x_max + buf * dist_x)
+        ax.set_ylim(y_min - buf * dist_y, y_max + buf * dist_y)
+    else:
+        ax.set_xlim(x_min, x_max)
+        ax.set_ylim(y_min, y_max)
+
+    plt.axis('off')
+    plt.tight_layout()
+    plt.show()
+
+
+def visualize_land_cover_grid_on_map(grid, rectangle_vertices, meshsize, source='Urbanwatch', vmin=None, vmax=None, alpha=0.5, buf=0.2, edge=True, basemap='CartoDB light'):
+    geod = initialize_geod()
+    land_cover_classes = get_land_cover_classes(source)
+    vertex_0 = rectangle_vertices[0]; vertex_1 = rectangle_vertices[1]; vertex_3 = rectangle_vertices[3]
+    dist_side_1 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_1[1], vertex_1[0])
+    dist_side_2 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_3[1], vertex_3[0])
+    side_1 = np.array(vertex_1) - np.array(vertex_0)
+    side_2 = np.array(vertex_3) - np.array(vertex_0)
+    u_vec = normalize_to_one_meter(side_1, dist_side_1)
+    v_vec = normalize_to_one_meter(side_2, dist_side_2)
+    origin = np.array(rectangle_vertices[0])
+    grid_size, adjusted_meshsize = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
+    transformer = setup_transformer(CRS.from_epsg(4326), CRS.from_epsg(3857))
+    plot_grid(grid, origin, adjusted_meshsize, u_vec, v_vec, transformer, rectangle_vertices, 'land_cover', alpha=alpha, buf=buf, edge=edge, basemap=basemap, land_cover_classes=land_cover_classes)
+
+
+def visualize_building_height_grid_on_map(building_height_grid, filtered_buildings, rectangle_vertices, meshsize, vmin=None, vmax=None, color_map=None, alpha=0.5, buf=0.2, edge=True, basemap='CartoDB light'):
+    geod = initialize_geod()
+    vertex_0, vertex_1, vertex_3 = rectangle_vertices[0], rectangle_vertices[1], rectangle_vertices[3]
+    dist_side_1 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_1[1], vertex_1[0])
+    dist_side_2 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_3[1], vertex_3[0])
+    side_1 = np.array(vertex_1) - np.array(vertex_0)
+    side_2 = np.array(vertex_3) - np.array(vertex_0)
+    u_vec = normalize_to_one_meter(side_1, dist_side_1)
+    v_vec = normalize_to_one_meter(side_2, dist_side_2)
+    origin = np.array(rectangle_vertices[0])
+    _, adjusted_meshsize = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
+    transformer = setup_transformer(CRS.from_epsg(4326), CRS.from_epsg(3857))
+    plot_grid(building_height_grid, origin, adjusted_meshsize, u_vec, v_vec, transformer,
+              rectangle_vertices, 'building_height', vmin=vmin, vmax=vmax, color_map=color_map, alpha=alpha, buf=buf, edge=edge, basemap=basemap, buildings=filtered_buildings)
+
+
+def visualize_numerical_grid_on_map(canopy_height_grid, rectangle_vertices, meshsize, type, vmin=None, vmax=None, color_map=None, alpha=0.5, buf=0.2, edge=True, basemap='CartoDB light'):
+    geod = initialize_geod()
+    vertex_0, vertex_1, vertex_3 = rectangle_vertices[0], rectangle_vertices[1], rectangle_vertices[3]
+    dist_side_1 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_1[1], vertex_1[0])
+    dist_side_2 = calculate_distance(geod, vertex_0[1], vertex_0[0], vertex_3[1], vertex_3[0])
+    side_1 = np.array(vertex_1) - np.array(vertex_0)
+    side_2 = np.array(vertex_3) - np.array(vertex_0)
+    u_vec = normalize_to_one_meter(side_1, dist_side_1)
+    v_vec = normalize_to_one_meter(side_2, dist_side_2)
+    origin = np.array(rectangle_vertices[0])
+    _, adjusted_meshsize = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
+    transformer = setup_transformer(CRS.from_epsg(4326), CRS.from_epsg(3857))
+    plot_grid(canopy_height_grid, origin, adjusted_meshsize, u_vec, v_vec, transformer,
+              rectangle_vertices, type, vmin=vmin, vmax=vmax, color_map=color_map, alpha=alpha, buf=buf, edge=edge, basemap=basemap)
+
+
+
+
+
+
+
+

voxcity/visualizer/palette.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+
+def get_voxel_color_map(color_scheme='default'):
+    """
+    Returns a color map for voxel visualization based on the specified color scheme.
+
+    This function provides multiple predefined color schemes for visualizing voxel data.
+    Each scheme maps voxel class IDs to RGB color values [0-255]. The class IDs follow
+    a specific convention where negative values represent built environment elements
+    and positive values represent natural/ground surface elements.
+    """
+    if color_scheme == 'default':
+        return {
+            -99: [0, 0, 0],
+            -30: [255, 0, 102],
+            -17: [238, 242, 234],
+            -16: [56, 78, 84],
+            -15: [147, 140, 114],
+            -14: [139, 149, 159],
+            -13: [186, 187, 181],
+            -12: [248, 166, 2],
+            -11: [81, 59, 56],
+            -3: [180, 187, 216],
+            -2: [78, 99, 63],
+            -1: [188, 143, 143],
+            1: [239, 228, 176],
+            2: [123, 130, 59],
+            3: [97, 140, 86],
+            4: [112, 120, 56],
+            5: [116, 150, 66],
+            6: [187, 204, 40],
+            7: [77, 118, 99],
+            8: [22, 61, 51],
+            9: [44, 66, 133],
+            10: [205, 215, 224],
+            11: [108, 119, 129],
+            12: [59, 62, 87],
+            13: [150, 166, 190],
+            14: [239, 228, 176],
+        }
+    elif color_scheme == 'high_contrast':
+        return {
+            -99: [0, 0, 0],
+            -30: [255, 0, 255],
+            -17: [255, 255, 255],
+            -16: [0, 0, 255],
+            -15: [153, 76, 0],
+            -14: [192, 192, 192],
+            -13: [128, 128, 128],
+            -12: [255, 128, 0],
+            -11: [153, 0, 0],
+            -3: [0, 255, 255],
+            -2: [0, 153, 0],
+            -1: [204, 0, 102],
+            1: [255, 255, 153],
+            2: [102, 153, 0],
+            3: [0, 204, 0],
+            4: [153, 204, 0],
+            5: [0, 102, 0],
+            6: [204, 255, 51],
+            7: [0, 153, 153],
+            8: [0, 51, 0],
+            9: [0, 102, 204],
+            10: [255, 255, 255],
+            11: [76, 76, 76],
+            12: [0, 0, 0],
+            13: [102, 102, 255],
+            14: [255, 204, 153],
+        }
+    elif color_scheme == 'monochrome':
+        return {
+            -99: [0, 0, 0],
+            -30: [28, 28, 99],
+            -17: [242, 242, 242],
+            -16: [51, 51, 153],
+            -15: [102, 102, 204],
+            -14: [153, 153, 204],
+            -13: [204, 204, 230],
+            -12: [76, 76, 178],
+            -11: [25, 25, 127],
+            -3: [179, 179, 230],
+            -2: [51, 51, 153],
+            -1: [102, 102, 178],
+            1: [230, 230, 255],
+            2: [128, 128, 204],
+            3: [102, 102, 204],
+            4: [153, 153, 230],
+            5: [76, 76, 178],
+            6: [204, 204, 255],
+            7: [76, 76, 178],
+            8: [25, 25, 127],
+            9: [51, 51, 204],
+            10: [242, 242, 255],
+            11: [128, 128, 178],
+            12: [51, 51, 127],
+            13: [153, 153, 204],
+            14: [230, 230, 255],
+        }
+    elif color_scheme == 'pastel':
+        return {
+            -99: [0, 0, 0],
+            -30: [255, 179, 217],
+            -17: [245, 245, 245],
+            -16: [173, 196, 230],
+            -15: [222, 213, 196],
+            -14: [211, 219, 226],
+            -13: [226, 226, 226],
+            -12: [255, 223, 179],
+            -11: [204, 168, 166],
+            -3: [214, 217, 235],
+            -2: [190, 207, 180],
+            -1: [235, 204, 204],
+            1: [250, 244, 227],
+            2: [213, 217, 182],
+            3: [200, 226, 195],
+            4: [209, 214, 188],
+            5: [195, 220, 168],
+            6: [237, 241, 196],
+            7: [180, 210, 205],
+            8: [176, 196, 190],
+            9: [188, 206, 235],
+            10: [242, 245, 250],
+            11: [209, 213, 219],
+            12: [189, 190, 204],
+            13: [215, 221, 232],
+            14: [250, 244, 227],
+        }
+    elif color_scheme == 'dark_mode':
+        return {
+            -99: [0, 0, 0],
+            -30: [153, 51, 102],
+            -17: [76, 76, 76],
+            -16: [33, 46, 51],
+            -15: [89, 84, 66],
+            -14: [83, 89, 94],
+            -13: [61, 61, 61],
+            -12: [153, 102, 0],
+            -11: [51, 35, 33],
+            -3: [78, 82, 99],
+            -2: [46, 58, 37],
+            -1: [99, 68, 68],
+            1: [102, 97, 75],
+            2: [61, 66, 31],
+            3: [46, 77, 46],
+            4: [56, 61, 28],
+            5: [54, 77, 31],
+            6: [89, 97, 20],
+            7: [38, 59, 49],
+            8: [16, 31, 26],
+            9: [22, 33, 66],
+            10: [82, 87, 92],
+            11: [46, 51, 56],
+            12: [25, 31, 43],
+            13: [56, 64, 82],
+            14: [102, 97, 75],
+        }
+    elif color_scheme == 'grayscale':
+        return {
+            -99: [0, 0, 0],
+            -30: [253, 231, 37],
+            -17: [240, 240, 240],
+            -16: [60, 60, 60],
+            -15: [130, 130, 130],
+            -14: [150, 150, 150],
+            -13: [180, 180, 180],
+            -12: [170, 170, 170],
+            -11: [70, 70, 70],
+            -3: [190, 190, 190],
+            -2: [90, 90, 90],
+            -1: [160, 160, 160],
+            1: [230, 230, 230],
+            2: [120, 120, 120],
+            3: [110, 110, 110],
+            4: [115, 115, 115],
+            5: [100, 100, 100],
+            6: [210, 210, 210],
+            7: [95, 95, 95],
+            8: [40, 40, 40],
+            9: [50, 50, 50],
+            10: [220, 220, 220],
+            11: [140, 140, 140],
+            12: [30, 30, 30],
+            13: [170, 170, 170],
+            14: [230, 230, 230],
+        }
+    elif color_scheme == 'white_mode':
+        return {
+            -99: [0, 0, 0],
+            -30: [220, 80, 80],
+            -17: [250, 250, 250],
+            -16: [210, 225, 235],
+            -15: [230, 225, 215],
+            -14: [225, 230, 235],
+            -13: [236, 236, 236],
+            -12: [245, 232, 210],
+            -11: [235, 210, 205],
+            -3: [225, 230, 240],
+            -2: [190, 210, 190],
+            -1: [230, 215, 215],
+            1: [248, 245, 235],
+            2: [225, 235, 215],
+            3: [220, 235, 220],
+            4: [240, 235, 215],
+            5: [210, 230, 210],
+            6: [245, 250, 235],
+            7: [220, 235, 230],
+            8: [205, 215, 210],
+            9: [200, 220, 245],
+            10: [252, 252, 252],
+            11: [230, 230, 230],
+            12: [210, 210, 215],
+            13: [230, 235, 240],
+            14: [248, 245, 235],
+        }
+    else:
+        # Fallback to default palette for unknown schemes
+        return get_voxel_color_map('default')
+
+
+
+
+
+
+
+
+
+