Upload 11 files

README.md

@@ -1,12 +1,6 @@
 ---
-title: NAS ALKIS Conversion
-emoji: 🔥
-colorFrom: gray
-colorTo: gray
+title: NAS-ALKIS_CONVERSION
+app_file: app.py
 sdk: gradio
 sdk_version: 4.44.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,63 @@
+import gradio as gr
+import subprocess
+import os
+import time
+
+def run_script(script_name, *args):
+    command = ['python', script_name] + list(args)
+    start_time = time.time()
+    result = subprocess.run(command, capture_output=True, text=True)
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    if result.returncode != 0:
+        return f"Error running {script_name}: {result.stderr}"
+    else:
+        pass
+
+def process_files(xml_file, output_path):
+    # Define file paths
+    bez_dict_file = "bez_dict.json"
+    flurstueck_shapefile = os.path.join(output_path, "flurstueck.shp")
+    nutzung_shapefile = os.path.join(output_path, "nutzung.shp")
+    nutzung_flurstueck_shapefile = os.path.join(output_path, "nutzungFlurstueck.shp")
+    gebauede_bauwerk_shapefile = os.path.join(output_path, "gebauedeBauwerk.shp")
+    verwaltungs_einheit_shapefile = os.path.join(output_path, "verwaltungsEinheit.shp")
+    kataster_bezirk_shapefile = os.path.join(output_path, "katasterBezirk.shp")
+
+    # Ensure the output directory exists
+    os.makedirs(output_path, exist_ok=True)
+
+    # Run scripts in the correct order
+    results = []
+    results.append(run_script('flurstueck.py', xml_file, flurstueck_shapefile))
+    results.append(f"Generated: {flurstueck_shapefile}")
+    results.append(run_script('nutzung.py', xml_file, bez_dict_file, nutzung_shapefile))
+    results.append(f"Generated: {nutzung_shapefile}")
+    results.append(run_script('nutflu.py', flurstueck_shapefile, nutzung_shapefile, nutzung_flurstueck_shapefile))
+    results.append(f"Generated: {nutzung_flurstueck_shapefile}")
+    results.append(run_script('guby.py', xml_file, gebauede_bauwerk_shapefile))
+    results.append(f"Generated: {gebauede_bauwerk_shapefile}")
+    results.append(run_script('ver.py', flurstueck_shapefile, xml_file, verwaltungs_einheit_shapefile))
+    results.append(f"Generated: {verwaltungs_einheit_shapefile}")
+    results.append(run_script('kat.py', flurstueck_shapefile, kataster_bezirk_shapefile))
+    results.append(f"Generated: {kataster_bezirk_shapefile}")
+
+    results.append("CONVERSION COMPLETED")
+
+    return "\n".join(results)
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=process_files,
+    inputs=[
+        gr.File(label="Input XML File"),
+        gr.Textbox(label="Output Path", placeholder="Enter the output directory path")
+    ],
+    outputs="text",
+    title="NAS-ALKIS Conversion",
+    description="Upload an XML file and specify the output path to generate conversion."
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch(share=True)

bez_dict.json

