User Tools

Site Tools


r:r-tutorials:rsaga

FIXME This page is not fully translated, yet. Please help completing the translation.
(remove this paragraph once the translation is finished)

Introduction to RSAGA

Warum RSAGA?

Das Open-Source GIS SAGA kann nahezu vollständig und einfach aus der R-Umgebung genutzt werden. R kann vor allem für eine weiterführende statistische Analyse von Geodaten aber auch als einfache Skript-Sprache zur Steuerung von SAGA genutzt werden. Neben der deutlich höheren Leistungsfähigkeit dieser Kombination läuft SAGA im Skript-Modus deutlich stabiler als mit der eigenen GUI. Zunächst werden die notwendigen Voraussetzungen erläutert. Im Anschluss werden anhand einiger Code-Schnipsel Anwendungsmöglichkeiten gezeigt. Für ein etwas umfangreicheres Beispiel sei auf die Seite Der perfekte Gipfel verwiesen.

Erste Schritte mit RSAGA

R und Saga installieren

RSAGA funktioniert derzeit nur für SAGA Versionen > 2.0.4 und < 2.1.0

Windows

Für Windows gibt es das Rundum-Sorglos-Paket WinR-Gis2Go. Hier finden sich QGIS,SAGA,GRASS R und RStudio als portable Bündel inkl. einem kleinen aber feinen Setup Skript.

Linux

Die folgende Anleitung ist für Xubuntu/Ubuntu/Kubuntu 12.04 precise und SAGA 2.0.8 getestet. Falls SAGA 2.04 - 2.8.0 eingesetzt wird sollte es mit den Beispielen keine Probleme geben. Falls SAGA 2.1.0 unter Linux verwendet wird bitte diesen Saga 2.1.0 Fix einspielen. Bei Bedarf kann auch die XubuntuGIS 14.04 Distro installiert werden.

R Basis installieren

* R Basispaket installieren

sudo apt-get install r-base
  • Einbinden des Ubuntu GIS Repository und Update/Upgrade der Paketlisten/Pakete
sudo sh -c 'echo "deb http://ppa.launchpad.net/ubuntugis/ppa/ubuntu precise main " >> /etc/apt/sources.list' 
sudo apt-get update && sudo apt-get upgrade
sudo apt-get install saga
  • Weils gerade so gut läuft auch noch GRASS GIS und Doku installieren
sudo apt-get install grass
sudo apt-get install grass-doc
  • Nach Wunsch R GUI installieren Geschmackssache (z.B. R-Studio )
sudo sh -c 'echo "deb http://ppa.launchpad.net/aims/aims-desktop/ubuntu precise main " >> /etc/apt/sources.list' 
sudo apt-get install rstudio-upstream-deb
Hier sieht man dann als Beispiel den //Simple Filter// aus der Bibliothek //libgrid_filter//. 

Windows

…den Anweisungen unter http://mirrors.softliste.de/cran/ → Download R for Windows → install R for the first time und http://sourceforge.net/projects/saga-gis/ folgen

RSAGA package installieren

* R GUI starten und das R Package RSAGA unter installieren:

install.packages ("RSAGA")       # RSAGA installieren

Tip: Will man keine IDE wie R-Studio so kann zum Schreiben des R Skripts auch jeder Text Editor verwendet werden. Angenehm ist Syntax-Highlighting z.B. unter Windows “notepad++“ (unter “Sprachen” R angeben!) bzw. unter Linux geany. Nach der Fertigstellung des des Skripts, kann der Inhalt einfach in die R Konsole kopiert und ausgeführt werden.

Weitere Pakete installieren

Optional aber sehr nützlich für die erweiterte Bearbeitung von Geodaten sind die folgenden Pakete

install.packages ("gdalUtils")   # GDAL& more für R installieren
install.packages ("maptools")    # maptools installieren
install.packages ("spgrass6")    # R Paket für die Integration von GRASS 
install.packages ("raster")      # generisches R Paket für die HAndhabung von Rastern 

Umgebungsvariablen und Librarys

Um die RSAGA Funktionen nutzen zu können, muss jedes Mal wenn R neu gestartet wird die RSAGA library geladen werden. Deshalb ist das die erste Zeile des R-Skripts:

library(RSAGA)      # RSAGA library laden

