Fortgeschrittener QGIS-Analyst

Bevor wir loslegen sollten wir uns darüber Gedanken machen, in welchem Koordinatensystem wir arbeiten werden. Im Projektverlauf sollten wir dann penibel darauf achten, dass ALLE unsere Daten in diesem Koordinatensystem vorliegen. Sollte das nicht der Fall sein, müssen wir sie ggf. neu projezieren. In unseren Breiten empfiehlt es sich das Koordinatensystem UTM Zone 32 mit dem EPSG-Code 25832 zu verwendet. Vorteile dieses Koordinatensystems sind, dass es international kompatibel ist, in unseren Untersuchungsgebieten wenige Verzerrungen verursacht und die Strecken in Meter gemessen werden. Dies ist auch die Empfehlung des Landes.

Wir legen also ein neues Projekt an. Dazu öffnen wir QGIS und klicken links oben auf (Neues Projekt Strg+N).

Anschließend öffnen wir die Projekteigenschaften, indem wir auf Projekt --> Eigenschaften klicken (alternativ mit der Tastenkombination Strg+Umsch+P).

Im Reiter KBS tippen wir bei Filter den Text 25832 ein.

Durch die Verwendung des EPSG-Codes wird eindeutig EIN Koordinatensystem gefunden. Dieses klicken wir das Icon an und anschließend auf OK.

Tipp: Koordinatensysteme NIEMALS über den Namen suchen oder definieren.

Alternativ lässt sich das Koordinatensystem des Projektes über die Statusleiste am rechten unteren Rand einstellen. Dazu klicken wir einfach auf den EPSG-Code des gerade verwendete Koordinatensystems, der rechts unten angezeigt wird.

An dieser Stelle sollten wir unser Projekt das erste Mal speichern, indem wir in der Werkzeugleiste auf (Speichern als… Strg+Umsch+S) klicken, einen Speicherort wählen und einen sinnigen Namen (ohne Sondern- und Leerzeichen) vergeben.

Tipp: Wir haben die Wahl ob wir das klassische Format für Projektdateien mit der Dateierweiterung .qgs wählen. Alternativ können wir unser Projekt als .qgz-Datei speichern. Das ist ein gepacktes Format, was es erlaubt auch zusätzliche Dateien mitzuspeichern (bspw. Hilfstabellen, die die Platzierung von Beschriftungen erleichtern).

Der erste Schritt ist schon mal getan! Damit haben wir das Koordinatensystem mit Hilfe des EPSG-Codes definiert und dadurch den Grundstein für unser Projekt gelegt.

Den Gemeindeumriss beschaffen wir uns über ein Web Feature Service (WFS). Dazu besuchen wir die Internetseite open.nrw und geben den Suchbefehl Verwaltungsgrenzen ein. Wenn wir etwas herunterscrollen, finden wir den Datensatz Verwaltungsgebiete 1:250 000 – Stand 01.01. Wenn wir auf diesen Datensatz klicken, können wir unten die URL des WFS-Dienstes abrufen, indem wir auf klicken und anschließend die URL aus der Adresszeile des Browsers herauskopieren. Sie lautet wie folgt:

http://sg.geodatenzentrum.de/wfs_vg250?REQUEST=GetCapabilities&SERVICE=WFS

Eigentlich brauchen wir aber nur den Teil vor dem Fragezeichen:

http://sg.geodatenzentrum.de/wfs_vg250

In QGIS klicken wir in der oberen Werkzeugleiste auf , um die Datenquellenverwaltung zu öffnen.

Tipp: Mit der Tastenkombination Strg+L können wir noch schneller die Datenquellenverwaltung öffnen, um ganz flink einen Layer hinzuzufügen.

Alternativ können wir die Datenquellen-Werkzeugleiste an der linken Seite einblenden. Dazu klicken wir indem entweder auf eine leere Stelle in der Werkzeugleiste und setzen dann ein Häkchen bei Layerverwaltungswerkzeugleiste. Oder wir klicken in der Menü-Leiste auf Ansicht à Werkzeugkästen à Layerverwaltungswerkzeugleiste.

In dem sich öffnenden Fenster klicken wir im Reiter WFS auf Neu. Wir nennen den neuen Dienst Verwaltungsgrenzen und kopieren die URL in die Zeile darunter.

Tipp: Es gibt Dienste, die nicht komplett frei verfügbar sind, sondern die eine Authentifizierung erfordern. Einstellung für solche Dienste können wir vornehmen, indem wir auf Basic klicken und Benutzername und Passwort eingeben. Allerdings wird von dieser sehr einfachen Authentifizierungsmethode abgeraten, da der gespeicherte Klartext anfällig für Cyberangriffe ist. Besser ist es, im Reiter Konfiguration auf (Neue Authentifikationskonfiguration anlegen) zu klicken und hier eine der möglichen Authentifikationsmethoden einzustellen. Die Zugangsdaten werden in QGIS mit dem Profil verschlüsselt gespeichert, sodass man nicht jedes Mal, wenn man einen Dienst nutzen will, das Passwort eingeben muss.

Nachdem wir auf OK geklickt haben, wählen wir aus dem Drop-Down-Menü unseren neuen Dienst und klicken auf Verbinden. Jetzt können wir sehen, welche Layer der Dienst anbietet. Wir wählen den Layer Gemeinde und klicken anschließend auf Hinzufügen und Schließen.

In der Attributtabelle des Dienstes (Rechtsklick à Attributtabelle öffnen, in der Werkzeugleiste auf klicken oder F6 drücken) können wir sehen, dass im Feld GEN die Namen der Kommunen gespeichert sind. Wir wollen beispielhaft unsere Analyse für die Stadt Bergheim durchführen.

Wir öffnen das SQL-Auswahlfenster, indem wir entweder in der Menüleiste oder in den Attributtabelle auf (Objekte über Ausdruck wählen Strg+F3) klicken. Im sich öffnenden Fenster klicken wir auf Felder und Werte und danach doppelt auf GEN. Anschließend klicken wir auf und danach auf Alle eindeutigen (Werte laden). In der Werte Suchen-Zeile geben wir Bergheim ein und klicken anschließend doppelt auf den Eintrag Bergheim. Der vollständige SQL-Befehl sollte jetzt so aussehen:

"GEN" = 'Bergheim'

Anschließend klicken wir auf Objekt wählen und Schließen.

Jetzt müssen wir nur noch unser selektiertes Feature in eine eigene Datei schreiben. Dazu machen wir einen Rechtsklick auf den Layer vg250:vg250_gem und klicken danach auf Exportieren à Objekt speichern als… In dem sich öffnenden Fenster wählen wir unter Format die Option GeoPackage. Wir wählen einen Speicherort und nennen das neue GeoPackage Uebungsdaten.gpkg. Den ersten Layer, den wir in dieses GeoPackage speichern, nennen wir Bergheim. Ganz wichtig: Wir stellen das richtige Koordinatensystem ein, indem wir auf die kleine Weltkugel klicken, den EPSG-Code 25832 eingeben und anschließend auf das gefundene Koordinatensystem klicken (wenn wir nur Enter drücken, wird das Koordinatensystem nicht übernommen!). Als Kodierung wählen wir UTF-8 und setzten ein Häkchen bei Nur gewählte Objekte speichern (Sonst würden wir ja nicht unser Untersuchungsgebiet, sondern wieder ALLE Gemeinden Deutschlands speichern). Bevor wir weitermachen überprüfen wir, ob alle Einstellungen genauso aussehen, wie auf dem Screenshot (Koordinatensystem richtig? Häkchen richtig gesetzt? …)

Bevor wir weitermachen, sollten wir den Layer vg250:v250_gem aus unserem Projekt entfernen. Dieser WFS-Layer muss über das Internet aktualisiert und nachgeladen werden, was das Arbeiten stark entschleunigen könnte und wir benötigen ihn nicht mehr.

Wenn wir uns den Layer Uebungsdaten Bergheim einmal ansehen, stellen wir fest, dass es scheinbar ein zweites Bergheim in Deutschland gibt.

Da wir uns für das Bergheim in Nordrhein-Westfalen interessieren, entfernen wir die süd-östliche Gemeinde aus dem Layer. Dazu schalten wir in den Bearbeitungsmodus, indem wir in der Werkzeugleiste auf (Bearbeitungsmodus umschalten) klicken. Anschließend wählen wir die süd-östliche Gemeinde aus, indem wir in der Werkzeugleiste auf (Objekte über Rechteck oder Einzelklick wählen) und dann in der Kartenansicht auf die betreffende Gemeinde klicken. Um das markierte Objekt zu löschen, drücken wir die Entf-Taste auf der Tastatur. Abschließend verlassen wir den Bearbeitungsmodus durch einen erneuten Klicken auf in der Werkzeugleiste und speichern die Änderungen.

Gratulation! Damit können wir schon mal unser Untersuchungsgebiet abstecken. Dazu können wir Daten aus einem WFS-Dienst filtern und die Auswahl lokal in einem GeoPackage speichern.

Wir wollen die Erreichbarkeit der Kindergärten auf Wohngebäude beziehen. Dazu nutzen wir ALKIS-Daten, die wir, ähnlich wie im vorherigen Abschnitt, über einen WFS-Dienst beziehen werden. Wir besuchen wieder die Internetseite open.nrw und geben in die Suchleiste (Portal durchsuchen) das Schlagwort ALKIS ein. Wenn wir ein wenig runterscrollen finden wir den Datensatz ALKIS vereinfachtes Schema. Wir klicken auf diesen Datensatz und anschließend auf . Aus der Adressleiste unseres Browsers kopieren wir die URL bis zu dem Fragezeichen:

https://www.wfs.nrw.de/geobasis/wfs_nw_alkis_vereinfacht

Tipp: Für unsere Zwecke ist das vereinfachte ALKIS-Schema mehr als ausreichend. Wenn wir für andere Fragestellungen ALKIS-Daten mit vollständigem AAA-Schema benötigen, können wir den Link https://www.wfs.nrw.de/geobasis/wfs_nw_alkis_aaa-modell-basiert verwenden.

In QGIS klicken wir in der oberen Werkzeugleiste auf , um die Datenquellenverwaltung zu öffnen oder drücken Strg+L auf der Tastatur. Anschließend klicken wir im Reiter WFS auf Neu. Wir vergeben einen Namen für die neue Verbindung, bspw. ALKIS NRW vereinfacht, und fügen die kopierte URL ein.

Wir klicken auf OK und dann auf Verbinden. Spätestens jetzt sollten wir uns mit den Metadaten zu ALKIS befassen, um herauszufinden, wie wir an unsere Wohngebäude kommen können.

Hinweis: Der angeforderte WFS-Dienst liegt in Version 1.1.0 bzw. 2.0 vor. QGIS unterstützt diese WFS-Versionen erst ab Version 2.18.

Wir besuchen die Internetseite www.adv-online.de. Am linken Rand navigieren wir zu AAA®-Modell à ALKIS®. Im Text, am Ende des ersten Absatzes klicken wir auf den Link GeoInfoDok und auf der nachfolgenden Seite auf den Link zu aktuelle GeoInfoDok 6.0. Wenn wir runterscrollen finden wir als ersten Eintrag zu ALKIS den ALKIS®-Objektartenkatalog, den wir als PDF herunterladen.

Tipp: Wenn man in eine Suchmaschine GeoInfoDok ALKIS 6 eingibt, kommt man auch auf direktem Weg zur PDF.

In der PDF nutzen wir die Suchfunktion (Strg+F), um nach dem Teil-Schlagwort Wohngeb zu suchen. Wir sehen, dass die gesuchte Objektart AX_Gebaeude heißt, oder je nach Datenformat mit der Kennung 31001 angegeben wird. Das Attributfeld mit der Information, ob es sich um ein Wohngebäude handelt heißt GFK, was für gebaeudefunktion steht. Wir sehen auch, dass der Eintrag 1000, der für Wohngebäude steht, nicht der einzige Eintrag ist, den wir berücksichtigen sollten. Weitere Werte, die für unsere Fragestellung in Betracht kommen sind bspw. 1010 für Wohnhaus, 1020 für Wohnheim, usw.

Werfen wir noch einmal einen Blick auf die Layerübersicht des geladenen WFS-Dienstes in QGIS. Dort finden wir den gesuchten Layer als ave:GebaeudeBauwerk wieder, was im AAA-Schema der Objektart AX_Gebaeude entspricht. Da wir sehr große Datenmengen laden, ist es außerdem sinnvoll ein Häkchen bei Nur Objekte laden, die sich mit dem Kartenausschnitt überschneiden zu setzten, um nicht unnötige Daten zu laden, die weit außerhalb unseres Untersuchungsgebietes liegen. Natürlich sollten wir dann vorher auch sicherstellen, dass wir auf unsere Beispielgemeinde herangezoomt haben. Jetzt können wir die Gebäude durch einen Klick auf Hinzufügen in unser Projekt laden.

Da wir sehr große Datenmengen herunterladen kann dieser Schritt einen Moment dauern.

Wenn alle Daten geladen sind, machen wir einen Rechtsklick auf den Layer ave:GebaeudeBauwerk und klicken auf Exportieren --> Objekt speichern als…, um die gestreamten Daten lokal zu speichern.

In dem sich öffnenden Fenster geben wir an, dass unsere Gebäude-Daten im bereits bestehenden GeoPackage names Uebungsdaten.gpkg gespeichert werden sollen und vergeben einen Namen für den neuen Layer, bspw. AX_Gebaeude. Wir wählen, wie von nun an immer ; ) das richtige Koordinatensystem. Da wir nicht alle Daten des WFS-Layers benötigen (für ganz NRW!), setzten wir ein Häkchen bei Ausmaße (aktuell: Kartengrenzen) und klicken einmal auf Anzeigeausdehnung, was dafür sorgt, dass wir nur die Daten speichern, die wir gerade sehen. Anschließend klicken wir auf OK um die Daten lokal zu speichern.

Tipp: Man sollte generell die Layer, die man für’s Erste nicht mehr benötigt ausschalten und nur die Layer sichtbar machen, mit denen man gerade arbeitet. Das schafft Übersicht und beschleunigt die Reaktionszeit unseres Projektes. Im vorliegenden Fall ist es aber ganz besonders wichtig, dass wir den Layer ave:GebaeudeBauwerk ausschalten - oder noch besser: ganz aus dem Projekt entfernen - bevor wir weitermachen, weil dieser WFS-Layer aufgrund der großen Datenmenge, die aus dem Internet gestreamt wird, unser Projekt stark verlangsamt.

Wir haben nun die Gebäude-Daten für unser Untersuchungsgebiet beschafft. Jetzt müssen wir noch die Wohngebäude herausfiltern. Dazu klicken wir einmal den Layer AX_Gebaeude an und anschließend auf (Objekte über Ausdruck wählen Strg+F3). Im SQL-Auswahlfenster, was sich öffnet, klicken wir, wie im vorherigen Abschnitt, den Filterbefehl für Wohngebäude zusammen, wobei uns die Informationen aus der GeoInfoDok weiterhelfen. Wir wissen, dass die gesuchte Information in einem Feld gespeichert sein muss, was GFK, gebaeudefunktion oder wenigsten so ähnlich heißt (Stichwort Standards befolgen ; ) Wenn wir auf Felder und Werte klicken, sehen wir, dass das gesuchte Feld funktion heißt. Wenn wir doppelt auf dieses Feld klicken, dann auf und anschließend auf Alle eindeutigen (Werte laden), finden wir die Einträge wieder, die wir in der GeoInfoDok unter den Bezeichner gesehen hatten, bspw. den Eintrag Wohnhaus. Damit wir nicht zu viel Zeit mit dem Zusammenklicken des SQL-Befehls verbringen, können wir diesen Befehl auch aus der Datei ALKIS_Abfrage.sql im Ordner Zusatzdaten herauskopieren. Die Datei-Endung .sql zeigt an, dass es sich um ein SQL-Statement handelt. Es kann mit jedem beliebigen Text-Editor geöffnet werden. Das SQL-Statement lautet in diesem Fall:

"funktion" = 'Gemischt genutztes Gebäude mit Wohnen' OR

"funktion" = 'Wohn- und Betriebsgebäude' OR

"funktion" = 'Wohn- und Bürogebäude' OR

"funktion" = 'Wohn- und Geschäftsgebäude' OR

"funktion" = 'Wohn- und Wirtschaftsgebäude' OR

"funktion" = 'Wohngebäude' OR

"funktion" = 'Wohngebäude mit Gewerbe und Industrie' OR

"funktion" = 'Wohngebäude mit Handel und Dienstleistungen' OR

"funktion" = 'Wohnhaus' OR

"funktion" = 'Wohnheim' OR

"funktion" = 'Asylbewerberheim' OR

