Verwenden von Werkzeugen in Python

Alle Geoverarbeitungswerkzeuge verfügen über einen festen Satz von Parametern, über die das Werkzeug die Informationen erhält, die für seine Ausführung erforderlich sind. Werkzeuge enthalten i. d. R. Eingabeparameter, die die Datasets definieren, mit denen die neuen Ausgabedaten erzeugt werden. Parameter weisen mehrere wichtige Eigenschaften auf:

Name	Jedem Werkzeugparameter ist ein eindeutiger Name zugewiesen.
Typ	Der Typ der erwarteten Daten, z. B. "Feature-Class", "Ganzzahl", "Zeichenfolge" oder "Raster".
Richtung	Der Parameter definiert Eingabe- oder Ausgabewerte.
Erforderlich	Entweder muss ein Wert für einen Parameter eingegeben werden, oder der Parameter ist optional.

Wenn ein Werkzeug in einem Skript verwendet wird, müssen die Parameterwerte korrekt festgelegt werden, damit das Werkzeug mit dem Skript ausgeführt werden kann. In der Dokumentation zu den einzelnen Werkzeugen sind die Parameter und Eigenschaften klar definiert. Sobald gültige Parameterwerte bereitgestellt wurden, kann das Werkzeug ausgeführt werden.

Parameter werden als Zeichenfolge oder Objekt angegeben. Zeichenfolgen bestehen einfach aus Text, mit dem ein Parameterwert eindeutig bestimmt wird, z. B. ein Pfad zu einem Dataset oder ein Schlüsselwort.

Die meisten Werkzeugparameter können als einfache Zeichenfolge angegeben werden. Für einige Parameter, z. B. einen Raumbezug, können Sie ein Objekt statt einer Zeichenfolge verwenden. Im folgenden Codebeispiel wurden Eingabe- und Ausgabeparameter für das Werkzeug Puffer angegeben. Beachten Sie, dass der Werkzeugname immer mit seinem Toolbox-Aliasnamen angehängt wird. Die Eingabe- und Ausgabeparameter wurden mit zwei Zeichenfolgenvariablen definiert, damit der Aufruf des Werkzeugs leichter lesbar ist.

import arcpy

roads = "c:/St_Johns/data.gdb/roads"
output = "c:/St_Johns/data.gdb/roads_Buffer"

# Run Buffer using the variables set above and pass the remaining parameters
#   in as strings
#
arcpy.Buffer_analysis(roads, output, "distance", "FULL", "ROUND", "NONE")

Im folgenden Codebeispiel wird das Werkzeug CreateFeatureClass mit einem Raumbezugsobjekt für den optionalen Parameter für das Koordinatensystem ausgeführt. Das Raumbezugsobjekt wird mit der Methode SpatialReference-Klasse erstellt und die Informationen werden aus einer Projektionsdatei geladen.

import arcpy

inputWorkspace = "c:/temp"
outputName =  "rivers.shp"

# Create a spatial reference object
#
spatialRef = arcpy.SpatialReference()

# Use a projection file to define the spatial reference's properties
#
spatialRef.createFromFile("c:/program files/arcgis/Desktop10.0/Coordinate Systems/" + \
                          "Projected Coordinate Systems/Continental/North America/North America Equidistant Conic.prj")

# Run CreateFeatureclass using the spatial reference object
#
arcpy.CreateFeatureclass_management(inputWorkspace, outputName, 
                                    "POLYLINE", "", "", "", spatialRef)

Werkzeugorganisation

Geoverarbeitungswerkzeuge werden auf zwei verschiedene Arten organisiert. Alle Werkzeuge sind als Funktionen auf ArcPy verfügbar, aber auch in Modulen, die dem Toolbox-Aliasnamen entsprechen. Obwohl die meisten der Beispiele in der Hilfe Werkzeuge als in ArcPy verfügbare Funktionen zeigen, sind beide Ansätze gültig. Welche Vorgehensweise Sie verwenden, hängt von den persönlichen Vorlieben und Codierungsgewohnheiten ab. Im folgenden Beispiel wird das Werkzeug GetCount auf beide Arten gezeigt.

