Verfahrensgebietsprüfung auf Knickpunkte umgestellt
Co-authored-by: Copilot <copilot@github.com>
This commit is contained in:
Copilot
@@ -914,6 +914,158 @@ def _erstelle_joined_layer(
|
||||
result_layer.updateExtents()
|
||||
return result_layer
|
||||
|
||||
|
||||
def lade_punktort_ta(
|
||||
schluessel_liste: List[str],
|
||||
vg_geom,
|
||||
progress=None,
|
||||
) -> Optional[object]:
|
||||
"""Lädt ``AX_PunktortTA`` gemarkungsweise mit STARTINDEX-Paginierung.
|
||||
|
||||
Verwendet dieselbe Strategie wie :func:`grenzpunkte_gemarkungsweise`:
|
||||
|
||||
1. Gemarkungsextents laden und mit einem 200-m-VG-Puffer verschneiden.
|
||||
2. Hits-Abfrage pro Gemarkung zur Batch-Planung.
|
||||
3. PunktortTA je Gemarkung in 5000-Feature-Batches laden (STARTINDEX-Paging).
|
||||
4. gml_id-Deduplizierung über Gemarkungsgrenzen hinweg.
|
||||
|
||||
Es werden keine Grenzpunkt-Batches geladen – die Funktion gibt ausschließlich
|
||||
den PunktortTA-Layer zurück.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
schluessel_liste :
|
||||
4-stellige Gemarkungsnummern (aus dem aktuellen Workflow bereits bekannt).
|
||||
vg_geom :
|
||||
``QgsGeometry`` des BROR-Objekts (EPSG:25833). Wird für den 200-m-Puffer
|
||||
zur Einschränkung der Gemarkungsextents verwendet.
|
||||
progress :
|
||||
Optionales Fortschrittsdialog-Objekt mit ``set_label()``, ``set_value()``
|
||||
und ``is_canceled()``.
|
||||
|
||||
Returns
|
||||
-------
|
||||
QgsVectorLayer | None
|
||||
Memory-Layer mit allen PunktortTA-Features oder ``None`` bei Fehler.
|
||||
"""
|
||||
from sn_basis.functions import QgsField
|
||||
from sn_basis.functions import QgsFeature as _QgsFeature
|
||||
from sn_basis.functions.qt_wrapper import QVariant
|
||||
|
||||
_BBOX_BATCH = 5000
|
||||
|
||||
if not schluessel_liste:
|
||||
return None
|
||||
|
||||
if vg_geom and not vg_geom.isEmpty():
|
||||
extents = _lade_gemarkung_extents_mit_puffer(schluessel_liste, vg_geom, 200.0)
|
||||
else:
|
||||
extents = _lade_gemarkung_extents(schluessel_liste)
|
||||
|
||||
if not extents:
|
||||
return None
|
||||
|
||||
n_extents = len(extents)
|
||||
alle_records: List[Dict] = []
|
||||
gesehene_ids: set = set()
|
||||
feld_namen: List[str] = []
|
||||
|
||||
for g_idx, (gemarkungsnummer, bbox) in enumerate(extents.items(), 1):
|
||||
if progress is not None and progress.is_canceled():
|
||||
return None
|
||||
|
||||
bbox_param = _punktort_ta_bbox_param(bbox)
|
||||
n_hits = _wfs_hits_count(ALKIS_SF_URL, PUNKTORT_TA_TYPENAME, {'BBOX': bbox_param})
|
||||
n_batches = max(1, math.ceil(n_hits / _BBOX_BATCH)) if n_hits > 0 else 1
|
||||
|
||||
info(
|
||||
"Grenzpunkte (Diagnose)",
|
||||
f"Gemarkung {gemarkungsnummer} ({g_idx}/{n_extents}): "
|
||||
f"~{n_hits} PunktortTA → {n_batches} Batch(es).",
|
||||
duration=2,
|
||||
)
|
||||
|
||||
for b_idx in range(n_batches):
|
||||
if progress is not None:
|
||||
progress.set_label(
|
||||
f"PunktortTA: Gemarkung {gemarkungsnummer} "
|
||||
f"({g_idx}/{n_extents}), Batch {b_idx + 1}/{n_batches} …"
|
||||
)
|
||||
if progress.is_canceled():
|
||||
return None
|
||||
|
||||
extra: dict = {'BBOX': bbox_param}
|
||||
if n_batches > 1:
|
||||
extra['COUNT'] = str(_BBOX_BATCH)
|
||||
extra['STARTINDEX'] = str(b_idx * _BBOX_BATCH)
|
||||
|
||||
_gml_bytes = _wfs_get_gml(ALKIS_SF_URL, PUNKTORT_TA_TYPENAME, extra)
|
||||
if not _gml_bytes:
|
||||
warning(
|
||||
"Grenzpunkte (Diagnose)",
|
||||
f"Gemarkung {gemarkungsnummer} Batch {b_idx + 1}: "
|
||||
f"GET-Anfrage fehlgeschlagen – übersprungen.",
|
||||
duration=4,
|
||||
)
|
||||
continue
|
||||
|
||||
tmp = _parse_alkis_gml_memory_layer(
|
||||
_gml_bytes, "AX_PunktortTA", "_TmpPTA", geom_prop="position"
|
||||
)
|
||||
if not tmp:
|
||||
continue
|
||||
|
||||
cur_felder = [f.name() for f in tmp.fields()]
|
||||
for n in cur_felder:
|
||||
if n not in feld_namen:
|
||||
feld_namen.append(n)
|
||||
|
||||
for feat in tmp.getFeatures():
|
||||
gml_id = _extrahiere_feature_gml_id(feat, cur_felder)
|
||||
if gml_id and gml_id in gesehene_ids:
|
||||
continue
|
||||
if gml_id:
|
||||
gesehene_ids.add(gml_id)
|
||||
attrs: Dict = {}
|
||||
for n in cur_felder:
|
||||
if n:
|
||||
try:
|
||||
attrs[n] = feat[n]
|
||||
except Exception:
|
||||
pass
|
||||
alle_records.append({'geom': feat.geometry(), 'attrs': attrs})
|
||||
|
||||
info(
|
||||
"Grenzpunkte (Diagnose)",
|
||||
f"Gemarkung {gemarkungsnummer}: {len(gesehene_ids)} PunktortTA bisher.",
|
||||
duration=2,
|
||||
)
|
||||
|
||||
if not alle_records:
|
||||
return None
|
||||
|
||||
result = QgsVectorLayer("Point?crs=EPSG:25833", PUNKTORT_LAYER_NAME, "memory")
|
||||
pr = result.dataProvider()
|
||||
pr.addAttributes([QgsField(n, QVariant.String) for n in feld_namen if n])
|
||||
result.updateFields()
|
||||
|
||||
neue_features = []
|
||||
for record in alle_records:
|
||||
f = _QgsFeature(result.fields())
|
||||
f.setGeometry(record['geom'])
|
||||
for n, val in record['attrs'].items():
|
||||
if n in feld_namen:
|
||||
try:
|
||||
f[n] = val
|
||||
except Exception:
|
||||
pass
|
||||
neue_features.append(f)
|
||||
|
||||
pr.addFeatures(neue_features)
|
||||
result.updateExtents()
|
||||
return result
|
||||
|
||||
|
||||
def grenzpunkt_alkis(tab_widget, extent=None) -> Tuple[Optional[object], Optional[object]]:
|
||||
"""Lädt Grenzpunkte aus dem ALKIS-WFS für den angegebenen Begrenzungsrahmen.
|
||||
|
||||
|
||||
@@ -0,0 +1,467 @@
|
||||
"""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
|
||||
@@ -12,13 +12,18 @@ optionaler Umringsprüfung:
|
||||
6. Flächenvergleich zwischen BROR-Objekt und abgeleitetem Verfahrensgebiet.
|
||||
|
||||
- **Übereinstimmung** (≤ Toleranz): modale OK-Meldung, Ablauf beendet.
|
||||
- **Abweichung**: Ja/Nein-Abfrage für Detailprüfung.
|
||||
- **Abweichung**: 3-Optionen-Dialog (Detailprüfung / Als VG laden / Abbrechen).
|
||||
|
||||
7. Optionale Umringsprüfung (Variante 1):
|
||||
7. Bei Wahl „Als VG laden":
|
||||
|
||||
- BROR-Umring gegen Flurstücksgrenzen vergleichen.
|
||||
- Ergebnislayer (grün/rot) ins Projekt einfügen.
|
||||
- Abschlussmeldung mit Konfliktanzahl.
|
||||
- BROR-Objekt direkt mit VG-Namen ins Projekt übernehmen.
|
||||
|
||||
8. Bei Wahl „Detailprüfung" (knickpunktbasiert):
|
||||
|
||||
- Grenzpunkte (AX_PunktortTA) per BBox laden.
|
||||
- Knickpunkte des BROR mit PunktortTA vergleichen (grün/rot/orange).
|
||||
- Ergebnislayer (Punkte) ins Projekt einfügen.
|
||||
- Abschlussmeldung mit Zählung.
|
||||
|
||||
Das BROR-Objekt (``AX_BauRaumOderBodenordnungsrecht``) bleibt bei Erfolg als
|
||||
temporärer Layer ``BauRaumOrdnungsrecht (ALKIS)`` im Projekt erhalten.
|
||||
@@ -42,7 +47,7 @@ from sn_basis.functions.variable_wrapper import get_variable
|
||||
from sn_basis.functions.dialog_wrapper import (
|
||||
create_progress_dialog,
|
||||
show_info_dialog,
|
||||
ask_yes_no,
|
||||
ask_detailpruefung_oder_vg_laden,
|
||||
)
|
||||
|
||||
from sn_verfahrensgebiet.functions.verfahrensgebiet_alkis import (
|
||||
@@ -57,7 +62,11 @@ from sn_verfahrensgebiet.functions.verfahrensgebiet_edit_service import (
|
||||
erstelle_verfahrensgebiet_aus_auswahl,
|
||||
VERF_LAYER_NAME,
|
||||
)
|
||||
from sn_verfahrensgebiet.functions.umringspruefung import umringspruefung
|
||||
from sn_verfahrensgebiet.functions.grenzpunkt_alkis import lade_punktort_ta
|
||||
from sn_verfahrensgebiet.functions.knickpunkt_pruefung import (
|
||||
knickpunkt_pruefung,
|
||||
_extrahiere_knickpunkte,
|
||||
)
|
||||
|
||||
# Feldname für das Verfahrenskennzeichen im enriched Layer
|
||||
FELD_VKZ = "verfahrensnummer"
|
||||
@@ -417,51 +426,96 @@ def verfahrensgebiet_alkis_komplett(
|
||||
return enriched_layer, flst_layer, alkis_vg_layer, vg_status
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Flächenabweichung → Nutzerabfrage für Detailprüfung
|
||||
# Flächenabweichung → 3-Optionen-Dialog
|
||||
# ------------------------------------------------------------------
|
||||
progress.close()
|
||||
diff = abs(bror_flaeche - vg_flaeche)
|
||||
starten = ask_yes_no(
|
||||
entscheidung = ask_detailpruefung_oder_vg_laden(
|
||||
tab_widget,
|
||||
"Abweichung erkannt",
|
||||
f"Abweichung zwischen BauRaumOrdnungsrecht-Objekt und abgeleitetem "
|
||||
f"Verfahrensgebiet erkannt. Detailprüfung starten?\n\n"
|
||||
f"Verfahrensgebiet erkannt.\n\n"
|
||||
f"BauRaumOrdnungsrecht: {bror_flaeche:.2f} m²\n"
|
||||
f"Verfahrensgebiet: {vg_flaeche:.2f} m²\n"
|
||||
f"Differenz: {diff:.2f} m²",
|
||||
default=True,
|
||||
parent=tab_widget,
|
||||
f"Differenz: {diff:.2f} m²\n\n"
|
||||
f"Wie möchten Sie fortfahren?",
|
||||
)
|
||||
|
||||
if not starten:
|
||||
if entscheidung == "abbrechen":
|
||||
abgeschlossen = True
|
||||
return enriched_layer, flst_layer, alkis_vg_layer, vg_status
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Umringsprüfung (Variante 1: linienbasierter Umringvergleich)
|
||||
# Option: Bodenordnungsobjekt direkt als Verfahrensgebiet laden
|
||||
# ------------------------------------------------------------------
|
||||
umring_progress = create_progress_dialog(
|
||||
3, "Detailprüfung (Umringe)", "Starte Umringsprüfung …"
|
||||
if entscheidung == "als_vg_laden":
|
||||
# Layer bleibt im Projekt – nur umbenennen. working_tab überspringt
|
||||
# addMapLayer wenn der Layer bereits registriert ist.
|
||||
alkis_vg_layer.setName(VERF_LAYER_NAME)
|
||||
bror_was_added_by_us = False
|
||||
abgeschlossen = True
|
||||
return alkis_vg_layer, None, None, vg_status
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Option: Detailprüfung (knickpunktbasiert)
|
||||
# ------------------------------------------------------------------
|
||||
# Knickpunkte vorab extrahieren, um Schrittanzahl zu bestimmen
|
||||
knickpunkte = _extrahiere_knickpunkte(alkis_vg_layer)
|
||||
n_knick = len(knickpunkte)
|
||||
# Gesamtschritte: 0=Start, 1=PTA-Index, 2…n+1=Knickpunkte, n+2=Orange, n+3=Fertig
|
||||
# + 1 Schritt vorab für Grenzpunkte laden
|
||||
gesamt_schritte = n_knick + 5
|
||||
|
||||
detail_progress = create_progress_dialog(
|
||||
gesamt_schritte,
|
||||
"Detailprüfung (Knickpunkte)",
|
||||
"Schritt 1: Grenzpunkte laden …",
|
||||
)
|
||||
detail_progress.set_value(0)
|
||||
|
||||
# Schritt 1: PunktortTA gemarkungsweise laden (Hits + 5000er-Batches)
|
||||
punktort_layer = lade_punktort_ta(
|
||||
vorgabe_schluessel, vg_geom, progress=detail_progress
|
||||
)
|
||||
|
||||
ergebnis_layer, konflikt_anzahl = umringspruefung(
|
||||
alkis_vg_layer, flst_layer, progress=umring_progress
|
||||
)
|
||||
|
||||
if umring_progress.is_canceled():
|
||||
umring_progress.close()
|
||||
if detail_progress.is_canceled():
|
||||
detail_progress.close()
|
||||
abgeschlossen = True
|
||||
return enriched_layer, flst_layer, alkis_vg_layer, vg_status
|
||||
|
||||
umring_progress.set_value(3)
|
||||
umring_progress.close()
|
||||
detail_progress.set_value(1)
|
||||
|
||||
if punktort_layer is None:
|
||||
detail_progress.close()
|
||||
abgeschlossen = True
|
||||
return enriched_layer, flst_layer, alkis_vg_layer, vg_status
|
||||
|
||||
# Schritte 2…Ende: Knickpunktprüfung
|
||||
ergebnis_layer, identisch, kein_pta, fehlender_knick = knickpunkt_pruefung(
|
||||
alkis_vg_layer,
|
||||
punktort_layer,
|
||||
flst_layer,
|
||||
progress=detail_progress,
|
||||
knickpunkte=knickpunkte,
|
||||
)
|
||||
|
||||
if detail_progress.is_canceled():
|
||||
detail_progress.close()
|
||||
abgeschlossen = True
|
||||
return enriched_layer, flst_layer, alkis_vg_layer, vg_status
|
||||
|
||||
detail_progress.set_value(gesamt_schritte)
|
||||
detail_progress.close()
|
||||
|
||||
if ergebnis_layer and ergebnis_layer.isValid():
|
||||
project.addMapLayer(ergebnis_layer)
|
||||
|
||||
show_info_dialog(
|
||||
"Detailprüfung",
|
||||
f"Detailprüfung abgeschlossen. "
|
||||
f"Es wurden {konflikt_anzahl} Konfliktstellen identifiziert.",
|
||||
"Detailprüfung abgeschlossen",
|
||||
f"Knickpunkte geprüft: {n_knick}\n"
|
||||
f" Identisch (grün): {identisch}\n"
|
||||
f" Kein PunktortTA (rot): {kein_pta}\n"
|
||||
f" Fehlende Knickpunkte (orange): {fehlender_knick}",
|
||||
parent=tab_widget,
|
||||
)
|
||||
|
||||
|
||||
@@ -0,0 +1,307 @@
|
||||
"""sn_verfahrensgebiet/tests/test_knickpunkt_pruefung.py
|
||||
|
||||
Unit-Tests für :mod:`sn_verfahrensgebiet.functions.knickpunkt_pruefung`.
|
||||
|
||||
Getestete Szenarien:
|
||||
|
||||
_extrahiere_knickpunkte:
|
||||
- Leerer Layer → leere Liste
|
||||
- Polygon mit 4 Knickpunkten → korrekte Anzahl (ohne doppelten Schlusspunkt)
|
||||
- Keine Geometrie → leere Liste
|
||||
|
||||
knickpunkt_pruefung:
|
||||
- Leere Knickpunktliste → (None, 0, 0, 0)
|
||||
- Kein PunktortTA-Layer → (None, 0, 0, 0)
|
||||
- Identischer Punkt → grün gezählt
|
||||
- Kein passender PunktortTA → rot gezählt
|
||||
- PunktortTA nahe Umring auf Flurstücksgrenze → orange gezählt
|
||||
- Abbruch via progress.is_canceled() → (None, 0, 0, 0)
|
||||
"""
|
||||
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Minimales QGIS-Mock-Setup (identisch mit test_verfahrensgebiet_alkis_komplett)
|
||||
# ---------------------------------------------------------------------------
|
||||
if "qgis" not in sys.modules:
|
||||
qgis_mod = types.ModuleType("qgis")
|
||||
qgis_core = types.ModuleType("qgis.core")
|
||||
# Attribute vorab setzen, damit patch() sie überschreiben kann
|
||||
qgis_core.QgsPointXY = None
|
||||
qgis_core.QgsRectangle = None
|
||||
qgis_core.QgsSpatialIndex = None
|
||||
qgis_core.QgsMarkerSymbol = None
|
||||
qgis_core.QgsCategorizedSymbolRenderer = None
|
||||
qgis_core.QgsRendererCategory = None
|
||||
qgis_utils = types.ModuleType("qgis.utils")
|
||||
qgis_utils.iface = types.SimpleNamespace()
|
||||
qgis_utils.plugins = {}
|
||||
qgis_mod.utils = qgis_utils
|
||||
qgis_mod.core = qgis_core
|
||||
sys.modules["qgis"] = qgis_mod
|
||||
sys.modules["qgis.core"] = qgis_core
|
||||
sys.modules["qgis.utils"] = qgis_utils
|
||||
|
||||
from sn_verfahrensgebiet.functions.knickpunkt_pruefung import (
|
||||
knickpunkt_pruefung,
|
||||
_extrahiere_knickpunkte,
|
||||
WERT_IDENTISCH,
|
||||
WERT_KEIN_PTA,
|
||||
WERT_FEHLENDER_KNICK,
|
||||
)
|
||||
|
||||
_MOD = "sn_verfahrensgebiet.functions.knickpunkt_pruefung"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Hilfsfunktionen
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _make_layer(valid=True, crs="EPSG:25833", lid="L1"):
|
||||
layer = MagicMock()
|
||||
layer.isValid.return_value = valid
|
||||
layer.id.return_value = lid
|
||||
mock_crs = MagicMock()
|
||||
mock_crs.authid.return_value = crs
|
||||
layer.crs.return_value = mock_crs
|
||||
layer.getFeatures.return_value = []
|
||||
return layer
|
||||
|
||||
|
||||
def _make_progress(canceled_after: int = 9999):
|
||||
"""Progress-Mock: gibt is_canceled() nach N Aufrufen True zurück."""
|
||||
call_count = [0]
|
||||
|
||||
def _is_canceled():
|
||||
call_count[0] += 1
|
||||
return call_count[0] > canceled_after
|
||||
|
||||
prog = MagicMock()
|
||||
prog.is_canceled.side_effect = _is_canceled
|
||||
return prog
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests: _extrahiere_knickpunkte
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestExtrahiereKnickpunkte(unittest.TestCase):
|
||||
|
||||
def test_leerer_layer_gibt_leere_liste(self):
|
||||
layer = _make_layer()
|
||||
layer.getFeatures.return_value = []
|
||||
result = _extrahiere_knickpunkte(layer)
|
||||
self.assertEqual(result, [])
|
||||
|
||||
def test_keine_gueltige_geometrie_gibt_leere_liste(self):
|
||||
feat = MagicMock()
|
||||
feat.geometry.return_value = None
|
||||
layer = _make_layer()
|
||||
layer.getFeatures.return_value = [feat]
|
||||
result = _extrahiere_knickpunkte(layer)
|
||||
self.assertEqual(result, [])
|
||||
|
||||
def test_feature_mit_leerer_geometrie_gibt_leere_liste(self):
|
||||
feat = MagicMock()
|
||||
geom = MagicMock()
|
||||
geom.isEmpty.return_value = True
|
||||
feat.geometry.return_value = geom
|
||||
layer = _make_layer()
|
||||
layer.getFeatures.return_value = [feat]
|
||||
result = _extrahiere_knickpunkte(layer)
|
||||
self.assertEqual(result, [])
|
||||
|
||||
def test_qgis_nicht_verfuegbar_gibt_leere_liste(self):
|
||||
"""Wenn qgis.core kein QgsPointXY hat (ImportError in Funktion), leere Liste."""
|
||||
layer = _make_layer()
|
||||
feat = MagicMock()
|
||||
geom = MagicMock()
|
||||
geom.isEmpty.return_value = False
|
||||
feat.geometry.return_value = geom
|
||||
layer.getFeatures.return_value = [feat]
|
||||
|
||||
# QgsGeometry.unaryUnion wirft eine Exception → leere Liste erwartet
|
||||
with patch(f"{_MOD}.QgsGeometry") as mock_geom_cls:
|
||||
mock_geom_cls.unaryUnion.side_effect = ImportError("kein QGIS")
|
||||
result = _extrahiere_knickpunkte(layer)
|
||||
self.assertEqual(result, [])
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests: knickpunkt_pruefung – Eingabevalidierung
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestKnickpunktPruefungInputvalidierung(unittest.TestCase):
|
||||
|
||||
def test_keine_knickpunkte_gibt_none_zurueck(self):
|
||||
bror = _make_layer()
|
||||
bror.getFeatures.return_value = []
|
||||
result = knickpunkt_pruefung(bror, MagicMock(), None)
|
||||
layer, identisch, kein_pta, fehlend = result
|
||||
self.assertIsNone(layer)
|
||||
self.assertEqual(identisch, 0)
|
||||
self.assertEqual(kein_pta, 0)
|
||||
self.assertEqual(fehlend, 0)
|
||||
|
||||
def test_kein_punktort_layer_gibt_none_zurueck(self):
|
||||
bror = _make_layer()
|
||||
result = knickpunkt_pruefung(bror, None, None, knickpunkte=[MagicMock()])
|
||||
layer, identisch, kein_pta, fehlend = result
|
||||
self.assertIsNone(layer)
|
||||
|
||||
def test_abbruch_via_progress_gibt_none_zurueck(self):
|
||||
bror = _make_layer()
|
||||
pta = _make_layer()
|
||||
prog = _make_progress(canceled_after=0) # sofort abbrechen
|
||||
result = knickpunkt_pruefung(
|
||||
bror, pta, None,
|
||||
progress=prog,
|
||||
knickpunkte=[MagicMock()],
|
||||
)
|
||||
self.assertIsNone(result[0])
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests: knickpunkt_pruefung – Klassifizierungslogik (mit QGIS-Mocks)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestKnickpunktPruefungKlassifizierung(unittest.TestCase):
|
||||
"""Testet die Grün/Rot/Orange-Klassifizierung mit gesteuertem QGIS-Mock."""
|
||||
|
||||
def _make_pta_layer_mit_punkt(self, x: float, y: float, fid: int = 1):
|
||||
"""Erstellt einen PunktortTA-Layer-Mock mit einem Punkt bei (x, y)."""
|
||||
layer = _make_layer(lid=f"PTA_{fid}")
|
||||
geom = MagicMock()
|
||||
geom.isEmpty.return_value = False
|
||||
pt = MagicMock()
|
||||
pt.x.return_value = x
|
||||
pt.y.return_value = y
|
||||
geom.asPoint.return_value = pt
|
||||
feat = MagicMock()
|
||||
feat.id.return_value = fid
|
||||
feat.geometry.return_value = geom
|
||||
layer.getFeatures.return_value = [feat]
|
||||
return layer
|
||||
|
||||
def _make_bror_layer(self, x: float = 0.0, y: float = 0.0):
|
||||
"""BROR-Layer mit einer minimalen Polygon-Geometrie."""
|
||||
layer = _make_layer()
|
||||
geom = MagicMock()
|
||||
geom.isEmpty.return_value = False
|
||||
geom.area.return_value = 10000.0
|
||||
feat = MagicMock()
|
||||
feat.geometry.return_value = geom
|
||||
layer.getFeatures.return_value = [feat]
|
||||
return layer
|
||||
|
||||
@patch(f"{_MOD}.QgsGeometry")
|
||||
@patch(f"{_MOD}._baue_pta_index")
|
||||
@patch(f"{_MOD}._erstelle_ergebnis_layer")
|
||||
@patch(f"qgis.core.QgsRectangle", create=True)
|
||||
@patch(f"qgis.core.QgsPointXY", create=True)
|
||||
def test_identischer_punkt_wird_gruen_gezaehlt(
|
||||
self, mock_ptxy, mock_rect, mock_erstelle, mock_index, mock_geom_cls
|
||||
):
|
||||
"""PunktortTA exakt am Knickpunkt → identisch_count == 1."""
|
||||
# Knickpunkt bei (100, 200)
|
||||
knick = MagicMock()
|
||||
knick.x.return_value = 100.0
|
||||
knick.y.return_value = 200.0
|
||||
|
||||
# PunktortTA ebenfalls bei (100, 200) – exakter Treffer
|
||||
pta_geom = MagicMock()
|
||||
pta_geom.isEmpty.return_value = False
|
||||
pta_pt = MagicMock()
|
||||
pta_pt.x.return_value = 100.0
|
||||
pta_pt.y.return_value = 200.0
|
||||
pta_geom.asPoint.return_value = pta_pt
|
||||
|
||||
# Spatial-Index gibt Feature-ID 1 zurück
|
||||
mock_idx = MagicMock()
|
||||
mock_idx.intersects.return_value = [1]
|
||||
mock_index.return_value = (mock_idx, {1: pta_geom})
|
||||
|
||||
# Ergebnis-Layer
|
||||
pr = MagicMock()
|
||||
pr.addFeatures.return_value = True
|
||||
ergebnis = MagicMock()
|
||||
ergebnis.dataProvider.return_value = pr
|
||||
ergebnis.isValid.return_value = True
|
||||
mock_erstelle.return_value = ergebnis
|
||||
|
||||
bror = self._make_bror_layer()
|
||||
pta = self._make_pta_layer_mit_punkt(100.0, 200.0)
|
||||
|
||||
result = knickpunkt_pruefung(
|
||||
bror, pta, None, knickpunkte=[knick]
|
||||
)
|
||||
_, identisch, kein_pta, _ = result
|
||||
self.assertEqual(identisch, 1)
|
||||
self.assertEqual(kein_pta, 0)
|
||||
|
||||
@patch(f"{_MOD}.QgsGeometry")
|
||||
@patch(f"{_MOD}._baue_pta_index")
|
||||
@patch(f"{_MOD}._erstelle_ergebnis_layer")
|
||||
@patch(f"qgis.core.QgsRectangle", create=True)
|
||||
@patch(f"qgis.core.QgsPointXY", create=True)
|
||||
def test_kein_pta_an_knickpunkt_wird_rot_gezaehlt(
|
||||
self, mock_ptxy, mock_rect, mock_erstelle, mock_index, mock_geom_cls
|
||||
):
|
||||
"""Kein PunktortTA am Knickpunkt → kein_pta_count == 1."""
|
||||
knick = MagicMock()
|
||||
knick.x.return_value = 100.0
|
||||
knick.y.return_value = 200.0
|
||||
|
||||
# Spatial-Index gibt leere Liste zurück → kein Treffer
|
||||
mock_idx = MagicMock()
|
||||
mock_idx.intersects.return_value = []
|
||||
mock_index.return_value = (mock_idx, {})
|
||||
|
||||
pr = MagicMock()
|
||||
pr.addFeatures.return_value = True
|
||||
ergebnis = MagicMock()
|
||||
ergebnis.dataProvider.return_value = pr
|
||||
ergebnis.isValid.return_value = True
|
||||
mock_erstelle.return_value = ergebnis
|
||||
|
||||
bror = self._make_bror_layer()
|
||||
pta = self._make_pta_layer_mit_punkt(999.0, 999.0) # weit weg
|
||||
|
||||
result = knickpunkt_pruefung(
|
||||
bror, pta, None, knickpunkte=[knick]
|
||||
)
|
||||
_, identisch, kein_pta, _ = result
|
||||
self.assertEqual(identisch, 0)
|
||||
self.assertEqual(kein_pta, 1)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests: _baue_flst_vertex_set
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestBaueFlstVertexSet(unittest.TestCase):
|
||||
|
||||
def test_none_layer_gibt_leeres_set(self):
|
||||
from sn_verfahrensgebiet.functions.knickpunkt_pruefung import _baue_flst_vertex_set
|
||||
result = _baue_flst_vertex_set(None, MagicMock())
|
||||
self.assertEqual(result, set())
|
||||
|
||||
def test_layer_ohne_schnitt_mit_puffer_ignoriert(self):
|
||||
from sn_verfahrensgebiet.functions.knickpunkt_pruefung import _baue_flst_vertex_set
|
||||
layer = _make_layer()
|
||||
geom = MagicMock()
|
||||
geom.isEmpty.return_value = False
|
||||
geom.intersects.return_value = False # kein Schnitt
|
||||
feat = MagicMock()
|
||||
feat.geometry.return_value = geom
|
||||
layer.getFeatures.return_value = [feat]
|
||||
buffer_geom = MagicMock()
|
||||
result = _baue_flst_vertex_set(layer, buffer_geom)
|
||||
self.assertEqual(result, set())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -17,9 +17,10 @@ Abbruchpfade:
|
||||
- Progress-Abbruch nach Schritt 1 → sofortiger sauberer Rückgabestatus
|
||||
|
||||
Flächenvergleich:
|
||||
- Übereinstimmung → show_info_dialog, keine Umringsprüfung
|
||||
- Abweichung + Nein → kein Umringsprüfungs-Aufruf
|
||||
- Abweichung + Ja → umringspruefung aufgerufen, Ergebnislayer ins Projekt
|
||||
- Übereinstimmung → show_info_dialog, keine Detailprüfung
|
||||
- Abweichung + abbrechen → kein Detailprüfungs-Aufruf
|
||||
- Abweichung + als_vg_laden → BROR umbenannt, als enriched_layer zurückgegeben
|
||||
- Abweichung + detailpruefung → lade_punktort_ta + knickpunkt_pruefung aufgerufen
|
||||
|
||||
Cleanup:
|
||||
- BROR-Layer wird bei Erfolg NICHT entfernt
|
||||
@@ -141,8 +142,10 @@ _PATCH_GET_VAR = f"{_MOD}.get_variable"
|
||||
_PATCH_PROGRESS = f"{_MOD}.create_progress_dialog"
|
||||
_PATCH_VERGLEICHE = f"{_MOD}._vergleiche_flaechen"
|
||||
_PATCH_SHOW_INFO = f"{_MOD}.show_info_dialog"
|
||||
_PATCH_ASK_YES_NO = f"{_MOD}.ask_yes_no"
|
||||
_PATCH_UMRING = f"{_MOD}.umringspruefung"
|
||||
_PATCH_ASK_DIALOG = f"{_MOD}.ask_detailpruefung_oder_vg_laden"
|
||||
_PATCH_GP_ALKIS = f"{_MOD}.lade_punktort_ta"
|
||||
_PATCH_KNICK = f"{_MOD}.knickpunkt_pruefung"
|
||||
_PATCH_EXTRAHIERE = f"{_MOD}._extrahiere_knickpunkte"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
@@ -448,12 +451,12 @@ class TestVerfahrensgebietAlkisKomplett(unittest.TestCase):
|
||||
mock_vkz.assert_called_once_with(enriched, "")
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Flächenvergleich – Abweichung + Nein
|
||||
# Flächenvergleich – Abweichung + Abbrechen
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
@patch(_PATCH_PROGRESS)
|
||||
@patch(_PATCH_UMRING)
|
||||
@patch(_PATCH_ASK_YES_NO)
|
||||
@patch(_PATCH_KNICK)
|
||||
@patch(_PATCH_ASK_DIALOG)
|
||||
@patch(_PATCH_VERGLEICHE)
|
||||
@patch(_PATCH_VKZ)
|
||||
@patch(_PATCH_GET_VAR)
|
||||
@@ -463,11 +466,11 @@ class TestVerfahrensgebietAlkisKomplett(unittest.TestCase):
|
||||
@patch(_PATCH_GEM)
|
||||
@patch(_PATCH_FLST)
|
||||
@patch(_PATCH_VG_ALKIS)
|
||||
def test_flaechen_abweichung_nein_kein_umring(
|
||||
def test_flaechen_abweichung_abbrechen_kein_detailcheck(
|
||||
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select,
|
||||
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_ask, mock_umring, mock_prog,
|
||||
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_ask, mock_knick, mock_prog,
|
||||
):
|
||||
"""Abweichung + Nein → umringspruefung wird NICHT aufgerufen."""
|
||||
"""Abweichung + Abbrechen → knickpunkt_pruefung wird NICHT aufgerufen."""
|
||||
mock_proj.instance.return_value = _DummyProject()
|
||||
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
|
||||
flst_layer = _make_layer(name="Flurstücke")
|
||||
@@ -480,23 +483,22 @@ class TestVerfahrensgebietAlkisKomplett(unittest.TestCase):
|
||||
mock_erstelle.return_value = (enriched, 3, 0)
|
||||
mock_get_var.return_value = ""
|
||||
mock_vergl.return_value = (1000.0, 800.0, False)
|
||||
mock_ask.return_value = False
|
||||
mock_ask.return_value = "abbrechen"
|
||||
mock_prog.return_value = _make_progress_mock()
|
||||
|
||||
result_enriched, _, _, status = verfahrensgebiet_alkis_komplett(None)
|
||||
|
||||
mock_umring.assert_not_called()
|
||||
mock_knick.assert_not_called()
|
||||
self.assertIs(result_enriched, enriched)
|
||||
self.assertEqual(status, LoadStatus.FIRST)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Flächenvergleich – Abweichung + Ja → Umringsprüfung
|
||||
# Flächenvergleich – Abweichung + Als VG laden
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
@patch(_PATCH_PROGRESS)
|
||||
@patch(_PATCH_SHOW_INFO)
|
||||
@patch(_PATCH_UMRING)
|
||||
@patch(_PATCH_ASK_YES_NO)
|
||||
@patch(_PATCH_KNICK)
|
||||
@patch(_PATCH_ASK_DIALOG)
|
||||
@patch(_PATCH_VERGLEICHE)
|
||||
@patch(_PATCH_VKZ)
|
||||
@patch(_PATCH_GET_VAR)
|
||||
@@ -506,20 +508,18 @@ class TestVerfahrensgebietAlkisKomplett(unittest.TestCase):
|
||||
@patch(_PATCH_GEM)
|
||||
@patch(_PATCH_FLST)
|
||||
@patch(_PATCH_VG_ALKIS)
|
||||
def test_flaechen_abweichung_ja_startet_umringspruefung(
|
||||
def test_flaechen_abweichung_als_vg_laden(
|
||||
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select,
|
||||
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_ask,
|
||||
mock_umring, mock_info, mock_prog,
|
||||
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_ask, mock_knick, mock_prog,
|
||||
):
|
||||
"""Abweichung + Ja → umringspruefung aufgerufen, Ergebnislayer ins Projekt,
|
||||
Abschlussmeldung mit Konfliktanzahl."""
|
||||
"""Abweichung + Als VG laden → BROR-Layer wird umbenannt und als
|
||||
enriched_layer zurückgegeben; flst_layer und bror_layer sind None."""
|
||||
proj_inst = _DummyProject()
|
||||
mock_proj.instance.return_value = proj_inst
|
||||
|
||||
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
|
||||
flst_layer = _make_layer(name="Flurstücke")
|
||||
enriched = _make_layer(name="Verfahrensgebiet", valid=True)
|
||||
ergebnis_layer = _make_layer(name="Umringsprüfung", lid="UMRING_L")
|
||||
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)", lid="BROR_VG")
|
||||
flst_layer = _make_layer(name="Flurstücke")
|
||||
enriched = _make_layer(name="Verfahrensgebiet", valid=True)
|
||||
|
||||
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
|
||||
mock_gem.return_value = []
|
||||
@@ -528,17 +528,79 @@ class TestVerfahrensgebietAlkisKomplett(unittest.TestCase):
|
||||
mock_erstelle.return_value = (enriched, 3, 0)
|
||||
mock_get_var.return_value = ""
|
||||
mock_vergl.return_value = (1000.0, 800.0, False)
|
||||
mock_ask.return_value = True
|
||||
mock_umring.return_value = (ergebnis_layer, 4)
|
||||
mock_ask.return_value = "als_vg_laden"
|
||||
mock_prog.return_value = _make_progress_mock()
|
||||
|
||||
result_enriched, result_flst, result_bror, status = verfahrensgebiet_alkis_komplett(None)
|
||||
|
||||
mock_knick.assert_not_called()
|
||||
# BROR-Layer wird als enriched_layer zurückgegeben
|
||||
self.assertIs(result_enriched, vg_layer)
|
||||
self.assertIsNone(result_flst)
|
||||
self.assertIsNone(result_bror)
|
||||
self.assertEqual(status, LoadStatus.FIRST)
|
||||
# Name wurde auf VERF_LAYER_NAME geändert
|
||||
vg_layer.setName.assert_called()
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Flächenvergleich – Abweichung + Detailprüfung
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
@patch(_PATCH_PROGRESS)
|
||||
@patch(_PATCH_SHOW_INFO)
|
||||
@patch(_PATCH_EXTRAHIERE)
|
||||
@patch(_PATCH_KNICK)
|
||||
@patch(_PATCH_GP_ALKIS)
|
||||
@patch(_PATCH_ASK_DIALOG)
|
||||
@patch(_PATCH_VERGLEICHE)
|
||||
@patch(_PATCH_VKZ)
|
||||
@patch(_PATCH_GET_VAR)
|
||||
@patch(_PATCH_ERSTELLE)
|
||||
@patch(_PATCH_SELECT)
|
||||
@patch(_PATCH_PROJECT)
|
||||
@patch(_PATCH_GEM)
|
||||
@patch(_PATCH_FLST)
|
||||
@patch(_PATCH_VG_ALKIS)
|
||||
def test_flaechen_abweichung_detailpruefung_startet_knickpruefung(
|
||||
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select,
|
||||
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_ask,
|
||||
mock_gp, mock_knick, mock_extrahiere, mock_info, mock_prog,
|
||||
):
|
||||
"""Abweichung + Detailprüfung → lade_punktort_ta + knickpunkt_pruefung
|
||||
aufgerufen, Ergebnislayer ins Projekt, Abschlussmeldung mit Zählung."""
|
||||
proj_inst = _DummyProject()
|
||||
mock_proj.instance.return_value = proj_inst
|
||||
|
||||
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
|
||||
flst_layer = _make_layer(name="Flurstücke")
|
||||
enriched = _make_layer(name="Verfahrensgebiet", valid=True)
|
||||
punktort_layer = _make_layer(name="PunktortTA", lid="PTA_L")
|
||||
ergebnis_layer = _make_layer(name="Knickpunktprüfung", lid="KNICK_L")
|
||||
|
||||
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
|
||||
mock_gem.return_value = []
|
||||
mock_flst.return_value = (flst_layer, LoadStatus.FIRST)
|
||||
mock_select.return_value = 3
|
||||
mock_erstelle.return_value = (enriched, 3, 0)
|
||||
mock_get_var.return_value = ""
|
||||
mock_vergl.return_value = (1000.0, 800.0, False)
|
||||
mock_ask.return_value = "detailpruefung"
|
||||
mock_extrahiere.return_value = [MagicMock(), MagicMock(), MagicMock()] # 3 Knickpunkte
|
||||
mock_gp.return_value = punktort_layer
|
||||
mock_knick.return_value = (ergebnis_layer, 2, 1, 0)
|
||||
mock_prog.return_value = _make_progress_mock()
|
||||
|
||||
result_enriched, _, _, status = verfahrensgebiet_alkis_komplett(None)
|
||||
|
||||
mock_umring.assert_called_once()
|
||||
mock_gp.assert_called_once()
|
||||
mock_knick.assert_called_once()
|
||||
self.assertIn(ergebnis_layer, proj_inst.added)
|
||||
mock_info.assert_called_once()
|
||||
self.assertIn("4", mock_info.call_args[0][1])
|
||||
self.assertIn("Konfliktstellen", mock_info.call_args[0][1])
|
||||
# Abschlussmeldung muss Zahlen enthalten
|
||||
info_text = mock_info.call_args[0][1]
|
||||
self.assertIn("3", info_text) # Anzahl Knickpunkte
|
||||
self.assertIn("2", info_text) # identisch
|
||||
self.assertIn("1", info_text) # kein_pta
|
||||
self.assertEqual(status, LoadStatus.FIRST)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
@@ -166,8 +166,9 @@ class WorkingTab(QWidget):
|
||||
if bror_layer and bror_layer.isValid():
|
||||
_setze_bror_stil(bror_layer)
|
||||
|
||||
# Enriched VG-Layer ins Projekt
|
||||
project.addMapLayer(enriched_layer)
|
||||
# Enriched VG-Layer ins Projekt (ggf. bereits registriert, z.B. bei "als VG laden")
|
||||
if not project.mapLayer(enriched_layer.id()):
|
||||
project.addMapLayer(enriched_layer)
|
||||
apply_style(enriched_layer, "verfahrensgebiet.qml")
|
||||
iface.mapCanvas().setExtent(enriched_layer.extent())
|
||||
iface.mapCanvas().refresh()
|
||||
|
||||
Reference in New Issue
Block a user