"funktion" = 'Bauernhaus' OR

"funktion" = 'Kinderheim' OR

"funktion" = 'Seniorenheim'

Nachdem wir den Ausdruck eingefügt haben, klicken wir auf Objekt wählen und anschließend auf Schließen.

Um die Auswahl in einen eigenen Layer zu speichern, machen wir einen Rechtsklick auf den Layer AX_Gebaeude und klicken auf Exportieren --> Objekt speichern als… (Objekte speichern unter…). Wir geben das bereits bestehende GeoPackge Uebungsdaten.gpgk als Dateinamen an und wählen einen Layernamen bspw. Wohngebaeude. Wir wählen das richtige Koordinatensystem mit EPSG-Code 25832 und setzen ein Häkchen bei nur gewählte Objekte speichern.

An dieser Stelle erscheint eine Fehlermeldung, die uns darüber informiert, dass wir einen Layer aus einem GeoPackage nicht in das gleiche GeoPackage hineinspeichern können.

Wir müssen also ein wenig tiefer in die Trickkiste greifen und statt dem schnellen Export von Layern, eine etwas professionellere Methode wählen, nämlich den Datenbank-Manager.

Dazu stellen wir zunächst eine Datenbank-Verbindung zu unserem GeoPackage her. Im QGIS-Browser navigieren wir zum GeoPackage namens Uebungsdaten.gpkg und machen einen Rechtsklick darauf. Anschließend klicken wir auf Verbindung hinzufügen.

Ab jetzt finden wir unser GeoPackage im Schnellzugriff des QGIS-Browsers unter GeoPackage --> Uebungsdaten.gpkg.

Tipp: Wenn wir jetzt Layer aus dieser Datenbank-Verbindung in unser Projekt laden, bekommen die Layernamen nicht mehr den Namen des GeoPackages (Uebungsdaten) als Namenspräfix vor dem eigentlichen Layer-Namen.

Jetzt öffnen wir den Datenbank-Manager, indem wir in der Menü-Leiste auf Datenbank --> DB Manager… klicken.

In dem sich öffnenden Fenster klicken wir auf GeoPackage --> Uebungsdaten.gpkg und dann auf Layer/Datei importieren…

Tipp: Ggf. müssen wir einen Doppelklick und dann einen Rechtsklick auf das GeoPackage Uebungsdaten.gpkg machen und dann auf Neu Verbinden klicken.

In dem sich öffnenden Fenster wählen wir den Layer Uebungsdaten AX_Gebaeude als Eingabe und setzten ein Häkchen bei Nur gewählte Objekte importieren, um nur die selektierten Wohngebäude zu berücksichtigen. Unter Ausgabetabelle tippen wir bei Tabelle einen sinnvollen Namen für den neuen Layer ein, bspw. Wohngebaeude. Da Koordinatensystem und Kodierung stimmen, lassen wir diese Einstellungen unverändert.

Wir klicken auf OK und warten einen Augenblick, bis alle Wohngebäude in das GeoPackage importiert wurden. Nachdem der Import erfolgreich war, fügen wir den neuen Layer namens Wohngebaeude unserem QGIS-Projekt hinzu.

Tipp: Den DB Manager können wir für den Schnellzugriff in der Werkzeug-Leiste verfügbar machen, indem wir einen Rechtsklick auf eine freie Stelle machen und dann ein Häkchen bei Datenbankwerkzeugleiste setzen.

Geschafft! Wir können uns Wohngebäude aus ALKIS beschaffen, indem wir einen WFS-Dienst laden, die Daten lokal speichern, filtern und schließlich in ein GeoPackage importieren.

Hallo und herzlich willkommen zu diesem QGIS Tipp. In diesem QGIS-Tipp gehen wir einfach mal hin und stellen mal unsere Benutzeroberfläche auf eine andere Sprache ein. Das ist relativ einfach. Ich arbeite ganz gerne immer auf der englischsprachigen Benutzeroberfläche. Das hat den folgenden Vorteil: Ich finde es gut, wenn ich in der Community eine Frage habe und das Problem in einem Forum oder Ähnlichem danach suche, dann weiß ich sofort wie die Funktion mit Fachbezeichnung auf Englisch heißt. Wenn ihr aber lieber auf Deutsch arbeiten wollt,  dann zeige ich euch jetzt einfach mal wie man das Ganze einstellt. Wie gesagt, es ist relativ einfach:

In der Menüleiste auf Settings --> Options --> General --> Override system locale --> User Interface Translation & Locale: Beides auf Deutsch einstellen, fertig!

Um eine Erreichbarkeitsanalyse durch das Fußwegenetz durchführen zu können, benötigen wir natürlich die Fußwege. Die Wege an sich (bspw. separat rechter und linker Bordstein) werden allerdings sehr selten erfasst, weswegen wir eine Annährung versuchen wollen, indem wir Straßen betrachten, von denen wir annehmen können, dass sie für Fußgänger geeignet sind. Die Daten dazu beschaffen wir uns von der OpenStreetMap, einer weltweiten ehrenamtlichen Initiative zur Sammlung und Bereitstellung freier und offener Geodaten.

Dazu besuchen wir die Internetseite www.openstreetmap.org. Im Suchfeld geben wir Bergheim ein. Wir suchen auf der linken Seite nach dem Bergheim, was wir meinen, nämlich das Bergheim im Rhein-Erft-Kreis in Nordrhein-Westfalen, klicken darauf und klicken anschließend links oben auf Export. Wenn wir unter dem Absatz Lizenz auf Export klicken, können wir die Daten aus dem aktuell angezeigten Abschnitt herunterladen. Leider funktioniert diese Funktion unter Umständen nicht. Glückerweise bietet uns OpenStreetMap mehrere Möglichkeiten für den Download der Daten an. Statt die Daten direkt von OpenStreetMap zu beziehen, haben wir bspw. die Möglichkeit verschiedene aufbereitete Auszüge des Gesamtdatensatzes herunterzuladen. Wir rufen solch einen Datenspiegel auf, indem wir auf Geofabrik Downloads klicken.

Auf der Seite der Geofabrik navigieren wir uns durch die räumlichen Einheiten Europe --> Germany --> Nordrhein-Westfalen --> Bezirksregierung Köln und klicken anschließend auf den Link zum Shapefile-Download.

Wir speichern die Daten an einen sinnvollen Ort und entpacken sie, indem wir mit der rechten Maustaste auf die .zip-Datei klicken und anschließend auf Hier entpacken klicken.

Hinweis: Je nach Archivierungsprogramm kann sich das Menü an dieser Stelle unterscheiden. Falls noch kein Archivierungsprogramm installiert ist, empfiehlt sich WinRAR oder 7-Zip, welche über Suchmaschinen gefunden und kostenlos installiert werden können.

Wir sehen jetzt, dass wir mehrere Shapefiles zur Verfügung haben. Ein Shapefile nennt sich gis.osm_roads_free_1.shp. Hieraus können wir schließen, dass es sich um die gesuchten Wege handelt. Wir laden dieses Shapefile in unser QGIS-Projekt.

Wir haben den Datensatz für den gesamten Regierungsbezirk Köln heruntergeladen. Um die anschließenden Bearbeitungsschritte zu beschleunigen wollen wir zunächst die Straßen filtern, die sich in und um Bergheim befinden. Dazu nutzen wir das Selektieren-Werkzeug aus der Werkzeugleiste und ziehen anschließend ein Rechteck um Bergheim.

Uns interessieren nur Straßen, die von Fußgängern benutzt werden können. Um diese Straßen zu filtern, nutzen wir die Attribute unserer Daten. Spätestens jetzt sollten wir uns mit den Metadaten unserer Daten befassen, also den Daten über Daten, die den Datensatz näher beschreiben.

Wir besuchen die Internetseite wiki.openstreetmap.org/wiki/DE:Map_Features. Hier können wir nachlesen, dass sich das Datenmodell von OpenStreetMap durch Punkte, Linien, Flächen, bzw. Knoten, Wege und Beziehungen aufbaut. Zusätzliche Informationen werden über sogenannte Schlüssel-Wert-Paare (Tags und Keys) vergeben. Wenn wir runterscrollen, sehen wir jede Menge Beispiele für solche Schlüssel-Wert-Paare und bekommen auch direkt ein Bild dazu, was uns dabei hilft zu verstehen, was mit den jeweiligen Attributierungen gemeint sein soll. Wir sehen bspw., dass highway = pedestrian offensichtlich eine Straße ist, die von Fußgängern genutzt werden kann.

Zurück in QGIS wollen wir diese Information nutzen, um alle Straßen und Wege aus der bereits bestehenden Auswahl zu entfernen, die nicht von Fußgängern genutzt werden können. Wenn wir die Attributtabelle von gis.osm_roads_free_1 öffnen, sehen wir, dass in unserem Datensatz das gesuchte Feld nicht highway sondern fclass heißt, die Werte aber so aussehen, wie wir es in den Metadaten gesehen haben. Wir selektieren die gesuchten Objekte durch einen SQL-Ausdruck, indem wir entweder oben in der Werkzeugleiste, oder in der Attributtabelle auf klicken. In dem sich öffnenden Ausdruck-Fenster klicken wir auf Felder und Werte und dann mit einem Doppelklick auf fclass. Anschließend klicken wir auf und dann auf Alle eindeutigen (Werte laden). In der Auswahl klicken wir dann doppelt auf den ersten Eintrag, von dem wir annehmen, dass er eine durch Fußgänger nutzbare Straße darstellt, bspw. footway (Fußweg). Wir wiederholen diese Prozedur für alle entsprechenden Einträge aus der Liste, wobei wir die einzelnen SQL-Statements durch ein OR voneinander trennen.

Frage: Was würde passieren, wenn wir die Auswahl in diesem Zustand durchführen würden?

Wir erinnern uns, dass wir schon alle Straßen und Wege in und um Bergheim ausgewählt haben. Aus dieser Auswahl wollen wir jetzt alle Objekte entfernen, die NICHT durch Fußgänger genutzt werden können. Das bedeutet, dass wir unser SQL-Statement rumdrehen müssen. Es bleiben dann nur noch die Wege übrig, die uns interessieren. Dazu schreiben wir vor dem Ausdruck eine sich öffnende und nach dem ganzen Ausdruck eine sich schließende Klammer. Dann schreiben wir ganz vorne, vor die sich öffnende Klammer, ein NOT. Das bewirkt, dass wir nach Objekten fragen, die NICHT in irgendeiner Weise Fußgängerwege darstellen. Diese Objekte wollen wir im nächsten Schritt von der bestehenden Auswahl abziehen.

Insgesamt sollte der Ausdruck jetzt so aussehen (Achtung: Danach noch nicht auf Objekte wählen klicken!):

NOT("fclass" = 'footway' OR "fclass" = 'living_street' OR

"fclass" = 'path' OR "fclass" = 'pedestrian' OR

"fclass" = 'residential' OR "fclass" = 'secondary' OR

"fclass" = 'secondary_link' OR "fclass" = 'steps' OR

"fclass" = 'tertiary' OR "fclass" = 'tertiary_link' OR

"fclass" = 'track' OR "fclass" ='track_grade1' OR

"fclass" = 'track_grade2' OR "fclass" = 'track_grade3' OR

"fclass" = 'track_grade4' OR "fclass" = 'track_grade5' OR

"fclass" = 'trunk' OR "fclass" = 'trunk_link' OR

"fclass" = 'unclassified' OR "fclass" = 'unknown')

Tipp: Wir können dieses recht lange SQL-Statement auch aus der Datei OSM_Select.sql im Ordner Zusatzdaten herauskopieren.

Um die besagten Objekte von der bereits bestehenden Auswahl abzuziehen, klicken wir auf den kleinen Pfeil neben Objekt wählen und dann auf Aus aktueller Auswahl entfernen. Anschließend klicken wir auf Schließen.

Jetzt müssen wir nur noch unsere ausgewählten Objekte in einen eigenen Layer im GeoPackage speichern. Dazu machen wir einen Rechtsklick auf den Layer gis.osm_roads_free_1 und klicken dann auf Exportieren à Objekt speichern als… Wir wählen das GeoPackage Uebungsdaten.gpkg nennen den neuen Layer Wegenetz und stellen das richtige Koordinatensystem mit EPSG-Code 25832 ein. Außerdem setzen wir natürlich ein Häkchen bei Nur gewählte Objekte speichern (sonst wäre ja die ganze Selektierung umsonst gewesen):

Hinweis: Grundsätzlich sind OpenStreetMap-Daten frei nutzbar. Allerdings sollte man beachten, dass man sie nicht mit sensiblen Daten mischen sollte. Hintergrund ist, dass die Nutzungsbedingungen der OpenStreetMap-Daten besagen, dass wenn sie mit anderen Daten gemeinsam genutzt, bzw. veröffentlicht werden, diese anderen Daten ebenfalls in OpenStreetMap eingepflegt werden sollen!

Gratulation! Wir können das Fußgängernetz aus OpenStreetMap-Daten selbstständig beschaffen und aufbereiten. Dazu können wir Daten von der Geofabrik herunterladen und anschließend räumlich - für das Untersuchungsgebiet - und thematisch - nach Fußgängerwegen - filtern.

Die Kindergärten wollen wir ebenfalls von OpenStreetMap beziehen. Hierbei werden wir aber einen zweiten, sehr bequemen Weg kennenlernen, um an die Daten zu kommen, nämlich direkt aus QGIS heraus. Dazu nutzen wir das Plug-In QuickOSM (schnelle OpenStreetMap-Daten).

Zunächst müssen wir die Erweiterung installieren. Dazu klicken wir in der oberen Menü-Leiste auf Erweiterungen --> Erweiterungen verwalten und installieren… In dem sich öffnenden Fenster tippen wir im Reiter Alle in der Suchleiste den Text osm ein. Es werden einige sehr hilfreichen Plug-Ins gefunden, die die Arbeit mit OpenStreetMap-Daten erleichtern. Wir klicken auf die Erweiterung QuickOSM und dann auf Erweiterung installieren. Nachdem das Plug-In installiert wurde, klicken wir auf Schließen.

Das wäre schon mal geschafft! Ab sofort finden wir das neue Werkzeug in der oberen Menü-Leiste unter Vektor --> Quick OSM --> QuickOSM.

Alternativ können wir es für den Schnellzugriff in der Werkzeug-Leiste sichtbar machen, indem wir auf einer freien Stelle in der Werkzeug-Leite einen Rechtsklick machen und dann ein Häkchen bei QuickOSM setzen.

Um die richtigen Einstellungen für dieses Werkzeug machen zu können, müssen wir uns noch einmal mit den Metadaten zu OpenStreetMap befassen. Diesmal wollen wir ganz konkret nach Kindergärten suchen, wozu wir die Internetseite tagfinder.herokuapp.com besuchen. Im Suchen-Fenster geben wir Kindergarten ein und drücken Enter. Unter den gefunden Treffern finden wir u.A. amenity = kindergarten, was sich auf Punkte bezieht, und buildung = kindergarten, was sich auf Flächen bezieht. Wir wollen für unsere Analyse die Punkte verwenden.

Tipp: Bei diesem Anwendungsbeispiel hatten wir ungeheures Glück, weil der deutsche Begriff Kindergarten zufälligerweise auf Englisch ebenfalls kindergarten heißt. Der TagFinder ist in der Lage, eine Übersetzung im Hintergrund vorzunehmen. Wenn wir bspw. den Begriff Bücherei eingeben, wird das Schüssel-Wert-Paar amenity=library gefunden. Sollte das aber mal nicht so gut funktionieren, sollten wir probieren, nach dem englischen Begriff zu suchen.

Jetzt, wo wir wissen, dass Kindergärten im OSM-Datenmodell mit dem Schlüssel-Wert-Paar amenity=kindergarten abgebildet werden, öffnen das QuickOSM-Werkzeug, indem wir entweder auf Vektor à Quick OSM à QuickOSM oder in der Werkzeugleiste auf (QuickOSM) klicken.

