voxcity 1.0.2__py3-none-any.whl → 1.0.13__py3-none-any.whl

voxcity/geoprocessor/raster/landcover.py

@@ -58,7 +58,7 @@ def create_land_cover_grid_from_geotiff_polygon(
         xs, ys = new_affine * (cols, rows)
         xs_flat, ys_flat = xs.flatten(), ys.flatten()
 
-        row, col = src.index(xs_flat, ys_flat)
+        row, col = rasterio.transform.rowcol(src.transform, xs_flat, ys_flat)
         row, col = np.array(row), np.array(col)
 
         valid = (row >= 0) & (row < src.height) & (col >= 0) & (col < src.width)
@@ -79,14 +79,35 @@ def create_land_cover_grid_from_gdf_polygon(
     meshsize: float,
     source: str,
     rectangle_vertices: List[Tuple[float, float]],
-    default_class: str = 'Developed space'
+    default_class: str = 'Developed space',
+    detect_ocean: bool = True,
+    land_polygon = "NOT_PROVIDED"
 ) -> np.ndarray:
-    """Create a grid of land cover classes from GeoDataFrame polygon data."""
+    """
+    Create a grid of land cover classes from GeoDataFrame polygon data.
+    
+    Uses vectorized rasterization for ~100x speedup over cell-by-cell intersection.
+    
+    Args:
+        gdf: GeoDataFrame with land cover polygons and 'class' column
+        meshsize: Grid cell size in meters
+        source: Land cover data source name (e.g., 'OpenStreetMap')
+        rectangle_vertices: List of (lon, lat) tuples defining the area
+        default_class: Default class for cells not covered by any polygon
+        detect_ocean: If True, use OSM land polygons to detect ocean areas.
+                     Areas outside land polygons will be classified as 'Water'
+                     instead of the default class.
+        land_polygon: Optional pre-computed land polygon from OSM coastlines.
+                     If provided (including None), this is used directly.
+                     If "NOT_PROVIDED", coastlines will be queried when detect_ocean=True.
+    
+    Returns:
+        2D numpy array of land cover class names
+    """
     import numpy as np
     import geopandas as gpd
-    from shapely.geometry import box
-    from shapely.errors import GEOSException
-    from rtree import index
+    from rasterio import features
+    from shapely.geometry import box, Polygon as ShapelyPolygon
 
     class_priority = get_class_priority(source)
 
@@ -95,8 +116,9 @@ def create_land_cover_grid_from_gdf_polygon(
         calculate_distance,
         normalize_to_one_meter,
     )
-    from .core import calculate_grid_size, create_cell_polygon
+    from .core import calculate_grid_size
 
+    # Calculate grid dimensions
     geod = initialize_geod()
     vertex_0, vertex_1, vertex_3 = rectangle_vertices[0], rectangle_vertices[1], rectangle_vertices[3]
     dist_side_1 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_1[0], vertex_1[1])
