Fixing Self-Intersecting Polygons in GeoPandas

Fixing self-intersecting polygons in GeoPandas requires validating geometries and applying topology-aware repairs before executing spatial operations. In modern environments (Shapely 2.0+ / GEOS 3.10+), the vectorized gdf.geometry.make_valid() method is the standard. For legacy stacks, gdf.geometry.buffer(0) remains the fallback. Self-intersections violate the OGC Simple Features specification and will trigger silent data corruption or TopologyException crashes during joins, overlays, and rasterization.

Why Self-Intersections Break Spatial Pipelines

Self-intersecting polygons occur when a boundary crosses itself, producing bowtie shapes, overlapping lobes, or degenerate rings. While these geometries often pass basic format checks during ingestion, they fail at downstream computational steps because GEOS (the C++ engine powering Shapely and GeoPandas) strictly enforces planar graph topology:

• Exterior rings must not cross themselves.
• Interior rings (holes) must lie entirely within the exterior ring.
• Rings must not touch at single points unless explicitly allowed by the topology model.

When these rules break, core operations like gpd.overlay(), gpd.sjoin(), or gdf.to_file() with shapefile/GeoJSON drivers will either raise exceptions, drop features, or silently produce invalid output. Automated ETL pipelines amplify this risk: a single invalid geometry in a batch of 100,000 features can halt processing or skew spatial aggregations.

Version Compatibility & Repair Strategies

Critical CRS Note: Always validate in a projected coordinate system (e.g., local UTM or EPSG:3857). Geographic coordinates (WGS84/EPSG:4326) use angular units that distort planar topology, masking micro-intersections or creating false positives near the poles and date line.

Production-Ready Repair Function

The following function integrates validation, targeted repair, and audit logging. It avoids blanket operations that degrade performance on large datasets and safely handles version differences.

import geopandas as gpd
import shapely
import logging
from packaging import version

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def repair_self_intersections(
    gdf: gpd.GeoDataFrame, 
    target_crs: str = None,
    preserve_original_crs: bool = True
) -> gpd.GeoDataFrame:
    """
    Identifies and repairs self-intersecting polygons in a GeoDataFrame.
    Uses make_valid() for Shapely 2.0+, falls back to buffer(0) for legacy.
    """
    if gdf.empty:
        logger.info("Empty GeoDataFrame provided. Returning as-is.")
        return gdf

    original_crs = gdf.crs
    if target_crs:
        gdf = gdf.to_crs(target_crs)

    # Vectorized validity mask
    invalid_mask = ~gdf.geometry.is_valid
    invalid_count = invalid_mask.sum()

    if invalid_count == 0:
        logger.info("No self-intersecting polygons detected.")
        return gdf if not preserve_original_crs else gdf.to_crs(original_crs)

    logger.info(f"Repairing {invalid_count} invalid geometries...")
    
    # Version-aware repair
    shapely_ver = version.parse(shapely.__version__)
    if shapely_ver >= version.parse("2.0.0"):
        gdf.loc[invalid_mask, "geometry"] = gdf.loc[invalid_mask, "geometry"].make_valid()
    else:
        logger.warning("Shapely <2.0 detected. Falling back to buffer(0) repair.")
        gdf.loc[invalid_mask, "geometry"] = gdf.loc[invalid_mask, "geometry"].buffer(0)

    # Post-repair validation check
    remaining_invalid = (~gdf.geometry.is_valid).sum()
    if remaining_invalid > 0:
        logger.warning(f"{remaining_invalid} geometries remain invalid after repair. "
                       "Consider manual inspection or topology simplification.")

    return gdf.to_crs(original_crs) if preserve_original_crs else gdf

Key Implementation Notes

• Targeted Repair: The function isolates invalid rows using a boolean mask, avoiding expensive operations on valid geometries.
• CRS Handling: Projects to a planar system for repair, then restores the original CRS to maintain pipeline compatibility.
• Fallback Logic: Uses packaging.version to safely route to buffer(0) when running on older infrastructure.
• Audit Trail: Logs counts before/after repair, enabling data quality dashboards and alerting.

Integrating Validation into Automated Workflows

Geometry validation should run early in your data ingestion pipeline, immediately after format parsing and before spatial indexing or joins. For teams scaling this into broader Automated Vector & Raster Cleaning Workflows, validation acts as a gatekeeper: invalid features are quarantined, logged, and routed to a review queue rather than crashing batch jobs.

When working with complex administrative boundaries, land parcels, or environmental zoning layers, self-intersections often originate from digitization errors, coordinate rounding during format conversion, or poorly merged adjacent polygons. Running make_valid() alongside ring-orientation normalization (shapely.geometry.polygon.orient) ensures consistent clockwise/counter-clockwise winding rules. See our guide on Geometry Repair with Shapely & GeoPandas for advanced topology fixes, including sliver removal and gap closure.

For reference, the official Shapely validation documentation details the underlying GEOS algorithms, while GeoPandas geometry methods cover vectorized execution patterns. Always pair automated repair with spatial quality metrics (e.g., area delta, vertex count changes) to catch silent degradation before models or maps consume the data.