QGis on Mein Blog

QGIS: Geocodierte Fotos auf einer Karte anzeigen

Sat, 09 May 2026 12:49:21 +0200

Hier wird ein Verfahren beschrieben, mit dem man unter Linux eine Sammlung geocodierter Fotos mit QGis auf einer Karte darstellen kann. Die Fotos können in beliebig geschachtelten Unterverzeichnissen liegen. Ausgewertet werden die EXIF-Tags GPSLongitude und GPSLatitude. In einem ersten Schritt werden die Fotos analysiert und eine SQLite/SpatiaLite-Datenbank erstellt. Im zweiten Schritt wird diese Datei in einen QGis-Layer geladen und der Layer so konfiguriert, dass beim Überfahren der Position eines Fotos mit der Maus das Foto angezeigt wird.

QGis: Animation von GPX-Tracks mit Heatmap

Thu, 07 May 2026 08:20:14 +0100

Mit QGis ist es recht einfach, Geodaten auf der Zeitachse zu animieren. Hier beschreibe ich, wie ich das nutze, um meine Radtouren dynamisch darzustellen.

QGis: Nicht befahrene Straßen ermitteln

Sun, 23 Nov 2025 08:20:14 +0100

Inspiriert von wandrer.earth habe ich nach einer Möglichkeit gesucht - ohne Strava und Wandrer zu nutzen - von mir noch nicht mit dem Fahrrad befahrene Straßen in meiner Umgebung zu visualisieren, um dann gezielt neue Strecken zu erkunden. Hier beschreibe ich eine lokale Lösung mit QGIS.

GeoActivityPlayground: Tiles innerhalb eines Gebiets

Fri, 08 Aug 2025 10:11:00 +0200

Seitdem ich Geo Activity Playground entdeckt habe , versuche ich, meine persönliche Missing-Tiles-Statistik zu verbessern. GeoActivityPlayground unterstützt dabei, indem es die befahrenen und nicht befahrenen Tiles auf der Karte anzeigt und Tile-Cluster markiert. Da ich mit dem Cluster in dem Gebiet, das ich von zu Hause aus oder mit einer akzeptablen Bahnfahrt erreichen kann, so langsam an meine Grenzen stoße, habe ich mich nach einer anderen Herausforderung umgeschaut. Dabei habe ich festgestellt, dass mir noch Tiles in einigen entfernten Ecken des Landkreises fehlen. Ich habe darauf hin nach einer Möglichkeit gesucht, diese Tiles zu zu identifizieren. Eine Lösung mit QGis beschreibe ich hier.

QGIS: "Traveling Salesman"-Routing mit den ORS Tools

Fri, 18 Jul 2025 17:51:00 +0200

Im Umfeld von OpenStreetMap kommt es immer wieder mal vor, dass man eine Reihe von Objekten erkunden möchte, z.B. alle seit Jahren nicht mehr überprüften Geschäfte einer Stadt. Es ist recht einfach, solche Objekte aus der OSM-Datenbank zu extrahieren. Einen GPX-Track zu erstellen, mit dem man alle gefundenen Objekte auf optimale Weise abfahren kann, ist dagegen recht mühsam. Diese Aufgabenstellung, also den optimalen Weg zu ermitteln, auf dem eine Menge von geografischen Punkten besucht werden kann, wird Traveling Salesman Problem genannt, auf deutsch Problem des Handlungsreisenden. Das Problem kann im Prinzip nur durch Ausprobieren aller Möglichkeiten gelöst werden, so dass der Aufwand mit der Zahl der Punkte exponentiell ansteigt. Die meisten verfügbaren Lösungen sind daher nicht perfekt, aber für den Hausgebrauch ausreichend. Neben OsmAnd und QMapShack bietet openrouteservice.org über sein API ein Traveling-Salesman-Routing an. Dieses kann auch über das QGis-Plugin ORS Tools genutzt werden.

QGIS: GUI-Problem unter unter Linux

Mon, 22 Jul 2024 08:38:55 +0200

