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

voxcity/geoprocessor/raster/canopy.py

@@ -0,0 +1,258 @@
+import warnings
+from typing import List, Tuple
+
+import numpy as np
+import geopandas as gpd
+from shapely.geometry import Polygon, Point
+from pyproj import CRS, Transformer, Geod
+
+from ..utils import initialize_geod, calculate_distance, normalize_to_one_meter
+from .core import calculate_grid_size
+
+
+def create_vegetation_height_grid_from_gdf_polygon(veg_gdf, mesh_size, polygon):
+    """
+    Create a vegetation height grid from a GeoDataFrame of vegetation polygons/objects.
+    Cells with vegetation take the max height of intersecting features.
+    Returns north-up grid (row 0 = north).
+    """
+    if veg_gdf.crs is None:
+        warnings.warn("veg_gdf has no CRS. Assuming EPSG:4326. ")
+        veg_gdf = veg_gdf.set_crs(epsg=4326)
+    else:
+        if veg_gdf.crs.to_epsg() != 4326:
+            veg_gdf = veg_gdf.to_crs(epsg=4326)
+
+    if 'height' not in veg_gdf.columns:
+        raise ValueError("Vegetation GeoDataFrame must have a 'height' column.")
+
+    if isinstance(polygon, list):
+        poly = Polygon(polygon)
+    elif isinstance(polygon, Polygon):
+        poly = polygon
+    else:
+        raise ValueError("polygon must be a list of (lon, lat) or a shapely Polygon.")
+
+    left, bottom, right, top = poly.bounds
+    geod = Geod(ellps="WGS84")
+    _, _, width_m = geod.inv(left, bottom, right, bottom)
+    _, _, height_m = geod.inv(left, bottom, left, top)
+
+    num_cells_x = int(width_m / mesh_size + 0.5)
+    num_cells_y = int(height_m / mesh_size + 0.5)
+
+    if num_cells_x < 1 or num_cells_y < 1:
+        warnings.warn("Polygon bounding box is smaller than mesh_size; returning empty array.")
+        return np.array([])
+
+    xs = np.linspace(left, right, num_cells_x)
+    ys = np.linspace(top, bottom, num_cells_y)
+    X, Y = np.meshgrid(xs, ys)
+    xs_flat = X.ravel()
+    ys_flat = Y.ravel()
+
+    grid_points = gpd.GeoDataFrame(
+        geometry=[Point(lon, lat) for lon, lat in zip(xs_flat, ys_flat)],
+        crs="EPSG:4326"
+    )
+
+    joined = gpd.sjoin(
+        grid_points,
+        veg_gdf[['height', 'geometry']],
+        how='left',
+        predicate='intersects'
+    )
+
+    joined_agg = (
+        joined.groupby(joined.index).agg({'height': 'max'})
+    )
+
+    veg_grid = np.zeros((num_cells_y, num_cells_x), dtype=float)
+    for i, row_data in joined_agg.iterrows():
+        if not np.isnan(row_data['height']):
+            row_idx = i // num_cells_x
+            col_idx = i % num_cells_x
+            veg_grid[row_idx, col_idx] = row_data['height']
+
+    return np.flipud(veg_grid)
+
+
+def create_dem_grid_from_gdf_polygon(terrain_gdf, mesh_size, polygon):
+    """
+    Create a height grid from a terrain GeoDataFrame using nearest-neighbor sampling.
+    Returns north-up grid.
+    """
+    if terrain_gdf.crs is None:
+        warnings.warn("terrain_gdf has no CRS. Assuming EPSG:4326. ")
+        terrain_gdf = terrain_gdf.set_crs(epsg=4326)
+    else:
+        if terrain_gdf.crs.to_epsg() != 4326:
+            terrain_gdf = terrain_gdf.to_crs(epsg=4326)
+
+    if isinstance(polygon, list):
+        poly = Polygon(polygon)
+    elif isinstance(polygon, Polygon):
+        poly = polygon
+    else:
+        raise ValueError("`polygon` must be a list of (lon, lat) or a shapely Polygon.")
+
+    left, bottom, right, top = poly.bounds
+    geod = Geod(ellps="WGS84")
+    _, _, width_m = geod.inv(left, bottom, right, bottom)
+    _, _, height_m = geod.inv(left, bottom, left, top)
+    num_cells_x = int(width_m / mesh_size + 0.5)
+    num_cells_y = int(height_m / mesh_size + 0.5)
+    if num_cells_x < 1 or num_cells_y < 1:
+        warnings.warn("Polygon bounding box is smaller than mesh_size; returning empty array.")
+        return np.array([])
+
+    xs = np.linspace(left, right, num_cells_x)
+    ys = np.linspace(top, bottom, num_cells_y)
+    X, Y = np.meshgrid(xs, ys)
+    xs_flat = X.ravel()
+    ys_flat = Y.ravel()
+
+    grid_points = gpd.GeoDataFrame(
+        geometry=[Point(lon, lat) for lon, lat in zip(xs_flat, ys_flat)],
+        crs="EPSG:4326"
+    )
+
+    if 'elevation' not in terrain_gdf.columns:
+        raise ValueError("terrain_gdf must have an 'elevation' column.")
+
+    try:
+        centroid = poly.centroid
+        lon_c, lat_c = float(centroid.x), float(centroid.y)
+        zone = int((lon_c + 180.0) // 6) + 1
+        epsg_proj = 32600 + zone if lat_c >= 0 else 32700 + zone
+        terrain_proj = terrain_gdf.to_crs(epsg=epsg_proj)
+        grid_points_proj = grid_points.to_crs(epsg=epsg_proj)
+
+        grid_points_elev = gpd.sjoin_nearest(
+            grid_points_proj,
+            terrain_proj[['elevation', 'geometry']],
+            how="left",
+            distance_col="dist_to_terrain"
+        )
+        grid_points_elev.index = grid_points.index
+    except Exception:
+        grid_points_elev = gpd.sjoin_nearest(
+            grid_points,
+            terrain_gdf[['elevation', 'geometry']],
+            how="left",
+            distance_col="dist_to_terrain"
+        )
+
+    dem_grid = np.full((num_cells_y, num_cells_x), np.nan, dtype=float)
+    for i, elevation_val in zip(grid_points_elev.index, grid_points_elev['elevation']):
+        row = i // num_cells_x
+        col = i % num_cells_x
+        dem_grid[row, col] = elevation_val
+    return np.flipud(dem_grid)
+
+
+def create_canopy_grids_from_tree_gdf(tree_gdf, meshsize, rectangle_vertices):
+    """
+    Create canopy top and bottom height grids from a tree GeoDataFrame.
+    Returns (canopy_height_grid, canopy_bottom_height_grid).
+    """
+    if tree_gdf is None or len(tree_gdf) == 0:
+        return np.array([]), np.array([])
+
+    required_cols = ['top_height', 'bottom_height', 'crown_diameter', 'geometry']
+    for col in required_cols:
+        if col not in tree_gdf.columns:
+            raise ValueError(f"tree_gdf must contain '{col}' column.")
+
+    if tree_gdf.crs is None:
+        warnings.warn("tree_gdf has no CRS. Assuming EPSG:4326.")
+        tree_gdf = tree_gdf.set_crs(epsg=4326)
+    elif tree_gdf.crs.to_epsg() != 4326:
+        tree_gdf = tree_gdf.to_crs(epsg=4326)
+
+    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)
+
+    origin = np.array(rectangle_vertices[0])
+    grid_size, adjusted_meshsize = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
+    nx, ny = grid_size[0], grid_size[1]
+
+    i_centers_m = (np.arange(nx) + 0.5) * adjusted_meshsize[0]
+    j_centers_m = (np.arange(ny) + 0.5) * adjusted_meshsize[1]
+
+    canopy_top = np.zeros((nx, ny), dtype=float)
+    canopy_bottom = np.zeros((nx, ny), dtype=float)
+
+    transform_mat = np.column_stack((u_vec, v_vec))
+    try:
+        transform_inv = np.linalg.inv(transform_mat)
+    except np.linalg.LinAlgError:
+        transform_inv = np.linalg.pinv(transform_mat)
+
+    for _, row in tree_gdf.iterrows():
+        geom = row['geometry']
+        if geom is None or not hasattr(geom, 'x'):
+            continue
+        top_h = float(row.get('top_height', 0.0) or 0.0)
+        bot_h = float(row.get('bottom_height', 0.0) or 0.0)
+        dia = float(row.get('crown_diameter', 0.0) or 0.0)
+        if dia <= 0 or top_h <= 0:
+            continue
+        if bot_h < 0:
+            bot_h = 0.0
+        if bot_h > top_h:
+            top_h, bot_h = bot_h, top_h
+        R = dia / 2.0
+        a = max((top_h - bot_h) / 2.0, 0.0)
+        z0 = (top_h + bot_h) / 2.0
+        tree_lon = float(geom.x)
+        tree_lat = float(geom.y)
+        delta = np.array([tree_lon, tree_lat]) - origin
+        alpha_beta = transform_inv @ delta
+        alpha_m = alpha_beta[0]
+        beta_m = alpha_beta[1]
+        du_cells = int(R / adjusted_meshsize[0] + 2)
+        dv_cells = int(R / adjusted_meshsize[1] + 2)
+        i_center_idx = int(alpha_m / adjusted_meshsize[0])
+        j_center_idx = int(beta_m / adjusted_meshsize[1])
+        i_min = max(0, i_center_idx - du_cells)
+        i_max = min(nx - 1, i_center_idx + du_cells)
+        j_min = max(0, j_center_idx - dv_cells)
+        j_max = min(ny - 1, j_center_idx + dv_cells)
+        if i_min > i_max or j_min > j_max:
+            continue
+        ic = i_centers_m[i_min:i_max + 1][:, None]
+        jc = j_centers_m[j_min:j_max + 1][None, :]
+        di = ic - alpha_m
+        dj = jc - beta_m
+        r = np.sqrt(di * di + dj * dj)
+        within = r <= R
+        if not np.any(within):
+            continue
+        ratio = np.clip(r / max(R, 1e-9), 0.0, 1.0)
+        factor = np.sqrt(1.0 - ratio * ratio)
+        local_top = z0 + a * factor
+        local_bot = z0 - a * factor
+        local_top_masked = np.where(within, local_top, 0.0)
+        local_bot_masked = np.where(within, local_bot, 0.0)
+        canopy_top[i_min:i_max + 1, j_min:j_max + 1] = np.maximum(
+            canopy_top[i_min:i_max + 1, j_min:j_max + 1], local_top_masked
+        )
+        canopy_bottom[i_min:i_max + 1, j_min:j_max + 1] = np.maximum(
+            canopy_bottom[i_min:i_max + 1, j_min:j_max + 1], local_bot_masked
+        )
+
+    canopy_bottom = np.minimum(canopy_bottom, canopy_top)
+    return canopy_top, canopy_bottom
+
+
+
+

