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

voxcity/geoprocessor/raster/core.py

@@ -2,6 +2,8 @@ import numpy as np
 from typing import Tuple, Dict, Any
 from shapely.geometry import Polygon
 
+from ..utils import initialize_geod, calculate_distance, normalize_to_one_meter
+
 
 def apply_operation(arr: np.ndarray, meshsize: float) -> np.ndarray:
     """
@@ -146,5 +148,34 @@ def create_cell_polygon(
     return Polygon([bottom_left, bottom_right, top_right, top_left])
 
 
+def compute_grid_shape(rectangle_vertices, meshsize: float) -> Tuple[int, int]:
+    """
+    Compute the grid dimensions (rows, cols) for a given rectangle and mesh size.
+    
+    This is useful when you need to know the output grid shape without
+    actually creating the grid (e.g., for pre-allocating arrays or fallback shapes).
+    
+    Args:
+        rectangle_vertices: List of 4 vertices [(lon, lat), ...] defining the rectangle.
+        meshsize: Grid cell size in meters.
+        
+    Returns:
+        Tuple of (grid_size_0, grid_size_1) representing 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])
+    dist_side_2 = calculate_distance(geod, vertex_0[0], vertex_0[1], vertex_3[0], vertex_3[1])
+    
+    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_size, _ = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
+    return grid_size
+
+
 
 

voxcity/geoprocessor/raster/export.py

