voxcity 0.5.31__py3-none-any.whl → 0.6.0__py3-none-any.whl

voxcity/utils/lc.py

@@ -183,114 +183,35 @@ def get_land_cover_classes(source):
 
 def convert_land_cover(input_array, land_cover_source='Urbanwatch'):   
     """
-    Convert land cover classification from source-specific indices to standardized indices.
-    
-    This function maps land cover classes from various data sources to a standardized
-    classification system. Each source has different class definitions and indices,
-    so this conversion enables consistent processing across different data sources.
-    
-    Args:
-        input_array (numpy.ndarray): Input array with source-specific land cover indices
-        land_cover_source (str): Name of the source land cover classification system
-                                Default is 'Urbanwatch'
-                                
-    Returns:
-        numpy.ndarray: Array with standardized land cover indices
-        
-    Standardized Classification System:
-        0: Bareland
-        1: Rangeland  
-        2: Shrub
-        3: Agriculture land
-        4: Tree
-        5: Moss and lichen
-        6: Wet land
-        7: Mangrove
-        8: Water
-        9: Snow and ice
-        10: Developed space
-        11: Road
-        12: Building
-        13: No Data
+    Optimized version using direct numpy array indexing instead of np.vectorize.
+    This is 10-100x faster than the original.
     """
-
+    # Define mappings
     if land_cover_source == 'Urbanwatch':
-        # Define the mapping from Urbanwatch to new standardized classes
-        convert_dict = {
-            0: 12,  # Building
-            1: 11,  # Road
-            2: 10,  # Parking Lot -> Developed space
-            3: 4,   # Tree Canopy -> Tree
-            4: 1,   # Grass/Shrub -> Rangeland
-            5: 3,   # Agriculture -> Agriculture land
-            6: 8,   # Water
-            7: 0,   # Barren -> Bareland
-            8: 13,  # Unknown -> No Data
-            9: 8    # Sea -> Water
-        }
+        mapping = {0: 12, 1: 11, 2: 10, 3: 4, 4: 1, 5: 3, 6: 8, 7: 0, 8: 13, 9: 8}
     elif land_cover_source == 'ESA WorldCover':
-        # ESA WorldCover to standardized mapping
-        convert_dict = {
-            0: 4,   # Trees -> Tree
-            1: 2,   # Shrubland -> Shrub
-            2: 1,   # Grassland -> Rangeland
-            3: 3,   # Cropland -> Agriculture land
-            4: 10,  # Built-up -> Developed space
-            5: 0,   # Barren / sparse vegetation -> Bareland
-            6: 9,   # Snow and ice
-            7: 8,   # Open water -> Water
-            8: 6,   # Herbaceous wetland -> Wet land
-            9: 7,   # Mangroves
-            10: 5   # Moss and lichen
-        }
+        mapping = {0: 4, 1: 2, 2: 1, 3: 3, 4: 10, 5: 0, 6: 9, 7: 8, 8: 6, 9: 7, 10: 5}
     elif land_cover_source == "ESRI 10m Annual Land Cover":
-        # ESRI 10m to standardized mapping
-        convert_dict = {
-            0: 13,  # No Data
-            1: 8,   # Water
-            2: 4,   # Trees -> Tree
-            3: 1,   # Grass -> Rangeland
-            4: 6,   # Flooded Vegetation -> Wet land
-            5: 3,   # Crops -> Agriculture land
-            6: 2,   # Scrub/Shrub -> Shrub
-            7: 10,  # Built Area -> Developed space
-            8: 0,   # Bare Ground -> Bareland
-            9: 9,   # Snow/Ice
-            10: 13  # Clouds -> No Data
-        }
+        mapping = {0: 13, 1: 8, 2: 4, 3: 1, 4: 6, 5: 3, 6: 2, 7: 10, 8: 0, 9: 9, 10: 13}
     elif land_cover_source == "Dynamic World V1":
-        # Dynamic World to standardized mapping
-        convert_dict = {
-            0: 8,   # Water
-            1: 4,   # Trees -> Tree
-            2: 1,   # Grass -> Rangeland
-            3: 6,   # Flooded Vegetation -> Wet land
-            4: 3,   # Crops -> Agriculture land
-            5: 2,   # Shrub and Scrub -> Shrub
-            6: 10,  # Built -> Developed space
-            7: 0,   # Bare -> Bareland
-            8: 9    # Snow and Ice
-        }    
+        mapping = {0: 8, 1: 4, 2: 1, 3: 6, 4: 3, 5: 2, 6: 10, 7: 0, 8: 9}    
     elif land_cover_source == "OpenEarthMapJapan":