RSAGA muss wissen, wo es SAGA finden soll. Daher muss der Pfad zu “saga_cmd.exe” sowie zu den SAGA Modulen angegeben werden. Außerdem muss der Workspace angegeben werden, also das Arbeitsverzeichnis wo sich die Inputdaten befinden bzw. wo neue Daten gespeichert werden sollen. Normalerweise sollte es reichen, wenn die Umgebung einmal eingestellt wird, allerdings scheint das nicht immer zu funktionieren. In dem Fall muss die Umgebung bei jedem Modul mit angegeben werden (folgt später!). Um aber nicht die ganzen Pfade jedes Mal angeben zu müssen, kann eine Variable (myenv) erstellt werden, die die Environment Settings enthält.

myenv=rsaga.env(workspace="E:/Gipfeltourenplaner",
               path="C:/Program Files (x86)/SAGA-GIS",
               modules="C:/Program Files (x86)/SAGA-GIS/modules")  #PFADE ANPASSEN!

Wenn alles geklappt hat müsste beim Aufrufen von “myenv” bzw wenn es nicht auf eine Variable geschrieben wurde beim Aufruf von “rsaga.env()” ungefähr so was erscheinen:

rsaga.env()
 
$workspace
[1] "/home/workspace/sagaprojects/GIPFEL/SRTM/work"
$cmd
[1] "saga_cmd"
$path
[1] "/usr/bin"
$modules
[1] "/usr/lib/saga"
$version
[1] "2.0.7"

Sinnvoll, wenn man neben den SAGA Funktionen auch R Funktionen nutzt und die Daten hin und her schickt, ist das working directory in R identisch dem Workspace in SAGA zu setzen:

setwd("/home/workspace/sagaprojects/GIPFEL/SRTM/work")

SAGA Module über R verwenden

Es gibt 2 Möglichkeiten die Saga Module zu verwenden. am einfachsten ist es, wenn das Modul im RSAGA-Manual gelistet ist. Dann kann das Modul so ausgeführt werden, wie es dort angegeben ist. Der Vorteil ist, dass man nicht alle Parameter angeben muss, da die voreingestellten Werte für den Parameter verwendet werden. Die andere Möglichkeit ist der direkte Zugriff auf die Module. Das ist nicht komplizierter als die erste Möglichkeit, es müssen nur in der Regel ALLE Parameter angegeben werden (außer optionale Eingaben, Der exakte Aufruf steht dann in der rsaga.get.usage() Hilfe). Um es hier allgemein zu halten, wird nur diese Möglichkeit vorgestellt, da sie für alle Module funktioniert.

rsaga.get.modules(,env=myenv)                     #gibt Überblick über Module 
rsaga.get.usage("io_grid",6,env=myenv)            #gibt an was alles angegeben werden muss für zB Modul "io_grid,6" 

Die Syntax zur Modulausführung ist immer die gleiche und sieht so aus: Es wird für jedes Modul “rsaga.geoprocessor” geschrieben, dann den Namen der Modulkategorie in Anführungszeichen sowie den Code für das Modul. Evt. muss env wieder angegeben werden. Also alles genauso wie bei get.usage(). Es folgt dann eine Liste, in der alle Parameter, die bei get.usage() genannt werden angegeben werden müssen.

rsaga.geoprocessor("NameDerModulKategorie",ModulCode,env=myenv,list(...))

Übersicht der verfügbaren SAGA Module

Wenn man sich das [RSAGA manual|http://cran.r-project.org/web/packages/RSAGA/RSAGA.pdf]anschaut, fällt auf, dass nur einige der SAGA Module beschrieben sind. Das sind die benutzerfreundlich gestalteten Module, die in R einfach verwendet werden können (später!). Generell kann aber jedes SAGA Modul verwendet werden. Eine Übersicht über alle SAGA Module findet man so:

rsaga.get.modules()                  # gibt Überblick über Module
rsaga.get.modules(,env=myenv)        # sollte das nicht Funktionieren weil die Umgebung nicht gespeichert ist,
                                     # muss env mit angegeben werden:

Hilfe zu den SAGA-Modulen

Um zu erfahren, wie man das konkrete Modul verwendet, benötigt man den Befehl “rsaga.get.usage()”. Will man zum Beispiel wissen, wie man das Modul “simple filter” verwendet, gibt man den Namen der Kategorie, also “grid_filter” und den Code dieser Funktion, also hier “0” an. Zusätzlich muss evt die environment(env) angegeben werden.

Mit dem folgenden Befehl kann man konkret zu einem spezifischen Algorithmus (0 im Beispiel) innerhalb des Moduls Hilfe erhalten. Nicht irritieren lassen, dass immer Unknown option 'h' mit ausgegeben wird ;)