@@ -1,93 +1,93 @@
-import numpy as np
-import geopandas as gpd
-from shapely.geometry import box
-from pyproj import CRS, Transformer
-from ...utils.orientation import ensure_orientation, ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP
-
-
-def grid_to_geodataframe(grid_ori, rectangle_vertices, meshsize):
-    """
-    Converts a 2D grid to a GeoDataFrame with cell polygons and values.
-    Output CRS: EPSG:4326
-    """
-    grid = ensure_orientation(grid_ori.copy(), ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP)
-
-    min_lon = min(v[0] for v in rectangle_vertices)
-    max_lon = max(v[0] for v in rectangle_vertices)
-    min_lat = min(v[1] for v in rectangle_vertices)
-    max_lat = max(v[1] for v in rectangle_vertices)
-
-    rows, cols = grid.shape
-
-    wgs84 = CRS.from_epsg(4326)
-    web_mercator = CRS.from_epsg(3857)
-    transformer_to_mercator = Transformer.from_crs(wgs84, web_mercator, always_xy=True)
-    transformer_to_wgs84 = Transformer.from_crs(web_mercator, wgs84, always_xy=True)
-
-    min_x, min_y = transformer_to_mercator.transform(min_lon, min_lat)
-    max_x, max_y = transformer_to_mercator.transform(max_lon, max_lat)
-
-    cell_size_x = (max_x - min_x) / cols
-    cell_size_y = (max_y - min_y) / rows
-
-    polygons = []
-    values = []
-
-    for i in range(rows):
-        for j in range(cols):
-            cell_min_x = min_x + j * cell_size_x
-            cell_max_x = min_x + (j + 1) * cell_size_x
-            cell_min_y = max_y - (i + 1) * cell_size_y
-            cell_max_y = max_y - i * cell_size_y
-            cell_min_lon, cell_min_lat = transformer_to_wgs84.transform(cell_min_x, cell_min_y)
-            cell_max_lon, cell_max_lat = transformer_to_wgs84.transform(cell_max_x, cell_max_y)
-            cell_poly = box(cell_min_lon, cell_min_lat, cell_max_lon, cell_max_lat)
-            polygons.append(cell_poly)
-            values.append(grid[i, j])
-
-    gdf = gpd.GeoDataFrame({'geometry': polygons, 'value': values}, crs=CRS.from_epsg(4326))
-    return gdf
-
-
-def grid_to_point_geodataframe(grid_ori, rectangle_vertices, meshsize):
-    """
-    Converts a 2D grid to a GeoDataFrame with point geometries at cell centers and values.
-    Output CRS: EPSG:4326
-    """
-    import geopandas as gpd
-    from shapely.geometry import Point
-
-    grid = ensure_orientation(grid_ori.copy(), ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP)
-
-    min_lon = min(v[0] for v in rectangle_vertices)
-    max_lon = max(v[0] for v in rectangle_vertices)
-    min_lat = min(v[1] for v in rectangle_vertices)
-    max_lat = max(v[1] for v in rectangle_vertices)
-
-    rows, cols = grid.shape
-
-    wgs84 = CRS.from_epsg(4326)
-    web_mercator = CRS.from_epsg(3857)
-    transformer_to_mercator = Transformer.from_crs(wgs84, web_mercator, always_xy=True)
-    transformer_to_wgs84 = Transformer.from_crs(web_mercator, wgs84, always_xy=True)
-
-    min_x, min_y = transformer_to_mercator.transform(min_lon, min_lat)
-    max_x, max_y = transformer_to_mercator.transform(max_lon, max_lat)
-
-    cell_size_x = (max_x - min_x) / cols
-    cell_size_y = (max_y - min_y) / rows
-
-    points = []
-    values = []
-    for i in range(rows):
-        for j in range(cols):
-            cell_center_x = min_x + (j + 0.5) * cell_size_x
-            cell_center_y = max_y - (i + 0.5) * cell_size_y
-            center_lon, center_lat = transformer_to_wgs84.transform(cell_center_x, cell_center_y)
-            points.append(Point(center_lon, center_lat))
-            values.append(grid[i, j])
-
-    gdf = gpd.GeoDataFrame({'geometry': points, 'value': values}, crs=CRS.from_epsg(4326))
-    return gdf
-
-
+import numpy as np
+import geopandas as gpd
+from shapely.geometry import box
+from pyproj import CRS, Transformer
+from ...utils.orientation import ensure_orientation, ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP
+
+
+def grid_to_geodataframe(grid_ori, rectangle_vertices, meshsize):
+    """
+    Converts a 2D grid to a GeoDataFrame with cell polygons and values.
+    Output CRS: EPSG:4326
+    """
+    grid = ensure_orientation(grid_ori.copy(), ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP)
+
+    min_lon = min(v[0] for v in rectangle_vertices)
+    max_lon = max(v[0] for v in rectangle_vertices)
+    min_lat = min(v[1] for v in rectangle_vertices)
+    max_lat = max(v[1] for v in rectangle_vertices)
+
+    rows, cols = grid.shape
+
+    wgs84 = CRS.from_epsg(4326)
+    web_mercator = CRS.from_epsg(3857)
+    transformer_to_mercator = Transformer.from_crs(wgs84, web_mercator, always_xy=True)
+    transformer_to_wgs84 = Transformer.from_crs(web_mercator, wgs84, always_xy=True)
+
+    min_x, min_y = transformer_to_mercator.transform(min_lon, min_lat)
+    max_x, max_y = transformer_to_mercator.transform(max_lon, max_lat)
+
+    cell_size_x = (max_x - min_x) / cols
+    cell_size_y = (max_y - min_y) / rows
+
+    polygons = []
+    values = []
+
+    for i in range(rows):
+        for j in range(cols):
+            cell_min_x = min_x + j * cell_size_x
+            cell_max_x = min_x + (j + 1) * cell_size_x
+            cell_min_y = max_y - (i + 1) * cell_size_y
+            cell_max_y = max_y - i * cell_size_y
+            cell_min_lon, cell_min_lat = transformer_to_wgs84.transform(cell_min_x, cell_min_y)
+            cell_max_lon, cell_max_lat = transformer_to_wgs84.transform(cell_max_x, cell_max_y)
+            cell_poly = box(cell_min_lon, cell_min_lat, cell_max_lon, cell_max_lat)
+            polygons.append(cell_poly)
+            values.append(grid[i, j])
+
+    gdf = gpd.GeoDataFrame({'geometry': polygons, 'value': values}, crs=CRS.from_epsg(4326))
+    return gdf
+
+
+def grid_to_point_geodataframe(grid_ori, rectangle_vertices, meshsize):
+    """
+    Converts a 2D grid to a GeoDataFrame with point geometries at cell centers and values.
+    Output CRS: EPSG:4326
+    """
+    import geopandas as gpd
+    from shapely.geometry import Point
+
+    grid = ensure_orientation(grid_ori.copy(), ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP)
+
+    min_lon = min(v[0] for v in rectangle_vertices)
+    max_lon = max(v[0] for v in rectangle_vertices)
+    min_lat = min(v[1] for v in rectangle_vertices)
+    max_lat = max(v[1] for v in rectangle_vertices)
+
+    rows, cols = grid.shape
+
+    wgs84 = CRS.from_epsg(4326)
+    web_mercator = CRS.from_epsg(3857)
+    transformer_to_mercator = Transformer.from_crs(wgs84, web_mercator, always_xy=True)
+    transformer_to_wgs84 = Transformer.from_crs(web_mercator, wgs84, always_xy=True)
+
+    min_x, min_y = transformer_to_mercator.transform(min_lon, min_lat)
+    max_x, max_y = transformer_to_mercator.transform(max_lon, max_lat)
+
+    cell_size_x = (max_x - min_x) / cols
+    cell_size_y = (max_y - min_y) / rows
+
+    points = []
+    values = []
+    for i in range(rows):
+        for j in range(cols):
+            cell_center_x = min_x + (j + 0.5) * cell_size_x
+            cell_center_y = max_y - (i + 0.5) * cell_size_y
+            center_lon, center_lat = transformer_to_wgs84.transform(cell_center_x, cell_center_y)
+            points.append(Point(center_lon, center_lat))
+            values.append(grid[i, j])
+
+    gdf = gpd.GeoDataFrame({'geometry': points, 'value': values}, crs=CRS.from_epsg(4326))
+    return gdf
+
+

voxcity/geoprocessor/raster/landcover.py

@@ -17,9 +17,12 @@ from .core import translate_array
 def tree_height_grid_from_land_cover(land_cover_grid_ori: np.ndarray) -> np.ndarray:
     """
     Convert a land cover grid to a tree height grid.
+    
+    Expects 1-based land cover indices where class 5 is Tree.
     """
-    land_cover_grid = np.flipud(land_cover_grid_ori) + 1
-    tree_translation_dict = {1: 0, 2: 0, 3: 0, 4: 10, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0}
+    land_cover_grid = np.flipud(land_cover_grid_ori)
+    # 1-based indices: 1=Bareland, 2=Rangeland, 3=Shrub, 4=Agriculture, 5=Tree, etc.
+    tree_translation_dict = {1: 0, 2: 0, 3: 0, 4: 0, 5: 10, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0}
     tree_height_grid = translate_array(np.flipud(land_cover_grid), tree_translation_dict).astype(int)
     return tree_height_grid
 
@@ -55,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)
@@ -76,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)
 
@@ -92,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])
@@ -104,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)
 
-    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]
+    # 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:
-                    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
+                    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
+
+    # 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 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)