In dem sich öffnenden Werkzeug-Fenster wählen wir im Reiter Schnelle Abfrage unter Schlüssel die Option amenity und bei Wert den Eintrag kindergarten. Da uns nur Kindergärten im Untersuchungsgebiet interessieren (und nicht weltweit), wählen wir bei Layer Extent (Layer-Ausdehnung den Layer Bergheim, der die Gemeindegrenzen unseres Untersuchungsgebietes beinhaltet. Außerdem setzen wir im Abschnitt Weiteres die Häkchen so, dass wir nur Punkte (Points) und keine Linien oder Flächen (Lines, Multilinestrings, Multipolygons) abfragen.

Nachdem wir auf Ausführen geklickt haben, schließen wir das QuickOSM-Fenster und sehen, dass die Kindergärten aus den OSM-Daten als Punkte in unser QGIS-Projekt eingefügt wurden.

Tipp: Das QuickOSM-Werkzeug kann auch genutzt werden, um eine .osm-Datei, die heruntergeladen und lokal gespeichert wurde, abzufragen. Das ist eine spezielle XML-Datei, die OSM-Daten speichern kann. Um Objekte aus solch einer .osm-Datei abzufragen, können wir den Reiter OSM-Datei im QuickOSM-Werkzeug nutzen.

Als letzten Schritt müssen wir nur noch die Objekte des Layers amenity_kindergarten in unser GeoPackage Uebungsdaten.gpkg exportieren. Dazu klicken wir entweder in der oberen Menü-Leiste auf Datenbank --> DB Manager oder in der Werkzeug-Leiste auf (DB Manager…). In dem sich öffnenden Fenster klicken wir auf GeoPackage --> Uebungsdaten.gpkg und dann auf Layer/Datei importieren…

Tipp: Ggf. muss das GeoPackage neu verbunden werden (Doppelklick --> Rechtsklick --> Neu verbinden).

Unter Eingabe wählen wir den Layer amenity_kindergarten und unter Tabelle vergeben wir den Namen Kindergarten. Wir überprüfen, ob das Koordinatensystem korrekt eingestellt ist und klicken auf OK, schließen den DB Manager und fügen den neuen Layer unserem QGIS-Projekt hinzu.

Tipp: OpenStreetMap-Daten basieren darauf, dass ehrenamtliche Kartierer die Daten erheben und pflegen. Dabei ist die Datenqualität, –vollständigkeit und –aktualität natürlich immer ein Thema. Sollten wir feststellen, dass wichtige Daten fehlen, sollten wir uns an die örtliche Kartierer-Community wenden, die wir über die Internetseite der OpenStreetMap finden können. Noch besser: Wir melden uns an und pflegen die Daten selbst ein.

Herzlichen Glückwunsch! Wir können uns Daten der OpenStreetMap besorgen, indem wir die elegantere QGIS-integrierte Methode verwenden. Dabei haben wir das Plug-In QuickOSM genutzt, um thematisch nach Kindergärten und Punkten zu filtern.

Vielleicht ist uns aufgefallen, dass die Kindergärten in unserem Untersuchungsgebiet, die wir aus der OpenStreetMap bezogen haben, nicht vollständig sind. In den nächsten Abschnitten nehmen wir an, dass uns Kollegen weitere Daten zur Verfügung gestellt haben, die die Lage der fehlenden Kindergärten beinhalten. Leider haben uns die Kollegen aber kein GeoPackage, Shapefile oder anderes Datenformat zur Verfügung gestellt, mit dem wir direkt räumlich arbeiten könnten. Einer hat uns stattdessen eine CSV-Tabelle mit Adress-Koordinaten und ein anderer eine Adressliste geschickt. Ein Kollege aus dem Katasteramt hat uns außerdem Zugangsdaten zu einer PostgreSQL-Datenbank geschickt, die auf dem hauseigenen Server liegt. Wir werden lernen, wie wir mit diesen Daten umgehen können und wie wir sie für unsere Analyse nutzen können.

Hinweis: Wir werden an dieser Stelle mit Pseudo-Daten arbeiten. Es befinden sich also an den entsprechenden Stellen keine Kindergärten (oder es wäre ein ziemlicher Zufall). Die verwendeten Daten sollen an dieser Stelle lediglich zur Veranschaulichung der Methodik dienen, die dann im eigenen Haus mit echten Daten umgesetzt werden kann!

Zunächst werden wir Daten, die uns als X- und Y-Koordinaten in einer CSV-Tabelle zur Verfügung gestellt wurden, in unser QGIS-Projekt laden.

Wenn wir die bereitgestellte CSV-Tabelle namens Zusatz_Kindergaerten_XY.csv in Excel öffnen sieht sie so aus:

Die Daten beinhalten offenbar vier weitere Kindergärten. Zu jedem Kindergarten liegen uns die X- und die Y-Koordinate in jeweils einer Spalte vor.

Um diese Daten in unser QGIS-Projekt zu laden, klicken wir in der Werkzeug-Leiste auf oder verwenden die Tastenkombination Strg+L, um die Datenquellenverwaltung zu öffnen. Im Reiter Getrennte Texte wählen wir unter Dateiname die CSV-Datei aus, in denen die Koordinaten gespeichert sind. Unter Dateiformat wählen wir Benutzerdefiniert, damit wir händich noch ein paar Einstellungen machen können. Im unteren Vorschau-Fenster sehen wir, wie die Daten mit den bisherigen Einstellungen importiert werden. Wenn sowohl die X- als auch die Y-Koordinaten in einer Spalte stehen, müssen wir noch einstellen, mit welchem Zeichen die Spalten getrennt werden.

In unserem Fall ist das ein Semikolon, also setzen wir ein Häkchen bei Semikolon. Da wir unsere Kindergärten als Punkte importieren wollen, wählen wir unter Geometriedefinition die Option Punktkoordinaten. Jetzt müssen wir nur noch angeben, wie die Spalten heißen, in denen die X- bzw. Y-Koordinaten gespeichert sind. In unserem Fall wählen wir bei X-Feld die Spalte x und bei Y-Feld die Spalte y. Jetzt müssen wir natürlich noch das Koordinatensystem angeben, da QGIS sonst zwar weiß, bei welcher Koordinate sich die Kindergärten befinden, aber nicht, wo diese Koordinaten liegen. Glückerweise hat uns unser Kollege mitgeteilt, dass sich die Koordinaten auf das Koordinatensystem mit dem EPSG-Code 25832 beziehen. Hätte es das nicht getan, hätte er also nicht die notwendigen Metadaten geliefert, würden wir an dieser Stelle schon im Dunkeln tappen.

Wenn wir auf Anwenden klicken, werden unsere Punktdaten importiert. Damit wir später noch mit den Daten arbeiten können, speichern wir sie als Layer in unser GeoPackage Uebungsdaten.gpgk mit dem Namen Kindergarten_xy. Dazu machen wir einen Rechtsklick auf den Layernamen Zusatz_Kindergaerten_XY und klicken dann auf Exportieren à Objekt speichern als…

Alternativ können wir auch den DB Manager zum speichern des Layers verwenden.

Herzlichen Glückewunsch! Wir können jetzt Daten, die als X- und Y-Koordinaten in einer CSV-Tabelle vorliegen in QGIS importieren und als räumlichen Datensatz speichern.

Außerdem hat uns der Kollege aus dem Katasteramt einen Zugang für eine PostgreSQL/PostGIS-Datenbank geschickt, die auf einem Server liegt und in der weitere (fiktive) Kindergarten-Standorte enthalten sind.

Um uns mit dieser PostGIS-Datenbank zu verbinden, machen wir im QGIS-Browser ziemlich weit unten einen Rechtsklick auf Neue Verbindung…

In dem sich öffnenden Fenster nennen wir unter Name diese neue Verbindung FortQGIS_postgres_qgiscloud. Der Kollege hat uns mitgeteilt, dass der Server, auf dem die Daten liegen, db.qgiscloud.com heißt. Mit dieser Adresse, lässt sich der Server weltweit über das Internet identifizieren. Wir geben die Adresse unter Host ein. Bei Port tragen wir 5432 ein, was der Standard-Port für PostgreSQL-Datenbanken ist. Der Kollege hat uns außerdem mittgeteilt, dass der Name der Datenbank deujns_izraxm lautet, was wir bei Datenbank eintragen. Da die Datenbank nicht frei verfügbar ist, sondern nach einem Benutzernamen mit Kennwort fragt, stellen wir zusätzlich im Abschnitt Authentifizierung ein paar Dinge ein. Wir könnten an dieser Stelle auf den Reiter Basic klicken und hier die Zugangsdaten eintragen, die uns der Kollege geschickt hat. Davon wird allerdings dringend abgeraten, weil die Daten an dieser Stelle nicht verschlüsselt werden, was ein Sicherheitsrisiko birgt. Besser ist es eine verschlüsselte Authentifizierungsmethode zu wählen, die wir im Reiter Konfiguration einstellen. Hier klicken wir auf (Neue Athentifizierungskonfiguration anlegen).

In dem sich öffnenden Fenster vergeben wir einen Namen für die neue Authentifizierung und wählen Einfache Authentifizierung. Anschließend geben wir den Benutzernamen und das Passwort ein, was uns unser Kollege geschickt hat.

Tipp: Wie wir sehen, könnten wir hier auch fortgeschrittenere Authentifizierungsmethoden wählen, die eine Kombination aus privatem und öffentlichem Schlüssel verwenden. Sollten wir mit sehr sensiblen Daten arbeiten, lohnt es sich an dieser Stelle ein paar Überlegungen mehr zu investieren.

Dann klicken wir auf Speichern, wodurch diese Authentifizierung mit unserem QGIS-Profil verschlüsselt gespeichert wird (wir erinnern uns, dass wir unter Einstellungen --> Benutzerprofile die Benutzer wechseln können). Zurück im Hauptfenster, klicken wir auf Verbindung testen. Ist alles richtig eingestellt, erscheint am oberen Rand des Fensters die Meldung Verbindung zu FortQGIS_postgres war erfolgreich. Danach klicken wir auf OK und wir sehen, dass wir den gesuchten Layer im QGIS-Browser unter PostGIS --> FortQGIS_postgres_qgiscloud --> public --> Kindergarten_postgres finden.

Wir laden uns diesen Layer per Drag & Drop in unser QGIS-Projekt und speichern ihn mit dem Layernamen Kindergarten_postgres in unser GeoPackage Uebungsdaten.gpkg (Rechtsklick --> Exportieren --> Objekt speichern als… oder mit Hilfe des DB Managers).

Gratulation! Wir können uns jetzt mit einer PostgreSQL/PostGIS-Datenbank verbinden und Daten von einem Server in ein lokales GeoPackage übertragen.

Als nächstes wollen wir die Adressliste für die fehlenden Kindergärten, die uns zur Verfügung gestellt wurde, auf die Karte bringen. Dazu werden wir die tabellarischen Adressdaten mit amtlichen Hauskoordinaten verbinden. Diese amtlichen Hauskoordinaten werden wir, auf eine ganz ähnliche Weise wie im vorherigen Abschnitt, als eine Text-Datei herunterladen und in QGIS einfügen.

Die amtlichen Hauskoordinaten können wir uns von open.nrw herunterladen. Dazu geben wir den Suchbefehl Hauskoordinaten ein. Der erste Treffer, Gebäudereferenzen, ist der gesuchte Datensatz. Wenn wir ihn anklicken, können wir zunächst die Metadaten einsehen, indem wir auf ATOM: Atom-Feed Gebäudereferenzen und dann unter Weiterführende Informationen auf den Link

https://www.bezreg-koeln.nrw.de/brk_internet/geobasis/

liegenschaftskataster/gebaeudereferenzen/index.html

klicken. Das führt uns zur Internetseite von Geobasis NRW. Wenn wir ganz runter scrollen, finden wir unter Weitere Informationen die Datenformatbeschreibung Gebäudereferenzen. Wenn wir diesen Link anklicken, gelangen wir zu einer PDF-Datei mit Metadaten zu unserem gesuchten Datensatz. Bspw. können wir hier nachlesen, dass in der 12. Spalte der Ost-Koordinatenwert und in der 13. Spalte der Nord-Koordinatenwert als UTM-Koordinaten (ETRS89) gespeichert vorliegen. Außerdem sehen wir, dass in der 14. Spalte der Straßenname, der 10. Spalte die Hausnummer, der 11. Spalte der Adresszusatz und in den Spalten 4-7 die Schlüssel zur Identifikation der Gemeinde gespeichert wurden. Diese Informationen werden wir gleich benötigen.

Zurück auf open.nrw laden wir uns den eigentlichen Datensatz herunter, indem wir auf Gebäudereferenzen --> ATOM: Atom-Feed Gebäudereferenzen à gebref_EPSG4647_ASCII.zip klicken. Hier können wir zusätzlich sehen, dass die Daten als Text-Datei vorliegen und dass sie im Koordinatensystem mit dem EPSG-Code 4647 gespeichert wurden.

Wir entpacken die Daten mit einem Archivierungsprogramm wie bspw. 7-Zip oder WinRAR. Danach klicken wir in QGIS in der Werkzeug-Leiste auf oder verwenden die Tastenkombination Strg+L, um die Datenquellenverwaltung zu öffnen. Im Reiter Getrennte Texte wählen wir unter Dateiname die Datei gebref.txt aus dem heruntergeladenen und entpackten Ordner. In der unteren Vorschau sehen wir, dass die Spalten schon korrekt als solche erkannt wurden, sodass wir unter Dateiformat diesmal nichts weiter einstellen müssen. Damit die erste Zeile in den Daten nicht als Spaltenname verkannt wird, entfernen wir unter Datensatz- und Feldoptionen das Häkchen bei Erster Datensatz enthält Feldnamen. Da wir die Hauskoordinaten wieder als Punkte importieren wollen, wählen wir auch diesmal unter Geometriedefinition die Option Punktkoordinaten. In der Vorschau können wir durch unser Wissen aus den Metadaten erkennen, dass zu jedem Koordinatenpaar die Straßennamen (field_14), Hausnummer (field_10) und Hausnummerzusätze (field_11) gespeichert sind. Die Postleitzahlen und Ortnamen sehen wir zwar nicht direkt, aber die Zahlencodes in den Spalten field_4 bis field_7 können uns weiterhelfen. Da wir in unserem Untersuchungsgebiet in nur einer Gemeinde arbeiten, ist das kein Problem. Sollten wir in mehreren Gemeinden arbeiten müssen wir unsere tabellarischen Adressdaten entsprechend dieser Codes anpassen. Dabei hilft uns die Datei gebref_schluessel.txt, die sich ebenfalls in dem entpackten Archiv befinden, welches wir heruntergeladen haben. Außerdem wissen wir in welchen Feldern die X- und Y-Koordinaten gespeichert sind. Wir wählen dementsprechend als X-Feld den Eintrag field_12 und als Y-Feld den Eintrag field_13 aus den jeweiligen Drop-Down-Menüs. Wir erinnern uns an die Angaben beim Download der Daten und wählen das Koordinatensystem mit dem EPSG-Code 4647. Wenn wir uns diese Felder noch etwas genauer in der Vorschau ansehen, können wir erkennen, dass, wie es (ausschließlich) in Deutschland üblich ist, Kommas als Dezimaltrennzeichen verwendet wurden (und nicht, wie überall sonst auf der Welt, Punkte). Wir setzten also ein Häkchen bei Dezimalseparator ist Komma. Um schnell in den importierten Daten suchen zu können, setzten wir auch noch ein Häkchen bei Räumlichen Index benutzen.

Wenn wir auf Hinzufügen klicken, werden ALLE Hauskoordinaten in NRW eingeladen, also für jedes Gebäude einen Punkt. Das sind ganz schöne viele Daten. Wir müssen uns also ein wenig gedulden. Zeit für einen Kaffee : )

Um komfortabler mit den Daten arbeiten zu können, benennen wir noch die benötigten Spalten um. Dazu öffnen wir die Layereigenschaften und schalten im Reiter Quellfelder durch einen Klick auf den Bearbeitungsmodus ein. Danach machen wir einen Doppelklick auf den Feldnamen field_10 und ändern ihn zu HNR. Auf die gleiche Weise ändern wir die Spaltennamen field_11 zu Zusatz und field_14 zu Strasse.

Danach verlassen wir den Bearbeitungsmodus durch einen Klick auf und speichern die Änderungen.

Um später noch mit den Daten arbeiten zu können, speichern wir sie wie gehabt als Layer in unser GeoPacakge Uebungsdaten.gpkg mit dem Namen AmtlicheAdressen (Rechte Maustaste auf den Layernamen --> Exportieren --> Objekt speichern als… oder mit Hilfe des DB Managers). Dabei sollten wir nicht vergessen, das Koordinatensystem vom EPSG-Code 4647 nach 25832 umzustellen. Um die Datenmenge auf das Wesentliche zu beschränken, sollten wir außerdem auf unser Untersuchungsgebiet zoomen und beim Speichern ein Häkchen bei Ausmaße ( aktuell Layer) setzten und dann auf Anzeigeausdehnung setzen.

Gratulation! Wir können jetzt alle amtlichen Hauskoordinaten samt Adressangaben für unser Untersuchungsgebiet in QGIS einladen.

Um unsere tabellarischen Adressdaten mit den geladenen amtlichen Adresskoordinaten zu verbinden, legen wir in beiden Datensätzen ein Adress-ID-Feld an, welches wir als Schlüssel-Feld für eine Verknüpfung nutzen können. In diesem Feld sollen der Straßenname, die Hausnummer und der Hausnummer-Zusatz zusammen gespeichert werden, sodass eine eindeutige Zuordnung der tabellarischen Daten zu den Punkten auf der Karte möglich ist.

