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

voxcity/geoprocessor/heights.py

@@ -0,0 +1,199 @@
+"""
+Height extraction and complement utilities for building footprints.
+"""
+
+from typing import List, Dict
+
+import numpy as np
+import geopandas as gpd
+import pandas as pd
+from shapely.errors import GEOSException
+from shapely.geometry import shape
+from rtree import index
+import rasterio
+from pyproj import Transformer, CRS
+
+
+def extract_building_heights_from_gdf(gdf_0: gpd.GeoDataFrame, gdf_1: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """
+    Extract building heights from one GeoDataFrame and apply them to another based on spatial overlap.
+    """
+    gdf_primary = gdf_0.copy()
+    gdf_ref = gdf_1.copy()
+
+    if 'height' not in gdf_primary.columns:
+        gdf_primary['height'] = 0.0
+    if 'height' not in gdf_ref.columns:
+        gdf_ref['height'] = 0.0
+
+    count_0 = 0
+    count_1 = 0
+    count_2 = 0
+
+    spatial_index = index.Index()
+    for i, geom in enumerate(gdf_ref.geometry):
+        if geom.is_valid:
+            spatial_index.insert(i, geom.bounds)
+
+    for idx_primary, row in gdf_primary.iterrows():
+        if row['height'] <= 0 or pd.isna(row['height']):
+            count_0 += 1
+            geom = row.geometry
+
+            overlapping_height_area = 0
+            overlapping_area = 0
+
+            potential_matches = list(spatial_index.intersection(geom.bounds))
+
+            for ref_idx in potential_matches:
+                if ref_idx >= len(gdf_ref):
+                    continue
+
+                ref_row = gdf_ref.iloc[ref_idx]
+                try:
+                    if geom.intersects(ref_row.geometry):
+                        overlap_area = geom.intersection(ref_row.geometry).area
+                        overlapping_height_area += ref_row['height'] * overlap_area
+                        overlapping_area += overlap_area
+                except GEOSException:
+                    try:
+                        fixed_ref_geom = ref_row.geometry.buffer(0)
+                        if geom.intersects(fixed_ref_geom):
+                            overlap_area = geom.intersection(fixed_ref_geom).area
+                            overlapping_height_area += ref_row['height'] * overlap_area
+                            overlapping_area += overlap_area
+                    except Exception:
+                        print(f"Failed to fix polygon")
+                    continue
+
+            if overlapping_height_area > 0:
+                count_1 += 1
+                new_height = overlapping_height_area / overlapping_area
+                gdf_primary.at[idx_primary, 'height'] = new_height
+            else:
+                count_2 += 1
+                gdf_primary.at[idx_primary, 'height'] = np.nan
+
+    if count_0 > 0:
+        print(f"For {count_1} of these building footprints without height, values from the complementary source were assigned.")
+        print(f"For {count_2} of these building footprints without height, no data exist in complementary data.")
+
+    return gdf_primary
+
+
+def complement_building_heights_from_gdf(gdf_0, gdf_1, primary_id='id', ref_id='id'):
+    """
+    Vectorized approach with GeoPandas to compute weighted heights and add non-intersecting buildings.
+    Returns a single combined GeoDataFrame.
+    """
+    gdf_primary = gdf_0.copy()
+    gdf_ref = gdf_1.copy()
+
+    if 'height' not in gdf_primary.columns:
+        gdf_primary['height'] = 0.0
+    if 'height' not in gdf_ref.columns:
+        gdf_ref['height'] = 0.0
+
+    gdf_primary = gdf_primary.rename(columns={'height': 'height_primary'})
+    gdf_ref = gdf_ref.rename(columns={'height': 'height_ref'})
+
+    intersect_gdf = gpd.overlay(gdf_primary, gdf_ref, how='intersection')
+    intersect_gdf['intersect_area'] = intersect_gdf.area
+    intersect_gdf['height_area'] = intersect_gdf['height_ref'] * intersect_gdf['intersect_area']
+
+    group_cols = {
+        'height_area': 'sum',
+        'intersect_area': 'sum'
+    }
+    grouped = intersect_gdf.groupby(f'{primary_id}_1').agg(group_cols)
+    grouped['weighted_height'] = grouped['height_area'] / grouped['intersect_area']
+
+    gdf_primary = gdf_primary.merge(grouped['weighted_height'],
+                                    left_on=primary_id,
+                                    right_index=True,
+                                    how='left')
+
+    zero_or_nan_mask = (gdf_primary['height_primary'] == 0) | (gdf_primary['height_primary'].isna())
+    valid_weighted_height_mask = zero_or_nan_mask & gdf_primary['weighted_height'].notna()
+    gdf_primary.loc[valid_weighted_height_mask, 'height_primary'] = gdf_primary.loc[valid_weighted_height_mask, 'weighted_height']
+    gdf_primary['height_primary'] = gdf_primary['height_primary'].fillna(np.nan)
+
+    sjoin_gdf = gpd.sjoin(gdf_ref, gdf_primary, how='left', predicate='intersects')
+    non_intersect_mask = sjoin_gdf[f'{primary_id}_right'].isna()
+    non_intersect_ids = sjoin_gdf[non_intersect_mask][f'{ref_id}_left'].unique()
+    gdf_ref_non_intersect = gdf_ref[gdf_ref[ref_id].isin(non_intersect_ids)]
+    gdf_ref_non_intersect = gdf_ref_non_intersect.rename(columns={'height_ref': 'height'})
+
+    gdf_primary = gdf_primary.rename(columns={'height_primary': 'height'})
+    if 'weighted_height' in gdf_primary.columns:
+        gdf_primary.drop(columns='weighted_height', inplace=True)
+
+    final_gdf = pd.concat([gdf_primary, gdf_ref_non_intersect], ignore_index=True)
+
+    count_total = len(gdf_primary)
+    count_0 = len(gdf_primary[zero_or_nan_mask])
+    count_1 = len(gdf_primary[valid_weighted_height_mask])
+    count_2 = count_0 - count_1
+    count_3 = len(gdf_ref_non_intersect)
+    count_4 = count_3
+    height_mask = gdf_ref_non_intersect['height'].notna() & (gdf_ref_non_intersect['height'] > 0)
+    count_5 = len(gdf_ref_non_intersect[height_mask])
+    count_6 = count_4 - count_5
+    final_height_mask = final_gdf['height'].notna() & (final_gdf['height'] > 0)
+    count_7 = len(final_gdf[final_height_mask])
+    count_8 = len(final_gdf)
+
+    if count_0 > 0:
+        print(f"{count_0} of the total {count_total} building footprints from base data source did not have height data.")
+        print(f"For {count_1} of these building footprints without height, values from complementary data were assigned.")
+        print(f"For the rest {count_2}, no data exists in complementary data.")
+        print(f"Footprints of {count_3} buildings were added from the complementary source.")
+        print(f"Of these {count_4} additional building footprints, {count_5} had height data while {count_6} had no height data.")
+        print(f"In total, {count_7} buildings had height data out of {count_8} total building footprints.")
+
+    return final_gdf
+
+
+def extract_building_heights_from_geotiff(geotiff_path, gdf):
+    """
+    Extract building heights from a GeoTIFF raster for building footprints in a GeoDataFrame.
+    """
+    gdf = gdf.copy()
+
+    count_0 = 0
+    count_1 = 0
+    count_2 = 0
+
+    with rasterio.open(geotiff_path) as src:
+        transformer = Transformer.from_crs(CRS.from_epsg(4326), src.crs, always_xy=True)
+
+        mask_condition = (gdf.geometry.geom_type == 'Polygon') & ((gdf.get('height', 0) <= 0) | gdf.get('height').isna())
+        buildings_to_process = gdf[mask_condition]
+        count_0 = len(buildings_to_process)
+
+        for idx, row in buildings_to_process.iterrows():
+            coords = list(row.geometry.exterior.coords)
+            transformed_coords = [transformer.transform(lon, lat) for lon, lat in coords]
+            polygon = shape({"type": "Polygon", "coordinates": [transformed_coords]})
+
+            try:
+                masked_data, _ = rasterio.mask.mask(src, [polygon], crop=True, all_touched=True)
+                heights = masked_data[0][masked_data[0] != src.nodata]
+                if len(heights) > 0:
+                    count_1 += 1
+                    gdf.at[idx, 'height'] = float(np.mean(heights))
+                else:
+                    count_2 += 1
+                    gdf.at[idx, 'height'] = np.nan
+            except ValueError as e:
+                print(f"Error processing building at index {idx}. Error: {str(e)}")
+                gdf.at[idx, 'height'] = None
+
+    if count_0 > 0:
+        print(f"{count_0} of the total {len(gdf)} building footprint from OSM did not have height data.")
+        print(f"For {count_1} of these building footprints without height, values from complementary data were assigned.")
+        print(f"For {count_2} of these building footprints without height, no data exist in complementary data.")
+
+    return gdf
+
+

voxcity/geoprocessor/io.py

@@ -0,0 +1,101 @@
+"""
+I/O helpers for reading/writing vector data (GPKG, gzipped GeoJSON lines) and
+saving FeatureCollections.
+"""
+
+import copy
+import gzip
+import json
+from typing import List
+
+import geopandas as gpd
+
+from .conversion import filter_and_convert_gdf_to_geojson
+
+
+def get_geojson_from_gpkg(gpkg_path, rectangle_vertices):
+    """
+    Read a GeoPackage file and convert it to GeoJSON features within a bounding rectangle.
+    """
+    print(f"Opening GPKG file: {gpkg_path}")
+    gdf = gpd.read_file(gpkg_path)
+    geojson = filter_and_convert_gdf_to_geojson(gdf, rectangle_vertices)
+    return geojson
+
+
+def get_gdf_from_gpkg(gpkg_path, rectangle_vertices):
+    """
+    Read a GeoPackage file and convert it to a GeoDataFrame with consistent CRS.
+
+    Note: rectangle_vertices is currently unused but kept for signature compatibility.
+    """
+    print(f"Opening GPKG file: {gpkg_path}")
+    gdf = gpd.read_file(gpkg_path)
+
+    if gdf.crs is None:
+        gdf.set_crs(epsg=4326, inplace=True)
+    elif gdf.crs != "EPSG:4326":
+        gdf = gdf.to_crs(epsg=4326)
+
+    gdf['id'] = gdf.index
+    return gdf
+
+
+def load_gdf_from_multiple_gz(file_paths):
+    """
+    Load GeoJSON features from multiple gzipped files into a single GeoDataFrame.
+    Each line in each file must be a single GeoJSON Feature.
+    """
+    geojson_objects = []
+
+    for gz_file_path in file_paths:
+        with gzip.open(gz_file_path, 'rt', encoding='utf-8') as file:
+            for line in file:
+                try:
+                    data = json.loads(line)
+                    if 'properties' in data and 'height' in data['properties']:
+                        if data['properties']['height'] is None:
+                            data['properties']['height'] = 0
+                    else:
+                        if 'properties' not in data:
+                            data['properties'] = {}
+                        data['properties']['height'] = 0
+                    geojson_objects.append(data)
+                except json.JSONDecodeError as e:
+                    print(f"Skipping line in {gz_file_path} due to JSONDecodeError: {e}")
+
+    gdf = gpd.GeoDataFrame.from_features(geojson_objects)
+    gdf.set_crs(epsg=4326, inplace=True)
+    return gdf
+
+
+def swap_coordinates(features):
+    """
+    Swap coordinate ordering in GeoJSON features from (lat, lon) to (lon, lat).
+    Modifies the input features in-place.
+    """
+    for feature in features:
+        if feature['geometry']['type'] == 'Polygon':
+            new_coords = [[[lon, lat] for lat, lon in polygon] for polygon in feature['geometry']['coordinates']]
+            feature['geometry']['coordinates'] = new_coords
+        elif feature['geometry']['type'] == 'MultiPolygon':
+            new_coords = [[[[lon, lat] for lat, lon in polygon] for polygon in multipolygon] for multipolygon in feature['geometry']['coordinates']]
+            feature['geometry']['coordinates'] = new_coords
+
+
+def save_geojson(features, save_path):
+    """
+    Save GeoJSON features to a file with coordinate swapping and pretty printing.
+    """
+    geojson_features = copy.deepcopy(features)
+    swap_coordinates(geojson_features)
+
+    geojson = {
+        "type": "FeatureCollection",
+        "features": geojson_features
+    }
+
+    with open(save_path, 'w') as f:
+        json.dump(geojson, f, indent=2)
+
+

voxcity/geoprocessor/merge_utils.py

@@ -0,0 +1,91 @@
+"""
+Utilities to merge GeoDataFrames while resolving ID conflicts.
+"""
+
+import pandas as pd
+
+
+def _merge_gdfs_with_missing_columns(gdf_1, gdf_2):
+    """
+    Helper to merge two GeoDataFrames while handling missing columns by filling with None.
+    """
+    columns_1 = set(gdf_1.columns)
+    columns_2 = set(gdf_2.columns)
+
+    only_in_1 = columns_1 - columns_2
+    only_in_2 = columns_2 - columns_1
+
+    for col in only_in_2:
+        gdf_1[col] = None
+    for col in only_in_1:
+        gdf_2[col] = None
+
+    all_columns = sorted(list(columns_1.union(columns_2)))
+    gdf_1 = gdf_1[all_columns]
+    gdf_2 = gdf_2[all_columns]
+
+    merged_gdf = pd.concat([gdf_1, gdf_2], ignore_index=True)
+    return merged_gdf
+
+
+def merge_gdfs_with_id_conflict_resolution(gdf_1, gdf_2, id_columns=['id', 'building_id']):
+    """
+    Merge two GeoDataFrames while resolving ID conflicts by modifying IDs in the second GeoDataFrame.
+    """
+    gdf_primary = gdf_1.copy()
+    gdf_secondary = gdf_2.copy()
+
+    missing_columns = []
+    for col in id_columns:
+        if col not in gdf_primary.columns:
+            missing_columns.append(f"'{col}' missing from gdf_1")
+        if col not in gdf_secondary.columns:
+            missing_columns.append(f"'{col}' missing from gdf_2")
+
+    if missing_columns:
+        print(f"Warning: Missing ID columns: {', '.join(missing_columns)}")
+        id_columns = [col for col in id_columns if col in gdf_primary.columns and col in gdf_secondary.columns]
+
+    if not id_columns:
+        print("Warning: No valid ID columns found. Merging without ID conflict resolution.")
+        merged_gdf = _merge_gdfs_with_missing_columns(gdf_primary, gdf_secondary)
+        return merged_gdf
+
+    max_ids = {}
+    for col in id_columns:
+        if gdf_primary[col].dtype in ['int64', 'int32', 'float64', 'float32']:
+            max_ids[col] = gdf_primary[col].max()
+        else:
+            max_ids[col] = len(gdf_primary)
+
+    next_ids = {col: max_ids[col] + 1 for col in id_columns}
+    modified_buildings = 0
+
+    for idx, row in gdf_secondary.iterrows():
+        needs_new_ids = False
+        for col in id_columns:
+            current_id = row[col]
+            if current_id in gdf_primary[col].values:
+                needs_new_ids = True
+                break
+        if needs_new_ids:
+            modified_buildings += 1
+            for col in id_columns:
+                new_id = next_ids[col]
+                gdf_secondary.at[idx, col] = new_id
+                next_ids[col] += 1
+
+    merged_gdf = _merge_gdfs_with_missing_columns(gdf_primary, gdf_secondary)
+
+    total_buildings = len(merged_gdf)
+    primary_buildings = len(gdf_primary)
+    secondary_buildings = len(gdf_secondary)
+
+    print(f"Merged {primary_buildings} buildings from primary dataset with {secondary_buildings} buildings from secondary dataset.")
+    print(f"Total buildings in merged dataset: {total_buildings}")
+    if modified_buildings > 0:
+        print(f"Modified IDs for {modified_buildings} buildings in secondary dataset to resolve conflicts.")
+
+    return merged_gdf
+
+

voxcity/geoprocessor/mesh.py

@@ -1,9 +1,19 @@
+"""Mesh generation utilities for voxel and 2D grid visualization.
+
+Orientation contract:
+- Mesh builders expect 2D inputs (e.g., simulation grids, building_id grids)
+  to be provided in north_up orientation (row 0 = north/top) with columns
+  increasing eastward (col 0 = west/left). Any internal flips are
+  implementation details to match mesh coordinates.
+"""
+
 import numpy as np
 import os
 import trimesh
 import matplotlib.colors as mcolors
 import matplotlib.cm as cm
 import matplotlib.pyplot as plt
+from ..utils.orientation import ensure_orientation, ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP
 
 def create_voxel_mesh(voxel_array, class_id, meshsize=1.0, building_id_grid=None, mesh_type=None):
     """
@@ -38,9 +48,9 @@ def create_voxel_mesh(voxel_array, class_id, meshsize=1.0, building_id_grid=None
     mesh_type : str, optional
         Type of mesh to create, controlling which faces are included:
         - None (default): create faces at boundaries between different classes
-        - 'building_solar': only create faces at boundaries between buildings (-3)
-                          and either void (0) or trees (-2). Useful for solar analysis
-                          where only exposed surfaces matter.
+        - 'building_solar' or 'open_air': only create faces at boundaries between
+                          buildings (-3) and either void (0) or trees (-2). Useful for
+                          solar analysis where only exposed surfaces matter.
 
     Returns
     -------
@@ -81,7 +91,11 @@ def create_voxel_mesh(voxel_array, class_id, meshsize=1.0, building_id_grid=None
     voxel_coords = np.argwhere(voxel_array == class_id)
 
     if building_id_grid is not None:
-        building_id_grid_flipud = np.flipud(building_id_grid)
+        building_id_grid_flipud = ensure_orientation(
+            building_id_grid,
+            ORIENTATION_NORTH_UP,
+            ORIENTATION_SOUTH_UP,
+        )
 
     if len(voxel_coords) == 0:
         return None
@@ -142,8 +156,8 @@ def create_voxel_mesh(voxel_array, class_id, meshsize=1.0, building_id_grid=None
                 else:
                     adj_value = voxel_array[adj_coord]
                     
-                    if mesh_type == 'open_air' and class_id == -3:
-                        # For building_solar, only create faces at boundaries with void (0) or trees (-2)
+                    if class_id == -3 and mesh_type in ('building_solar', 'open_air'):
+                        # Only create faces at boundaries with void (0) or trees (-2)
                         is_boundary = (adj_value == 0 or adj_value == -2)
                     else:
                         # Default behavior - create faces at any class change
@@ -278,9 +292,9 @@ def create_sim_surface_mesh(sim_grid, dem_grid,
     - The mesh is positioned at dem_grid + z_offset to float above the terrain
     - Face colors are interpolated from the colormap based on sim_grid values
     """
-    # Flip arrays vertically
-    sim_grid_flipped = np.flipud(sim_grid)
-    dem_grid_flipped = np.flipud(dem_grid)
+    # Flip arrays vertically using orientation helper
+    sim_grid_flipped = ensure_orientation(sim_grid, ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP)
+    dem_grid_flipped = ensure_orientation(dem_grid, ORIENTATION_NORTH_UP, ORIENTATION_SOUTH_UP)
 
     # Identify valid (non-NaN) values
     valid_mask = ~np.isnan(sim_grid_flipped)
@@ -318,7 +332,9 @@ def create_sim_surface_mesh(sim_grid, dem_grid,
             if np.isnan(val):
                 continue
 
-            z_base = meshsize * int(dem_grid_flipped[x, y] / meshsize + 1.5) + z_offset            
+            # Match voxel ground rounding: int(dem/mesh + 0.5) + 1 == int(dem/mesh + 1.5)
+            # Then lower the plane by one mesh layer as requested
+            z_base = meshsize * int(dem_grid_flipped[x, y] / meshsize + 1.5) + z_offset - meshsize            
 
             # 4 corners in (x,y)*meshsize
             v0 = [ x      * meshsize,  y      * meshsize, z_base ]

voxcity/geoprocessor/network.py

@@ -15,7 +15,7 @@ import pyproj
 from pyproj import Transformer
 from joblib import Parallel, delayed
 
-from .grid import grid_to_geodataframe
+from .raster import grid_to_geodataframe
 
 def vectorized_edge_values(G, polygons_gdf, value_col='value'):
     """
@@ -99,8 +99,9 @@ def vectorized_edge_values(G, polygons_gdf, value_col='value'):
 
 def get_network_values(
     grid,
-    rectangle_vertices,
-    meshsize,
+    rectangle_vertices=None,
+    meshsize=None,
+    voxcity=None,
     value_name='value',
     **kwargs
 ):
@@ -115,10 +116,13 @@ def get_network_values(
     ----------
     grid : array-like or geopandas.GeoDataFrame
         Either a grid array of values or a pre-built GeoDataFrame with polygons and values.
-    rectangle_vertices : list of tuples
+    rectangle_vertices : list of tuples, optional
         List of (lon, lat) coordinates defining the bounding rectangle in EPSG:4326.
-    meshsize : float
-        Size of each grid cell (used only if grid is array-like).
+        Optional if `voxcity` is provided.
+    meshsize : float, optional
+        Size of each grid cell (used only if grid is array-like). Optional if `voxcity` is provided.
+    voxcity : VoxCity, optional
+        VoxCity object from which `rectangle_vertices` and `meshsize` will be derived if not supplied.
     value_name : str, default='value'
         Name to use for the edge attribute storing computed values.
     **kwargs : dict
@@ -162,6 +166,31 @@ def get_network_values(
     }
     settings = {**defaults, **kwargs}
 
+    # Derive geometry parameters from VoxCity if supplied (inline to avoid extra helper)
+    if voxcity is not None:
+        derived_rv = None
+        derived_meshsize = None
+        # Try extras['rectangle_vertices'] when available
+        if hasattr(voxcity, "extras") and isinstance(voxcity.extras, dict):
+            derived_rv = voxcity.extras.get("rectangle_vertices")
+        # Pull meshsize and bounds from voxels.meta
+        voxels = getattr(voxcity, "voxels", None)
+        meta = getattr(voxels, "meta", None) if voxels is not None else None
+        if meta is not None:
+            derived_meshsize = getattr(meta, "meshsize", None)
+            if derived_rv is None:
+                bounds = getattr(meta, "bounds", None)
+                if bounds is not None:
+                    west, south, east, north = bounds
+                    derived_rv = [(west, south), (west, north), (east, north), (east, south)]
+        if rectangle_vertices is None:
+            rectangle_vertices = derived_rv
+        if meshsize is None:
+            meshsize = derived_meshsize
+
+    if rectangle_vertices is None:
+        raise ValueError("rectangle_vertices must be provided, either directly or via `voxcity`.")
+
     # Build polygons GDF if needed
     polygons_gdf = (grid if isinstance(grid, gpd.GeoDataFrame) 
                     else grid_to_geodataframe(grid, rectangle_vertices, meshsize))

voxcity/geoprocessor/overlap.py

@@ -0,0 +1,84 @@
+"""
+Utilities for processing overlaps between building footprints.
+"""
+
+from rtree import index
+from shapely.errors import GEOSException
+
+
+def process_building_footprints_by_overlap(filtered_gdf, overlap_threshold=0.5):
+    """
+    Merge overlapping buildings based on area overlap ratio, assigning the ID of the larger building
+    to smaller overlapping ones.
+    """
+    gdf = filtered_gdf.copy()
+
+    if 'id' not in gdf.columns:
+        gdf['id'] = gdf.index
+
+    if gdf.crs is None:
+        gdf_projected = gdf.copy()
+    else:
+        gdf_projected = gdf.to_crs("EPSG:3857")
+
+    gdf_projected['area'] = gdf_projected.geometry.area
+    gdf_projected = gdf_projected.sort_values(by='area', ascending=False)
+    gdf_projected = gdf_projected.reset_index(drop=True)
+
+    spatial_idx = index.Index()
+    for i, geom in enumerate(gdf_projected.geometry):
+        if geom.is_valid:
+            spatial_idx.insert(i, geom.bounds)
+        else:
+            fixed_geom = geom.buffer(0)
+            if fixed_geom.is_valid:
+                spatial_idx.insert(i, fixed_geom.bounds)
+
+    id_mapping = {}
+
+    for i in range(1, len(gdf_projected)):
+        current_poly = gdf_projected.iloc[i].geometry
+        current_area = gdf_projected.iloc[i].area
+        current_id = gdf_projected.iloc[i]['id']
+
+        if current_id in id_mapping:
+            continue
+
+        if not current_poly.is_valid:
+            current_poly = current_poly.buffer(0)
+            if not current_poly.is_valid:
+                continue
+
+        potential_overlaps = [j for j in spatial_idx.intersection(current_poly.bounds) if j < i]
+
+        for j in potential_overlaps:
+            larger_poly = gdf_projected.iloc[j].geometry
+            larger_id = gdf_projected.iloc[j]['id']
+
+            if larger_id in id_mapping:
+                larger_id = id_mapping[larger_id]
+
+            if not larger_poly.is_valid:
+                larger_poly = larger_poly.buffer(0)
+                if not larger_poly.is_valid:
+                    continue
+
+            try:
+                if current_poly.intersects(larger_poly):
+                    overlap = current_poly.intersection(larger_poly)
+                    overlap_ratio = overlap.area / current_area
+                    if overlap_ratio > overlap_threshold:
+                        id_mapping[current_id] = larger_id
+                        gdf_projected.at[i, 'id'] = larger_id
+                        break
+            except (GEOSException, ValueError):
+                continue
+
+    for i, row in filtered_gdf.iterrows():
+        orig_id = row.get('id')
+        if orig_id in id_mapping:
+            filtered_gdf.at[i, 'id'] = id_mapping[orig_id]
+
+    return filtered_gdf
+
+