Ich nutze nach Möglichkeit das mit dem von mir eingesetzten Debian-Release ausgelieferte QGIS. Dass es dabei immer wieder mal zu Problemen kommt, bin ich gewohnt und ist bei einem Entwicklungs-Release wie Debian Testing nicht ungewöhnlich. Als bei der QGIS-Version 3.34 die Fenster und Icons der Bedienoberfläche unvollständig und überlappt angezeigt wurden, bin ich daher zunächst auf ein Flatpak-Paket der QGIS-Version 3.28 umgestiegen. Als die störenden Effekte in der Debian-Version auch nach längerer Zeit nicht verschwunden sind, habe ich mich an die Fehlersuche gemacht.

Werkzeugleiste

Digitale Geländedaten im 5m-Raster von IGN France mit QMapShack nutzen

Mon, 08 May 2023 19:47:55 +0200

IGN RGE Alti Digitale Höhendaten

Das französische Institut national de l’information géographique et forestière (IGN) bietet unter dem Produktnamen RGE ALTI® digitale Höhendaten (DTM. Digital Terrain Model) im 5m- und 1m-Raster zum freien Download an. Die Daten stehen als Kacheln mit 1000x1000 Pixeln, also 5kmx5km beim 5m-Raster, zur Verfügung. Die Kacheln sind im Esri ASCII Grid Format codiert. Um sie in QMapShack nutzen zu können, müssen sie in das GeoTIFF-Format umgewandelt werden. Ein einfacher Workflow dafür wird nachfolgend für Linux Debian beschrieben.

Mit dem Fahrrad befahrene Departements in Frankreich

Mon, 18 Jul 2022 20:57:38 +0200

Auf dieser Karte sind alle Departements eingefärbt, die ich in den letzten zehn Jahren mit dem Fahrrad bereist habe:

Die angezeigten Daten wurden mit QGIS nach der in diesem Post beschriebenen Methode erstellt.

QGIS: Karte mit den Verwaltungseinheiten erstellen, durch die ein GPX-Track führt

Tue, 02 Jul 2019 19:42:56 +0200

Hier wird gezeigt, wie man mit QGIS auf sehr einfache Weise eine Karte der Verwaltungseinheiten (Landkreise, Departements) erzeugen kann, durch welche ein GPX-Track führt.

Georeferenziertes Rasterbild aus OSM-Daten erstellen

Mon, 05 Dec 2016 16:29:17 +0100

Hier wird beschrieben, wie man mit Hilfe des Overpass-API, QGIS und GDAL auf der Grundlage der Openstreetmap-Daten ein georeferenziertes Rasterbild erstellen kann. Als Beispiel wird das Radwegenetz der Städe Ulm und Neu-Ulm verwendet.

Extrahieren der Openstreetmap-Daten

Dies geschieht am einfachsten mit dem QGIS-Plugin QuickOSM. Dieses Plugin ermöglicht es, Openstreetmap-Daten über das Overpass-API mit der Abfragesprache Overpass QL herunter zu laden und in QGIS als Layer anzuzeigen. Nach Installation des Plugins wird es über Vektor->QuickOSM->QuickOSM gestartet. Für das Beispiel wird die folgende Overpass-Abfrage verwendet:

Animierte Tracks erstellen mit QGIS

Thu, 14 Apr 2016 14:01:15 +0200

Hier wird beschrieben, wie man aus einem GPX-Track eine Animation der Strecke erstellen kann. Die Animation besteht darin, dass der Track abschnittsweise oder punktweise gezeichnet wird.

Punktweise Animation

Für die Animation des Tracks wird das QGIS-Plugin TimeManager verwendet. Dieses Plugin stellt die Objekte eines Layers zeitlich verzögert entsprechend einem Zeitstempel aus den Objektattributen dar. Da GPX-Dateien für Tracks keinen Zeitstempel und auch kein anderes als Zeitstempel interpretierbares Attribut enthalten, wird die GPX-Datei mit dem Programm gpx2shp in eine ESRI-Shape-Datei konvertiert:

OSM: Zugriff auf die Attribute des Admin_Centre beim Rendern von Verwaltungsgrenzen

Fri, 04 Oct 2013 15:16:16 +0200