@@ -0,0 +1,255 @@
+{
+    "2620": "Abfallbehandlungsanlage",
+    "7000": "Abraum",
+    "1010": "Ackerland",
+    "8220": "Altarm",
+    "8210": "Altwasser",
+    "2014": "Andesit",
+    "5002": "Anhydritstein",
+    "5630": "Anlegestelle",
+    "3010": "Antimon",
+    "1450": "Ausstellung, Messe",
+    "4260": "Autokino, Freilichtkino",
+    "8500": "Bach",
+    "8640": "Baggersee",
+    "1420": "Bank, Kredit",
+    "2013": "Basalt, Diabas",
+    "1031": "Baumschule",
+    "1000": "Vegetationslose Fläche",
+    "1110": "Verwaltung",
+    "1460": "Beherbergung",
+    "1002": "Bentonit",
+    "2000": "Steine, Gestein, Festgestein",
+    "2710": "Betrieb",
+    "1780": "Betriebliche Sozialeinrichtung",
+    "2502": "Industrie und Gewerbefläche",
+    "2532": "Betriebsfläche Versorgungsanlage, Elektrizität",
+    "2582": "Betriebsfläche Versorgungsanlage, Funkund Fernmeldewesen",
+    "2562": "Betriebsfläche Versorgungsanlage, Gas",
+    "2522": "Betriebsfläche Versorgungsanlage, Wasser",
+    "2572": "Betriebsfläche Versorgungsanlage, Wärme",
+    "2552": "Betriebsfläche Versorgungsanlage, Öl",
+    "2602": "Betriebsfläche, Entsorgungsanlage",
+    "2622": "Betriebsfläche, Entsorgungsanlage Abfallbeseitigung",
+    "2612": "Betriebsfläche, Entsorgungsanlage Abwasserbeseitigung",
+    "2623": "Betriebsfläche, Entsorgungsanlage Schlamm",
+    "1120": "Unbebaute Gewässerbegleitfläche",
+    "3004": "Blei",
+    "4430": "Botanischer Garten",
+    "1200": "Stadtbahn",
+    "4021": "Braunkohle",
+    "3002": "Buntmetallerze",
+    "1310": "Laubwald mit Nadelholz",
+    "4330": "Campingplatz",
+    "2630": "Deponie (oberirdisch)",
+    "2640": "Deponie (untertägig)",
+    "2006": "Dolomitstein",
+    "3011": "Edelmetallerze",
+    "4160": "Eis-, Rollschuhbahn",
+    "3001": "Eisen",
+    "1100": "Öffentliche Zwecke",
+    "2600": "Entsorgung",
+    "4000": "Treib- und Brennstoffe",
+    "4300": "Erholungsfläche",
+    "3000": "Kohle",
+    "5210": "Fahrweg",
+    "1011": "Streuobstacker",
+    "5009": "Feldspat",
+    "5350": "Festplatz",
+    "8410": "Fleet",
+    "8230": "Flussmündungstrichter",
+    "5510": "Flughafen",
+    "8200": "Fluss",
+    "5006": "Flusspat",
+    "1760": "Forschung",
+    "7600": "Forstwirtschaftliche Betriebsfläche",
+    "4250": "Freilichtmuseum",
+    "4240": "Freilichttheater",
+    "4200": "Freizeitanlage",
+    "4230": "Freizeitpark",
+    "9403": "Friedhof (Park)",
+    "9402": "Friedhof (ohne Gebäude)",
+    "2580": "Funk- und Fernmeldeanlage",
+    "5130": "Fußgängerzone",
+    "5220": "Fußweg",
+    "5640": "Fähranlage",
+    "5230": "Gang",
+    "4460": "Garten",
+    "1030": "Geröll",
+    "2560": "Gaswerk",
+    "2341": "Gebäude- Freifläche zu Verkehrsanlagen, Schifffahrt",
+    "2601": "Gebäude- und Freifläche Entsorgungsanlage",
+    "2610": "Kläranlage, Klärwerk",
+    "2621": "Gebäude- und Freifläche Entsorgungsanlage, Abfallbeseitigung",
+    "2611": "Gebäude- und Freifläche Entsorgungsanlage, Abwasserbeseitigung",
+    "4301": "Gebäude- und Freifläche Erholung",
+    "4321": "Gebäude- und Freifläche, Bad",
+    "4431": "Gebäude- und Freifläche, Erholung, Botanik",
+    "4331": "Gebäude- und Freifläche, Camping",
+    "4101": "Gebäude- und Freifläche Erholung, Sport",
+    "9401": "Gebäude- und Freifläche Friedhof",
+    "1701": "Gebäude- und Freifläche Industrie und Gewerbe",
+    "2700": "Gebäude- und Freifläche Land- und Forstwirtschaft",
+    "2501": "Gebäude- und Freifläche Versorgungsanlage",
+    "2521": "Gebäude- und Freifläche Versorgungsanlage, Wasser",
+    "2531": "Gebäude- und Freifläche Versorgungsanlage, Elektrizität",
+    "2581": "Gebäude- und Freifläche Versorgungsanlage, Funk- und Fernmeldesystem",
+    "2561": "Gebäude- und Freifläche Versorgungsanlage, Gas",
+    "2571": "Gebäude- und Freifläche Versorgungsanlage, Wärme",
+    "2551": "Gebäude- und Freifläche Versorgungsanlage, Öl",
+    "5501": "Gebäude- und Freifläche zu Verkehrsanlagen, Luftfahrt",
+    "2321": "Gebäude- und Freifläche zu Verkehrsanlagen, Schiene",
+    "2311": "Gebäude- und Freifläche zu Verkehrsanlagen, Straße",
+    "4211": "Gebäude- und Freifläche, Zoologie",
+    "2100": "Gebäude- und Freifläche, Mischnutzung mit Wohnen",
+    "1150": "Gesundheit, Kur",
+    "2160": "Gewerbe und Industrie mit Wohnen",
+    "5001": "Gipsstein",
+    "2012": "Gneis",
+    "4110": "Golfplatz",
+    "8400": "Graben",
+    "2016": "Granit",
+    "2017": "Granodiorit",
+    "5011": "Graphit",
+    "2010": "Grauwacke",
+    "1770": "Grundstoff",
+    "4400": "Grünanlage",
+    "4410": "Grünfläche",
+    "1020": "Grünland",
+    "1490": "Gärtnerei",
+    "1102": "Güterverkehr",
+    "5610": "Hafenanlage (Landfläche)",
+    "9999": "Tagebau, Grube, Steinbruch",
+    "1440": "Handel",
+    "1400": "Handel und Dienstleistung",
+    "2150": "Handel und Dienstleistungen mit Wohnen",
+    "1720": "Handwerk",
+    "5211": "Hauptwirtschaftsweg",
+    "2570": "Heizwerk",
+    "1300": "Seilbahn, Bergbahn",
+    "9404": "Historischer Friedhof",
+    "1012": "Quarzsand",
+    "5530": "Hubschrauberflugplatz",
+    "4280": "Hundeübungsplatz",
+    "1700": "Industrie und Gewerbe",
+    "5000": "Schutt",
+    "5511": "Internationaler Flughafen",
+    "5004": "Kalisalz",
+    "1007": "Kalk, Kalktuff, Kreide",
+    "5005": "Kalkspat",
+    "2005": "Kalkstein",
+    "8300": "Kanal",
+    "1003": "Kaolin",
+    "8000": "Schrott, Altmaterial",
+    "1009": "Kies, Kiessand",
+    "1013": "Spargel",
+    "4440": "Kleingarten",
+    "4020": "Kohle",
+    "2530": "Kraftwerk",
+    "1130": "Kultur",
+    "3003": "Kupfer",
+    "8710": "Küstengewässer",
+    "1740": "Lagerplatz",
+    "5540": "Landeplatz, Sonderlandeplatz",
+    "6800": "Landwirtschaftliche Betriebsfläche",
+    "2020": "Lavaschlacke",
+    "1004": "Lehm",
+    "1005": "Löß, Lößlehm",
+    "1600": "Magnetschwebebahn",
+    "3009": "Mangan",
+    "5340": "Marktplatz",
+    "2008": "Marmor",
+    "1006": "Mergel",
+    "2004": "Mergelstein",
+    "2003": "Metamorphe Schiefer",
+    "4290": "Modellflugplatz",
+    "1320": "Schlossanlage",
+    "1051": "Obstbaumplantage",
+    "1050": "Obstplantage",
+    "1052": "Obststrauchplantage",
+    "4420": "Park",
+    "5310": "Parkplatz",
+    "5010": "Pegmatitsand",
+    "2015": "Porphyr, Quarzporphyr",
+    "1710": "Produktion",
+    "5008": "Quarz",
+    "2011": "Quarzit",
+    "5250": "Rad- und Fußweg",
+    "5240": "Radweg",
+    "2550": "Raffinerie",
+    "5320": "Rastplatz",
+    "5330": "Raststätte",
+    "5512": "Regionalflughafen",
+    "41400": "Reitplatz",
+    "5260": "Reitweg",
+    "1140": "Religiöse Einrichtung",
+    "4130": "Rennbahn",
+    "1470": "Restauration",
+    "1104": "S-Bahn",
+    "4220": "Safaripark, Wildpark",
+    "1008": "Sand",
+    "1040": "Weingarten",
+    "2009": "Sandstein",
+    "2002": "Schiefer, Dachschiefer",
+    "4150": "Schießanlage",
+    "6000": "Schlacke",
+    "5620": "Schleuse (Landfläche)",
+    "5007": "Schwerspat",
+    "4320": "Schwimmbad, Freibad",
+    "8610": "See",
+    "5550": "Segelfluggelände",
+    "1170": "Sicherheit und Ordnung",
+    "1160": "Soziales",
+    "8631": "Speicherbecken",
+    "4470": "Spielplatz, Bolzplatz",
+    "4100": "Sportanlage",
+    "8810": "Sporthafenbecken",
+    "4120": "Sportplatz",
+    "1302": "Standseilbahn",
+    "8630": "Stausee",
+    "4022": "Steinkohle",
+    "5003": "Steinsalz",
+    "1201": "Straßenbahn",
+    "2313": "Straßenentwässerungsanlage",
+    "1021": "Streuobstwiese",
+    "2021": "Talkschiefer, Speckstein",
+    "1730": "Tankstelle",
+    "8620": "Teich",
+    "4170": "Tennisplatz",
+    "1001": "Ton",
+    "2001": "Tonstein",
+    "4010": "Torf",
+    "1750": "Transport",
+    "2019": "Trass",
+    "2007": "Travertin",
+    "2018": "Tuff, Bimsstein",
+    "1202": "U-Bahn",
+    "2540": "Umspannstation",
+    "3008": "Uran",
+    "1480": "Vergnügung",
+    "2322": "Verkehrsbegleitfläche Bahnverkehr",
+    "2312": "Verkehrsbegleitfläche Straße",
+    "5520": "Verkehrslandeplatz",
+    "4270": "Verkehrsübungsplatz",
+    "1430": "Versicherung",
+    "2500": "Versorgungsanlage",
+    "1410": "Verwaltung, freie Berufe",
+    "2520": "Wasserwerk",
+    "22000": "Weg",
+    "1790": "Werft",
+    "5212": "Wirtschaftsweg",
+    "3007": "Wismut, Kobaldt, Nickel",
+    "4310": "Wochenend- und Ferienhausfläche",
+    "4450": "Wochenendplatz",
+    "2720": "Wohnen",
+    "2130": "Wohnen mit Gewerbe und Industrie",
+    "2120": "Wohnen mit Handel und Dienstleistungen",
+    "2110": "Wohnen mit Öffentlich",
+    "2730": "Wohnen und Betrieb",
+    "1301": "Zahnradbahn",
+    "3005": "Zink",
+    "3006": "Zinn",
+    "4210": "Zoo",
+    "2140": "Öffentlich mit Wohnen",
+    "4030": "Ölschiefer"
+}