Wir laden zunächst unsere Excel-Tabelle namens Kindergaerten_Adressliste.xlsx in QGIS ein, indem wir sie aus dem Datei-Browser per Drag & Drop entweder in das Inhaltsverzeichnis, oder in das Kartenfenster ziehen. Wir öffnen diese Tabelle so, wie wir eine Attributtabelle eines Shapefiles öffnen und sehen, dass in der Tabelle die Straße (Strasse), Hausnummer (HNR), Hausnummer-Zusatz (Zusatz), der Ortsname (Ort) und der amtliche Gemeindeschlüssel (AGS) für 9 weitere (fiktive) Kindergärten gespeichert sind.

Tipp: Sollten die Spaltennamen einmal nicht korrekt als Spaltennamen, sondern als erste Zeile des Datensatzes angezeigt werden, kann es helfen, in Excel eine Spalte anzulegen, in der nummerische Zahlendaten gespeichert werden, bspw. ein ID-Feld. Alternativ lässt sich über das Plug-In Spreadsheet Layers der Daten-Import aus Excel-Tabellen gezielter steuern.

Um ein Adress-ID-Feld zu erzeugen öffnen wir den Feldrechnern, indem wir entweder in der Menüleiste der Attributtabelle oder im oberen Menü-Band auf (Feldrechner öffnen) klicken oder den Tastatur-Shortcut Strg + I verwenden. Im Feldrechner-Fenster setzen wir ein Häkchen bei Neues Feld anlegen und nennen es adressID. Der Ausgabefeldtyp soll Text (string) sein und um auch auf sehr lange Straßennamen reagieren zu können geben wir 250 Zeichen als Ausgabefeldlänge an. Als nächstes klicken wir uns den Ausdruck zum Erstellen des Adress-ID-Feldes zusammen. Im mittleren Fenster klicken wir unter Felder und Werte doppelt auf Strasse dann am oberen Rand des linken Fensters auf (Zeichenkettenverkettung : ), dann wieder im mittleren Fenster auf HNR, wieder auf und schließlich auf Zusatz. Der vollständige Ausdruck sollte dann so aussehen:

"Strasse" || "HNR" || "Zusatz"

Tipp: Da alle unsere Adressen im gleichen Ort liegen, reichen diese Angaben. Wenn wir gleichzeitig in mehreren Gemeinden arbeiten, müssen wir an dieser Stelle natürlich noch Postleitzahl und Ort anfügen, bzw. den amtlichen Gemeindeschlüssel verwenden.

Wir klicken auf OK und dann in der Werkzeug-Leiste oder am oberen Rand der Attributtabelle auf , um den Bearbeitungsmodus zu verlassen und die Änderungen zu speichern.

Herzlichen Glückwunsch! Wir können jetzt ein eindeutiges Address-ID-Feld erzeugen. Dieses Feld können wir als Schlüssel-Feld nutzen, um unsere tabellarischen Adress-Daten mit den amtlichen Hauskoordinaten zu verbinden.

Tipp: Wenn in manchen Zeilen statt der gewünschten Adress-ID der Eintrag NULL erscheint, könnte das daran liegen, dass fehlende Werte bspw. beim Hausnummer-Zusatz nicht richtig gelesen werden konnten. Dann kann es helfen, das QGIS-Projekt zu speichern, QGIS zu schließen, in Excel alle Zellen als Text zu formatieren, in die leeren Zellen ein Leerzeichen einzutippen, die Tabelle zu speichern und das Adress-ID-Feld in QGIS erneut zu erzeugen.

Allerdings enthält unser Adress-ID-Feld noch Sonderzeichen, wie bspw. ü und ., und die Schreibweisen sind auch nicht durchgehend gleich, bspw. str. und Straße.

Um diese Fälle zu vereinheitlichen öffnen wir erneut den Feldrechner. Diesmal wollen wir kein neues Feld anlegen, sondern ein Vorhandenes Feld erneuern und zwar wollen wir das Feld adressID überschreiben.

Im mittleren Fenster finden wir in der Kategorie Zeichenketten die Funktion regexp_replace. Wenn wir sie anklicken, erfahren wir in der Kurzhilfe im rechten Fenster, dass diese Funktion genutzt werden kann, um Teile von Zeichenketten, also Text, zu ersetzen. Wir werden diese Funktion nutzen, um Sonder- und Leerzeichen, sowie Umlaute und unterschiedliche Schreibweisen zu ersetzen.

Durch einen Doppelklick fügen wir die Funktion dem Ausdruck auf der linken Seite hinzu. In der Kurzhilfe sehen wir, dass die Funktion als erstes Argument in der Klammer die Zeichenkette erwartet, in der etwas ersetzt werden soll. Wir klicken also im mittleren Fenster unter der Kategorie Felder und Werte doppelt auf adressID. Getrennt durch ein Komma, soll das zweite Argument der zu ersetzende Teil sein und wieder durch ein Komma getrennt, das dritte Argument die Ersetzung. Zunächst wollen wir die Schreibweise für ü zu ue vereinheitlichen. Wir geben als zweites Argument also 'ü' und als drittes Argument 'ue' (beides mit einfachen Anführungszeichen) an und schließen die Klammer.

Insgesamt sollte unser Ausdruck jetzt so aussehen:

regexp_replace("adressID" , 'ü', 'ue')

Anschließend klicken wir auf OK und dann auf , um den Bearbeitungsmodus zu verlassen und die Änderungen zu speichern.

In der „Attribut-Tabelle“ sehen wir, dass die Schreibweisen einen Schritt in Richtung Vereinheitlichung gemacht haben. Allerdings müssen wir jetzt auch strße durch str ersetzen. Außerdem müssen noch Straße durch str ersetzt und Leer- und Sonderzeichen entfernt werden. Um das Ganze etwas schneller zu gestalten, kann man den Ausdruck auch schachteln. Dabei ist die Zeichenkette, in der die Ersetzung stattfinden soll wiederrum eine Ersetzung usw. In der Datei Ersetzung.sql ist solch ein geschachtelter Ausdruck vorbereitet:

regexp_replace(

    regexp_replace(

        regexp_replace(

            …

                regexp_replace("adressID", ' ', ''),

            …

        'Strße', 'str'),

    'strsse', 'str'),

'Strsse', 'str')

Wir öffnen erneut den Feldrechner, geben an, dass wir das adressID-Feld erneuern wollen und kopieren den Text aus der Datei Ersetzung.sql in das Ausdruck-Fenster.

Anschließend klicken wir auf OK und auf , um den Bearbeitungsmodus zu verlassen und die Änderungen zu speichern.

Jetzt müssen wir das Ganze nur noch mit den amtlichen Adresskoordinaten machen. Wir nutzen wieder den Feldrechner, um ein Adress-ID-Feld zu erzeugen und den bereits verwendeten SQL-Ausdruck, um es anschließend zu vereinheitlichen. Da die jeweiligen Berechnungen für die Fülle der Adressen allerdings recht lange dauert, können wir an dieser Stelle etwas abkürzen, indem wir den Layer AmtlicheAdressen_AdressID im GeoPackage vorbereiteteDaten_Backup\backup.gpkg nutzen, für die die Adress-Daten genau wie wir es für unsere Adressenliste gemacht haben vereinheitlicht in das Adress-ID-Feld überführt wurden. Dabei wurden die Adressen vor der Aufbereitung auf das Untersuchungsgebiet zugeschnitten, um die Berechnungen zu beschleunigen. Dann wurden alle leeren Zeilen in der Spalte Zusatz selektiert,

"Zusatz" is null

und anschließend durch die Zeichenkette 'NullErsatzwert' im Feldrechner ersetzt. Das ist ein Platzhalter, um in keine Probleme mit NULL-Werten in leeren Zellen zu laufen. Dieser Platzhalter wurde dann durch den Ausdruck in Ersetzung.sql wieder entfernt.

Geschafft! Wir können jetzt die Schreibweisen im Adress-ID-Feld vereinheitlicht sowie Sonder- und Leerzeichen entfernen. Der Verbindung der Daten mit den amtlichen Hauskoordinaten über dieses Schlüsselfeld steht jetzt also nichts mehr im Wege.

Wir haben jetzt sowohl in den amtlichen Hauskoordinaten, die uns als Punkte vorliegen, als auch in unserer Adressliste mit den fehlenden Kindergärten ein Feld namens adressID, was wir als sogenanntes Schlüsselfeld nutzen können, um die beiden Datensätze miteinander zu verbinden.

Dazu öffnen wir die Layer-Eigenschaften des Layers AmtlicheAdressen_AdressID und klicken im Reiter Verknüfpungen auf (Neue Verknüpfung hinzufügen).

In dem sich öffnenden Fenster wählen wir die tabellarische Adressliste Kindergaerten_Adressliste unter Layer verknüpfen. Da die Felder, über die die Verknüpfung stattfinden soll, beide gleich heißen, wählen wir sowohl unter Verknüpfungsfeld als auch unter Zielfeld das Schlüsselfeld adressID. Damit die Spaltennamen nicht zu lang werden, aber trotzdem noch erkennbar ist, welche Spalte aus welchem Datensatz kommt, setzen wir ein Häkchen bei Benutzerfeldnamenpräfix und tippen AL_ ein. Auf diese Weise wissen wir später noch, dass die betreffenden Daten aus der AdressListe kamen.

Anschließend klicken auf OK, im Layer-Eigenschaften-Fenster nochmals auf OK und öffnen dann die Attributtabelle des Layers AmtlicheAdressen_AdressID. Wenn wir ganz nach rechts scrollen, sehen wir, dass die entsprechenden Spalten aus der tabellarischen Adressliste der fehlenden Kindergärten hinzugefügt wurden. Allerdings steht in fast allen Zellen kein Wert, bzw. der Eintrag NULL. Wenn wir uns überlegen, dass wir alle amtlichen Hauskoordinaten mit den 9 Adressen der fehlenden Kindergärten verknüpft haben, wird klar, dass das auch Sinn macht. Denn nicht zu allen Adressen im Untersuchungsgebiet wird ein Kindergarten gefunden, sondern nur für ein paar wenige Adressen.

Die gesuchten Kindergärten können wir jetzt also filtern, indem wir nach Werten selektieren, die nicht NULL sind. Dazu klicken wir entweder in der oberen Menü-Leiste oder in der Menü-Leiste der Attributtabelle auf (Objekte über Auswahl wählen). Im mittleren Feld klicken wir in der Kategorie Felder und Werte doppelt auf den Feldnamen AL_ID, um ihn zu unserem Ausdruck auf der linken Seite hinzuzufügen. Um die Werte zu selektieren, die nicht NULL sind, ergänzen wir den Ausdruck zu:

"AL_ID" is not null

Tipp: Wir hätten an dieser Stelle natürlich auch jedes andere Feld nehmen können, was aus der Adressliste kommt und mit AL_ beginnt.

Wenn wir auf Objekt wählen und dann auf Schließen klicken, sieht es zunächst so aus als wäre nichts ausgewählt worden, weil die Karte einfach durch zu viele Adresspunkte überfrachtet ist. Im Titel der Attributtabelle sehen wir aber, dass 7 Elemente ausgewählt wurden. Durch einen Klick auf in der Werkzeug-Leiste der Attributtabelle können wir auch die Auswahl nach oben holen und sehen, dass tatsächlich die gesuchten Kindergärten mit den Punktdaten verknüpft und selektiert wurden. Alternativ können wir auch nur die selektierten Zeilen anzeigen lassen, indem wir links unten auf Alle gewählten Objekte anzeigen klicken.

Die selektierten Punkte speichern wir als separaten Layer in unser GeoPackage Uebungsdaten.gpkg, und vergeben den Namen Kindergarten_Adressliste (entweder Rechtsklick auf den Layernamen --> Exportieren --> Objekt speichern als… oder mit Hilfe des DB Managers). Dabei sollten wir das Häkchen bei nur gewählte Objekte speichern nicht vergessen ; )

Gratulation! Wir können jetzt Adressen aus der Adressliste mit den amtlichen Hauskoordinaten über ein selbst erzeugtes Adress-Schlüsselfeld verknüpfen. Wir haben anschließend die Punkte ausgewählt, an denen sich ein (Pseudo-)Kindergarten befindet und die bisher fehlenden Kindergärten in einen eigenen GeoPackage-Layer gespeichert.

Alternativ können wir auch ein eigenes Werkzeug erstellen, was genau das macht, was wir wollen und was alle Arbeiten zu einem einzigen Arbeitsschritt zusammenführt. Dazu binden wir ein Python-Skript in QGIS ein. Python ist eine sogenannte Skript-Sprache. Mit dieser Sprache können wir Anweisungen in ein Dokument schreiben und dieses Dokument QGIS übergeben. Während QGIS die Anweisungen abarbeitet, können wir uns einen Kaffee holen. Wir werden sehen, dass es in QGIS nicht nur sehr einfach ist, Erweiterungen zu installieren und Werkzeuge aus anderen GIS-Systemen zu nutzen, sondern auch problemlos Skripte einzubinden und so eigene Werkzeuge, ganz nach unseren Wünschen zu erstellen. Dazu müssen wir entweder ein paar Kenntnisse in Python mitbringen oder uns Python-Skripte bspw. aus der QGIS-Community besorgen.

Wir klicken in der Werkzeugleiste auf (Werkzeugkiste Strg+Alt+T), um die Werkzeugkiste zu öffnen. Am oberen Rand der Werkzeugkiste klicken wir auf (Skripte) und dann auf Erzeuge neues Skript.

Im sich öffnenden Skript-Editor, dem sogenannten Verarbeitungsskripteditor, können wir den Python-Code eingeben, der das Verhalten unseres Werkzeuges definiert. Diesen Code finden wir im Ordner Zusatzdaten in der Datei allocateAddresses.py. An der Datei-Erweiterung .py sehen wir, dass es sich um ein Python-Skript handelt. Da solch ein Skript nichts anderes ist als eine Text-Datei, können wir sie mit einem beliebigen Text-Editor öffnen, bspw. mit Editor oder Notepad++ (Rechtsklick auf die Datei à Öffnen mit). Wir gucken uns den Code an und versuchen ihn nachzuvollziehen. Zu Beginn wird in Nutzeroberfläche definiert, dann folgen die eigentlichen Programm-Anweisungen. Wir sehen, dass hier untereinander Befehle abgetippt wurden, die wir bisher nacheinander händisch durchgeführt haben, um die Kindergärten mit amtlichen Adressen zu geocodieren. Wir kopieren den kompletten Text in diesem Python-Skript und fügen ihn im Verarbeitungsskripteditor in QGIS ein.

Danach klicken wir in der Werkzeug-Leiste des Verarbeitungsskripteditors auf (Skript speichern als). Wir ändern nicht den Speicherort und geben lediglich einen Namen für unser Skript ein, bspw. amtlicheAdressenGeocodieren.py. Danach schließen wir den Verarbeitungsskripteditor und auch QGIS, um es neu zu starten.

Tipp: Mit der Erweiterung Plugin Reloader kann man sich diesen Neustart des Programms sparen.

Nach einem Neustart erscheint unser eigens hinzugefügtes Werkezeug am Ende der Werkzeugkiste.

Tipp: Eine stets aktuelle Version des Werkzeuges (und viele weitere Werkzeuge) können wir über die Versionierungsplattform github.com beziehen:

https://github.com/RaumanalysenChristianMueller/AddressAllocator

Durch einen Klick auf Clone or download (Klonen oder herunterladen) --> Download ZIP (ZIP-Archiv herunterladen) können wir das ganze Verzeichnis im aktuellen Zustand herunterladen.

Gratulation! Wir können jetzt eigene Werkzeuge in QGIS integrieren, indem wir Python-Skripte einbinden. Wir wissen auch, dass wir viele solcher OpenSource-Skripte auf GitHub finden können.

Unser neues Werkzeug nimmt uns eine Menge Arbeit ab, indem es viele der bisherigen Schritte schnell und einfach zusammenfasst. Dabei werden die meisten Abläufe automatisiert, sodass wir unsere Zeit für schönere Dinge verwenden können.

Um das neue Werkzeug zu verwenden, machen wir in der Werkzeugkiste am rechten Bildschirmrand einen Doppelklick auf Mit amtlichen Adressen geocodieren.

