Ouvrir un projet et passer en revue les jeux de données

Avant de commencer à utiliser Python pour exécuter les outils de géotraitement, vous allez télécharger et examiner les jeux de données dans ArcGIS Pro.

  1. Téléchargez les données de ce didacticiel et extrayez le contenu dans un emplacement sur votre ordinateur.

    Le fichier .zip contient un dossier nommé PythonWorkflow.

    Dans ce didacticiel, les données sont présentées sur C:\Lessons\PythonWorkflow\. Vous pouvez utiliser un autre dossier, mais dans ce cas, vous devez adapter les chemins d’accès dans les instructions et le code qui suivent.

  2. Dans le dossier C:\Lessons\PythonWorkflow\, double-cliquez sur Workflow.aprx.

    Le dossier Workflow s’ouvre dans ArcGIS Pro.

  3. Si la fenêtre Catalog (Catalogue) n’est pas déjà visible, cliquez sur l’onglet View (Vue) et sur Catalog Pane (Fenêtre Catalogue).
  4. Dans la fenêtre Catalog (Catalogue), développez Folders (Dossiers), puis PythonWorkflow.
  5. Développez Transportation.gdb.

    Géodatabase Transportation (Transports) développée pour afficher les classes d’entités.

    Les classes d’entités figurant dans cette géodatabase ont trait aux transports. Supposons que vous devez construire un réseau à partir de ces classes d’entités. Pour que ce soit possible, ces classes d’entités doivent être stockées dans le même jeu de classes d’entités et posséder le même système de coordonnées. Ce n’est actuellement pas le cas.

    Dans ce didacticiel, vous allez utiliser le code Python pour vérifier le système de coordonnées des classes d’entités et utiliser l’outil Project (Projeter) pour convertir les jeux de données ne figurant pas déjà dans le système de coordonnées correct, en les copiant vers une nouvelle géodatabase et un nouveau jeu de classes d’entités. Vous pourrez ainsi créer un réseau, bien que vous ne le ferez pas dans ce didacticiel.

    Avant d’utiliser le code Python, vous allez examiner le système de coordonnées des jeux de données sélectionnés et exécuter l’outil Project (Projeter) manuellement. Vous disposez ainsi d’informations dont vous aurez besoin pour utiliser le code Python afin d’automatiser le processus.

  6. Cliquez avec le bouton droit sur bike_racks et cliquez sur Add To Current Map (Ajouter à la carte actuelle).

    Cliquez avec le bouton droit sur la classe d’entités et ajoutez-la à la carte actuelle.

  7. Procédez de la même manière pour ajouter la classe d’entités routes à la carte.

    Ces classes d’entités représentent les supports de stationnement de vélo et les routes à Washington, D.C.

    Vous allez ensuite examiner les systèmes de coordonnées des deux classes d’entités.

  8. Dans la fenêtre Contents (Contenu), cliquez avec le bouton droit sur Map (Carte) et choisissez Properties (Propriétés).

    Ouvrez la fenêtre Properties (Propriétés) de la carte.

  9. Dans la fenêtre Map Properties: Map (Propriétés de la carte : Carte), cliquez sur Coordinate Systems (Systèmes de coordonnées).

    Cliquez sur Coordinate Systems (Systèmes de coordonnées).

  10. Développez Layers (Couches), ainsi que les entités des systèmes de coordonnées WGS 1984 et NAD 1983 StatePlane Maryland FIPS 1900 (US Feet).

    Développez les entrées des deux systèmes de coordonnées.

    La classe d’entités bike_racks se trouve dans un système de coordonnées géographiques nommé WGS 1984, tandis que les classes d’entités de routes et de limites se trouvent dans le système de coordonnées projetées State Plane du Maryland, NAD 1983 StatePlane Maryland FIPS 1900 (US Feet).

    Votre objectif est de placer toutes les classes d’entités dans un jeu de données avec le système de coordonnées projetées.

  11. Cliquez sur OK pour fermer la fenêtre Map Properties (Propriétés de la carte).

    Vous avez examiné la géodatabase et identifié les deux systèmes de coordonnées utilisés par les classes d’entités. Vous allez maintenant projeter l’un des classes d’entités.

Projeter une classe d’entités

Vous allez maintenant projeter l’une des classes d’entités et examiner les paramètres requis pour cet outil.

  1. Sur le ruban, cliquez sur Analysis (Analyse), puis, dans la section Geoprocessing (Géotraitement), cliquez sur Tools (Outils).

    Cliquez sur Analysis (Analyse) et, dans la section Geoprocessing (Géotraitement), cliquez sur Tools (Outils).

    La fenêtre Geoprocessing (Géotraitement) s’affiche.

  2. Dans la fenêtre Geoprocessing (Géotraitement), cliquez dans la zone de recherche et saisissez Project (Projeter).
  3. Dans les résultats de recherche, cliquez sur Project (Data Management Tools) (Projeter (outils de gestion de données)).
  4. Dans la fenêtre de l’outil Project (Projeter), pour le paramètre Input Dataset or Feature Class (Jeu de données ou classe d’entités en entrée), choisissez bike_racks.
  5. Pour le nom Output Dataset or Feature Class (Jeu de données ou classe d’entités en sortie), cliquez sur le bouton de navigation et accédez à la géodatabase Transportation (Transports). Développez la géodatabase et, dans le champ Name (Nom), saisissez bike_racks_sp. Cliquez sur Save (Enregistrer).
  6. Dans la section Output Coordinate System (Système de coordonnées en sortie), cliquez sur la flèche de la liste déroulante, puis sur roads (routes).

    Outil Projeter avec les paramètres définis.

    Choisir roads (routes) définit la valeur de Output Coordinate System (Système de coordonnées en sortie) sur le système de coordonnées de la classe d’entités de routes, le système de coordonnées Plan d’État du Maryland.

    Le paramètre Geographic Transformation (Transformation géographique) est défini sur WGS_1984_(ITRF00) To_NAD_1983 car les systèmes de coordonnées géographiques de l’entrée et de la sortie sont différents.

    Remarque :

    Une transformation géographique est nécessaire lorsque les systèmes de coordonnées de la classe d’entités en entrée et de la classe d’entités en sortie sont différents. Lorsque les systèmes de coordonnées géographiques sont identiques, aucune liste de valeur n’apparaît pour ce paramètre. Lorsqu’une transformation est nécessaire, une liste déroulante apparaît, en fonction des systèmes de coordonnées géographiques en entrée et en sortie, et une transformation par défaut est sélectionnée. Vous utiliserez cette transformation par défaut dans ce didacticiel.

  7. Cliquez sur Run (Exécuter).

    L’outil Project (Projeter) s’exécute et la classe d’entités projetée est ajoutée à la carte active.

    Pour préparer les données à utiliser dans un réseau, il vous faudrait répéter ce processus pour chaque classe d’entités dans la géodatabase : vérifiez le système de coordonnées et voyez s’il est nécessaire ou non d’exécuter l’outil Project (Projeter). Projetez la classe d’entités qui doit l’être. Copiez les autres classes d’entités sans les projeter.

    Au lieu de répéter ces étapes manuellement, vous allez utiliser le code Python pour automatiser le processus.

  8. Fermez l’outil Project (Projeter).
  9. Dans la fenêtre Catalog (Catalogue), cliquez avec le bouton droit sur la classe d’entités, puis cliquez sur la classe d’entités bike_racks_sp, sur Delete (Supprimer) et sur Yes (Oui) pour supprimer définitivement la classe d’entités.

    Vous êtes maintenant prêt à démarrer le processus à l’aide du code Python.

