HowTo OGR2OGR

Zurück zu OGR

See also GeoConverter#Alternatives for (online) alternatives.

INTERLIS 1-Reader und -Writer

Vorbereitungen:

• Unter Windows ev. setfw.bat ausführen, damit die Programme im System-Pfad sind und gefunden werden.
• Ggf. ili2c.jar (siehe UML/INTERLIS-Editor-Installation) in die System-Umgebungsvariablen (Pfad) einfügen (gleiches Verzeichnis wie setfw.bat)
• Fehlt die .ili-Datei, muss diese zuerst erstellt, bzw. organisiert werden. Ev. muss diese "erraten" (d.h. "reverse engineered") werden, z.B. mit Hilfe von OGRINFO.

INTERLIS 1 nach Shapefile

Konvertieren von INTERLIS 1-Dateien (.itf und .ili) nach Shapefile.

• Input-Dateien: ili-bsp.itf und ili-bsp.ili
• Resultat.....: Für jede INTERLIS 1-Tabelle wird im Output-Verzeichnis shpdir/ ein Shapefile (.shp, .dbf und .shx) erzeugt.

 > ogr2ogr -f "ESRI Shapefile" shpdir ili-bsp.itf,ili-bsp.ili

Hinweise:

• Allfällige Warnung "Info: Folder D:\daten_eigene2\OGR\demo\standard doesn't exist; ignored" ignorieren.
• Es wird immer ein .dbf erzeugt, auch wenn keine Sachdaten vorhanden sind.
• Speziell: Beschriftungen werden in separaten Tabellen verwaltet. Das bedingt eine nachträgliche Bearbeitung (Konverter wie FME machen das im Rahmen des Konvertierung-Schrittes). Die Erzeugung von Sichten (JOINs) aufgrund von Beziehungen zwischen Tabellen sind nicht Bestandteil einer Datenbeschreibung und der Daten (einfaches SQL schon; siehe unten).
• Problem behoben (Behandlung von INTERLIS-Referenzattributen (->), die aus anderen Tabellen auf das Input-Shapefile "zeigen").

INTERLIS 1-Daten der amtl. Vermessung nach Shapefile

Daten der amtl. Vermessung (AV), d.h. AV-CH01; sollte aber mit versch. AV-Modellen funktionieren.

Input: AV-Daten .itf/.ili Output: Shapefile (Layer/Table) mit Parzellenbeschriftung.

 1. Convert INTERLIS 1 to Shapefile
 > ogr2ogr out AV-Daten.itf,AV-Daten.ili
 2. Convert two Shapes to one (with labelling)
 > ogr2ogr Parzellenbeschriftung.shp Liegenschaften__GrundstueckPos.shp 
    -nln Parzellenbeschriftung  
    -sql "SELECT Grundstuec,Nummer FROM Liegenschaften__GrundstueckPos  
          JOIN 'Liegenschaften__Grundstueck.shp'.Liegenschaften__Grundstueck
          ON Liegenschaften__GrundstueckPos.Grundstuec = Liegenschaften__Grundstueck._TID"

Hinweise:

• Der Befehl ist zum besseren Verständnis in mehrere Zeilen aufgeteilt; der Befehl muss aber schliesslich als eine einzige Zeile eingegeben werden.
• Die Abarbeitung geht sehr langsam (Minuten)! Jede Variante mit PostGIS geht sicher schneller!
• Das Attribut 'Grundstuec' hiess ursprünglich 'GrundstueckPos_von' wurde aber wegen Beschränkungen des Shapefiles (DBase) auf 8 Zeichen reduziert.

INTERLIS 1-Daten nach DXF

Skript, um Hoehenkurven-Daten (INTERLIS 1 mit Geometrie und separater Hoehe, CHLV03/EPSG 21781) in ein 3D-Shapefile und 3D-DXF umzuwandeln. Voraussetzung: Eine leere PostgreSQL/PostGIS-Datenbank (hier ‘gisdb’).

1. Convert INTERLIS to PostgreSQL (ARC_DEGREES Default: 1 degree).

 DOS> SET ARC_DEGREES=1.0
 DOS> ogr2ogr -f PostgreSQL PG:"dbname='gisdb' user=postgres password='postgres'" hoehen.itf,hoehen.ili 
        -sql "SELECT * FROM Hoehen__Hoehenkurven" -nln hoehenkurven2d -overwrite

2. Convert PostgreSQL to DXF (or whatever target file format) while target layer/feature class is 3D containing Z value from hoehe:

 DOS> ogr2ogr -f DXF out\hoehenkurven3d.dxf PG:"dbname='gisdb' user=postgres password='postgres'" 
        -sql "SELECT ogc_fid, ST_Translate(ST_Force_3DZ(wkb_geometry),0,0,hoehe) AS the_geom from hoehenkurven"

