Outdated version of the documentation. Find the latest one here.

SEXTANTE mit der Konsole nutzen

Einführung

Die Konsole ermöglicht fortgeschrittenen Anwendern, die Produktivität zu steigern und komplexe Operationen auszuführen, die mit keinem der anderen Elemente der SEXTANTE Toolbox ausgeführt werden können. Modelle mit mehreren Algorithmen können mit der Kommandozeilen-Schnittstelle erstellt und zusätzliche Operationen wie Schleifen und Bedingungen hinzugefügt werden, um flexible und leistungsfähige Workflows zu erstellen.

Es gibt keine SEXTANTE Konsole in QGIS, aber alle SEXTANTE Befehle stehen in der QGIS Python-Konsole zur Verfügung. Das bedeutet, dass Sie diese Befehle in Ihre Arbeit mit der Konsole einfließen lassen und mit SEXTANTE Algorithmen verbinden können, um somit alle Funktionen (einschließlich der Methoden aus der QGIS API) zur Verfügung zu haben.

Der Code, den Sie mit der Python-Konsole ausführen, auch wenn es keine SEXTANTE Methode enthält, können Sie in einen neuen SEXTANTE Algorithmus umwandeln, den Sie später aus der Toolbox, den grafischen Modeller oder jede andere SEXTANTE Komponente starten können. genauso wie jeder andere SEXTANTE Algorithmus. Tatsächlich sind einige Algorithmen, die Sie in der Toolbox finden, z.B. aus der mmqgis Gruppe einfache Skripte.

In diesem Kapitel werden Sie sehen, wie Sie die SEXTANTE QGIS Python-Konsole verwenden, und auch, wie Sie Ihre eigenen Algorithmen mit Python schreiben können.

SEXTANTE aus der Python Konsole aufrufen

Als erstes müssen Sie die SEXTANTE Funktionen mit folgender Zeile importieren:

>>> import sextante

Im Grunde gibt es nur eine (interessante) Sache, die Sie mit SEXTANTE von der Konsole aus tun können: einen Algorithmus ausführen. Dieses geschieht mit dem runalg() Verfahren, die den Namen des Algorithmus nimmt und als ersten Parameter ausführt und danach eine variable Anzahl von zusätzlichen Parametern in Abhängigkeit von den Anforderungen des Algorithmus. Die erste Sache, die Sie wissen müssen, ist also der Name des Algorithmus. Das ist nicht der Name, den Sie in der Toolbox sehen, sondern ein Kommandozeilen-Name. Um den richtigen Namen für Ihren Algorithmus zu finden, können Sie die algslist()-Methode nutzen. Geben Sie folgende Zeile in die Konsole ein:

>>> sextante.alglist()

Sie werden etwas wie dieses sehen.

Accumulated Cost (Anisotropic)---------------->saga:accumulatedcost(anisotropic)
Accumulated Cost (Isotropic)------------------>saga:accumulatedcost(isotropic)
Add Coordinates to points--------------------->saga:addcoordinatestopoints
Add Grid Values to Points--------------------->saga:addgridvaluestopoints
Add Grid Values to Shapes--------------------->saga:addgridvaluestoshapes
Add Polygon Attributes to Points-------------->saga:addpolygonattributestopoints
Aggregate------------------------------------->saga:aggregate
Aggregate Point Observations------------------>saga:aggregatepointobservations
Aggregation Index----------------------------->saga:aggregationindex
Analytical Hierarchy Process------------------>saga:analyticalhierarchyprocess
Analytical Hillshading------------------------>saga:analyticalhillshading
Average With Mask 1--------------------------->saga:averagewithmask1
Average With Mask 2--------------------------->saga:averagewithmask2
Average With Thereshold 1--------------------->saga:averagewiththereshold1
Average With Thereshold 2--------------------->saga:averagewiththereshold2
Average With Thereshold 3--------------------->saga:averagewiththereshold3
B-Spline Approximation------------------------>saga:b-splineapproximation
...

Das ist eine Liste aller verfügbaren Algorithmen, alphabetisch geordnet, zusammen mit ihren entsprechenden Kommandozeilen-Namen.

