voxcity 1.0.2__py3-none-any.whl → 1.0.15__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/solar/__init__.py

@@ -64,3 +64,16 @@ from .integration import (  # noqa: F401
     save_irradiance_mesh,
     load_irradiance_mesh,
 )
+
+# Computation mask utilities (re-export from simulator_gpu for convenience)
+try:
+    from voxcity.simulator_gpu.solar.mask import (  # noqa: F401
+        create_computation_mask,
+        draw_computation_mask,
+        get_mask_from_drawing,
+        visualize_computation_mask,
+        get_mask_info,
+    )
+except ImportError:
+    # simulator_gpu may not be installed
+    pass

voxcity/simulator_gpu/__init__.py

@@ -0,0 +1,90 @@
+"""simulator_gpu: GPU-accelerated urban simulation using Taichi.
+
+This package provides GPU-accelerated implementations for:
+- Solar radiation simulation (direct, diffuse, cumulative)
+- View analysis (green view index, sky view factor)
+- Landmark visibility analysis
+
+Submodules:
+    solar: Solar radiation calculations
+    visibility: View and visibility analysis
+
+Example:
+    from voxcity.simulator_gpu import solar, visibility
+    
+    # Solar radiation
+    irradiance = solar.get_global_solar_irradiance_using_epw(voxcity, ...)
+    
+    # View analysis
+    gvi = visibility.get_view_index(voxcity, mode='green')
+"""
+
+import os
+
+# Disable Numba caching to prevent stale cache issues
+os.environ.setdefault("NUMBA_CACHE_DIR", "")
+os.environ.setdefault("NUMBA_DISABLE_JIT", "0")
+
+# Taichi initialization
+from .init_taichi import init_taichi, ensure_initialized, is_initialized
+
+# Core utilities
+from .core import (
+    Vector3, Point3,
+    PI, TWO_PI, DEG_TO_RAD, RAD_TO_DEG,
+    SOLAR_CONSTANT, EXT_COEF,
+)
+
+# Domain (shared between solar and visibility)
+from .domain import Domain, Surfaces, extract_surfaces_from_domain
+from .domain import IUP, IDOWN, INORTH, ISOUTH, IEAST, IWEST
+
+# Submodules
+from . import solar
+from . import visibility
+
+# Convenience imports from solar
+from .solar import (
+    get_global_solar_irradiance_using_epw,
+    get_building_global_solar_irradiance_using_epw,
+    get_direct_solar_irradiance_map,
+    get_diffuse_solar_irradiance_map,
+    get_global_solar_irradiance_map,
+)
+
+# Convenience imports from visibility
+from .visibility import (
+    get_view_index,
+    get_sky_view_factor_map,
+    get_surface_view_factor,
+    get_landmark_visibility_map,
+    get_surface_landmark_visibility,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Initialization
+    'init_taichi', 'ensure_initialized', 'is_initialized',
+    # Core
+    'Vector3', 'Point3',
+    'PI', 'TWO_PI', 'DEG_TO_RAD', 'RAD_TO_DEG',
+    'SOLAR_CONSTANT', 'EXT_COEF',
+    # Domain
+    'Domain', 'Surfaces', 'extract_surfaces_from_domain',
+    'IUP', 'IDOWN', 'INORTH', 'ISOUTH', 'IEAST', 'IWEST',
+    # Submodules
+    'solar', 'visibility',
+    # Solar (convenience)
+    'get_global_solar_irradiance_using_epw',
+    'get_building_global_solar_irradiance_using_epw',
+    'get_direct_solar_irradiance_map',
+    'get_diffuse_solar_irradiance_map',
+    'get_global_solar_irradiance_map',
+    # Visibility (convenience)
+    'get_view_index',
+    'get_sky_view_factor_map',
+    'get_surface_view_factor',
+    'get_landmark_visibility_map',
+    'get_surface_landmark_visibility',
+]