Shapefile nach INTERLIS 1

Konvertieren von Shapefile nach INTERLIS 1-Dateien (.itf).

• Input: bahnhoefe.itf und bahnhoefe.ili
• Resultat: Eine INTERLIS 1-Datei Bahnhoefe.itf mit vom Programm generierten Transfer-Identifikatoren (TID).

 > ogr2ogr -f "INTERLIS 1" Bahnhoefe.itf Bahnhoefe.shp

Hinweise:

• Schreibt fälschlicherweise noch 'TOPI Topic' (ca. Zeile 6) ins ITF. Unbedingt mit Editor abändern.
• Sollte in Zukunft auch ein .ILI generieren, denn die Informationen aus dem Shapefile (DBF) sind bekannt; siehe ogrinfo.

INTERLIS 2-Reader und -Writer

Vorbereitungen: siehe INTERLIS 1-Reader und -Writer.

Shape to INTERLIS 2 (xml) mit .ili-file:

• Input.: one Shape including shp-, shx- and dbf-file
• Output: one INTERLIS 2.2 xml-file

 > ogr2ogr -f "INTERLIS 2" Bahnhoefe.xml,Bahnhoefe.ili Bahnhoefe.shp

Hinweis: Meldet eine Warnung ("Could not open standard...") und eine grosse Zahl von Fehlern(?) "<Xxxx> not found"... Diese können ignoriert werden.

INTERLIS 2 (.xml) to Shape without INTERLIS model ***

• Input.: zpl_k23.xml
• shapefiles in shpdir2/

 > ogr2ogr -f "ESRI Shapefile" shpdir2 zpl_k23.xml

KML-Writer mit SQL- und BBox-Optionen

KML ist ein Mix von Formattierung und Geometrie-/Sachdaten. Es gibt für OGR einen KML-Writer aber erst einen rudimentären KML-Reader.

Konvertiere Shapefile nach KML:

 > ogr2ogr -f KML Bahnhoefe.kml Bahnhoefe.shp

Konvertiere Shapefile nach KML mit den dsco-Optionen NameField (setzt das Namensfeld des Markers) und AltitudeMode, das im GE die Höhe gemäss Intputdaten (und nicht Geländemodell-anschmiegend) anzeigen lässt (Hinweis: eine einzige Zeile ohne Zeilenumbruch).

 > ogr2ogr -f KML Bahnhoefe.kml Bahnhoefe.shp -dsco NameField=Name -dsco AltitudeMode=absolute

Shapefile nach KML mit SQL ohne Geometrie (selektiere alle Bahnhöfe der Ostschweiz):

 > ogr2ogr -f KML bahnhoefe.kml bahnhoefe.shp -sql "SELECT name,type,level,
   cntryname,prov1name from bahnhoefe where prov1name = 'Ostschweiz'"

Shapefile nach KML mit spat-Option über eine BBox (Region Zürich):

 > ogr2ogr -spat 8.38 47.81 8.83 47.30 -f KML output.kml input.shp

KML nach Shapefile: Hinweis: Funktioniert z.Zt. nur, wenn nur ein Geometrietyp (im obersten Folder) enthalten ist (und -nlt point oder -sql funktioniert auch nicht).

 > ogr2ogr test.shp ge_export_test2.kml

PostgreSQL/PostGIS-Reader und -Writer

Tipp: Das mit PostGIS mitgelieferte Werkzeug shp2pgsql (siehe PostGIS_-_Tipps_und_Tricks) ist in diesem Fall einfacher in der Bedienung als ogr2ogr.

Zeige alle Attribute einer PostGIS-Datenbank (Layer towns)

 > ogrinfo -so -al PG:dbname=gisdb towns
 oder
 > ogrinfo PG:"dbname='gisdb' user=gisdb password='gisdb'" towns

PostgreSQL-DB nach Shapefile konvertieren:

• Input: PostgreSQL/PostGIS-Datenbank gisdb
• Resultat: out.gml-Datei

 > ogr2ogr -f gml out.gml PG:"host=localhost dbname=gisdb"
 Warning 1: Multi-column primary key in 'towns' detected but not supported.

Hinweis: Diese Warnung ist offensichtlich falsch, denn es gibt keinen primary key in dieser DB (Bug gemeldet --Stefan 22:15, 3. Jan. 2008 (CET)).

PostgreSQL-DB nach KML konvertieren und dabei Linien vereinfachen (simplify):

 > ogr2ogr -sql "select admin, case when area(the_geom) > 3000000000 then 
   transform(simplify(the_geom, 4), 4030) else transform(simplify(the_geom, 
   0.01), 4030) end from utlanduse" -f kml out.kml PG:"host=localhost 
   dbname=statewide user=xxx password=xxx"