import arcpy

inFeatures = "c:/temp/rivers.shp"

# Tools can be accessed as functions on the arcpy module, and
#  from modules matching the toolbox name.
#
arcpy.GetCount_management(inFeatures)
arcpy.management.GetCount(inFeatures)

Wenn Sie Werkzeuge in Modulen verwenden, möchten Sie unter Umständen darauf aufmerksam machen, wie ein Modul identifiziert wird, um das Skript besser lesbar zu machen. In diesem Fall können Sie die Form from - import - as verwenden.

# Clean up street centerlines that were digitized without having set
#  proper snapping environments
#
import arcpy
from arcpy import edit as EDIT
from arcpy import management as DM

streets = "c:/data/streets.gdb/majorrds"
streetsCopy = "c:/output/Output.gdb/streetsBackup"

DM.CopyFeatures(streets, streetsBackup)
EDIT.TrimLine(streets, "10 Feet", "KEEP_SHORT")
EDIT.ExtendLine(streets, "15 Feet", "EXTENSION")

Lizenz:

Spatial Analyst-Werkzeuge werden anders behandelt, um Map-Algebra unterzubringen, und sind nur im arcpy.sa-Modul verfügbar und nicht als Funktionen für ArcPy.

Abrufen von Ergebnissen von einem Werkzeug

ArcPy gibt bei der Ausführung eines Werkzeugs dessen Ausgabewerte als Ergebnisobjekt zurück. Der Vorteil eines Ergebnisobjekts besteht darin, dass Informationen über die Werkzeugausführung, einschließlich der Meldungen, Parameter und der Ausgabe, verwaltet werden können. Die Ergebnisse bleiben erhalten, selbst wenn zwischenzeitlich mehrere andere Werkzeuge ausgeführt werden.

Die folgenden Beispiele zeigen, wie Sie nach der Ausführung eines Geoverarbeitungswerkzeugs die Ausgabe aus dem Ergebnisobjekt abrufen können.

import arcpy

arcpy.env.workspace = "D:/St_Johns/data.gdb"

# Geoprocessing tools return a result object of the derived 
#   output dataset. 
#
result = arcpy.CopyFeatures_management("roads", "urban_roads")

# A print statement will display the string 
#   representation of the output.
#
print result 

# To get the output value, the result object has a getOutput method
#
resultValue = result.getOutput(0)

 

Hinweis:

Die getOutput-Methode des Ergebnisobjekts gibt eine Unicode-Zeichenfolge von Ergebnisobjekten zurück, die über Ausgabewerte verfügen. Dies ist wichtig bei Werkzeugen wie GetCount, das die Anzahl von Datensätzen in einer Tabelle zurückgibt, und Werkzeugen wie CalculateDefaultClusterTolerance, das einen Cluster-Toleranzwert bereitstellt. Um den Wert in den erwarteten Typ zu konvertieren, muss die Unicode-Zeichenfolge mit integrierten Python-Funktionen wie int() oder float() umgewandelt werden.

import arcpy
from arcpy import env
import types

env.workspace = "c:/St_Johns/data.gdb"

# Many geoprocessing tools return a result object of the derived 
#   output dataset. A print statement will display the string 
#   representation of the output.
#
result = arcpy.GetCount_management("roads")
resultValue = result.getOutput(0)

# The result object's getOutput method returns values as a 
#   unicode string.  To convert to a different Python type, use 
#   built-in Python functions: str(), int(), long(), float()
#
count = int(resultValue)
print count
print types.TypeType(count) 

Ergebniseigenschaften und Methoden

