Suite

Utilisation d'arcpy et de script toolbox pour ajouter la date à une table attributaire

Utilisation d'arcpy et de script toolbox pour ajouter la date à une table attributaire


Je voudrais des informations sur la façon d'ajouter une date à une table attributaire, en ajoutant une date spécifiée par l'utilisateur dans un outil de script qui mettra à jour la table attributaire des polygones. Bref j'ai deux polygones dont je souhaite calculer la différence de temps, en heures entre eux. La date est déterminée par la spécification à l'intérieur d'une boîte de script, visible dans l'image ci-dessous.

J'aimerais utiliser du code qui va avec mon outil et j'ai besoin de comprendre ce qui me manque dans le code suivant ; (Ceci est le code simple de l'outil)

import arcpy Mother1 = sys.argv[1] date1= sys.argv[2] ### Je crois que le style de date est au format mm/dd/yyyy hh:mm:ss Mother2 = sys.argv[3] date2 = sys. argv[4] essayez: arcpy.AddField_management(Mother1,"Date","DATE","#","#","#","#","NULLABLE","NON_REQUIRED","#") arcpy. AddField_management(Mother2,"Date","DATE","#","#","#","#","NULLABLE","NON_REQUIRED","#")

Ensuite, j'ai essayé d'ajouter la date au champ comme celui-ci;

arcpy.CalculateField_management(Mère1, "Date", date1) arcpy.CalculateField_management(Mère2, "Date", date2)

Mais ça n'a pas marché.

Je voudrais ajouter la date à la table attributaire et ensuite pouvoir également calculer la différence entre les deux dates, mais dois-je entrer la date dans la table attributaire avant de pouvoir calculer quoi que ce soit ?


Je ne supposerais pas que c'est un rendez-vous. Je m'assurerais que la date et l'heure sont capturées sous forme de chaîne et créerais une expression python à l'aide de la fonction strptime et utiliserais un calcul PYTHON_9.3 pour que la date et l'heure entières soient calculées. Les expressions de date VB doivent être au format #date#, mais elles ne sont pas fiables, car elles ne conservent que la date, pas l'heure, et vous ne pouvez pas contrôler la façon dont elles interprètent les différents formats de date de chaîne, comme vous le pouvez avec la fonction strptime en utilisant un calcul de champ PYTHON_9.3. (Edit : j'ai ajusté l'emplacement du bloc d'essai pour m'assurer que toute erreur de conversion de date est gérée dans le bloc except et j'ai ajouté une logique pour déterminer si le champ Date doit être ajouté ou s'il existe déjà). Le code révisé formate désormais l'expression de la fonction strptime en tant que chaîne qui permet au calculateur de champ d'effectuer la conversion de date à l'aide de la fonction strptime, et non du script :

import arcpy from datetime import datetime try: Mother1 = arcpy.GetParameterAsText(0) print arcpy.GetParameterAsText(1) ### Confirmez à partir de print que la chaîne de date est au format aaaa-mm-jj hh:mm:ss ### Make une expression de calcul de champ qui utilisera strptime pour obtenir une date/heure. date1 = "datetime.datetime.strptime('" + arcpy.GetParameterAsText(1) + "', '%Y-%m-%d %H:%M:%S')" ### Les calculs VB Script utilisent " #date#" chaînes pour créer des dates, mais pas datetime ### date1 = '#' + arcpy.GetParameterAsText(1) + '#' Mother2 = arcpy.GetParameterAsText(2) date2 = "datetime.datetime.strptime('" + arcpy.GetParameterAsText(3) + "', '%Y-%m-%d %H:%M:%S')" ### Les calculs VB Script utilisent les chaînes "#date#" pour créer des dates, mais pas datetime ### date2 = '#' + arcpy.GetParameterAsText(3) + '#' fields = arcpy.ListFields(Mother1) addfield = True pour le champ dans les champs : if field.name.upper() == "DATE": addfield = False si addfield : arcpy.AddField_management(Mother1,"Date","DATE","#","#","#","#","NULLABLE","NON_REQUIRED","#") champs = arcpy.ListFields(Mother2) addfield = True pour le champ dans les champs : if field.name.upper() == "DATE": addfield = False si addfield : arcpy.AddField_management(Mother2,"Date","DATE","# ","#","#","#","NULLABLE","NON_REQUIRED","#") arcpy.CalculateField_management(Mother1, "Date", date1, "PYTHON_9.3") arcpy.CalculateField_management(Mother2, "Date", date2, "PYTHON_9.3") sauf Exception as e: print e.message # Si vous utilisez ce code dans un outil de script, AddError peut être utilisé pour renvoyer des messages # vers un outil de script. Sinon, AddError n'aura aucun effet. arcpy.AddError(e.message)

Avertir:

Cet outil modifie les données d'entrée. Voir Outils sans sortie pour plus d'informations et de stratégies pour éviter les modifications de données indésirables.

Si les champs POINT_X , POINT_Y , POINT_Z et POINT_M existent, leurs valeurs sont recalculées.

Les valeurs des champs POINT_X et POINT_Y en sortie sont basées sur le système de coordonnées du jeu de données, et non sur le système de coordonnées de l'affichage de la carte. Pour forcer les valeurs POINT_X et POINT_Y à se trouver dans un système de coordonnées différent du jeu de données en entrée, définissez l'environnement Système de coordonnées en sortie.

Si des points sont déplacés après avoir utilisé Ajouter des coordonnées XY , leurs valeurs POINT_X et POINT_Y et les valeurs POINT_Z et POINT_M (si présentes) doivent être recalculées en exécutant à nouveau Ajouter des coordonnées XY.

L'outil Projet ne modifie pas les valeurs des champs POINT_X , POINT_Y , POINT_Z ou POINT_M .

Si les entités en entrée se trouvent dans un système de coordonnées géographiques , POINT_X et POINT_Y représentent respectivement la longitude et la latitude.


Objet schéma

Chaque paramètre en sortie de type classe d'entités, table, raster ou espace de travail possède un objet de schéma. Seules les classes d'entités en sortie, les tables, les rasters et les espaces de travail ont un schéma, les autres types n'en ont pas. L'objet de schéma est créé pour vous par géotraitement. Vous accédez à ce schéma via l'objet paramètre et définissez les règles de description de la sortie de votre outil. Après avoir défini les règles de schéma et au retour de la classe ToolValidator, le code de validation interne du géotraitement examine les règles que vous avez définies et met à jour la description de la sortie.

A revoir, le flux de contrôle est le suivant :

  1. Lorsque la boîte de dialogue de l'outil est ouverte pour la première fois, initializeParameters est appelé. Vous configurez les règles statiques (règles qui ne changent pas en fonction de l'entrée de l'utilisateur) pour décrire la sortie. Aucune description de sortie n'est créée pour le moment, car l'utilisateur n'a spécifié de valeurs pour aucun des paramètres (sauf si vous avez fourni des valeurs par défaut).
  2. Une fois que l'utilisateur interagit avec la boîte de dialogue de l'outil de quelque manière que ce soit, updateParameters est appelé.
  3. updateParameters peut modifier l'objet de schéma pour tenir compte du comportement dynamique qui ne peut pas être déterminé à partir des dépendances de paramètres (comme l'ajout d'un nouveau champ comme Ajouter un champ).
  4. Après le retour de updateParameters , les routines de validation internes sont appelées et les règles trouvées dans l'objet de schéma sont appliquées pour mettre à jour la description des données de sortie.
  5. updateMessages est alors appelé. Vous pouvez examiner les messages d'avertissement et d'erreur que la validation interne peut avoir créés et les modifier ou ajouter vos propres messages d'avertissement et d'erreur personnalisés.

Toutes les propriétés de schéma sont en lecture et en écriture, à l'exception de type , qui est en lecture seule.

Chaîne : « Feature », « Table », « Raster », « Container » (pour les espaces de travail et les jeux de données d'entités) (propriété en lecture seule)

Chaîne : "AsSpecified", "FirstDependency"

Chaîne : "Simple", "Annotation", "Dimension"

Chaîne : "Unknown", "FirstDependency", "Min", "Max", "AsSpecified"

Chaîne : "Point", "Multipoint", "Polyligne", "Polygone"

Chaîne : "AsSpecified", "FirstDependency", "Intersection", "Union", "Environment"

Chaîne : "Aucun", "FirstDependency", "FirstDependencyFIDs", "All", "AllNoFIDs", "AllFIDsOnly"

Chaîne : "AsSpecified", "FirstDependency", "Min", "Max", "Environment"

Chaîne : "FirstDependency", "Min", "Max", "Integer", "Float"

Liste des jeux de données à ajouter à un schéma d'espace de travail

Utilisation de FirstDependency

Plusieurs règles peuvent être définies sur "FirstDependency", ce qui signifie utiliser la valeur du premier paramètre trouvé dans le tableau de dépendances de paramètres défini avec parameter.parameterDependencies . Dans l'exemple de code ci-dessous, le paramètre 2 a deux paramètres dépendants, 0 et 1, et la première dépendance est le paramètre 0.

Si un paramètre dépendant est une multivaleur (une liste de valeurs), la première valeur de la liste multivaleur est utilisée.

La propriété type est en lecture seule et est définie par géotraitement.

Cloner

Si vrai, vous demandez au géotraitement de faire une copie exacte (clone) de la description dans le premier paramètre dépendant. La valeur par défaut est faux. En règle générale, vous définissez clone sur true dans la méthode initializeParameters. Si le premier paramètre dépendant est une multivaleur (une liste de valeurs), la première valeur de la liste multivaleur est clonée.

  • Si parameter.parameterType est "Derived", une copie exacte est effectuée. C'est le comportement de l'outil Ajouter un champ.
  • Si parameter.parameterType est "Required", une copie exacte est également effectuée, mais le chemin du catalogue vers l'ensemble de données est modifié. Les chemins de catalogue se composent de deux parties : l'espace de travail et le nom de base. Par exemple

  • Espace de travail = E:/Data/TestData/netcity.gdb/infrastructure
  • Nom de base = routes
  • Le nom de base est le même que le nom de base du premier paramètre d'entrée contenant un ensemble de données (pas la première dépendance mais le premier paramètre) suivi du nom de l'outil de script (par exemple, roads_MyTool ).
  • L'espace de travail est défini sur le paramètre d'environnement de l'espace de travail temporaire. S'il est vide, le paramètre d'environnement de l'espace de travail actuel est utilisé. S'il est vide, l'espace de travail du premier paramètre d'entrée contenant un ensemble de données est utilisé. Si cet espace de travail est en lecture seule, le répertoire temporaire du système est utilisé.

Après avoir défini clone sur true, toutes les méthodes basées sur des règles, telles que featureTypeRule , geometryTypeRule et extendRule , sont définies sur « FirstDependency ».

Les deux exemples de code ci-dessous font le travail équivalent. Les deux exemples sont basés sur la façon dont l'outil Clip crée le schéma de sortie.

Exemple 1 : définir explicitement toutes les règles

FeatureTypeRule

Ce paramètre détermine le type d'entité de la classe d'entités en sortie. Cette règle n'a aucun effet sur les rasters ou les tables en sortie.

Le type d'entité sera déterminé par la propriété featureType.

Le type de fonctionnalité sera le même que le premier paramètre dans les dépendances. Si le premier paramètre dépendant est une multivaleur (une liste de valeurs), la première valeur de la liste multivaleur est utilisée.

FeatureType

Lorsque featureTypeRule est "AsSpecified", la valeur de featureType est utilisée pour spécifier le type de fonctionnalité de la sortie.

La sortie contiendra des fonctionnalités simples. Le type de géométrie des entités est spécifié avec geometryTypeRule .

La sortie contiendra des entités d'annotation.

La sortie contiendra des entités dimensionnelles.

GéométrieTypeRule

Ce paramètre détermine le type de géométrie (tel qu'un point ou un polygone) de la classe d'entités en sortie.

Ce sont les paramètres par défauts. En règle générale, vous devriez être en mesure de déterminer le type de géométrie dans updateParameters en fonction des valeurs d'autres paramètres. Vous ne définiriez la règle sur "Inconnu" que si vous n'avez pas suffisamment d'informations pour déterminer le type de géométrie.

Le type de géométrie est le même que le premier paramètre dépendant. Si le premier paramètre dépendant est une multivaleur (une liste de valeurs), la première valeur de la liste multivaleur est utilisée.

Le type de géométrie sera déterminé par la valeur de la propriété geometryType.

GéométrieType

Définissez ceci sur le type de géométrie à utiliser ("Point", "Multipoint", "Polyline" ou "Polygon") lorsque geometryTypeRule est "AsSpecified".

Règle d'étendue

L'étendue de sortie sera spécifiée dans la propriété d'étendue.

L'étendue en sortie est la même que celle du premier paramètre dépendant. Si le premier paramètre dépendant est une multivaleur (une liste de valeurs), la première valeur de la liste multivaleur est utilisée.

L'étendue en sortie sera l'intersection géométrique de tous les paramètres dépendants. (C'est ce que l'outil Découper utilise, comme indiqué ci-dessous.)

L'étendue en sortie sera l'union géométrique de tous les paramètres dépendants.

L'étendue en sortie sera calculée en fonction du paramètre d'environnement de l'étendue en sortie.

Le degré

Définissez ceci sur l'étendue à utiliser lorsque extendRule est "AsSpecified". Vous pouvez définir l'étendue avec une chaîne délimitée par des espaces ou une liste avec quatre valeurs. La séquence est xmin, ymin, xmax, ymax.

Règle des champs

fieldsRule détermine quels champs existeront dans la classe d'entités ou la table en sortie.

Dans le tableau ci-dessous, FID signifie Feature ID mais fait en réalité référence au champ ObjectID trouvé sur chaque classe d'entités ou table.

Aucun champ ne sera généré à l'exception de l'ID de l'objet.

Les champs de sortie seront les mêmes que le premier paramètre dépendant. Si le premier paramètre dépendant est une multivaleur (une liste de valeurs), la première valeur de la liste multivaleur est utilisée.

Seul l'ObjectID de la première entrée dépendante sera écrit dans la sortie.

Tous les champs de la liste des paramètres dépendants seront affichés.

Tous les champs, à l'exception des ObjectID, seront écrits dans la sortie.

Tous les champs ObjectID sont écrits dans la sortie, mais aucun autre champ des entrées ne sera écrit.

Exemple de Clip utilisant des champsRule de "FirstDependency"

Champs supplémentaires

Outre les champs ajoutés par l'application de fieldsRule , vous pouvez ajouter des champs supplémentaires à la sortie. additionalFields prend une liste d'objets de champ.

RègleTailleCellule

Cela détermine la taille des cellules des rasters ou des grilles en sortie.

La taille de cellule de sortie est spécifiée dans la propriété cellSize.

La taille de la cellule est calculée à partir du premier paramètre dépendant. Si le paramètre dépendant est un raster, sa taille de cellule est utilisée. Pour d'autres types de paramètres dépendants, tels que les classes d'entités ou les jeux de classes d'entités, l'étendue des données est utilisée pour calculer une taille de cellule. Si le premier paramètre dépendant est une multivaleur (une liste de valeurs), la première valeur de la liste multivaleur est utilisée.

"Min" signifie que la taille de cellule de sortie est la plus petite taille de cellule des paramètres dépendants. "Max" signifie qu'il s'agit de la plus grande taille de cellule des paramètres dépendants.

La taille de cellule en sortie est calculée en fonction du paramètre d'environnement de taille de cellule.

Taillecellule

Définissez ceci sur la taille de cellule à utiliser lorsque cellSizeRule est "AsSpecified".

Règle raster

Cela détermine le type de données (entier ou flottant) contenu dans le raster en sortie.

Le type de données (entier ou flottant) est le même que le premier paramètre dépendant. Si le premier paramètre dépendant est une multivaleur (une liste de valeurs), la première valeur de la liste multivaleur est utilisée.

Integer est considéré comme plus petit que float. Par exemple, s'il existe deux paramètres dépendants, l'un contenant des entiers et l'autre contenant des flottants, "Min" crée une sortie entière et "Max" crée une sortie flottante.

Le raster en sortie contient des entiers (nombres entiers).

Le raster en sortie contient des flottants (nombres fractionnaires).

RègleFormat raster

Cela détermine le format raster de sortie, soit "Grid" ou "Img". La valeur par défaut est « Img », qui est le format ERDAS IMAGINE. "Grille" est le format d'Esri.

SupplémentaireEnfants

Un espace de travail est un conteneur pour les jeux de données (entités, tables et rasters). Ces ensembles de données sont des enfants de l'espace de travail (pensez à l'espace de travail comme au parent). Si votre outil ajoute des jeux de données à un espace de travail nouveau ou existant, vous pouvez mettre à jour la description de l'espace de travail en ajoutant des descriptions des enfants. Par exemple, vous pouvez avoir un outil qui prend une liste de classes d'entités (une valeur multiple), les modifie d'une certaine manière, puis écrit les classes d'entités modifiées dans un espace de travail existant. Lorsque l'outil est utilisé dans ModelBuilder, l'espace de travail est la sortie dérivée de l'outil et vous souhaiterez peut-être utiliser cet espace de travail comme entrée de l'outil Sélectionner des données. Select Data vous permet de sélectionner un jeu de données enfant trouvé dans un conteneur et de l'utiliser comme entrée dans un autre outil.

L'entrée de additionalChildren est une ou plusieurs descriptions des enfants. Il existe deux formes de descriptions d'enfants :

Une classe d'entités, une table, un raster, une cote ou une valeur d'annotation, telle que renvoyée par la propriété value.

Objet de liste du formulaire [type, nom, champs, étendue, référence spatiale]

Une liste contenant une description de l'enfant à ajouter. Seules les deux premières entrées de la liste, type et nom , sont obligatoires. Les arguments restants sont facultatifs.

Lorsque vous ajoutez plusieurs enfants, vous fournissez une liste de descriptions d'enfants. Si vous ajoutez les enfants sous forme de liste, vous créerez une liste de listes pour additionalChildren .

La forme de liste a cinq arguments, comme décrit dans le tableau suivant.

L'un des éléments suivants : "Point", "Multipoint", "Polyligne", "Polygone", "Table", "Raster", "Annotation", "Dimension"

Le nom de l'ensemble de données. Il peut simplement s'agir du nom de base de l'ensemble de données (streets) ou du chemin complet du catalogue ( E:mydata est.gdbinfrastructurestreets ). Lorsqu'un chemin de catalogue complet est fourni, tout sauf le nom de base (rues) est ignoré.

Une liste d'objets de champ. Celui-ci contient les champs apparaissant sur l'enfant, s'ils sont connus.

Une chaîne ou une liste contenant l'étendue spatiale de l'enfant.

Un objet de référence spatiale.

Ces arguments doivent être fournis dans l'ordre indiqué. Pour ignorer un argument facultatif, utilisez None , ou '#' .

Voici quelques exemples de définition d'un schéma d'espace de travail. Les exemples sont basés sur un outil de script qui a les arguments suivants :

Espace de travail : entrée (un espace de travail existant qui contient les résultats de l'outil).

Espace de travail : sortie dérivée, obtenue à partir de Input_workspace. Le schéma de cet espace de travail est modifié pour contenir des enfants supplémentaires.

L'outil prend la classe d'entités et la table en entrée, les copie dans l'espace de travail, ajoute un nouveau champ à la classe d'entités, puis crée une nouvelle classe d'entités surfaciques dans l'espace de travail. (Le travail réel de l'outil n'est pas important car il sert uniquement à illustrer la définition d'un schéma d'espace de travail.) Les exemples de code ci-dessous s'appuient les uns sur les autres, en commençant par l'utilisation simple de additionalChildren .

Dans initializeParameters , l'espace de travail de sortie est cloné à partir de son paramètre dépendant (paramètre 2). Cette dépendance est définie dans les propriétés de l'outil, mais peut également être définie dans initializeParameters pour éviter que quelqu'un ne supprime la dépendance dans les propriétés de l'outil.

Exemple : Copiez les deux entrées (aucune modification) dans l'espace de travail de sortie :

Exemple : L'outil crée une nouvelle classe d'entités surfaciques. Les seules propriétés connues de cette nouvelle classe d'entités (lors de la validation) sont le nom ("SummaryPolygon") et le type ("polygone").

Exemple : ajoutez un champ à la classe d'entités en entrée.

Pour créer des champs pour SummaryPolygon (la nouvelle classe d'entités surfaciques), créez une liste d'objets de champ similaire au modèle illustré dans l'exemple ci-dessus.

Dans cet exemple, le premier paramètre est une valeur multiple de classes d'entités. Chaque classe d'entités de la valeur multiple est copiée dans l'espace de travail dérivé. Un nouveau champ, ProjectID , est ajouté à chacune des classes d'entités copiées.


Création de paramètres à valeurs multiples

Si vous souhaitez qu'un paramètre puisse gérer une liste de valeurs, plutôt qu'une seule valeur, définissez la propriété multiValue sur True.

Dans les boîtes de dialogue d'outil, deux commandes d'interface utilisateur différentes sont utilisées pour les valeurs multiples, comme illustré ci-dessous.

  • Une liste de cases à cocher est utilisée pour les champs et pour les chaînes, les longs et les doubles, s'ils contiennent un filtre ValueList.
  • Tous les autres types de données affichent le contrôle de paramètre à valeurs multiples.

Les deux types de commandes à valeurs multiples sont illustrés ci-dessous.

À partir de l'illustration ci-dessus, si l'utilisateur sélectionne tous les types de routes, la valeur du paramètre sera définie sur ["Interstates", "Primary roads", "Secondary roads"] .


Les scripts pour les outils de la boîte à outils sont très similaires aux scripts Python classiques que nous avons créés. La principale différence est que vous devrez lire les paramètres définis par l'utilisateur dans la boîte de dialogue de l'outil. Ceux-ci sont passés par "parameters". Votre script Python va lire les valeurs des paramètres dans des variables que vous pouvez utiliser dans votre script. Le code ci-dessous sera lu dans le premier paramètre et l'affichera sous forme de message dans ArcGIS. Enregistrez le code dans un nouveau fichier dans votre dossier de projet.

Assurez-vous que votre script Python fournit de bons messages d'erreur qui aident l'utilisateur à déterminer ce qui ne va pas. Vous savez probablement déjà qu'il n'y a rien de plus frustrant que d'exécuter un logiciel et de recevoir un message que vous ne comprenez pas ou aucun message lorsqu'un problème survient. Maintenant, c'est à votre tour d'être le développeur que tout le monde apprécie ou déteste !


1 réponse 1

Avec un outil de script standard, vous devez définir un filtre avec une liste de valeurs pour le paramètre, via les propriétés de l'outil de script. Ouvrez les propriétés de l'outil de script (ou passez par l'assistant d'ajout de script), cliquez sur l'onglet Paramètres et à côté de Filtre, choisissez Liste de valeurs dans la liste déroulante :

Cliquez sur le bouton à côté de Liste de valeurs et entrez les valeurs manuellement une par une. Voir une explication détaillée dans la section « Filtre » de la page Paramètres de l'outil de script de réglage.


Ligne de fractionnement interactive à l'aide d'ArcPy FeatureSets

À l'époque où je travaillais beaucoup sur les SIG pour la gestion des actifs civils et électriques, une tâche courante que j'avais consistait à m'assurer que toutes les structures civiles représentées sous forme de polyligne (réticulation et canalisations en vrac, câbles d'alimentation électrique, surfaces routières, etc. les intersections routières physiques telles qu'elles apparaissent sur les dernières images aériennes disponibles, ainsi que l'endroit où elles se sont croisées.

Cette tâche n'était pas trop compliquée si les lignes étaient déjà tracées l'une à côté de l'autre, car le plus souvent, les lignes se croisaient aux intersections routières. Le résultat était généralement obtenu en utilisant l'option Planariser de la barre d'outils d'édition avancée. Cependant, cela devenait un problème pour les nouvelles zones qui devaient être numérisées à la main (pas de dessins CAO ou de fichiers de formes reçus), ou des lignes qui devaient être corrigées.

Je devrais vérifier visuellement sur l'imagerie où se trouvaient les intersections routières, puis diviser manuellement chaque polyligne. J'ai parcouru quelques idées, notamment la numérisation de toutes les intersections routières en tant que points (ce qui serait de toute façon de bonnes données), puis la division de toutes les lignes à l'intersection la plus proche en utilisant l'outil Diviser la ligne au point.

Je voulais cependant créer une méthode pour diviser la ligne plusieurs fois à la volée, au lieu de la diviser une seule fois (ce qui est l'option fournie par le bouton Diviser sur la barre d'outils de l'éditeur). Je voulais pouvoir sélectionner une ligne, cliquer sur autant de points le long de la ligne que je le voulais, puis diviser la ligne en ces points.

'''
@date 06/10/2015
@auteur Cindy Williams
@version 1.0
Utilise un arcpy FeatureSet pour permettre à l'utilisateur de créer de manière interactive
points sur une ligne qui seront utilisés pour diviser cette ligne en parties,
tout en conservant tous les attributs.
Exigences:
– Fonctionne comme un outil de script. Ajouter à une boîte à outils.
– Ne peut fonctionner que sur une seule ligne pour le moment. Sélectionnez la ligne, à droite
cliquez sur la couche et "Créer une couche à partir des entités sélectionnées". Utilisation
cette couche de sélection en entrée de l'outil.
– Numériser les points accrochés à la ligne sélectionnée. L'outil échouera sinon
cassé
– Numérisez les points de gauche à droite le long de la ligne.
Les futures versions comprendront :
– diviser plusieurs lignes en même temps
– points d'accrochage automatiquement/erreur d'accrochage des points
– les points seront triés après la numérisation pour assurer un ordre correct
Construit sur une idée ici http://gis.stackexchange.com/questions/154708/standalone-python-script-to-split-a-polyline-with-a-point-layer
'''
importer arcpy
encart = arcpy . GetParameter ( 0 ) # FeatureSet de points interactifs d'ArcMap
inline = arcpy . GetParameterAsText ( 1 ) # Couche d'entités polyligne en entrée
# Obtenir tous les noms de champs à l'exception des champs dynamiques
champs = [ [email protected]" ]
des champs . étendre ([ champ . nom du champ dans arcpy . ListFields ( en ligne ) si champ . nom pas dans [ "OBJECTID" , "Shape_Length" , "Shape" ]])
# Ouvrir un curseur d'insertion pour insérer les lignes de coupe
curseur_ins = arcpy . da. InsertCursor ( en ligne , champs )
# Obtenir la référence spatiale de la polyligne
sr = arcpy . Décrivez (en ligne). spatialRéférence
# Obtenez la polyligne et supprimez l'enregistrement d'origine
avec arcpy. da. UpdateCursor ( en ligne , champs ) en tant que curseur :
pour la ligne dans le curseur :
polyligne = ligne
le curseur . Supprimer la ligne ()
# Itérer sur les points
avec arcpy. da. SearchCursor ( inset , [email protected]" ) comme curseur :
pour la ligne dans le curseur :
point = ligne [ 0 ]. premier point
# Construisez une ligne diagonale temporaire à partir du point
diag = arcpy . Polyligne ( arcpy . Array ([ arcpy . Point ( point . X + 10.0 , point . Y + 10.0 ), arcpy . Point ( point . X – 10.0 , point . Y – 10.0 )]), sr )
# Couper la polyligne d'origine
geom = polyligne [ 0 ]. couper (diag)
# Créer une nouvelle ligne avec le côté droit du geom c'est-à-dire fini avec ce côté
nouvelle ligne = [ geom [ 1 ]]
nouvelle ligne . prolonger ( polyligne [ 1 :])
# Insérez la ligne dans la couche d'entités
curseur_ins . insertRow ( saut de ligne )
# Définir le côté gauche de la ligne de coupe comme nouvelle ligne de coupe
polyligne = [ geom [ 0 ]]
polyligne. extension ( saut de ligne [ 1 :])
# Insérez la dernière partie de la ligne
curseur_ins . insertRow ( polyligne )
del curseur_ins
de la polyligne

L'outil itère sur tous les points créés par l'utilisateur dans le FeatureSet. Pour chaque point, une diagonale temporaire est créée pour couper la polyligne d'origine. Cette nouvelle pièce est enregistrée dans une liste et l'outil s'exécute à nouveau sur la polyligne d'origine (moins la nouvelle pièce). Une fois que tous les points ont été traités, la polyligne d'origine est supprimée de la classe d'entités et les nouvelles pièces sont insérées. Tous les attributs d'entité sont conservés.

Mon intention avec cet outil était de l'étendre avec plus de fonctionnalités, de corriger les bogues (cela ne fonctionnerait pas au hasard) et de le télécharger en tant que boîte à outils. Cependant, la nécessité de le faire est tombée. J'ai également réalisé que je commençais à entrer dans un espace où je forçais autant de code que possible dans mon travail afin de passer la journée.


Matériel de cours pour les étudiants

Une version étudiante d'ArcGIS for Desktop vous sera fournie. Il s'agit d'une version complète du logiciel, mais il s'agit d'une licence à durée limitée. Vous recevrez également une série d'exercices ArcGIS et les fichiers de données nécessaires.

Le temps pour terminer les exercices ci-dessus varie, mais vous devez prévoir au moins deux heures par exercice.

Lectures et ressources supplémentaires :
Aide d'ArcGIS Desktop disponible à partir d'ArcMap ou d'ArcCatalog
Ressources ArcGIS : http://resources.arcgis.com/en/home/ en particulier la page sur les emplacements de chargement : http://desktop.arcgis.com/en/arcmap/10.3/tools/network-analyst-toolbox/add- emplacements.htm

2. HORAIRE ET AFFECTATIONS DE BLOG

  • Installer ArcGIS
  • Terminez les exercices 1 et 2
  • Terminez les exercices 2 et 3
  • Passez en revue le matériel Python sur l'entrée et la sortie des fichiers disponibles sur https://www.codecademy.com/learn/python (leçon 12)
  • Mission de blog:
    • Allez sur https://www.ted.com/playlists/17/how_to_live_with_robots Sélectionnez un minimum de deux vidéos à regarder. Nommez les vidéos que vous avez regardées et donnez votre avis sur ces vidéos.
    • Commentez ce qui a bien fonctionné cette semaine, ce qui n'a pas fonctionné et ce que vous avez appris.
    • Téléchargez le document Team Project Peer Assessments, lisez-le, cliquez sur l'URL à la fin du document et notez au moins deux de vos anciens partenaires de projet. Nous vous encourageons à évaluer les quatre. (Dû dimanche soir à 20h00)
    • Terminer l'exercice 4
    • Travail sur la mission de projet de l'équipe SIG 1.
    • Mission de projet 1 de l'équipe SIG sur la lecture des données et l'affichage des caractéristiques est dû en classe. Démonstration à d'autres groupes.
    • Mission de blog:
      • Sélectionnez l'une des vidéos suivantes, visionnez-la et donnez votre avis sur la vidéo. Lorna Goulden : L'internet des objets, Marco Annunziata : Bienvenue à l'ère de l'internet industriel, Massimo Banzi, Comment Arduino est une imagination en open source, ou Rana el Kaliouby, Cette application sait ce que vous ressentez — à partir de l'apparence de votre visage
      • Commentez ce qui a bien fonctionné cette semaine, ce qui n'a pas fonctionné et ce que vous avez appris. (Dû dimanche soir à 20h00)
      • Installez ArcMap Add-In Manager disponible sur http://desktop.arcgis.com/en/arcmap/latest/analyze/python-addins/obtaining-the-python-add-in-wizard.htm
      • Terminez les exercices 5 et 6
      • Apprenez à configurer une zone de liste déroulante dans ArcMap ArcMap en regardant https://www.youtube.com/watch?v=S78v_NH4tO0
      • Terminez les exercices 7 et 8
      • Mission de blog:
        • Allez sur https://www.ted.com/playlists/135/will_drones_save_us_or_destroy Sélectionnez un minimum de deux vidéos à regarder. Nommez les vidéos que vous avez regardées et donnez votre avis sur ces vidéos.
        • Commentez ce qui a bien fonctionné cette semaine, ce qui n'a pas fonctionné et ce que vous avez appris. (Dû dimanche soir à 20h00)
        • Travail sur la mission de projet de l'équipe SIG 2.
        • Mission de projet de l'équipe SIG 2 sur le chemin le plus court parmi les sites sélectionnés est dû en classe.
        • Mission de blog:
          • Allez sur https://www.ted.com/playlists/385/10_years_of_ted_talks?utm_source=tedcomshare&utm_medium=email&utm_campaign=tedspread Sélectionnez un minimum de deux vidéos à regarder. Nommez les vidéos que vous avez regardées et donnez votre avis sur ces vidéos.
          • Commentez ce qui a bien fonctionné cette semaine, ce qui n'a pas fonctionné et ce que vous avez appris. (Dû dimanche soir à 20h00)

          Comme pour tous les cours universitaires, vous devez vous attendre à passer 2 à 3 heures en dehors des cours pour chaque heure passée en classe.

          3. MISSIONS DE PROJET DE DEUX SEMAINES

          Mission de projet de l'équipe SIG 1 (à remettre à la fin de la semaine 11) – Lecture des données et affichage des fonctionnalités (version pdf)

          Créez un script Python pour lire un fichier de données d'un phoque (de préférence un phoque commun) à partir du site Web suivant : http://whale.wheelock.edu/whalenet-stuff/stop_cover.html. Analysez les colonnes du tableau : ID, DATE_TIME, LOCATION CODE, LATITUDE, LONGITUDE, le tout dans le format correct, et affichez le tableau dans un fichier séparé par des virgules.

          Apportez le fichier dans ARCGIS et convertissez-le en classe d'entités et affichez les traces de scellement à l'aide d'un analyste de suivi.

          Classement: Les soumissions tardives de projets entraînent une baisse de la note complète par semaine.

          Noter Performance
          UNE Le script Python fonctionne et la mise en page générée est correcte. (A- si des détails mineurs manquent.
          B Le script fonctionne, mais ne génère pas la sortie correcte, mais il peut être affiché dans ArcGIS.
          C Le script fonctionne, mais ne génère pas la sortie correcte et ne peut pas être affiché dans ArcGIS.
          Le projet fonctionne dans ArcMap, mais le script ne fonctionne pas.
          F Aucun projet soumis n'a atteint l'un des niveaux de performance ci-dessus dans les deux semaines suivant la date limite.

          Mission de projet de l'équipe SIG 2 (échéance à la fin de la semaine 13) – Itinéraire le plus court parmi les sites sélectionnés (version pdf)

          Installez le gestionnaire de compléments ArcGIS. Créez une zone de liste déroulante complémentaire qui permet à l'utilisateur de déterminer le type de visite qu'il souhaite. Créez au moins deux choix, par ex. “Choses à faire et “Choses à voir.” Écrivez un script ArcPy qui charge les arrêts appropriés dans la fenêtre Network Analyst, puis crée l'itinéraire le plus court pour visiter les sites sélectionnés.

          Classement: Les soumissions tardives de projets entraînent une baisse de la note complète par semaine. Un programme hors sujet obtiendra au maximum un B-

          Noter Performance
          UNE La zone de liste déroulante fonctionne et les fichiers sont chargés correctement et la route créée.
          B La zone de liste déroulante fonctionne et les fichiers sont chargés mais aucun itinéraire n'est créé.
          C La zone de liste déroulante fonctionne, mais aucun fichier n'est chargé.
          Le projet fonctionne dans ArcMap, mais la zone de liste déroulante ne fonctionne pas.
          F Aucun projet soumis n'a atteint l'un des niveaux de performance ci-dessus dans les deux semaines suivant la date limite.

          />
          COS 120 Introduction to Programming by School of Computing and Information Science est sous licence Creative Commons Attribution 4.0 International License.


          Au-delà des bases

          Vous pouvez créer une mosaïque en définissant uniquement le nom et le système de référence spatiale (comme indiqué dans les étapes ci-dessus), mais il existe des paramètres supplémentaires pour vous aider à créer de meilleurs produits de mosaïque qui répondent aux besoins de votre application, tels que le type de pixel, le nombre des bandes et des informations sur la longueur d'onde de la bande. Vous pouvez également affiner la mosaïque en définissant des propriétés, telles que les valeurs par défaut d'affichage, en définissant le traitement et en affinant les entrées, telles que la modification de leurs emprises.

          Création de la mosaïque

          Dans les étapes ci-dessus, vous n'avez défini aucune propriété ni modifié les paramètres de l'outil. L'outil Créer une mosaïque de données contient des paramètres supplémentaires qui permettent de personnaliser la mosaïque en fonction de vos besoins. These control the product properties and the pixel properties of the mosaic dataset, which can impact the data added and the output.

          Product properties

          The product definition allows you to customize the mosaic dataset to contain data with a specific number of bands and wavelengths. The product definition controls how the data is added to the mosaic dataset, how it displays by default, and aids in some processing.

          The most commonly used product definitions are:

          • Natural Color (RGB)—This creates a three-band mosaic dataset, with red, green, and blue wavelength ranges.
          • Natural Color (RGBI)—This creates a four-band mosaic dataset, with red, green, blue and near infrared wavelength ranges.
          • False Color (IRG)—This creates a three-band mosaic dataset, with near infrared, red, and green wavelength ranges.

          Using a product definition helps when adding data containing wavelength information in its metadata. If the wavelength information is ordered differently in the inputs, they will all be ordered correctly when added to the mosaic dataset. For example, if band 1 in a QuickBird scene is a blue wavelength, and band 3 in the mosaic dataset is designed to contain the blue wavelengths, then the QuickBird's blue band will be mapped to the mosaic dataset's blue band. Without this, the QuickBird's blue band may be mapped to the mosaic dataset's red band. The correct ordering is shown below.

          There are additional product definitions that are designed to support specific satellite imagery products, such as QuickBird and Landsat. You can also create a custom product definition, where you define the number of bands, their order, and their wavelength ranges by editing the Product Band Definitions parameter.

          If you create a mosaic dataset using a product definition with fewer bands than the input, then the extra bands will be excluded from the mosaic dataset. For example, if the mosaic dataset's product definition is Natural Color (RGBI) and the input has five bands, then one of the bands will be excluded from the mosaic dataset. This will be the band with the wavelength range furthest from the ranges defined for the RGBI bands.

          If there are more bands in the mosaic dataset than in the input, the mosaic dataset will not contain an empty band. The band with the wavelength closest to the extra band will be used.

          If the input doesn't have wavelength information, it can still be added to the mosaic dataset, but it will be up to you to make sure the bands are added in the correct order. You may need to use the Extract Bands function to map the bands in a different order than how they are stored.

          Pixel properties

          As an alternative to defining a product definition, you can define the number of bands in the mosaic dataset and the output pixel type. The number of bands and pixel type are properties of the mosaic dataset, just as they are a raster dataset. If these are not defined when you create the mosaic dataset, they will be identified by the application. By default, this information is derived from the first raster added to the mosaic dataset or altered by functions you may add that change these defaults.

          If you're mixing the types of raster data used in the mosaic dataset, it is recommended that you define these values. For example, if using raster data from single-band orthophotos and a three-band orthophoto, you should specify three bands' otherwise, if the single-band orthophoto is added first, then only the first band of the three-band orthophoto will be added. Also, if you're mixing elevation data sources, the inputs could have a mix of pixel types. By defining a pixel type, such as 32-bit float, then you won't lose any information if the first input added is 8 bit and the others are larger.

          Adding data to the mosaic dataset

          • The Update Cell Size Ranges check box should be checked when adding data. Cell size ranges are used to determine what rasters are processed to create the mosaicked image from the mosaic dataset and must exist. If you plan to immediately add more data, you may opt to calculate the cell sizes for all data at the same time rather than each time you add data, since the existing data and new data will be analyzed and values recalculated or calculated. You can check this option the final time you add data to the mosaic dataset, or use the Calculate Cell Size Ranges tool.
          • The Update Boundary check box should be checked when adding data. The boundary is the extent of all the raster datasets, defined by their footprints. Like the previous parameter, if you're adding additional data immediately after, you can opt to calculate the boundary after all your data has been added.
          • The Update Overviews check box should be checked when adding data. Overviews are lower-resolution images created to increase the display speed and reduce the CPU usage, since fewer rasters are examined to display the mosaicked image. You should build the overviews once all your data is added to the mosaic dataset (as with the previous parameters). They take time to create therefore, for a large mosaic dataset, you may want to build them when your system is not busy with other operations. If you choose to generate these at another time, use the Build Overviews tool.
          • The Include Sub Folders check box should be checked. This option will recursively explore any subfolders containing the data being added.
          • If your workspace contains duplicate data, you can change the Add New Datasets Only parameter to exclude duplicates. This may be very useful however, it will take more time because it must check every new item with one already added.
          • If your data doesn't have statistics, you may want to check Calculate Statistics . This is useful for data that has not been preprocessed (enhanced). If your dataset already has statistics, they will not be recalculated.
          • If your data doesn't have pyramids, you may want to check Build Raster Pyramids . Pyramids will reduce the number of overviews that will be generated for the entire mosaic dataset. If your dataset already has pyramids, they will not be recalculated. Note that pyramids are not necessary for the CADRG/ECRG, CIB, and DTED raster types.
          • If you want to restrict the data in your workspace that is added, you can define a File Filter , which performs a file name search. For example, there may be thumbnail images stored with the original data. If you're using the Raster Dataset raster type, you may want to specify the valid file extension (such as *.tif) so the thumbnails (such as *.gif) are not added.

          When you run the tool to add the data to the mosaic dataset, footprints are created for each raster dataset and the attribute table is populated with each raster. Depending on the options you selected, cell sizes, overviews, pyramids, statistics, and the boundary may be created.


          Export only dominant routes from LRS?

          I'm looking to export the entirety of our enterprise LRS out of ArcMap, but with a caveat. When there is a concurrency, I would like only the dominant route present in the exported data.

          I've got a workflow that seems to give me what I want, but it's a lot of steps.

          Here's what I'm currently using:

          1. Run the Calculate Route Concurrencies GP tool with the appropriate temporal view date
          2. Export all non-retired routes into a separate LRS feature class
          3. Select the dominant routes from the output table, and run the Make Route Event GP tool from the Location Referencing toolbox to create an event of dominant routes
          4. Use the Erase GP tool from the Analysis toolbox to remove all concurrent sections from the LRS feature class
          5. Merge the dominant events with the LRS feature class that's output from Erase
          6. Dissolve on Route ID

          Does anyone have a simpler workflow to accomplish this? Do you see any flaws in this current workflow?

          I'm including a Python script that implements something similar to Amit Hazra‌'s model builder screenshot. Maybe someone will find it useful. Thanks for the tips, RHUG.

          I ended up turning this into an ArcGIS Desktop Geoprocessing Tool as well. It's only been tested on ArcGIS Desktop 10.5.1 with an LRSN Route Network stored in a file geodatabase or SQL Server 2016 geodatabase. If you're using a different RDBMS, the where_clause that applies the Temporal View Date may be different.

          I've also attached a .zip directory containing the tool as of today's date.

          by AmitHazra

          Yes you are almost there. If the intent is to create a new route feature class with non-overlapping primary (dominant) routes only you'll want to add a few more steps to this process.

          After the erase you'll most likely need to run multi-part to single part before you re-assemble the non-overlapping sections with the sections you've created as a result of the CRC process. After that, you'll append those two sources and then if you need to produce routes the easiest way to complete this would be to calculate MMin and MMax fields based on each feature part and then use the core linear referencing Create Routes GP tool.

          Here's what my GP Model would look like:

          The expression on the table view is: DominantFlag = 1 and DominantError <> 4

          by AmitHazra

          Yes you are almost there. If the intent is to create a new route feature class with non-overlapping primary (dominant) routes only you'll want to add a few more steps to this process.

          After the erase you'll most likely need to run multi-part to single part before you re-assemble the non-overlapping sections with the sections you've created as a result of the CRC process. After that, you'll append those two sources and then if you need to produce routes the easiest way to complete this would be to calculate MMin and MMax fields based on each feature part and then use the core linear referencing Create Routes GP tool.

          Here's what my GP Model would look like:

          The expression on the table view is: DominantFlag = 1 and DominantError <> 4

          Thanks, Amit. This is very helpful.

          My "model" is essentially the same as yours except that I'm using Merge/Dissolve rather than Multipart to Singlepart/Append. I've also done away with the template feature class, since all I need from the LRS is the route ID and geometry (the end game is simply to build a feature class of an external event table).

          I'm still struggling to understand why you suggest creating new routes as a last step. Since I need the original m-values from the LRS to properly locate my external events, isn't it best to leave the native m-values?

          by AmitHazra

          In my experience the Erase GP tool will typically create multi-part features. Reassembling the multi-part features with the output from Calculate Route Concurrency (CRC) dynamic segmentation using the merge/dissolve pattern will also continue to produce multi-part features where the part orders may be jumbled (Dissolve GP is mostly the common offender here). So although the geometry of the routes may be intact and the vertices are still carrying the original route m-values, the GP-derived route parts are not ordered correctly and would yield incorrect geometries if the features were used as input routes in Make Route Event Layer (MREL).

          In order to create a monotonic derived LRS feature class where there are no route concurrencies and only the dominant routes are included I've found that exploding the erased multi-parts into single parts and then appending them to the erased routes preserves the part orders and m-values such that I can then field calculate the MMin and MMax for each singlepart and use those fields and polylines to build a monotonic network in core linear referencing.

          This kind of derived network might be used for the purpose of say. feature based location of geometries that you wish to associate to the R&H LRS. I'm sure there are other reporting and publication uses as well where you wish to inform users or systems of only the routes that carry inventory/event information.

          Regardless of the process you end up utilizing, I highly suggest you quality assure your derived network using the Data Reviewer Monotonicity Check in Polyline Checks.


          Voir la vidéo: ArcGIS: Créer et éditer les tables attributaires. Create and edit attribute tables