Hinweis: user und password müssen noch gesetzt werden.

ESRI Personal Geobatabase

ESRI Personal Geobatabase (.mdb). Reader only. Siehe OGR#Dateiformate.

Zuerst muss ein Eintrag (sog. System DSN) in ODBC gemacht werden (siehe nachfolgend)! Dann kann man mit dem OGR-PGeo-Treiber darauf zugreifen.

Um auf die ESRI Personal Geodatabase (=MS Access-Datenbank) zugreifen zu können, ist in Windows ein Eintrag in der Datenquellenverwaltung notwendig, der auf die entsprechende Datenbank verweist. Normalerweise kann man in Windows unter Systemsteuerung, Verwaltung, Datenquellen (ODBC) die nötigen Einstellungen vornehmen und eine Datenquelle für die ESRI-Datenbank hinzufügen auf die OGR dann zugreifen kann. In Windows 7 (64-Bit-Version) muss man aber auf die Verwaltung der 32-Bit Version unter %system-drive%\Windows\SysWoW64\Odbcad32.exe zurückgreifen und dort eine Datenquelle für die Datenbank sia426_snp_v12de hinzufügen (Abb. 21). Ist die Datenquelle eingerichtet ermöglicht der OGR-PGeo-Treiber, dass die Daten aus der Datenbank ausgelesen werden können.

Beispiel mit Datei Bahnhoefe.mdb:

 > odbcconf /a {CONFIGSYSDSN "Microsoft Access Driver (*.mdb)" "DSN=Bahnhoefe;DBQ=C:\temp\ogr\Bahnhoefe.mdb"}
 > ogrinfo PGeo:Bahnhoefe
   INFO: Open of `PGeo:ArcHydro'
         using driver `PGeo' successful.
   1: bahnhoefe

MS Access-Datei als DSN registrieren:

• Unix: Siehe ESRI Personal GeoDatabase
• Windows:

 > odbcconf /a {CONFIGSYSDSN "Microsoft Access Driver (*.mdb)" "DSN=<dbame>;DBQ=<file_mit_path.mdb>"}

 reg_odbc.bat:
 @ECHO OFF
 REM Assumes MS Access file is given with full path!
 REM SET FILEPATH=%cd%\%1.mdb
 SET FILEPATH=%1
 IF NOT EXIST %FILEPATH% GOTO ERROR1
 c:\windows\system32\odbcconf /a {CONFIGSYSDSN "Microsoft Access Driver (*.mdb)" "DSN=%1;DBQ=%FILEPATH%"}
 GOTO END
 :ERROR1
 ECHO ERROR - File %FILEPATH% not found.
 :END
 @ECHO OFF

MS Excel-Reader (.xls)

Ähnlich wie MS Access (siehe oben):

 > odbcconf /a CONFIGSYSDSN "Microsoft Excel Driver (*.xls)" "DSN=test|DBQ=c:\test.xls|DefaultDir=C:|Description=Test"

Comma Separated Values (CSV)

Über den OGR-CSV Writer/Reader:

• Verwendet Kommas als Feld-Trennzeichen/Deliminter/Separator.
• Die erste Zeile ist eine Header-Zeile.
• Geometrie-Felder werden wie Strings behandelt - ausser man verwendet .VRT für Import und Parameter "-lco GEOMETRY=AS_WKT" (u.a.) fpr export.

CSV-Writer mit WKT-Attribut

CSV-Writer: Erzeuge aus einem Shapefile ein CSV mit WKT-Attribut (gegeben, das WKT-Attribut heisse 'OGR_GEOM_WKT'):

Alte Option:

 > ogr2ogr -f CSV out Bahnhoefe.shp -sql "select *,OGR_GEOM_WKT from Bahnhoefe"

 1. Mit ogrinfo -ro Bahnhoefe.kml Name des Layers eruieren, sicherstellen, ob WGS84, dann:
 > ogr2ogr -f CSV out Bahnhoefe.kml -sql "select *,OGR_GEOM_WKT from BahnhoefeWGS84"

Neue Option GEOMETRY (GDAL 1.6.0):

By default, the geometry of a feature written to a .CSV file is discarded. It is possible to export the geometry in its WKT representation by specifying GEOMETRY=AS_WKT. It is also possible to export point geometries into their X,Y,Z components (different columns in the CSV file) by specifying GEOMETRY=AS_XYZ, GEOMETRY=AS_XY or GEOMETRY=AS_YX. The geometry column(s) will be prepended to the columns with the attributes values.

 > ogr2ogr -f CSV out Bahnhoefe.shp -lco GEOMETRY=AS_XY