Es öffnet sich das Werkzeugfenster, in dem wir unsere tabellarische Adressliste als Zu geocodierende Adressen als Tabelle auswählen. Jetzt müssen wir nur noch angeben, in welchen Spalten die Straßennamen, Hausnummern, Hausnummer-Zusätze und der amtliche Gemeindeschlüssel gespeichert sind. Zum Schluss wählen wir durch einen Klick auf die drei Pünktchen einen Ordner aus, in dem die geocodierten Adressen gespeichert werden sollen. Hierzu empfiehlt es sich einen neuen Unterordner in den Übungsdaten anzulegen, den wir bspw. KindergartenAdressliste nennen können.

Nachdem wir auf Starte geklickt haben, werden alle Prozesse, die wir vorher mühsehlig nacheinander durchgeführt haben, automatisch in einem Rutsch bearbeitet. Wenn wir das Werkzeug das erste Mal ausführen, kann es sein, dass es eine ganze Weile braucht, weil es die amtlichen Adressen zuerst herunterladen muss. Wenn wir das Werkzeug dann das nächste Mal verwenden, geht es viel schneller, es sei denn, wir weisen es durch ein Häkchen bei Lade aktuelle amtlichen Adressen an, die amtlichen Adressen erneut herunterzuladen.

Gratulation! Wir können jetzt ein eigenes Werkzeug verwenden, um tabellarische Adressdaten in einem Schritt mit amtlichen Adressen zu geocodieren.

Uns ist sicherlich aufgefallen, dass in unserer tabellarischen Adressliste 9 zusätzliche Kindergärten aufgelistet sind. Im vorherigen Abschnitt wurden allerdings nur 7 Kindergärten mit den amtlichen Hauskoordinaten verbunden. Gucken wir uns noch ein mal die tabellarische Adressliste an und suchen nach den zwei Einträge, die nicht verbunden und deshalb auch nicht auf die Karte gebracht wurden:

Der erste fehlende Eintrag ist die Fortunaschule, die (in unserem fiktiven Übungsbeispiel) vielleicht einen Kindergarten integriert hat. Der zweite Eintrag, der nicht als Punkt auf der Karte erscheint ist der (fiktive) Kindergarten im Lilienweg. Hierbei wurde keine Hausnummer angegeben, entweder weil der Lilienweg so kurz ist, dass es in der Regel ausreicht zu wissen, dass sich der Kindergarten dort befindet, oder weil man ganz einfach die Hausnummer nicht kennt. Beides sind Fälle, die in der Praxis recht häufig vorkommen und in beiden Fällen haben wir es nicht mit amtlichen Adressen zu tun, sondern eher mit geläufigen Ortsangaben. Es ist also nur logisch, dass die beiden Einträge nicht mit den amtlichen Hauskoordinaten gematcht werden konnten.

Um diese Daten trotzdem auf unsere Karte zu bekommen, werden wir einen externen Geocodierungsdienst um Rat fragen. Dazu installieren wir das QGIS-Plug-In-Bündel MMQGIS. Wir klicken in der Menü-Leiste auf Erweiterungen --> Erweiterungen verwalten und installieren… In dem sich öffnenden Fenster tippen wir in die Suchzeile mmqgis ein, klicken auf das gefundene Plug-In und ggf. auf Installieren, falls es nicht schon vorher installiert wurde. Danach schließen der Erweitungen-Fenster wieder. In der Menü-Leiste erscheint jetzt eine neuer Menü-Eintrag namens MMQGIS.

Das Geocodierungs-Werkzeug, was wir verwenden wollen, erwartet die Adress-Daten allerdings im CSV-Format und nicht, wie wir sie vorliegen haben im XLSX-Format. Um die Daten im erwarteten Format zu speichern, öffnenen wir die Datei Kindergaerten_Adressliste.xlsx in Excel. Hier löschen wir erst einmal alle Einträge, die wir schon erfolgreich mit den amtlichen Adresskoordinaten verbunden haben und lassen nur die beiden Zeilen übrig, die uns noch fehlen.

Dann klicken wir (je nach Excel-Version) auf Datei à Speichern unter und ändern den Dateityp auf CSV (Trennzeichen-getrennt) (*.csv). Die Warnmeldung darüber, dass möglicherweise Features verloren gehen bestätigen wir mit Ja. Wenn wir beim Schließen von Excel gefragt werden, ob wir die Änderungen speichern wollen, klicken wir auf Nein (!), weil sonst wieder im falschen Format gespeichert wird.

Hinweis: Wenn man in der GIS-Welt von Features spricht, meint man Geoobjekte. Hier sind aber Excel-Funktionen gemeint. Wir müssen also keine Angst haben, dass Daten verloren gehen.

Zurück in QGIS klicken wir in der Menü-Leiste auf MMQGIS à Geocode à Geocde CSV with Google / OpenStreetMap.

In dem sich öffnenden Geocodierungswerkzeug wählen wir unter Input CSV File (UTF-8) die gerade erzeugte CSV-Datei namens Kindergaertern_Adressliste.csv. Als Adress Field wählen wir das Feld namens Strasse und als City Field die Spalte Ort. Das State Field und Country Field müssen wir in unserem Fall nicht angeben. Unter Web Service haben wir die Wahl, ob wir den Geocodierungsdienst von OpenStreetMap oder Google nutzen wollen. Wir wählen OpenStreetMap / Nominatim. Zum Schluss geben wir noch an, wohin das Shapefile gespeichert werden soll, was die geocodierten Adressen beinhaltet und wie es heißen soll, bspw. Kindergarten_geocodeOSM.shp. Außerdem können wir uns unter Not Found Output List noch eine Tabelle ausgeben lassen, in der die Adressen enthalten sind, die nicht über OpenStreetMap geocodiert werden konnten. Auch hier wählen wir einen geeigneten Speicherort und Namen, bspw. nichtGefunden.csv.

Wir haben es fast geschafft. Wenn wir auf OK klicken, erscheinen die beiden fehlenden Kindergärten aus der tabellarischen Adressliste in der Karte. Die Daten, die über OpenStreetMap geocodiert werden, liegen aber im Koordinatensystem mit dem EPSG-Code 4326 vor und alle Attributfelder bekommen den Datentypen string also Text. Im nächsten Abschnitt wollen wir diese geocodierten Kindergärten mit den übrigen Kindergärten in einem Layer vereinigen. Damit das gelingt, sollten wir es vermeiden, dass es bei den Datentypen zu Kollisionen kommt. Wenn wir es uns geneauer überlegen, brauchen wir eigentlich gar keine Attribute für unsere Erreichbarkeitsanalyse, weil wir lediglich an den Standorten der Kindergärten interessiert sind. Um uns das Leben leicht zu machen, löschen wir außer der Spalte ID ganz einfach alle Attributfelder aus dem Layer Kindergaerten_Adressliste.shp. Dazu öffnen wir die Layereigenschaften dieses Layers und klicken im Reiter Quellfelder auf , um in den Bearbeitungsmodus zu schalten. Anschließend markieren wir alle Attributfelder außer ID und klicken auf (Feld löschen).

Danach klicken wir erneut auf , um den Bearbeitungsmodus wieder zu verlassen und die Änderungen zu speichern.

Wir speichern den Layer mit dem Namen Kindergarten_geocodiert im GeoPackage Uebungsdaten.gpkg und achten darauf, dass wir das Koordinatensystem mit dem EPSG-Code 25832 wählen (Entweder Rechtsklick auf den Layernamen --> Exportieren --> Objekt speichern als… oder mit Hilfe des DB Managers).

Herzlichen Glückwunsch! Wir können jetzt tabellarische Adressdaten, die nicht in den amtlichen Hauskoordinaten enthalten sind, über einen externen Geocodierungsdienst in unser QGIS-Projekt bringen.

Tipp: Sollte es einmal nicht mit OpenStreetMap bzw. Nominatim funktionieren, gibt es neben der anderen Option im verwendeten Tool, Google, auch noch weitere gute Geocodierungs-Plug-Ins, sowie Online-Geocodierungsdienste wie bspw. den BKG GeoCoder des Bundesamtes für Kartographie und Geodäsie. Darüber hinaus steht es natürlich jedem offen, weitere Plug-Ins für QGIS zu entwickeln und zu veröffentlichen. Allerdings sollte man dazu ein paar Kenntnisse in der Sprache Python haben.

Bis hierher haben wir mehrere Methoden genutzt, um Kindergärten (und auch fiktive Kindergärten) auf unsere Karte zu bringen. Wir haben die Standorte der Kindergärten aus der OpenStreetMap bezogen, XY-Koordinaten verortet und tabellarische Adressdaten mit amtlichen Hauskoordinaten verknüpft, was wir durch ein Python-Skript vereinfacht haben, sowie den Geocodierungsdienst der OpenStreetMap, Nominatim, genutzt. Zum Schluss haben wir zusätzliche Daten von einem PostgreSQL/PostGIS-Server bezogen. Als Ergebnis liegen uns die Kindergärten in mehreren Layern in unserem GeoPackage Uebungsdaten.gpkg vor. Bevor wir endlich mit der eigentlichen Erreichbarkeitsanalyse starten, wollen wir die Kindergärten in einem einzigen Layer bündeln.

Dazu klicken wir in der Menü-Leiste auf Vektor --> Datenmanagement-Werkzeuge --> Vektorlayer zusammenführen…

In dem sich öffnenden Werkzeug-Fenster wählen wir unter Eingabelayer die Layer Kindergarten (von OSM bezogen), Kindergarten_xy (aus X-Y-Koordinaten erstellt), Kindergarten_Adressliste (mit amtlichen Adresskoordinaten verknüpft), Kindergarten_geocodiert (über OSM geocodiert) und Kindergarten_postgres. Das Ziel-KBS stellen wir wie gehabt auf das Koordinatensystem mit dem EPSG-Code 25832 ein. Unter Zusammengeführt geben wir nichts ein, bzw. belassen die Voreinstellung bei Temporärlayer erzeugen. Dadurch werden die Daten zunächst in einem QGIS Layer dargestellt und noch nicht auf die Festplatte geschrieben.

Wenn wir auf Im Hintergrund ausführen klicken, erscheint ein neuer Layer namens Zusammengeführt im Inhaltsverzeichnis und auf der Karte sehen wir, dass er alle Kindergärten enthält, die aus den unterschiedlichen Datenquellen zusammengeführt wurden. Wir Schließen das Werkzeug-Fenster.

Bevor wir den temporären Layer in unser GeoPackage speichern können, müssen wir noch dafür sorgen, dass das ID-Feld keine doppelten Werte beinhaltet. Wenn wir uns die Attributtabelle des temporären Layers Zusammengeführt angucken, sehen wir, dass das Feld fid, was eigentlich eine eindeutige ID speichern soll, durch die Zusammenführung der unterschiedlichen Layer doppelte Werte enthält. Das korrigieren wir mit Hilfe des Feldrechners.

Wir öffnen den Feldrechner durch einen Klick auf in der Werkzeugleiste oder der Werkzeugleiste der Attributtabelle oder durch die Tastenkombination Strg+I. Wir setzen ein Häkchen bei Vorhandenes Feld erneuern und wählen die Spalte fid. Im Ausdrucksfenster tippen wir

$id

ein. Dadurch wird das Feld fid mit einer fortlaufenden Ganzzahl überschrieben. Wenn wir auf OK klicken, sehen wir, dass das Feld fid jetzt nur noch eindeutige Werte beinhaltet. Wir verlassen den Bearbeitungsmodus durch einen Klick auf und speichern die Änderungen.

Wir speichern diesen Layer als Kindergarten_alle in unser GeoPackage Uebungsdaten.gpkg (entweder Rechtsklick --> Exportieren --> Objekt speichern als… oder mit Hilfe des DB Managers). Wenn wir gefragt werden, ob wir die Objekte überschreiben oder anhängen wollen, klicken wir auf An Layer anhängen. Wenn wir dann gefragt werden, ob die fehlenden Felder dem Layer hinzugefügt werden sollen, antworten wir mit Nein, da uns nicht die Attribut-Felder, sondern nur die Lage der Kindergärten interessiert.

Herzlichen Glückwunsch! Wir können jetzt Layer aus verschiedenen Datenquellen zu einem Layer zusammenführen. Dabei können wir eine eindeutige ID sicherstellen.

Bis hierher haben wir unsere Daten aufbereitet. In der Praxis ist es tatsächlich nicht selten, dass die Datenaufbereitung und das Datenmanagement einen Großteil der Arbeitszeit ausmachen. Jetzt wollen wir die eigentliche Analyse durchführen. Im ersten Schritt führen wir eine Netzwerkanalyse mit festem Abstand durch.

Dazu klicken wir in der Werkzeugleiste auf (Werkzeugkiste Strg+Alt+T), um die Werkzeugkiste zu öffnen. In der Kategorie Netzwerkanalyse finden einige hilfreiche Werkzeuge für Netzwerkanalysen. Wir werden das Werkzeug Dienstbereich (aus Layer) nutzen, um eine sogenannte Service Area zu berechnen, was hier mit Dienstbereich übersetzt wurde. Wir öffnen das Werkzeug Dienstbereich (aus Layer) durch einen Doppelklick.

In dem sich öffnenden Werkzeug-Fenster geben wir bei Netzwerk-Vektorlayer den Layer Wegenetz an. Als Startpunkt-Vektorlayer wählen wir Kindergarten_alle. Unter Zu berechnender Pfadtyp wählen wir die Kürzeste Strecke und geben bei Reisekosten den Entfernungswert 500 Meter ein. Beim zu berechnenden Dienstbereich belassen wir die Einstellung bei Temporärlayer erzeugen.

Wir klicken auf Im Hintergrund ausführen und dann auf Schließen.

Gratulation! Wir können jetzt eine Netzwerkanalyse durch das Gehwegenetz durchführen.

Jetzt wissen wir schon mal, welche Wegabschnitte innerhalb von 500 Metern zum nächsten Kindergarten liegen. Uns interessieren ja aber gar nicht so sehr die Wege selbst, als vielmehr die Gebäude, genauer gesagt die Wohngebäude. Um herauszufinden, welche Wohngebäude in diesem Einzugsgebiet liegen, bilden wir im nächsten Schritt zunächst eine Fläche, die die identifizierten Wegabschnitte einschließt. Dazu nutzen wir das Werkzeug Vektor --> Geoverabeitungswerkzeuge --> Konvexe Hülle… Dieses Werkzeug bildet eine Fläche, wie durch eine Schnur, die außen um die Wegabschnitte herum gelegt wird.

In dem sich öffnenden Werkzeugfenster wählen wir Dienstbereich (Linien) als Eingabelayer. Das Ergebnis speichern wir als Temporärlayer, indem wir bei Konvexe Hüllen nichts eingeben.

Nachdem wir auf Start geklickt haben, sehen wir, dass wir Flächen erzeugt haben, die die 500-Meter-Linien einschließen.

Herzlichen Glückwunsch! Wir können jetzt Flächen als konvexe Hüllen erzeugen, die Geometrien flächendeckend einschließen.

Im letzten Schritt müssen wir nur noch herausfinden, welche Wohngebäude, in den identifizierten Einzugsgebieten liegen. Dazu nutzen wir das Werkzeug Attribute nach Position verknüpfen (Zusammenfassung). Um dieses Werkzeug aufzurufen öffnen wir die Werkzeugkiste durch einen Klick auf in der Werkzeugleiste. In der Werkzeugleiste finden wir dann das Werkzeug unter Vektoren allgemein à Attribute nach Position verknüpfen (Zusammenfassung), was wir durch einen Doppelklick öffnen.

Hinweis: Es gibt ein Werkzeug, was fast genauso heißt, nämlich Attribute nach Position zusammenfügen, also ohne „(Zusammenfassung)“. Dieses Werkzeug verknüpft allerdings nur mit dem ersten gefunden Objekt in dem zu verknüpfenden Layer! Wir bekommen dann keine Fehler- oder Warnmeldung! Wir sollten also sehr aufpassen, dass wir das richtige Werkzeug verwenden.

In dem Werkzeugfenster wählen von die Wohngebaeude als Eingabelayer und die erzeugten Konvexen Hüllen unter Layer verknüpfen aus. Um auch Wohngebäude zu berücksichtigen, die nicht komplett innerhalb des Einzugsgebietes liegen, sondern nur teilweise, setzten wir bei Geometrisches Prädikat ein Häkchen bei schneidet sich mit. Wir wollen zählen lassen, in wie vielen Einzugsgebieten die jeweiligen Wohngebäude liegen. Dazu wählen wir bei Zusammenfassende Felder irgendein beliebiges Feld aus, bspw. das fid-Feld. Unter Zu berechnende Zusammenfassung wählen setzten wir dann ein Häkchen bei Anzahl. Jetzt müssen wir nur noch unter Zusammengefasster Layer angeben, wo der neue Layer hin gespeichert werden soll, der die Information enthält, ob und wenn ja, in wie vielen Kindergarten-Einzugsgebieten die jeweiligen Wohngebäude liegen. Hier könnten wir bpsw. ein GeoPackage namens Wohngeb_Einzugsgebiet.gpkg erzeugen lassen.