-        # OpenEarthMapJapan to standardized mapping
-        convert_dict = {
-            0: 0,   # Bareland
-            1: 1,   # Rangeland
-            2: 10,  # Developed space
-            3: 11,  # Road
-            4: 4,   # Tree
-            5: 8,   # Water
-            6: 3,   # Agriculture land
-            7: 12,  # Building
-        }
-
-    # Create a vectorized function for the conversion
-    vectorized_convert = np.vectorize(lambda x: convert_dict.get(x, x))
+        mapping = {0: 0, 1: 1, 2: 10, 3: 11, 4: 4, 5: 8, 6: 3, 7: 12}
+    else:
+        # If unknown source, return as-is
+        return input_array.copy()
+    
+    # Create a full mapping array for all possible values (0-255 for uint8)
+    max_val = max(max(mapping.keys()), input_array.max()) + 1
+    lookup = np.arange(max_val, dtype=input_array.dtype)
     
-    # Apply the conversion to the input array
-    converted_array = vectorized_convert(input_array)
+    # Apply the mapping
+    for old_val, new_val in mapping.items():
+        if old_val < max_val:
+            lookup[old_val] = new_val
     
-    return converted_array
+    # Use fancy indexing for fast conversion
+    return lookup[input_array]
 
 def get_class_priority(source):
     """

voxcity/utils/visualization.py

@@ -45,6 +45,7 @@ import trimesh
 import pyvista as pv
 from IPython.display import display
 import os
+import sys
 
 # Import utility functions for land cover classification
 from .lc import get_land_cover_classes
@@ -1839,13 +1840,34 @@ def create_multi_view_scene(meshes, output_directory="output", projection_type="
     >>> views = create_multi_view_scene(meshes, "renders/", "orthographic", 1.5)
     >>> print(f"Generated {len(views)} views")
     """
-    # Compute overall bounding box across all meshes
-    vertices_list = [mesh.vertices for mesh in meshes.values()]
-    all_vertices = np.vstack(vertices_list)
-    bbox = np.array([
-        [all_vertices[:, 0].min(), all_vertices[:, 1].min(), all_vertices[:, 2].min()],
-        [all_vertices[:, 0].max(), all_vertices[:, 1].max(), all_vertices[:, 2].max()]
-    ])
+    # Precompute PyVista meshes once to avoid repeated conversion per view
+    pv_meshes = {}
+    for class_id, mesh in meshes.items():
+        if mesh is None or len(mesh.vertices) == 0 or len(mesh.faces) == 0:
+            continue
+        # PyVista expects a faces array where each face is prefixed by its vertex count (3 for triangles)
+        faces = np.hstack([[3, *face] for face in mesh.faces])
+        pv_mesh = pv.PolyData(mesh.vertices, faces)
+        # Attach per-cell colors if provided
+        colors = getattr(mesh.visual, 'face_colors', None)
+        if colors is not None:
+            colors = np.asarray(colors)
+            if colors.size and colors.max() > 1:
+                colors = colors / 255.0
+            pv_mesh.cell_data['colors'] = colors
+        pv_meshes[class_id] = pv_mesh
+
+    # Compute overall bounding box across all meshes without stacking
+    min_xyz = np.array([np.inf, np.inf, np.inf], dtype=float)
+    max_xyz = np.array([-np.inf, -np.inf, -np.inf], dtype=float)
+    for mesh in meshes.values():
+        if mesh is None or len(mesh.vertices) == 0:
+            continue
+        v = mesh.vertices
+        # update mins and maxs
+        min_xyz = np.minimum(min_xyz, v.min(axis=0))
+        max_xyz = np.maximum(max_xyz, v.max(axis=0))
+    bbox = np.vstack([min_xyz, max_xyz])
 
     # Compute the center and diagonal of the bounding box
     center = (bbox[1] + bbox[0]) / 2
