voxcity 0.3.16__py3-none-any.whl → 0.3.18__py3-none-any.whl

voxcity/downloader/gee.py

@@ -393,4 +393,35 @@ def save_geotiff_open_buildings_temporal(aoi, geotiff_path):
         scale=4,
         region=aoi,
         file_per_band=False
-    )
+    )
+
+def save_geotiff_england_dsm_minus_dtm(roi, geotiff_path, meshsize):
+    """Get the height difference between DSM and DTM from England 1m terrain data.
+    
+    Args:
+        roi: Earth Engine geometry defining area of interest
+        geotiff_path: Output path for GeoTIFF file
+        meshsize: Size of each grid cell in meters
+        
+    Returns:
+        ee.Image: Image representing DSM minus DTM (building/vegetation heights)
+    """
+    # Initialize Earth Engine
+    ee.Initialize()
+
+    # Add buffer around ROI to ensure smooth interpolation at edges
+    buffer_distance = 100
+    roi_buffered = roi.buffer(buffer_distance)
+
+    collection_name = 'UK/EA/ENGLAND_1M_TERRAIN/2022'
+    dtm = ee.Image(collection_name).select('dtm')
+    dsm = ee.Image(collection_name).select('dsm_first')
+    
+    # Subtract DTM from DSM to get height difference
+    height_diff = dsm.subtract(dtm)
+
+    # Clip to buffered ROI
+    image = height_diff.clip(roi_buffered)
+
+    # Export as GeoTIFF using meshsize as scale
+    save_geotiff(image, geotiff_path, scale=meshsize, region=roi_buffered, crs='EPSG:4326')

voxcity/generator.py