voxcity/geoprocessor/raster/core.py

@@ -0,0 +1,150 @@
+import numpy as np
+from typing import Tuple, Dict, Any
+from shapely.geometry import Polygon
+
+
+def apply_operation(arr: np.ndarray, meshsize: float) -> np.ndarray:
+    """
+    Applies a sequence of operations to an array based on a mesh size to normalize and discretize values.
+
+    1) Divide by meshsize, 2) +0.5, 3) floor, 4) rescale by meshsize
+    """
+    step1 = arr / meshsize
+    step2 = step1 + 0.5
+    step3 = np.floor(step2)
+    return step3 * meshsize
+
+
+def translate_array(input_array: np.ndarray, translation_dict: Dict[Any, Any]) -> np.ndarray:
+    """
+    Translate values in an array using a dictionary mapping (vectorized).
+
+    Any value not found in the mapping is replaced with an empty string.
+    Returns an object-dtype ndarray preserving the input shape.
+    """
+    if not isinstance(input_array, np.ndarray):
+        input_array = np.asarray(input_array)
+
+    getter = np.vectorize(lambda v: translation_dict.get(v, ''), otypes=[object])
+    return getter(input_array)
+
+
+def group_and_label_cells(array: np.ndarray) -> np.ndarray:
+    """
+    Convert non-zero numbers in a 2D numpy array to sequential IDs starting from 1.
+    """
+    result = array.copy()
+    unique_values = sorted(set(array.flatten()) - {0})
+    value_to_id = {value: idx + 1 for idx, value in enumerate(unique_values)}
+    for value in unique_values:
+        result[array == value] = value_to_id[value]
+    return result
+
+
+def process_grid_optimized(grid_bi: np.ndarray, dem_grid: np.ndarray) -> np.ndarray:
+    """
+    Optimized version that computes per-building averages without allocating huge arrays
+    when building IDs are large and sparse.
+    """
+    result = dem_grid.copy()
+    if np.any(grid_bi != 0):
+        if grid_bi.dtype.kind == 'f':
+            grid_bi_int = np.nan_to_num(grid_bi, nan=0).astype(np.int64)
+        else:
+            grid_bi_int = grid_bi.astype(np.int64)
+
+        flat_ids = grid_bi_int.ravel()
+        flat_dem = dem_grid.ravel()
+        nz_mask = flat_ids != 0
+        if np.any(nz_mask):
+            ids_nz = flat_ids[nz_mask]
+            vals_nz = flat_dem[nz_mask]
+            unique_ids, inverse_idx = np.unique(ids_nz, return_inverse=True)
+            sums = np.bincount(inverse_idx, weights=vals_nz)
+            counts = np.bincount(inverse_idx)
+            counts[counts == 0] = 1
+            means = sums / counts
+            result.ravel()[nz_mask] = means[inverse_idx]
+    return result - np.min(result)
+
+
+def process_grid(grid_bi: np.ndarray, dem_grid: np.ndarray) -> np.ndarray:
+    """
+    Safe version that tries optimization first, then falls back to original method.
+    """
+    try:
+        return process_grid_optimized(grid_bi, dem_grid)
+    except Exception as e:
+        print(f"Optimized process_grid failed: {e}, using original method")
+        unique_ids = np.unique(grid_bi[grid_bi != 0])
+        result = dem_grid.copy()
+        for id_num in unique_ids:
+            mask = (grid_bi == id_num)
+            avg_value = np.mean(dem_grid[mask])
+            result[mask] = avg_value
+        return result - np.min(result)
+
+
+def calculate_grid_size(
+    side_1: np.ndarray,
+    side_2: np.ndarray,
+    u_vec: np.ndarray,
+    v_vec: np.ndarray,
+    meshsize: float
+) -> Tuple[Tuple[int, int], Tuple[float, float]]:
+    """
+    Calculate grid size and adjusted mesh size based on input parameters.
+    Returns ((nx, ny), (dx, dy))
+    """
+    dist_side_1_m = np.linalg.norm(side_1) / (np.linalg.norm(u_vec) + 1e-12)
+    dist_side_2_m = np.linalg.norm(side_2) / (np.linalg.norm(v_vec) + 1e-12)
+
+    grid_size_0 = max(1, int(dist_side_1_m / meshsize + 0.5))
+    grid_size_1 = max(1, int(dist_side_2_m / meshsize + 0.5))
+
+    adjusted_mesh_size_0 = dist_side_1_m / grid_size_0
+    adjusted_mesh_size_1 = dist_side_2_m / grid_size_1
+
+    return (grid_size_0, grid_size_1), (adjusted_mesh_size_0, adjusted_mesh_size_1)
+
+
+def create_coordinate_mesh(
+    origin: np.ndarray,
+    grid_size: Tuple[int, int],
+    adjusted_meshsize: Tuple[float, float],
+    u_vec: np.ndarray,
+    v_vec: np.ndarray
+) -> np.ndarray:
+    """
+    Create a coordinate mesh based on input parameters.
+    Returns array of shape (coord_dim, ny, nx)
+    """
+    x = np.linspace(0, grid_size[0], grid_size[0])
+    y = np.linspace(0, grid_size[1], grid_size[1])
+    xx, yy = np.meshgrid(x, y)
+    cell_coords = origin[:, np.newaxis, np.newaxis] + \
+                  xx[np.newaxis, :, :] * adjusted_meshsize[0] * u_vec[:, np.newaxis, np.newaxis] + \
+                  yy[np.newaxis, :, :] * adjusted_meshsize[1] * v_vec[:, np.newaxis, np.newaxis]
+    return cell_coords
+
+
+def create_cell_polygon(
+    origin: np.ndarray,
+    i: int,
+    j: int,
+    adjusted_meshsize: Tuple[float, float],
+    u_vec: np.ndarray,
+    v_vec: np.ndarray
+):
+    """
+    Create a polygon representing a grid cell.
+    """
+    bottom_left = origin + i * adjusted_meshsize[0] * u_vec + j * adjusted_meshsize[1] * v_vec
+    bottom_right = origin + (i + 1) * adjusted_meshsize[0] * u_vec + j * adjusted_meshsize[1] * v_vec
+    top_right = origin + (i + 1) * adjusted_meshsize[0] * u_vec + (j + 1) * adjusted_meshsize[1] * v_vec
+    top_left = origin + i * adjusted_meshsize[0] * u_vec + (j + 1) * adjusted_meshsize[1] * v_vec
+    return Polygon([bottom_left, bottom_right, top_right, top_left])
+
+
+
+