Utiliser Python pour décrire une classe d’entités

La première étape du processus consiste à examiner le système de coordonnées des classes d’entités. Pour cela, vous utiliserez le code Python dans la fenêtre Python.

  1. Sur le ruban, cliquez sur Analysis (Analyse), puis, dans la section Geoprocessing (Géotraitement), cliquez sur la flèche du menu déroulant sur le bouton Python, puis cliquez sur Python Window (Fenêtre Python).

    Ouvrez la fenêtre Python.

  2. Cliquez sur la section d’invite située au bas de la fenêtre Python, saisissez le code suivant, puis appuyez sur Entrée :

    desc = arcpy.da.Describe("bike_racks")

    Ajoutez du code pour décrire la classe d’entités bike_racks.

    Lorsque vous appuyez sur Entrée, le code s’exécute immédiatement. Il n’imprime aucune information, mais il crée une variable nommée desc qu’il définit comme étant égale au résultat de l’exécution de la fonction Describe (Décrire) sur la classe d’entités bike_racks.

    La fonction Describe (Décrire) renvoie un dictionnaire avec les propriétés du jeu de données. Ce dictionnaire vous permet d’accéder à la référence spatiale, entre autres propriétés.

  3. Dans la section d’invite, ajoutez le code suivant et appuyez sur Entrée.

    sr = desc["spatialReference"]

    La nouvelle variable nommée sr est alors définie sur la valeur stockée à la clé SpatialReference du dictionnaire des propriétés de jeu de données. L’objet SpatialReference contient toutes les informations pertinentes relatives au système de coordonnées du jeu de données. Vous pouvez ainsi vérifier des propriétés spécifiques.

  4. Dans la section d’invite, ajoutez le code suivant et appuyez sur Entrée.

    print(sr.name)

    Le nom de l’objet de référence spatiale est alors imprimé.

    Imprimez le nom de l’objet de référence spatiale.

    Vérifier de cette manière le système de coordonnées pour chaque classe d’entités tour à tour étant un peu fastidieux, vous allez utiliser une fonction de liste pour établir une liste, puis traiter toutes les classes d’entités.

Établir une liste de classes d’entités et les décrire

Vous pouvez accélérer le processus de vérification des systèmes de coordonnées des classes d’entités en établissant une liste de ces classes d’entités, puis en utilisant une structure de boucle dans Python pour traiter la liste et décrire chaque classe d’entités.

  1. Dans la section d’invite, ajoutez le code suivant et appuyez sur Entrée.

    fcs = arcpy.ListFeatureClasses()

    Une variable nommée fcs est alors créée et est définie comme étant égale au résultat de l’exécution de la fonction ListFeatureClasses sur l’espace de travail actuel. Bien que vous n’ayez pas défini l’espace de travail explicitement, Transportation.gdb est l’espace de travail par défaut de ce projet. La fonction renvoie une liste des classes d’entités dans Transportation.gdb.

  2. Dans la section d’invite, ajoutez le code suivant et appuyez sur Entrée.

    print(fcs)

    Le résultat consiste en une liste Python de noms de classes d’entités. La liste est entourée de crochets et les noms de classes d’entités sont des chaînes Python, séparées par des virgules.

    ['bus_lines', 'boundary', 'street_lights', 'roads', 'traffic_analysis_zones', 'bike_routes', 'bike_racks', 'parking_zones', 'intersections', 'station_entrances']

    Vous allez ensuite utiliser une boucle for pour traiter chaque élément de la liste.

  3. Dans la section d’invite, ajoutez le code suivant :

    for fc in fcs:
        desc = arcpy.da.Describe(fc)
        sr = desc["spatialReference"]
        print(f"{fc}: {sr.name}")

    Boucle pour traiter la liste de classes d’entités

    La première ligne décrit une boucle for. Elle crée une variable temporaire nommée fc, qui se verra attribuer le nom de chaque classe d’entités dans la liste fcs. La ligne se termine par un deux-points afin d’indiquer que le contenu qui suit est le bloc de code allant s’exécuter pour chaque élément de la liste. Les trois lignes suivantes sont décalées de quatre espaces pour indiquer qu’elles appartiennent au bloc de code. La première ligne du bloc de code crée une variable nommée desc et la définit comme étant égale au résultat de l’exécution de la fonction Describe sur la valeur de classe d’entités actuelle stockée dans la variable fc. La deuxième ligne crée la variable sr et la définit sur l’objet spatialReference stocké dans desc. La troisième ligne imprime une chaîne formatée qui contient le nom de la classe d’entités, un deux-points et le nom de la référence spatiale.

    Le code de ce bloc répète le processus précédent pour obtenir le nom de la référence spatiale de la classe d’entités bike_racks, mais il le fait sur une variable définie sur chacun des éléments de la liste, et donc traite et communique les résultats pour l’ensemble des classes d’entités.

  4. Appuyez deux fois sur Entrée pour exécuter la boucle for et son bloc de code.

    Signalez la référence spatiale de chaque classe d’entités figurant dans la liste.

    La moitié des classes d’entités se trouvent dans un système de coordonnées, et l’autre moitié dans l’autre système de coordonnées.

    L’étape suivante consiste à écrire du code pour créer une géodatabase et à utiliser les outils Project (Projeter) et Copy Features (Copier les entités) pour intégrer les classes d’entités dans le même jeu de données avec un système de coordonnées projetées commun. Vous allez exporter le travail effectué jusqu’à présent et l’utiliser comme base d’un script.

