Présentation rapide d'ArcPy
ArcPy est un site-package qui repose sur le module arcgisscripting éprouvé (et lui succède). Son but est de créer le fondement d'une méthode pratique et productive permettant d'effectuer l'analyse, la conversion et la gestion de données géographiques ainsi que de procéder à l'automatisation de cartes avec Python.
ArcPy fournit l'accès à des outils de géotraitement ainsi qu'à des fonctions, des classes et des modules supplémentaires qui vous permettent de créer rapidement et facilement des workflow simples ou complexes.
Les applications et scripts ArcGIS écrits à l'aide d'ArcPy bénéficient de la capacité d'accès et d'utilisation des nombreux modules Python développés par des professionnels du SIG et des programmeurs issus de nombreuses disciplines différentes. En outre, l'utilisation d'ArcPy dans Python offre plusieurs avantages étant donné que Python est un langage de programmation destiné à un usage général, facile à maîtriser et à utiliser. Il est saisi et interprété de manière dynamique, ce qui permet d'ébaucher et de tester rapidement des scripts dans un environnement interactif, tout en restant assez puissant pour prendre en charge l'écriture d'applications importantes.
ArcPy fournit l'accès à des outils de géotraitement ainsi qu'à des fonctions, des classes et des modules supplémentaires qui vous permettent de créer des workflows simples ou complexes. D'une façon générale, ArcPy est organisé en différents outils, fonctions, classes et modules.
Techniquement parlant, les outils de géotraitement sont disponibles dans arcpy, c'est-à-dire qu'ils sont accessibles comme n'importe quelle autre fonction Python. Toutefois, pour éviter toute confusion, une distinction est toujours faite entre les fonctions de type outil et les autres fonctions (telles que les fonctions de type utilitaire comme ListFeatureClasses()).
- Les outils sont documentés différemment des fonctions. Chaque outil possède sa propre page de référence de l'outil dans le système d'aide d'ArcGIS Desktop. Les fonctions sont expliquées dans la documentation ArcPy.
- Les outils renvoient un objet result, ce qui n'est pas le cas des fonctions.
- Les outils génèrent des messages, accessibles par le biais de différentes fonctions, telles que GetMessages(). Les fonctions ne génèrent pas de messages.
- Les outils sont concédés sous licence par niveau de produit (ArcView, ArcEditor ou ArcInfo) et par extension (Network Analyst, Spatial Analyst et ainsi de suite). La page de référence de l'outil vous indique les niveaux de licence requis. Les fonctions ne sont pas concédées sous licences ; elles sont installées avec ArcPy.
Attention :Exécution d'un outil
L'exemple suivant indique comment exécuter l'outil Zone tampon. Lorsque l'outil s'exécute, les messages apparaissent par défaut sur le côté droit de la fenêtre Python dans la section d'aide.
>>> arcpy.Buffer_analysis("c:/data/Portland.gdb/streets", "c:/data/Portland.gdb/steets_buffer", "500 METERS")
Voici un autre exemple d'exécution des outils. Cet exemple fait appel aux outils des boîtes à outils Data Management et Conversion. Un champ est ajouté à la classe d'entités Streets en entrée, le champ est calculé et la classe d'entités est ensuite chargée dans une géodatabase ArcSDE Enterprise.
>>> import arcpy
>>> arcpy.AddField_management("c:/data/Portland.gdb/streets", "LENGTH_MILES", "TEXT")
>>> arcpy.CalculateField_management("c:/data/Portland.gdb/streets", "LENGTH_MILES", "!shape.length@miles!", "PYTHON_9.3")
>>> arcpy.FeatureClassToFeatureClass_conversion("c:/data/Portland.gdb/streets", "Database Connections/MySDE.sde/PortlandDataset", "streets")
Obtention de résultats à partir d'un outil
Lorsqu'un outil de géotraitement est exécuté, le résultat de l'outil est renvoyé dans un objet result. Généralement, il s'agit du chemin d'accès au jeu de données en sortie créé ou mis à jour par l'outil. Dans d'autres cas, il peut contenir d'autres types de valeurs tels qu'un nombre ou une valeur booléenne. Si la sortie d'un outil est un paramètre à valeurs multiples, les valeurs peuvent être renvoyées sous forme de liste au sein d'une liste.
Les exemples de code suivants montrent comment les valeurs renvoyées sont capturées et les valeurs qu'elles peuvent afficher :
Renvoyez le chemin d'accès de la classe d'entités en sortie. Le résultat peut être utilisé comme entrée d'une autre fonction.
>>> result = arcpy.Buffer_analysis("rivers", "riverBuf", "50 METERS")
>>> print result
C:\Portland\Portland_OR.gdb\riverBuf
>>> arcpy.Clip_analysis("streets", result, "streets_50m_of_rivers")
Renvoyez le nombre d'entités.
>>> result = arcpy.GetCount_management("streets_50m_of_rivers")
>>> print result.getOutput(0)
54
Renvoyez une liste d'index spatiaux par défaut pour une classe d'entités.
>>> result = arcpy.CalculateDefaultGridIndex_management("streets_50m_of_rivers")
>>> for i in range(0, result.outputCount):
... print result.getOutput(i)
...
560
200
0
Utilisation des paramètres d'environnement
Les paramètres d'environnement de géotraitement peuvent être considérés comme des paramètres supplémentaires qui affectent les résultats d'un outil. Ils diffèrent des paramètres d'outils normaux dans la mesure où ils sont définis séparément de l'outil et qu'ils sont interrogés et utilisés par des outils lors de leur exécution. Les paramètres d'environnement, tels qu'une zone d'intérêt, le système de coordonnées du jeu de données en sortie et la taille de cellule d'un nouveau jeu de données raster, peuvent tous être définis à l'aide des outils et pris en compte par ces derniers.
Les paramètres d'environnement sont disponibles dans la classe env en tant que propriétés. Ces propriétés peuvent servir à extraire les valeurs d'environnement actuelles et à les définir. Voici des exemples d'utilisation des valeurs d'environnement :
Définissez l'environnement de l'espace de travail.
>>> arcpy.env.workspace = "c:/data/Portland.gdb"
>>> arcpy.Buffer_analysis("streets", "streetBuf", "500 METERS")
Définissez la valeur d'index spatial selon la valeur renvoyée d'un outil.
>>> arcpy.env.spatialGrid1 = arcpy.CalculateDefaultSpatialGridIndex_management("streets").getOutput(0)
Obtenez le paramètre de taille de cellule raster courant pour vérifier qu'il s'agit d'une taille spécifique pour une sortie standard.
if arcpy.env.cellSize != 30:
arcpy.env.cellSize = 30
Utilisation des fonctions
Une fonction est un élément de fonctionnalité défini qui réalise une tâche spécifique et peut être intégré dans un programme plus important. En plus des outils, ArcPy présente plusieurs fonctions permettant une meilleure prise en charge des workflows de géotraitement. Les fonctions peuvent servir à répertorier certains jeux de données, à extraire les propriétés d'un jeu de données, à vérifier l'existence de données, à valider un nom de table avant de l'ajouter à une géodatabase ou à effectuer de nombreuses autres tâches de script utiles.
L'exemple de code suivant montre comment obtenir les propriétés des données et extraire une extension :
import arcpy
# prints True
print arcpy.Exists("c:/data/Portland.gdb/streets")
# prints NAD_1983_StatePlane_Oregon_North_FIPS_3601_Feet
sr = arcpy.Describe("c:/data/Portland.gdb/streets").spatialReference
print sr.name
# prints Available
print arcpy.CheckExtension("spatial")
arcpy.CheckOutExtension("spatial")
Utilisation des classes
Les classes ArcPy, telles que les classes SpatialReference et Extent, sont souvent utilisées comme raccourcis vers des paramètres d'outil de géotraitement complets qui présenteraient autrement un équivalent de chaîne plus compliqué. Une classe est analogue à un plan architectural. Le plan fournit la structure pour une création. Les classes permettent de créer des objets, souvent désignés par le terme instance.
import arcpy prjFile = "c:/projections/North America Equidistant Conic.prj" spatialRef = arcpy.SpatialReference(prjFile)
Utilisation des modules
ArcPy inclut des modules qui couvrent d'autres domaines d'ArcGIS. ArcPy est pris en charge par toute une série de modules et notamment un module de cartographie (arcpy.mapping), un module Spatial Analyst (arcpy.sa) et un module Geostatistical Analyst (arcpy.ga).
Par exemple, les outils du module arcpy.sa font appel aux outils de la boîte à outils Spatial Analyst, mais sont configurés pour prendre en charge l'algèbre spatiale. Par conséquent, exécuter arcpy.sa.Slope revient au même qu'exécuter l'outil Pente de la boîte à outils Spatial Analyst.