voxcity 0.3.17__tar.gz → 0.3.19__tar.gz

{voxcity-0.3.17 → voxcity-0.3.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: voxcity
-Version: 0.3.17
+Version: 0.3.19
 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.17 → voxcity-0.3.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "voxcity"
-version = "0.3.17"
+version = "0.3.19"
 requires-python = ">=3.10,<3.13"
 classifiers = [
     "Programming Language :: Python :: 3.10",
@@ -52,6 +52,9 @@ dependencies = [
     "astral",
     "osmnx",
     "joblib",
+    "trimesh",
+    "pyvista",
+    "IPython"
 ]
 
 [project.optional-dependencies]

{voxcity-0.3.17 → voxcity-0.3.19}/src/voxcity/geoprocessor/__init_.py

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

voxcity-0.3.19/src/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-0.3.17 → voxcity-0.3.19}/src/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-0.3.17 → voxcity-0.3.19}/src/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("view_point_height", 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.17 → voxcity-0.3.19}/src/voxcity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: voxcity
-Version: 0.3.17
+Version: 0.3.19
 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.17 → voxcity-0.3.19}/src/voxcity.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ src/voxcity/exporter/obj.py
 src/voxcity/geoprocessor/__init_.py
 src/voxcity/geoprocessor/draw.py
 src/voxcity/geoprocessor/grid.py
+src/voxcity/geoprocessor/mesh.py
 src/voxcity/geoprocessor/network.py
 src/voxcity/geoprocessor/polygon.py
 src/voxcity/geoprocessor/utils.py

{voxcity-0.3.17 → voxcity-0.3.19}/src/voxcity.egg-info/requires.txt

@@ -33,6 +33,9 @@ timezonefinder
 astral
 osmnx
 joblib
+trimesh
+pyvista
+IPython
 
 [dev]
 coverage