How to Define Topology Rules for Cadastral Maps

To define topology rules for cadastral maps, establish a formal validation schema that enforces spatial integrity across parcel boundaries, adjacency relationships, and attribute consistency. This requires selecting standardized spatial predicates, mapping them to your cadastral data model, and implementing them in an automated validation pipeline using spatial SQL or GIS scripting frameworks. The process begins with a clean, single-CRS dataset, followed by explicit tolerance configuration, rule execution, exception logging, and iterative correction.

Core Cadastral Topology Rules

Cadastral systems demand strict spatial consistency because legal boundaries, taxation, and land administration depend on geometrically sound data. The foundational topology rules typically include:

• Must Not Overlap: Parcel interiors cannot intersect. Overlaps indicate duplicate survey records, digitizing errors, or unmerged subdivisions.
• Must Not Have Gaps: Adjacent parcels must share boundaries completely. Unassigned voids suggest missing submissions or vertex drift.
• Boundary Coincidence: Shared edges must align within a defined tolerance (typically 0.001 m–0.01 m for modern surveys).
• Attribute-Spatial Consistency: Parcel identifiers (e.g., parcel_id, tax_lot) must be unique, non-null, and directly reference the spatial feature.
• Node/Vertex Alignment: Boundary endpoints must snap to survey control points, easements, or right-of-way centerlines without generating sliver geometries.

These constraints align with the broader framework of Understanding OGC Topology Rules, where spatial relationships are formalized using standardized predicates rather than proprietary heuristics. Cadastral validation specifically requires planar enforcement, as geographic coordinates (lat/lon) introduce angular distortion that breaks adjacency logic.

Step-by-Step Implementation Workflow

1. Standardize Input Data: Ensure all layers share the same projected CRS (e.g., EPSG:32633, UTM, or a local state plane). Convert legacy CAD, SHP, or DWG files to GeoPackage or PostGIS.
2. Define Tolerance & Precision: Cadastral surveys use sub-centimeter positional accuracy. Explicitly set snap_tolerance (for vertex alignment) and validation_tolerance (for rule evaluation). Never rely on default floating-point comparisons.
3. Configure Rule Engine: Map cadastral requirements to executable spatial predicates. Most modern platforms support rule definitions via JSON, XML, or SQL constraints. Reference Core Spatial QC Fundamentals & Standards for baseline validation architectures.
4. Run Validation & Capture Exceptions: Execute the rules, log violations with geometry references, and generate a remediation queue. Tag each violation by severity (critical vs. warning).
5. Automate & Integrate: Embed validation into CI/CD pipelines for spatial data. Trigger alerts when new submissions fail compliance checks, and block publication until topology is resolved.

SQL-Based Validation Pattern (PostGIS)

The following pattern demonstrates how to enforce cadastral rules using spatial SQL. It checks for interior overlaps and boundary gaps, then logs exceptions to a dedicated audit table. Production environments should wrap these queries in stored procedures or trigger them via ETL tools.

-- 1. Create audit table for violations
CREATE TABLE IF NOT EXISTS cadastral_violations (
    violation_id SERIAL PRIMARY KEY,
    rule_name TEXT NOT NULL,
    parcel_id_a TEXT,
    parcel_id_b TEXT,
    violation_geom GEOMETRY(Polygon, 32633),
    severity TEXT DEFAULT 'critical',
    logged_at TIMESTAMP DEFAULT NOW()
);

-- 2. Detect overlaps (interior intersection)
INSERT INTO cadastral_violations (rule_name, parcel_id_a, parcel_id_b, violation_geom)
SELECT 'MUST_NOT_OVERLAP', a.parcel_id, b.parcel_id, ST_Intersection(a.geom, b.geom)
FROM parcels a
JOIN parcels b ON ST_Intersects(a.geom, b.geom) 
  AND ST_Area(ST_Intersection(a.geom, b.geom)) > 0.0001
WHERE a.parcel_id < b.parcel_id;

-- 3. Detect gaps within a defined cadastral block
WITH block_union AS (
    SELECT ST_Union(geom) AS merged_geom FROM parcels WHERE block_id = 'BLK_04'
),
block_extent AS (
    SELECT ST_Envelope(merged_geom) AS extent FROM block_union
)
INSERT INTO cadastral_violations (rule_name, violation_geom, severity)
SELECT 'MUST_NOT_HAVE_GAPS', ST_Difference(e.extent, u.merged_geom), 'warning'
FROM block_extent e, block_union u
WHERE ST_Area(ST_Difference(e.extent, u.merged_geom)) > 0.01;

Tolerance Configuration & Planar Enforcement

Tolerance is the single most critical parameter in cadastral topology. A mismatch between snap_tolerance and validation_tolerance produces false positives or masks real errors. Follow these guidelines:

• Snap Tolerance: Use 0.001 m–0.005 m for high-precision surveys. Apply ST_Snap before validation to eliminate micro-drift from digitizing or coordinate conversion.
• Validation Tolerance: Set slightly higher than snap tolerance (e.g., 0.01 m) to account for legitimate survey variance and measurement uncertainty.
• Planar Enforcement: Always project data to a local metric CRS before running topology checks. The OGC Simple Features Specification explicitly defines planar geometry operations as the baseline for spatial predicates. Geographic coordinates (WGS84) should only be used for visualization, not validation.

Rule Mapping & Predicate Selection

Translating legal cadastral requirements into executable logic requires a clear predicate mapping table. Avoid ad-hoc spatial functions; instead, anchor your rules to deterministic operations:

Exception Handling & CI/CD Integration

Automated validation must be non-destructive and auditable. Instead of modifying source geometries in place, route violations to a staging environment. Implement a three-tier severity model:

• Critical: Overlaps, missing IDs, or topology breaks that prevent legal registration. Block publication.
• Warning: Minor gaps (< tolerance), attribute mismatches, or dangling nodes. Flag for manual review.
• Info: Metadata inconsistencies or non-critical formatting issues. Log for reporting.

Integrate validation into your data pipeline using tools like ogr2ogr, PostGIS, or Python libraries (geopandas, shapely). For enterprise deployments, leverage the PostGIS Topology extension to maintain persistent topological networks that automatically update when edges are modified. Schedule nightly validation jobs, attach results to pull requests, and require topology clearance before merging cadastral updates into production.

Compliance & Continuous Improvement

Cadastral topology rules are not static. As surveying technology shifts from total stations to LiDAR and UAV photogrammetry, positional accuracy improves, requiring tighter tolerance thresholds. Maintain a versioned rule catalog, document tolerance changes, and audit validation logs quarterly. Align your schema with ISO 19107 (Spatial Schema) and national cadastre standards to ensure interoperability across jurisdictions. Regularly review exception trends to identify systemic digitizing errors, outdated survey methods, or pipeline configuration drift. By treating topology validation as a continuous compliance checkpoint rather than a one-time cleanup task, platform teams can guarantee legally defensible, spatially sound cadastral datasets.