Boundary Topology Validation for Automated Catchment Delineation

Q: Is make_valid safe to apply to all watershed boundary defects?

make_valid fixes structural invalidity (self-intersections, degenerate rings) but can split a single polygon into a MultiPolygon. Always explode MultiPolygon outputs and inspect fragment areas — fragments below your sliver threshold should be merged with the largest adjacent neighbour, not silently dropped.

Boundary topology validation is the quality gate that separates raw delineation output from production-ready spatial data. When catchment polygons contain geometric defects — overlaps, slivers, self-intersections, or ring orientation errors — downstream processes such as flow accumulation routing, mass-balance calculations, and regulatory reporting fail silently or produce biased results. This page details a repeatable, Python-driven workflow for diagnosing and repairing these defects as part of the broader Watershed Delineation & Catchment Synchronization pipeline, where geometric precision directly determines whether nested hydrologic networks and cross-basin data harmonization can proceed reliably. Sibling topics — outlet point mapping and basin partitioning strategies — both depend on topologically sound input polygons before their own algorithms can execute correctly.

Prerequisites & Environment Setup

Topology operations require planar geometry and a precise GEOS backend. Confirm your stack before running any validation code.

Python environment:

bash

# conda
conda create -n topo-val python=3.11
conda activate topo-val
conda install -c conda-forge geopandas=0.14 shapely=2.0 pyproj=3.6 fiona=1.9

# or pip
pip install "geopandas>=0.14" "shapely>=2.0" "pyproj>=3.6" "fiona>=1.9"

Verify GEOS version (must be 3.11+):

python

import shapely
print(shapely.geos_version_string)  # e.g. "3.12.1"

Input data specifications:

Requirement	Detail
Format	GeoPackage (`.gpkg`), Shapefile, or PostGIS layer
Geometry type	Polygon or MultiPolygon
CRS	Any projected CRS (UTM, state plane, national grid) — not geographic WGS84
nodata / nulls	Null geometries must be identified and dropped before validation
Recommended source	Output from automated DEM-based delineation (pysheds, WhiteboxTools, or RichDEM)

Why projected CRS is mandatory: Topology operations assume Cartesian distance. Snapping tolerances specified in degrees produce nonsensical thresholds (0.01° ≈ 1.1 km at the equator). Always reproject to a locally appropriate CRS — for North American studies this is typically UTM NAD83 — before any validation step. See coordinate reference system alignment for projection selection guidance.

Algorithm Mechanics: What Topology Validation Actually Checks

OGC Simple Features geometry validity for polygons requires:

Closed rings — exterior and interior rings must start and end at the same coordinate.
Non-self-intersecting rings — ring edges may touch at isolated points but must not cross.
Correct ring orientation — exterior rings counter-clockwise, holes clockwise (PostGIS convention) or the reverse (ISO/SQL convention); mismatches cause area sign errors.
Non-degenerate geometry — zero-area polygons (collapsed to lines or points) must not appear.
No overlapping polygons — a tiled catchment mosaic must partition space without shared area.

Floating-point arithmetic in raster-to-vector conversion introduces violations of rules 1–4. The raster grid’s finite cell size introduces violations of rule 5 whenever two adjacent catchment cells are converted independently and their shared boundary pixels are rounded in different directions. The result is an irregular fringe of micro-overlaps and micro-gaps running along every catchment divide.

Defect taxonomy and hydrological impact:

Defect	Root Cause	Hydrological Impact
Self-intersecting ring	Float rounding at bowtie vertices	Polygon area calculation returns NaN or negative values
Unclosed ring	Incomplete rasterization at boundary	Spatial joins fail silently — polygon excluded from results
Micro-sliver (< 1 m²)	Sub-pixel raster stepping	Zonal statistics count sliver pixels, inflating contributing area
Boundary overlap	Independent rounding of shared edge	Double-counting in flow accumulation; mass-balance closure fails
Ring orientation error	Mixed CW/CCW from external tools	Hole/exterior confusion in rendering and area computation
Zero-area polygon	Collapsed triangle after simplification	Division-by-zero in unit-area normalization routines

Step-by-Step Validation Workflow

The diagram below shows the five-stage pipeline. Each stage emits a log entry and a defect count; the pipeline halts and raises if post-repair validity falls below a configurable threshold.

Step 1: Ingest and Standardize

Load catchment polygons, enforce a single projected CRS, and eliminate null or empty geometries. Standardizing the CRS here prevents cascading projection mismatches in later spatial joins and overlay operations.