flurstueck.py

@@ -0,0 +1,213 @@
+import time
+import geopandas as gpd
+from shapely.geometry import Polygon
+import xml.etree.ElementTree as ET
+import multiprocessing as mp
+import sys
+
+# Parse the XML file correctly
+def parse_xml(file_path):
+    tree = ET.parse(file_path)  # Parse the entire XML file
+    root = tree.getroot()       # Get the root element
+    return root
+
+# Extract coordinates in bulk
+def extract_coordinates(posList):
+    coordinates = [float(x) for x in posList.strip().split()]
+    return [(coordinates[i], coordinates[i + 1]) for i in range(0, len(coordinates), 2)]
+
+# Create flurstnr based on zaehler and nenner
+def create_flurstnr(zaehler, nenner=None):
+    return f"{zaehler}/{nenner}" if nenner else zaehler
+
+# Create gmdschl by merging land, kreis, regierungsbezirk, and gemeinde
+def create_gmdschl(land, regierungsbezirk, kreis, gemeinde):
+    return f"{land}{regierungsbezirk}{kreis}{gemeinde}"
+
+# Find and extract kreis values
+def find_kreis(root, namespaces):
+    kreis_dict = {}
+    for kreis_region in root.findall('.//adv:AX_KreisRegion', namespaces):
+        schluessel_gesamt = kreis_region.find('.//adv:schluesselGesamt', namespaces)
+        if schluessel_gesamt is not None:
+            kreis_dict[schluessel_gesamt.text] = kreis_region.find('.//adv:bezeichnung', namespaces).text
+    return kreis_dict
+
+# Find and extract regbezirk values
+def find_regbezirk(root, namespaces):
+    regbezirk_dict = {}
+    for regbezirk in root.findall('.//adv:AX_Regierungsbezirk', namespaces):
+        schluessel_gesamt = regbezirk.find('.//adv:schluesselGesamt', namespaces)
+        bezeichnung = regbezirk.find('.//adv:bezeichnung', namespaces)
+        if schluessel_gesamt is not None and bezeichnung is not None:
+            regbezirk_dict[schluessel_gesamt.text] = bezeichnung.text
+    return regbezirk_dict
+
+# Create lookup dictionary
+def create_lookup_dict(root, tag, key_path, value_path, namespaces):
+    lookup_dict = {}
+    for element in root.findall(f'.//adv:{tag}', namespaces):
+        key = element.find(key_path, namespaces)
+        value = element.find(value_path, namespaces)
+        if key is not None and value is not None:
+            lookup_dict[key.text] = value.text
+    return lookup_dict
+
+# Create lagebeztxt lookup dictionary
+def create_lagebeztxt_dict(root, namespaces):
+    lagebeztxt_dict = {}
+    for tag in ['AX_LagebezeichnungMitHausnummer', 'AX_LagebezeichnungOhneHausnummer']:
+        for element in root.findall(f'.//adv:{tag}', namespaces):
+            gml_id = element.get('{http://www.opengis.net/gml/3.2}id')
+            unverschluesselt = element.find('.//adv:unverschluesselt', namespaces)
+            hausnummer = element.find('.//adv:hausnummer', namespaces)
+            
+            if unverschluesselt is not None:
+                if hausnummer is not None:
+                    lagebeztxt_dict[gml_id] = f"{unverschluesselt.text} {hausnummer.text}"
+                else:
+                    lagebeztxt_dict[gml_id] = unverschluesselt.text
+            else:
+                lagebeztxt_dict[gml_id] = "<null>"
+    
+    return lagebeztxt_dict
+
+# Process a single AX_Flurstueck element
+def process_single_flurstueck(flurstueck, namespaces, lookup_dicts):
+    # Extracting coordinates in bulk
+    polygon_coords = [coord for posList in flurstueck.findall('.//gml:posList', namespaces)
+                      for coord in extract_coordinates(posList.text)]
+    polygon = Polygon(polygon_coords)
+    
+    # Extract attributes in a single pass
+    flaeche = flurstueck.find('.//adv:amtlicheFlaeche', namespaces)
+    flaeche = flaeche.text if flaeche is not None else None
+    
+    flstkennz = flurstueck.find('.//adv:flurstueckskennzeichen', namespaces)
+    flstkennz = flstkennz.text if flstkennz is not None else None
+
+    zaehler = flurstueck.find('.//adv:zaehler', namespaces).text
+    nenner = flurstueck.find('.//adv:nenner', namespaces)
+    flurstnr = create_flurstnr(zaehler, nenner.text if nenner is not None else None)
+
+    # Gemeindeschlüssel extraction
+    gemeindekennzeichen = flurstueck.find('.//adv:AX_Gemeindekennzeichen', namespaces)
+    if gemeindekennzeichen is not None:
+        land = gemeindekennzeichen.find('.//adv:land', namespaces).text
+        kreis = gemeindekennzeichen.find('.//adv:kreis', namespaces).text
+        regierungsbezirk = gemeindekennzeichen.find('.//adv:regierungsbezirk', namespaces).text
+        gemeinde_code = gemeindekennzeichen.find('.//adv:gemeinde', namespaces).text
+        gmdschl = create_gmdschl(land, regierungsbezirk, kreis, gemeinde_code)
+    else:
+        gmdschl = None
+        land = None
+        regierungsbezirk = None
+        gemeinde_code = None
+
+    # Use the lookup dictionaries for faster data retrieval
+    merged_value = f"{land}{regierungsbezirk}{kreis}"
+    kreis_bezeichnung = lookup_dicts['kreis'].get(merged_value, "<null>")
+
+    regbezirk_key = f"{land}{regierungsbezirk}" if land and regierungsbezirk else None
+    regbezirk_bezeichnung = lookup_dicts['regbezirk'].get(regbezirk_key, "<null>")
+
+    gemeinde = lookup_dicts['gemeinde'].get(merged_value + gemeinde_code, "<null>") if gemeindekennzeichen is not None else "<null>"
+    land_name = lookup_dicts['land'].get(land, "<null>") if land else "<null>"
+    
+    gemarkungsnummer = flurstueck.find('.//adv:AX_Gemarkung_Schluessel/adv:gemarkungsnummer', namespaces)
+    gemarkung = lookup_dicts['gemarkung'].get(f"{land}{gemarkungsnummer.text}", "<null>") if land is not None and gemarkungsnummer is not None else "<null>"
+
+    # Extract lagebeztxt using the lookup dictionary
+    weist_auf = flurstueck.find('.//adv:weistAuf[@xlink:href]', namespaces)
+    zeigt_auf = flurstueck.find('.//adv:zeigtAuf[@xlink:href]', namespaces)
+    
+    if weist_auf is not None:
+        href = weist_auf.get('{http://www.w3.org/1999/xlink}href')
+        lagebeztxt = lookup_dicts['lagebeztxt'].get(href.split(":")[-1], "<null>")
+    elif zeigt_auf is not None:
+        href = zeigt_auf.get('{http://www.w3.org/1999/xlink}href')
+        lagebeztxt = lookup_dicts['lagebeztxt'].get(href.split(":")[-1], "<null>")
+    else:
+        lagebeztxt = "<null>"
+
+    # Return the extracted data as a dictionary
+    return {
+        'geometry': polygon,
+        'flaeche': flaeche,
+        'flstkennz': flstkennz,
+        'flur': 'Flur',
+        'flurstnr': flurstnr,
+        'gmdschl': gmdschl,
+        'regbezirk': regbezirk_bezeichnung,
+        'kreis': kreis_bezeichnung,
+        'gemeinde': gemeinde,
+        'land': land_name,
+        'gemarkung': gemarkung,
+        'lagebeztxt': lagebeztxt
+    }
+
+# Process all AX_Flurstueck tags with optimizations
+def process_flurstueck(root):
+    namespaces = {'gml': 'http://www.opengis.net/gml/3.2',
+                  'adv': 'http://www.adv-online.de/namespaces/adv/gid/6.0',
+                  'xlink': 'http://www.w3.org/1999/xlink'}
+    
+    # Create lookup dictionaries
+    lookup_dicts = {
+        'kreis': find_kreis(root, namespaces),
+        'regbezirk': find_regbezirk(root, namespaces),
+        'gemeinde': create_lookup_dict(root, 'AX_Gemeinde', './/adv:schluesselGesamt', './/adv:bezeichnung', namespaces),
+        'land': create_lookup_dict(root, 'AX_Bundesland', './/adv:schluesselGesamt', './/adv:bezeichnung', namespaces),
+        'gemarkung': create_lookup_dict(root, 'AX_Gemarkung', './/adv:schluesselGesamt', './/adv:bezeichnung', namespaces),
+        'lagebeztxt': create_lagebeztxt_dict(root, namespaces)
+    }
+    
+    # Use multiprocessing to process Flurstueck elements in parallel
+    with mp.Pool() as pool:
+        data = pool.starmap(
+            process_single_flurstueck,
+            [(flurstueck, namespaces, lookup_dicts) for flurstueck in root.findall('.//adv:AX_Flurstueck', namespaces)]
+        )
+    
+    return data
+
+# Main function
+def main(xml_file, output_shapefile):
+    start_time = time.time()
+    root = parse_xml(xml_file)
+    data = process_flurstueck(root)
+    
+    # Create a GeoDataFrame
+    gdf = gpd.GeoDataFrame(data)
+    gdf.set_crs(epsg=25832, inplace=True)  # Set appropriate CRS
+    
+    # Save to a shapefile
+    gdf.to_file(output_shapefile, driver='ESRI Shapefile')
+    
+    # Save the .prj file with the specified projection
+    prj_content = ('PROJCS["ETRS89 / UTM zone 32N",'
+                   'GEOGCS["ETRS89",'
+                   'DATUM["European_Terrestrial_Reference_System_1989",'
+                   'SPHEROID["GRS 1980",6378137,298.257222101]],'
+                   'PRIMEM["Greenwich",0],'
+                   'UNIT["degree",0.0174532925199433]],'
+                   'PROJECTION["Transverse_Mercator"],'
+                   'PARAMETER["latitude_of_origin",0],'
+                   'PARAMETER["central_meridian",9],'
+                   'PARAMETER["scale_factor",0.9996],'
+                   'PARAMETER["false_easting",500000],'
+                   'PARAMETER["false_northing",0],'
+                   'UNIT["metre",1]]')
+    
+    prj_file = output_shapefile.replace('.shp', '.prj')
+    with open(prj_file, 'w') as prj:
+        prj.write(prj_content)
+    
+    end_time = time.time()
+    print(f"Processing complete. Shapefile saved as '{output_shapefile}'. Time taken: {end_time - start_time:.2f} seconds.")
+
+# Example usage
+if __name__ == "__main__":
+    xml_file = sys.argv[1]
+    output_shapefile = sys.argv[2]
+    main(xml_file, output_shapefile)

