voxcity 0.3.25__py3-none-any.whl → 0.4.1__py3-none-any.whl

voxcity/exporter/obj.py

@@ -9,7 +9,7 @@ import numpy as np
 import os
 from numba import njit, prange
 import matplotlib.pyplot as plt
-from ..utils.visualization import get_default_voxel_color_map
+from ..utils.visualization import get_voxel_color_map
 
 def convert_colormap_indices(original_map):
     """
@@ -209,7 +209,7 @@ def export_obj(array, output_dir, file_name, voxel_size, voxel_color_map=None):
             If None, uses default color map.
     """
     if voxel_color_map is None:
-        voxel_color_map = get_default_voxel_color_map()
+        voxel_color_map = get_voxel_color_map()
 
     # Extract unique voxel values (excluding zero)
     unique_voxel_values = np.unique(array)

voxcity/generator.py

@@ -82,7 +82,8 @@ def get_land_cover_grid(rectangle_vertices, meshsize, source, output_dir, **kwar
     print(f"Data source: {source}")
     
     # Initialize Earth Engine for accessing satellite data
-    initialize_earth_engine()
+    if source is not "OpenStreetMap":
+        initialize_earth_engine()
 
     # Create output directory if it doesn't exist
     os.makedirs(output_dir, exist_ok=True)
@@ -157,7 +158,8 @@ def get_building_height_grid(rectangle_vertices, meshsize, source, output_dir, *
     """
 
     # Initialize Earth Engine for accessing satellite data
-    initialize_earth_engine()
+    if source is not "OpenStreetMap":
+        initialize_earth_engine()
 
     print("Creating Building Height grid\n ")
     print(f"Data source: {source}")
@@ -320,7 +322,7 @@ def get_dem_grid(rectangle_vertices, meshsize, source, output_dir, **kwargs):
         image = get_dem_image(roi_buffered, source)
         
         # Save DEM data with appropriate resolution based on source
-        if source in ["England 1m DTM", 'DEM France 1m', 'DEM France 5m', 'AUSTRALIA 5M DEM']:
+        if source in ["England 1m DTM", 'DEM France 1m', 'DEM France 5m', 'AUSTRALIA 5M DEM', 'Netherlands 0.5m DTM']:
             save_geotiff(image, geotiff_path, scale=meshsize, region=roi_buffered, crs='EPSG:4326')
         elif source == 'USGS 3DEP 1m':
             scale = max(meshsize, 1.25)
@@ -569,7 +571,18 @@ def get_voxcity(rectangle_vertices, building_source, land_cover_source, canopy_h
         building_gdf.to_file(save_path, driver='GPKG')
     
     # Get canopy height data
-    canopy_height_grid = get_canopy_height_grid(rectangle_vertices, meshsize, canopy_height_source, output_dir, **kwargs)
+    if canopy_height_source == "Static":
+        # Create canopy height grid with same shape as land cover grid
+        canopy_height_grid = np.zeros_like(land_cover_grid, dtype=float)
+        
+        # Set default static height for trees (20 meters is a typical average tree height)
+        static_tree_height = kwargs.get("static_tree_height", 10.0)
+        tree_mask = (land_cover_grid == 4)
+        
+        # Set static height for tree cells
+        canopy_height_grid[tree_mask] = static_tree_height
+    else:
+        canopy_height_grid = get_canopy_height_grid(rectangle_vertices, meshsize, canopy_height_source, output_dir, **kwargs)
     
     # Handle DEM - either flat or from source
     if dem_source == "Flat":

voxcity/geoprocessor/grid.py

@@ -26,7 +26,8 @@ from ..geoprocessor.polygon import (
     filter_buildings, 
     extract_building_heights_from_geotiff, 
     extract_building_heights_from_gdf,
-    complement_building_heights_from_gdf
+    complement_building_heights_from_gdf,
+    process_building_footprints_by_overlap
 )
 from ..utils.lc import (
     get_class_priority, 
@@ -555,6 +556,9 @@ def create_building_height_grid_from_gdf_polygon(
             filtered_gdf = extract_building_heights_from_gdf(filtered_gdf, filtered_gdf_comp)
     elif geotiff_path_comp:
         filtered_gdf = extract_building_heights_from_geotiff(geotiff_path_comp, filtered_gdf)
+    
+    # After filtering and complementing heights, process overlapping buildings
+    filtered_gdf = process_building_footprints_by_overlap(filtered_gdf, overlap_threshold=0.5)
 
     # --------------------------------------------------------------------------
     # 2) PREPARE BUILDING POLYGONS & SPATIAL INDEX

voxcity/geoprocessor/mesh.py

@@ -4,7 +4,7 @@ import matplotlib.colors as mcolors
 import matplotlib.cm as cm
 import matplotlib.pyplot as plt
 
-def create_voxel_mesh(voxel_array, class_id, meshsize=1.0):
+def create_voxel_mesh(voxel_array, class_id, meshsize=1.0, building_id_grid=None):
     """
     Create a mesh from voxels preserving sharp edges, scaled by meshsize.
 
@@ -16,15 +16,21 @@ def create_voxel_mesh(voxel_array, class_id, meshsize=1.0):
         The ID of the class to extract.
     meshsize : float
         The real-world size of each voxel in meters, for x, y, and z.
+    building_id_grid : np.ndarray (2D), optional
+        2D grid of building IDs, shape (X, Y). Used when class_id=-3 (buildings).
 
     Returns
     -------
     mesh : trimesh.Trimesh or None
         The resulting mesh for the given class_id (or None if no voxels).
+        If class_id=-3, mesh.metadata['building_id'] contains building IDs.
     """
     # Find voxels of the current class
     voxel_coords = np.argwhere(voxel_array == class_id)
 
+    if building_id_grid is not None:
+        building_id_grid_flipud = np.flipud(building_id_grid)
+
     if len(voxel_coords) == 0:
         return None
 
@@ -57,8 +63,14 @@ def create_voxel_mesh(voxel_array, class_id, meshsize=1.0):
     vertices = []
     faces = []
     face_normals_list = []
+    building_ids = []  # List to store building IDs for each face
 
     for x, y, z in voxel_coords:
+        # For buildings, get the building ID from the grid
+        building_id = None
+        if class_id == -3 and building_id_grid is not None:
+            building_id = building_id_grid_flipud[x, y]
+            
         # Check each face of the current voxel
         adjacent_coords = [
             (x,   y,   z+1),  # Front
@@ -95,6 +107,10 @@ def create_voxel_mesh(voxel_array, class_id, meshsize=1.0):
                 ])
                 # Add face normals for both triangles
                 face_normals_list.extend([face_normals[face_idx], face_normals[face_idx]])
+                
+                # Store building ID for both triangles if this is a building
+                if class_id == -3 and building_id_grid is not None:
+                    building_ids.extend([building_id, building_id])
 
     if not vertices:
         return None
@@ -112,6 +128,10 @@ def create_voxel_mesh(voxel_array, class_id, meshsize=1.0):
 
     # Merge vertices that are at the same position
     mesh.merge_vertices()
+    
+    # Add building IDs as metadata for buildings
+    if class_id == -3 and building_id_grid is not None and building_ids:
+        mesh.metadata = {'building_id': np.array(building_ids)}
 
     return mesh
 

voxcity/geoprocessor/polygon.py

@@ -19,6 +19,7 @@ from pyproj import Transformer, CRS
 import rasterio
 from rasterio.mask import mask
 import copy
+from rtree import index
 
 from .utils import validate_polygon_coordinates
 
@@ -794,4 +795,97 @@ def get_buildings_in_drawn_polygon(building_gdf, drawn_polygon_vertices,
         else:
             raise ValueError("operation must be 'intersect' or 'within'")
 
-    return included_building_ids
+    return included_building_ids
+
+def process_building_footprints_by_overlap(filtered_gdf, overlap_threshold=0.5):
+    """
+    Process building footprints to merge overlapping buildings.
+    
+    Args:
+        filtered_gdf (geopandas.GeoDataFrame): GeoDataFrame containing building footprints
+        overlap_threshold (float): Threshold for overlap ratio (0.0-1.0) to merge buildings
+        
+    Returns:
+        geopandas.GeoDataFrame: Processed GeoDataFrame with updated IDs
+    """
+    # Make a copy to avoid modifying the original
+    gdf = filtered_gdf.copy()
+    
+    # Ensure 'id' column exists
+    if 'id' not in gdf.columns:
+        gdf['id'] = gdf.index
+    
+    # Calculate areas and sort by area (descending)
+    gdf['area'] = gdf.geometry.area
+    gdf = gdf.sort_values(by='area', ascending=False)
+    gdf = gdf.reset_index(drop=True)
+    
+    # Create spatial index for efficient querying
+    spatial_idx = index.Index()
+    for i, geom in enumerate(gdf.geometry):
+        if geom.is_valid:
+            spatial_idx.insert(i, geom.bounds)
+        else:
+            # Fix invalid geometries
+            fixed_geom = geom.buffer(0)
+            if fixed_geom.is_valid:
+                spatial_idx.insert(i, fixed_geom.bounds)
+    
+    # Track ID replacements to avoid repeated processing
+    id_mapping = {}
+    
+    # Process each building (skip the largest one)
+    for i in range(1, len(gdf)):
+        current_poly = gdf.iloc[i].geometry
+        current_area = gdf.iloc[i].area
+        current_id = gdf.iloc[i]['id']
+        
+        # Skip if already mapped
+        if current_id in id_mapping:
+            continue
+        
+        # Ensure geometry is valid
+        if not current_poly.is_valid:
+            current_poly = current_poly.buffer(0)
+            if not current_poly.is_valid:
+                continue
+        
+        # Find potential overlaps with larger polygons
+        potential_overlaps = [j for j in spatial_idx.intersection(current_poly.bounds) if j < i]
+        
+        for j in potential_overlaps:
+            larger_poly = gdf.iloc[j].geometry
+            larger_id = gdf.iloc[j]['id']
+            
+            # Skip if already processed
+            if larger_id in id_mapping:
+                larger_id = id_mapping[larger_id]
+            
+            # Ensure geometry is valid
+            if not larger_poly.is_valid:
+                larger_poly = larger_poly.buffer(0)
+                if not larger_poly.is_valid:
+                    continue
+            
+            try:
+                # Calculate overlap
+                if current_poly.intersects(larger_poly):
+                    overlap = current_poly.intersection(larger_poly)
+                    overlap_ratio = overlap.area / current_area
+                    
+                    # Replace ID if overlap exceeds threshold
+                    if overlap_ratio > overlap_threshold:
+                        id_mapping[current_id] = larger_id
+                        gdf.at[i, 'id'] = larger_id
+                        break  # Stop at first significant overlap
+            except (GEOSException, ValueError) as e:
+                # Handle geometry errors gracefully
+                continue
+    
+    # Propagate ID changes through the original DataFrame
+    for i, row in filtered_gdf.iterrows():
+        orig_id = row.get('id')
+        if orig_id in id_mapping:
+            filtered_gdf.at[i, 'id'] = id_mapping[orig_id]
+    
+    return filtered_gdf