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

voxcity/geoprocessor/grid.py

@@ -10,18 +10,19 @@ It includes functionality for:
 import numpy as np
 import pandas as pd
 import os
-from shapely.geometry import Polygon, box
+from shapely.geometry import Polygon, Point, MultiPolygon, box, mapping
 from scipy.ndimage import label, generate_binary_structure
 from pyproj import Geod, Transformer, CRS
 import rasterio
+from rasterio import features
+from rasterio.transform import from_bounds
 from affine import Affine
-from shapely.geometry import box, Polygon, Point, MultiPolygon
-import warnings
-
+import geopandas as gpd
+from collections import defaultdict
 from scipy.interpolate import griddata
 from shapely.errors import GEOSException
-import geopandas as gpd
 from rtree import index
+import warnings
 
 from .utils import (
     initialize_geod,
@@ -144,42 +145,114 @@ def group_and_label_cells(array):
     
     return result
 
-def process_grid(grid_bi, dem_grid):
+def process_grid_optimized(grid_bi, dem_grid):
+    """
+    Optimized version using numpy's bincount for fast averaging.
+    This is much faster than iterating through unique IDs.
     """
-    Process a binary grid and DEM grid to create averaged elevation values.
+    result = dem_grid.copy()
     
-    This function takes a binary grid identifying regions and a corresponding DEM
-    grid with elevation values. For each non-zero region in the binary grid, it
-    calculates the mean elevation from the DEM grid and assigns this average to
-    all cells in that region. The result is normalized by subtracting the minimum value.
+    # Only process if there are non-zero values
+    if np.any(grid_bi != 0):
+        # Handle float IDs by converting to integers
+        # First check if we have float values
+        if grid_bi.dtype.kind == 'f':
+            # Convert to int, handling NaN values
+            grid_bi_int = np.nan_to_num(grid_bi, nan=0).astype(np.int64)
+        else:
+            grid_bi_int = grid_bi.astype(np.int64)
+        
+        # Flatten arrays for processing
+        flat_bi = grid_bi_int.ravel()
+        flat_dem = dem_grid.ravel()
+        
+        # Filter out zero values
+        mask = flat_bi != 0
+        ids = flat_bi[mask]
+        values = flat_dem[mask]
+        
+        # Check if we have any valid IDs
+        if len(ids) > 0:
+            # Use bincount to sum values for each ID
+            sums = np.bincount(ids, weights=values)
+            counts = np.bincount(ids)
+            
+            # Avoid division by zero
+            counts[counts == 0] = 1
+            
+            # Calculate means
+            means = sums / counts
+            
+            # Apply means back to result
+            # Use the integer version for indexing
+            mask_nonzero = grid_bi_int != 0
+            # Ensure indices are within bounds
+            valid_ids = grid_bi_int[mask_nonzero]
+            valid_mask = valid_ids < len(means)
+            
+            # Apply only to valid indices
+            result_mask = np.zeros_like(mask_nonzero)
+            result_mask[mask_nonzero] = valid_mask
+            
+            # Set values
+            result[result_mask] = means[grid_bi_int[result_mask]]
     
-    Args:
-        grid_bi (numpy.ndarray): Binary grid indicating regions (0 for background,
-                                non-zero for different regions)
-        dem_grid (numpy.ndarray): Grid of elevation values corresponding to the
-                                same spatial extent as grid_bi
+    return result - np.min(result)
+
+def process_grid(grid_bi, dem_grid):
+    """
+    Safe version that tries optimization first, then falls back to original method.
+    """
+    try:
+        # Try the optimized version first
+        return process_grid_optimized(grid_bi, dem_grid)
+    except Exception as e:
+        print(f"Optimized process_grid failed: {e}, using original method")
+        # Fall back to original implementation
+        unique_ids = np.unique(grid_bi[grid_bi != 0])
+        result = dem_grid.copy()
         
-    Returns:
-        numpy.ndarray: Processed grid with averaged and normalized elevation values.
-                      Same shape as input grids.
+        for id_num in unique_ids:
+            mask = (grid_bi == id_num)
+            avg_value = np.mean(dem_grid[mask])
+            result[mask] = avg_value
         
-    Example:
-        >>> binary_grid = np.array([[1, 1, 0], [1, 1, 2], [0, 2, 2]])
-        >>> elevation = np.array([[100, 110, 90], [105, 115, 120], [95, 125, 130]])
-        >>> result = process_grid(binary_grid, elevation)
+        return result - np.min(result)
     """
-    # Get unique non-zero region IDs
-    unique_ids = np.unique(grid_bi[grid_bi != 0])
-    result = dem_grid.copy()
+    Optimized version that avoids converting to Python lists.
+    Works directly with numpy arrays.
+    """
+    if not isinstance(arr, np.ndarray):
+        return arr
     
-    # For each region, calculate mean elevation and assign to all cells in region
-    for id_num in unique_ids:
-        mask = (grid_bi == id_num)
-        avg_value = np.mean(dem_grid[mask])
-        result[mask] = avg_value
+    # Create output array
+    result = np.empty_like(arr, dtype=object)
     
-    # Normalize by subtracting minimum value
-    return result - np.min(result)
+    # Vectorized operation for empty cells
+    for i in range(arr.shape[0]):
+        for j in range(arr.shape[1]):
+            cell = arr[i, j]
+            
+            if cell is None or (isinstance(cell, list) and len(cell) == 0):
+                result[i, j] = []
+            elif isinstance(cell, list):
+                # Process list without converting entire array
+                new_cell = []
+                for segment in cell:
+                    if isinstance(segment, (list, np.ndarray)):
+                        # Use numpy operations where possible
+                        if isinstance(segment, np.ndarray):
+                            new_segment = np.where(np.isnan(segment), replace_value, segment).tolist()
+                        else:
+                            new_segment = [replace_value if (isinstance(v, float) and np.isnan(v)) else v for v in segment]
+                        new_cell.append(new_segment)
+                    else:
+                        new_cell.append(segment)
+                result[i, j] = new_cell
+            else:
+                result[i, j] = cell
+    
+    return result
 
 def calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize):
     """
@@ -587,6 +660,7 @@ def create_building_height_grid_from_gdf_polygon(
     gdf,
     meshsize,
     rectangle_vertices,
+    overlapping_footprint=False,
     gdf_comp=None,
     geotiff_path_comp=None,
     complement_building_footprints=None,
@@ -599,11 +673,13 @@ def create_building_height_grid_from_gdf_polygon(
         gdf (geopandas.GeoDataFrame): GeoDataFrame containing building information
         meshsize (float): Size of mesh cells
         rectangle_vertices (list): List of rectangle vertices defining the boundary
+        overlapping_footprint (bool): If True, use precise geometry-based processing for overlaps.
+                                    If False, use faster rasterio-based approach.
         gdf_comp (geopandas.GeoDataFrame, optional): Complementary GeoDataFrame
         geotiff_path_comp (str, optional): Path to complementary GeoTIFF file
         complement_building_footprints (bool, optional): Whether to complement footprints
         complement_height (float, optional): Height value to use for buildings with height=0
-
+        
     Returns:
         tuple: (building_height_grid, building_min_height_grid, building_id_grid, filtered_buildings)
             - building_height_grid (numpy.ndarray): Grid of building heights
@@ -612,34 +688,25 @@ def create_building_height_grid_from_gdf_polygon(
             - filtered_buildings (geopandas.GeoDataFrame): The buildings used (filtered_gdf)
     """
     # --------------------------------------------------------------------------