Nachdem das Werkzeug durchgelaufen ist, symbolisieren wir den erzeugten Layer nach der Spalte fid_count. In dieser Spalte wurde gezählt, in wie vielen 500-Meter-Kindergarten-Einzugsgebieten die jeweiligen Wohngebäude liegen.

Wir öffnen die Layereigenschaften des neu erzeugten Layers durch einen Doppelklick. Im Reiter Symbolisierung wählen wir die Darstellungsmethode Kategorisiert und geben unter Spalte die neue Spalte fid_count an. Nachdem wir auf Klassifizieren geklickt haben, wir für jeden Wert, der in dieser Spalte vorkommt, eine Darstellungsklasse angelegt. Durch einen Doppelklick auf das farbige Symbol, können wir die Darstellung für jede Klasse manuell vornehmen. Es empfiehlt sich ein Rotton für die Null-Klasse, da diese Wohngebäude in keinem Einzugsgebiet liegen. Für die Klassen, für die die Wohngebäude in einem oder in mehreren Einzugsgebiete liegen, sind abgestufte Grüntöne sinnvoll.

Gratulation! Wir können jetzt darstellen, ob und wenn ja, in wie vielen Einzugsgebiete sich Wohngebäude befinden.

Wir erinnern uns an unsere Ausgangsfragestellung: „Wie hoch ist der Anteil der Wohngebäude, für die sich ein Kindergarten innerhalb einer fußläufigen Entfernung von 500 Metern befindet?“ Um diese Frage zu beantworten müssen wir die Anzahl der Wohngebäude innerhalb der erzeugten Einzugsgebiete durch die Gesamtanzahl der Wohngebäude teilen. Hierzu gibt es mehrere Möglichkeiten. Eine sehr schnelle und einfache Möglichkeit ist es, die entsprechenden Wohngebäude zu selektieren und dann abzulesen, wie viele Wohngebäude selektiert wurden. Das ist, wie gesagt, eine recht einfache Methode. Im nächsten Praxisteil werden wir das Ganze etwas systematischer angehen (siehe nächster Abschnitt), aber für jetzt reicht uns das, um die Fragestellung zu beantworten.

Zunächst selektieren wir alle Wohngebäude, die innerhalb unseres Untersuchungsgebietes liegen. Dazu verwenden wir das Werkzeug Vektor --> Forschungswerkzeuge --> Nach Position selektieren…

Wir stellen das Werkzeug so ein, dass sich, von oben nach unten gelesen, folgender Satz ergibt: Wir wählen die Objekte aus Wohngebaeude aus, die innerhalb von Bergheim liegen und erzeugen dabei eine neue Auswahl.

Nachdem das Werkzeug durchgelaufen ist, werfen wir einen Blick auf den Titel der Attributtabelle des Layers Wohngebaeude. Hier sehen wir, dass 17671 Wohngebäude ausgewählt wurden, die sich innerhalb von Bergheim befinden.

Als nächstes selektieren wir die Wohngebäude, die sowohl innerhalb des Untersuchungsgebietes, als auch innerhalb der Kindergarten-Einzugsgebiete liegen.

Dazu öffnen wir erneut das Werkzeug Vektor --> Forschungswerkzeuge --> Nach Position selektieren…

Diesmal stellen das Werkzeug so ein, dass sich, wieder von oben nach unten gelesen, folgender Satz ergibt: Wir wählen die Objekte aus Wohngebaeude aus, die schneiden Objekte aus Konvexe Hülle (das sind die Einzugsgebiete). Zugegebenermaßen, muss man sich bei dieser Formulierung Meister Yoda vorstellen, aber es hilft, um das richtige geometrische Prädikat auszuwählen. Ganz wichtig (!): Um nur Wohngebäude zu berücksichtigen, die innerhalb des Untersuchungsgebietes liegen, sollten wir diesmal die Option innerhalb der aktuellen Auswahl wählen angeben!

Wenn das Werkzeug durchgelaufen ist, werfen wir erneut einen Blick auf den Titel der Attributtabelle. Wir sehen, dass 6992 Wohngebäude in Bergheim in einem fußläufigen Abstand von 500 Metern zum nächsten Kindergarten liegen.

Gratulation! Wir können unsere Anfangsfragestellung jetzt beantworten: Der Anteil der Wohngebäude, für die sich ein Kindergarten innerhalb einer fußläufigen Entfernung von 500 Metern befindet beträgt ca. 39.6% (6992/17671)“.

Nachteile unserer Methodik ist allerdings, dass nur ein fester Abstand zum nächsten Kindergarten berücksichtigt wurde. Nehmen wir an, ein Wohngebäude liegt gerade an der Grenze eines identifizierten Einzugsgebietes. Das würde bedeuten, dass wir für dieses Gebäude eine gute fußläufige Erreichbarkeit von Kindergärten zuordnen würden. Dieses Gebäude liegt in einer fußläufigen Entfernung von, sagen wir mal, 495 Metern zum nächstgelegenen Kindergarten. Für das Nachbargebäude beträgt diese Entfernung, sagen wir, 503 Meter, weswegen wir ihm eine schlechte Erreichbarkeit von Kindergärten zuweisen. Diese Ganz-Oder-Gar-Nicht-Methodik ist nicht sonderlich realitätsnah. Dem wollen wir uns jetzt ein wenig annehmen.

Als einfache Methode, um dieser Problematik gerecht zu werden, können wir natürlich nicht nur einen Dienstbereich, sondern direkt mehrere Dienstbereiche mit unterschiedlichen Entfernungen berechnen lassen. Das ist allerdings mühselig, weil wir jedes Mal die gleichen Klicks machen müssen. Das geht viel schneller und einfacher, wenn wir die sehr praktische Funktionalität der sogenannten Batch-Prozessierung nutzen. Dabei stellen wir einmal alles ein, sagen QGIS, dass es alles, was wir ihm im Stapel aufgetragen haben, ausführen soll, holen uns einen Kaffee, genießen dieses Heißgetränk und wenn wir zurück an unseren Rechner kommen, hat QGIS (hoffentlich) alles für uns erledigt. Das spart Klickerei, Zeit und Nerven und verhindert an vielen Stellen Flüchtigkeitsfehler.

Wir öffnen erneut das Werkzeug Dienstbereich (aus Layer) und klicken links unten auf Als Batchprozess starten… Jetzt sehen wir alle Einstellungen, die wir vorher untereinander im Werkzeug-Fenster gemacht haben, als Zeile aufgelistet. Das soll uns nicht weiter abschrecken. Wir stellen alles genau so wie wir es gewohnt sind ein, nur dass wir jetzt von links nach rechts statt von oben nach unten arbeiten müssen. Bei Netzwerk-Vektorlayer klicken wir auf die drei Punkte und dann auf Wähle aus geöffnetem Layern… Wir setzen ein Häkchen bei Wegenetz um diesen Layer auszuwählen. Auf gleiche Weise gehen wir vor, um bei Startpunkt-Vektorlayer den Layer Kindergarten_alle, bei Zu berechnender Pfadtyp die Option Kürzeste und bei Reisekosten den Wert 100 einzustellen. Bei Dienstbereich (Linien) navigieren wir zu einem geeigneten Speicherort und tippen den Dateinamen 100m.gpkg ein. Das Gleiche machen wir bei Dienstbereich (Grenzknoten) und tippen hier den Namen Knoten100m.gpkg ein. Anschließend klicken wir auf am oberen Rand des Werkzeug-Fensters auf (Zeile hinzufügen). Wir kopieren alle Werte von der ersten Zeile in die zweite Zeile und ändern nur die Entfernung von 100 Metern zu 200 Metern und die Namen der zu speichernden Dateien von 100m.gpkg zu 200m.gpkg sowie von Knoten100m.gpkg zu Knoten200m.gpkg. Diesen Vorgang wiederholen wir, bis wir für alle Entfernungen von 100 Metern bis 8000 Metern im 100 Meter-Abstand eine Zeile angelegt haben.

Wenn wir alles eingestellt haben, klicken wir auf (Speichern), wählen einen geeigneten Speicherort und geben einen sinnvollen Namen ein, bspw. Netzwerkanalysen_Batch.json. Das hat den Vorteil, dass wir die Einstellungen, die wir gerade gemacht haben, nicht erneut machen müssen, wenn wir die gleiche Analyse noch einmal ausführen möchten, wenn sich bspw. die Datenlage geändert hat. In dem Fall würden wir die geänderten Daten einladen und dann in diesem Werkzeug-Fenster auf (Öffnen) klicken, um alle Einstellungen aus der gerade gespeicherten Datei zu lesen.

Nachdem wir noch mal alles überprüft haben, klicken wir auf Im Hintergrund ausführen und holen uns ein Leckerchen…

Nachdem alle Berechnungen durchgeführt wurden, klicken wir auf OK und dann auf Schließen. Wir fügen die gerade berechneten Dienstbereiche aus den jeweiligen GeoPackages unserem QGIS-Projekt hinzu (über Drag & Drop des QGIS-Browsers oder die Datenquellenverwaltung) und sehen, dass diese Netzwerkanalyse ein deutlich differenziertes Bild darstellt.

Herzlichen Glückwunsch! Wir könne jetzt nicht nur eine differenzierte Netzwerkanalyse durch das Gehwegenetz durchführen. Wir können darüber hinaus die Batch-Prozessierung nutzen, um uns viel Klick-Arbeit und Zeit zu sparen.

Tipp: In QGIS lässt sich jedes Werkzeug als Batch-Prozess ausführen.

Tipp: Sollten wir unsere Arbeitsabläufe noch weiter automatisieren wollen, können wir den sogenannten Graphical Modeller oder die Programmiersprache Python nutzen.

Wir haben es geschafft! Jetzt liegt es nur noch an unserer Kreativität diese Ergebnisse ansprechend zu präsentieren. Wir nutzen die Kenntnisse aus der QGIS-Analyst-Schulung, um eine ansprechende Karte unserer Ergebnisse zu erstellen. Im nächsten Schulungsteil werden wir dann auch noch ein paar fortgeschrittene Darstellungsmethoden kennenlernen.

Wir wollen in diesem Schritt unsere Stadtteile selbst frei-hand definieren. Dazu zerschneiden wir unser Gemeindegebiet in einzelne Stadtteile, wobei wir die Topologie, d.h. die Beziehung der Objekte untereinander beachten.

Hinweis: Diesen Arbeitsschritt führen wir als Übung durch. Im wahren Leben werden Stadtteile oder statistische Bezirke nicht frei-hand und erst recht nicht im Alleingang definiert. Im Optimalfall basieren die Einteilungen auf teilweise historisch gewachsenen topographischen Besonderheiten und zusätzlich statistischen Verfahren und in enger Zusammenarbeit aller Abteilungen und Akteuren.

Im ersten Schritt erstellen wir eine Kopie unseres Layers Bergheim im GeoPackage Uebungsdaten.gpkg und benennen ihn dann in Stadtteile um. Dazu laden wir diesen Layer zunächst in unser QGIS-Projekt (bspw. per Drag & Drop aus dem QGIS-Browser) und speichern ihn dann wieder mit Hilfe des DB Managers unter neuem Namen zurück in das GeoPackage.

Frage: Was würde passieren, wenn wir statt dieser Vorgehensweise den Layer Bergheim im QGIS-Projekt duplizieren würden?

Anschließend laden wir diesen neuen Layer in QGIS ein.

Bevor wir mit der Bearbeitung beginnen, wollen wir noch das sogenannte Fangen/Einrasten (Snaping) einstellen, was uns dabei hilft, dass wir lückenlos an bestehende Strukturen anschließen und so die Topologie berücksichtigen. Dazu klicken wir in der Menüleiste auf Projekt --> Einrastoptionen…

In dem sich öffnenden Fenster schalten wir die Snapping-Funktionalität ein, indem wir auf (Einrasten einstellen) klicken. Dann stellen wir ein, dass wir auf den Aktiven Layer snappen wollen und zwar auf Stützpunkt und Segment. Die Toleranz soll dabei 12 px betragen. Außerdem schalten wir noch das Einrasten auf Schnittpunkte ein, indem wir auf die entsprechende Fläche klicken.

Danach schließen wir dieses Fenster wieder und aktivieren die Bearbeitung, indem wir mit einen Rechtsklick auf eine freie Stelle in der Menüleiste machen, dann ein Häkchen bei Digitalisierungswerkzeugleiste setzten. Außerdem setzten wir ein Häkchen bei Erweiterte Digitalisierungswerkzeugleiste, wodurch wir noch ein paar zusätzliche Werkzeuge für den Schnellzugriff in der Werkzeug-Leiste bekommen. Dann klicken wir auf (Bearbeitungsstatus umschalten), um in den Bearbeitungsmodus zu schalten.

Um unser Stadtgebiet in Stadtteile zu zerlegen klicken auf (Objekte zerteilen) und können jetzt mit mehreren Linksklicks eine Trennlinie zur Aufteilung des Stadtgebietes einzeichnen. Die Teilung schließen wir dann mit einem Rechtsklick ab. Das Ganze wiederholen wir, bis das Stadtgebiet in Stadtteile aufgeteilt ist. Haben wir uns im Laufe der Erstellung einer Trennlinie vertan, können wir diese Linie mit Esc abbrechen. Zur Übersicht:

Einfacher Klick --> neuen Stützpunkt für eine Trennlinie setzen

Rechtsklick --> Trennung durchführen

Esc --> Trennlinie abbrechen

Achtung: Unsere Trennlinien sollten immer über das zu zerteilende Objekt hinausragen oder wenigstens bündig abschließen (wobei das Snapping hilft)!

Ein Stadtteil im Norden unseres Untersuchungsgebietes ist ein bisschen klein geraten. Wir wollen es dem östlichen Viertel anschließen. Wir klicken in der Werkzeug-Leiste auf (Objekte über Rechteck oder Einzelklick wählen) und selektieren die beiden Stadtteile, die wir zusammenführen wollen:

Anschließend klicken wir auf (gewählte Objekte verschmelzen).

Im sich öffnenden Fenster sehen wir ein Übersicht darüber, wie bei der Verschmelzung mit den einzelnen Attributen umgegangen werden soll. Wir sehen die Attribute der einzelnen Objekte (Zeile 2 und 3) und auch, wie die Attribute nach der Verschmelzung aussehen werden (Zeile 4). Im unteren Teil haben wir die Möglichkeit verschiedene Optionen auszuwählen, um vorzugeben wie die Attribute übernommen werden sollen.

Da in unserem Falle aber alle Attribute gleich sind (sie stammen ja aus ein und demselben Geoobjekt, nämlich dem Gemeindeumriss), sind diese Optionen für uns eher uninteressant. Wir klicken einfach auf OK.

Außerdem haben wir beim Zerschneiden vergessen einen Stützpunkt zu setzen. Das holen wir nach, indem wir in der Werkzeug-Leiste auf (Knotenwerkzeug) klicken. Wenn wir jetzt mit der Maus in der Karte über einzelne Stützpunkte fahren, werden diese etwas größer, um anzuzeigen, dass wir sie selektieren können. Uns ist aufgefallen, dass eine Grenze zwischen zwei Stadtteilen zu weit südlich verläuft. Wir verschieben einen Stützpunkt einer Grenze zwischen zwei Stadtteilen, indem wir ihn anklicken und durch einen erneuten Klick an einer anderen Stelle wieder absetzten. Auch diesmal können wir jederzeit durch die ESC-Taste die aktuelle Bearbeitung abbrechen.

Das hat ja super geklappt. Allerdings ist jetzt eine Lücke entstanden. Darum werden wir uns später noch kümmern.

Als nächstes fügen wir einen zusätzlichen Stützpunkt in eine Stadtteil-Grenze ein. Dazu fahren wir mit der Maus über den Mittelpunkt einer Kante und klicken dann auf das kleine Plus. Durch einen erneuten Klick wird an der entsprechenden Stelle ein Stützpunkt eingefügt. Wir üben das mal an einer Stadtteil-Grenze. Auch diesmal können wir jederzeit durch die ESC-Taste die aktuelle Bearbeitung abbrechen.

Wir wollen noch einen Stützpunkt verschieben und probieren, ob sich solch eine Lücke nicht schon während der Bearbeitung automatisch schließen lässt. Dazu öffnen wir noch mal die Snapping-Optionen in der Menü-Leiste unter Projekt --> Einrastoptionen… In dem sich öffnenden Fenster aktivieren wir das Topologische Editieren durch einen Klick auf die entsprechende Fläche.

Anschließend verschieben wir erneut einen Stützpunkt einer Stadtteil-Grenze.