guby.py

@@ -0,0 +1,131 @@
+import xml.etree.ElementTree as ET
+import shapefile
+import sys
+
+# Input XML file
+input_xml = sys.argv[1]
+
+# Output shapefile
+output_shapefile = sys.argv[2]
+
+# Create shapefile writer
+w = shapefile.Writer(output_shapefile)
+w.autoBalance = 1
+
+# Define fields for shapefile
+w.field('gebnutzbez', 'C')      # Gebaeude Nutzung Bezeichnung
+w.field('funktion', 'C')        # Funktion value (mapped to text)
+w.field('fktkurz', 'C')         # Kurz Funktion (<null>)
+w.field('name', 'C')            # Name value
+w.field('anzahlgs', 'C')        # Anzahl der Oberirdischen Geschosse
+w.field('lagebeztxt', 'C')      # Lagebezeichnung text
+
+# Parse the XML file
+tree = ET.parse(input_xml)
+root = tree.getroot()
+
+# Namespace map
+ns = {'gml': 'http://www.opengis.net/gml/3.2',
+      'adv': 'http://www.adv-online.de/namespaces/adv/gid/6.0'}
+
+# Building function mapping
+funktion_mapping = {
+    '1000': 'Wohngebäude',
+    '2000': 'Gebäude für Wirtschaft oder Gewerbe',
+    '3000': 'Gebäude für öffentliche Zwecke',
+    '3020': 'Gebäude für Bildung und Forschung',
+    '2463': 'Garage',
+    '1610': 'Überdachung',
+    '2523': 'Umformer',
+    '1620': 'Treppe',
+    '9999': 'Sonstiges',
+    '1700': 'Mauer',
+    '3041': 'Kirche',
+    '3065': 'Kinderkrippe, Kindergarten, Kindertagesstätte',
+    '3043': 'Kapelle',
+    '3072': 'Feuerwehr'
+}
+
+# Helper function to extract polygon coordinates
+def extract_polygon(coords_text):
+    try:
+        coords = list(map(float, coords_text.split()))
+        return [(coords[i], coords[i+1]) for i in range(0, len(coords), 2)]
+    except Exception as e:
+        print(f"Error parsing coordinates: {e}")
+        return None
+
+# Cache frequently accessed elements
+lagebezeichnung_cache = {}
+for lage_elem in root.findall('.//adv:AX_LagebezeichnungMitHausnummer', ns):
+    gml_id = lage_elem.attrib.get('{http://www.opengis.net/gml/3.2}id')
+    if gml_id:
+        unverschluesselt_elem = lage_elem.find('.//adv:lagebezeichnung/adv:AX_Lagebezeichnung/adv:unverschluesselt', ns)
+        hausnummer_elem = lage_elem.find('.//adv:hausnummer', ns)
+        unverschluesselt = unverschluesselt_elem.text if unverschluesselt_elem is not None else ''
+        hausnummer = hausnummer_elem.text if hausnummer_elem is not None else ''
+        lagebezeichnung_cache[gml_id] = f"{unverschluesselt} {hausnummer}".strip()
+
+# Process AX_Gebaeude and AX_SonstigesBauwerkOderSonstigeEinrichtung
+for gebaeude in root.findall('.//adv:AX_Gebaeude', ns) + root.findall('.//adv:AX_SonstigesBauwerkOderSonstigeEinrichtung', ns):
+    # Create 'gebnutzbez' value
+    gebnutzbez = 'Gebaeude' if gebaeude.tag == '{http://www.adv-online.de/namespaces/adv/gid/6.0}AX_Gebaeude' else 'Sonstiges Bauwerk Oder Sonstige Einrichtung'
+
+    # Extract and map 'funktion' value
+    funktion_elem = gebaeude.find('.//adv:gebaeudefunktion', ns)
+    if funktion_elem is None:
+        funktion_elem = gebaeude.find('.//adv:bauwerksfunktion', ns)
+    funktion = funktion_mapping.get(funktion_elem.text, 'Unbekannt') if funktion_elem is not None and funktion_elem.text else '<null>'
+
+    # Set 'fktkurz' to '<null>'
+    fktkurz = '<null>'
+
+    # Extract 'name' value
+    name_elem = gebaeude.find('.//adv:name', ns)
+    name = name_elem.text if name_elem is not None else '<null>'
+
+    # Extract 'anzahlDerOberirdischenGeschosse' value
+    anzahlgs_elem = gebaeude.find('.//adv:anzahlDerOberirdischenGeschosse', ns)
+    anzahlgs = anzahlgs_elem.text if anzahlgs_elem is not None else '<null>'
+
+    # Extract 'lagebeztxt' based on the 'zeigtAuf' reference
+    zeigtauf_elem = gebaeude.find('.//adv:zeigtAuf', ns)
+    lagebeztxt = '<null>'
+    if zeigtauf_elem is not None:
+        xlink_href = zeigtauf_elem.attrib.get('{http://www.w3.org/1999/xlink}href')
+        if xlink_href:
+            gml_id = xlink_href.split(':')[-1]
+            lagebeztxt = lagebezeichnung_cache.get(gml_id, '<null>')
+
+    # Extract coordinates for the polygon
+    pos_list = gebaeude.findall('.//gml:posList', ns)
+    polygon_coords = []
+    if pos_list:
+        for pos in pos_list:
+            coords = extract_polygon(pos.text)
+            if coords:
+                polygon_coords.extend(coords)
+
+    if polygon_coords:
+        # Add polygon and record to shapefile
+        w.poly([polygon_coords])
+        w.record(gebnutzbez, funktion, fktkurz, name, anzahlgs, lagebeztxt)
+
+# Save shapefile
+w.close()
+
+# Define spatial reference (projection file)
+with open(output_shapefile.replace('.shp', '.prj'), 'w') as prj_file:
+    prj_file.write('PROJCS["ETRS89 / UTM zone 32N",'
+                   'GEOGCS["ETRS89",'
+                   'DATUM["European_Terrestrial_Reference_System_1989",'
+                   'SPHEROID["GRS 1980",6378137,298.257222101]],'
+                   'PRIMEM["Greenwich",0],'
+                   'UNIT["degree",0.0174532925199433]],'
+                   'PROJECTION["Transverse_Mercator"],'
+                   'PARAMETER["latitude_of_origin",0],'
+                   'PARAMETER["central_meridian",9],'
+                   'PARAMETER["scale_factor",0.9996],'
+                   'PARAMETER["false_easting",500000],'
+                   'PARAMETER["false_northing",0],'
+                   'UNIT["metre",1]]')

