# Setting Geometry Repair Thresholds

ST_MakeValid will fix almost any invalid geometry, and that is exactly why it needs a policy. Applied without thresholds it silently converts polygons into collections, absorbs upstream defects that should have been reported, and turns a data-quality problem into a slow accumulation of geometry nobody recognises. This guide sets the boundary: which defects are repaired automatically, which are repaired only within a bounded change, and which are rejected outright and sent back to the producer. It refines the blocking gate specified in Spatial Data Quality and Validation Standards within Geospatial Data Mesh Fundamentals, and its runtime counterpart is Topology Validation with Dagster Asset Checks.

# Prerequisites

The retention requirement is load-bearing. A repair applied in place destroys the evidence of what the producer actually sent, which makes both the producer conversation and any later audit impossible.

# Step-by-Step Implementation

# 1. Classify the defect before deciding anything

ST_IsValidReason names the specific defect, and the defect — not the fact of invalidity — determines whether repair is safe.

-- classify.sql — group invalid features by their actual defect.
-- Parameters: :product (text), :partition (text)
SELECT
    -- The reason string carries a location; strip it so defects group.
    regexp_replace(ST_IsValidReason(geom), '\[.*\]$', '') AS defect,
    ST_GeometryType(geom)                                  AS geom_type,
    count(*)                                               AS features
FROM product_features
WHERE product = :'product'
  AND partition_key = :'partition'
  AND NOT ST_IsValid(geom)
GROUP BY 1, 2
ORDER BY features DESC;

Verify the defects cluster. Invalid geometry almost always shares one upstream cause, and a long tail of distinct reasons usually means the source itself is corrupt rather than merely imprecise:

psql --csv -f classify.sql -v product="$PRODUCT_ID" -v partition="$PARTITION"
# One or two defect classes covering 95%+ of features is the normal shape.

# 2. Compute the repair delta without committing it

The question that decides whether a repair is acceptable is how much the geometry moved. A repair that changes area by a fraction of a percent is a precision fix; one that changes it by ten percent is a different polygon.

-- repair_delta.sql — measure what a repair would do, without applying it.
-- Parameters: :product (text), :partition (text)
WITH candidate AS (
    SELECT feature_id,
           geom                                    AS original,
           ST_MakeValid(geom, 'structure')         AS repaired
    FROM product_features
    WHERE product = :'product' AND partition_key = :'partition'
      AND NOT ST_IsValid(geom)
)
SELECT
    feature_id,
    ST_GeometryType(original)                        AS type_before,
    ST_GeometryType(repaired)                        AS type_after,
    ST_Area(original::geography)                     AS area_before_m2,
    ST_Area(repaired::geography)                     AS area_after_m2,
    CASE WHEN ST_Area(original::geography) > 0
         THEN abs(ST_Area(repaired::geography) - ST_Area(original::geography))
              / ST_Area(original::geography)
         ELSE NULL END                               AS area_delta_ratio,
    -- Hausdorff distance bounds how far any point moved.
    ST_HausdorffDistance(original, repaired)         AS hausdorff_deg
FROM candidate;

Verify that the type is preserved for the features you intend to repair automatically:

psql --csv -f repair_delta.sql -v product="$PRODUCT_ID" -v partition="$PARTITION" \
  | awk -F, 'NR>1 && $2 != $3 {n++} END {print (n+0) " feature(s) would change geometry type"}'

# 3. Apply the threshold policy

Three outcomes, decided per feature from the measured delta rather than per layer from a preference.

# repair_policy.py — accept, quarantine, or reject each candidate repair.
import csv
import sys

# Per-layer thresholds, governed by the data steward, not the pipeline author.
POLICY = {
    "max_area_delta_ratio": 0.001,     # 0.1% — a precision fix, not a reshape
    "max_hausdorff_deg": 0.0000135,    # ~1.5 m at the equator
    "allow_type_change": False,        # a polygon must stay a polygon
}