Eigenschaften und Methoden	Erklärung
inputCount	Gibt die Anzahl der Eingaben zurück.
outputCount	Gibt die Anzahl der Ausgaben zurück.
messageCount	Gibt die Anzahl der Meldungen zurück.
maxSeverity	Gibt die maximale Gewichtung zurück. Mögliche Werte für die zurückgegebene Gewichtung sind 0 (keine Fehler/Warnungen ausgelöst), 1 (Warnungen ausgelöst) und 2 (Fehler ausgelöst).
resultID	Gibt die eindeutige Ergebnis-ID zurück. Wenn es sich bei dem Werkzeug nicht um einen Geoverarbeitungs-Service handelt, ist resultID gleich "".
Status	Gibt den Status des Auftrags auf dem Server zurück. 0 – Neu 1 – Übergeben 2 – Wartet 3 – Wird ausgeführt 4 – Erfolgreich 5 – Fehlgeschlagen 6 – Zeitlimit überschritten 7 – Wird abgebrochen 8 – Abgebrochen 9 – Wird gelöscht 10 – Gelöscht
cancel()	Bricht den Auftrag auf dem Server ab.
getInput(index)	Gibt eine bestimmte Eingabe zurück. Bei einem Datensatz- oder einem Raster-Daten-Objekt wird ein RecordSet- bzw. RasterData-Objekt zurückgegeben.
getMapImageURL(ParameterList, Height, Width, Resolution)	Ruft für eine bestimmte Ausgabe das Karten-Service-Image ab.
getMessage(index)	Gibt eine bestimmte Meldung zurück.
getMessages(severity)	Der Typ der zurückzugebenden Meldungen. 0 (Meldung), 1 (Warnung), 2 (Fehler). Wenn Sie keinen Wert angeben, werden alle Meldungstypen zurückgegeben.
getOutput(index)	Gibt eine bestimmte Ausgabe zurück. Bei einem Datensatz- oder einem Raster-Daten-Objekt wird ein RecordSet- bzw. RasterData-Objekt zurückgegeben.
getSeverity(index)	Gibt die Gewichtung einer bestimmten Meldung zurück.

Ergebniseigenschaften und Methoden

Abrufen von Ergebnissen von einem Serverwerkzeug

Wie andere Geoverarbeitungswerkzeuge auch verfügen Serverwerkzeuge für die Geoverarbeitung über eine festgelegte Anzahl von Parametern, über die das Werkzeug die für seine Ausführung erforderlichen Informationen erhält. Bei der Verwendung von asynchronen Serverwerkzeugen in einem Skript kann die Ausgabe von der getOutput-Methode des Ergebnisses abgerufen werden.

Tipp:

Die Funktion IsSynchronous kann verwendet werden, um zu bestimmen, ob ein Werkzeug synchron oder asynchron ausgeführt wird. Wenn ein Werkzeug synchron ist, werden die Ergebnisse automatisch zurückgegeben, aber es kann keine andere Aktion durchgeführt werden, bis das Werkzeug abgeschlossen wurde.

Im folgenden Beispiel wird mit der Funktion GetParameterValue ein FeatureSet-Objekt aus einem Serverwerkzeug abgerufen. Das FeatureSet-Objekt enthält das Schema für den Eingabeparameter des Werkzeugs. Anschließend wird eine Feature-Class in das FeatureSet-Objekt geladen und das Serverwerkzeug auf dem Server ausgeführt. Am Ende ruft das Skript mit der Methode getOutput des Ergebnisobjekts die Werkzeugausgabe ab, die dann mit der Methode "Save" des FeatureSet-Objekts lokal gespeichert wird.

import arcpy
import time

# Add a toolbox from a server
#
arcpy.ImportToolbox("http://flame7/arcgis/services;GP/BufferByVal", "mytools")

# Use GetParameterValue to get a featureset object with the default 
#   schema of the first parameter of the tool 'bufferpoints'
#
inFeatureSet = arcpy.GetParameterValue("bufferpoints", 0)

# Load a shapefile into the featureset
#
inFeatureSet.load("c:/base/roads.shp")

# Run a server tool named BufferPoints with featureset created above
#
result = arcpy.BufferPoints_mytools(inFeatureSet, "5 feet")