Sie können einen String als Parameter für diese Methode verwenden. Statt die vollständige Liste der Algorithmen zurückzugeben, werden nur diejenigen angezeigt, die diese Zeichenfolge enthalten. Wenn Sie auf der Suche nach einem Algorithmus sind, um aus einem DGM die Hangneigung zu berechnen, tippen Sie alglist("slope"), um das folgende Ergebnis zu bekommen:

DTM Filter (slope-based)---------------------->saga:dtmfilter(slope-based)
Downslope Distance Gradient------------------->saga:downslopedistancegradient
Relative Heights and Slope Positions---------->saga:relativeheightsandslopepositions
Slope Length---------------------------------->saga:slopelength
Slope, Aspect, Curvature---------------------->saga:slopeaspectcurvature
Upslope Area---------------------------------->saga:upslopearea
Vegetation Index[slope based]----------------->saga:vegetationindex[slopebased]

Dieses Ergebnis könnte sich ändern, je nach den Algorithmen, die Sie zur Verfügung haben.

Es ist jetzt einfacher, den Algorithmus, die Sie suchen und den Kommandozeilen-Namen zu finden, in diesem Fall saga:slopeaspectcurvature.

Sobald Sie den Kommandozeilen-Namen des Algorithmus wissen, ist das nächste, was zu tun ist, die richtige Syntax zu kennen, um sie auszuführen. Das bedeutet, Sie müssen wissen, welche Parameter erforderlich sind und in welcher Reihenfolge sie beim Aufruf des runalg() Verfahrens zu übergeben sind. SEXTANTE bietet ein Verfahren, um einen Algorithmus im Detail zu beschreiben mit einer Liste der Parameter, die der Algorithmus fordert und die Ausgaben, die erzeugt werden können. Um dies zu erreichen, können Sie die alghelp(name_of_the_algorithm)-Methode nutzen. Verwenden Sie den Kommandozeilen-Name des Algorithmus, nicht den beschreibenden Namen.

Aufrufen der Methode mit saga:slopeaspectcurvature als Parameter, wird folgende Beschreibung ausgegeben.

>>> sextante.alghelp("saga:slopeaspectcurvature")
ALGORITHM: Slope, Aspect, Curvature
   ELEVATION <ParameterRaster>
   METHOD <ParameterSelection>
   SLOPE <OutputRaster>
   ASPECT <OutputRaster>
   CURV <OutputRaster>
   HCURV <OutputRaster>
   VCURV <OutputRaster>

Jetzt haben Sie alles, was Sie brauchen, um jeden Algorithmus laufen zu lassen. Wie wir bereits erwähnt haben, gibt es nur einen einzigen Befehl, Algorithmen auszuführen: runalg(). Die Syntax ist wie folgt:

>>> sextante.runalg{name_of_the_algorithm, param1, param2, ..., paramN,
         Output1, Output2, ..., OutputN)

Die Liste der Parameter und Ausgaben, die hinzugefügt werden müssen, hängt vom Algorithmus ab, den Sie ausführen möchten, und ist genau die Liste, die die alghelp()-Methode anzeigt, und zwar in derselben Reihenfolge wie gezeigt.