Créer un script

Vous allez ensuite continuer à écrire le code pour automatiser ce processus en tant que script. Vous pouvez tester le code dans la fenêtre Python mais il est généralement préférable d’écrire les scripts plus longs dans un éditeur Python. Vous allez exporter le code dont vous disposez et continuer à travailler dessus dans IDLE, l’éditeur Python par défaut.

  1. Cliquez avec le bouton droit sur la section de transcription de la fenêtre Python et cliquez sur Save Transcript (Enregistrer la transcription).

    Cliquez avec le bouton droit sur la fenêtre Python et enregistrez la transcription.

  2. Dans la fenêtre Save Transcript (Enregistrer la transcription), accédez au dossier PythonWorkflow dans lequel vous avez extrait les données, nommez la transcription workflow_project.py, puis cliquez sur Save.

    La transcription est alors enregistrée en tant que script Python pouvant être ouvert dans un éditeur Python.

  3. Démarrez Microsoft File Explorer et accédez au dossier PythonWorkflow.
  4. Cliquez avec le bouton droit sur workflow_project.py, puis cliquez sur Edit with IDLE (ArcGIS Pro) (Mettre à jour avec IDLE (ArcGIS Pro)).

    Cliquez avec le bouton droit sur le script workflow_project.py, puis cliquez sur Edit with IDLE (ArcGIS Pro) (Mettre à jour avec IDLE (ArcGIS Pro)).

    Remarque :
    Si ArcGIS Desktop 10.x (ArcMap) est installé, le menu contextuel comporte également le raccourci Edit with IDLE (Mettre à jour avec IDLE). N’utilisez pas ce raccourci car il n’ouvre pas la version correcte de Python.

    Remarque :
    Si Edit with IDLE (ArcGIS Pro) (Mettre à jour avec IDLE (ArcGIS Pro)) n’est pas visible dans le menu contextuel, cliquez sur Start (Démarrer), développez ArcGIS, puis cliquez sur Python Command Prompt (Invite de commande Python). Dans la fenêtre Python Command Prompt (Invite de commande Python), saisissez idle et appuyez sur Entrée. La fenêtre IDLE (Python 3.9 Shell) apparaît. Cliquez sur File (Fichier) et sur Open (Ouvrir). Accédez au fichier workflow_project.py et ouvrez-le.

    Le script s’ouvre dans IDLE, l’éditeur par défaut de Python. Le script comprend tout le code de la section de transcription de la fenêtre Python, y compris les messages imprimés, qui apparaissent en tant que commentaires avec le caractère de hachage en début de ligne.

    La transcription s’ouvre dans l’éditeur IDLE de Python.

  5. Dans la fenêtre de l’éditeur IDLE, supprimez tout le code situé avant la ligne fcs = arcpy.ListFeatureClasses().
  6. Supprimez toutes les lignes de commentaires.
  7. Supprimez la ligne print(fcs).

    Le code restant est le suivant :

    fcs = arcpy.ListFeatureClasses()
    for fc in fcs:
        desc = arcpy.da.Describe(fc)
        sr = desc["spatialReference"]
        print(f"{fc}: {sr.name}")

    Vous allez ensuite ajouter des lignes pour importer deux bibliothèques, définir des variables et définir l’espace de travail.

  8. Ajoutez une nouvelle ligne avant la ligne fcs = arcpy.ListFeatureClasses() et ajoutez les lignes suivantes au début du script.

    import arcpy
    import os

    La première ligne de code importe le paquetage ArcPy pour garantir que les fonctionnalités d’ArcPy sont disponibles dans le script lorsqu’il est exécuté en dehors d’ArcGIS Pro. La deuxième ligne importe le module os, utilisé pour gérer les chemins d’accès aux fichiers.

  9. Ajoutez une nouvelle ligne après les deux premières lignes et ajoutez les lignes de code suivantes :
    mypath = "C:/Lessons/PythonWorkflow"
    gdb = "Transportation.gdb"
    arcpy.env.workspace = os.path.join(mypath, gdb)

    La première ligne spécifie l’emplacement des données. Si vous avez extrait le dossier PythonWorkflow dans un autre emplacement, vous devez modifier cette ligne afin qu’elle indique le chemin d’accès sur votre ordinateur. Cette valeur est attribuée à une variable nommée mypath. Cette variable sera utilisée pour définir l’espace de travail, ainsi que pour d’autres tâches, telles que la création d’une géodatabase fichier.

    Une barre oblique unique (/) est utilisée dans le chemin au lieu d’une barre oblique inverse unique (\). Une barre oblique inverse unique dans Python est utilisée comme caractère d’échappement et peut avoir des conséquences imprévisibles. Au lieu d’une barre oblique, vous pouvez également utiliser la lettre r (pour raw, c’est-à-dire brut) avant la chaîne (par exemple, r"C:\Lessons\PythonWorkflow") ou utiliser des barres obliques inverses doubles (par exemple, "C:\\Lessons\\PythonWorkflow"). Les trois notations sont considérées comme correctes et peuvent être utilisées indifféremment.

    La ligne suivante définit la variable gdb sur le nom de la géodatabase dans laquelle les classes d’entités d’intérêt sont stockées.

    La dernière ligne définit l’espace de travail en combinant le dossier dans lequel les données résident (mypath) et le nom de la géodatabase (gdb). La fonction os.path.join() est utilisée pour combiner ces deux chaînes en une nouvelle chaîne du chemin d’accès pour l’espace de travail. Il est recommandé d’utiliser os.path.join() pour effectuer cela car des chaînes de chemin d’accès robustes sont créées sans utiliser des barres obliques inverses uniques (\). Ces chaînes sont interprétées par Python en tant que caractères d’échappement et peuvent générer des erreurs.

    Le script complet créé jusqu’à présent est le suivant :

    import arcpy
    import os
    mypath = "C:/Lessons/PythonWorkflow"
    gdb = "Transportation.gdb"
    arcpy.env.workspace = os.path.join(mypath, gdb)
    fcs = arcpy.ListFeatureClasses()
    for fc in fcs:
        desc = arcpy.da.Describe(fc)
        sr = desc["spatialReference"]
        print(f"{fc}: {sr.name}")

    Script au premier point de test

    Vous pouvez à présent tester votre script pour vérifier qu’il fonctionne.

  10. Cliquez sur File (Fichier), puis sur Save (Enregistrer).

    Les modifications que vous avez apportées au script sont alors enregistrées. Vous pouvez également utiliser le raccourci clavier Ctrl+S dans IDLE pour enregistrer votre travail.

  11. Cliquez sur Run (Exécuter), puis sur Run Module (Exécuter le module).

    Run Module (Exécuter le module) pour exécuter le code de script

    Cela exécute le script. Vous pouvez également utiliser le raccourci clavier F5 pour exécuter le script.

    La fenêtre IDLE Shell s’affiche et, après une brève pause pendant laquelle le module ArcPy est importé, les noms des classes d’entités et des références spatiales sont imprimés.

    Résultats du premier test, noms imprimés des classes d’entités et des références spatiales

    Pour compléter le script afin d’automatiser ce processus, vous devez ajouter les fonctionnalités suivantes : 1) créer une géodatabase ; 2) créer un jeu de classes d’entités ; 3) copier les classes d’entités déjà projetées et 4) projeter les classes d’entités figurant dans un système de coordonnées géographiques. Vous allez écrire du code pour chaque élément, tester le code, puis continuer avec l’élément suivant.

