AG_QGIS/Plugin_SN_Verfahrensgebiet
3
1
Fork 1
Code Issues 10 Pull Requests Actions Releases 25 Wiki Activity
Files
b9c03627ae89e6ad45d5b45bfe21b5f5bf5c59fb
Plugin_SN_Verfahrensgebiet/functions/knickpunkt_pruefung.py
T

468 lines
15 KiB
Python
Raw Normal View History

Verfahrensgebietsprüfung auf Knickpunkte umgestellt
2026-05-05 19:46:08 +02:00
"""sn_verfahrensgebiet/functions/knickpunkt_pruefung.py – Knickpunktbasierte BROR-Prüfung.
Vergleicht die Knickpunkte (Stützpunkte) des BauRaumOderBodenordnungsrecht-
Polygons mit den Punktorten der geladenen ``AX_PunktortTA``-Objekte und
identifiziert:
- **Identische Punkte** (grün): An einem BROR-Knickpunkt liegt ein PunktortTA.
- **Fehlende PunktortTA** (rot): Ein BROR-Knickpunkt hat keinen zugehörigen PunktortTA.
- **Fehlende Knickpunkte** (orange): Ein PunktortTA liegt nahe des BROR-Umrings
auf einer Flurstücksgrenze, hat aber keinen entsprechenden Knickpunkt im BROR.
**Algorithmus:**
1. BROR-Polygon-Stützpunkte (Knickpunkte) extrahieren.
2. Spatial-Index auf PunktortTA aufbauen.
3. Für jeden Knickpunkt nächsten PunktortTA im Radius von
:data:`KOORDINATEN_TOLERANZ_M` suchen → grün oder rot.
Gematchte PunktortTA-Feature-IDs merken.
4. Gepufferter BROR-Umring + Flurstück-Vertex-Set ermitteln.
5. Nicht-gematchte PunktortTA nahe BROR-Umring, die auf einer Flurstücksgrenze
liegen → orange.
**Rückgabe:** ``(result_layer, identisch, kein_pta, fehlender_knick)``
"""
from __future__ import annotations
from typing import Dict, List, Optional, Set, Tuple
from sn_basis.functions.qgiscore_wrapper import (
QgsVectorLayer,
QgsFeature,
QgsField,
QgsGeometry,
)
from sn_basis.functions.qt_wrapper import QVariant
# ---------------------------------------------------------------------------
# Konstanten
# ---------------------------------------------------------------------------
#: Koordinatentoleranz für die Knickpunkt ↔ PunktortTA-Übereinstimmung (m).
KOORDINATEN_TOLERANZ_M: float = 0.01
#: Puffer um den BROR-Umring für die Suche nach fehlenden Knickpunkten (m).
BOUNDARY_PUFFER_M: float = 0.5
#: Rundungsgenauigkeit für Vertex-Koordinaten im Flurstück-Set (Dezimalstellen).
_VERTEX_ROUND = 3
ERGEBNIS_LAYER_NAME = "Knickpunktprüfung"
FELD_TYP = "typ"
WERT_IDENTISCH = "identisch"
WERT_KEIN_PTA = "kein_pta"
WERT_FEHLENDER_KNICK = "fehlender_knick"
# ---------------------------------------------------------------------------
# Interne Hilfsfunktionen
# ---------------------------------------------------------------------------
def _extrahiere_knickpunkte(bror_layer) -> List[object]:
"""Extrahiert alle Stützpunkte (Knickpunkte) des BROR-Polygons.
Doppelte Start/End-Punkte eines Rings werden dedupliziert. Gibt eine
flache Liste von ``QgsPointXY``-Objekten zurück.
Parameters
----------
bror_layer :
BauRaumOderBodenordnungsrecht-Polygon-Layer.
Returns
-------
List[QgsPointXY]
Alle eindeutigen Stützpunkte; leer bei Fehler.
"""
try:
from qgis.core import QgsPointXY # type: ignore[import]
bror_feats = [
f for f in bror_layer.getFeatures()
if f.geometry() and not f.geometry().isEmpty()
]
if not bror_feats:
return []
union_geom = QgsGeometry.unaryUnion([f.geometry() for f in bror_feats])
if union_geom is None or union_geom.isEmpty():
return []
punkte: List[object] = []
seen: Set[Tuple[float, float]] = set()
def _add_ring(vertices):
# Letzter Punkt = erster Punkt (Ring geschlossen) → überspringen
ring_pts = list(vertices)
n = len(ring_pts)
if n >= 2:
# Prüfen ob letzter Punkt identisch mit erstem
last = n - 1
if (
abs(ring_pts[last].x() - ring_pts[0].x()) < 1e-9
and abs(ring_pts[last].y() - ring_pts[0].y()) < 1e-9
):
ring_pts = ring_pts[:-1]
for pt in ring_pts:
key = (round(pt.x(), _VERTEX_ROUND), round(pt.y(), _VERTEX_ROUND))
if key not in seen:
seen.add(key)
punkte.append(pt)
geom_type = union_geom.wkbType()
# Polygon oder MultiPolygon
if union_geom.isMultipart():
for poly in union_geom.asMultiPolygon():
for ring in poly:
_add_ring([QgsPointXY(x, y) for x, y in ring])
else:
for ring in union_geom.asPolygon():
_add_ring([QgsPointXY(x, y) for x, y in ring])
return punkte
except Exception:
return []
def _erstelle_ergebnis_layer(crs_authid: str) -> object:
"""Erzeugt den leeren Punkt-Ergebnislayer mit Feld ``typ``.
Parameters
----------
crs_authid :
CRS-Kennung, z.B. ``"EPSG:25833"``.
Returns
-------
QgsVectorLayer
Leerer Memory-Layer vom Typ Point.
"""
layer = QgsVectorLayer(
f"Point?crs={crs_authid}", ERGEBNIS_LAYER_NAME, "memory"
)
pr = layer.dataProvider()
pr.addAttributes([QgsField(FELD_TYP, QVariant.String)])
layer.updateFields()
return layer
def _setze_kategorien_symbologie(layer) -> None:
"""Wendet Kategoriesymbologie an: grün/rot/orange Punkte.
- ``identisch`` → grün
- ``kein_pta`` → rot
- ``fehlender_knick`` → orange
Wird bei fehlendem QGIS-Kontext still ignoriert.
"""
try:
from qgis.core import ( # type: ignore[import]
QgsCategorizedSymbolRenderer,
QgsRendererCategory,
QgsMarkerSymbol,
)
def _marker(color: str, size: str = "2") -> object:
return QgsMarkerSymbol.createSimple(
{"color": color, "size": size, "outline_style": "no"}
)
categories = [
QgsRendererCategory(
WERT_IDENTISCH,
_marker("0,180,0,255"),
"identisch (Knickpunkt mit PunktortTA)",
),
QgsRendererCategory(
WERT_KEIN_PTA,
_marker("220,0,0,255"),
"kein PunktortTA an Knickpunkt",
),
QgsRendererCategory(
WERT_FEHLENDER_KNICK,
_marker("255,128,0,255"),
"fehlender Knickpunkt (PunktortTA ohne BROR-Knickpunkt)",
),
]
renderer = QgsCategorizedSymbolRenderer(FELD_TYP, categories)
layer.setRenderer(renderer)
except Exception:
pass # Kein QGIS-Kontext (Tests) → Standarddarstellung behalten
def _baue_pta_index(punktort_layer) -> Tuple[object, Dict[int, object]]:
"""Baut einen QgsSpatialIndex und eine ID→Geometrie-Map für PunktortTA.
Parameters
----------
punktort_layer :
Geladener ``AX_PunktortTA``-Layer.
Returns
-------
Tuple[QgsSpatialIndex, Dict[int, QgsGeometry]]
Index und Feature-ID-zu-Geometrie-Dict.
"""
from qgis.core import QgsSpatialIndex # type: ignore[import]
index = QgsSpatialIndex()
geom_map: Dict[int, object] = {}
for feat in punktort_layer.getFeatures():
geom = feat.geometry()
if geom and not geom.isEmpty():
index.insertFeature(feat)
geom_map[feat.id()] = geom
return index, geom_map
def _baue_flst_vertex_set(
flst_layer,
bror_buffer_geom,
) -> Set[Tuple[float, float]]:
"""Erstellt ein Set gerundeter (x, y)-Koordinaten aller Flurstück-Vertices
innerhalb des gepufferten BROR-Umrings.
Parameters
----------
flst_layer :
Flurstücke-Layer.
bror_buffer_geom :
Gepufferter BROR-Umring (Polygon-Geometrie).
Returns
-------
Set[Tuple[float, float]]
Gerundete Vertex-Koordinaten.
"""
vertex_set: Set[Tuple[float, float]] = set()
if flst_layer is None:
return vertex_set
try:
for feat in flst_layer.getFeatures():
geom = feat.geometry()
if geom is None or geom.isEmpty():
continue
try:
# Nur Flurstücke berücksichtigen, die den Puffer berühren
if not geom.intersects(bror_buffer_geom):
continue
boundary = geom.convertToType(1) # 1 = Line
if boundary is None or boundary.isEmpty():
continue
if boundary.isMultipart():
parts = boundary.asMultiPolyline()
else:
parts = [boundary.asPolyline()]
for line in parts:
for pt in line:
vertex_set.add(
(round(pt.x(), _VERTEX_ROUND), round(pt.y(), _VERTEX_ROUND))
)
except Exception:
continue
except Exception:
pass
return vertex_set
# ---------------------------------------------------------------------------
# Öffentliche API
# ---------------------------------------------------------------------------
def knickpunkt_pruefung(
bror_layer,
punktort_layer,
flst_layer,
progress=None,
knickpunkte: Optional[List] = None,
) -> Tuple[Optional[object], int, int, int]:
"""Knickpunktbasierte BROR-Prüfung.
Vergleicht BROR-Knickpunkte mit ``AX_PunktortTA``-Objekten und ermittelt
fehlende Knickpunkte anhand von Flurstücksgrenzen.
Parameters
----------
bror_layer :
BauRaumOderBodenordnungsrecht-Polygon-Layer.
punktort_layer :
Geladener ``AX_PunktortTA``-Layer (Ergebnis aus ``grenzpunkt_alkis``).
flst_layer :
Flurstücke-Layer für die Orange-Prüfung. Kann ``None`` sein.
progress :
Optionaler ``ProgressDialog`` für Fortschrittsanzeige.
knickpunkte :
Vorberechnete Knickpunktliste (optional). Wenn ``None``, werden die
Knickpunkte aus ``bror_layer`` extrahiert.
Returns
-------
Tuple[Optional[QgsVectorLayer], int, int, int]
``(result_layer, identisch_count, kein_pta_count, fehlender_knick_count)``
- ``result_layer``: Punkt-Layer mit grünen/roten/orangen Punkten,
oder ``None`` bei Abbruch oder fehlgeschlagener Verarbeitung.
- ``identisch_count``: Knickpunkte mit passendem PunktortTA (grün).
- ``kein_pta_count``: Knickpunkte ohne passenden PunktortTA (rot).
- ``fehlender_knick_count``: PunktortTA ohne BROR-Knickpunkt (orange).
"""
def _canceled() -> bool:
return progress is not None and progress.is_canceled()
def _schritt(label: str, wert: int) -> None:
if progress is not None:
progress.set_label(label)
progress.set_value(wert)
# ------------------------------------------------------------------
# Schritt 0: Knickpunkte ermitteln
# ------------------------------------------------------------------
_schritt("Knickpunktprüfung: Knickpunkte extrahieren …", 0)
if knickpunkte is None:
knickpunkte = _extrahiere_knickpunkte(bror_layer)
if not knickpunkte:
return None, 0, 0, 0
n = len(knickpunkte)
crs_authid = bror_layer.crs().authid()
if _canceled():
return None, 0, 0, 0
# ------------------------------------------------------------------
# Schritt 1: Spatial-Index für PunktortTA aufbauen
# ------------------------------------------------------------------
_schritt("Knickpunktprüfung: PunktortTA-Index aufbauen …", 1)
if punktort_layer is None:
return None, 0, 0, 0
try:
pta_index, geom_map = _baue_pta_index(punktort_layer)
except Exception:
return None, 0, 0, 0
if _canceled():
return None, 0, 0, 0
# ------------------------------------------------------------------
# Schritte 2…n+1: Jeden Knickpunkt mit PunktortTA vergleichen
# ------------------------------------------------------------------
try:
from qgis.core import QgsRectangle # type: ignore[import]
except ImportError:
return None, 0, 0, 0
ergebnis_layer = _erstelle_ergebnis_layer(crs_authid)
pr = ergebnis_layer.dataProvider()
feats_to_add: List[object] = []
identisch_count = 0
kein_pta_count = 0
matched_pta_ids: Set[int] = set()
for i, knick_pt in enumerate(knickpunkte):
if _canceled():
return None, 0, 0, 0
_schritt(f"Knickpunktprüfung: Knickpunkt {i + 1}/{n} prüfen …", i + 2)
x, y = knick_pt.x(), knick_pt.y()
t = KOORDINATEN_TOLERANZ_M
suchbox = QgsRectangle(x - t, y - t, x + t, y + t)
kandidaten = pta_index.intersects(suchbox)
gefunden = False
for fid in kandidaten:
pta_geom = geom_map.get(fid)
if pta_geom is None:
continue
pta_pt = pta_geom.asPoint()
dist = ((pta_pt.x() - x) ** 2 + (pta_pt.y() - y) ** 2) ** 0.5
if dist <= KOORDINATEN_TOLERANZ_M:
gefunden = True
matched_pta_ids.add(fid)
break
feat = QgsFeature()
try:
from qgis.core import QgsPointXY # type: ignore[import]
feat.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y)))
except Exception:
continue
feat.setAttributes([WERT_IDENTISCH if gefunden else WERT_KEIN_PTA])
feats_to_add.append(feat)
if gefunden:
identisch_count += 1
else:
kein_pta_count += 1
if _canceled():
return None, 0, 0, 0
# ------------------------------------------------------------------
# Schritt n+2: Fehlende Knickpunkte (orange) ermitteln
# ------------------------------------------------------------------
_schritt("Knickpunktprüfung: Fehlende Knickpunkte ermitteln …", n + 2)
fehlender_knick_count = 0
# BROR-Umring ermitteln und puffern
try:
bror_feats = [
f for f in bror_layer.getFeatures()
if f.geometry() and not f.geometry().isEmpty()
]
bror_union = QgsGeometry.unaryUnion([f.geometry() for f in bror_feats])
bror_boundary = bror_union.convertToType(1) if bror_union else None
bror_buffer_geom = (
bror_boundary.buffer(BOUNDARY_PUFFER_M, 8) if bror_boundary else None
)
except Exception:
bror_buffer_geom = None
if bror_buffer_geom is not None and flst_layer is not None:
flst_vertex_set = _baue_flst_vertex_set(flst_layer, bror_buffer_geom)
for feat in punktort_layer.getFeatures():
if _canceled():
break
if feat.id() in matched_pta_ids:
continue
geom = feat.geometry()
if geom is None or geom.isEmpty():
continue
try:
if not geom.within(bror_buffer_geom):
continue
pta_pt = geom.asPoint()
key = (round(pta_pt.x(), _VERTEX_ROUND), round(pta_pt.y(), _VERTEX_ROUND))
if key in flst_vertex_set:
orange_feat = QgsFeature()
orange_feat.setGeometry(geom)
orange_feat.setAttributes([WERT_FEHLENDER_KNICK])
feats_to_add.append(orange_feat)
fehlender_knick_count += 1
except Exception:
continue
if _canceled():
return None, 0, 0, 0
# ------------------------------------------------------------------
# Schritt n+3: Ergebnislayer fertigstellen
# ------------------------------------------------------------------
_schritt("Knickpunktprüfung: Ergebnislayer erstellen …", n + 3)
pr.addFeatures(feats_to_add)
ergebnis_layer.updateExtents()
_setze_kategorien_symbologie(ergebnis_layer)
return ergebnis_layer, identisch_count, kein_pta_count, fehlender_knick_count
Reference in New Issue Copy Permalink