In der OpenStreetMap-Datenbank sind die Informationen über Verwaltungseinheiten (Gemeinden, Kreise, Länder) meist auf die Grenzrelation und den Knoten mit der Rolle admin_centre verteilt. Will man zum Rendern der Grenze oder Fläche einer Verwaltungseinheit auf Informationen zurückgreifen, die beim Knoten gespeichert sind, z.B. das Attribut population oder name:xx, dann stellt man fest, dass üblichen Werkzeuge diese Informationen nicht bereit stellen. Nachfolgend werden Methoden beschrieben, wie man dieses Problem bei mit osm2pgsql erstellten Datenbanken und bei aus OSM erzeugten Shape-Dateien lösen kann.

PostGis / osm2pgsql

osm2pgsql überträgt zwar Attribute der äußeren Wege, also der Wege mit Rolle outer, auf das für die Relation erzeugte Polygon, für den Knoten mit der Rolle admin_centre wird nichts vergleichbares gemacht. Es wird auch kein Link vom Polygon zum Knoten erzeugt. Die im Slim-Modus von osm2pgsql erzeugte Tabelle <prefix>_rels enthält zwar in der Spalte members sämtliche Mitglieder der Relation und deren OSM-ID, aber leider in einer nicht direkt und effizient mit SQL auswertbaren Form. Beispiel:

psql -d osm -c  "select members from planet_osm_rels\
                     where hstore(tags)->'name'='Corneilla-la-Rivière';"
                               members
----------------------------------------------------------------------------
{w121772197,outer,w100006391,outer,w121772204,outer,n287557758,admin_centre}

Die Member der Relation werden also in einem Array abgelegt, zwei aufeinander folgende Array-Elemente pro Member. Mit einer kleinen Funktion kann man die Node-Id des Admin_Centre extrahieren:

CREATE OR REPLACE FUNCTION admin_centre(anyarray)
   RETURNS bigint
   LANGUAGE sql
   AS $function$
      SELECT cast(substring($1[i] from 2) as bigint)
         FROM generate_series(array_lower($1,1),array_upper($1,1),2) i 
         WHERE $1[i+1]='admin_centre';$function$

Damit kann man nun die Polygone der Verwaltungsgrenzen zusammen mit den Attributen des Admin_Centre abfragen:

select poly.name, point.name, point."name:ca", point.population 
   from planet_osm_rels r, 
        planet_osm_polygon poly, 
        planet_osm_point point 
   where poly.admin_level='8' 
         and admin_centre(r.members) = point.osm_id 
         and r.id = -poly.osm_id ;

Je nach Anwendungsfall und Performanceanforderung kann man damit auch die benötigten Attribute in die jeweils andere Tabelle übertragen oder eine Tabelle mit der Zuordnung von Knoten zu Relationen erstellen:

create table admin_rel 
   as select -id as rel_id,
             admin_centre(members) as admin_centre
        from planet_osm_rels 
        where hstore(tags)->'boundary'='administrative' and 
              hstore(tags)->'admin_level'  in ('8','6','4');

Shape-Dateien

Hierfür wird die Osmium-Bibliothek, das darauf basierende Javascript-Tool osmjs und QGis benutzt. Mit osmjs können auf einfache Weise Shape-Dateien aus den Objekten einer OSM-Datei zu erzeugt werden. Wie bei osm2pgsql werden dabei zwar Polygone aus Grenzrelationen erstellt, aber ohne Bezug zum admin_centre. Es ist jedoch möglich, eine CSV-Datei zu erstellen, welche diesen Bezug enthält:

/*
  Osmium Javascript Example:  shape_export.js

  run with: osmjs -2 -m -l sparsetable -j shape_export.js OSMFILE
*/

var shp_places = Osmium.Output.Shapefile.open('./places', 'point');
shp_places.add_field('id', 'string', 12);
shp_places.add_field('type', 'string', 32);
shp_places.add_field('name', 'string', 32);

var shp_boundaries = Osmium.Output.Shapefile.open('./boundaries', 'polygon');
shp_boundaries.add_field('id', 'integer', 10);
shp_boundaries.add_field('type', 'string', 32);
shp_boundaries.add_field('boundary', 'string', 255);
shp_boundaries.add_field('admin_level', 'string', 255);

var csv_file = Osmium.Output.CSV.open("./rels.csv");