Utiliser du code pour créer une géodatabase

L’étape suivante consiste à ajouter du code à votre script afin de créer une géodatabase. Comme vous aurez peut-être besoin de tester le script plusieurs fois, vous devrez être en mesure de remplacer les données précédemment créées. À cette fin, vous allez ajouter un paramètre d’environnement au script.

  1. Après la ligne commençant par arcpy.env.workspace, ajoutez une ligne et le code suivant :

    arcpy.env.overwriteOutput = True

    Vous allez ensuite créer des variables pour stocker le nom de la nouvelle géodatabase et celui du nouveau jeu de classes d’entités.

  2. Après la ligne gdb = "Transportation.gdb", ajoutez une ligne et le code suivant :

    new_gdb = "Metro_Transport.gdb"
    fds = "Metro_Network"

    Utiliser des variables vous évite de répéter les noms dans le reste du script. Votre code est ainsi plus réutilisable. Si vous souhaitez utiliser un nom différent pour la géodatabase ou le jeu de données, il vous suffit de modifier le nom à un endroit dans le script.

    Ajoutez ensuite du code pour créer la géodatabase.

  3. Après la ligne commençant par arcpy.env.overwriteOutput, ajoutez le code suivant :

    new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)

    Cette ligne appelle l’outil Créer une géodatabase fichier. Dans les parenthèses, indiquez que le premier paramètre requis, l’emplacement de la nouvelle géodatabase, est défini sur la variable mypath, qui contient la valeur de chemin d’accès que vous avez définie. Après une virgule, indiquez l’autre paramètre requis de l’outil, le nom de la géodatabase fichier. La variable new_gdb contient le nom de la nouvelle géodatabase.

    La ligne a également attribué les résultats de la création de la géodatabase à une variable. La variable new_gdb_path contient le chemin d’accès et le nom de la nouvelle géodatabase. Il est ainsi plus facile de se référer à cette nouvelle géodatabase dans le script.

    Avant de tester le script, vous allez commenter du code n’ayant pas besoin d’être testé.

  4. Sélectionnez toutes les lignes de code après la ligne new_gdb_path.

    Sélectionnez les lignes n’ayant pas besoin d’être testées.

  5. Cliquez sur Format (Format) puis sur Comment Out Region (Commenter la région).

    Commentez des lignes.

    Deux caractères de hachage sont alors ajoutés au début de chacune des lignes de code sélectionnées. Python interprétant les lignes commençant par un caractère de hachage en tant que commentaires, ces lignes ne sont pas exécutées. Vous pouvez supprimer ces lignes, mais une partie du code est réutilisée. En commentant ces lignes, vous pouvez conserver le code du script afin de le réutiliser plus tard tout en l’empêchant de s’exécuter.

    Certaines lignes sont commentées.

    Le code créé jusqu’à présent est le suivant :

    import arcpy
    import os
    mypath = "C:/Lessons/PythonWorkflow"
    gdb = "Transportation.gdb"
    new_gdb = "Metro_Transport.gdb"
    fds = "Metro_Network"
    arcpy.env.workspace = os.path.join(mypath, gdb)
    arcpy.env.overwriteOutput = True
    new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
    ##fcs = arcpy.ListFeatureClasses()
    ##for fc in fcs:
    ##    desc = arcpy.da.Describe(fc)
    ##    sr = desc["spatialReference"]
    ##    print(f"{fc}: {sr.name}")

  6. Enregistrez et exécutez le script.

    La fenêtre IDLE Shell réapparaît et, au bout de quelques instants, l’invite en entrée, >>> s’affiche de nouveau. Le code ne possédant actuellement aucune ligne opérationnelle imprimant des informations dans le shell, il est difficile de savoir s’il a fonctionné. Vous allez vérifier cela dans ArcGIS Pro.

  7. Dans ArcGIS Pro, dans la fenêtre Catalog (Catalogue), dans la section Folders (Dossiers), cliquez avec le bouton droit sur le dossier PythonWorkflow, puis cliquez sur Refresh (Actualiser).

    Actualisez le dossier PythonWorkflow dans la fenêtre Catalog (Catalogue).

  8. Développez le dossier PythonWorkflow.

    La nouvelle géodatabase se trouve dans le dossier.

    La nouvelle géodatabase se trouve dans le dossier. Il est actuellement vide.

  9. Cliquez avec le bouton droit sur Metro_Transport.gdb, puis cliquez sur Delete (Supprimer) et Yes (Oui) pour supprimer définitivement la géodatabase.

    Pour tester un script, il est souvent utile de supprimer les sorties afin de déterminer plus facilement si le script fonctionne ou non.

    Un autre indicateur permettant de savoir si un script fonctionne consiste à ajouter des messages déclarant ce qui s’est produit. Vous pouvez ajouter des instructions print à votre code pour surveiller plus facilement les événements qui se produisent.

  10. Dans la fenêtre de l’éditeur IDLE, après la ligne commençant par new_gdb_path = arcpy.CreateFileGDB, ajoutez une nouvelle ligne et le code suivant :

    print(f"The geodatabase {new_gdb} has been created.")

    Ajoutez une ligne pour imprimer une chaîne formatée indiquant que la géodatabase a été créée.

    Cette instruction d’impression imprime une chaîne formatée qui contient la valeur de la variable new_gdb. Les instructions d’impression ne sont pas nécessaires à l’exécution du script, mais elles vous permettent de surveiller les actions du script. Elles peuvent également être très utiles pour corriger les erreurs se produisant dans les scripts longs. Vous pouvez ajouter plusieurs instructions d’impression indiquant le statut dans le script à différents endroits, et lorsque vous voyez chaque message, vous savez que le script s’est exécuté jusqu’à cet endroit. Vous pouvez également utiliser des chaînes formatées pour imprimer les valeurs des variables dans votre script, ce qui peut être très utile pour corriger les erreurs.

  11. Enregistrez le script.