python

import logging
import geopandas as gpd
from pyproj import CRS

log = logging.getLogger(__name__)

def load_and_standardize(
    input_path: str,
    target_epsg: int = 32610,
) -> gpd.GeoDataFrame:
    """Load catchment polygons and enforce a projected CRS.

    Args:
        input_path: Path to GeoPackage, Shapefile, or PostGIS URI.
        target_epsg: EPSG code of the target projected CRS (default UTM zone 10N).

    Returns:
        GeoDataFrame with uniform projected CRS and no null/empty geometries.
    """
    gdf = gpd.read_file(input_path)
    original_count = len(gdf)

    if gdf.crs is None:
        raise ValueError(
            f"Input '{input_path}' has no CRS. "
            "Assign one with gdf.set_crs() before standardizing."
        )

    # Drop null / empty geometries before any spatial operation
    mask_valid = gdf.geometry.notna() & ~gdf.geometry.is_empty
    gdf = gdf[mask_valid].copy()
    dropped = original_count - len(gdf)
    if dropped:
        log.warning("Dropped %d null/empty geometries from input.", dropped)

    gdf = gdf.to_crs(CRS.from_epsg(target_epsg))
    log.info(
        "Loaded %d catchment polygons → reprojected to EPSG:%d.",
        len(gdf), target_epsg,
    )
    return gdf

Step 2: Initial Validity Scanning

Identify every polygon that violates OGC Simple Features rules. Shapely 2.0’s is_valid property wraps GEOS’s GEOSisValid, which reports self-intersections, degenerate rings, and orientation errors. Log the reason string for each invalid geometry — it names the exact defect (e.g., "Self-intersection", "Ring Self-intersection", "Too Few Points In Geometry Component").

python

from shapely.validation import explain_validity