Konvertieren von CVS nach CSV inkl. Koordinatentransformation mit Hilfe von .VRT für den Import (vgl. 'sample2.vrt' unten):

 > ogr2ogr -f CSV out Bahnhoefe1.vrt -lco GEOMETRY=AS_WKT -t_srs EPSG:21781 -overwrite

Hinweise:

• -lco LINEFORMAT=CRLF erzwingt Zeilenenden für Windows.
• MS Excel zuerst starten und dann das File importieren (Doppelklick funktioniert nicht wie erwartet).

CSV-Reader: Variante mit lat/lon-Punktgeometrie

Angenommen folgende CSV-Datei sample1.csv existiere:

 lon, lat, name
 -81.0, 32.0, Wert 1
 -82.0, 33.0, Wert 2
 -83.0, 34.0, Wert 3

• Erzeuge Shapefile layer1 aus der sample1.dbf mit Hilfe der Konfigurationsdatei sample1.vrt (siehe VRT).

 > ogr2ogr -f "ESRI Shapefile" sample1_dir sample1.vrt

• sample1.vrt-Datei (Erzeugt layer1.dbf, layer1.shp, layer1.shx und layer1.prj):

 <OGRVRTDataSource>
   <OGRVRTLayer name="layer1">
     <SrcDataSource relativeToVRT="1">sample1.csv</SrcDataSource>
     <SrcLayer>sample1</SrcLayer>
     <GeometryType>wkbPoint</GeometryType>
     <LayerSRS>WGS84</LayerSRS>
     <GeometryField encoding="PointFromColumns" x="lon" y="lat"/>
   </OGRVRTLayer> 
 </OGRVRTDataSource>

CSV-Reader: Variante mit Geometrieattribut im WKT-Format

Gegeben Datei sample2.csv (CSV) mit Geometrien codiert in WKT:

 ID, NAME, OGR_GEOM_WKT
 1, Wert 1, "POINT(12.375 49.618)"
 2, Wert 2, "POINT(16.198 50.431)"
 3, Wert 3, "POINT(19.628 51.389)"

Konvertiere CSV zu ESRI Shapefile:

 > ogr2ogr -f "ESRI Shapefile" sample2_dir sample2.vrt

wobei die VRT-Definition sample2.vrt wie folgt ist:

 <OGRVRTDataSource>
     <OGRVRTLayer name="sample2">
         <SrcDataSource relativeToVRT="0">sample2.csv</SrcDataSource>
         <SrcLayer>sample2</SrcLayer>
         <GeometryType>wkbPoint</GeometryType>
         <GeometryField encoding="WKT" field="OGR_GEOM_WKT" />
         <LayerSRS>epsg:4326</LayerSRS>
     </OGRVRTLayer>
 </OGRVRTDataSource>

Variante mit LineString:

sample3.csv:

 ID, NAME, OGR_GEOM_WKT
 1, Wert 1, "LINESTRING(12.375 49.618, 12.380 49.61, 12.474 49.634)"
 2, Wert 2, "LINESTRING(16.198 50.431, 16.205 50.434, 16.334 50.405)"
 3, Wert 3, "LINESTRING(19.628 51.389, 20.278 51.782, 20.350 51.840)"

sample3.vrt:

 <OGRVRTDataSource>
     <OGRVRTLayer name="sample3">
         <SrcDataSource relativeToVRT="0">sample3.csv</SrcDataSource>
         <SrcLayer>sample3</SrcLayer>
         <GeometryType>wkbLineString</GeometryType>
         <GeometryField encoding="WKT" field="OGR_GEOM_WKT" />
         <LayerSRS>epsg:4326</LayerSRS>
     </OGRVRTLayer>
 </OGRVRTDataSource>

CSV-Reader mit Schema (.csvt)

Der OGR CSV driver behandelt alle Attribute als String, falls keine Feld/Attribut-Typen Informations-Datei CSV-Types (.csvt) vorhanden ist.

Es gibt folgende sechs Typen in CSVT: Integer, Real, String, Date (YYYY-MM-DD), Time (HH:MM:SS+nn) und DateTime (YYYY-MM-DD HH:MM:SS+nn). Die Typen jeder Kolonne werden auf einer einzigen Zeile aufgereiht, in anführungszeichen und Komma-separiert.

Beispiel: Gegeben eine CSV-Datei sample4.csv:

 ID,NAME,CREATED
 1, Wert 1, 2007-01-13
 2, Wert 2, 2007-01-14
 3, Wert 3, 2007-01-15

Dann bestimmt diese Datei sample4.csvt die Typen (eine Zeile):

 "Integer","String","Date"

GPX-Reader und -Writer

Konvertiere GPX nach Shapefile:

 > ogr2ogr -f "ESRI Shapefile" tmpdir t.gpx