@@ -1897,21 +1919,14 @@ def create_multi_view_scene(meshes, output_directory="output", projection_type="
         elif projection_type.lower() != "perspective":
             print(f"Warning: Unknown projection_type '{projection_type}'. Using perspective projection.")
 
-        # 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)
+        # Add each precomputed mesh to the scene
+        for class_id, pv_mesh in pv_meshes.items():
+            has_colors = 'colors' in pv_mesh.cell_data
+            plotter.add_mesh(
+                pv_mesh,
+                rgb=True,
+                scalars='colors' if has_colors else None
+            )
 
         # Set camera position for this view
         plotter.camera_position = camera_pos
@@ -2350,8 +2365,11 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
     - visualize_voxcity_multi_view(): Basic voxel visualization without custom meshes
     - create_multi_view_scene(): Lower-level rendering function
     """
-    os.system('Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &')
-    os.environ['DISPLAY'] = ':99'
+    # Setup offscreen rendering only when needed and supported
+    if sys.platform.startswith('linux'):
+        if 'DISPLAY' not in os.environ:
+            os.system('Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &')
+            os.environ['DISPLAY'] = ':99'
 
     # Configure PyVista settings
     pv.set_plot_theme('document')
@@ -2381,13 +2399,25 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
     nan_color = kwargs.get("nan_color", "gray")
     show_views = kwargs.get("show_views", True)
     save_obj = kwargs.get("save_obj", False)
+    include_classes = kwargs.get("include_classes", None)
+    exclude_classes = kwargs.get("exclude_classes", None)
+    copy_custom_mesh = kwargs.get("copy_custom_mesh", False)
     
     if value_name is None:
         print("Set value_name")
 
     # Create meshes from voxel data
     print("Creating voxel meshes...")
-    meshes = create_city_meshes(voxel_array, vox_dict, meshsize=meshsize)
+    # Skip generating voxel meshes for classes that will be replaced by custom meshes
+    if exclude_classes is None and custom_meshes is not None:
+        exclude_classes = list(custom_meshes.keys())
+    meshes = create_city_meshes(
+        voxel_array,
+        vox_dict,
+        meshsize=meshsize,
+        include_classes=include_classes,
+        exclude_classes=exclude_classes,
+    )
     
     # Replace specific voxel class meshes with custom simulation meshes
     if custom_meshes is not None:
@@ -2399,18 +2429,23 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
                 import matplotlib.colors as mcolors
                 
                 # Get values from metadata
-                values = custom_mesh.metadata[value_name]
+                values = np.asarray(custom_mesh.metadata[value_name])
                 
                 # Set vmin/vmax if not provided
-                local_vmin = vmin if vmin is not None else np.nanmin(values[~np.isnan(values)])
-                local_vmax = vmax if vmax is not None else np.nanmax(values[~np.isnan(values)])
+                finite_mask = np.isfinite(values)
+                if not np.any(finite_mask):
+                    local_vmin = 0.0 if vmin is None else vmin
+                    local_vmax = 1.0 if vmax is None else vmax
+                else:
+                    local_vmin = vmin if vmin is not None else float(np.nanmin(values[finite_mask]))
+                    local_vmax = vmax if vmax is not None else float(np.nanmax(values[finite_mask]))
 
                 # Create colors
                 cmap = cm.get_cmap(cmap_name)
                 norm = mcolors.Normalize(vmin=local_vmin, vmax=local_vmax)
                 
                 # Handle NaN values with custom color
-                face_colors = np.zeros((len(values), 4))
+                face_colors = np.zeros((len(values), 4), dtype=float)
                 
                 # Convert string color to RGBA if needed
                 if isinstance(nan_color, str):
@@ -2421,25 +2456,25 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
                     nan_rgba = np.array(nan_color)
                 
                 # Apply colors: NaN values get nan_color, others get colormap colors
-                nan_mask = np.isnan(values)
+                nan_mask = ~finite_mask
                 face_colors[~nan_mask] = cmap(norm(values[~nan_mask]))
                 face_colors[nan_mask] = nan_rgba
                 
                 # Create a copy with colors
-                vis_mesh = custom_mesh.copy()
+                vis_mesh = custom_mesh.copy() if copy_custom_mesh else custom_mesh
                 vis_mesh.visual.face_colors = face_colors
 
-                # Prepare the colormap and create colorbar
-                norm = mcolors.Normalize(vmin=local_vmin, vmax=local_vmax)
-                scalar_map = cm.ScalarMappable(norm=norm, cmap=cmap_name)
-                
-                # Create a figure and axis for the colorbar but don't display
-                fig, ax = plt.subplots(figsize=(6, 1))
-                cbar = plt.colorbar(scalar_map, cax=ax, orientation='horizontal')
-                if colorbar_title:
-                    cbar.set_label(colorbar_title)
-                plt.tight_layout()
-                plt.show()  
+                # Prepare the colormap and create colorbar if views will be shown
+                if show_views:
+                    norm = mcolors.Normalize(vmin=local_vmin, vmax=local_vmax)
+                    scalar_map = cm.ScalarMappable(norm=norm, cmap=cmap_name)
+                    fig, ax = plt.subplots(figsize=(6, 1))
+                    cbar = plt.colorbar(scalar_map, cax=ax, orientation='horizontal')
+                    if colorbar_title:
+                        cbar.set_label(colorbar_title)
+                    plt.tight_layout()
+                    plt.show()
+                    plt.close(fig)
                 
                 if class_id in meshes:
                     print(f"Replacing voxel class {class_id} with colored custom simulation mesh")
@@ -2504,8 +2539,12 @@ def visualize_voxcity_with_sim_meshes(voxel_array, meshsize, custom_meshes=None,
     if save_obj:
         output_directory = kwargs.get('output_directory', 'output')
         output_file_name = kwargs.get('output_file_name', 'voxcity_mesh')
-        max_materials = kwargs.get('max_materials', 20)
-        obj_path, mtl_path = save_obj_from_colored_mesh(meshes, output_directory, output_file_name, max_materials=max_materials)
+        # Default: do NOT quantize to preserve exact face colors like in images
+        max_materials = kwargs.get('max_materials', None)
+        if max_materials is None:
+            obj_path, mtl_path = save_obj_from_colored_mesh(meshes, output_directory, output_file_name)
+        else:
+            obj_path, mtl_path = save_obj_from_colored_mesh(meshes, output_directory, output_file_name, max_materials=max_materials)
         print(f"Saved mesh files to:\n  {obj_path}\n  {mtl_path}")    
 
     if show_views:
@@ -2559,6 +2598,13 @@ def visualize_building_sim_results(voxel_array, meshsize, building_sim_mesh, **k
     
     # Create custom meshes dictionary with the building simulation mesh
     custom_meshes = {building_class_id: building_sim_mesh}
+
+    # Performance: skip voxel mesh generation for building class by default
+    if "include_classes" not in kwargs and "exclude_classes" not in kwargs:
+        kwargs["exclude_classes"] = [building_class_id]
+
+    # Memory-safety: do not duplicate the provided mesh unless requested
+    kwargs.setdefault("copy_custom_mesh", False)
     
     # Add colorbar title if not provided
     if "colorbar_title" not in kwargs:

{voxcity-0.5.31.dist-info → voxcity-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voxcity
-Version: 0.5.31
+Version: 0.6.0
 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>

{voxcity-0.5.31.dist-info → voxcity-0.6.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 voxcity/__init__.py,sha256=el9v3gfybHOF_GUYPeSOqN0-vCrTW0eU1mcvi0sEfeU,252
-voxcity/generator.py,sha256=mEggM4FxE7LChTPCspAQmJlAoUz1PVcbaUfY11cMfzQ,54176
+voxcity/generator.py,sha256=mnwlmfFr-23_ZytPSeU-5SpHklO30w5b8NbNOQLemik,54983
 voxcity/downloader/__init__.py,sha256=o_T_EU7hZLGyXxX9wVWn1x-OAa3ThGYdnpgB1_2v3AE,151
 voxcity/downloader/citygml.py,sha256=jVeHCLlJTf7k55OQGX0lZGQAngz_DD2V5TldSqRFlvc,36024
 voxcity/downloader/eubucco.py,sha256=ln1YNaaOgJfxNfCtVbYaMm775-bUvpAA_LDv60_i22w,17875
@@ -16,23 +16,23 @@ voxcity/exporter/magicavoxel.py,sha256=SfGEgTZRlossKx3Xrv9d3iKSX-HmfQJEL9lZHgWMD
 voxcity/exporter/obj.py,sha256=h1_aInpemcsu96fSTwjKMqX2VZAFYbZbElWd4M1ogyI,27973
 voxcity/geoprocessor/__init__.py,sha256=JzPVhhttxBWvaZ0IGX2w7OWL5bCo_TIvpHefWeNXruA,133
 voxcity/geoprocessor/draw.py,sha256=avXQwbGQWG3ZPPI8mwy0YN0K_aG4NMBdXI0vDg7yad0,35837
-voxcity/geoprocessor/grid.py,sha256=lhELyznlk4Jt7vnd0uOpMCLPCjrYQjX7qtQq-xHkYE4,64161
-voxcity/geoprocessor/mesh.py,sha256=ElqAE2MA8KZs7yD7B1P88XYmryC6F9nkkP6cXv7FzIk,30777
+voxcity/geoprocessor/grid.py,sha256=uIfEE-2rfT274QKN9qnyXu3E2nCwaUHiuxHra2iclZM,71186
+voxcity/geoprocessor/mesh.py,sha256=-r_3EGL3PZr-QngMOXrwKllYA4o0moDj0-bZvU0mlOo,31237
 voxcity/geoprocessor/network.py,sha256=YynqR0nq_NUra_cQ3Z_56KxfRia1b6-hIzGCj3QT-wE,25137
-voxcity/geoprocessor/polygon.py,sha256=-obeI0KprySwwRXT4j3vs_xsk5sd9p9YzYdle1jJbCE,59845
+voxcity/geoprocessor/polygon.py,sha256=DfzXf6R-qoWXEZv1z1aHCVfr-DCuCFw6lieQT5cNHPA,61188
 voxcity/geoprocessor/utils.py,sha256=DVg3EMRytLQLEQeXLvNgjt1Ynoa689EsD-To-14xgSQ,30369
 voxcity/simulator/__init__.py,sha256=APdkcdaovj0v_RPOaA4SBvFUKT2RM7Hxuuz3Sux4gCo,65
-voxcity/simulator/solar.py,sha256=t7zOSxBObQMuWvQSiHN9AViJstzfkXqAg3BpIppn0KA,82694
+voxcity/simulator/solar.py,sha256=h_jVPjJ8wKl8z8Tx0EcVJBzNRKSr8WXBL9bVCgJpyZE,101788
 voxcity/simulator/utils.py,sha256=sEYBB2-hLJxTiXQps1_-Fi7t1HN3-1OPOvBCWtgIisA,130
-voxcity/simulator/view.py,sha256=Xnr-NoKGyO9D02bF104ZKzNhsnjNCkzc-B1yPtDEqpQ,75898
+voxcity/simulator/view.py,sha256=W6QtoSnLSQPEPtTy5B6BB5l0UGQ5Vs-Bt1ISNZKdGTI,92020
 voxcity/utils/__init__.py,sha256=Q-NYCqYnAAaF80KuNwpqIjbE7Ec3Gr4y_khMLIMhJrg,68
-voxcity/utils/lc.py,sha256=h2yOWLUIrrummkyMyhRK5VbyrsPtslS0MJov_y0WGIQ,18925
+voxcity/utils/lc.py,sha256=722Gz3lPbgAp0mmTZ-g-QKBbAnbxrcgaYwb1sa7q8Sk,16189
 voxcity/utils/material.py,sha256=H8K8Lq4wBL6dQtgj7esUW2U6wLCOTeOtelkTDJoRgMo,10007
-voxcity/utils/visualization.py,sha256=OvfZ67dg3rHr1LD0xTPYK_LBtoZwjJe-H0Nhcwkd_HA,112919
+voxcity/utils/visualization.py,sha256=Hk31pVOZ3q8K0QaudAMSqKUquF1Hd1Hug8626D4JJ74,115143
 voxcity/utils/weather.py,sha256=2Jtg-rIVJcsTtiKE-KuDnhIqS1-MSS16_zFRzj6zmu4,36435
-voxcity-0.5.31.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
-voxcity-0.5.31.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
-voxcity-0.5.31.dist-info/METADATA,sha256=1edKOnYTIW2Io9E0QuRMhEXmEqHEZnT4-lrShCMNUvM,26724
-voxcity-0.5.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-voxcity-0.5.31.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
-voxcity-0.5.31.dist-info/RECORD,,
+voxcity-0.6.0.dist-info/licenses/AUTHORS.rst,sha256=m82vkI5QokEGdcHof2OxK39lf81w1P58kG9ZNNAKS9U,175
+voxcity-0.6.0.dist-info/licenses/LICENSE,sha256=s_jE1Df1nTPL4A_5GCGic5Zwex0CVaPKcAmSilxJPPE,1089
+voxcity-0.6.0.dist-info/METADATA,sha256=C-1oyOYd7anMYVqYfTIH_zJWNDqpRL5v5bvcYgsYPkI,26723
+voxcity-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+voxcity-0.6.0.dist-info/top_level.txt,sha256=00b2U-LKfDllt6RL1R33MXie5MvxzUFye0NGD96t_8I,8
+voxcity-0.6.0.dist-info/RECORD,,