def scan_validity(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
    """Flag invalid geometries and attach a human-readable reason.

    Returns the GeoDataFrame with 'is_valid' and 'validity_reason' columns.
    """
    gdf = gdf.copy()
    gdf["is_valid"] = gdf.geometry.is_valid
    gdf["validity_reason"] = gdf.geometry.apply(
        lambda g: explain_validity(g) if not g.is_valid else "valid"
    )

    invalid = gdf[~gdf["is_valid"]]
    if len(invalid):
        log.warning(
            "%d / %d polygons failed initial validity scan. "
            "Top reason: %s",
            len(invalid),
            len(gdf),
            invalid["validity_reason"].value_counts().idxmax(),
        )
    else:
        log.info("All %d polygons pass initial validity scan.", len(gdf))
    return gdf

Step 3: Geometry Repair with Precision Grids

Apply precision snapping first (removes floating-point drift), then make_valid (repairs any structural invalidity that remains). The precision grid tolerance should be calibrated to the DEM source resolution — use 0.01 m for 1 m LiDAR, 0.1 m for 10 m DEM sources. When make_valid splits a Polygon into a MultiPolygon, explode and inspect fragments rather than silently dropping them.

python

from shapely import set_precision, make_valid
from shapely.geometry import MultiPolygon

def repair_geometries(
    gdf: gpd.GeoDataFrame,
    precision: float = 0.01,
) -> gpd.GeoDataFrame:
    """Snap to a precision grid then apply structural repairs.

    Args:
        gdf: GeoDataFrame with 'is_valid' column from scan_validity().
        precision: Grid spacing in CRS units (metres). Controls snapping aggressiveness.

    Returns:
        GeoDataFrame with repaired geometries and a 'was_repaired' flag column.
    """
    gdf = gdf.copy()
    repaired_count = 0

    def _repair(geom):
        nonlocal repaired_count
        g = set_precision(geom, precision, mode="pointwise")
        if not g.is_valid:
            g = make_valid(g)
            repaired_count += 1
        return g

    gdf["geometry"] = gdf.geometry.apply(_repair)
    gdf["was_repaired"] = ~gdf["geometry"].is_valid  # flag any still-invalid

    log.info(
        "Precision snap + make_valid applied. "
        "%d geometries required structural repair. "
        "%d remain invalid after repair.",
        repaired_count,
        int(gdf["was_repaired"].sum()),
    )
    return gdf

Step 4: Sliver Filtering and Overlap Resolution

Micro-slivers originate from sub-pixel rounding along catchment divides. Filter by absolute area rather than a percentage of basin size — a fixed threshold tied to DEM resolution (e.g., 4 × cell area) is more reproducible across datasets.

Boundary overlaps arise when adjacent catchments independently round their shared edge in opposite directions. Resolve them with a precision inward-buffer followed by an outward-buffer of equal magnitude (a morphological open operation), which closes gaps and collapses micro-overlaps without merging distinct catchments.

python

import numpy as np

def filter_slivers(
    gdf: gpd.GeoDataFrame,
    min_area_m2: float = 4.0,
) -> gpd.GeoDataFrame:
    """Remove polygons below a minimum hydrological significance area.

    Args:
        gdf: Repaired GeoDataFrame.
        min_area_m2: Minimum polygon area in square metres. Default (4 m²) matches
                     one 2×2 m LiDAR cell. Increase for coarser DEM sources.

    Returns:
        GeoDataFrame with slivers removed and sliver count logged.
    """
    gdf = gdf.copy()
    gdf["area_m2"] = gdf.geometry.area
    slivers = gdf[gdf["area_m2"] < min_area_m2]

    if len(slivers):
        log.warning(
            "Removing %d sliver polygons below %.2f m² threshold "
            "(max sliver area: %.4f m²).",
            len(slivers),
            min_area_m2,
            slivers["area_m2"].max(),
        )

    return gdf[gdf["area_m2"] >= min_area_m2].reset_index(drop=True)


def resolve_boundary_overlaps(
    gdf: gpd.GeoDataFrame,
    tolerance: float = 0.05,
) -> gpd.GeoDataFrame:
    """Close micro-gaps and collapse micro-overlaps via morphological buffering.

    Args:
        gdf: Sliver-free GeoDataFrame.
        tolerance: Buffer distance in CRS units. Must be less than 1/10th of
                   the minimum expected channel width. Default 0.05 m.

    Returns:
        GeoDataFrame with adjacency-cleaned geometries.
    """
    gdf = gdf.copy()

    # Detect whether pairwise overlaps exist before modifying geometries
    unioned = gdf.geometry.unary_union
    expected_area = unioned.area
    actual_area = gdf.geometry.area.sum()
    overlap_area = actual_area - expected_area

    if overlap_area > tolerance ** 2:
        log.info(
            "Detected %.4f m² of boundary overlap across dataset. "
            "Applying inward/outward buffer (tolerance=%.4f m) to resolve.",
            overlap_area,
            tolerance,
        )
        gdf["geometry"] = (
            gdf.geometry
            .buffer(-tolerance, cap_style=2, join_style=2)
            .buffer(tolerance,  cap_style=2, join_style=2)
        )
    else:
        log.info("No significant boundary overlaps detected (%.6f m²).", overlap_area)

    return gdf

Step 5: Adjacency Enforcement and Contiguity Audit

Contiguous catchments in a delineation mosaic must partition the study area without gaps. Verify this by comparing the sum of individual polygon areas against the area of their union. A ratio above 1.001 indicates residual overlaps; a ratio below 0.999 indicates gaps. Both conditions warrant re-inspection before export.

python

def audit_contiguity(gdf: gpd.GeoDataFrame, tolerance_pct: float = 0.1) -> dict:
    """Compare summed polygon area against union area to detect gaps and overlaps.

    Args:
        gdf: Final GeoDataFrame after repair and sliver filtering.
        tolerance_pct: Maximum allowed deviation (%) between sum and union area.

    Returns:
        Dict with 'sum_area', 'union_area', 'overlap_pct', 'gap_pct', 'pass'.
    """
    sum_area   = float(gdf.geometry.area.sum())
    union_area = float(gdf.geometry.unary_union.area)

    overlap_pct = max(0.0, (sum_area - union_area) / union_area * 100)
    gap_pct     = max(0.0, (union_area - sum_area) / union_area * 100)
    passed      = overlap_pct <= tolerance_pct and gap_pct <= tolerance_pct

    log.info(
        "Contiguity audit — sum area: %.2f m², union area: %.2f m², "
        "overlap: %.4f%%, gap: %.4f%%, result: %s",
        sum_area, union_area, overlap_pct, gap_pct,
        "PASS" if passed else "FAIL",
    )
    return {
        "sum_area": sum_area,
        "union_area": union_area,
        "overlap_pct": overlap_pct,
        "gap_pct": gap_pct,
        "pass": passed,
    }

Step 6: Post-Validation Export

Re-run validity scans, confirm the contiguity audit passes, and export to GeoPackage. Production pipelines should embed the repair log as a sidecar JSON file alongside the GeoPackage so downstream users can trace every modification.

python

import json, pathlib

def export_validated(
    gdf: gpd.GeoDataFrame,
    output_path: str,
    repair_log: dict | None = None,
) -> None:
    """Export validated catchment polygons and an optional repair log.

    Raises RuntimeError if any invalid geometries remain.
    """
    invalid_count = int((~gdf.geometry.is_valid).sum())
    if invalid_count:
        raise RuntimeError(
            f"Export aborted: {invalid_count} geometries remain invalid after repair. "
            "Inspect 'validity_reason' column and re-run repair step."
        )

    gdf.to_file(output_path, driver="GPKG")
    log.info("Exported %d validated catchments to '%s'.", len(gdf), output_path)

    if repair_log:
        log_path = pathlib.Path(output_path).with_suffix(".repair_log.json")
        log_path.write_text(json.dumps(repair_log, indent=2))
        log.info("Repair log written to '%s'.", log_path)

Production-Ready Code

The function below chains all six steps into a single callable, suitable for integration into Airflow tasks, Prefect flows, or CI pre-commit hooks.

python

import logging
import geopandas as gpd

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)-8s %(name)s: %(message)s",
)
log = logging.getLogger("topology_validation")