Konvertiere Shapefile nach GPX:

 > ogr2ogr -f "GPX" t2.gpx bahnhoefe.shp

Beispiel mit Attributen in <extensions>.

 > ogr2ogr -f "GPX" t2.gpx -dsco GPX_USE_EXTENSIONS=YES bahnhoefe.shp

Hinweise zum GPX-Writer:

• Falls "ERROR 6..." auftritt siehe GPX_USE_EXTENSIONS.
• GPX_USE_EXTENSIONS=YES gibt Attribute in XML-Element extensions aus.
• FORCE_GPX_TRACK=YES: Ändere das Mapping "LineString => GPX Routes" nach "LineString => GPX Tracks"
• FORCE_GPX_ROUTE=YES: Ändere das Mapping "MultiLineString => GPX Tracks" nach "MultiLineString => GPX Routes" (falls MultiLineString nur eine einzige Linie sind)

Über GPX: GPX kennt WayPoints, Routes und Tracks. Weitere Attribute können in einem extensions-Attribut versorgt werden (GPX_USE_EXTENSIONS). Default Geometrie-Typen-Mapping OGR-intern nach GPX:

• Point => GPX Waypoints (<wpt>)
• LineString => GPX Routes (<rte>)
• MultiLineString => GPX Tracks (<trk>).
• Andere Geometrietpen sind nicht unterstützt.

GML-Reader und -Writer

Shapefile nach GML konvertieren:

 > ogr2ogr -f GML bahnhoefe.gml bahnhoefe.shp
 

GML nach Shapefile konvertieren:

 > ogr2ogr -f "ESRI Shapefile" tmpdir bahnhoefe.gml

Hinweis: Falls folgender Fehler auftritt "ERROR 1: XML Parsing Error: An exception occurred! Type:UTFDataFormatException, Message: invalid byte 2 (g) of a 4-byte sequence." dann ist die Datei nicht im UTF-8-Encoding gespeichert. Das kann ggf. mit einem Werkzeug (Editor) korrigiert werden.

WFS-Reader und -Writer

Nachfolgend einige Beispiele zum WFS-Reader. Man merke, dass die Datenquelle eines WFS eine URL (http) ist. OGR unterstützt auch das Schreiben von WFS in Form des WFS Transactional (WFS-T). Mehr dazu vgl. die Original-Doku. zu OGR WFS.

Allgemeine Befehle

Alle Layernamen auflisten:

 > ogrinfo -ro -so WFS:"http://maps.zh.ch/wfs/FnsNSWFS"

Ausgabe:

 INFO: Open of `WFS:http://maps.zh.ch/wfs/FnsNSWFS'
       using driver `WFS' successful.
 1: naturschutzobjekte_f
 2: naturschutzobjekte_p
 3: nso_2011_kantonal_f
 4: nso_2011_kantonal_p
 5: nso_2011_regional
 6: svo_zonen
 7: svo_ueberlagernde_zonen
 8: svo_objekte
 9: lichtwaelder_teilobj

Alle Layer mit Titel und Beschreibung auflisten:

 > ogrinfo -ro -al WFS:"http://maps.zh.ch/wfs/FnsNSWFS" WFSLayerMetadata

Attribute eines Typs auflisten: (ACHTUNG: Kann dauern! Liest ganzen Datensatz!)

 > ogrinfo -ro -so WFS:"http://maps.zh.ch/wfs/FnsNSWFS" svo_zonen

Konvertieren

WFS-Layer nach Shapefile konvertieren:

 > ogr2ogr -f "ESRI Shapefile" svo_zonen_shp WFS:"http://maps.zh.ch/wfs/FnsNSWFS" svo_zonen

In dem von diesem Befehl erzeugten Shapefile sind einige Daten abgeschnitten, die Länge der Strings ist auf 80 Zeichen beschränkt. Ab GDAL/OGR 2.0 wird die Länge automatisch auf bis zu 255 Zeichen erhöht. Andere Formate wie SQLite kennen dieses Problem nicht.

WFS-Layer nach SQLite konvertieren:

 > ogr2ogr -f "SQLite" svo_zonen.sqlite WFS:"http://maps.zh.ch/wfs/FnsNSWFS" svo_zonen

XML-Konfigurationsdatei

Falls z.B. die WFS-Version (1.0.0 oder 1.1.0), das Timeout, oder ein Passwort angegeben werden müssen, geht das über eine XML-Konfigutationsdatei.

Parameter mit XML übergeben:

 > ogrinfo -ro -so OGR_WFS_FnsNSWFS.xml svo_zonen