-    # 1) INITIAL SETUP AND DATA FILTERING
+    # 1) COMMON INITIAL SETUP AND DATA FILTERING
     # --------------------------------------------------------------------------
     geod = initialize_geod()
     vertex_0, vertex_1, vertex_3 = rectangle_vertices[0], rectangle_vertices[1], rectangle_vertices[3]
-
+    
     # Distances for each side
     dist_side_1 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_1[0], vertex_1[1])
     dist_side_2 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_3[0], vertex_3[1])
-
+    
     # Normalized vectors
     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)
-
+    
     # Grid parameters
     origin = np.array(rectangle_vertices[0])
     grid_size, adjusted_meshsize = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
-
-    # Initialize output grids
-    building_height_grid = np.zeros(grid_size)
-    building_id_grid = np.zeros(grid_size)
-    # Use a Python list-of-lists or object array for min_height tracking
-    building_min_height_grid = np.empty(grid_size, dtype=object)
-    for i in range(grid_size[0]):
-        for j in range(grid_size[1]):
-            building_min_height_grid[i, j] = []
-
+    
     # Filter the input GeoDataFrame by bounding box
     extent = [
         min(coord[1] for coord in rectangle_vertices),
@@ -649,12 +716,12 @@ def create_building_height_grid_from_gdf_polygon(
     ]
     plotting_box = box(extent[2], extent[0], extent[3], extent[1])
     filtered_gdf = gdf[gdf.geometry.intersects(plotting_box)].copy()
-
+    
     # Count buildings with height=0 or NaN
     zero_height_count = len(filtered_gdf[filtered_gdf['height'] == 0])
     nan_height_count = len(filtered_gdf[filtered_gdf['height'].isna()])
     print(f"{zero_height_count+nan_height_count} of the total {len(filtered_gdf)} building footprint from the base data source did not have height data.")
-
+    
     # Optionally merge heights from complementary sources
     if gdf_comp is not None:
         filtered_gdf_comp = gdf_comp[gdf_comp.geometry.intersects(plotting_box)].copy()
@@ -667,11 +734,41 @@ def create_building_height_grid_from_gdf_polygon(
     
     # After filtering and complementing heights, process overlapping buildings
     filtered_gdf = process_building_footprints_by_overlap(filtered_gdf, overlap_threshold=0.5)
+    
+    # --------------------------------------------------------------------------
+    # 2) BRANCH BASED ON OVERLAPPING_FOOTPRINT PARAMETER
+    # --------------------------------------------------------------------------
+    
+    if overlapping_footprint:
+        # Use precise geometry-based approach for better overlap handling
+        return _process_with_geometry_intersection(
+            filtered_gdf, grid_size, adjusted_meshsize, origin, u_vec, v_vec, complement_height
+        )
+    else:
+        # Use faster rasterio-based approach
+        return _process_with_rasterio(
+            filtered_gdf, grid_size, adjusted_meshsize, origin, u_vec, v_vec, 
+            rectangle_vertices, complement_height
+        )
 
+
+def _process_with_geometry_intersection(filtered_gdf, grid_size, adjusted_meshsize, origin, u_vec, v_vec, complement_height):
+    """
+    Process buildings using precise geometry intersection approach.
+    Better for handling overlapping footprints but slower.
+    """
+    # Initialize output grids
+    building_height_grid = np.zeros(grid_size)
+    building_id_grid = np.zeros(grid_size)
+    
+    # Use a Python list-of-lists or object array for min_height tracking
+    building_min_height_grid = np.empty(grid_size, dtype=object)
+    for i in range(grid_size[0]):
+        for j in range(grid_size[1]):
+            building_min_height_grid[i, j] = []
+    
     # --------------------------------------------------------------------------
-    # 2) PREPARE BUILDING POLYGONS & SPATIAL INDEX
-    #    - fix geometries if needed
-    #    - store bounding boxes
+    # PREPARE BUILDING POLYGONS & SPATIAL INDEX
     # --------------------------------------------------------------------------
     building_polygons = []
     for idx_b, row in filtered_gdf.iterrows():
@@ -684,177 +781,129 @@ def create_building_height_grid_from_gdf_polygon(
             
         min_height = row.get('min_height', 0)
         if pd.isna(min_height):
-            min_height = 0      
+            min_height = 0
+            
         is_inner = row.get('is_inner', False)
         feature_id = row.get('id', idx_b)
-
-        # Fix invalid geometry (buffer(0) or simplify if needed)
-        # Doing this once per building avoids repeated overhead per cell.
+        
+        # Fix invalid geometry
         if not polygon.is_valid:
             try:
-                # Attempt simple fix
                 polygon = polygon.buffer(0)
                 if not polygon.is_valid:
-                    # Attempt a small simplify if buffer(0) didn't fix it
                     polygon = polygon.simplify(1e-8)
             except Exception as e:
-                # If still invalid, we keep it as-is; intersection attempts
-                # will be caught in the main loop's try/except
                 pass
-
+                
         bounding_box = polygon.bounds  # (minx, miny, maxx, maxy)
-        building_polygons.append(
-            (
-                polygon,
-                bounding_box,
-                height,
-                min_height,
-                is_inner,
-                feature_id
-            )
-        )
-
+        building_polygons.append((
+            polygon, bounding_box, height, min_height, is_inner, feature_id
+        ))
+    
     # Build R-tree index using bounding boxes
     idx = index.Index()
     for i_b, (poly, bbox, _, _, _, _) in enumerate(building_polygons):
         idx.insert(i_b, bbox)
-
+    
     # --------------------------------------------------------------------------
-    # 3) MAIN GRID LOOP
+    # MAIN GRID LOOP WITH PRECISE INTERSECTION
     # --------------------------------------------------------------------------
     INTERSECTION_THRESHOLD = 0.3
-
+    
     for i in range(grid_size[0]):
         for j in range(grid_size[1]):
             # Create the cell polygon once
             cell = create_cell_polygon(origin, i, j, adjusted_meshsize, u_vec, v_vec)
             if not cell.is_valid:
                 cell = cell.buffer(0)
-
-            cell_area = cell.area  # reused for intersection ratio checks
-
+            cell_area = cell.area
+            
             # Find possible intersections from the index
             potential = list(idx.intersection(cell.bounds))
             if not potential:
                 continue
-
+            
             # Sort buildings by height descending
-            # (height=None => treat as -inf so it sorts last)
             cell_buildings = []
             for k in potential:
                 bpoly, bbox, height, minh, inr, fid = building_polygons[k]
-                # We only sort by height for a stable layering
                 sort_val = height if (height is not None) else -float('inf')
                 cell_buildings.append((k, bpoly, bbox, height, minh, inr, fid, sort_val))
-
             cell_buildings.sort(key=lambda x: x[-1], reverse=True)
-
+            
             found_intersection = False
             all_zero_or_nan = True
-
-            for (
-                k,
-                polygon,
-                bbox,
-                height,
-                min_height,
-                is_inner,
-                feature_id,
-                _
-            ) in cell_buildings:
+            
+            for (k, polygon, bbox, height, min_height, is_inner, feature_id, _) in cell_buildings:
                 try:
-                    # Quick bounding-box check to skip expensive geometry intersection
-                    # if bounding boxes cannot possibly meet the threshold
-                    # --------------------------------------------------------
+                    # Quick bounding-box check
                     minx_p, miny_p, maxx_p, maxy_p = bbox
                     minx_c, miny_c, maxx_c, maxy_c = cell.bounds
-
+                    
                     # Overlap bounding box
                     overlap_minx = max(minx_p, minx_c)
                     overlap_miny = max(miny_p, miny_c)
                     overlap_maxx = min(maxx_p, maxx_c)
                     overlap_maxy = min(maxy_p, maxy_c)
-
+                    
                     if (overlap_maxx <= overlap_minx) or (overlap_maxy <= overlap_miny):
-                        # No bounding-box overlap => skip
                         continue
-
+                    
                     # Area of bounding-box intersection
                     bbox_intersect_area = (overlap_maxx - overlap_minx) * (overlap_maxy - overlap_miny)
                     if bbox_intersect_area < INTERSECTION_THRESHOLD * cell_area:
-                        # Even if the polygons overlap, they can't exceed threshold
                         continue
-                    # --------------------------------------------------------
-
+                    
                     # Ensure valid geometry
                     if not polygon.is_valid:
                         polygon = polygon.buffer(0)
-                        # If still invalid, let intersection attempt fail
-
+                    
                     if cell.intersects(polygon):
                         intersection = cell.intersection(polygon)
                         inter_area = intersection.area
-
+                        
                         # If the fraction of cell covered > threshold
                         if (inter_area / cell_area) > INTERSECTION_THRESHOLD:
                             found_intersection = True
-
+                            
                             # If not an inner courtyard
                             if not is_inner:
                                 building_min_height_grid[i, j].append([min_height, height])
                                 building_id_grid[i, j] = feature_id
-
+                                
                                 # Update building height if valid
-                                if (
-                                    height is not None
-                                    and not np.isnan(height)
-                                    and height > 0
-                                ):
+                                if (height is not None and not np.isnan(height) and height > 0):
                                     all_zero_or_nan = False
                                     current_height = building_height_grid[i, j]
-
+                                    
                                     # Replace if we had 0, nan, or smaller height
-                                    if (
-                                        current_height == 0
-                                        or np.isnan(current_height)
-                                        or current_height < height
-                                    ):
+                                    if (current_height == 0 or np.isnan(current_height) or current_height < height):
                                         building_height_grid[i, j] = height
-
                             else:
                                 # Inner courtyards => override with 0
                                 building_min_height_grid[i, j] = [[0, 0]]
                                 building_height_grid[i, j] = 0
                                 found_intersection = True
                                 all_zero_or_nan = False
-                                # Because it's an inner courtyard, we can break
                                 break
-
+                                
                 except (GEOSException, ValueError) as e:
-                    # Attempt to fix in a fallback
+                    # Attempt fallback fix
                     try:
                         simplified_polygon = polygon.simplify(1e-8)
                         if simplified_polygon.is_valid:
                             intersection = cell.intersection(simplified_polygon)
                             inter_area = intersection.area
-
                             if (inter_area / cell_area) > INTERSECTION_THRESHOLD:
                                 found_intersection = True
                                 if not is_inner:
                                     building_min_height_grid[i, j].append([min_height, height])
                                     building_id_grid[i, j] = feature_id
-
-                                    if (
-                                        height is not None
-                                        and not np.isnan(height)
-                                        and height > 0
-                                    ):
+                                    if (height is not None and not np.isnan(height) and height > 0):
                                         all_zero_or_nan = False
-                                        if (
-                                            building_height_grid[i, j] == 0
-                                            or np.isnan(building_height_grid[i, j])
-                                            or building_height_grid[i, j] < height
-                                        ):
+                                        if (building_height_grid[i, j] == 0 or 
+                                            np.isnan(building_height_grid[i, j]) or 
+                                            building_height_grid[i, j] < height):
                                             building_height_grid[i, j] = height
                                 else:
                                     building_min_height_grid[i, j] = [[0, 0]]
@@ -863,14 +912,131 @@ def create_building_height_grid_from_gdf_polygon(
                                     all_zero_or_nan = False
                                     break
                     except Exception as fix_error:
-                        # Log and skip
                         print(f"Failed to process cell ({i}, {j}) - Building {k}: {str(fix_error)}")
                         continue
-
+            
             # If we found intersecting buildings but all were zero/NaN, mark as NaN
             if found_intersection and all_zero_or_nan:
                 building_height_grid[i, j] = np.nan
+    
+    return building_height_grid, building_min_height_grid, building_id_grid, filtered_gdf
 
+
+def _process_with_rasterio(filtered_gdf, grid_size, adjusted_meshsize, origin, u_vec, v_vec, rectangle_vertices, complement_height):
+    """
+    Process buildings using fast rasterio-based approach.
+    Faster but less precise for overlapping footprints.
+    """
+    # Set up transform for rasterio
+    min_x, min_y = origin[0], origin[1]
+    max_corner = origin + grid_size[0] * adjusted_meshsize[0] * u_vec + grid_size[1] * adjusted_meshsize[1] * v_vec
+    max_x, max_y = max_corner[0], max_corner[1]
+    
+    transform = from_bounds(min_x, min_y, max_x, max_y, grid_size[0], grid_size[1])
+    
+    # Process buildings data
+    filtered_gdf = filtered_gdf.copy()
+    if complement_height is not None:
+        mask = (filtered_gdf['height'] == 0) | (filtered_gdf['height'].isna())
+        filtered_gdf.loc[mask, 'height'] = complement_height
+    
+    # Add missing columns with defaults
+    filtered_gdf['min_height'] = 0
+    
+    if 'is_inner' not in filtered_gdf.columns:
+        filtered_gdf['is_inner'] = False
+    
+    if 'id' not in filtered_gdf.columns:
+        filtered_gdf['id'] = range(len(filtered_gdf))
+    
+    # Sort by height for proper layering
+    regular_buildings = filtered_gdf[~filtered_gdf['is_inner']].copy()
+    regular_buildings = regular_buildings.sort_values('height', ascending=True, na_position='first')
+    
+    # Initialize grids
+    building_height_grid = np.zeros(grid_size, dtype=np.float64)
+    building_id_grid = np.zeros(grid_size, dtype=np.float64)
+    
+    # Vectorized rasterization
+    if len(regular_buildings) > 0:
+        valid_buildings = regular_buildings[regular_buildings.geometry.is_valid].copy()
+        
+        if len(valid_buildings) > 0:
+            # Height grid
+            height_shapes = [(mapping(geom), height) for geom, height in 
+                           zip(valid_buildings.geometry, valid_buildings['height']) 
+                           if pd.notna(height) and height > 0]
+            
+            if height_shapes:
+                building_height_grid = features.rasterize(
+                    height_shapes,
+                    out_shape=grid_size,
+                    transform=transform,
+                    fill=0,
+                    dtype=np.float64
+                )
+            
+            # ID grid  
+            id_shapes = [(mapping(geom), id_val) for geom, id_val in 
+                        zip(valid_buildings.geometry, valid_buildings['id'])]
+            
+            if id_shapes:
+                building_id_grid = features.rasterize(
+                    id_shapes,
+                    out_shape=grid_size,
+                    transform=transform,
+                    fill=0,
+                    dtype=np.float64
+                )
+    
+    # Handle inner courtyards
+    inner_buildings = filtered_gdf[filtered_gdf['is_inner']].copy()
+    if len(inner_buildings) > 0:
+        inner_shapes = [(mapping(geom), 1) for geom in inner_buildings.geometry if geom.is_valid]
+        if inner_shapes:
+            inner_mask = features.rasterize(
+                inner_shapes,
+                out_shape=grid_size,
+                transform=transform,
+                fill=0,
+                dtype=np.uint8
+            )
+            building_height_grid[inner_mask > 0] = 0
+            building_id_grid[inner_mask > 0] = 0
+    
+    # Simplified min_height grid 
+    building_min_height_grid = np.empty(grid_size, dtype=object)
+    min_heights = np.zeros(grid_size, dtype=np.float64)
+    
+    if len(regular_buildings) > 0:
+        valid_buildings = regular_buildings[regular_buildings.geometry.is_valid].copy()
+        if len(valid_buildings) > 0:
+            min_height_shapes = [(mapping(geom), min_h) for geom, min_h in 
+                               zip(valid_buildings.geometry, valid_buildings['min_height']) 
+                               if pd.notna(min_h)]
+            
+            if min_height_shapes:
+                min_heights = features.rasterize(
+                    min_height_shapes,
+                    out_shape=grid_size,
+                    transform=transform,
+                    fill=0,
+                    dtype=np.float64
+                )
+    
+    # Convert to list format (simplified)
+    for i in range(grid_size[0]):
+        for j in range(grid_size[1]):
+            if building_height_grid[i, j] > 0:
+                building_min_height_grid[i, j] = [[min_heights[i, j], building_height_grid[i, j]]]
+            else:
+                building_min_height_grid[i, j] = []
+    
+    # Fix north-south orientation by flipping grids
+    building_height_grid = np.flipud(building_height_grid)
+    building_id_grid = np.flipud(building_id_grid)
+    building_min_height_grid = np.flipud(building_min_height_grid)
+    
     return building_height_grid, building_min_height_grid, building_id_grid, filtered_gdf
 
 def create_building_height_grid_from_open_building_temporal_polygon(meshsize, rectangle_vertices, output_dir):