@@ -34,7 +34,8 @@ from .downloader.gee import (
     save_geotiff_esa_land_cover,
     save_geotiff_esri_landcover,
     save_geotiff_dynamic_world_v1,
-    save_geotiff_open_buildings_temporal
+    save_geotiff_open_buildings_temporal,
+    save_geotiff_england_dsm_minus_dtm
 )
 from .geoprocessor.grid import (
     group_and_label_cells, 
@@ -200,6 +201,13 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, *
             geotiff_path_comp = os.path.join(output_dir, "building_height.tif")
             save_geotiff_open_buildings_temporal(roi, geotiff_path_comp)
             building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(gdf, meshsize, rectangle_vertices, geotiff_path_comp=geotiff_path_comp, complement_height=building_complement_height)   
+        elif building_complementary_source == "England 1m DSM - DTM":
+            # Special case: use temporal height data as complement
+            roi = get_roi(rectangle_vertices)
+            os.makedirs(output_dir, exist_ok=True)
+            geotiff_path_comp = os.path.join(output_dir, "building_height.tif")
+            save_geotiff_england_dsm_minus_dtm(roi, geotiff_path_comp, meshsize)
+            building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings = create_building_height_grid_from_gdf_polygon(gdf, meshsize, rectangle_vertices, geotiff_path_comp=geotiff_path_comp, complement_height=building_complement_height)
         else:
             # Get complementary data from other sources
             if building_complementary_source == 'Microsoft Building Footprints':

voxcity/geoprocessor/__init_.py

@@ -3,3 +3,4 @@ from .grid import *
 from .utils import *
 from .network import *
 from .polygon import *
+from .mesh import *

voxcity/geoprocessor/mesh.py

@@ -0,0 +1,269 @@
+import numpy as np
+import trimesh
+import matplotlib.colors as mcolors
+import matplotlib.cm as cm
+
+def create_voxel_mesh(voxel_array, class_id, meshsize=1.0):
+    """
+    Create a mesh from voxels preserving sharp edges, scaled by meshsize.
+
+    Parameters
+    ----------
+    voxel_array : np.ndarray (3D)
+        The voxel array of shape (X, Y, Z).
+    class_id : int
+        The ID of the class to extract.
+    meshsize : float
+        The real-world size of each voxel in meters, for x, y, and z.
+
+    Returns
+    -------
+    mesh : trimesh.Trimesh or None
+        The resulting mesh for the given class_id (or None if no voxels).
+    """
+    # Find voxels of the current class
+    voxel_coords = np.argwhere(voxel_array == class_id)
+
+    if len(voxel_coords) == 0:
+        return None
+
+    # Define the 6 faces of a unit cube (local coordinates 0..1)
+    unit_faces = np.array([
+        # Front
+        [[0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]],
+        # Back
+        [[0, 0, 0], [0, 1, 0], [1, 1, 0], [1, 0, 0]],
+        # Right
+        [[1, 0, 0], [1, 1, 0], [1, 1, 1], [1, 0, 1]],
+        # Left
+        [[0, 0, 0], [0, 0, 1], [0, 1, 1], [0, 1, 0]],
+        # Top
+        [[0, 1, 0], [0, 1, 1], [1, 1, 1], [1, 1, 0]],
+        # Bottom
+        [[0, 0, 0], [1, 0, 0], [1, 0, 1], [0, 0, 1]]
+    ])
+
+    # Define face normals
+    face_normals = np.array([
+        [0, 0, 1],   # Front
+        [0, 0, -1],  # Back
+        [1, 0, 0],   # Right
+        [-1, 0, 0],  # Left
+        [0, 1, 0],   # Top
+        [0, -1, 0]   # Bottom
+    ])
+
+    vertices = []
+    faces = []
+    face_normals_list = []
+
+    for x, y, z in voxel_coords:
+        # Check each face of the current voxel
+        adjacent_coords = [
+            (x,   y,   z+1),  # Front
+            (x,   y,   z-1),  # Back
+            (x+1, y,   z),    # Right
+            (x-1, y,   z),    # Left
+            (x,   y+1, z),    # Top
+            (x,   y-1, z)     # Bottom
+        ]
+
+        # Only create faces where there's a transition between this class and "not this class"
+        for face_idx, adj_coord in enumerate(adjacent_coords):
+            try:
+                # If adj_coord is outside array bounds, it's a boundary => face is visible
+                if adj_coord[0] < 0 or adj_coord[1] < 0 or adj_coord[2] < 0:
+                    is_boundary = True
+                else:
+                    adj_value = voxel_array[adj_coord]
+                    is_boundary = (adj_value == 0 or adj_value != class_id)
+            except IndexError:
+                # Out of range => boundary
+                is_boundary = True
+
+            if is_boundary:
+                # Local face in (0..1) for x,y,z, then shift by voxel coords
+                face_verts = (unit_faces[face_idx] + np.array([x, y, z])) * meshsize
+                current_vert_count = len(vertices)
+
+                vertices.extend(face_verts)
+                # Convert quad to two triangles
+                faces.extend([
+                    [current_vert_count, current_vert_count + 1, current_vert_count + 2],
+                    [current_vert_count, current_vert_count + 2, current_vert_count + 3]
+                ])
+                # Add face normals for both triangles
+                face_normals_list.extend([face_normals[face_idx], face_normals[face_idx]])
+
+    if not vertices:
+        return None
+
+    vertices = np.array(vertices)
+    faces = np.array(faces)
+    face_normals_list = np.array(face_normals_list)
+
+    # Create mesh
+    mesh = trimesh.Trimesh(
+        vertices=vertices,
+        faces=faces,
+        face_normals=face_normals_list
+    )
+
+    # Merge vertices that are at the same position
+    mesh.merge_vertices()
+
+    return mesh
+
+def create_sim_surface_mesh(sim_grid, dem_grid,
+                            meshsize=1.0, z_offset=1.5,
+                            cmap_name='viridis',
+                            vmin=None, vmax=None):
+    """
+    Create a planar surface mesh from sim_grid located at dem_grid + z_offset.
+    Skips any cells in sim_grid that are NaN, and flips both sim_grid and dem_grid
+    (up-down) to match voxel_array orientation. Applies meshsize scaling in x,y.
+
+    Parameters
+    ----------
+    sim_grid : 2D np.ndarray
+        2D array of simulation values (e.g., Green View Index).
+    dem_grid : 2D np.ndarray
+        2D array of ground elevations (same shape as sim_grid).
+    meshsize : float
+        Size of each cell in meters (same in x and y).
+    z_offset : float
+        Additional offset added to dem_grid for placing the mesh.
+    cmap_name : str
+        Matplotlib colormap name. Default is 'viridis'.
+    vmin : float or None
+        Minimum value for color mapping. If None, use min of sim_grid (non-NaN).
+    vmax : float or None
+        Maximum value for color mapping. If None, use max of sim_grid (non-NaN).
+
+    Returns
+    -------
+    trimesh.Trimesh or None
+        A single mesh containing one square face per non-NaN cell.
+        Returns None if there are no valid cells.
+    """
+    # Flip arrays vertically
+    sim_grid_flipped = np.flipud(sim_grid)
+    dem_grid_flipped = np.flipud(dem_grid)
+
+    # Identify valid (non-NaN) values
+    valid_mask = ~np.isnan(sim_grid_flipped)
+    valid_values = sim_grid_flipped[valid_mask]
+    if valid_values.size == 0:
+        return None
+
+    # If vmin/vmax not provided, use actual min/max of the valid sim data
+    if vmin is None:
+        vmin = np.nanmin(valid_values)
+    if vmax is None:
+        vmax = np.nanmax(valid_values)
+
+    # Prepare the colormap
+    norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
+    scalar_map = cm.ScalarMappable(norm=norm, cmap=cmap_name)
+
+    vertices = []
+    faces = []
+    face_colors = []
+
+    vert_index = 0
+    nrows, ncols = sim_grid_flipped.shape
+
+    # Build a quad (two triangles) for each valid cell
+    for x in range(nrows):
+        for y in range(ncols):
+            val = sim_grid_flipped[x, y]
+            if np.isnan(val):
+                continue
+
+            z_base = dem_grid_flipped[x, y] + z_offset
+
+            # 4 corners in (x,y)*meshsize
+            v0 = [ x      * meshsize,  y      * meshsize, z_base ]
+            v1 = [(x + 1) * meshsize,  y      * meshsize, z_base ]
+            v2 = [(x + 1) * meshsize, (y + 1) * meshsize, z_base ]
+            v3 = [ x      * meshsize, (y + 1) * meshsize, z_base ]
+
+            vertices.extend([v0, v1, v2, v3])
+            faces.extend([
+                [vert_index,     vert_index + 1, vert_index + 2],
+                [vert_index,     vert_index + 2, vert_index + 3]
+            ])
+
+            # Get color from colormap
+            color_rgba = np.array(scalar_map.to_rgba(val))  # shape (4,)
+
+            # Each cell has 2 faces => add the color twice
+            face_colors.append(color_rgba)
+            face_colors.append(color_rgba)
+
+            vert_index += 4
+
+    if len(vertices) == 0:
+        return None
+
+    vertices = np.array(vertices, dtype=float)
+    faces = np.array(faces, dtype=int)
+    face_colors = np.array(face_colors, dtype=float)
+
+    mesh = trimesh.Trimesh(
+        vertices=vertices,
+        faces=faces,
+        face_colors=face_colors,
+        process=False  # skip auto merge if you want to preserve quads
+    )
+
+    return mesh
+
+def create_city_meshes(voxel_array, vox_dict, meshsize=1.0):
+    """
+    Create meshes from voxel data with sharp edges preserved.
+    Applies meshsize for voxel scaling.
+    """
+    meshes = {}
+
+    # Convert RGB colors to hex for material properties
+    color_dict = {k: mcolors.rgb2hex([v[0]/255, v[1]/255, v[2]/255])
+                 for k, v in vox_dict.items() if k != 0}  # Exclude air
+
+    # Create vertices and faces for each object class
+    for class_id in np.unique(voxel_array):
+        if class_id == 0:  # Skip air
+            continue
+
+        try:
+            mesh = create_voxel_mesh(voxel_array, class_id, meshsize=meshsize)
+
+            if mesh is None:
+                continue
+
+            # Convert hex color to RGBA
+            rgb_color = np.array(mcolors.hex2color(color_dict[class_id]))
+            rgba_color = np.concatenate([rgb_color, [1.0]])
+
+            # Assign color to all faces
+            mesh.visual.face_colors = np.tile(rgba_color, (len(mesh.faces), 1))
+
+            meshes[class_id] = mesh
+
+        except ValueError as e:
+            print(f"Skipping class {class_id}: {e}")
+
+    return meshes
+
+def export_meshes(meshes, output_directory, base_filename):
+    """
+    Export meshes to OBJ (with MTL) and STL formats.
+    """
+    # Export combined mesh as OBJ with materials
+    combined_mesh = trimesh.util.concatenate(list(meshes.values()))
+    combined_mesh.export(f"{output_directory}/{base_filename}.obj")
+
+    # Export individual meshes as STL
+    for class_id, mesh in meshes.items():
+        # Convert class_id to a string for filename
+        mesh.export(f"{output_directory}/{base_filename}_{class_id}.stl")

voxcity/geoprocessor/polygon.py

@@ -625,8 +625,8 @@ def extract_building_heights_from_geotiff(geotiff_path, gdf):
     # Print statistics about height updates
     if count_0 > 0:
         print(f"{count_0} of the total {len(gdf)} building footprint from OSM did not have height data.")
-        print(f"For {count_1} of these building footprints without height, values from Open Building 2.5D Temporal were assigned.")
-        print(f"For {count_2} of these building footprints without height, no data exist in Open Building 2.5D Temporal. Height values of 10m were set instead")
+        print(f"For {count_1} of these building footprints without height, values from complementary data were assigned.")
+        print(f"For {count_2} of these building footprints without height, no data exist in complementary data. Height values of 10m were set instead")
 
     return gdf
 

voxcity/utils/visualization.py

@@ -16,6 +16,10 @@ import seaborn as sns
 import random
 import folium
 import math
+import trimesh
+import pyvista as pv
+from IPython.display import display
+import os
 
 from .lc import get_land_cover_classes
 # from ..geo.geojson import filter_buildings
@@ -25,7 +29,6 @@ from ..geoprocessor.grid import (
     create_cell_polygon,
     grid_to_geodataframe
 )
-
 from ..geoprocessor.utils import (
     initialize_geod,
     calculate_distance,
@@ -33,6 +36,12 @@ from ..geoprocessor.utils import (
     setup_transformer,
     transform_coords,
 )
+from ..geoprocessor.mesh import (
+    create_voxel_mesh,
+    create_sim_surface_mesh,
+    create_city_meshes,
+    export_meshes
+)
 from .material import get_material_dict
 
 def get_default_voxel_color_map():
@@ -911,4 +920,282 @@ def visualize_point_grid_on_basemap(point_gdf, value_name='value', **kwargs):
     
     # Adjust layout to prevent colorbar cutoff
     plt.tight_layout()
-    plt.show()
+    plt.show()
+
+def create_multi_view_scene(meshes, output_directory="output"):
+    """
+    Create multiple views of the scene from different angles.
+    """
+    # Get the first mesh to compute bounding box
+    first_mesh = next(iter(meshes.values()))
+    vertices = first_mesh.vertices
+    bbox = np.array([
+        [vertices[:, 0].min(), vertices[:, 1].min(), vertices[:, 2].min()],
+        [vertices[:, 0].max(), vertices[:, 1].max(), vertices[:, 2].max()]
+    ])
+
+    # Compute the center and diagonal of the bounding box
+    center = (bbox[1] + bbox[0]) / 2
+    diagonal = np.linalg.norm(bbox[1] - bbox[0])
+
+    # Use the diagonal to set the camera distance
+    distance = diagonal * 2
+
+    # Define the isometric viewing angles
+    iso_angles = {
+        'iso_front_right': (1, 1, 0.7),
+        'iso_front_left': (-1, 1, 0.7),
+        'iso_back_right': (1, -1, 0.7),
+        'iso_back_left': (-1, -1, 0.7)
+    }
+
+    # Compute camera positions for isometric views
+    camera_positions = {}
+    for name, direction in iso_angles.items():
+        direction = np.array(direction)
+        direction = direction / np.linalg.norm(direction)
+        camera_pos = center + direction * distance
+        camera_positions[name] = [camera_pos, center, (0, 0, 1)]
+
+    # Add orthographic views
+    ortho_views = {
+        'xy_top': [center + np.array([0, 0, distance]), center, (0, 1, 0)],
+        'yz_right': [center + np.array([distance, 0, 0]), center, (0, 0, 1)],
+        'xz_front': [center + np.array([0, distance, 0]), center, (0, 0, 1)],
+        'yz_left': [center + np.array([-distance, 0, 0]), center, (0, 0, 1)],
+        'xz_back': [center + np.array([0, -distance, 0]), center, (0, 0, 1)]
+    }
+    camera_positions.update(ortho_views)
+
+    images = []
+    for view_name, camera_pos in camera_positions.items():
+        # Create new plotter for each view
+        plotter = pv.Plotter(notebook=True, off_screen=True)
+
+        # Add each mesh to the scene
+        for class_id, mesh in meshes.items():
+            vertices = mesh.vertices
+            faces = np.hstack([[3, *face] for face in mesh.faces])
+            pv_mesh = pv.PolyData(vertices, faces)
+
+            if hasattr(mesh.visual, 'face_colors'):
+                colors = mesh.visual.face_colors
+                if colors.max() > 1:
+                    colors = colors / 255.0
+                pv_mesh.cell_data['colors'] = colors
+
+            plotter.add_mesh(pv_mesh,
+                           rgb=True,
+                           scalars='colors' if hasattr(mesh.visual, 'face_colors') else None)
+
+        # Set camera position for this view
+        plotter.camera_position = camera_pos
+
+        # Save screenshot
+        filename = f'{output_directory}/city_view_{view_name}.png'
+        plotter.screenshot(filename)
+        images.append((view_name, filename))
+        plotter.close()
+
+    return images
+
+def visualize_voxcity_multi_view(voxel_array, **kwargs):
+    """
+    Create multiple views of the voxel city data.
+    """
+
+    os.system('Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &')
+    os.environ['DISPLAY'] = ':99'
+
+    # Configure PyVista settings
+    pv.set_plot_theme('document')
+    pv.global_theme.background = 'white'
+    pv.global_theme.window_size = [1024, 768]
+    pv.global_theme.jupyter_backend = 'static'
+
+# view_kwargs = {
+#     "view_point_height": 1.5, # To set height of view point in meters. Default: 1.5 m.
+#     "dem_grid": dem_grid,
+#     "colormap": 'viridis', # Choose a colormap. Default: 'viridis'.
+#     "obj_export": True, # Set "True" if you want to export the result in an OBJ file.
+#     "output_directory": f'output/{key}/obj', # To set directory path for output files. Default: False.
+#     "output_file_name": 'gvi', # To set file name excluding extension. Default: 'view_index'.
+#     "num_colors": 10, # Number of discrete colors
+#     "alpha": 1.0, # Set transparency (0.0 to 1.0)
+#     "vmin": 0.0, # Minimum value for colormap normalization
+#     "vmax": 1.0 # Maximum value for colormap normalization
+# }
+    # Parse kwargs
+    vox_dict = kwargs.get("vox_dict", get_default_voxel_color_map())
+    output_directory = kwargs.get("output_directory", 'output')
+    base_filename = kwargs.get("output_file_name", None)
+    sim_grid = kwargs.get("sim_grid", None)
+    dem_grid = kwargs.get("dem_grid", None)
+    meshsize = kwargs.get("meshsize", 1.0) / 5
+    z_offset = kwargs.get("z_offset", 1.5)
+    cmap_name = kwargs.get("colormap", "viridis")
+    vmin = kwargs.get("vmin", 0)
+    vmax = kwargs.get("vmax", 1)
+
+    # Create meshes
+    print("Creating voxel meshes...")
+    meshes = create_city_meshes(voxel_array, vox_dict, meshsize=meshsize)
+
+    # Create sim_grid surface mesh if provided
+    if sim_grid is not None and dem_grid is not None:
+        print("Creating sim_grid surface mesh...")
+        sim_mesh = create_sim_surface_mesh(
+            sim_grid, dem_grid,
+            meshsize=meshsize,
+            z_offset=z_offset,
+            cmap_name=cmap_name,
+            vmin=vmin,
+            vmax=vmax
+        )
+        if sim_mesh is not None:
+            meshes["sim_surface"] = sim_mesh
+
+    # Export if filename provided
+    if base_filename is not None:
+        print(f"Exporting files to '{base_filename}.*' ...")# Create output directory if it doesn't exist
+        os.makedirs(output_directory, exist_ok=True)
+        export_meshes(meshes, output_directory, base_filename)
+
+    # Create and save multiple views
+    print("Creating multiple views...")        
+    # Create output directory if it doesn't exist
+    os.makedirs(output_directory, exist_ok=True)
+    image_files = create_multi_view_scene(meshes, output_directory=output_directory)
+
+    # Display each view separately
+    for view_name, img_file in image_files:
+        plt.figure(figsize=(12, 8))
+        img = plt.imread(img_file)
+        plt.imshow(img)
+        plt.title(view_name.replace('_', ' ').title(), pad=20)
+        plt.axis('off')
+        plt.show()
+        plt.close()
+
+# def create_interactive_scene(meshes):
+#     scene = trimesh.Scene()
+#     scene.ambient_light = np.array([0.1, 0.1, 0.1, 1.0])
+#     scene.directional_light = np.array([0.1, 0.1, 0.1, 1.0])
+
+#     for class_id, mesh in meshes.items():
+
+#         # If this is our sim_surface, do NOT override the per-face colors.
+#         if class_id == "sim_surface":
+#             # Just add the mesh as-is, retaining mesh.visual.face_colors
+#             scene.add_geometry(mesh, node_name=f"class_{class_id}")
+#         else:
+#             # Existing code for single-color classes
+#             material = trimesh.visual.material.PBRMaterial(
+#                 baseColorFactor=mesh.visual.face_colors[0],
+#                 metallicFactor=0.2,
+#                 roughnessFactor=0.8,
+#                 emissiveFactor=np.array([0.1, 0.1, 0.1]),
+#                 alphaMode='OPAQUE'
+#             )
+#             mesh.visual = trimesh.visual.TextureVisuals(
+#                 material=material,
+#                 uv=None
+#             )
+#             scene.add_geometry(mesh, node_name=f"class_{class_id}")
+
+#     # (Optional) add checkboxes if in Jupyter:
+#     try:
+#         import ipywidgets as widgets
+#         from IPython.display import display
+
+#         def update_visibility(cid, visible):
+#             scene.graph.nodes[f"class_{cid}"].visible = visible
+
+#         checkboxes = []
+#         for cid in meshes.keys():
+#             checkbox = widgets.Checkbox(value=True, description=f'Class {cid}')
+#             checkbox.observe(
+#                 lambda change, _cid=cid: update_visibility(_cid, change['new']),
+#                 names='value'
+#             )
+#             checkboxes.append(checkbox)
+#         display(widgets.VBox(checkboxes))
+#     except ImportError:
+#         pass  # Not running in Jupyter
+
+#     return scene
+
+# def visualize_voxcity_interactive(voxel_array, **kwargs):
+#     """
+#     Process voxel city data:
+#     - create voxel meshes,
+#     - optionally create a sim_grid surface mesh,
+#     - optionally export,
+#     - return a trimesh Scene for visualization.
+
+#     Optional arguments via **kwargs:
+#     --------------------------------
+#     base_filename : str, default "city_model"
+#         Base name for exported files (OBJ, STL).
+#     sim_grid : 2D np.ndarray or None, default None
+#         Simulation array for creating a 2D surface mesh.
+#     dem_grid : 2D np.ndarray or None, default None
+#         DEM array for the surface mesh. Must match sim_grid shape.
+#     meshsize : float, default 1.0
+#         Real-world size (in meters) per voxel/cell in x,y,z.
+#     z_offset : float, default 1.5
+#         Offset added to dem_grid when placing sim_grid surface.
+#     cmap_name : str, default 'viridis'
+#         Matplotlib colormap name for sim_grid.
+#     vmin : float or None, default 0
+#         Minimum value for color mapping. If None, auto from data.
+#     vmax : float or None, default 1
+#         Maximum value for color mapping. If None, auto from data.
+#     """
+
+#     # 1. Parse **kwargs
+#     vox_dict = kwargs.get("vox_dict", get_default_voxel_color_map())
+#     base_filename = kwargs.get("base_filename", None)
+#     sim_grid = kwargs.get("sim_grid", None)
+#     dem_grid = kwargs.get("dem_grid", None)
+#     meshsize = kwargs.get("meshsize", 1.0) / 5
+#     z_offset = kwargs.get("z_offset", 1.5)
+#     cmap_name = kwargs.get("cmap_name", "viridis")
+#     vmin = kwargs.get("vmin", 0)
+#     vmax = kwargs.get("vmax", 1)
+
+#     # 2. Create voxel-based meshes (same logic as before)
+#     print("Creating voxel meshes...")
+#     meshes = create_city_meshes(voxel_array, vox_dict, meshsize=meshsize)
+
+#     # 3. Optionally create the sim_grid surface mesh
+#     if sim_grid is not None and dem_grid is not None:
+#         print("Creating sim_grid surface mesh...")
+#         sim_mesh = create_sim_surface_mesh(
+#             sim_grid,
+#             dem_grid,
+#             meshsize=meshsize,
+#             z_offset=z_offset,
+#             cmap_name=cmap_name,
+#             vmin=vmin,
+#             vmax=vmax
+#         )
+#         if sim_mesh is not None:
+#             meshes["sim_surface"] = sim_mesh
+#         else:
+#             print("No valid cells in sim_grid (all NaN?). Skipping surface mesh.")
+
+#     # 4. Optionally export
+#     if base_filename is not None:
+#         print(f"Exporting files to '{base_filename}.*' ...")
+#         export_meshes(meshes, base_filename)
+#     else:
+#         print("Skipping export step.")
+
+#     # 5. Create interactive visualization (voxel + optional sim_surface)
+#     print("Creating interactive visualization...")
+#     scene = create_interactive_scene(meshes)
+
+#     scene.show()
+
+#     return scene

{voxcity-0.3.16.dist-info → voxcity-0.3.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: voxcity
-Version: 0.3.16
+Version: 0.3.18
 Summary: voxcity is an easy and one-stop tool to output 3d city models for microclimate simulation by integrating multiple geospatial open-data
 Author-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>
 Maintainer-email: Kunihiko Fujiwara <kunihiko@nus.edu.sg>
@@ -50,6 +50,9 @@ Requires-Dist: timezonefinder
 Requires-Dist: astral
 Requires-Dist: osmnx
 Requires-Dist: joblib
+Requires-Dist: trimesh
+Requires-Dist: pyvista
+Requires-Dist: IPython
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: mypy; extra == "dev"

{voxcity-0.3.16.dist-info → voxcity-0.3.18.dist-info}/RECORD

@@ -1,8 +1,8 @@
 voxcity/__init__.py,sha256=el9v3gfybHOF_GUYPeSOqN0-vCrTW0eU1mcvi0sEfeU,252
-voxcity/generator.py,sha256=3cr520doEAdoXasvdywiK0FOvIfh1YdALv4tlhFvbAk,33654
+voxcity/generator.py,sha256=2wmfiCXJREOC0zxq6GB8ECxtGjk42UYzGvf5vGZuEOg,34359
 voxcity/downloader/__init__.py,sha256=OgGcGxOXF4tjcEL6DhOnt13DYPTvOigUelp5xIpTqM0,171
 voxcity/downloader/eubucco.py,sha256=XCkkdEPNuWdrnuxzL80Ext37WsgiCiZGueb-aQV5rvI,14476
-voxcity/downloader/gee.py,sha256=j7jmzp44T3M6j_4DwhU9Y8Y6gqbZo1zFIlduQPc0jvk,14339
+voxcity/downloader/gee.py,sha256=C5Y3UFAK4-AcBQwUd5FQNDwwxT_iqfElAHWiVJTkF9k,15471
 voxcity/downloader/mbfp.py,sha256=5fXq9S7qNVSLDdVtj67Da1pBAJP6kL4P8qLZTOmWqdw,3895
 voxcity/downloader/oemj.py,sha256=YlCuWBQfi40gfmwQcGDeHiPOs4Pk_jLZq65d5R3IGMU,7886
 voxcity/downloader/omt.py,sha256=ByFvoQDnBOJF4qdVYNkDjn7cMvEhWwtD0mIV_T-zMEs,9017
@@ -13,11 +13,12 @@ voxcity/exporter/__init_.py,sha256=cVyNyE6axEpSd3CT5hGuMOAlOyU1p8lVP4jkF1-0Ad8,9
 voxcity/exporter/envimet.py,sha256=m-y2IYw-yp45AT2wN9UIlxvMjvDvupTKzyfRJl057fE,24300
 voxcity/exporter/magicavoxel.py,sha256=Fsv7yGRXeKmp82xcG3rOb0t_HtoqltNq2tHl08xVlqY,7500
 voxcity/exporter/obj.py,sha256=oW-kPoZj53nfmO9tXP3Wvizq6Kkjh-QQR8UBexRuMiI,21609
-voxcity/geoprocessor/__init_.py,sha256=FFJFf6idmAtmNkwfKPt3ERGSIzjb8tt35D1n9QQbCA8,112
+voxcity/geoprocessor/__init_.py,sha256=JzPVhhttxBWvaZ0IGX2w7OWL5bCo_TIvpHefWeNXruA,133
 voxcity/geoprocessor/draw.py,sha256=8Em2NvazFpYfFJUqG9LofNXaxdghKLL_rNuztmPwn8Q,13911
 voxcity/geoprocessor/grid.py,sha256=aLb_iInDrhh5cacQOOtHPZ9IWFTWsQtF6hEgsA6TB2Y,43761
+voxcity/geoprocessor/mesh.py,sha256=arXGQM5NUNazwU021vQwYhFdFrR_2Udl88uCQDZSh2s,9147
 voxcity/geoprocessor/network.py,sha256=opb_kpUCAxDd1qtrWPStqR5reYZtVe96XxazNSen7Lk,18851
-voxcity/geoprocessor/polygon.py,sha256=8fU2Ayu2Y_G1z7Mbj8KoSKVurdPuAVbASjGMVS36ftM,32249
+voxcity/geoprocessor/polygon.py,sha256=EeAlawsI0AQHctxG_1rS8y3sLFijwmWtdIFtLIXHUCg,32231
 voxcity/geoprocessor/utils.py,sha256=1BRHp-DDeOA8HG8jplY7Eo75G3oXkVGL6DGONL4BA8A,19815
 voxcity/simulator/__init_.py,sha256=APdkcdaovj0v_RPOaA4SBvFUKT2RM7Hxuuz3Sux4gCo,65
 voxcity/simulator/solar.py,sha256=FOcHoUm4miJNyeCcGs2oL93Vu38Affyywt29dJcmIT4,31974
@@ -26,11 +27,11 @@ voxcity/simulator/view.py,sha256=zNbfTLQ2Jo0V5-rFA3-xamRjOuw3H3MBrLKpQp8x3hY,367
 voxcity/utils/__init_.py,sha256=nLYrj2huBbDBNMqfchCwexGP8Tlt9O_XluVDG7MoFkw,98
 voxcity/utils/lc.py,sha256=RwPd-VY3POV3gTrBhM7TubgGb9MCd3nVah_G8iUEF7k,11562
 voxcity/utils/material.py,sha256=Vt3IID5Ft54HNJcEC4zi31BCPqi_687X3CSp7rXaRVY,5907
-voxcity/utils/visualization.py,sha256=2bv3y-1zkUX0cm_YbMHwe_Vt9J2R3QhouaVAGNifQXg,36805
+voxcity/utils/visualization.py,sha256=pMQRqmNiAfibRdfRLHy3wkZ7Qbs__cUEfvGF7va0Pak,47980
 voxcity/utils/weather.py,sha256=P6s1y_EstBL1OGP_MR_6u3vr-t6Uawg8uDckJnoI7FI,21482
-voxcity-0.3.16.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.3.16.dist-info/LICENSE,sha256=-hGliOFiwUrUSoZiB5WF90xXGqinKyqiDI2t6hrnam8,1087
-voxcity-0.3.16.dist-info/METADATA,sha256=d67Drf-UV5hy7212m7y3rPmqC-cZ8LwloyVYgwq3EsA,25114
-voxcity-0.3.16.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-voxcity-0.3.16.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
-voxcity-0.3.16.dist-info/RECORD,,
+voxcity-0.3.18.dist-info/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.3.18.dist-info/LICENSE,sha256=-hGliOFiwUrUSoZiB5WF90xXGqinKyqiDI2t6hrnam8,1087
+voxcity-0.3.18.dist-info/METADATA,sha256=DBPn1oJmBwUP3TZzUUN4H6PhPk56ESJUOC_or4GTMXA,25186
+voxcity-0.3.18.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+voxcity-0.3.18.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
+voxcity-0.3.18.dist-info/RECORD,,