Beispiel einer XML:

 <OGRWFSDataSource>
   <URL>http://path/to/WFS/service[?OPTIONAL_PARAMETER1=VALUE[&OPTIONNAL_PARAMETER2=VALUE]]</URL>
   <Version>1.0.0</Version>
   <Timeout>120</Timeout>
   <UserPwd>somepassword</UserPwd>
 </OGRWFSDataSource>

 (=> muss noch getestet werden...)

GeoJSON-Reader und -Writer

• Der GeoJSON Reader liest sowohl ab URL als auch aus einer Datei mit der Endung .json oder .geojson.
• Man beachte, dass der Reader einen vordefinierten Layer-Namen 'OGRGeoJSON' verlangt.
• Zum Writer gibt es hier noch keine Tipps.
• Besonders nützlich ist der Reader auch zum Lesen von ArcGIS] 'Feature Service' (ArcGIS Server REST API)!
• Siehe die Original-Doku. zu OGR GeoJSON.

Konvertiere den GeoJSON-Output von einem FeatureServer zu Shapefile ('OGRGeoJSON' ist fix):

 $ ogr2ogr -f "ESRI Shapefile" somelayer.shp http://somefeatureserver.org/somelayer/.geojson OGRGeoJSON

Zeige eine Übersicht an von einem ArcGIS Feature Services (ArcGIS Server REST API):

 $ ogrinfo -ro al -so "http://sampleserver3.arcgisonline.com/ArcGIS/rest/services/Hydrography/Watershed173811/FeatureServer/0/query?where=objectid+%3D+objectid&outfields=*&f=json"

tbd...

MapInfo MIF/MID-Reader und -Writer

Konvertiere Shapefile nach MapInfo Files MIF/MID (erzeugt bahnhoefe.mif und bahnhoefe.mid im Unterverzeichnis .\tmp\). Wenn FORMAT=MIF fehlt, werden die binären TAB-Dateien erzeugt:

 > ogr2ogr -f "MapInfo File" tmp -dsco FORMAT=MIF bahnhoefe.shp

Konvertiere alle MapInfo-Dateien MIF/MID im Unterverzeichnis .\tmp\ (z.B. die Dateien bahnhoefe.mif und bahnhoefe.mid) nach Shapefile im selben Unterverzeichnis:

 > ogr2ogr -f "ESRI Shapefile" tmp tmp

Koordinatensystem-Transformation (ogr2ogr-Option SRS)

Beispiel CH1903 nach WGS84

Transformiere Shapefile, das im Koordinatensystem CH1903 vorliegt nach WGS84:

 > ogr2ogr out Bahnhoefe.shp -s_srs EPSG:21781 -t_srs EPSG:4326

Erläuterungen:

• EPSG:4326 steht für WGS84, also GPS-Koordinaten.
• EPSG:21781 ist der EPSG-Code für CH1903, EPSG:2056 für CH1903+/LV95
• Eine Liste aller Codes befindet sich in der Datei gcs.csv im data-Verzeichnis der FWTools.
• EPSG
• PRJ

SRS-Option als URL

"GDAl 1.5 release allows you to import a spatial reference definition from a URL. It’s expected that you might use http://spatialreference.org URLs, but any old URL will do. For example, this command will reproject the world_borders shapefile to an Albers projection that a user contributed that focuses on the Northern Pacific:"

Dasselbe Beispiel wie oben, nun aber mit einer URL:

 > ogr2ogr out Bahnhoefe.shp -t_srs http://spatialreference.org/ref/epsg/4326/ 

Erläuterungen:

• Liste von EPSG-Codes (bzw. URLs) siehe http://spatialreference.org

Räumlicher Ausschnitt (ogr2ogr-Option spat)

Über die spat-Option kann eine BBox angegeben als "xmin ymin xmax ymax" (hier: Region Zürich):

 > ogr2ogr -spat 8.38 47.81 8.83 47.30 -f KML output.kml input.shp

Vergrössern/Verkleinern der BBox:

 > ogr2ogr -spat 3500000 5300000 3540000 5400000 out.shp in.shp

Hinweis: -spat does not actually clip the returned geometries. It looks for all features whose geometries touch the selection region and returns the geometries intact, not clipped.

SQL-Queries (ogrinfo/ogr2ogr-Option SQL)

Siehe OGR SQL.

Analyse

ogrinfo als Analyse-Werkzeug kann auch mit SQL verwendet werden, z.B. zur Analyse.

Type Casting

Manchmal will man den Typ oder den Namen eines Datenfeldes beim Konvertieren ändern. Dazu gibt es ab GDAL/OGR 1.6 ev. eine Möglichkeit im Rahmen der OGR SQL select list (d.h. der sql-Option): Siehe rfc21_ogrsqlcast.