kat.py

@@ -0,0 +1,92 @@
+import geopandas as gpd
+from shapely.ops import unary_union
+import shapefile
+from shapely.geometry import Polygon, MultiPolygon
+import sys
+
+# Input shapefile
+input_shapefile = sys.argv[1]
+
+# Output shapefile
+output_shapefile = sys.argv[2]
+
+# Step 1: Load the shapefile
+gdf = gpd.read_file(input_shapefile)
+
+# Step 2: Fix invalid geometries
+gdf['geometry'] = gdf['geometry'].buffer(0)
+
+# Step 3: Group by gemarkung and create exterior boundaries
+gemarkung_boundaries = {}
+gemarkung_data = {}
+for gemarkung, group in gdf.groupby('gemarkung'):
+    merged_polygon = unary_union(group.geometry)
+    if isinstance(merged_polygon, Polygon):
+        exterior_boundary = Polygon(merged_polygon.exterior)
+    elif isinstance(merged_polygon, MultiPolygon):
+        exterior_boundary = MultiPolygon([Polygon(poly.exterior) for poly in merged_polygon.geoms])
+    else:
+        print(f"Skipping invalid geometry for gemarkung: {gemarkung}")
+        continue
+    gemarkung_boundaries[gemarkung] = exterior_boundary
+    
+    # Store additional data for each gemarkung
+    sample_row = group.iloc[0]
+    gemarkung_data[gemarkung] = {
+        'gemeinde': sample_row['gemeinde'],
+        'schluessel': sample_row['flstkennz'].split('___')[0]
+    }
+
+# Step 4: Create a new shapefile with the exterior boundaries
+w = shapefile.Writer(output_shapefile)
+w.autoBalance = 1
+
+# Define fields for shapefile
+w.field('oid_1', 'C')
+w.field('art', 'C')
+w.field('name', 'C')
+w.field('schluessel', 'C')
+w.field('gemeinde', 'C')
+
+# Add geometries and attribute values to the shapefile
+for gemarkung, boundary in gemarkung_boundaries.items():
+    data = gemarkung_data[gemarkung]
+    
+    # Original record
+    if isinstance(boundary, Polygon):
+        w.poly([list(boundary.exterior.coords)])
+        w.record(f"DE{data['schluessel']}", 'Gemarkung', gemarkung, data['schluessel'], data['gemeinde'])
+    elif isinstance(boundary, MultiPolygon):
+        for poly in boundary.geoms:
+            w.poly([list(poly.exterior.coords)])
+            w.record(f"DE{data['schluessel']}", 'Gemarkung', gemarkung, data['schluessel'], data['gemeinde'])
+    
+    # Additional record
+    if isinstance(boundary, Polygon):
+        w.poly([list(boundary.exterior.coords)])
+        w.record(f"DE{data['schluessel']}000", 'Gemarkungsteil / Flur', 'Flur', f"{data['schluessel']}00", data['gemeinde'])
+    elif isinstance(boundary, MultiPolygon):
+        for poly in boundary.geoms:
+            w.poly([list(poly.exterior.coords)])
+            w.record(f"DE{data['schluessel']}000", 'Gemarkungsteil / Flur', 'Flur', f"{data['schluessel']}00", data['gemeinde'])
+
+# Define spatial reference (projection file)
+with open(output_shapefile.replace('.shp', '.prj'), 'w') as prj_file:
+    prj_file.write('PROJCS["ETRS89 / UTM zone 32N",'
+                   'GEOGCS["ETRS89",'
+                   'DATUM["European_Terrestrial_Reference_System_1989",'
+                   'SPHEROID["GRS 1980",6378137,298.257222101]],'
+                   'PRIMEM["Greenwich",0],'
+                   'UNIT["degree",0.0174532925199433]],'
+                   'PROJECTION["Transverse_Mercator"],'
+                   'PARAMETER["latitude_of_origin",0],'
+                   'PARAMETER["central_meridian",9],'
+                   'PARAMETER["scale_factor",0.9996],'
+                   'PARAMETER["false_easting",500000],'
+                   'PARAMETER["false_northing",0],'
+                   'UNIT["metre",1]]')
+
+# Save the shapefile
+w.close()
+
+print(f"Shapefile '{output_shapefile}' created successfully with exterior boundaries and additional fields.")