Das Topologische Editieren sorgt dafür, dass Stützpunkte, die aufeinander liegen, immernoch übereinander liegen, wenn einer der beiden Stützpunkte verschoben wird. Das wird dadurch erreicht, dass beide Stützpunkte sozusagen aneinander geklebt werden und nur gemeinsam verschoben werden können. Dadurch wird vermieden, dass Lücken entstehen.

Abschließend wollen wir noch Phantasienamen für die erstellten Stadtteile eingeben. Dazu klicken wir rechts unten in der Attributtabelle auf (auf Formularansicht umschalten), um die Attribute auf bequeme Weise in ein Formular antragen zu können. Wir klicken links die einzelnen Stadtteile durch und ändern rechts jeweils den Eintrag unter GEN.

Zum Schluss klicken wir erneut auf und bestätigen, dass wir unsere Änderungen speichern wollen.

Tipp: Arbeiten wir länger im Bearbeitungsmodus, sollten wir zwischendurch immer wieder unsere Änderungen speichern. Dazu genügt es nicht das QGIS-Projekt zu speichern (!), da hier lediglich die Darstellung der Daten gespeichert wird (welche Layer sollen wie visualisiert werden). Um die Daten selbst, also deren Geometrie und Attribute, zu speichern klicken wir auf .

Geschafft! Wir können jetzt Layer unter Berücksichtigung der Topologie und mit Hilfe der erweiterten Digitalisierungswerkzeuge editieren. Dabei nutzen wir auch die Funktionalitäten der automatischen Attributierung, sowie die Formular-Eingabe. Wir können dabei sowohl Objekte zerschneiden als auch einzelne Objekte miteinander verschmelzen.

Da wir die Geometrie der Stadtteile verändert haben, sollten wir, bevor wir damit weiterarbeiten, überprüfen, ob sich keine Lücken oder Überschneidungen eingeschlichen haben. Dazu werden wir zwei Erweiterungen nutzen. Zunächst installieren wir das Plug-In Topologie-Prüfung.

Wir klicken auf Erweiterungen --> Erweiterungen verwalten und installieren… Im Suchfeld geben wir Topologie ein und setzen ein Häkchen bei Topologie-Prüfung. Ggf. müssen wir rechts unten auf Erweiterung installieren klicken.

Anschließend öffnen wir die Topologie-Prüfung unter Vektor --> Topologie-Prüfung oder durch einen Klick auf (Topologie-Prüfung), was wir in der Werkzeug-Leiste finden, wenn wir die Vektorwerkzeugleiste aktivieren.

Wenn wir im sich öffnenden Fenster auf (Konfigurieren) klicken, haben wir die Möglichkeit verschiedene Regeln zu definieren, die überprüft werden sollen.

Als erste zu überprüfende Regeln wählen wir: Der Layer Stadtteile darf keine Lücken haben. Als zweite Regel definieren wir: Der Layer Stadtteile darf sich nicht überlappen. Die einzelnen Regeln fügen wir hinzu, indem wir auf Regel hinzufügen klicken. Nachdem wir unsere Regeln definiert haben, klicken wir auf OK.

Wenn wir im Hauptfenster auf (Alle prüfen) klicken, werden die von uns definierten Regeln überprüft. Offensichtlich haben wir nicht so gut gearbeitet, da Fehler gefunden werden.

Im Fenster der Topologie-Prüfung sehen wir die entsprechenden Einträge:

Durch einen Klick auf einen Eintrag wird auf den gefunden Fehler gezoomt, den wir dann wie im vorherigen Abschnitt bearbeiten können. Allerdings müssen wir hier manuell arbeiten. Einfacher geht es mit dem zweiten Plug-In, was wir an dieser Stelle nutzen wollen, der Geometrieprüfung.

Wir installieren diese Erweiterung wie gehabt unter Erweiterungen --> Erweiterungen verwalten und installieren…, indem wir in die Suchleiste Geometrie eingeben und dann ein Häkchen bei Geometrieprüfung setzen, bzw. das Plug-In installieren.

Die Geometrieprüfung öffnen wir durch einen Klick auf Vektor --> Geometrien prüfen…

In dem sich öffnenden Fenster wählen wir bei Eingabevektorlayer den Layer Stadtteile. Wie wir sehen, haben wir in diesem Werkzeug sehr viele Möglichkeiten nach einer ganzen Bandbreite von Fehlern zu suchen und diese automatisiert korrigieren zu lassen. Es lohnt sich hier mal ein wenig herumzustöbern, um zu sehen, welche Probleme wir mit diesem Werkzeug versuchen können zu lösen. Das wird uns helfen, wenn wir dann mal in diese Probleme hineinlaufen werden. Wir beschränken uns in diesem Beispiel nur auf Lücken und Überlagerungen.

Im Abschnitt Topologieprüfungen setzen wir ein Häkchen bei Überlappen kleiner als prüfen (Karteneinheiten²) und bei Lücken kleiner als prüfen (Karteneinheiten²). Als Wert geben wir jeweils 3,000,000 m² ein, da wir sehr schlampig gearbeitet haben und tatsächlich so riesige Lücken entstanden sind.

Im Abschnitt Ausgabevektorlayer wählen wir GeoPackage als Format und klicken bei Ausgabeverzeichnis auf Durchsuchen. Wir navigieren zu unserem Ordner namens Uebungsdaten und erstellen einen neuen leeren Ordner durch einen Rechtsklick à Neuer Ordner. Diesen neuen Ordner nennen wir GeometrieCheck. Nachdem wir alles noch einmal überprüft haben, klicken wir auf Starte, um die Überprüfung durchzuführen.

Wie wir sehen, werden durch die Geometrieprüfung die gleichen Fehler gefunden wir bei der Topologie-Prüfung. Durch einen Klick auf die einzelnen Zeilen im Geometrieprüfungsergebnis bekommen wir auch hier die entsprechenden Stellen in der Karte angezeigt. Der Unterschied zur Topologie-Prüfung besteht darin, dass wir die gefundenen Fehler automatisiert korrigieren lassen können.

Dazu markieren wir die entsprechenden Zeilen im Geometrieprüfungsergebnis und klicken dann auf Gewählte Fehler mit vorgegebener Fehlerlösung beheben. Diese vorgegebene Fehlerlösung können wir, wenn wir das wollen, unter Fehlerlösungsoptionen einstellen. Alternativ können wir die Fehler auch durch einen Klick auf Fehlerlösung zu gewählten Fehlern abfragen klicken. Dadurch werden wir bei jedem gefundenen Fehler gefragt, wie er gelöst werden soll.

Herzlichen Glückwunsch! Wir können jetzt Topologie- und Geometrie-Fehler in unseren Daten ausfindig machen und automatisiert korrigieren.

Tipp: Topologie- und Geometrie-Fehler führen oft zu Problemen und unerwartetem Verhalten verschiedener Werkzeuge. Sollten Probleme auftauchen, die wir uns nicht erklären können, ist es eine gute Idee die Topologie bzw. die Geometrie unserer Geodaten zu überprüfen.

Normalerweise versuchen wir so präzise wie möglich zu arbeiten. In manchen Fällen interessieren uns aber nicht die exakte Lage und Geometrie von Objekten. Wir wollen vielmehr unsere Daten mit einem Eindruck der räumlichen Geometrie vermitteln. Das kann gestalterisch ansprechend sein und hat den netten Nebeneffekt, dass sich die Datenmenge verringert. In diesem Abschnitt wollen wir den Umriss unserer Beispielkommune für Präsentationszwecke stark vereinfachen.

Dazu kopieren wir, wie schon bei der Erstellung der selbst definierten Stadtteile, den Layer Bergheim mit Hilfe des DB Managers und benennen den neuen Layer mit Bergheim_vereinfacht.

Wir fügen den neuen Layer Bergheim_vereinfacht in QGIS ein und schalten erneut den Bearbeitungsmodus ein, indem wir zuerst auf den neuen Layer und dann auf klicken. Falls wir das erweiterte Digitalisierungsfenster noch nicht aktiviert haben, können wir das jetzt tun, indem wir einen Rechtsklick auf eine freie Stelle in der Werkzeug-Leiste machen und ein Häkchen bei Erweitertes Digitalisierungsfenster setzen.

In der Werkzeugleiste des erweiterten Digitalisierungsfensters klicken wir auf (Objekt vereinfachen) und ziehen anschließend ein Fenster um den Umriss unserer Kommune.

In dem sich öffnenden Fenster wählen wir als Methode zur Vereinfachung die Option Nach Abstand vereinfachen. Außerdem können wir angeben, wie stark vereinfacht werden soll. Wir geben eine Toleranz von 300 Layereinheiten (= Meter, da wir im Koordinatensystem mit EPSG-Code 25832 arbeiten ; ) an. Uns wird dann auch direkt angezeigt, dass unsere Geometrie im Augenblick 171 und nach der Vereinfachung nur noch 34 Stützpunkte, also nur noch 19 % haben wird (entsprechend weniger Daten müssen gespeichert und verarbeitet werden).

In der Karte sehen wir in der Voransicht, wie sich die Vereinfachung optisch auswirken wird (halbtransparenter Umriss).

Wenn wir mit der Voransicht zufrieden sind, klicken wir auf OK und beenden den Bearbeitungsmodus, indem wir erneut auf klicken. In dem sich öffnenden Fenster bestätigen wir, dass wir die Änderungen Speichern wollen.

Herzlichen Glückwunsch! Wir können Geometrien zu Darstellungszwecken mit den erweiterten Digitalisierungswerkzeugen stark vereinfachen.

Tipp: Alternativ können wir auch das Werkzeug Vektor --> Geometrie-Werkzeuge --> Geometrien vereinfachen nutzen.

Oft macht es Sinn, Daten nicht direkt in absoluten Zahlen kartographisch darzustellen, sondern sie vorher auf die zugrundeliegende Fläche oder auch auf die Gesamteinwohnerzahl zu beziehen. In diesem Abschnitt werden wir zunächst die Siedlungsflächen in unser QGIS-Projekt laden, die Flächen auf die Stadtteile aggregieren und schließlich (mit Pseudodaten) die Kinder im Kindergartenalter pro besiedeltem Meter berechnen.

Wir laden uns die Layer Siedlungsflaeche und Stadtteile_ALKIS aus dem GeoPackage Zusatzdaten in unser QGIS-Projekt.

Hinweis: Die Übungsdaten zu diesem Abschnitt wurden, wie im zweiten Teil der Schulung, aus offenen Datenquellen bezogen. Beide Datensätze stammen aus dem ALKIS-Datenbestand, der von der Bezirksregierung Köln als Open Data vorgehalten wird. Wenn wir die Datenbeschaffung und –Aufbereitung nachvollziehen wollen, gehen wir wie folgt vor (siehe auch Teil 2 dieser Schulung):

Für den Layer Siedlungsflächen: Wir laden uns den WFS-Dienst mit der URL https://www.wfs.nrw.de/geobasis/wfs_nw_alkis_vereinfacht? in unser QGIS-Projekt und speichern den Layer „Nutzung“ für das Untersuchungsgebiet lokal. Anschließend filtern wir anhand der Spalte „nutzart“ nach den Einträgen „Wohnbauflaeche“ und „Faeche Gemischter Nutzung“.

Für den Layer Stadtteile_ALKIS: Wir nutzen den gleichen WFS-Dienst und speichern uns diesmal den Layer „KatasterBezirk“ für unser Untersuchungsgebiet lokal. Wir nutzen das Werkzeug „Räumliche Abfrage“, um alle Features in unserem Untersuchungsgebiet auszuwählen und löschen alle Features, die in der Spalte „ueboname“ keinen Eintrag haben. Anschließend nutzen wir das Werkzeug „Auflösen“, um nach dem Feld „ueboname“ aufzulösen. Achtung: Diese Daten beinhalten Topologiefehler! Für unsere Übungs-Zwecke ist das nicht so tragisch. Wenn wir aber mit den Daten ernsthaft weiterarbeiten wollen, sollten wir sorgfältig nach Topologie-Fehlern (Lücken, Überschneidungen, Ringe in Features) suchen.

Ein Blick in die Attributtabelle von Stadtteile_ALKIS zeigt, dass in der Spalte Kinder die Anzahl der Kinder im Kindergartenalter gespeichert ist (Pseudodaten).

Zunächst müssen wir die individuellen Flächengrößen der Siedlungsflächen berechnen. Dazu klicken wir auf den Layer Siedlungsflaechen, um ihn zu aktivieren und öffnen dann den Feldrechner durch eine Klick auf . Alternativ können wir auch die Tastenkombination Strg+I verwenden.

Im Feldrechner setzen wir ein Häkchen bei Neues Feld anlegen, nennen es Flaeche und geben den Ausgabefeldtypen Dezimalzahl (real) vor. Für die Berechnung des Flächeninhaltes suchen wir in der Kategorie Geometrie und finden dort die Funktion $area. Wenn wir einmal auf den Funktionsnamen klicken, können wir in der Beschreibung lesen, dass diese Funktion genau das macht, was wir suchen, nämlich den Flächeninhalt für jedes Feature berechnen. Also fügen wir diese Funktion durch einen Doppelklick in unseren Ausdruck ein und klicken dann auf OK.

In der Attributtabelle sehen wir, dass eine neue Spalte mit den Flächeninhalten für jede individuelle Siedlungsfläche angelegt wurde.

Tipp: Alternativ können wir auch das Werkzeug Vektor --> Geometrie-Werkzeuge --> Geometrieattribute Hinzufügen… nutzen, um die Flächeninhalte der einzelnen Features zu berechnen.

Als nächstes wollen wir diese Werte auf die Stadtteile aggregieren. Dazu klicken wir in der Werkzeugkiste auf Vektoren allgemein --> Attribute nach Position verknüpfen (Zusammenfassung).

Im Werkzeug-Fenster geben wir Stadtteile_ALKIS als Eingabelayer und Siedlungsflaeche unter Layer verknüpfen an. Da die Siedlungsflächen zusammengerechnet werden sollen, die sich in den jeweiligen Stadtteilen befinden, setzen wir ein Häkchen bei enthält. Ganz wichtig: Als Zusammenfassende Felder wählen wir Flaeche und unter Zu berechnende Zusammenfassung setzen wir ein Häkchen bei Summe, damit die Summe der jeweiligen Siedlungsflächen berechnet wird. Bei Zusammengefasster Layer lassen wir die Standardeinstellung Temporärlayer erzeugen stehen und klicken auf Starte. Nachdem das Werkezeug fertig gearbeitet hat, klicken wir auf Schließen.

In der Attributtabelle des erzeugten Layers sehen wir, dass in der Spalte Flaeche_sum die Siedlungsfläche für jeden Stadtteil berechnet wurde.

Zum Schluss müssen wir nur noch die Anzahl der Kinder im Kindergartenalter auf die berechnete Siedlungsfläche beziehen. Dazu öffnen wir wieder den Feldrechner mit einem Klick auf oder durch die Tastenkombination Strg+I.

Im Feldrechner geben wir an, dass wir ein Neues Feld anlegen möchten, nennen es Kinder_relativ und definieren den Ausgabefeldtyp als Dezimalzahl (real). Als Ausgabefeldlänge geben wir 10 und als Genauigkeit geben wir 5 an. Wir möchten die Anzahl der Kinder im Kindergartenalter durch die Siedlungsfläche teilen. Dazu klicken wir in der Kategorie Felder und Werte doppelt auf Kinder, dann auf und dann doppelt auf Flaeche_sum. Damit die Werte nicht sehr klein werden klicken wir außerdem noch auf und geben den Wert 1000 ein, um die Werte nicht pro m², sondern pro 1000 m² zu erhalten. Nachdem wir überprüft haben, dass alles richtig eingestellt ist, klicken wir auf OK. Um die Änderungen zu speichern, müssen wir durch einen Klick auf den Bearbeitungsmodus verlassen und das Speichern bestätigen.

Schließlich können wir die neue Spalte visualisieren, indem wir die Layereigenschaften öffnen und im Reiter Symbolisierung die Darstellungsmethode Abgestuft wählen. Als Spalte wählen wir die gerade berechnete Spalte Kinder_relativ, als Genauigkeit wählen wir 3 Nachkommastellen. Der Farbverlauf soll von weiß nach blau verlaufen. Als Klassifizierungsmodus wählen wir Natürliche Unterbrechungen (Jenks) und 5 Klassen. Wir Klicken auf Klassifizieren und anschließend auf OK.

Glückwunsch! Wir können jetzt unsere Daten auf Flächen beziehen. Dadurch können wir kartographisch aussagekräftigere Karten erzeugen. Wir können bspw. unsere Daten auf die Siedlungsfläche beziehen, indem wir den Flächeninhalt für die individuellen Siedlungsflächen berechnen und diese anschließend auf Stadtteile aggregieren. Die relativen Werte können wir dann berechnen, indem wir unsere Daten durch die jeweiligen Siedlungsflächen teilen.