Beispiel: Importiert volle 255 Zeichen (statt nur den Default von 80) und ändert gleichzeitig das Datenfeld 'OGR_STYLE' zu 'style'.

 > ogr2ogr -f "ESRI Shapefile" -sql "select *, CAST(OGR_STYLE AS character(255)) AS 'style' from rivers" rivers.shp rivers.tab

Selektion und Projektion

Zeige alle Bahnhöfe mit Namen Rapperswil (falls es mehrere gibt...):

 > ogrinfo -al -ro Bahnhoefe.shp -sql "SELECT * FROM bahnhoefe WHERE name='Rapperswil'"

Konvertiere nur die Bahnhöfe mit Namen 'Rapperswil' (falls es mehrere gibt...):

> ogr2ogr Bahnhoefe_Rapperswil.shp Bahnhoefe.shp -sql "SELECT * FROM bahnhoefe WHERE name='Rapperswil'"

Join (Beschriftungen, Lookup-Tabellen)

Beispiel Zonenplan (SG):

• Quellen:
  • Geodaten: zuzwil.itf,zuzwil.ili
  • Tabelle 'A': Beschriftung_Kuerzel_rk, Attribute Entstehung_Gde_Kuerzel (Fremdschlüssel )
  • Tabelle 'B': Zone_rechtskraeftig, Attribute _TID, Identifikator, etc.
• Ziel: Zonenbeschriftung (Layer)
  • Tabelle Zonenbeschriftung mit Attributen _TID, Identifikator,Grundnutzungsflaeche,Zonenart_Gde_Kuerzel

Umweg von ILI über Shape1 nach joined Shape2...:

 1. ogr2ogr out -nln Zonenbeschriftung zuzwil.itf,zuzwil.ili
 2. rename ... zu Zone_Pos.shp und Zone.shp
 3. ogr2ogr -f "ESRI Shapefile" out -nln Zonenbeschriftung Zone_Pos.shp 
    -sql "SELECT Zonenart_G,_TID FROM Zone_Pos 
          JOIN 'Zone.shp'.Zone 
          ON Zone_Pos.Entstehung = Zone._TID"

Variante direkt von ILI joined nach Shape:

 ogr2ogr out -nln Zonenbeschriftung zuzwil.itf,zuzwil.ili 
   -sql "SELECT _TID,Identifikator,Grundnutzungsflaeche,Zonenart_Gde_Kuerzel 
         FROM Zonenplan__Beschriftung_Kuerzel_rk 
         JOIN 'zuzwil.itf,zuzwil.ili'.Zonenplan__Zone_rechtskaeftig 
         ON Zonenplan__Beschriftung_Kuerzel_rk.Entstehung_Gde_Kuerzel = 
            Zonenplan__Zone_rechtskraeftig._TID"

Test mit ogrinfo:

 ogrinfo zuzwil.itf,zuzwil.ili
   -sql ... (dasselbe SQL-Statement wie oben)

Beispiel amtliche Vermessung (AV-CH 01):

• Quellen:
  • Geodaten. gossau_ch01.itf,gossau_ch01.ili
  • Tabelle 'A': Liegenschaften__GrundstueckPos, Attribute GrundstueckPos_von, ...
  • Tabelle 'B': Liegenschaften__Grundstueck, Attribute _TID,Nummer
• Ziel: Parzellenbeschriftung (Layer)

 ogr2ogr out gossau_ch01.itf,gossau_ch01.ili 
   -skipfailures
   -nln Parzellenbeschriftung 
   -sql "SELECT _TID,Nummer 
         FROM Liegenschaften__GrundstueckPos 
         JOIN 'gossau_ch01.itf,gossau_ch01.ili'.Liegenschaften__Grundstueck 
         ON Liegenschaften__GrundstueckPos.GrundstueckPos_von = 
            Liegenschafen__Grundstueck._TID"

Treiber-spezifisches SQL

Falls das Quell-Format ein OGR-Treiber für Datenbanken (MySQL, PostgreSQL, Oracle, SQLite, ODBC und Personal Geodatabase) ist, wird der SQL-Befehl direkt an diesen Treiber weitergeleitet.

Hier ein Beispiel, bei dem das Attribut geom (aus Tabelle gisdb) vom Typ Linie zu einem solchen vom Typ Punkt umgewandelt wird. Dazu wird eine PostGIS-Funktion verwendet, welche den ersten Stützpunkt jeder Linie nimmt (Funktion ST_Startpoint(...)). Das Resultat wird in einen Layer (Shapefile) vom Typ POINT geschrieben (Option -nlt):

 ogr2ogr point.shp PG:dbname=gisdb 
         -sql "SELECT ST_Startpoint(geom)::geometry AS geom FROM gtest" 
         -nlt POINT

ogr2ogr-Optionen Split- und Skipfailures

Split Files