main.py

@@ -0,0 +1,42 @@
+import subprocess
+import time
+
+def run_script(script_name, *args):
+    command = ['python', script_name] + list(args)
+    start_time = time.time()
+    result = subprocess.run(command, capture_output=True, text=True)
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    if result.returncode != 0:
+        print(f"Error running {script_name}: {result.stderr}")
+    else:
+        print(f"Successfully ran {script_name} in {elapsed_time:.2f} seconds")
+    return elapsed_time
+
+if __name__ == "__main__":
+    # Define file paths
+    xml_file = "1546621_0.xml"
+    bez_dict_file = "bez_dict.json"
+    flurstueck_shapefile = "flurstueck.shp"
+    nutzung_shapefile = "nutzung.shp"
+    nutzung_flurstueck_shapefile = "nutzungFlurstueck.shp"
+    gebauede_bauwerk_shapefile = "gebauedeBauwerk.shp"
+    verwaltungs_einheit_shapefile = "verwaltungsEinheit.shp"
+    kataster_bezirk_shapefile = "katasterBezirk.shp"
+
+    # Track total execution time
+    total_start_time = time.time()
+
+    # Run scripts in the correct order
+    total_time = 0
+    total_time += run_script('flurstueck.py', xml_file, flurstueck_shapefile)
+    total_time += run_script('nutzung.py', xml_file, bez_dict_file, nutzung_shapefile)
+    total_time += run_script('nutflu.py', flurstueck_shapefile, nutzung_shapefile, nutzung_flurstueck_shapefile)
+    total_time += run_script('guby.py', xml_file, gebauede_bauwerk_shapefile)
+    total_time += run_script('ver.py', flurstueck_shapefile, xml_file, verwaltungs_einheit_shapefile)
+    total_time += run_script('kat.py', flurstueck_shapefile, kataster_bezirk_shapefile)
+
+    total_end_time = time.time()
+    total_elapsed_time = total_end_time - total_start_time
+
+    print(f"Total execution time: {total_elapsed_time:.2f} seconds")

nutflu.py

@@ -0,0 +1,29 @@
+import geopandas as gpd
+import sys
+
+def clean_geometries(gdf):
+    # Check and fix invalid geometries
+    gdf['geometry'] = gdf['geometry'].buffer(0)  # This can help fix some topology issues
+    gdf = gdf[gdf.is_valid]  # Remove invalid geometries
+    return gdf
+
+def union_shapefiles(shapefile1, shapefile2, output_shapefile):
+    gdf1 = gpd.read_file(shapefile1)
+    gdf2 = gpd.read_file(shapefile2)
+
+    # Clean geometries
+    gdf1 = clean_geometries(gdf1)
+    gdf2 = clean_geometries(gdf2)
+
+    # Perform the union
+    union_gdf = gpd.overlay(gdf1, gdf2, how='union')
+
+    # Save the result to a new shapefile
+    union_gdf.to_file(output_shapefile)
+
+# Example usage
+if __name__ == "__main__":
+    shapefile1 = sys.argv[1]
+    shapefile2 = sys.argv[2]
+    output_shapefile = sys.argv[3]
+    union_shapefiles(shapefile1, shapefile2, output_shapefile)

nutzung.py