rsaga.get.usage("grid_filter",0)
Unknown option 'h'
Usage: 0 -INPUT <str> [-RESULT <str>] [-MODE <str>] [-METHOD <str>] [-RADIUS <num>]
  -INPUT:<str> 	Grid
	Grid (input)
  -RESULT:<str>	Filtered Grid
	Grid (optional output)
  -MODE:<str>  	Search Mode
	Choice
	Available Choices:
	[0] Square
	[1] Circle
  -METHOD:<str>	Filter
	Choice
	Available Choices:
	[0] Smooth
	[1] Sharpen
	[2] Edge
  -RADIUS:<num>	Radius
	Integer
	Minimum: 1.000000
library path:	/usr/lib/saga
library name:	libgrid_filter
module name :	Simple Filter                                                             

Somit erhält man die Liste aller Parameter, die für die Verwendung des Moduls angegeben werden müssen, also in diesem Fall ein Inputgrid, Outputgrid und Angaben zur Methode die verwendet werden soll. Alle Parameter entsprechen den Parametern, die man auch in Saga angeben würde. Zum Vergleich, hier das bekannte Saga Modul (manchmal lohnt es sich auch, das Modul vorher manuell in SAGA zu testen um zu wissen wie es funktioniert):

Erstes Beispiel

zum Download der Daten für die Beispiele

Wenn sich ein Saga Grid (.sgrd) im Workspace befindet, kann z.B. die Funktion Filter verwendet werden. Entsprechend der Angaben bei get.usage() wird im Beispiel das Eingabe-DGM angegeben, der Name für das Ergebnis Raster gewählt und in diesem Fall der Modus “square” mit einem Radius von 3 Pixeln und die Methode “smooth” gewählt. Achtung falls der Radius groß gewählt wird, kann das eine gewisse Zeit dauern.

rsaga.geoprocessor("grid_filter",0,env=myenv,list(					
                  INPUT="InputDGM.sgrd",
                  RESULT="filteredGrid",
                  MODE=0,
                  METHOD=0,
                  RADIUS=3))

Zu beachten ist, dass die Input Daten immer mit Endung angegeben werden müssen (”InputDGM.sgrd”), bei den Ergebnissen i.d.r aber kein Dateiendung angegeben werden darf. Die Endung ist automatisch „sgrd“ für Rater bzw „shp“ für Shapefiles.

Ausnahme: bei Exportmodulen muss die Endung (zB .csv,.rst,.tif) auch beim Ergebnis mit angegeben werden. Wenn alles funktioniert hat, steht im R Fenster “ready” (siehe unten) und im Workspace Verzeichnis ist das Raster “filteredGrid.sgrd” hinzugekommen.

Weitere Beispiele

Als weiteres Besipiel lassen sich jetzt mit dem gefilterten DGM Gipfel (=lokale Maxima) bestimmen. Dazu wird die “local Maxima” Funktion von SAGA auf dem gefilterten DGM verwendet.

rsaga.geoprocessor("shapes_grid",9,list(
                      GRID="filteredGrid.sgrd",            #Das Ergebnis vom Schritt davor
                      MAXIMA="localmax",                   #Ergebnis: Gifel Shapefile 
                      MINIMA="tmp"))                       #Ergebnis local min muss angegeben werden, 
                                                           #interessiert uns aber nicht

So wie am Beispiel “Filter” und “LocalMax”, funktionieren alle Module. Bei get.usage() ist jeweils die Angabe von welchem Typ die Eingabe sein muss zu finden. Beim “Filter” Modul gabe es die Typen “grid” und “choice”. Weitere häufige Eingabetypen sind “Text”, “shape”, “integer”,… die selbsterklärend sind. Ist der Typ “Boolean” verlangt, muss entweder TRUE oder FALSE eingegeben werden. Beim Typ “Grid List”, wird eine Liste mit mehreren durch ”;” getrennten Grids eingegeben (z.B. GRIDS=list(“Grid1.sgrd;Grid2.sgrd”)). Der Grid Calculator ist ein gutes Beispiel dafür. Das Beispiel zur Verwendung vom Grid Calculator ist weiter unten auf dieser Seite zu finden.