Ein sehr realitätsnahes Szenario ist es, dass wir interessante Ergebnisse produzieren, die wir aus datenschutzrechtlichen Bedenken nicht weiterreichen oder veröffentlichen. Das ist oft sehr schade, da diese Ergebnisse zur informierten Entscheidungsfindung und schließlich effizienteren Planung beitragen könnten.

In den nächsten beiden Abschnitten wollen wir zwei Methoden zur datenschutz-konformen Darstellung sensibler Daten kennenlernen.

Wir laden uns den Layer Pseudoeinwohner aus dem GeoPackage Zusatzdate.gpkg in unser QGIS-Projekt.

Hinweis: Diese Pseudoeinwohner wurden mit dem Werkzeug Vektor --> Forschungswerkzeuge --> Zufällige Punkte in Polygonen erzeugt.

Wie wir sehen gibt es Stadtteile, in denen nur wenige Einwohner leben, die uns für unsere Fragestellung interessieren. Es wäre allerdings sehr schade diese Daten nicht trotzdem für sinnvolle Zwecke zu nutzen. Wir werden die Daten auf ein Analysegitter aggregieren, was wir zunächst einmal erzeugen werden.

Dazu klicken wir auf Vektor --> Forschungswerkzeuge --> Gitter Erzeugen…

In dem sich öffnenden Fenster wählen wir unter Gittertyp die Einstellung Hexagon (Polygon). Unter dem Punkt Gittergrenze von Layer klicken wir auf und dann auf Layerausmaße bearbeiten. In dem sich öffnenden Fenster wählen wir unser Untersuchungsgebiet Bergheim. Als Horizontalen Abstand und Vertikalen Abstand geben wir jeweils 250 Meter an. Das Koordinatensystem (Grid CRS) stellen wir auf den EPSG-Code 25832 ein. Die Ausgabe lassen wir als Temporärlayer erzeugen und klicken auf Starte.

Wie wir sehen, wurde ein Analysegitter für unser Untersuchungsgebiet mit einer Zellengröße von 100 x 100 Metern erzeugt.

Jetzt müssen wir nur noch die Einwohnerdaten auf das Gitter aggregieren. Dazu nutzen wir wieder das Werkzeug aus der Werkzeugkiste Vektor allgemein --> Attribute nach Position verknüpfen (Zusammenfassung).

Als Eingabelayer wählen wir das gerade erzeugte Gitter und unter Layer verknüpfen den Layer Pseudoeinwohner. Da wir in einer Gitterzelle alle Einwohner zusammenfassen wollen, die diese Gitterzelle enthält, setzt wir ein Häkchen bei enthält. Unter Zusammenzufassende Layer setzen wir ein Häkchen bei fid und bei Zu berechnende Zusammenfassung wählen wir Anzahl, um die Einwohnerzahl zu aggregieren.

Tipp: Unsere Einwohnerdaten tragen im wahren Leben weitere Attribute, für das arithmetisches Mittel, die Minimal- und Maximalwert sowie der Median sinnvoller sein können als die Anzahl. Bspw. wäre es für das Alter sinnvoll, das Durchschnittsalter pro Gitterzelle berechnen zu lassen.

Die Option Zusammengefasster Layer belassen wir beim Standard-Wert Temporärlayer erzeugen und klicken auf Starte.

In der Attributtabelle des erzeugten Layers sehen wir, dass in den meisten Gitterzellen keine Einwohner leben. In diesen Zellen ist bspw. das Feld id_count leer, bzw. es enthält den Eintrag NULL. Wenn wir weiter runterscrollen werden wir allerdings auch Zellen entdecken, in denen Einwohner leben.

Das Feld fid_count wollen wir schließlich visualisieren. Dazu öffnen wir die Layereigenschaften, klicken auf den Reiter Symbolisierung und wählen als Darstellungsmethode Abgestuft. Als darzustellende Spalte wählen wir fid_count, eine Genauigkeit von 0 Nachkommastellen, als Farbverlauf eine Palette, die von weiß nach blau verläuft, geben 5 Klassen vor und klicken auf Klassifizieren. Die unteren und oberen Grenzen der Klassen und die Legendeneinträge passen wir, so wie im Screenshot zu sehen, manuell durch Doppelklicks an. Außerdem geben wir eine Deckkraft von 90 % an, um den Layer ein wenig transparent zu machen.

Geschafft! Wir können jetzt sensible Einwohnerdaten auf ein Analysegitter aggregieren, indem wir zunächst das Gitter erzeugen und anschließend die Einwohnerdaten mit diesem Gitter verschneiden.

Eine weitere Methode zur Darstellung sensibler Daten besteht in sogenannten Heatmaps (Hitzekarten). Zunächst laden wir uns den Datensatz Pseudofaelle aus dem GeoPackage Zusatzdaten.gpkg in unser QGIS-Projekt. Die Punkte in diesem Layer sollen Fälle darstellen, die für eine bestimmte Fragestellung relevant sind und die auf personenbezogene sensible Daten zurückgehen. Bspw. könnte es sich um alleinerziehende Personen handeln, die in einem bestimmten Sozialbezug stehen. Für solch einen Anwendungsfall bietet sich eine Heatmap an, da sie anzeigt, wo sich mehrere Ereignisse häufen, nicht aber einzelne Fälle (wenn man die Einstellungen entsprechend vornimmt).

Das Heatmap-Werkzeug öffnen wir, indem wir in der Werkzeugkiste auf Interpolation --> Heatmap (Kerndichtenschätzung) klicken.

Im sich öffnenden Werkzeug-Fenster wählen wir den Layer Pseudofaelle als Punktlayer. Als Radius für die Suche der einzelnen Punkte geben wir 1000 Metern an, als Pixelbreite und Pixelhöhe jeweils den Wert 20. Wir geben an, dass die auszugebene Heatmap als Temporärlayer erzeugt werden soll und klicken auf Starte.

Wenn das Werkzeug fertig gearbeitet hat klicken wir auf Schließen und sehen unsere gerade erzeugte Heatmap.

Hm, naja, plausibel sieht es schon aus, aber wirklich nicht hübsch. Diese Karte wollen wir nun noch farblich darstellen. Dazu öffnen wir die Layereigenschaften der gerade erzeugten Heatmap. Im Reiter Symbolisierung wählen wir als Darstellungsart den Eintrag Einkanalpseudofarbe. Wir geben einen geeigneten Farbverlauf vor, bspw. YlOrRd (Gelb-Orange-Rot), klicken auf Klassifizieren und anschließend auf Anwenden.

Wenn wir das Layereigenschaften-Fenster ein Stück zur Seite schieben, sehen wir das Ergebnis dieser Visualisierung.

Das sieht ja schon etwas ansprechender aus. Das Problem ist allerdings, dass man anhand dieser Karte immer noch Rückschlüsse auf die Einzelfälle schließen kann.

Wir gehen zurück zu den Layereigenschaften und geben diesmal den Minimalwert 3 an. Damit schieben wir alle Rasterzellen, für die weniger als 3 Punkte in der Nähe liegen, in eine Klasse. Diese Klasse soll in der Karte nicht dargestellt werden. Dazu machen wir einen Doppelklick auf die Farbe in der ersten Klasse mit den Grenzen von 3 bis 3 (siehe Screenshot).

In dem sich öffnenden Fenster setzten wir die Deckkraft auf 0 % und bestätigen mit OK und dann nochmals mit OK. Diese Klasse wird also unsichtbar.

Die Karte lässt keine Rückschlüsse auf Einzelfälle zu, gibt aber recht genau die Bereiche wieder, in denen sich die Fälle von Interesse häufen.

Tipp: Weitere Gestaltungmöglichkeiten ergeben sich, durch bspw. Erhöhen der Klassenanzahl, Variation der Klassengrenzen und durch die Layer-Transparenz. Letzteres lässt sich für Raster-Layer in den Layereigenschaften im Reiter Transparenz einstellen.

Herzlichen Glückwunsch! Wir können jetzt Einzelfälle datenschutzkonform visualisieren, indem wir eine Heatmap erzeugen und diese entsprechend visualisieren.

Oft kommt es vor, dass man Karten für mehrere Gebiete erstellen möchte. Es kann je nach Anzahl der Gebiete recht mühselig und fehleranfällig sein, jede Karte einzeln anzufertigen. Glücklicherweise nimmt uns die Atlas-Funktion in QGIS viel Arbeit ab, indem sie diesen Prozess automatisiert und so für einen durchgehenden Stil sorgt.

In diesem Abschnitt werden wir für jeden Stadtteil in unserem Untersuchungsgebiet eine Karte mit der Anzahl der Kinder im Kindergartenalter pro 1000 m² Siedlungsfläche erstellen.

Dazu laden wir uns den Layer Stadtteile_Siedlungsflaeche in unser QGIS-Projekt und symbolisieren ihn, wie im Abschnitt Darstellung von Daten bezogen auf Siedlungsflächen beschrieben, nach der Spalte Kinder_relativ (wenn wir diesen Layer bereits aus dem vorherigen Abschnitt in unserem Projekt haben, überspringen wir diesen Schritt).

Anschließend klicken wir in der oberen Menü-Leiste auf Projekt --> Neues Drucklayout… und vergeben einen Namen, bspw. Stadtteile mit Atlas-Funktion.

Im neuen Drucklayout machen wir einen Rechtsklick auf das leere Blatt in der Mitte und klicken dann auf Seiteneigenschaften… Am rechten Bildschirmrand können wir dann im Reiter Elementeigenschaften die Papiergröße auf A4 (210x297 mm) und die Orientierung auf Querformat einstellen.

Wir nutzen, wie in der QGIS-Analyst-Schulung gelernt, die Schaltflächen am linken Bildschirmrand, um unserer Druckzusammenstellung Layout-Elemente hinzuzufügen.

(Karte zum Layout hinzufügen)

(Bild zum Layout hinzufügen)

(Beschriftung zum Layout hinzufügen)

(Legende zum Layout hinzufügen)

(Maßstab zum Layout hinzufügen)

(Form zum Layout hinzufügen)

(Pfeil zum Layout hinzufügen)

Jetzt wollen wir unseren Atlas generieren. In der oberen Menü-Leiste klicken wir auf Atlas à Atlas-Einstellungen. Anschließend klicken wir am rechten Rand auf den Reiter Atlas, setzen ein Häkchen bei Einen Atlas erzeugen, wählen Stadtteile_ALKIS als Abdeckungslayer und als Seitenname die Spalte ueboname.

Danach klicken wir auf die Karte und dann auf den Reiter Elementeigenschaften. Hier setzen wir ein Häkchen bei Gesteuert durch Atlas.

Als nächstes wollen wir auch noch die Überschrift dynamisch machen. Dazu klicken wir die Überschrift einmal an und danach auf den Reiter Elementeigenschaften. Unter Haupteigenschaften entfernen wir den Namen des Untersuchungsgebietes Bergheim und fügen stattdessen folgenden variablen Namen ein:

[% @atlas_pagename %]

Tipp: Variablen lassen sich vielfach nutzen. Sie können bspw. auch bei der Gestaltung in den Layereigenschaften verwendet werden.

Zusätzlich machen wir die Legende dynamisch, indem wir sie einmal anklicken und danach im Reiter Elementeigenschaften ein Häkchen bei Nur Objekte im aktuellen Atlas-Objekt anzeigen setzen.

Wenn wir jetzt in der Menü-Leiste auf (Atlas-Vorschau anzeigen) klicken, können wir mit den Pfeiltasten durch die einzelnen Stadtteile klicken.

Durch einen Klick auf (Atlas exportieren) in der oberen Werkzeug-Leiste können wir unseren Atlas in verschiedene Formate, bspw. PDF, exportieren.

Jetzt müssen wir nur noch einen Ordner festlegen, in den für jeden Stadtteil eine eigene PDF erstellt wird.

Glückwunsch! Wir können jetzt auf Knopfdruck für jeden Stadtteil eine eigene Karte im konsistenten Stil erzeugen. Dazu nutzen wir die QGIS-Funktion zur Atlas-Generierung.

Um die Datenerfassung und Datenpflege einfacher und weniger fehleranfällig zu machen, bietet es sich an, Datenformulare vorzubereiten. Beispielhaft werden wir in diesem Abschnitt ein Datenerfassungsformular für Spielplätze erstellen.

Durch einen Klick auf (Neuer GeoPackage-Layer) in der Werkzeugleiste erzeugen wir ein neues GeoPackage. Wir nennen das neue GeoPackage Spielplaetze.gpkg als Tabellennamen geben wir Spielplatz an und als Geometrietyp wählen wir Punkt. Wir stellen das Koordinatensystem auf EPSG:25832 ein und definieren dann noch ein paar Felder für die Attributtabelle, indem wir nacheinander die entsprechenden Einträge unter Name und Typ machen und dann auf Zur Feldliste hinzufügen klicken (siehe Screenshot).

Als nächstes definieren wir die Dateneingabemaske für unseren neuen Layer. Für das Feld Art wollen wir vordefinierte Werte einstellen. Dazu laden wir uns die Excel-Tabelle SpielplatzArt.xlsx aus dem Zusatzdatenordner per Drag&Drop in unser QGIS-Projekt. Wir öffnen die Tabelle und gucken sie uns erstmal an.

Den Import hat gut funktioniert. Die Tabelle hat ein ID-Feld und ein Feld namens Art.

Als nächstes öffnen wir die Layereigenschaften des Layers Spielplatz und klicken auf den Reiter Attributformular. Im mittleren Teil des Fensters klicken wir auf Art und wählen im rechten Teil des Fensters unter Bedienelementtyp die Option Wertbeziehung. Als Layer wählen wir die Tabelle SpielplatzArt Tabelle1. Bei Schlüsselspalte und bei Wertspalte geben wir jeweil die Spalte Art an.

Als nächstes stellen wir das Eingabefeld für die Anzahl der Rutschen ein. In der Mitte klicken wir auf nRutschen und wählen dann im rechten Teil des Fensters unter Bedienelementtyp die Option Bereich und darunter die Option Schieber. Wir geben 0 als Minimun und 10 als Maximum an.

Jetzt stellen wir noch das Formular für das Feld geprueft ein. Dazu klicken wir im mittleren Fenster auf geprueft und scrollen rechts ganz runter. Hier finden wir den Abschnitt Vorgaben, wo wir wir Standardwerte vergeben können. Bei Vorgabewert tippen wir $now ein und setzten ein Häkchen bei Vorgabewert bei Aktualisierung anwenden. Dadurch wird der Wert in der Spalte geprueft immer dann auf das aktuelle Datum gesetzt, wenn wir ein Objekt bearbeiten.

Als letztes wollen wir noch einstellen, dass die ID, also die Identifikationsnummer, für alle Spielplätze automatisch fortgeführt wird. Dazu klicken wir in der Mitte auf oid und wählen dann rechts unter Bedienelementtyp die Option UUID-Generator.

Damit es bei der Dateneingabe möglichst schnell geht und wir nicht durch unnötige Felder gestört werden, verstecken wir noch die Felder, die wir nicht bearbeiten wollen. Dazu klicken wir in der Mitte die Felder aktualit, nutzart, bez und name an und stellen auf der rechten Seite jeweils den Bedienelementtyp auf Versteckt.

Anschließend klicken wir auf OK. Jetzt wollen wir doch mal sehen, ob unser Datenformular funktioniert. Wir klicken in der oberen Werkzeugleiste auf , um in den Bearbeitungsmodus zu schalten. Anschließend klicken wir auf , um einen neuen Spielplatz hinzuzufügen. Es öffnet sich das von uns definierte Eingabeformular.

Herzlichen Glückwunsch! Wir können jetzt selbst Dateneingabeformulare definieren, durch die wir die Datenpflege schnell und einfach gestalten können. Dabei sind wir nicht nur bequem, sondern vermeiden auch Tippfehler und Inkosistenzen.

Um unsere Fertigkeiten zu üben und zu vertiefen bietet es sich an, die Übungen aus diesem Teil für die eigene Kommune zu wiederholen. Dabei entstehen nebenbei Karten, die sicherlich in der Gemeinde auf Interesse stoßen werden. Nachdem wir die Fertigkeiten ein wenig geübt haben, können wir uns dann überlegen, in welcher Richtung wir uns weiterbilden möchten. Dabei kann uns der Schulungsplan auf der ersten Seite als Anregung dienen, um uns entweder im Selbststudium mit Hilfe der OpenSource-Community, durch individuelle Beratung oder auch durch eine weitere Fortbildung in Richtung QGIS-Master zu bewegen ; )