@@ -0,0 +1,115 @@
+import xml.etree.ElementTree as ET
+import shapefile
+import json
+import re
+import codecs
+from shapely.geometry import Polygon, MultiPolygon
+import sys
+
+# Input XML file
+input_xml = sys.argv[1]
+
+# Input JSON file for bez_dict
+bez_dict_file = sys.argv[2]
+
+# Output shapefile
+output_shapefile = sys.argv[3]
+
+# Load bez_dict from JSON file
+with codecs.open(bez_dict_file, 'r', encoding='utf-8') as f:
+    bez_dict = json.load(f)
+
+# Create shapefile writer
+w = shapefile.Writer(output_shapefile)
+w.autoBalance = 1
+
+# Define fields for shapefile
+w.field('nutzart', 'C')       # Nutzart as string
+w.field('bez', 'C')           # BEZ as string
+w.field('name', 'C')          # NAME as string
+
+# Parse the XML file
+tree = ET.parse(input_xml)
+root = tree.getroot()
+
+# List of tag names to process
+tags_to_process = [
+    "AX_Gehoelz", "AX_Wohnbauflaeche", "AX_UnlandVegetationsloseFlaeche",
+    "AX_Strassenverkehr", "AX_StehendesGewaesser", "AX_SportFreizeitUndErholungsflaeche",
+    "AX_Platz", "AX_Landwirtschaft", "AX_IndustrieUndGewerbeflaeche", 
+    "AX_Fliessgewaesser", "AX_FlaecheGemischterNutzung", "AX_Wald", "AX_Weg", "AX_Friedhof",
+    "AX_FlaecheBesondererFunktionalerPraegung", "AX_Bahnverkehr"
+]
+
+# Helper function to extract coordinates and create Polygon
+def extract_polygon(coords_text):
+    coords = list(map(float, coords_text.split()))
+    return [(coords[i], coords[i+1]) for i in range(0, len(coords), 2)]
+
+# Helper function to format nutzart
+def format_nutzart(tag):
+    # Remove 'AX_' prefix and add spaces before capital letters
+    return ' '.join(re.findall('[A-Z][^A-Z]*', tag[3:]))
+
+# Helper function to extract bez value
+def extract_bez(elem):
+    funktion_elem = elem.find('.//{http://www.adv-online.de/namespaces/adv/gid/6.0}funktion')
+    vegetationsmerkmal_elem = elem.find('.//{http://www.adv-online.de/namespaces/adv/gid/6.0}vegetationsmerkmal')
+    
+    if funktion_elem is not None:
+        return bez_dict.get(funktion_elem.text, "<null>")
+    elif vegetationsmerkmal_elem is not None:
+        return bez_dict.get(vegetationsmerkmal_elem.text, "<null>")
+    else:
+        return "<null>"
+
+# Process the elements
+for tag_name in tags_to_process:
+    for elem in root.findall(f".//{{http://www.adv-online.de/namespaces/adv/gid/6.0}}{tag_name}"):
+
+        # Format nutzart
+        nutzart = format_nutzart(tag_name)
+
+        # Extract bez
+        bez = extract_bez(elem)
+
+        # Extract name
+        name_elem = elem.find('.//{http://www.adv-online.de/namespaces/adv/gid/6.0}name')
+        name = name_elem.text if name_elem is not None else "<null>"
+
+        # Extract coordinates for polygon
+        coordinates = elem.findall('.//{http://www.opengis.net/gml/3.2}posList')
+        if coordinates:
+            polygon_coords = []
+            for coord_elem in coordinates:
+                polygon_coords.extend(extract_polygon(coord_elem.text))
+            
+            # Create a Shapely polygon and fix invalid geometries
+            try:
+                poly = Polygon(polygon_coords)
+                if not poly.is_valid:
+                    poly = poly.buffer(0)
+                
+                if isinstance(poly, Polygon):
+                    w.poly([list(poly.exterior.coords)])
+                elif isinstance(poly, MultiPolygon):
+                    for p in poly.geoms:
+                        w.poly([list(p.exterior.coords)])
+                
+                # Add record to shapefile
+                w.record(nutzart, bez, name)
+            except Exception as e:
+                print(f"Error processing polygon: {e}")
+
+# Save shapefile
+w.close()
+
+print("Shapefile created successfully.")
+
+# Create .prj file
+prj = open(output_shapefile.replace('.shp', '.prj'), "w")
+epsg = 'PROJCS["ETRS89 / UTM zone 32N",GEOGCS["ETRS89",DATUM["European_Terrestrial_Reference_System_1989",SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6258"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4258"]],PROJECTION["Transverse_Mercator"],PARAMETER["latitude_of_origin",0],PARAMETER["central_meridian",9],PARAMETER["scale_factor",0.9996],PARAMETER["false_easting",500000],PARAMETER["false_northing",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["Easting",EAST],AXIS["Northing",NORTH],AUTHORITY["EPSG","25832"]]'
+prj.write(epsg)
+prj.close()
+
+print("Shapefile and .prj file created successfully.")

requirements.txt

@@ -0,0 +1,77 @@
+aiofiles==23.2.1
+altgraph==0.17.4
+annotated-types==0.7.0
+anyio==4.6.0
+attrs==24.2.0
+certifi==2024.8.30
+charset-normalizer==3.3.2
+click==8.1.7
+click-plugins==1.1.1
+cligj==0.7.2
+colorama==0.4.6
+contourpy==1.3.0
+cycler==0.12.1
+fastapi==0.115.0
+ffmpy==0.4.0
+filelock==3.16.1
+fiona==1.10.0
+fonttools==4.53.1
+fsspec==2024.9.0
+GDAL==3.9.2
+geopandas==1.0.1
+gradio==4.44.0
+gradio_client==1.3.0
+h11==0.14.0
+httpcore==1.0.5
+httpx==0.27.2
+huggingface-hub==0.25.0
+idna==3.10
+importlib_resources==6.4.5
+Jinja2==3.1.4
+kiwisolver==1.4.7
+lxml==5.3.0
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.9.2
+mdurl==0.1.2
+numpy @ file:///D:/bld/numpy_1725411960638/work/dist/numpy-2.1.1-cp312-cp312-win_amd64.whl#sha256=e94e5df6c5700d841731b7e98583918f6096aee8c7f282eddef410fb039b3879
+orjson==3.10.7
+packaging==24.1
+pandas==2.2.2
+pefile==2024.8.26
+pillow==10.4.0
+psutil==6.0.0
+pydantic==2.9.2
+pydantic_core==2.23.4
+pydub==0.25.1
+Pygments==2.18.0
+pyinstaller==6.10.0
+pyinstaller-hooks-contrib==2024.8
+pyogrio==0.9.0
+pyparsing==3.1.4
+pyproj==3.6.1
+pyshp==2.3.1
+python-dateutil==2.9.0.post0
+python-multipart==0.0.10
+pytz==2024.2
+pywin32-ctypes==0.2.3
+PyYAML==6.0.2
+requests==2.32.3
+rich==13.8.1
+ruff==0.6.7
+semantic-version==2.10.0
+setuptools==72.1.0
+shapely==2.0.6
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+starlette==0.38.6
+tomlkit==0.12.0
+tqdm==4.66.5
+typer==0.12.5
+typing_extensions==4.12.2
+tzdata==2024.1
+urllib3==2.2.3
+uvicorn==0.30.6
+websockets==12.0
+wheel==0.43.0

ver.py