Vorteile von R nutzen

Daten Im-und Export

Datenimport: Daten von SAGA nach R

Generell sind die Daten die über RSAGA in SAGA bearbeitet werden nicht in R gespeichert. Um die Daten nach R zu bekommen gibt es mehrere Möglichkeiten. Am einfachsten lassen sich sowohl Raster als auch Shapefiles als xyz Datei über (R-)SAGA exportien und dann in R als Tabelle importieren. Koordinaten und Werte bleiben dann erhalten und es besteht die Möglichkeit ganz normal in der Tabelle/Spalte mit den Werten zu arbeiten und das Ergebnis später wieder als Shapefile/Raster zu konvertieren.

Das Beispiel für Shapefiles:

rsaga.geoprocessor("io_shapes",2,env=myenv, list(
                  SHAPES="localmax.shp",
                  FIELD="Z",
                  SEPARATE=0,
                  FILENAME="gipfel.xyz"))

…und für Raster:

rsaga.geoprocessor("io_grid",5,env=myenv,list(
                      GRIDS=list("marburg.sgrd"),
                      FILENAME="Marburg.xyz",
                      CAPTION=TRUE,
                      EX_NODATA=FALSE))

Jetzt kann die XYZ Datei einfach in R importiert werden:

GipfelTabelle=read.table("gipfel.xyz",header=T)

Das Ergebnis sieht dann zB. so aus:

Wenn die Eigenschaft als räumliches Objekt beibehalten werden soll, benötigt man weitere R-Packages. Das [http://cran.r-project.org/web/packages/raster/raster.pdf |Raster] Package erlaubt es Raster in R einzulesen und bietet zudem diverse Funktionen für Rasteroperationen. Weitere Packages für räumliche Daten (auch für Vektordaten) in R sind [hier|http://cran.r-project.org/web/views/Spatial.html] zu finden.

Datenexport: Daten von R nach SAGA

Tabellen in R, die die Koordinaten enthalten können in Shapefiles/Raster exportiert werden. Am einfachsten indem man die Tabellen als xyz Dateien importiert. Dazu müssen die Tabellen zunächst im workspace gespeichert werden. Wichtig ist dabei, dass die Spalten durch Tabulatoren getrennt sind.

write.table(GipfelTabelle, "gipfel.xyz",row.names=F,sep="\t")

Diese Datei kann dann importiert werden mit XYZ zu Raster bzw Shape. Hier das Beispiel für Shapefiles (Raster funktioniert im Prinzip genauso):

rsaga.geoprocessor("io_shapes",3,env=myenv,list(
                      SHAPES="GipfelShape",
                      X_FIELD=2,
                      Y_FIELD=1,
                      FILENAME="gipfel.xyz"))

Damit wird dann das Shapefile “GipfelShape.shp” erstellt und im workspace gespeichert.

Prozesse automatisieren

Mit Hilfe von RSAGA ist es jetzt möglich, Schritte zu automatisieren, indem Module aneinandergereiht werden, dessen Input zB jeweils der output vom letzten Modul ist. Dafür bräuchte man prinzipiell aber kein R, da dies auch durch die einfache Verwendung des [SAGA command line interpreter tools|http://sourceforge.net/apps/trac/saga-gis/wiki/Executing%20Modules%20with%20SAGA%20CMD] möglich ist. Durch die zusätzliche Verwendung von R ist aber auch möglich, einzelne Pixel/Punkte/… nacheinander anzusprechen, indem man in der Tabelle in R einzelne Einträge selektieren kann und zB aus diesem Subset neue Raster/Shapefiles erstellen kann, was nur über SAGA CMD nicht möglich wäre.

Beispiel Zur Veranschaulichung folgendes Beispiel: Es liegt ein Shapefile mit Gipfelpunkten und ein DGM vor. Es soll jetzt für jeden Gipfel bestimmt werden, in welchem Umkreis er der höchste ist (=Dominanz).

Der Lösungsansatz sieht so aus: Es wird für jeden Gipfel ein “proximity Grid” erstellt, welches für jedes Pixel die Entfernung zum Gipfel angibt. Weiterhin wird für jeden Gipfel ein binäres Grid benötigt, welches die Pixel ausschließt die niedriger sind als der Gipfel. Der minimale Wert des Produkts beider Raster ist die gefragte Dominanz des Gipfels.

Die Tabelle “gipfel” ist bereits in R vorhanden (siehe weiter oben). Da die Berechnungen für jeden Gipfel einzeln durchgeführt werden müssen, wird eine Schleife geschrieben, die die Module für jede Zeile der Gipfel-Tabelle (=1 Gipfel) aufruft.

Würde nur SAGA verwendet werden, müsste jeder der folgenden Schritte für jede Zeile (=Eintrag im Shapefile) der Tabelle per Hand durchgeführt werden, was ein fast unmöglicher Arbeitsaufwand wäre. Mit Hilfe von R muss der Prozess nur einmal geschrieben werden und läuft für alle Zeilen, also alle Gipfel automatisch ab.

Der zu implementierende Lösungsansatz sieht folgendermaßen aus:

for (i in 1: nrow(gipfel))    
{
#-Höhe vom Gipfel i aus der "gipfel"- Tabelle abfragen     
#-Zeile i der gipfel Tabelle als XYZ speichern
#-XYZ zu shape
#-shape zu raster
#-Binäres Grid (größer/kleiner Gipfel i) erstellen (reclass)
#-Proximity Grid erstellen
#-Grids multiplizieren
#-Raster nach R
#-Minimalen Wert abfragen
}

…übersetzt in R müsste folgendes eingegeben werden:

for (i in 1: nrow(gipfel))    
{
  hoehe=gipfel$Z[i]                                            #Die Höhe von Gipfel "i" als variable "hoehe" speichern
  write.table(gipfel[i,], "tmp1.xyz",row.names=F,sep="\t")     #speichert die Zeile i als xyz mit Dateinamen "tmp1.xyz"
  rsaga.geoprocessor("io_shapes",3,env=myenv,list(             #Die xyz Datei wird zu shapefile "Gipfel.shp"   
                      SHAPES="Gipfel",
                      FILENAME="tmp1.xyz",
                      X_FIELD=1,
                      Y_FIELD=2)) 
  rsaga.geoprocessor("grid_gridding",0,env=myenv,list(         #shp zu raster
                      INPUT="Gipfel.shp",
                      FIELD="X",
                      LINE_TYPE=2,
                      GRID_TYPE=3,
                      TARGET=1,GRID_GRID="tmp.sgrd")) 
  rsaga.geoprocessor("grid_tools",15,env=myenv,list(           #binäres grid erstellen mit Reclass: Alle die <Z bekommen Wert 0
                      INPUT="filteredGrid.sgrd",
                      RESULT="recl1",
                      METHOD=0,
                      OLD=hoehe,
                      NEW=0,
                      SOPERATOR=1))
  rsaga.geoprocessor("grid_tools",15,env=myenv,list(	       #Reclass: Alle die >=Z bekommen Wert 1
                      INPUT="recl1.sgrd",
                      RESULT="hoeherePixel",
                      METHOD=0,
                      OLD=hoehe,
                      NEW=1,
                      SOPERATOR=3))                            #Anmerkung zu reclass: Das geht bestimmt auch in einem Schritt...
  rsaga.geoprocessor("grid_tools",26,env=myenv,list(           #Proximity grid erstellen
                      FEATURES="tmp.sgrd",
                      DISTANCE="Proximity"))
  rsaga.geoprocessor("grid_calculus",1,env=myenv,list(	       #Raster aus Schritten davor multiplizieren
                      GRIDS=list("Proximity.sgrd;hoeherePixel.sgrd"),
                      RESULT="Dominanz",
                      FORMULA="a*b"))
  dominanzgrd=raster("Dominanz.sgrd")                          #Raster in R verfügbar machen (Achtung: library "raster" muss geladen sein)
  tmp=getValues(dominanzgrd) 
  gipfel$dominanz[i]=min(tmp[tmp>0])                           #Dominanz mit in die "gipfel" Tabelle schreiben
}

Statistische Analysen

In den oben gezeigten Beispielen wurde R genutzt um Sagamodule zu verwenden und zu automatisieren. Das Kapitel “Statistische Analysen” ist nicht unbedingt notwendig um die Schnittstelle RSAGA zu erklären denn die statistische Auswertungen finden i.d.R unabhängig von den SAGA Modulen, nur in R, statt. Trotzdem soll auf dieses Kapitel hier nicht verzichtet werden, da es einen entscheidenden Grund liefert sich mit einer Kombination von Gissoftware und R zu beschäftigen. Da diese Seite allerdings keine R Anleitung sein soll, sondern sich eigentlich mit der Schnittstelle RSAGA befasst, soll hier nur knapp einige Ansätze gezeigt werden wie man Raster so vorbereitet, dass gängige statistische Methoden auch auf diese Daten anwendbar werden.

Statistik mit Rasterdaten

Hier hat man die Möglichkeit entweder extra Packages für Statistik mit räumlichen Daten zu verwenden (siehe http://cran.r-project.org/web/views/Spatial.html) oder aber ganz einfach: man konvertiert das Raster (evt auch nur vorübergehend) zu einer Matrix und verwendet dann Standardmethoden in R.

library(raster)                      #wird benötigt um das Raster in R zu laden
dgm=raster("InputDGM.sgrd")          #Raster wird geladen
dgmmatrix=as.matrix(dgm)             #...und zu einer Matrix konvertiert
head(dgmmatrix)                      #...die dann so aussieht

mean(dgmmatrix);sd(dgmmatrix);hist(dgmmatrix);sum(dgmmatrix<150)    #einige Kleinigkeiten zum ausprobieren 
#-> Funktioniert alles wie üblich mit Matritzen

Jetzt lassen sich mit den Rasterwerten sämtliche Tests durchführen oder auf einzelne Rasterwerte zugreifen und diese Verändern, verschiedene Raster der gleichen Ausdehnung&Auflösung vergleichen, Korrelationen dazwischen durchführen usw. Auch ist es möglich zB Korrelationen für jedes Pixel (=Feld in der Matrix) einzeln durchzuführen.

Der Nachteil der Konvertierung zu Matritzen ist, dass die Eigenschaft als räumliches Objekt verloren geht. Koordinaten sind nicht mehr vorhhanden. Diese Eigenschaft kann aber leicht wiederhergestellt werden indem aus der Matrix ein Raster mit den früheren Eckkoordinaten erstellt wird. Die Eckkoordinaten erhält man durch Aufruf des ursprünglichen Rasters.

Die Eckkorrdinaten werden dann verwendet um aus der Matrix wieder ein Rasterobjekt zu machen:

dgmAusMatrix=raster(dgmmatrix,xmn=3477585,xmx=3495245, ymn=5623315, ymx=5637785)

Fehlersammlung

Checkliste

Mögliche Gründe wenn Modul nicht ausgeführt werden kann:
  • env nicht angegeben?
  • Parameter nicht durch “,” getrennt?
  • nicht alle Parameter angegeben?
  • falscher Eingabetyp (zb “grid” statt “shp”)?
  • Modul funktioniert mit dem Input nicht? → manuell in SAGA testen!

Sammlung auftretender Schwierigkeiten

  • Häufig bei “Shape to Grid” und “Grid Resampling”:

Wenn der Parameter “GRID_GRID” vorkommt und es sich um den Output handelt, dann MUSS ein bereits vorhandenes Grid (mit Endung!) angegeben werden, weil in diese Datei hineingeschrieben wird. Das ist der Fall bei Modulen wie “Shape to Grid” wo die räumliche Ausdehnung für das Ergebnis festgelegt werden muss! Häufig gibt es dort auch den Parameter “USER_GRID” das ein optionaler Output ist. Dieser kann meistens vernachlässigt werden.

rsaga.geoprocessor("grid_gridding",0,env=myenv,list(                   
                      INPUT="merged.shp",
                      FIELD="X",
                      LINE_TYPE=2,
                      GRID_TYPE=3,
                      TARGET=1,
                      GRID_GRID="tmp.sgrd"))
  • z.B bei “Points to Lines”:

Obwohl “ORDER” und “SEPARATE” optionale Parameter sind wird durch RSAGA ein manchmal unerwünschtes Feld als default gesetzt. Deshalb müsste, Saga entsprechend, eigentlich “not set” angegeben werden. “Not set” wird mit Rsaga normalerweise aber dadurch erreicht das man den Parameter einfach nicht angibt. Da das aber nicht funktioniert muss die ID eines Feldes Angegeben werden das nicht existiert. Wenn die Attributtabelle beispielsweise 2 Felder hat wird ORDER=3 und SEPARATE=3 angegeben.

Ergänzungen und weitere nützliche Infos gibt es hier:

Hanna Meyer

r/r-tutorials/rsaga.txt · Last modified: 2018/12/23 19:46 (external edit)