var node_tags = {
    place: { village: 'villaget', city: 'city', town: 'town'} //,
    //shop: { supermarket: 'supermarket' }
}

Osmium.Callbacks.init = function() {
    print("Init");
}
Osmium.Callbacks.node = function() {
    for (var key in this.tags) {
        if (node_tags[key]) {
            var type = node_tags[key][this.tags[key]];
            if (type) {
                shp_places.add(this.geom, { id: this.id, type: type, name: this.tags.name });
            }
        }
    }
}
Osmium.Callbacks.area = function() {
    if (this.tags.boundary) {
        shp_boundaries.add(this.geom, { id: this.id, type: this.tags.boundary, admin_level: this.tags.admin_level});
    }
}
Osmium.Callbacks.relation = function() {
   for (var key in this.members) {
      for (var key2 in this.members[key]) {
         if (key2=='role' && this.members[key].role=='admin_centre'){
            csv_file.print(this.id*2+1, this.members[key].ref, 
                           this.members[key].role, this.members[key].type);
         }
      }
   }
}
Osmium.Callbacks.end = function() {
    shp_places.close();
    shp_boundaries.close();
    csv_file.close();
    print("Done");
}

Das Skript erstellt eine Shape-Datei mit den Grenzpolygonen, eine Shape-Datei mit den Place-Knoten und eine CSV-Datei, welche die Ids der Grenzpolygone und der zugehörigen Place-Knoten enthält. Dabei wird berücksichtigt, dass osmjs den Polygonen eine Pseudo-ID mit dem Wert [2 * OSM-ID der Relation + 1 zuweist. Diese drei Dateien lädt man als Layer in QGis. Dann verknüpft man den CSV-Daten-Layer über die Knoten-ID mit dem Knoten-Layer und anschliessend den Polygon-Layer über die Pseudo-ID mit dem Knoten-Layer. Will man die Daten mit Tilemill / Mapnik verenden, kann man die Polygon-Layer als Shape-Datei speichern.

QGIS mit Python-Unterstützung unter Debian Jessie

Tue, 09 Jul 2013 14:22:37 +0200

Derzeit funktioniert die Python-Einbindung von QGis in Debian Jessie/Testing nicht. Das liegt daran, dass QGIS 1.7 die Version 8.1 des SIP-Interfaces unterstützt, in Jessie aber bereits auf SIP Version 10 umgestellt wurde. Versuche mit den Debian-Paketen für QGIS 1.8 von https://qgis.org/debian/ haben das Problem nicht behoben. Letztendlich habe ich QGIS 2.0 aus den Quellen erzeugt.

Quellen von qgis.org herunterladen.
Quellarchiv in ein Verzeichnis entpacken
Compilieren entsprechend der Anleitung in der Datei INSTALL. Bei mir waren nur die Schritte aus Abschnitt 3.3. und 3.7. notwendig.
Beim Konfigurieren mit ccmake wird der Pfad PYTHON_LIBRARY nicht automatisch gesetzt und muss daher von Hand eingetragen werden (in ccmake), z.B. /usr/lib/x86_64-linux-gnu/libpython2.7.so
ldconfig ausführen.

(Stand: 14.09.2013)

GPX-Track auf OpenStreetMap-Karte anzeigen und ausdrucken

Tue, 09 Jul 2013 08:49:01 +0200

Es gibt eine Reihe von Tools und Online-Diensten, mit denen man GPX-Tracks auf einer OpenStreetMap-Karte anzeigen kann: QLandkarteGT, GpsPrune, gpsies.com,... Beim Ausdrucken bzw. Erzeugen einer Vektorgrafik stößt man allerdings schnell an Grenzen. Die Darstellung der Tracks (Farbe, Breite, Transparenz) ist nicht konfigurierbar und der Zoomlevel wird anhand des Kartenausschnitts gewählt, usw. Dieses Video hat mir einen Weg zur Lösung aufgezeigt: Quantum GIS (QGIS) mit OpenLayers-Plugin.

OpenLayers-Plugin

Installation

Das OpenLayers-Plugin ermöglicht es, OSM-Kacheln und Kacheln aus anderen mit OpenLayers darstellbaren Quellen (Google, Bing) in einem QGIS-Layer anzuzeigen. Dazu muss zunächst das Plugin installiert werden. Bis QGIS 1.8 funktioniert das problemlos mit mit dem Plugin Installer. Zunächst muss im Menü "Erweiterungen" der Plugin Installer installiert werden, dann kann mit diesem das OpenLayers-Plugin installiert werden. QGIS 1.9/2.0 ist mit dem Plugin nicht kompatibel. Es existiert aber ein Workaround, der hier beschrieben ist: [node:254].

Layer hinzufügen

Danach erscheint im Menü "Erweiterungen" ein Untermenu "Openlayers Plugin", über das eine Kachelquelle ausgewählt und mit einem Layer verknüpft werden kann. Die Kacheln werden entsprechend dem Zoomlevel geschrumpft bzw, gedehnt, was zu einer unscharfen Darstellung führt. Ein Workaround besteht darin, den Maßstab explizit so einzustellen, dass die Kacheln in Original-Auflösung angezeigt werden. Stellt man den Maßstab 1:2257 ein, erhält man die Kacheln des Zoomlevels 18. Durch Zoomen mit der Maus bekommt man dann die Kacheln in den OSM-Zoomleveln angezeigt.

Weitere Kachelquelle hinzufügen

Eine zusätzliche Kachequelle kann auf einfache Weise Hinzugefügt werden. Im Verzeichnis ~/.qgis2/python/plugins/openlayers_plugin/html existiert für jede Kachelquelle eine HTML-Datei, die den Javascript-Code enthält, mit dem der entsprechende OpenLayers-Layer erzeugt wird. Man erstellt nun eine Kopie einer dieser Dateien und passt den Code entsprechend an. Für OSM-kompatible Kachelquellen genügt es in der Regel, die Datei osm.html zu kopieren und den URL anzupassen. Anschließend muss noch in ~/.qgis2/python/plugins/openlayers_plugin/openlayers_plugin.py, etwa bei Zeile 120, ein Eintrag für die neue Kachelquelle nach diesem Muster eingefügt werden: self.olLayerTypeRegistry.add( OlLayerType(self, 'OpenStreetMap', 'osm_icon.png', 'osm.html', True) ) nach einem Neustart von QGIS ist die neue Kachelquelle verfügbar.

Alternative Methode

Ein anderer Weg zur Anzeige der OSM-Kacheln in QGIS ist hier beschrieben.

GPX-Track

Ein GPX-Track kann als Vektor-Layer angezeigt werden:

Menüpunkt Vektorlayer hinzufügen anwählen
im Dialog die GPX-Datei auswählen und öffen
im anschliessenden Auswahlfenster den Layer tracks und ggf. weitere Layer auswählen und mit OK bestätigen
im Layer-Fenster die Eigenschaften der Track-Linie festlegen: Farbe, Breite,...

Karte drucken / Grafik erzeugen

Hierzu wird der Dialog Neue Druckzusammenstellung geöffnet und mit neue Karte hinzufügen ein Kartenauschnit in das Druckblatt eingefügt. Dabei wird der Kartenausschnitt aus dem Hauptfenster übernommen. Dieser kann im Modus Inhalt verschieben nach Belieben gezoomt und verschoben werden Die so erzeugten Ausdrucke haben eine miserable Qualität. Der Zoomlevel der Kacheln wird entsprechend Auflösung des Ausdrucks und der Größe des Kartenauschnitts automatisch gewählt. Dann werden die Kacheln skaliert um den gewählten Kartenausschnitt zu erhalten. Das Ergebnis ist in den meisten Fällen ziemlich unscharf und für den Druck in der Regel nicht verwendbar. Durch geeignete Wahl der Druckgröße und des Maßstabs des Kartenausschnitts kann man trotzdem eine akzeptable Bildqualität erreichen. Beispiele:

Format	Auflösung (dpi)	Maßstab	Zoomlevel
A4	300	57250	15
A4	150	57250	14
A4	72	57250	13
A1	72	57.250	13
A1	72	144.448	12
A1	300	144.448	14
A1	300	2.311.168	10
A1	72	577.792	10

Das beste Ergebnis erziele ich allerdings mit einer Bildschirmkopie, da die Kacheln auf dem Bildschirm unskaliert dargestellt werden.