def decide(row: dict) -> str:
    """accept: repair is a precision fix and is applied.
    quarantine: repair is plausible but material — a human decides.
    reject: repair would change what the feature is; the producer is told."""
    if row["type_before"] != row["type_after"] and not POLICY["allow_type_change"]:
        return "reject"
    delta = row.get("area_delta_ratio") or ""
    hausdorff = float(row["hausdorff_deg"] or 0)
    if delta == "":                                  # a line or point: use distance alone
        return "accept" if hausdorff <= POLICY["max_hausdorff_deg"] else "quarantine"
    if float(delta) <= POLICY["max_area_delta_ratio"] \
            and hausdorff <= POLICY["max_hausdorff_deg"]:
        return "accept"
    return "quarantine"


if __name__ == "__main__":
    counts = {"accept": 0, "quarantine": 0, "reject": 0}
    accepted = []
    for row in csv.DictReader(open(sys.argv[1], newline="")):
        verdict = decide(row)
        counts[verdict] += 1
        if verdict == "accept":
            accepted.append(row["feature_id"])
    print(counts)
    # Rejections block the publish; quarantines do not, but they are not repaired either.
    if counts["reject"]:
        print(f"BLOCKED: {counts['reject']} feature(s) would change geometry type",
              file=sys.stderr)
        raise SystemExit(1)
    open("accepted_ids.txt", "w").write("\n".join(accepted))

Verify the split before applying anything. A partition where most repairs quarantine is telling you the threshold is wrong or the source has degraded:

psql --csv -f repair_delta.sql -v product="$PRODUCT_ID" -v partition="$PARTITION" > /tmp/delta.csv
python3 repair_policy.py /tmp/delta.csv

# 4. Apply accepted repairs, preserving the original

-- apply_repair.sql — write the repaired geometry to a new column, never over the original.
-- Parameters: :product (text), :partition (text)
UPDATE product_features f
SET geom_repaired = ST_MakeValid(f.geom, 'structure'),
    repair_applied_at = now(),
    repair_method = 'structure'
FROM (SELECT unnest(string_to_array(pg_read_file('accepted_ids.txt'), E'\n')) AS id) a
WHERE f.feature_id = a.id
  AND f.product = :'product'
  AND f.partition_key = :'partition';

Verify every accepted feature is now valid and the originals are intact:

psql -c "SELECT count(*) FILTER (WHERE NOT ST_IsValid(geom_repaired)) AS still_invalid,
                count(*) FILTER (WHERE geom IS NULL)                  AS originals_lost
         FROM product_features
         WHERE product = '$PRODUCT_ID' AND partition_key = '$PARTITION'
           AND repair_applied_at IS NOT NULL;"
# expected: 0, 0

# Configuration Reference

The structure method matters. PostGIS’s default linework repair preserves every input vertex and will happily return a GeometryCollection from a Polygon; structure prioritises producing a valid geometry of the same class, which is what a contract-bound product needs.

# Common Failure Modes & Fixes

Repairs succeed but downstream consumers break. Root cause: ST_MakeValid returned a GeometryCollection where the contract promises Polygon. Fix: set allow_type_change: false and use the structure method; treat a type change as a rejection that goes back to the producer.

Area delta is enormous for a small visual change. Root cause: a bow-tie self-intersection, where the repair removes one lobe entirely. The visual difference is small and the semantic difference is total. Fix: this is exactly what the ratio threshold is for — quarantine it and look at the feature.

Every repair quarantines after a source upgrade. Root cause: the producer changed export precision, so geometry that used to be marginally invalid is now substantially so. Fix: this is a producer conversation, not a threshold adjustment. Widening the threshold to make the alert stop is how a systematic upstream defect becomes permanent.

Zero-area slivers pass validity and clog the layer. Root cause: ST_IsValid returns true for a degenerate polygon; it is valid and useless. Fix: this is a separate advisory check on area, not a repair concern. Do not extend the repair policy to delete features — deletion is a data decision, not a validity one.

The repair is not idempotent across re-runs. Root cause: repairing geom_repaired in place, so each run repairs the previous repair. Fix: always derive the repair from the original column, as the query above does; the original is the only stable input.

# FAQ

# Related

• Spatial Data Quality and Validation Standards — the parent topic and the blocking gate this refines
• Topology Validation with Dagster Asset Checks — the same gate expressed as an orchestrated asset check
• Detecting Attribute Drift in Published Layers — the non-geometric drift signal