Je nach Art der Parameter, werden Werte unterschiedlich integriert. Der nächste Abschnitt gibt einen kurzen Überblick, wie man Werte für jede Art von Eingabeparameter einführt

  • Rasterlayer, Vektorlayer oder Tabelle. Verwenden Sie einfach einen String mit dem Namen, der das Datenobjekt identifiziert (der Name der in der QGIS Legende auftaucht) oder ein Dateiname (wenn der entsprechende Layer nicht geöffnet ist, wird es geöffnet, aber nicht in das Kartenfenster hinzugefügt). Wenn Sie eine Instanz eines QGIS Objekts eines Layers haben, können Sie diese auch als Parameter übergeben. Wenn die Eingabe optional ist und Sie kein Datenobjekt angeben wollen, verwenden Sie None.

  • Auswahl. Wenn ein Algorithmus einen Auswahl-Parameter hat, sollte der Wert dieses Parameters als Integer-Wert eingegeben werden. Um die verfügbaren Optionen zu kennen, können Sie den Befehl algoptions nutzen, wie im folgenden Beispiel gezeigt:

    >>> sextante.algoptions("saga:slopeaspectcurvature")
    METHOD(Method)
        0 - [0] Maximum Slope (Travis et al. 1975)
        1 - [1] Maximum Triangle Slope (Tarboton 1997)
        2 - [2] Least Squares Fitted Plane (Horn 1981, Costa-Cabral & Burgess 1996)
        3 - [3] Fit 2.Degree Polynom (Bauer, Rohdenburg, Bork 1985)
        4 - [4] Fit 2.Degree Polynom (Heerdegen & Beran 1982)
        5 - [5] Fit 2.Degree Polynom (Zevenbergen & Thorne 1987)
        6 - [6] Fit 3.Degree Polynom (Haralick 1983)
    

    In diesem Fall weist der Algorithmus einen Parameter mit 7 Optionen auf. Beachten Sie, dass Ordnung auf Null-basiert ist.

  • Multiple Input. Der Wert ist ein String mit Eingabebeschreibung durch Semikolon getrennt. Wie in dem Fall der einzelnen Layer oder Tabellen kann jede Eingabebeschreibung der Datenobjektname oder der Dateipfad sein.

  • Tabellenspalte von XXX. Verwenden Sie eine Zeichenfolge mit dem Namen des Feldes. Dieser Parameter reagiert auf Groß-und Kleinschreibung.

  • Feste Tabelle. Geben Sie die Liste aller Tabellenwerte durch Kommata getrennt und eingeschlossen zwischen Anführungszeichen an. Werte beginnen in der oberen Zeile und gehen von links nach rechts. Sie können auch ein 2D-Array der Wert verwenden, um die Tabelle abzubilden.

  • KBS. Geben Sie den EPSG Code des gewünschten KBS an.

  • Extent. Sie müssen einen Text mit xmin, xmax, ymin und ymax Werten, durch Kommata getrennt angeben.

Boolean, Datei, Text-und numerische Parameter benötigen keine zusätzlichen Erklärungen.

Input-Parameter wie Text booleans oder Zahlenwerte haben Standardwerte. Um sie zu verwenden, verwenden Sie None für der entsprechenden Parameter-Eintrag.

Für die Ausgabe-Datenobjekte geben Sie den Dateipfad an, der verwendet werden soll, um sie zu speichern, so wie es auch aus der Toolbox getan wird. Wenn Sie das Ergebnis in einer temporären Datei speichern möchten, verwenden Sie None. Die Erweiterung der Datei bestimmt das Dateiformat. Wenn Sie eine Datei-Erweiterung verwenden, die nicht von QGIS unterstützt wird, wird das Standard-Dateiformat für diesen Ausgang Typ verwendet werden, und die entsprechende Erweiterung an den angegebenen Dateipfad angehängt.

Anders als ein Algorithmus aus der Toolbox ausgeführt wird, werden die Ausgaben nicht ins Kartenfenster hinzugefügt, wenn Sie denselben Algorithmus in der Python-Konsole ausführen. Wenn Sie eine Ausgabe hinzufügen möchten, müssen Sie es selbst tun nachdem der Algorithmus abgeschlossen ist. Um dies zu tun, können Sie QGIS API-Befehle nutzen, oder, noch einfacher, verwenden Sie eine der Methoden, die SEXTANTE für solche Aufgaben zur Verfügung gestellt.

Die runalg()-Methode gibt ein Wörterbuch mit den Ausgabe-Namen (die in der Algorithmusbeschreibung dargestellt sind) als Schlüssel und die Dateipfade der Ausgaben als Werte. Um alle Ausgaben, die durch einen Algorithmus generiert wurden, hinzuzufügen, überführen Sie den Dictionary in die loadFromAlg()-Methode. Sie können auch einen einzelnen Layer laden, indem Sie den Dateipfad an die``load()``-Methode übergeben.

Erstellen von Skripten und diese aus der Toolbox starten

Sie können Ihre eigenen Algorithmen mit Python schreiben, indem ein paar zusätzliche Zeilen ergänzen, um zusätzliche Informationen für SEXTANTE bereitzustellen. Dafür finden Sie einen : guilabel:Neues Skript erstellen Knopf unter der Gruppe Tools im Bereich Algorithmen der Toolbox. Doppelklicken Sie darauf, um die Skriptausgabe zu öffnen. Das ist der Ort, an dem Sie Ihren Code eingeben können. Speichern Sie das Skript von dort aus in den Skriptordner (Standard ist der Ordner, wenn Sie den ‘Datei speichern’ Dialog öffnen), mit :file:` py`-Erweiterung, wird automatisch ein entsprechender Algorithmus erstellt.