To split a DGN file into shapefiles with distinct geometry types try:

 > ogr2ogr -skipfailures -nlt point      out\demo_point.shp demo.dgn
 > ogr2ogr -skipfailures -nlt linestring out\demo_line.shp  demo.dgn
 > ogr2ogr -skipfailures -nlt polygon    out\demo_poly.shp  demo.dgn

You will see lots of error messages which you can ignore.

Merge Files

How to merge several Shapefiles into one?

Windows:

 > for %f in (dir1\*.shp dir2\*.shp) do (ogr2ogr -f "ESRI Shapefile" -append merged %f) 

Unix:

 > for i in $(ls *.shp); do ogr2ogr -f 'ESRI Shapefile' -update -append merged $i -nln abcdef

OGR parameter 'Simplify'

Simplify-Parameter "-simplify tolerance" (>= GDAL 1.9.0) mit Zahl. Mit der Zahl wird in den Einheiten des Quellformats(?) die Distanztoleranz angegeben, unterhalb der eine Linie vereinfacht wird. Die Funktion soll sogar Topologie erhalten. Siehe ogr2ogr.

Mit dieser Vereinfachung erreicht man auch z.T. erheblich kleinere Dateien.

Beispiel, das die Grenzlinien von Schweizer Kantonen (SQLite-Format) in eine andere SQLite-Datei umwandelt mit vereinfachten Grenzen:

 ogr2ogr -simplify 10 gg25_simplified.sqlite gg25.sqlite

HINWEIS: NOCH NICHT GETESTET!

OGR parameter stdin/piping

You can chain processes with the following command :

Read.osm.bz2 files and/or online files (Unix),

 bzcat my.osm.bz2 | ogr2ogr -f SQLite my.sqlite /vsistdin/

Convert an .osm or .pbf file without downloading it (Unix):

 wget -O - http://www.example.com/some.pbf | ogr2ogr -f SQLite my.sqlite /vsistdin/

Convert an .osm or .pbf file without downloading it (Windows):

 curl http://download.geofabrik.de/europe/liechtenstein-latest.osm.pbf | ogr2ogr -f SQLite liechtenstein.sqlite /vsistdin/

Ask for metadata with ogrinfo (Windows, ignore spurious error):

 curl http://download.geofabrik.de/europe/liechtenstein-latest.osm.pbf | ogrinfo -al -so /vsistdin/
 ogrinfo -al -so /vsicurl/http://download.geofabrik.de/europe/albania-latest.osm.pbf

Read zip Files from ogrinfo and ogr2ogr:

 ogrinfo /vsizip//vsicurl/http://www.srh.noaa.gov/images/shv/shp/Day2_Conv_Outlook/Day2_Conv_Outlook.latest.zip -al -so -ro CATEGORICAL
 ogr2ogr -f "GeoJSON" out.json /vsizip//vsicurl/http://www.srh.noaa.gov/images/shv/shp/Day2_Conv_Outlook/Day2_Conv_Outlook.latest.zip -skipfailures -overwrite

Grafik in OGR

Seit kurzen gibt es eine akzeptierten Draft 'OGR-Feature Style Specification' wie das Konzept eines Grafikmodells ('Features Styles') und deren Konfiguration aussehen soll. Features Styles werden soweit wie möglich beim Konvertieren (translating) zwischen Formaten, die Styles unterstützen, beibehalten.

Zurzeit wird die Grafik-Information nur bei den Formaten MIF/TAB und DGN berücksichtigt.

Anwendungen von Styles:

• UMN MapServer und das 'OpenEV' machen Gebrauch davon.
• Zukunft:
  • Der KML-Driver wäre ein Kandidat, unterstützt aber leider noch keine.
  • Eine Erweiterung des VRT-Formats (siehe oben) wäre naheliegend und könnte relativ einfach realisiert werden.

Quelle: OGR-Feature Style Specification draft V0.010 - 2006/09/23

Was sind die Gemeinsamkeiten und Unterschiede von SLD und Mapfile (UMN MapServer)?

The concept of assigning rendering rules to geometries is shared in both cases but that's about it. The terminology (pen/brush/etc vs SLD symbolizers) and encoding (compact text strings vs verbose XML) are completely different. SLD also supports building up classifications using filter encoding which is not part of the OGR style concept. Why did OGR invent its own encoding instead of reusing SLD? Mostly because the OGR style encoding predates the days when SLD became well known. But even if we were to do this again today I'm not sure if we would opt for a verbose XML encoding... we'd probably spend a lot of time debating the performance issues vs the benefits of interoperability with SLD.

Beispiele:

 > ogrinfo -al -ro Bahnhoefe.mif -sql "SELECT *,OGR_STYLE FROM Bahnhoefe WHERE OGR_STYLE LIKE '%'"