@@ -107,51 +129,153 @@ def create_land_cover_grid_from_gdf_polygon(
     u_vec = normalize_to_one_meter(side_1, dist_side_1)
     v_vec = normalize_to_one_meter(side_2, dist_side_2)
 
-    origin = np.array(rectangle_vertices[0])
     grid_size, adjusted_meshsize = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
+    rows, cols = grid_size
+
+    # Get bounding box for the raster
+    min_lon = min(coord[0] for coord in rectangle_vertices)
+    max_lon = max(coord[0] for coord in rectangle_vertices)
+    min_lat = min(coord[1] for coord in rectangle_vertices)
+    max_lat = max(coord[1] for coord in rectangle_vertices)
+
+    # Create affine transform (top-left origin, pixel size)
+    pixel_width = (max_lon - min_lon) / cols
+    pixel_height = (max_lat - min_lat) / rows
+    transform = Affine(pixel_width, 0, min_lon, 0, -pixel_height, max_lat)
+
+    # Build class name to priority mapping, then sort classes by priority (highest priority = lowest number = rasterize last)
+    unique_classes = gdf['class'].unique().tolist()
+    if default_class not in unique_classes:
+        unique_classes.append(default_class)
+    
+    # Map class names to integer codes
+    class_to_code = {cls: i for i, cls in enumerate(unique_classes)}
+    code_to_class = {i: cls for cls, i in class_to_code.items()}
+    default_code = class_to_code[default_class]
+
+    # Initialize grid with default class code
+    grid_int = np.full((rows, cols), default_code, dtype=np.int32)
+
+    # Sort classes by priority (highest priority last so they overwrite lower priority)
+    # Lower priority number = higher priority = should be drawn last
+    sorted_classes = sorted(unique_classes, key=lambda c: class_priority.get(c, 999), reverse=True)
+
+    # Rasterize each class in priority order (lowest priority first, highest priority last overwrites)
+    for lc_class in sorted_classes:
+        if lc_class == default_class:
+            continue  # Already filled as default
+        
+        class_gdf = gdf[gdf['class'] == lc_class]
+        if class_gdf.empty:
+            continue
+        
+        # Get all geometries for this class
+        geometries = class_gdf.geometry.tolist()
+        
+        # Filter out invalid geometries and fix them
+        valid_geometries = []
+        for geom in geometries:
+            if geom is None or geom.is_empty:
+                continue
+            if not geom.is_valid:
+                geom = geom.buffer(0)
+            if geom.is_valid and not geom.is_empty:
+                valid_geometries.append(geom)
+        
+        if not valid_geometries:
+            continue
+        
+        # Create shapes for rasterization: (geometry, value) pairs
+        class_code = class_to_code[lc_class]
+        shapes = [(geom, class_code) for geom in valid_geometries]
+        
+        # Rasterize this class onto the grid (overwrites previous values)
+        try:
+            features.rasterize(
+                shapes=shapes,
+                out=grid_int,
+                transform=transform,
+                all_touched=False,  # Only cells whose center is inside
+            )
+        except Exception:
+            # Fallback: try each geometry individually
+            for geom, val in shapes:
+                try:
+                    features.rasterize(
+                        shapes=[(geom, val)],
+                        out=grid_int,
+                        transform=transform,
+                        all_touched=False,
+                    )
+                except Exception:
+                    continue
+
+    # Convert integer codes back to class names
+    grid = np.empty((rows, cols), dtype=object)
+    for code, cls_name in code_to_class.items():
+        grid[grid_int == code] = cls_name
 
-    grid = np.full(grid_size, default_class, dtype=object)
-
-    extent = [min(coord[1] for coord in rectangle_vertices), max(coord[1] for coord in rectangle_vertices),
-              min(coord[0] for coord in rectangle_vertices), max(coord[0] for coord in rectangle_vertices)]
-    plotting_box = box(extent[2], extent[0], extent[3], extent[1])
-
-    land_cover_polygons = []
-    idx = index.Index()
-    for i, row in gdf.iterrows():
-        polygon = row.geometry
-        land_cover_class = row['class']
-        land_cover_polygons.append((polygon, land_cover_class))
-        idx.insert(i, polygon.bounds)
-
-    for i in range(grid_size[0]):
-        for j in range(grid_size[1]):
-            land_cover_class = default_class
-            cell = create_cell_polygon(origin, i, j, adjusted_meshsize, u_vec, v_vec)
-            for k in idx.intersection(cell.bounds):
-                polygon, land_cover_class_temp = land_cover_polygons[k]
+    # Apply ocean detection BEFORE flipping if requested
+    # This uses land polygons from OSM coastlines to classify ocean areas
+    if detect_ocean:
+        try:
+            from ...downloader.ocean import get_land_polygon_for_area, get_ocean_class_for_source
+            
+            ocean_class = get_ocean_class_for_source(source)
+            
+            # Use provided land_polygon or query from coastlines if not provided
+            if land_polygon == "NOT_PROVIDED":
+                land_polygon = get_land_polygon_for_area(rectangle_vertices, use_cache=False)
+            
+            if land_polygon is not None:
+                # Rasterize land polygon - cells inside are land, outside are ocean
+                land_mask = np.zeros((rows, cols), dtype=np.uint8)
+                
                 try:
-                    if cell.intersects(polygon):
-                        intersection = cell.intersection(polygon)
-                        if intersection.area > cell.area / 2:
-                            rank = class_priority[land_cover_class]
-                            rank_temp = class_priority[land_cover_class_temp]
-                            if rank_temp < rank:
-                                land_cover_class = land_cover_class_temp
-                                grid[i, j] = land_cover_class
-                except GEOSException as e:
-                    try:
-                        fixed_polygon = polygon.buffer(0)
-                        if cell.intersects(fixed_polygon):
-                            intersection = cell.intersection(fixed_polygon)
-                            if intersection.area > cell.area / 2:
-                                rank = class_priority[land_cover_class]
-                                rank_temp = class_priority[land_cover_class_temp]
-                                if rank_temp < rank:
-                                    land_cover_class = land_cover_class_temp
-                                    grid[i, j] = land_cover_class
-                    except Exception:
-                        continue
+                    if land_polygon.geom_type == 'Polygon':
+                        land_geometries = [(land_polygon, 1)]
+                    else:  # MultiPolygon
+                        land_geometries = [(geom, 1) for geom in land_polygon.geoms]
+                    
+                    features.rasterize(
+                        shapes=land_geometries,
+                        out=land_mask,
+                        transform=transform,
+                        all_touched=False
+                    )
+                    
+                    # Apply ocean class to cells that are:
+                    # 1. Outside land polygon (land_mask == 0)
+                    # 2. Currently classified as the default class
+                    ocean_cells = (land_mask == 0) & (grid == default_class)
+                    ocean_count = np.sum(ocean_cells)
+                    
+                    if ocean_count > 0:
+                        grid[ocean_cells] = ocean_class
+                        pct = 100 * ocean_count / grid.size
+                        print(f"  Ocean detection: {ocean_count:,} cells ({pct:.1f}%) classified as '{ocean_class}'")
+                        
+                except Exception as e:
+                    print(f"  Warning: Ocean rasterization failed: {e}")
+            else:
+                # No coastlines - check if area is all ocean or all land
+                from ...downloader.ocean import check_if_area_is_ocean_via_land_features
+                is_ocean = check_if_area_is_ocean_via_land_features(rectangle_vertices)
+                if is_ocean:
+                    # Convert all default class cells to water
+                    ocean_cells = (grid == default_class)
+                    ocean_count = np.sum(ocean_cells)
+                    if ocean_count > 0:
+                        grid[ocean_cells] = ocean_class
+                        pct = 100 * ocean_count / grid.size
+                        print(f"  Ocean detection: {ocean_count:,} cells ({pct:.1f}%) classified as '{ocean_class}' (open ocean)")
+                        
+        except Exception as e:
+            print(f"  Warning: Ocean detection failed: {e}")
+
+    # Flip to match expected orientation (north-up)
+    grid = np.flipud(grid)
+    
     return grid
 
 

voxcity/geoprocessor/raster/raster.py

@@ -38,7 +38,7 @@ def create_height_grid_from_geotiff_polygon(
         xs, ys = new_affine * (cols, rows)
         xs_flat, ys_flat = xs.flatten(), ys.flatten()
 
-        row, col = src.index(xs_flat, ys_flat)
+        row, col = rasterio.transform.rowcol(src.transform, xs_flat, ys_flat)
         row, col = np.array(row), np.array(col)
 
         valid = (row >= 0) & (row < src.height) & (col >= 0) & (col < src.width)

voxcity/models.py

@@ -70,6 +70,8 @@ class PipelineConfig:
     remove_perimeter_object: Optional[float] = None
     mapvis: bool = False
     gridvis: bool = True
+    # Parallel download mode: if True, downloads run concurrently using ThreadPoolExecutor
+    parallel_download: bool = False
     # Structured options for strategies and I/O/visualization
     land_cover_options: Dict[str, Any] = field(default_factory=dict)
     building_options: Dict[str, Any] = field(default_factory=dict)

voxcity/simulator_gpu/__init__.py

@@ -0,0 +1,115 @@
+"""simulator_gpu: GPU-accelerated simulation modules using Taichi.
+
+Compatibility goal:
+    Allow the common VoxCity pattern to work without code changes beyond the
+    import alias:
+
+        import simulator_gpu as simulator
+
+    by flattening a VoxCity-like public namespace (view/visibility/solar/utils).
+"""
+
+import os
+
+# Disable Numba caching to prevent stale cache issues when module paths change.
+# This avoids "ModuleNotFoundError: No module named 'simulator_gpu'" errors
+# that can occur when Numba tries to load cached functions with old module paths.
+os.environ.setdefault("NUMBA_CACHE_DIR", "")  # Disable disk caching
+os.environ.setdefault("NUMBA_DISABLE_JIT", "0")  # Keep JIT enabled for performance
+
+# Import Taichi initialization utilities first
+from .init_taichi import (  # noqa: F401
+    init_taichi,
+    ensure_initialized,
+    is_initialized,
+)
+
+# Check if Taichi is available
+try:
+    import taichi as ti
+    _TAICHI_AVAILABLE = True
+except ImportError:
+    _TAICHI_AVAILABLE = False
+
+# VoxCity-style flattening
+from .view import *  # noqa: F401,F403
+from .solar import *  # noqa: F401,F403
+from .utils import *  # noqa: F401,F403
+
+# Export submodules for explicit access
+from . import solar  # noqa: F401
+from . import visibility  # noqa: F401
+from . import view  # noqa: F401
+from . import utils  # noqa: F401
+from . import common  # noqa: F401
+
+# VoxCity-flattened module names that some code expects to exist on the toplevel
+from . import sky  # noqa: F401
+from . import kernels  # noqa: F401
+from . import radiation  # noqa: F401
+from . import temporal  # noqa: F401
+from . import integration  # noqa: F401
+
+# Commonly re-exported VoxCity solar helpers
+from .kernels import compute_direct_solar_irradiance_map_binary  # noqa: F401
+from .radiation import compute_solar_irradiance_for_all_faces  # noqa: F401
+
+# Backward compatibility: some code treats `simulator.view` as `simulator.visibility`
+# (VoxCity provides `view.py` wrapper; we also provide that module).
+
+# Export shared modules (kept; extra symbols are fine)
+from .core import (  # noqa: F401
+    Vector3, Point3,
+    PI, TWO_PI, DEG_TO_RAD, RAD_TO_DEG,
+    SOLAR_CONSTANT, EXT_COEF,
+)
+from .domain import Domain, IUP, IDOWN, INORTH, ISOUTH, IEAST, IWEST  # noqa: F401
+
+
+def clear_numba_cache():
+    """Clear Numba's compiled function cache to resolve stale cache issues.
+    
+    Call this function if you encounter errors like:
+        ModuleNotFoundError: No module named 'simulator_gpu'
+    
+    After calling this function, restart your Python kernel/interpreter.
+    """
+    import shutil
+    import glob
+    from pathlib import Path
+    
+    cleared = []
+    
+    # Clear .nbc and .nbi files in the package directory
+    package_dir = Path(__file__).parent
+    for pattern in ["**/*.nbc", "**/*.nbi"]:
+        for cache_file in package_dir.glob(pattern):
+            try:
+                cache_file.unlink()
+                cleared.append(str(cache_file))
+            except Exception:
+                pass
+    
+    # Clear __pycache__ directories
+    for pycache in package_dir.glob("**/__pycache__"):
+        try:
+            shutil.rmtree(pycache)
+            cleared.append(str(pycache))
+        except Exception:
+            pass
+    
+    # Try to clear user's .numba_cache if it exists
+    home = Path.home()
+    numba_cache = home / ".numba_cache"
+    if numba_cache.exists():
+        try:
+            shutil.rmtree(numba_cache)
+            cleared.append(str(numba_cache))
+        except Exception:
+            pass
+    
+    print(f"Cleared {len(cleared)} cache items. Please restart your Python kernel.")
+    return cleared
+
+
+__version__ = "0.1.0"

voxcity/simulator_gpu/common/__init__.py

@@ -0,0 +1,9 @@
+"""VoxCity-style `common` namespace.
+
+VoxCity exposes helpers under `voxcity.simulator.common.*`.
+`simulator_gpu` implements only the subset needed for drop-in compatibility.
+"""
+
+from .geometry import rotate_vector_axis_angle
+
+__all__ = ["rotate_vector_axis_angle"]

voxcity/simulator_gpu/common/geometry.py

@@ -0,0 +1,11 @@
+"""Geometry helpers for VoxCity compatibility.
+
+This module is intended to satisfy imports like:
+    from simulator.common.geometry import rotate_vector_axis_angle
+
+It forwards to the implementation used by `simulator_gpu.visibility`.
+"""
+
+from ..visibility.geometry import rotate_vector_axis_angle
+
+__all__ = ["rotate_vector_axis_angle"]