Der Name des Algorithmus (den Sie in der Toolbox sehen) wird aus dem Dateinamen erstellt, wobei die Erweiterung entfernt wird und Leerzeichen durch Unterstriche ersetzt werden.

Schauen wir uns den folgenden Code an, der den Topographischen Feuchte-Index (TWI) direkt aus einem DEM berechnet

##dem=raster
##twi=output
ret_slope = sextante.runalg("saga:slopeaspectcurvature", dem, 0, None,
                None, None, None, None)
ret_area = sextante.runalg("saga:catchmentarea(mass-fluxmethod)", dem,
                0, False, False, False, False, None, None, None, None, None)
sextante.runalg("saga:topographicwetnessindex(twi), ret_slope['SLOPE'],
                ret_area['AREA'], None, 1, 0, twi)

Wie Sie sehen können, geht es um 3 Algorithmen, die alle von SAGA kommen. Der letzte von ihnen berechnet den TWI, aber es wird ein Hangneigungslayer und ein Abflussakkumulationslayer benötigt, die zwar noch nicht vorhanden sind, aber auf Basis des DEM mit SAGA Algorithmen berechnet werden können.

Der Teil des Codes, in dem diese Verarbeitung stattfindet, ist nicht schwer zu verstehen, wenn Sie die vorherigen Abschnitte in diesem Kapitel gelesen haben. Die ersten Zeilen brauchen jedoch einige zusätzliche Erklärungen. Sie bieten SEXTANTE Informationen, die notwendig sind, um Ihren Code in einen Algorithmus zu überführen, der mit einer seiner Komponenten ausgeführt werden kann, wie z.B. die Toolbox oder der grafische Modeller.

Diese Zeilen beginnen mit einem Doppel-Python Kommentar Symbol und haben die folgende Struktur:

[parameter_name]=[parameter_type] [optional_values]

Hier ist eine Liste aller Parameter-Typen, die SEXTANTE unterstützt in seinen Skripten, ihre Syntax und einige Beispiele.

  • raster. Ein Rasterlayer

  • vector. Ein Vektorlayer

  • table. Eine Tabelle

  • number. Ein numerischer Wert. Ein Standardwert muss festgelegt werden. Z.B.: depth=number 2.4

  • String. Eine Textzeichenfolge. Wie im Fall von numerischen Werten, muss ein Standardwert hinzugefügt werden. Z.B.: name=string Victor

  • boolean. Ein boolescher Wert. Füge danach Add oder False hinzu, um den Standardwert zu setzen. Z.B.: verbose=boolean True

  • multiple raster. Ein Satz von Eingabe-Rasterlayern.

  • multiple vector. Ein Satz von Eingabe-Vektorlayern.

  • Spalte. Eine Spalte in der Attributtabelle eines Vektorlayers. Der Name des Layers muss nach dem Spalte tag hinzugefügt werden. Z.B.:, wenn Sie eine Vektoreingabe mit mylayer=Vektor definiert haben, können Sie myfield=spalte mylayer verwenden, um eine Spalte aus diesem Layer als Parameter hinzuzufügen.

  • folder. Ein Ordner

  • file. Ein Dateiname

Der Parameter Name ist der Name, der dem Benutzer angezeigt wird, wenn der Algorithmus ausgeführt wird und auch der Variablenname der im Skript-verwendet wird. Der Wert, der durch den Benutzer für diesen Parameter eingegeben wird der Variablen mit diesem Namen zugeordnet.

Beim Zeigen des Namens des Parameters bearbeitet SEXTANTE es, um das Erscheinungsbild zu verbessern. Dabei werden niedrige Bindestriche mit Leerzeichen ersetzt. So, zum Beispiel, wenn Sie wollen, dass der Benutzer einen Parameter Ein numerischer Wert sieht, können Sie für den Namen der Variablen A_numerical_value verwenden.