voxcity/geoprocessor/raster/export.py

@@ -0,0 +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
+
+

voxcity/geoprocessor/raster/landcover.py

@@ -0,0 +1,156 @@
+import numpy as np
+from typing import List, Tuple, Dict, Any
+from shapely.geometry import Polygon
+from affine import Affine
+import rasterio
+
+from pyproj import Geod
+
+from ...utils.lc import (
+    get_class_priority,
+    create_land_cover_polygons,
+    get_dominant_class,
+)
+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.
+    """
+    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}
+    tree_height_grid = translate_array(np.flipud(land_cover_grid), tree_translation_dict).astype(int)
+    return tree_height_grid
+
+
+def create_land_cover_grid_from_geotiff_polygon(
+    tiff_path: str,
+    mesh_size: float,
+    land_cover_classes: Dict[str, Any],
+    polygon: List[Tuple[float, float]]
+) -> np.ndarray:
+    """
+    Create a land cover grid from a GeoTIFF file within a polygon boundary.
+    """
+    with rasterio.open(tiff_path) as src:
+        img = src.read((1, 2, 3))
+        left, bottom, right, top = src.bounds
+        poly = Polygon(polygon)
+        left_wgs84, bottom_wgs84, right_wgs84, top_wgs84 = poly.bounds
+
+        geod = Geod(ellps="WGS84")
+        _, _, width = geod.inv(left_wgs84, bottom_wgs84, right_wgs84, bottom_wgs84)
+        _, _, height = geod.inv(left_wgs84, bottom_wgs84, left_wgs84, top_wgs84)
+
+        num_cells_x = int(width / mesh_size + 0.5)
+        num_cells_y = int(height / mesh_size + 0.5)
+
+        adjusted_mesh_size_x = (right - left) / num_cells_x
+        adjusted_mesh_size_y = (top - bottom) / num_cells_y
+
+        new_affine = Affine(adjusted_mesh_size_x, 0, left, 0, -adjusted_mesh_size_y, top)
+
+        cols, rows = np.meshgrid(np.arange(num_cells_x), np.arange(num_cells_y))
+        xs, ys = new_affine * (cols, rows)
+        xs_flat, ys_flat = xs.flatten(), ys.flatten()
+
+        row, col = src.index(xs_flat, ys_flat)
+        row, col = np.array(row), np.array(col)
+
+        valid = (row >= 0) & (row < src.height) & (col >= 0) & (col < src.width)
+        row, col = row[valid], col[valid]
+
+        grid = np.full((num_cells_y, num_cells_x), 'No Data', dtype=object)
+        for i, (r, c) in enumerate(zip(row, col)):
+            cell_data = img[:, r, c]
+            dominant_class = get_dominant_class(cell_data, land_cover_classes)
+            grid_row, grid_col = np.unravel_index(i, (num_cells_y, num_cells_x))
+            grid[grid_row, grid_col] = dominant_class
+
+    return np.flipud(grid)
+
+
+def create_land_cover_grid_from_gdf_polygon(
+    gdf,
+    meshsize: float,
+    source: str,
+    rectangle_vertices: List[Tuple[float, float]],
+    default_class: str = 'Developed space'
+) -> np.ndarray:
+    """Create a grid of land cover classes from GeoDataFrame polygon data."""
+    import numpy as np
+    import geopandas as gpd
+    from shapely.geometry import box
+    from shapely.errors import GEOSException
+    from rtree import index
+
+    class_priority = get_class_priority(source)
+
+    from ..utils import (
+        initialize_geod,
+        calculate_distance,
+        normalize_to_one_meter,
+    )
+    from .core import calculate_grid_size, create_cell_polygon
+
+    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)
+
+    origin = np.array(rectangle_vertices[0])
+    grid_size, adjusted_meshsize = calculate_grid_size(side_1, side_2, u_vec, v_vec, meshsize)
+
+    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]
+                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
+    return grid
+
+
+
+