@@ -0,0 +1,159 @@
+import geopandas as gpd
+from shapely.ops import unary_union
+import xml.etree.ElementTree as ET
+import shapefile
+from shapely.geometry import Polygon, MultiPolygon
+import sys
+
+# Input shapefile
+input_shapefile = sys.argv[1]
+
+# Input XML file
+input_xml = sys.argv[2]
+
+# Output shapefile
+output_shapefile = sys.argv[3]
+
+# Create shapefile writer for the output
+w = shapefile.Writer(output_shapefile)
+w.autoBalance = 1
+
+# Step 1: Load the shapefile and get the merged polygon with exterior boundary
+gdf = gpd.read_file(input_shapefile)
+
+# Step 1.1: Identify and fix invalid geometries
+gdf['valid'] = gdf.is_valid
+
+# Print invalid geometries
+invalid_geometries = gdf[~gdf['valid']]
+if not invalid_geometries.empty:
+    print(f"Invalid geometries found: {len(invalid_geometries)}. Attempting to fix them.")
+
+# Fix invalid geometries using buffer(0)
+gdf['geometry'] = gdf['geometry'].buffer(0)
+
+# Combine all polygons into one using unary_union
+merged_polygon = unary_union(gdf.geometry)
+
+# Step 1.2: Check if merged_polygon is a MultiPolygon or a single Polygon
+if isinstance(merged_polygon, Polygon):
+    exterior_boundaries = [merged_polygon.exterior]
+elif isinstance(merged_polygon, MultiPolygon):
+    exterior_boundaries = [poly.exterior for poly in merged_polygon.geoms]
+else:
+    raise TypeError("Resulting geometry is neither a Polygon nor a MultiPolygon.")
+
+# Define fields for shapefile
+w.field('art', 'C')          # Type of tag (Gemeinde, Bundesland, etc.)
+w.field('name', 'C')         # Name value
+w.field('schluessel', 'C')   # Schlüssel value
+w.field('uebaname', 'C')     # Uebaname value
+w.field('ueobjekt', 'C')     # Ueobjekt value
+
+# Parse the XML file
+tree = ET.parse(input_xml)
+root = tree.getroot()
+
+# Namespace map
+ns = {'gml': 'http://www.opengis.net/gml/3.2',
+      'adv': 'http://www.adv-online.de/namespaces/adv/gid/6.0'}
+
+# Store the tag names
+tag_names = {
+    'AX_Gemeinde': 'Gemeinde',
+    'AX_Bundesland': 'Bundesland',
+    'AX_Regierungsbezirk': 'Regierungsbezirk',
+    'AX_KreisRegion': 'Kreis / kreisfreie Stadt'
+}
+
+# Track if "Gemeinde" and "Kreis / kreisfreie Stadt" have already been added
+first_gemeinde_added = False
+first_kreis_added = False
+
+# Helper function to extract polygon coordinates
+def extract_polygon(coords_text):
+    try:
+        coords = list(map(float, coords_text.split()))
+        return [(coords[i], coords[i+1]) for i in range(0, len(coords), 2)]
+    except Exception as e:
+        print(f"Error parsing coordinates: {e}")
+        return None
+
+# Step 3: Add the extracted XML data to the shapefile along with the exterior boundary from the polygon
+tags = ['AX_Gemeinde', 'AX_Bundesland', 'AX_Regierungsbezirk', 'AX_KreisRegion']
+data = {}
+
+for tag in tags:
+    for element in root.findall(f'.//adv:{tag}', ns):
+        tag_name = tag_names.get(tag, '<null>')
+        name_elem = element.find('.//adv:bezeichnung', ns)
+        name = name_elem.text if name_elem is not None else '<null>'
+        
+        schluessel_elem = element.find('.//adv:schluesselGesamt', ns)
+        schluessel = schluessel_elem.text if schluessel_elem is not None else '<null>'
+        
+        # Define uebaname based on tag
+        if tag == 'AX_Gemeinde':
+            uebaname = data.get('AX_KreisRegion', {}).get('name', '<null>')
+        elif tag == 'AX_Bundesland':
+            uebaname = '<null>'
+        elif tag == 'AX_Regierungsbezirk':
+            uebaname = data.get('AX_Bundesland', {}).get('name', '<null>')
+        elif tag == 'AX_KreisRegion':
+            uebaname = data.get('AX_Regierungsbezirk', {}).get('name', '<null>')
+        
+        # Define ueobjekt based on schluessel
+        if tag == 'AX_Gemeinde':
+            ueobjekt = f"DE{schluessel[:5]}"
+        elif tag == 'AX_Bundesland':
+            ueobjekt = '<null>'
+        elif tag == 'AX_Regierungsbezirk':
+            ueobjekt = '<null>'
+        elif tag == 'AX_KreisRegion':
+            ueobjekt = f"DE{schluessel[:3]}"
+        
+        data[tag] = {'name': name, 'schluessel': schluessel}
+        
+        # Skip if first Gemeinde or Kreis / kreisfreie Stadt has already been added
+        if (tag == 'AX_Gemeinde' and first_gemeinde_added) or (tag == 'AX_KreisRegion' and first_kreis_added):
+            continue
+
+        # Set flags after first Gemeinde or Kreis / kreisfreie Stadt is added
+        if tag == 'AX_Gemeinde':
+            first_gemeinde_added = True
+        elif tag == 'AX_KreisRegion':
+            first_kreis_added = True
+
+        print("="*50)
+        print(tag_name)
+        print(name)
+        print(schluessel)
+        print(uebaname)
+        print(ueobjekt)
+        print("="*50)
+        
+        # Add record to shapefile (with the tag data)
+        w.record(tag_name, name, schluessel, uebaname, ueobjekt)
+
+# Step 4: Add the exterior boundaries to the shapefile
+for boundary in exterior_boundaries:
+    w.poly([list(boundary.coords)])
+
+# Define spatial reference (projection file)
+with open(output_shapefile.replace('.shp', '.prj'), 'w') as prj_file:
+    prj_file.write('PROJCS["ETRS89 / UTM zone 32N",'
+                   'GEOGCS["ETRS89",'
+                   'DATUM["European_Terrestrial_Reference_System_1989",'
+                   'SPHEROID["GRS 1980",6378137,298.257222101]],'
+                   'PRIMEM["Greenwich",0],'
+                   'UNIT["degree",0.0174532925199433]],'
+                   'PROJECTION["Transverse_Mercator"],'
+                   'PARAMETER["latitude_of_origin",0],'
+                   'PARAMETER["central_meridian",9],'
+                   'PARAMETER["scale_factor",0.9996],'
+                   'PARAMETER["false_easting",500000],'
+                   'PARAMETER["false_northing",0],'
+                   'UNIT["metre",1]]')
+
+# Save the shapefile
+w.close()