Layer und Tabellen Werte sind Strings, die den Dateipfad des entsprechenden Objekts enthalten. Um sie zu einem QGIS Objekt zu machen, können Sie die sextante.getObjectFromUri()-Funktion nutzen. Mehrere Eingaben haben auch einen String-Wert, der die Dateipfade enthält mit allen ausgewählten Objekten, durch Semikolon getrennt.

Die Ausgaben sind in ähnlicher Weise definiert, mit den folgenden Tags:

  • output raster
  • output vector
  • output table
  • output html
  • output file
  • output number
  • output string

Der zugewiesene Wert der Ausgabevariablen ist immer eine Zeichenfolge mit einem Dateipfad. Es entspricht einem vorübergehenden Dateipfad für den Fall, dass der Benutzer keine Ausgabedatei festgelegt hat.

Wenn Sie eine Ausgabe festlegen, wird SEXTANTE versuchen, es in QGIS hinzuzufügen, sobald der Algorithmus beendet ist. Das ist der Grund, warum, obwohl die runalg() Methode die produzierten Layer nicht lädt, der endgültige TWI Layer geladen wird, da es als Datei gespeichert wird, die vom Benutzer angegeben wurde.

Verwenden Sie nicht die load()-Methode in Ihren Skripten, sondern nur, wenn Sie mit der Konsole arbeiten. Wenn ein Layer als Ausgabe eines Algorithmus erstellt wird, sollte er als solches deklariert werden. Andernfalls werden Sie nicht in der Lage sein, den Algorithmus im Modeller richtig zu verwenden, da die Syntax (wie durch die Tags definiert und weiter oben erläutert) nicht übereinstimmen mit dem, was der Algorithmus wirklich erstellt.

Versteckte Ausgaben (Zahlen und Strings) haben keinen Wert. Stattdessen müssen Sie Ihnen einen Wert zuweisen. Um dies zu tun, setzen Sie nur den Wert einer Variablen mit dem Namen, den Sie verwendet haben, um diese Ausgabe anzuzeigen. Zum Beispiel, wenn Sie diese Anzeige verwendet haben,

##average=output number

die folgende Zeile wird den Wert der Ausgabe auf 5 setzen:

average = 5

Zusätzlich zu den Tags für die Parameter-und Ausgänge können Sie auch die Gruppe definieren, unter denen der Algorithmus angezeigt werden soll, indem Sie die tag Gruppe nutzen.

Wenn Ihr Algorithmus eine lange Zeit braucht, um die Daten zu verarbeiten, ist es eine gute Idee, den Benutzer zu informieren. Sie haben dafür einen globalen Namen Fortschritt zur Verfügung, mit zwei verfügbaren Methoden: setText(text) und setPercentage(Prozent), um den Fortschritt Text und die Fortschrittsanzeige zu ändern.

Einige Beispiele sind bereits in SEXTANTE vorhanden. Bitte, schauen Sie sich diese Beispiele an, wie man Algorithmen mit SEXTANTE erstellen kann. Sie können auf jeden Skript-Algorithmus mit der rechten Maustaste klicken und dann Skript bearbeiten auswählen, um den Code zu bearbeiten oder einfach nur zu sehen.

Eigene Skripte dokumentieren

Wie im Fall von Modellen, können Sie zusätzliche Dokumentation zu Ihrem Skript erstellen, um zu erklären, was sie tun und wie man das Skript benutzt. In dem Skript-Bearbeitung Dialog finden Sie ein [Bearbeite Skript Hilfe] Knopf. Klicken Sie darauf, um einen Editierdialog zu starten. Lesen Sie das Kapitel über den grafischen Modeller, um mehr über diesen Dialog und wie er benutzt wird zu erfahren.

Hilfe-Dateien werden im selben Ordner wie das Skript selbst gespeichert, indem sie die .help Erweiterung zum Dateinamen hinzufügen. Beachten Sie, dass Sie Ihre Skripthilfe vor dem Speichern zum ersten Mal bearbeiten. Wenn Sie später den Dialog schliessen, ohne das Skript zu speichern, ist der Inhalt der Hilfe verloren. Wenn Ihr Skript bereits gespeichert wurde, und einem Dateinamen zugeordnet ist, findet die Speicherung automatisch statt.