def validate_and_repair_catchments(
    input_path: str,
    output_path: str,
    target_epsg: int = 32610,
    precision: float = 0.01,
    min_area_m2: float = 4.0,
    overlap_tolerance: float = 0.05,
    contiguity_tolerance_pct: float = 0.1,
) -> dict:
    """End-to-end boundary topology validation and repair pipeline.

    Args:
        input_path: Source catchment polygons (GeoPackage, Shapefile, PostGIS URI).
        output_path: Destination GeoPackage for validated output.
        target_epsg: EPSG code of the projected CRS to use for all operations.
        precision: Precision grid cell size in CRS units for coordinate snapping.
        min_area_m2: Minimum polygon area in m²; smaller polygons are treated as slivers.
        overlap_tolerance: Buffer magnitude in m for overlap/gap resolution.
        contiguity_tolerance_pct: Max allowed gap/overlap percentage in the audit.

    Returns:
        Dict summarising counts, area audit results, and repair log.
    """
    from shapely.validation import explain_validity
    from shapely import set_precision, make_valid
    from pyproj import CRS
    import json, pathlib

    # ── Stage 1: Ingest ───────────────────────────────────────────────────
    gdf = gpd.read_file(input_path)
    if gdf.crs is None:
        raise ValueError(f"Input '{input_path}' has no CRS.")
    original_count = len(gdf)
    gdf = gdf[gdf.geometry.notna() & ~gdf.geometry.is_empty].copy()
    gdf = gdf.to_crs(CRS.from_epsg(target_epsg))
    log.info("Stage 1 — loaded %d polygons (dropped %d null/empty).",
             len(gdf), original_count - len(gdf))

    # ── Stage 2: Scan ─────────────────────────────────────────────────────
    gdf["is_valid"] = gdf.geometry.is_valid
    gdf["validity_reason"] = gdf.geometry.apply(
        lambda g: explain_validity(g) if not g.is_valid else "valid"
    )
    invalid_before = int((~gdf["is_valid"]).sum())
    log.info("Stage 2 — %d / %d invalid before repair.", invalid_before, len(gdf))

    # ── Stage 3: Repair ───────────────────────────────────────────────────
    repaired_count = 0

    def _repair(geom):
        nonlocal repaired_count
        g = set_precision(geom, precision, mode="pointwise")
        if not g.is_valid:
            g = make_valid(g)
            repaired_count += 1
        return g

    gdf["geometry"] = gdf.geometry.apply(_repair)
    log.info("Stage 3 — repaired %d geometries via precision snap + make_valid.",
             repaired_count)

    # ── Stage 4: Slivers and overlaps ────────────────────────────────────
    gdf["area_m2"] = gdf.geometry.area
    before_sliver = len(gdf)
    gdf = gdf[gdf["area_m2"] >= min_area_m2].reset_index(drop=True)
    slivers_removed = before_sliver - len(gdf)
    log.info("Stage 4 — removed %d sliver polygons (< %.2f m²).",
             slivers_removed, min_area_m2)

    unioned_area = float(gdf.geometry.unary_union.area)
    sum_area     = float(gdf.geometry.area.sum())
    if sum_area - unioned_area > overlap_tolerance ** 2:
        gdf["geometry"] = (
            gdf.geometry
            .buffer(-overlap_tolerance, cap_style=2, join_style=2)
            .buffer( overlap_tolerance, cap_style=2, join_style=2)
        )
        log.info("Stage 4 — applied inward/outward buffer to resolve overlaps.")

    # ── Stage 5: Contiguity audit ─────────────────────────────────────────
    audit = {
        "sum_area":    float(gdf.geometry.area.sum()),
        "union_area":  float(gdf.geometry.unary_union.area),
    }
    audit["overlap_pct"] = max(0.0, (audit["sum_area"] - audit["union_area"])
                               / audit["union_area"] * 100)
    audit["gap_pct"]     = max(0.0, (audit["union_area"] - audit["sum_area"])
                               / audit["union_area"] * 100)
    audit["pass"] = (audit["overlap_pct"] <= contiguity_tolerance_pct
                     and audit["gap_pct"]  <= contiguity_tolerance_pct)
    log.info("Stage 5 — contiguity audit: overlap=%.4f%%, gap=%.4f%%, %s.",
             audit["overlap_pct"], audit["gap_pct"],
             "PASS" if audit["pass"] else "FAIL")

    # ── Stage 6: Export ───────────────────────────────────────────────────
    invalid_after = int((~gdf.geometry.is_valid).sum())
    if invalid_after:
        raise RuntimeError(
            f"{invalid_after} geometries remain invalid after repair. "
            "Inspect 'validity_reason' and lower the precision grid."
        )
    gdf.to_file(output_path, driver="GPKG")

    repair_log = {
        "input": input_path,
        "output": output_path,
        "target_epsg": target_epsg,
        "original_count": original_count,
        "output_count": len(gdf),
        "invalid_before": invalid_before,
        "repaired": repaired_count,
        "slivers_removed": slivers_removed,
        "contiguity_audit": audit,
    }
    pathlib.Path(output_path).with_suffix(".repair_log.json").write_text(
        json.dumps(repair_log, indent=2)
    )
    log.info("Stage 6 — exported %d validated catchments to '%s'.", len(gdf), output_path)
    return repair_log