# Check the status of the result object every 0.2 seconds until it has a value 
#    of 4 (succeeded) or greater
#
while result.status < 4:
    time.sleep(0.2)

# Get the output FeatureSet back from the server and save to a local geodatabase
#
outFeatSet = result.getOutput(0)
outFeatSet.save("c:/temp/base.gdb/towers_buffer")

Abrufen von Raster-Ergebnissen von einem Serverwerkzeug

Raster-Ergebnisse werden im TIFF-Format (Tagged Image File Format) zurückgegeben. Bei Verwendung der Methode getOutput wird die TIFF-Datei normalerweise im TEMP-Ordner des Systems abgelegt. Wenn Sie einen anderen Speicherort für die TIFF-Datei festlegen möchten, legen Sie die Umgebungseinstellung für scratchWorkspace auf einen Ordner fest.

import arcpy 
import time

# Set the scratchworkspace to a folder.
#
arcpy.env.scratchWorkspace = "c:/temp/rasteroutput"

# Add a toolbox from a server
#
arcpy.ImportToolbox("http://flame7/arcgis/services;SlopeByVal", "mytools")

dem = "c:/dems/k_ne_g"

# Run a server tool named RunSlope
#
result = arcpy.RunSlope_mytools(dem)

# Check the status of the result object every 0.2 seconds until it has a value 
#    of 4 (succeeded) or greater
#
while result.status < 4:
    print result.status
    time.sleep(0.2)

# Raster output will be written to the scratchworkspace    
#
outTIFF = result.getOutput(0)

Abrufen eines Kartenbildes

Geoverarbeitungs-Services können mit einem Karten-Service des Ergebnisses ein digitales Kartenbild von Task-Ergebnissen erstellen. Digitale Karten enthalten visuelle Darstellungen geographischer Datasets, die Informationen vermitteln. Digitale Karten werden im Internet als Bilder (z. B. JPEG-Dateien) übermittelt. Ein aus einzelnen Bytes zusammengesetztes Kartenbild enthält weitaus mehr durch den Benutzer auswertbare Informationen als unbearbeitete Features in einer Feature-Class. Kartenbilder sind außerdem bequem zu handhaben: Sie lassen sich einfach komprimieren, sie können in verwaltbare Einheiten aufgeteilt werden, und es gibt bewährte Methoden, um sie über das Internet zu übertragen und anzuzeigen.

Kartenbilder werden von einem ArcGIS Server-Karten-Service erstellt und durch das Veröffentlichen eines ArcMap-Dokuments (.mxd) erzeugt. Aufgrund der Eigenschaften von Kartenbildern sollten Sie ein Kartenbild für die Ergebnisse des Geoverarbeitungs-Tasks erstellen und dann das Kartenbild über das Internet übertragen, statt ein oder mehrere Ergebnis-Datasets zu übertragen. Geoverarbeitungs-Services können über einen Karten-Service des Ergebnisses verfügen, der von ArcGIS Server zum Erstellen von Kartenbildern der Ausgabedaten verwendet wird.

import arcpy
import time
import urllib

# Add a toolbox from a server
#
arcpy.ImportToolbox("http://flame7/arcgis/services;GP/BufferByVal", "mytools")

# Use GetParameterValue to get a featureset object with the default schema of the 
#   first parameter of the tool 'bufferpoints'
#
inFeatureSet = arcpy.GetParameterValue("bufferpoints", 0)

# Load a shapefile into the featureset
#
inFeatureSet.load("c:/base/roads.shp")

# Run a server tool named BufferPoints with featureset created above
#
result = arcpy.BufferPoints_mytools(inFeatureSet, "5 feet")

# Check the status of the result object every 0.2 seconds until it has a value 
#    of 4 (succeeded) or greater
#
while result.status < 4:
    time.sleep(0.2)
    print result.status

# Return a map service
#
mapimage = result.getMapImageURL(0)

# Use Python's urllib module's urlretrieve method to copy the image locally
#
urllib.urlretrieve(mapimage, "c:/base/road_buffer.jpg")