Utiliser du code pour créer un jeu de classes d’entités

Vous allez ensuite créer le jeu de classes d’entités dans la nouvelle géodatabase. L’une des propriétés qui définissent un jeu de classes d’entités est que toutes les classes d’entités figurant dans le jeu de classes d’entités partagent le même système de coordonnées.

Vous allez utiliser le système de coordonnées State Plane Maryland (Plan d’État du Maryland) pour ce jeu de données. Il est possible d’utiliser le nom du système de coordonnées lors de la définition du système de coordonnées dans Python, mais il est plus simple d’utiliser un code court, appelé WKID, ou identifiant bien connu.

  1. Dans ArcGIS Pro, dans la fenêtre Contents (Contenu), cliquez avec le bouton droit sur la couche roads (routes), puis cliquez sur Properties (Propriétés).
  2. Dans la fenêtre Layer Properties (Propriétés de la couche), cliquez sur l’onglet Source (Source).

    Cliquez sur l’onglet Source (Source) de la fenêtre Layer Properties (Propriétés de la couche).

  3. Cliquez sur Data Source (Source de données) pour réduire la section Data Source (Source de données).

    Réduisez la section Data Source (Source de données).

  4. Cliquez sur la section Spatial Reference (Référence spatiale) pour la développer.

    Cliquez sur Spatial Reference (Référence spatiale) pour développer la section Spatial Reference (Référence spatiale).

    Le code WKID de ce système de coordonnées est 2248.

    Le code WKID est 2248.

  5. Cliquez sur Cancel (Annuler) pour fermer la fenêtre Layer Properties (Propriétés de la couche).

    Vous allez maintenant utiliser ce code WKID pour définir la référence spatiale du jeu de classes d’entités.

  6. Dans IDLE, après la ligne commençant par print(f"The geodatabase, ajoutez les lignes de code suivantes :

    arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
    print(f"The feature dataset {fds} has been created.")

    Des lignes permettant de créer le jeu de classes d’entités et d’en imprimer un rapport ont été ajoutées.

    La première ligne exécute l’outil Create Feature Dataset (Créer un jeu de classes d’entités) et lui attribue trois paramètres requis. Le premier paramètre indique l’emplacement de la géodatabase dans laquelle le jeu de classes d’entités est créé, le second indique le nom du jeu de classes d’entités et le troisième indique le WKID du système de coordonnées du jeu de données. La variable new_gdb_path comprend le chemin d’accès complet à la base de données. Le nom du jeu de classes d’entités était précédemment attribué à la variable fds.

    Une autre manière de définir le système de coordonnées consiste à spécifier le chemin d’accès à une classe d’entités existante (par exemple, en spécifiant le chemin d’accès à la classe d’entités roads (routes) dans la géodatabase Transportation.gdb).

    La deuxième ligne imprime une chaîne formatée pour indiquer que le nouveau jeu de données a été créé.

    Le code complet est le suivant :

    import arcpy
    import os
    mypath = "C:/Lessons/PythonWorkflow"
    gdb = "Transportation.gdb"
    new_gdb = "Metro_Transport.gdb"
    fds = "Metro_Network"
    arcpy.env.workspace = os.path.join(mypath, gdb)
    arcpy.env.overwriteOutput = True
    new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
    print(f"The geodatabase {new_gdb} has been created.")
    arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
    print(f"The feature dataset {fds} has been created.")
    ##fcs = arcpy.ListFeatureClasses()
    ##for fc in fcs:
    ##    desc = arcpy.da.Describe(fc)
    ##    sr = desc["spatialReference"]
    ##    print(f"{fc}: {sr.name}")

  7. Enregistrez et exécutez le code.

    Le code s’exécute et, au bout de quelques instants, les deux messages d’état sont imprimés dans le shell IDLE.

    Le code s’exécute et l’état est mis à jour.

  8. Dans ArcGIS Pro, dans la fenêtre Catalog (Catalogue), cliquez avec le bouton droit sur le dossier PythonWorkflow, puis cliquez sur Refresh (Actualiser).

    La géodatabase Metro_Transport a été créée.

  9. Développez la géodatabase Metro_Transport.

    Le jeu de classes d’entités Metro_Network a été créé.

  10. Supprimez la géodatabase Metro_Transport.

Utiliser du code pour copier des classes d’entités de manière conditionnelle

Vous allez ensuite utiliser une partie du code précédemment commenté pour répertorier les classes d’entités figurant dans la géodatabase Transportation.gdb. Vous allez y ajouter une logique pour vérifier si le WKID de référence spatiale de chaque classe d’entités est 2248, ainsi que du code pour copier la classe d’entités dans la nouvelle géodatabase lorsque cette condition est vraie.

  1. Dans IDLE, sélectionnez les lignes de code que vous avez précédemment commentées.
  2. Cliquez sur Format (Format), puis sur Uncomment Region (Supprimer les marques de commentaire de la région).

    Supprimez les marques de commentaire du code.

    Supprimer les marques de commentaire du code a pour effet de supprimer les caractères de hachage situés avant chaque ligne, si bien que le code est exécuté au lieu d’être interprété en tant que commentaire.

    Le code dont vous avez supprimé les marques de commentaire établit une liste des classes d’entités figurant dans l’espace de travail actuel, puis utilise la description de chacun des éléments de la liste pour extraire la référence spatiale. À présent, au lieu d’imprimer ces informations, vous allez ajouter du code pour vérifier la valeur de la référence spatiale et copier la classe d’entités ou la projeter.

    Les outils Copy Features (Copier des entités) et Project (Projeter) extraient une classe d’entités en entrée et produisent une classe d’entités en sortie. Les noms des classes d’entités peuvent rester inchangés, mais les chemins d’accès aux sorties sont différents car les nouvelles classes d’entités se trouvent dans la nouvelle géodatabase.

    Les classes d’entités en entrée sont représentées par la variable fc. Les valeurs de fc sont les noms de classes d’entités dérivés d’une liste de classes d’entités dans l’espace de travail actuel.

    Par exemple, le chemin d’accès complet à l’une des classes d’entités en entrée est : C:\Lessons\PythonWorkflow\Transportation.gdb\roads

    L’espace de travail étant défini, les noms de classes d’entités, tels que roads, peuvent être directement utilisés dans des outils. Le chemin d’accès complet n’est pas requis dans le cas de classes d’entités figurant dans l’espace de travail actuel. C’est pourquoi desc = arcpy.da.Describe(fc) ou desc = arcpy.da.Describe("roads") fonctionne.

    Toutefois, vous devez attribuer aux paramètres de la classe d’entités en sortie le chemin d’accès complet aux nouvelles classes d’entités dans le nouvel espace de travail. Ce chemin d’accès peut être défini avec os.path.join(), tout comme précédemment dans le script, où l’environnement a été défini.

  3. Sélectionnez la ligne de code qui commence par print(f"{fc}: et remplacez-la par la ligne de code suivante :

    new_fc = os.path.join(mypath, new_gdb, fds, fc)

    Cette ligne doit se trouver au même niveau d’indentation, dans le bloc de code de la boucle for fc in fcs:.

    Sur cette ligne, la nouvelle variable, new_fc, est définie sur le chemin d’accès créé en regroupant le dossier qui contient les données (mypath), la nouvelle géodatabase (new_gdb) et la nouvelle classe d’entités (fds). La dernière partie du chemin d’accès est constituée du nom de la nouvelle classe d’entités, identique au nom de la classe d’entités en entrée (la valeur de la variable fc). Cette partie du chemin d’accès change avec chaque itération de la boucle sur la liste de classes d’entités.

    Une fois que le chemin d’accès complet aux classes d’entités en sortie a été créé, vous pouvez ajouter du code pour choisir entre copier ou projeter chaque classe d’entités en fonction du système de coordonnées. Dans Python, vous pouvez tester différentes conditions avec des instructions if et exécuter différents blocs de code selon qu’une condition de l’instruction est vraie ou non.

  4. Après la ligne new_fc = os.path.join, au même niveau d’indentation (dans la boucle for), ajoutez la ligne de code suivante :

    if sr.factoryCode == 2248:

    Ce code vérifie si le WKID de la classe d’entités, stocké dans l’objet sr en tant que valeur factoryCode de l’objet, correspond au WKID 2248 du système de coordonnées State Plane Maryland (Plan d’État du Maryland).

    Il utilise une instruction if et une expression et se termine par un deux-points pour indiquer qu’un bloc de code vient ensuite et s’exécute si l’instruction est vraie.

    L’instruction utilise un signe d’égalité double. Dans Python, un signe d’égalité unique est utilisé pour définir une variable sur une valeur et un signe d’égalité double est utilisé pour rechercher l’égalité.

  5. Cliquez sur la fin de cette ligne de code et appuyez sur Entrée.

    La ligne de code suivante est alors indentée correctement, à quatre espaces par rapport à la ligne d’instruction if. Il s’agit du début d’un nouveau bloc de code, qui n’est exécuté que si sr.factoryCode est égal à la valeur 2248.

    Une fois que le chemin d’accès complet aux classes d’entités en sortie a été créé et que le test du système de coordonnées a réussi, vous pouvez ajouter du code pour copier la classe d’entités.

  6. Sur la ligne nouvellement indentée, ajoutez les lignes de code suivantes :

    arcpy.CopyFeatures_management(fc, new_fc)
            print(f"The feature class {fc} has been copied.")

    La première ligne exécute l’outil Copy Features (Copier des entités) et copie la classe d’entités actuelle dans la nouvelle géodatabase.

    La deuxième ligne imprime une chaîne formatée pour indiquer que le nouveau jeu de données a été créé.

    Le code complet est le suivant :

    import arcpy
    import os
    mypath = "C:/Lessons/PythonWorkflow"
    gdb = "Transportation.gdb"
    new_gdb = "Metro_Transport.gdb"
    fds = "Metro_Network"
    arcpy.env.workspace = os.path.join(mypath, gdb)
    arcpy.env.overwriteOutput = True
    new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
    print(f"The geodatabase {new_gdb} has been created.")
    arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
    print(f"The feature dataset {fds} has been created.")
    fcs = arcpy.ListFeatureClasses()
    for fc in fcs:
        desc = arcpy.da.Describe(fc)
        sr = desc["spatialReference"]
        new_fc = os.path.join(mypath, new_gdb, fds, fc)
        if sr.factoryCode == 2248:
            arcpy.CopyFeatures_management(fc, new_fc)
            print(f"The feature class {fc} has been copied.")

    La logique de copie de la classe d’entités entre les géodatabases si le WKID est 2248 est ajoutée au script.

  7. Enregistrez et exécutez le code.

    Les classes d’entités correspondantes sont copiées.

    Le code s’exécute. Il crée la géodatabase et le jeu de classes d’entités et copie les cinq couches qui figuraient dans le système de coordonnées State Plane Maryland (Plan d’État du Maryland).

  8. Dans ArcGIS Pro, dans la fenêtre Catalog (Catalogue), actualisez le dossier PythonWorkflow.
  9. Actualisez la géodatabase Metro_Transport et développez-la.
  10. Actualisez le jeu de classes d’entités Metro_Network et développez-le.

    Les cinq classes d’entités sont copiées dans la nouvelle géodatabase.

    La géodatabse et le jeu de données contiennent les classes d’entités qui correspondent au système de coordonnées du jeu de données.

Ajouter du code pour projeter des classes d’entités de manière conditionnelle

L’étape finale pour terminer le script consiste à ajouter une logique pour utiliser l’outil Project (Projeter) afin de projeter les classes d’entités ne figurant pas dans le système de coordonnées State Plane Maryland (Plan d’État du Maryland) et d’écrire les résultats dans le jeu de classes d’entités de la nouvelle géodatabase.

  1. Dans IDLE, cliquez à la fin de la ligne de code commençant par print(f"The feature class et appuyez sur Entrée.
  2. Appuyez sur la touche Retour Arrière pour réduire l’indentation d’un niveau.

    Vous allez ajouter une instruction else, qui doit se trouver au même niveau d’indentation que l’instruction if précédente.

    Une instruction else est utilisée pour exécuter un bloc de code différent lorsque l’instruction if est fausse.

  3. Sur la nouvelle ligne moins indentée, ajoutez les lignes de code suivantes :

    else:
            arcpy.Project_management(fc, new_fc, 2248)
            print(f"The feature class {fc} has been projected.")

    L’instruction if et les instructions else se trouvent au même niveau d’indentation.

    L’instruction else crée une branche logique avec un bloc de code exécuté une fois l’instruction if vérifiée pour les scénarios où elle n’est pas vraie. Selon cette logique, si le WKID est 2248, la classe d’entités doit être copiée et, dans le cas contraire, elle doit être projetée.

    La deuxième de ces lignes est indentée de quatre espaces car elle appartient au bloc de code qui s’exécute dans la condition else. L’outil Project (Projeter) projette la classe d’entités en entrée sur le système de coordonnées State Plane Maryland (Plan d’État du Maryland) et la classe d’entités en sortie est stockée dans la nouvelle géodatabase. Les paramètres de l’outil Project (Projeter) sont la classe d’entités en entrée, la classe d’entités en sortie et le système de coordonnées en sortie (le WKID 2248 est utilisé pour ce paramètre).

    Remarque :
    L’outil Project (Projeter) comporte un quatrième paramètre, qui est une transformation facultative. Lorsque vous avez exécuté l’outil Project (Projeter) précédemment, vous avez constaté qu’une transformation était nécessaire entre le système de coordonnées géographiques NAD 1983 et le système de coordonnées géographiques WGS 1984, mais que par défaut la transformation appropriée était sélectionnée lorsque l’outil était exécuté. Cela signifie qu’il n’est pas nécessaire de spécifier une transformation dans le code ici.

    Selon les résultats antérieurs de la vérification du système de coordonnées de toutes les classes d’entités, vous savez que les classes d’entités ne figurant pas déjà dans le système de coordonnées State Plane Maryland (Plan d’État du Maryland) se trouvent dans un système de coordonnées géographiques spécifique. Cependant, il n’est pas nécessaire de spécifier ce système de coordonnées spécifique. Avec une instruction else, l’outil Project (Projeter) est exécuté pour toutes les classes d’entités où l’instruction if est fausse, quel que soit le système de coordonnées spécifique.

    Le code complet est le suivant :

    import arcpy
    import os
    mypath = "C:/Lessons/PythonWorkflow"
    gdb = "Transportation.gdb"
    new_gdb = "Metro_Transport.gdb"
    fds = "Metro_Network"
    arcpy.env.workspace = os.path.join(mypath, gdb)
    arcpy.env.overwriteOutput = True
    new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
    print(f"The geodatabase {new_gdb} has been created.")
    arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
    print(f"The feature dataset {fds} has been created.")
    fcs = arcpy.ListFeatureClasses()
    for fc in fcs:
        desc = arcpy.da.Describe(fc)
        sr = desc["spatialReference"]
        new_fc = os.path.join(mypath, new_gdb, fds, fc)
        if sr.factoryCode == 2248:
            arcpy.CopyFeatures_management(fc, new_fc)
            print(f"The feature class {fc} has been copied.")
        else:
            arcpy.Project_management(fc, new_fc, 2248)
            print(f"The feature class {fc} has been projected.")

    Code complet du script

  4. Enregistrez et exécutez le script.

    Le code s’exécute. Il crée la géodatabase et le jeu de classes d’entités, copie les cinq couches qui figuraient dans le système de coordonnées State Plane Maryland (Plan d’État du Maryland) et projette les cinq couches qui figuraient dans le système de coordonnées WGS84.

    Résultats de l’exécution du code final

  5. Dans ArcGIS Pro, dans la fenêtre Catalog (Catalogue), actualisez le jeu de classes d’entités Metro_Network.

    Ce jeu de données contient toutes les classes d’entités, dans le système de coordonnées correct.

    Géodatabase finale avec toutes les classes d’entités

    Votre code fonctionne et, à ce stade, vous êtes en mesure de créer le réseau géométrique.

Ajouter des commentaires au script

Même s’il s’agit d’un script relativement simple, il est recommandé d’inclure des commentaires dans votre code afin de faciliter la compréhension du script. Des commentaires peuvent être utilisés pour expliquer l’objectif du script et identifier les étapes clés. Les autres utilisateurs pourront ainsi comprendre et modifier votre script pour leurs propres besoins plus facilement. Vous pourrez par ailleurs comprendre le code plus facilement, si vous le laissez de côté un certain temps et devez ensuite y revenir pour le modifier.

Les commentaires commencent par un ou plusieurs caractères de hachage. Les commentaires peuvent commencer au début d’une ligne de code ou être ajoutés à la fin.

  1. Dans IDLE, ajoutez une nouvelle ligne au début du script.
  2. Copiez et collez les commentaires suivants sur la nouvelle ligne :

    # Author: your name
    # Date: the date
    # Purpose: This script reads all the feature classes in a
    # geodatabase and copies them to a new feature dataset in
    # a new geodatabase. Feature classes not already in the
    # target coordinate system are projected.

  3. Modifiez les lignes Author et Date pour inclure votre nom et la date du jour.
  4. Avant la ligne import arcpy, ajoutez deux nouvelles lignes et, sur la seconde ligne, ajoutez le commentaire suivant :

    # Imports

    La ligne vierge n’affecte pas le code et le rend plus compréhensible. Le commentaire indique que cette section importe les bibliothèques nécessaires au code. Les importations sont généralement regroupées au début du script.

  5. Ajoutez deux nouvelles lignes après la ligne import os, puis ajoutez le commentaire suivant :

    # Variables for paths, outputs, workspaces

    Ce commentaire indique à quel emplacement ces variables sont d’abord définies.

  6. Ajoutez deux nouvelles lignes après la ligne arcpy.env.overwriteOutput = True, puis ajoutez le commentaire suivant :

    # Create a new geodatabase and dataset

  7. Ajoutez deux nouvelles lignes avant la ligne fcs = arcpy.ListFeatureClasses(), puis ajoutez le commentaire suivant :

    # Create a list of feature classes in the workspace

  8. Après la ligne if sr.factoryCode == 2248:, ajoutez le commentaire suivant sur la même ligne :

     # WKID of target coordinate system

    Vous avez ajouté deux commentaires qui expliquent le code.

    Le code complet est le suivant :

    # Author: your name
    # Date: the date
    # Purpose: This script reads all the feature classes in a
    # geodatabase and copies them to a new feature dataset in
    # a new geodatabase. Feature classes not already in the
    # target coordinate system are projected.
    
    # Imports
    import arcpy
    import os
    
    # Variables for paths, outputs, workspaces
    mypath = "C:/Lessons/PythonWorkflow"
    gdb = "Transportation.gdb"
    new_gdb = "Metro_Transport.gdb"
    fds = "Metro_Network"
    arcpy.env.workspace = os.path.join(mypath, gdb)
    arcpy.env.overwriteOutput = True
    
    # Create a new geodatabase and dataset
    new_gdb_path = arcpy.CreateFileGDB_management(mypath, new_gdb)
    print(f"The geodatabase {new_gdb} has been created.")
    arcpy.CreateFeatureDataset_management(new_gdb_path, fds, 2248)
    print(f"The feature dataset {fds} has been created.")
    
    # Create a list of feature classes in the workspace
    fcs = arcpy.ListFeatureClasses()
    for fc in fcs:
        desc = arcpy.da.Describe(fc)
        sr = desc["spatialReference"]
        new_fc = os.path.join(mypath, new_gdb, fds, fc)
        if sr.factoryCode == 2248: # WKID of target coordinate system
            arcpy.CopyFeatures_management(fc, new_fc)
            print(f"The feature class {fc} has been copied.")
        else:
            arcpy.Project_management(fc, new_fc, 2248)
            print(f"The feature class {fc} has been projected.")

    Script final avec commentaires

  9. Enregistrez le script.

Dans ce didacticiel, vous avez appris ce qui suit :

  • Les scripts Python permettent d’automatiser les tâches répétitives dans des processus SIG.
  • ArcPy comporte plusieurs fonctions pour créer des listes de jeux de données.
  • En répertoriant et décrivant les jeux de données avec du code Python, vous pouvez créer un inventaire détaillé des jeux de données SIG dans un espace de travail. Vous pouvez ensuite traiter chaque jeu de données différemment selon ses caractéristiques.
  • Les chemins d’accès et les noms de fichiers doivent être traités avec précaution pour garantir des sorties correctes.

Les documentations Script Python pour ArcGIS Pro et Script Python avancé pour ArcGIS Pro par le Dr Paul A. Zandbergen, publiées par Esri Press, peuvent vous intéresser également.