Minimal usage:

python

result = validate_and_repair_catchments(
    input_path="delineated_catchments.gpkg",
    output_path="catchments_validated.gpkg",
    target_epsg=32610,   # UTM zone 10N — adjust to your study area
    precision=0.01,      # 1 cm grid for 1 m LiDAR; use 0.1 for 10 m DEM
    min_area_m2=4.0,     # discard polygons < 1 DEM cell equivalent
)
print(result["contiguity_audit"])

Validation Protocol

After export, verify that the validated dataset is hydrologically and geometrically sound before passing it to flow routing or mass-balance routines.

Geometry checks:

gdf.geometry.is_valid.all() must return True.
gdf.geometry.geom_type.unique() must contain only "Polygon" — no "MultiPolygon", "LineString", or "GeometryCollection" artefacts from make_valid.
(gdf.geometry.area == 0).any() must return False.

Area budget check:

python

import numpy as np

sum_area   = gdf.geometry.area.sum()
union_area = gdf.geometry.unary_union.area
ratio      = sum_area / union_area

assert np.isclose(ratio, 1.0, atol=0.001), (
    f"Area ratio {ratio:.6f} deviates from 1.0 by more than 0.1%; "
    "residual overlaps or gaps detected."
)

Cross-check against DEM-derived basin area: Compute the DEM watershed area using a raster mask (e.g., numpy.sum(flow_acc >= threshold) * cell_area) and compare against the sum of polygon areas. Deviations above 2% typically indicate CRS mismatch, rounding error accumulation from DEM pit filling, or incorrect sliver thresholds.

Overlay against authoritative hydrography: Dissolve your validated catchments to their common outlet and compare the dissolved boundary against the National Hydrography Dataset reference basin. Planimetric deviation greater than one DEM cell width suggests upstream delineation errors rather than topology defects.

Common Failure Modes & Optimization

Floating-point drift after repeated CRS transforms. Every to_crs() call accumulates rounding error. Apply set_precision once, immediately after the final projection, and never re-project validated outputs. Store the canonical projected CRS in your project configuration so all pipeline stages agree.

make_valid producing unexpected MultiPolygon fragments. When a self-intersecting polygon is healed, GEOS may split it into two or more non-overlapping parts. If the smaller fragment is a genuine sliver it will be caught by filter_slivers; if it is large, it signals a more fundamental delineation error upstream — likely an incorrect outlet point placement rather than a topology defect. Cross-check with outlet point mapping and snapping before applying further repairs.

