Vous pouvez écrire un script Python pour exécuter et utiliser un service de géotraitement de plusieurs façons. La principale méthode d'exécution d'un script consiste à utiliser ArcPy. ArcPy possède des méthodes intégrées permettant de se connecter au service, de l'exécuter et d'en traiter le résultat. Vous pouvez également, à l'aide du répertoire de services, utiliser des modules Python pour effectuer des appels REST à l'aide d'une structure JSON pour transférer les résultats. Vous devrez créer un client intégralement à l'aide de code Python pour exploiter cette fonction. La majorité des scripts se connecte à des services de géotraitement et les utilise par le biais d'ArcPy.
Méthode ArcPy
Un service de géotraitement est accessible par la fenêtre Python d'ArcMap, un outil de script ou un script autonome. Une URL permet de se connecter à un service de géotraitement et de l'utiliser.
Se connecter à un service à l'aide d'ImportToolbox.
# arcpy.ImportToolbox("http://<hostname>:<port>/arcgis/services;<optional folder>/<service name>","<optional alias>")
arcpy.ImportToolbox("http://degrassi:6080/arcgis/services;GPFolder/BufferService","PointAlias")Chemin utilisé pour importer l'URL du service de géotraitement.ImportToolbox accepte deux paramètres : l'URL du service et un alias facultatif pour la boîte à outils. Le paramètre d'URL est divisé en deux parties, séparées par un point-virgule (;). La première partie est l'URL (ou lien) vers l'extrémité du service, et la seconde est le nom du service (en option, le nom du dossier précède le nom du service).
Un service de géotraitement peut s'exécuter de manière synchrone ou asynchrone. En tant que créateur de script Python, vous devez comprendre comment le service s'exécute pour pouvoir l'utiliser. La propriété IsSynchronous peut servir à déterminer le type d'exécution d'un service. Lorsqu'un service s'exécute de manière synchrone, les résultats sont retournés automatiquement, mais aucune autre action ne peut être effectuée avant la fin de son exécution. Pour les services asynchrones, l'état actuel de l'exécution doit être interrogé périodiquement. Une fois l'exécution du service terminée, le résultat est accessible.
Le code Python suivant illustre la connexion à un service de géotraitement asynchrone, et la façon dont les fonctions ArcPy l'exécutent, obtiennent le résultat et lui appliquent d'autres traitements. En définissant une variable de résultats lors de l'exécution de la tâche, il est possible de faire appel à une boucle while pour vérifier l'état. La tâche est terminée lorsqu'un code d'état de 4 (réussite) ou supérieur est renvoyé.
Utilisation d'un service de géotraitement asynchrone pour créer une zone tampon et enregistrer le résultat localement
import arcpy
import time
arcpy.ImportToolbox("http://sampleserver1.arcgisonline.com/ArcGIS/services;Elevation/ESRI_Elevation_World", "viewshedAlias")
result = arcpy.Viewshed_viewshedAlias(r'c:\data\inputPoint.shp', "10000 Kilometers")
while result.status < 4:
print result.status
time.sleep(0.2)
print "Execution Finished"
result.getMessages()
arcpy.CopyFeatures_management(result.getOutput(0), 'localResult.shp')Des informations supplémentaires concernant les codes de résultat objet et état, ainsi que la création d'une sortie raster et carte de type image, sont disponibles dans la rubrique d'aide Utilisation d'outils dans Python.
Méthode REST
Une méthode alternative (mais moins courante) d'utilisation d'un service de géotraitement consiste à créer une application qui effectue des appels REST, avec JSON comme format d'échange de données. Cette méthode implique d'écrire du code pour envoyer la requête et traiter la réponse.
L'envoi et la réception de messages REST est plus contraignant, car vous devez gérer vous-même tous les aspects de la syntaxe des entrées et des sorties. L'aspect positif de l'envoi et de la réception de messages REST est qu'ils sont renvoyés de manière cohérente. Il est possible d'effectuer les envois par le biais d'une méthode GET HTTP, et la réponse peut revenir structurée au format JSON. Les principales bibliothèques Python prennent en charge l'envoi d'une requête et de fonctions GET HTTP, ce qui simplifie la lecture et l'analyse de messages JSON.
L'exemple qui suit utilise un service sur les serveurs exemple Esri et illustre la façon de se connecter au service, d'envoyer une requête ou de traiter une réponse.
Envoi de la requête
Par exemple, SampleServer1 contient un service de géotraitement destiné à créer des champs de vision ; il est accessible à partir de http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Elevation. Ce service prend un point et une distance comme entrée et renvoie un jeu d'entités. Les entrées suivantes permettent de mieux comprendre le service :
| Nom du paramètre | Valeur en entrée |
|---|---|
Point d'observation en entrée (GPFeatureRecordSetLayer) | {"geometryType" : "esriGeometryPoint",
"spatialReference" : {"wkid" : 54003},
'features':[{'geometry':{'x': -13308192.1956127,
'y': 4221903.58555983}}]} |
Distance du champ de vision (GPLinearUnit) | { 'distance' : 8.5, 'units' : 'esriMiles' } |
Format (format de la sortie) | JSON |
Cette requête renvoie le format JSON des emplacements visibles à partir du service. L'URL complète permettant de générer la requête peut être utilisée dans la barre d'adresse d'un navigateur Web.
http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Elevation/ESRI_Elevation_World/GPServer/Viewshed/execute?Input_Observation_Point={%22features%22%3A[{%22geometry%22%3A{%22x%22%3A-13308192.1956127%2C%22y%22%3A4221903.58555983}}]}&Viewshed_Distance={+%27distance%27+%3A+8.5%2C+%27units%27+%3A+%27esriMiles%27+}&env%3AoutSR=&env%3AprocessSR=&f=pjsonIl est possible d'envoyer l'URL à l'aide du module Python urllib ou urllib2. Le code Python suivant exécute la requête ci-dessus, ce qui revient à utiliser un répertoire de service ou à copier un lien dans la barre d'adresse d'un navigateur Web.
import urllib
import json
inPts = {"geometryType" : "esriGeometryPoint",
"spatialReference" : {"wkid" : 54003},
'features':[{'geometry':{'x': -13308192.1956127,'y': 4221903.58555983}}]}
dist = {'distance':8.5,'units':'esriMiles'}
data = {'Input_Observation_Point': inPts,
'Viewshed_Distance': dist,
'f': 'pjson'}
URL = 'http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Elevation/ESRI_Elevation_World/GPServer/Viewshed/execute'
result = urllib.urlopen(URL, urllib.urlencode(data)).read()
print json.loads(result)L'objet de résultat est renvoyé sous forme de chaîne. Plusieurs méthodes peuvent être utilisées pour effectuer une requête et analyser un résultat ; l'exemple ci-dessus illustre l'une d'entre elles. Le JSON renvoyé par un service de géotraitement peut être placé dans un dictionnaire à l'aide de json.loads(), comme illustré dans l'exemple précédent. Selon la sortie de votre service de géotraitement, cette technique peut s'avérer la meilleure, ou vous pouvez avoir besoin d'expérimenter d'autres solutions pour traiter la sortie d'un service de géotraitement lorsqu'il est utilisé de Python via REST.
Remarque :
Si vous utilisez des entités de résultat, veillez à recourir aux paires x,y, utiles à votre workflow, car vous ne recevrez pas les entités dans un format prenant en charge la géométrie au sein d'ArcGIS.
Un service qui s'exécute de manière asynchrone nécessite que vous demandiez régulièrement quel est l'état de la tâche, pour savoir si elle est terminée, comme dans l'exemple ci-dessus avec ArcPy. Votre code Python peut rechercher l'expression esriJobSucceeded ou esriJobFailed dans le message d'état jobStatus renvoyé lors de la vérification de l'état de la tâche. L'exemple de code suivant présente une technique d'utilisation d'un service de géotraitement asynchrone (à l'aide de submitJob).
import urllib, json, time
inPts = {"geometryType" : "esriGeometryPoint",
"spatialReference" : {"wkid" : 54003},
'features':[{'geometry':{'x': -13308192.1956127,'y': 4221903.58555983}}]}
dist = {'distance':8.5,'units':'esriMiles'}
data = {'Input_Observation_Point': inPts,
'Viewshed_Distance': dist,
'f': 'pjson'}
taskUrl = "http://localhost:6080/arcgis/rest/services/WorldViewshed/GPServer/viewshed"
submitUrl = taskUrl + "/submitJob"
submitResponse = urllib.urlopen(submitUrl, urllib.urlencode(data))
submitJson = json.loads(submitResponse.read())
if 'jobId' in submitJson:
jobID = submitJson['jobId']
status = submitJson['jobStatus']
jobUrl = taskUrl + "/jobs/" + jobID
while status == "esriJobSubmitted" or status == "esriJobExecuting":
print "checking to see if job is completed..."
time.sleep(1)
jobResponse = urllib.urlopen(jobUrl, "f=json")
jobJson = json.loads(jobResponse.read())
if 'jobStatus' in jobJson:
status = jobJson['jobStatus']
if status == "esriJobSucceeded":
if 'results' in jobJson:
resultsUrl = jobUrl + "/results/"
resultsJson = jobJson['results']
for paramName in resultsJson.keys():
resultUrl = resultsUrl + paramName
resultResponse = urllib.urlopen(resultUrl, "f=json")
resultJson = json.loads(resultResponse.read())
print resultJson
if status == "esriJobFailed":
if 'messages' in jobJson:
print jobJson['messages']
else:
print "no jobId found in the response"Prise en main de Python, d'ArcPy et des outils de script
Si vous ne connaissez pas Python, ArcPy et les outils de script, le tableau ci-dessous contient des rubriques qui vous aideront dans votre apprentissage.
| Rubrique d'aide | Contenu |
|---|---|
Concepts de base relatifs à la création de vos propres outils de géotraitement. | |
Rubriques de présentation de Python et ArcPy. Ces rubriques vous permettent d'accéder à des rubriques plus détaillées sur Python et sur le site-package ArcPy. | |
Rubrique de présentation de la création d'outils de script personnalisés avec Python. | |
Une fois que vous vous êtes familiarisé avec le processus de création d'un outil de script, cette rubrique est souvent référencée car elle explique en détail comment définir des paramètres d'outils de script. |
Rubriques connexes
Vous avez un commentaire à formuler concernant cette rubrique ?