Inward buffer collapsing narrow catchments. Long, thin headwater catchments (width < 2 × overlap_tolerance) will collapse to empty geometries when buffered inward. Guard against this:

python

# Compute minimum bounding rectangle width before applying buffer
gdf["min_width"] = gdf.geometry.apply(
    lambda g: min(g.minimum_rotated_rectangle.exterior.coords[i]
                  for i in range(4)
                  if ... )  # omitted for brevity — use shapely.affinity bounds
)
narrow = gdf[gdf["min_width"] < 2 * overlap_tolerance]
if len(narrow):
    log.warning("%d narrow catchments may collapse under inward buffer.", len(narrow))

In practice, set overlap_tolerance to no more than 1/20th of the narrowest expected headwater channel width.

Ring orientation errors surviving make_valid. Some software (ESRI, SAGA GIS) exports polygons with clockwise exterior rings, which violates ISO/OGC convention and causes incorrect contains and within predicates. Fix explicitly:

python

from shapely.geometry.polygon import orient
gdf["geometry"] = gdf.geometry.apply(lambda g: orient(g, sign=1.0))

Memory exhaustion on large mosaics (> 50,000 polygons). The unary_union call in the contiguity audit loads all geometries into GEOS in a single pass. For large datasets, compute the union in spatial tiles using a spatial index, or use a chunked approach with shapely.ops.split.

Silent CRS mismatch with DEM layers. If the DEM used for area verification is in a different projected CRS than the validated polygons, the area comparison will be wrong without raising an error. Always confirm gdf.crs == raster_crs before the cross-check step, or reproject the raster mask to match. See coordinate reference system alignment for a complete CRS reconciliation workflow.

When to Use This vs. Alternatives

Use this Python workflow when:

Automated delineation pipelines produce large batches of polygons (> 100 catchments) where manual inspection is not feasible.
Multi-source integration combines catchments from different DEM resolutions or software packages, increasing the likelihood of boundary mismatches.
Regulatory submission requires OGC-compliant geometry and a documented repair audit trail.
Nested basin networks are being built with nested catchment delineation, where topology defects in outer basins propagate as area accounting errors into inner sub-basins.

Consider PostGIS topology (postgis_topology extension) instead when:

Your catchments are stored in PostgreSQL and you need persistent topological rules enforced at the database level.
You require shared-edge editing semantics where modifying one catchment boundary automatically updates all adjacent catchments.

Consider GRASS GIS v.clean instead when:

You are already working in a GRASS environment and need advanced snap-and-merge options (e.g., break, rmdupl, prune) that operate on vectors natively without conversion to Shapely.

For flow-routing decisions that determine whether boundary corrections are even necessary at a given precision, see D8 flow direction implementation and spatial resolution trade-offs in DEM preprocessing.

Frequently Asked Questions

Why do automated delineation pipelines produce invalid watershed boundaries?

Raster-to-vector conversion introduces floating-point precision artifacts, pixel stair-stepping, and algorithmic simplification errors. These manifest as self-intersecting rings, micro-slivers, and boundary overlaps that violate OGC Simple Features rules.

What precision grid value should I use for watershed boundary snapping?

For 1 m LiDAR-derived DEMs, a grid precision of 0.001 m is conservative. For 10 m or 30 m DEM sources, 0.01 m is typically sufficient. Never use a tolerance larger than 1/10th of the minimum channel width in your study area — larger values risk merging distinct catchments.

How do boundary overlaps affect flow accumulation calculations?

Overlapping catchment polygons double-count contributing area in zonal statistics, causing artificial inflation of upstream drainage area. This biases runoff volume calculations, rating curve extrapolations, and any mass-balance closure check.

Is make_valid safe to apply to all watershed boundary defects?

make_valid fixes structural invalidity (self-intersections, degenerate rings) but can split a single polygon into a MultiPolygon. Always explode MultiPolygon outputs and inspect fragment areas — fragments below your sliver threshold should be merged with the largest adjacent neighbour, not silently dropped.

Watershed Delineation & Catchment Synchronization — parent workflow covering the full delineation-to-export pipeline
Outlet Point Mapping & Validation — snap outlet points to stream networks before delineating the boundaries this page validates
Basin Partitioning Strategies — subdivide large basins into sub-units, which must each pass topology validation independently
Nested Catchment Delineation — topology errors in outer catchments propagate as area accounting errors in nested hierarchies
DEM Pit Filling Algorithms — upstream conditioning step whose output quality directly affects the density of topology defects
Coordinate Reference System Alignment — CRS reconciliation workflow required before any topology operation

Related topics