Programmation d'une classe ToolValidator

Pour une vue d'ensemble de la classe ToolValidator et de l'utilisation de méthodes de paramètres, reportez-vous à la rubrique Personnalisation du comportement d'un outil de script.

Objet Parameter

Accès aux paramètres de l'outil

Chaque paramètre d'outil dispose d'un objet Parameter associé comportant les propriétés et méthodes utiles à la validation d'outils. Les paramètres sont contenus dans une liste Python. La procédure habituelle consiste à créer la liste de paramètres dans la méthode __init__ de la classe ToolValidator, comme illustré dans le code ci-dessous.

def __init__(self):
  import arcpy 
  self.params = arcpy.GetParameterInfo()

Vous pouvez également accéder aux paramètres dans votre script (contrairement à la classe ToolValidator) comme indiqué ci-dessous. La seule raison d'accéder à la liste des paramètres d'un script est de définir la propriété symbology.

import arcpy
params = arcpy.GetParameterInfo()

Pour en savoir plus sur la définition de la symbologie dans les scripts

Ordre des paramètres

Les paramètres d'un outil et leur ordre sont définis dans l'onglet Paramètres des propriétés de l'outil, comme illustré ci-dessous.

Paramètres et leur ordre
RemarqueRemarque :

La liste des paramètres démarre à zéro, la position zéro est donc attribuée au premier paramètre de la liste. Pour accéder au troisième paramètre, vous devez entrer p3 = self.params[2].

Méthodes

Nom de la méthode

Description de l'utilisation

setErrorMessage(message:string)

Indique une erreur sur le paramètre (un X rouge) avec le message fourni. Les outils ne s'exécutent pas si l'un des paramètres comporte une erreur.

setWarningMessage(message:string)

Indique qu'un avertissement sur le paramètre (un triangle jaune) avec le message fourni. Contrairement aux erreurs, les outils s'exécutent avec les messages d'avertissement.

setIDMessage(messageType: string, messageID: string, {AddArgument1}, {AddArgument2})

Permet de définir un message système. Les arguments sont les mêmes que pour la fonction AddIDMessage.

clearMessage()

Supprime le texte de message et définit le statut sur information (pas d'erreur ou d'avertissement).

hasError()

Renvoie la valeur True si le paramètre contient une erreur.

hasWarning()

Renvoie la valeur True si le paramètre contient un avertissement.

isInputValueDerived()

Renvoie la valeur True si l'outil est validé à l'intérieur d'un Modèle et si la valeur en entrée correspond à la sortie d'un autre outil dans le modèle.

Méthodes des objets paramètre

Propriétés

Nom de la propriété

Lecture/écriture

Valeur(s)

Description

name

Lecture seule

Chaîne

Nom du paramètre tel que défini dans l'onglet Paramètres des propriétés de l'outil.

direction

Lecture seule

Chaîne : "Entrée", "Sortie"

Direction entrante/sortante du paramètre, telle que définie dans l'onglet Paramètres des propriétés de l'outil.

datatype

Lecture seule

Chaîne

Type de données, tel que défini dans l'onglet Paramètres des propriétés de l'outil.

parameterType

Lecture seule

Chaîne : "Requis", "Facultatif", "Dérivé"

Type, tel que défini dans l'onglet Paramètres des propriétés de l'outil.

parameterDependencies

Lecture/écriture

Liste Python

Liste des index de chaque paramètre dépendant.

value

Lecture/écriture

Objet Value

Valeur du paramètre.

defaultEnvironmentName

Lecture seule

Chaîne

Paramètre d'environnement par défaut, tel que défini dans l'onglet Paramètres des propriétés de l'outil.

enabled

Lecture/écriture

booléen

Valeur False si le paramètre est grisé (indisponible).

altered

Lecture seule

booléen

Valeur True si l'utilisateur a modifié la valeur.

hasBeenValidated

Lecture seule

booléen

Valeur True si la routine de validation interne a vérifié le paramètre.

category

Lecture/écriture

Chaîne

Catégorie du paramètre.

schema

Lecture seule

Objet GP Schema

Structure du jeu de données en sortie.

filter

Lecture seule

Objet GP Filter

Filtre à appliquer aux valeurs dans le paramètre.

symbology

Lecture/écriture

Chaîne

Chemin d'accès à un fichier de couches (.lyr) utilisé pour afficher la sortie.

message

Lecture seule

Chaîne

Message à afficher à l'utilisateur. Voir SetErrorMessage et SetWarningMessage ci-dessus.

Propriétés des objets paramètre

Voici quelques exemples de code. Pour d'autres exemples de codage, reportez-vous à la rubrique Personnalisation du comportement des outils de script.

Propriétés ToolValidator et propriétés des outils de script

La valeur, le filtre, la symbologie et les dépendances par défaut d'un paramètre peuvent être définis dans l'onglet Paramètres de la boîte de dialogue des propriétés de l'outil de script et dans la classe ToolValidator.

Les propriétés que vous définissez dans ToolValidator remplacent toujours celles définies dans la boîte de dialogue des propriétés de l'outil de script. Par exemple, si vous définissez la valeur par défaut d'un paramètre sur "BLUE" dans la boîte de dialogue des propriétés de l'outil de script, puis la réinitialisez sur "RED" dans initializeParameters(), la valeur par défaut est "RED". Lorsque initializeParameters() a été appelé, la boîte de dialogue des propriétés de l'outil de script affiche "RED" comme valeur par défaut. Si vous (ou vos utilisateurs) vous retrouvez dans la situation où les modifications que vous appliquez à l'une de ces quatre propriétés de paramètre dans la boîte de dialogue des propriétés du script ne sont pas enregistrées, cela est probablement dû au fait que la propriété est remplacée dans la classe ToolValidator.

parameterDependencies

Vous définissez généralement des dépendances de paramètres à utiliser par l'objet Schema. Dans deux cas, les dépendances peuvent avoir déjà été définies dans l'onglet Paramètres des propriétés de l'outil.

  • Pour un paramètre de jeu de données en sortie de type Dérivé, la dépendance est l'index du paramètre à partir duquel la sortie est dérivée.
  • Pour certains types de données en entrée, la dépendance est l'index du paramètre qui contient les informations utilisées par le contrôle, comme illustré dans la table ci-dessous.

Type de données en entrée

Type de données dépendantes

Description

Champ ou expression SQL

Table

Table qui contient les champs.

Elément INFO ou expression INFO

Table INFO

La table INFO qui contient les attributs.

Classe d'entités de couverture

Couverture

La couverture qui contient des entités.

Unités de surface ou unités linéaires

Jeu de données géographiques

Un jeu de données géographiques utilisé pour déterminer les unités par défaut.

Système de coordonnées

Espace de travail

Un espace de travail utilisé pour déterminer le système de coordonnées par défaut.

Paramètres de hiérarchie Network Analyst

Jeu de données réseau

Le jeu de données réseau qui contient les informations de hiérarchie.

Table de valeurs géostatistiques

Couche géostatistique

Couche d'analyse qui contient les tables.

Types de données de la propriété Obtenu à partir de

Les dépendances sont généralement définies dans la méthode initializeParameters() :

def initializeParameters(self):
  # Set the dependencies for the output and its schema properties
  #
  self.params[2].parameterDependencies = [0, 1]

value

C'est la valeur du paramètre que l'utilisateur a saisie ou que vous avez définie à l'aide d'un programme. Vous pouvez définir cette valeur dans initializeParameters(), auquel cas elle devient la valeur initiale par défaut du paramètre. Vous pouvez également définir les valeurs dans updateParameters() en réponse aux informations saisies par l'utilisateur, comme illustré ci-dessous.

def updateParameters(self):
    # Set the default distance threshold to 1/100 of the larger of the width
    #  or height of the extent of the input features.  Do not set if there is no 
    #  input dataset yet, or the user has set a specific distance (Altered is true).
    #
    if self.params[0].value:
        if not self.params[6].altered:
            extent = arcpy.Describe(self.params[0].value).extent
        if extent.width > extent.height:
            self.params[6].value = extent.width / 100
        else:
            self.params[6].value = extent.height / 100

    return

La propriété value d'un paramètre renvoie un objet, sauf si le paramètre n'est pas renseigné, auquel cas value renvoie None. Pour éviter qu'un paramètre ne soit pas renseigné, utilisez un contrôle if avant d'utiliser sa valeur.

L'extrait de code ci-dessous vérifie si la valeur est égale à la chaîne "Extraire les pondérations spatiales à partir du fichier". Ce test fonctionne car le type de données du paramètre est une chaîne.

# If the option to use a weights file is selected, enable the 
#   parameter for specifying the file, otherwise disable it

if self.params[3].value:  # check that parameter has a value
  if self.params[3].value == "Get Spatial Weights From File":
    self.params[8].enabled = True
  else:
    self.params[8].enabled = False

Comme un objet Value ne prend pas en charge la gestion des chaînes, utilisez la propriété de valeur de l'objet Value lorsqu'une chaîne doit être gérée ou analysée. L'exemple de code utilise la méthode os.path.dirname pour renvoyer le répertoire à partir d'un jeu de données.

if self.params[0].value:
  workspace = os.path.dirname(self.params[0].value.value)
AttentionAttention :

A l'exception de Describe, n'utilisez pas les méthodes qui utilisent un chemin d'accès de catalogue, telles que ListFields, lors de la validation. Il se peut que le jeu de données n'existe pas lorsque votre outil est validé dans ModelBuilder, la méthode risque alors d'échouer ou de donner des résultats inattendus.

Dans le cas précis de ListFields, la propriété fields de l'objet Describe fournira les informations équivalentes.

AttentionAttention :

Ne définissez pas la valeur d'un paramètre dans updateMessages(), car elle ne sera pas validée par la routine de validation interne.

altered

altered a la valeur True si l'utilisateur a modifié la valeur d'un paramètre, en saisissant un chemin en sortie, par exemple. Lorsqu'un paramètre a été modifié, il le reste jusqu'à ce que l'utilisateur vide (efface) la valeur, auquel cas il revient à son précédent état. La modification d'une valeur à l'aide d'un programme avec un code de validation ne change pas l'état Altered. Autrement dit, si vous définissez une valeur pour un paramètre, l'état Altered du paramètre ne change pas.

La propriété altered permet de déterminer si vous pouvez modifier la valeur d'un paramètre. Supposez par exemple qu'un outil contienne un paramètre de classe d'entités et un paramètre de mot-clé. Si la classe d'entités contient des points ou des polygones, les mots-clés sont RED, GREEN et BLUE et si elle contient des lignes, les mots-clés sont ORANGE, YELLOW, PURPLE et WHITE.

Supposons que l'utilisateur entre une classe d'entités ponctuelles. Si le paramètre de mot-clé est inchangé, vous définissez la valeur sur RED, car c'est la valeur par défaut.

Si une classe d'entités linéaires est entrée, vous définissez la valeur par défaut sur ORANGE tant que le paramètre de mot-clé reste inchangé.

Cependant, si le paramètre de mot-clé a été modifié par l'utilisateur (c'est-à-dire si le mot-clé est défini sur GREEN), vous ne devez pas réinitialiser le mot-clé : l'utilisateur a fait son choix (GREEN) et vous ne connaissez pas son intention, il peut modifier la classe d'entités afin que GREEN soit valide ou modifier le mot-clé (en spécifiant PURPLE, par exemple). Puisque GREEN ne fait pas partie de l'ensemble de mots-clé que vous avez créé pour les lignes, la validation interne marque le paramètre comme contenant une erreur. L'utilisateur a alors deux options : modifier la classe d'entités en entrée ou modifier le mot-clé.

if not self.params[2].altered:
      self.params[2].value = "POINT"

hasBeenValidated

La valeur de hasBeenValidated est False si la valeur d'un paramètre a été modifiée par l'utilisateur depuis le dernier appel de la méthode updateParameters() et de la validation interne. Lorsque la validation interne est appelée, le géotraitement définit automatiquement hasBeenValidated sur True pour chaque paramètre.

hasBeenValidated permet de déterminer si l'utilisateur a modifié une valeur depuis le dernier appel de la méthode updateParameters(). Vous pouvez utiliser cette information pour décider si vous devez effectuer un contrôle du paramètre.

# Set the default distance threshold to 1/100 of the larger of the width
#  or height of the extent of the input features. Do not set if there is no 
#  input dataset yet, or if the input features have already been validated,
#  or the user has set a specific distance (Altered is true).
# 
import string
if self.params[0].value and not self.params[0].hasBeenValidated:
  if not self.params[6].altered: 
    extent = arcpy.Describe(self.params[0].value).extent
    width = extent.width
    height = extent.height
    if width > height:
      self.params[6].value = width / 100
    else:
      self.params[6].value = height / 100

category

Vous pouvez placer les paramètres dans différentes catégories pour réduire la taille de la boîte de dialogue de l'outil. Les Extension ArcGIS Network Analyst outils utilisent des catégories, comme indiqué ci-dessous.

Catégories de paramètre

Puisque vous ne pouvez définir la catégorie qu'une seule fois, définissez-la dans initializeParameters(). La définition des catégories dans updateParameters() n'a aucun effet. Le code ci-dessous montre comment placer les paramètres 4 et 5 dans la catégorie "Options" et les paramètres 6 et 7 dans la catégorie "Advanced".

def initializeParameters(self):
    self.params[4].category = "Options"
    self.params[5].category = "Options"
    self.params[6].category = "Advanced"
    self.params[7].category = "Advanced"

Les catégories sont toujours affichées après les paramètres qui ne sont pas catégorisés. Ne placez pas les paramètres requis dans des catégories, car l'utilisateur pourrait ne pas les voir dans la boîte de dialogue de l'outil.

symbology

La propriété symbology associe un fichier de couche (.lyr) à un paramètre en sortie.

params[2].symbology = "E:/tools/extraction/ToolData/ClassByDist.lyr"

Pour en savoir plus sur la symbologie en sortie

Objet schema

Chaque paramètre de type classe d'entités, table, raster ou espace de travail en sortie dispose d'un objet Schema. Seules les classes d'entités, tables, raster et espaces de travail en sortie disposent d'un objet Schema, tous les autres types n'en ont pas. L'objet Schema est créé par géotraitement. Vous pouvez accéder à cet objet Schema via l'objet Parameter et définir les règles de description de la sortie de votre outil. Une fois les règles de l'objet Schema définies et après le renvoi à partir de la classe ToolValidator, le code de validation interne du géotraitement examine les règles que vous avez définies et actualise la description de la sortie.

Le flux de contrôle est le suivant :

  1. Lors de la première ouverture de la boîte de dialogue de l'outil, initializeParameters() est appelé. Vous définissez les règles statiques (règles qui ne changent pas en fonction des informations saisies par l'utilisateur) pour décrire la sortie. Aucune description en sortie n'est créée à ce moment-là, puisque l'utilisateur n'a spécifié aucune valeur pour les paramètres (à moins d'avoir indiqué des valeurs par défaut).
  2. Une fois que l'utilisateur a interagi d'une manière quelconque avec la boîte de dialogue de l'outil, updateParameters() est appelé.
  3. updateParameters() peut modifier l'objet Schema pour prendre en compte le comportement dynamique qui ne peut pas être déterminé à partir des dépendances de paramètres, comme par exemple l'ajout d'un nouveau champ tel qu'Ajouter un champ.
  4. Après avoir été renvoyées à partir de updateParameters(), les routines de validation internes sont appelées et les règles figurant dans l'objet Schema sont appliquées pour mettre à jour la description des données en sortie.
  5. updateMessages() est alors appelé. Vous pouvez examiner les messages d'avertissement et d'erreur que la validation interne a pu créer et les modifier ou ajouter vos propres messages d'avertissement et d'erreur personnalisés.

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

Nom de la propriété

Valeur(s)

type

Chaîne : "Entité", "Table", "Raster", "Conteneur" (pour les espaces de travail et les jeux de données d'entité) (Propriété en lecture seule)

clone

booléen

featureTypeRule

Chaîne : "AsSpecified", "FirstDependency"

featureType

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

geometryTypeRule

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

geometryType

Chaîne : "Point", "Multi-points", "Polyligne", "Polygone"

extentRule

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

extent

Objet Extent

fieldsRule

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

additionalFields

Liste Python d'objets champ

cellSizeRule

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

cellsize

Double

rasterRule

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

rasterFormatRule

Chaîne : "Img", "Grid"

additionalChildren

Liste Python de jeux de données à ajouter à une structure d'espace de travail

Propriétés des objets Schema

Utilisation de FirstDependency

Plusieurs des règles peuvent être définies sur "FirstDependency", ce qui équivaut à utiliser la valeur du premier paramètre figurant dans la table des dépendances de paramètres définie avec parameter.parameterDependencies. Dans l'exemple de code suivant, le paramètre 2 a deux paramètres dépendants, 0 et 1, et la première dépendance est le paramètre 0.

# Set the dependencies for the output and its schema properties
#
self.params[2].parameterDependencies = [0, 1]

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

type

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

clone

Si cette propriété est true, vous indiquez 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 false. 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 à valeurs multiples (une liste de valeurs), la première valeur de la liste de valeurs multiples est clonée.

  • Si parameter.parameterType est défini sur "Dérivé", une copie exacte est réalisée. C'est le comportement de l'outil Ajouter un champ.
  • Si parameter.parameterType a pour valeur "Requis", une copie exacte est également effectuée, mais le chemin d'accès de catalogue au jeu de données est modifié. Les chemins de catalogue sont constitués de deux parties : l'espace de travail et le nom de base. Par exemple :

    E:/Data/TestData/netcity.gdb/infrastructure/roads

    • Espace de travail = E:/Data/TestData/netcity.gdb/infrastructure
    • Nom de base = roads
    Les règles utilisées pour créer de nouveaux noms en sortie sont les suivantes :
    • Le nom de base est identique au nom de base du premier paramètre en entrée qui contient un jeu de données (pas la première dépendance mais le premier paramètre) auquel est ajouté le nom de l'outil de script (par exemple, roads_MyTool).
    • L'espace de travail est défini sur le paramètre d'environnement d'espace de travail temporaire. S'il est vide, le paramètre d'environnement d'espace de travail actuel est utilisé. S'il est vide, l'espace de travail du premier paramètre en entrée contenant un jeu 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 extentRule, sont définies sur "FirstDependency".

Les deux exemples de code suivants fonctionnent de manière équivalente. Ces deux exemples sont basés sur la façon dont l'outil Découper crée la structure en sortie.

Exemple 1 : définition explicite de toutes les règles
def initializeParameters(self):
    # Set the dependencies for the output and its schema properties
    #  The two input parameters are feature classes.
    #
    self.params[2].parameterDependencies = [0, 1]

    # Feature type, geometry type, and fields all come from the first 
    #  dependency (parameter 0), the input features
    #
    self.params[2].schema.featureTypeRule = "FirstDependency"
    self.params[2].schema.geometryTypeRule = "FirstDependency"
    self.params[2].schema.fieldsRule = "FirstDependency"

    # The extent of the output is the intersection of the input features 
    #  and the clip features (parameter 1)
    #
    self.params[2].schema.extentRule = "Intersection"

    return
Exemple 2 : utilisation de clone pour définir les règles sur FirstDependency, puis remplacement de la règle Extent :
def initializeParameters(self):
    # Set the dependencies for the output and its schema properties
    #  The two input parameters are feature classes.
    #
    self.params[2].parameterDependencies = [0, 1]
    self.params[2].schema.clone = True
    return
    
def updateParameters(self):
    # The only property of the clone that changes is that the extent 
    #  of the output is the intersection of the input features 
    #  and the clip features (parameter 1)
    #
    self.params[2].schema.extentRule = "Intersection"
    return

featureTypeRule

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

Valeur

Description

"AsSpecified"

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

"FirstDependency"

Le type d'entités sera le même que le premier paramètre des dépendances. Si le premier paramètre dépendant est à valeurs multiples (une liste de valeurs), la première valeur de la liste de valeurs multiples est utilisée.

Valeurs featureTypeRule

featureType

Lorsque la propriété featureTypeRule est définie sur "AsSpecified", la valeur dans featureType permet de spécifier le type d'entités de la sortie.

Valeur

Description

"Simple"

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

"Annotation"

La sortie contiendra des entités annotation.

"Dimension"

La sortie contiendra des entités cotations.

Valeurs featureType

geometryTypeRule

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

Valeur

Description

"Unknown"

Il s'agit de l'option par défaut. En règle générale, vous devez être en mesure de déterminer le type de géométrie dans updateParameters() en fonction des valeurs d'autres paramètres. Vous définirez la règle sur "Unknown" uniquement si vous n'avez pas assez d'informations pour déterminer le type de géométrie.

"FirstDependency"

Le type de géométrie est identique à celui du premier paramètre dépendant. Si le premier paramètre dépendant est à valeurs multiples (une liste de valeurs), la première valeur de la liste de valeurs multiples est utilisée.

"Min", "Max"

Examine les géométries de tous les paramètres dépendants et définit le type de géométrie en sortie sur le type minimal ou maximal trouvé. "Min" et "Max" sont définis comme suit :

  • Point et multi-points = 0
  • Polyligne = 1
  • Polygone = 2
Ainsi, si les paramètres dépendants étaient une classe d'entités surfaciques et ponctuelles, le minimum serait le point et le maximum serait le polygone.

"AsSpecified"

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

Valeurs geometryTypeRule

geometryType

Définissez cette propriété sur le type de géométrie à utiliser ("Point", "Multi-points", "Polyligne" ou "Polygone") lorsque geometryTypeRule a la valeur "AsSpecified".

extentRule

Valeur

Description

"AsSpecified"

L'étendue en sortie sera spécifiée dans la propriété extent.

"FirstDependency"

L'étendue en sortie est identique à celle du premier paramètre dépendant. Si le premier paramètre dépendant est à valeurs multiples (une liste de valeurs), la première valeur de la liste de valeurs multiples est utilisée.

"Intersection"

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

"Union"

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

"Environment"

L'étendue en sortie sera calculée d'après le paramètre d'environnement de l'étendue en sortie.

Valeurs extentRule

Exemple

# The extent of the output is the intersection of the input features 
#  and the clip features (the dependent parameters)
#
self.params[2].schema.extentRule = "Intersection"

extent

Définissez cette propriété sur l'étendue à utiliser lorsque extentRule a pour valeur "AsSpecified". Vous pouvez définir l'étendue avec une chaîne séparée par des espaces ou un objet de liste Python à quatre valeurs. La séquence est xmin, ymin, xmax, ymax.

Exemple

self.params[2].schema.extentRule = "AsSpecified"
self.params[2].schema.extent = "123.32 435.8 987.3 567.9"

ou à l'aide d'une liste Python

xmin = 123.32
ymin = 435.8
xmax = 987.3
ext = [xmin, ymin, xmax, 567.9]
self.params[2].schema.extent = ext

fieldsRule

fieldsRule détermine les champs qui existeront sur la table ou la classe d'entités en sortie.

Dans la table ci-dessous, FID correspond à Feature ID (identifiant de l'entité) mais se réfère en réalité au champ ObjectID qui se trouve dans chaque table ou classe d'entités.

Valeur

Description

"None"

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

"FirstDependency"

Les champs en sortie sont identiques à ceux du premier paramètre dépendant. Si le premier paramètre dépendant est à valeurs multiples (une liste de valeurs), la première valeur de la liste de valeurs multiples est utilisée.

"FirstDependencyFIDs"

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

"All"

Tous les champs de la liste de paramètres dépendants seront générés.

"AllNoFIDs"

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

"AllFIDsOnly"

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

Valeurs fieldsRule

Exemple de l'outil Découper utilisant une propriété fieldsRule de valeur "FirstDependency"

def initializeParameters(self):
    # Set the dependencies for the output and its schema properties
    #  The two input parameters are feature classes.
    #
    self.params[2].parameterDependencies = [0, 1]

    # Feature type, geometry type, and fields all come from the first 
    #  dependency (parameter 0), the input features
    #
    self.params[2].schema.featureTypeRule = "FirstDependency"
    self.params[2].schema.geometryTypeRule = "FirstDependency"
    self.params[2].schema.fieldsRule = "FirstDependency"

    # The extent of the output is the intersection of the input features 
    #  and the clip features (parameter 1)
    #
    self.params[2].schema.extentRule = "Intersection"

    return

additionalFields

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

Afficher un exemple d'utilisation de AdditionalFields

cellSizeRule

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

Valeur

Description

"AsSpecified"

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

"FirstDependency"

La taille de 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 alors utilisée. Pour d'autres types de paramètres dépendants, tels que les classes d'entités ou les jeux de données d'entité, l'étendue des données permet de calculer une taille de cellule. Si le premier paramètre dépendant est à valeurs multiples (une liste de valeurs), la première valeur de la liste de valeurs multiples est utilisée.

"Min", "Max"

"Min" signifie que la taille de cellule en sortie est la plus petite taille de cellule des paramètres dépendants. "Max" signifie que c'est la plus grande taille de cellule des paramètres dépendants.

"Environment"

La taille de cellule en sortie est calculée d'après le paramètre d'environnement cellsize.

Valeurs cellSizeRule

cellSize

Définissez cette propriété sur la taille de cellule à utiliser lorsque cellSizeRule a pour valeur "AsSpecified".

rasterRule

Cette propriété détermine le type de données, nombre entier ou réel simple, contenu dans le raster en sortie.

Valeur

Description

"FirstDependency"

Le type de données (nombre entier ou réel simple) est identique à celui du premier paramètre dépendant. Si le premier paramètre dépendant est à valeurs multiples (une liste de valeurs), la première valeur de la liste de valeurs multiples est utilisée.

"Min", "Max"

Le nombre entier est considéré comme étant plus petit que le réel simple. Par exemple, s'il y a deux paramètres dépendants, l'un contenant des nombres entiers et l'autre des réels simples, "Min" crée une sortie de nombres entiers et "Max" une sortie de réels simples.

"Integer"

Le raster en sortie contient des nombres entiers.

"Float"

Le raster en sortie contient des réels simples (nombres fractionnels).

Valeurs rasterRule

rasterFormatRule

Cette propriété détermine le format raster en sortie, "Grid" ou "Img". Le format par défaut est "Img", qui correspond au format ERDAS IMAGINE. "Grid" est le format d'Esri.

Pour en savoir plus sur les données raster

additionalChildren

Un espace de travail est un conteneur de jeux de données (entités, tables et rasters). Ces jeux de données sont les enfants de l'espace de travail (l'espace de travail est considéré comme le parent). Si votre outil ajoute des jeux de données à un nouvel espace de travail ou à un espace de travail 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 (liste à valeurs multiples), les modifie d'une certaine façon, 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 pouvez utiliser cet espace de travail comme entrée de l'outil Sélectionner des données. Cet outil vous permet de sélectionner un jeu de données enfant figurant dans un conteneur et de l'utiliser comme entrée pour un autre outil.

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

Forme

Description

Objet value

Une classe d'entités, une table, un raster, une dimension ou une valeur annotation, comme renvoyé(e) par la propriété value.

Objet Liste Python de la forme [type, nom, champs, étendue, référence spatiale]

Une liste Python qui contient une description de l'enfant à ajouter. Seules les deux premières entrées de la liste, type et nom, sont requises. Les autres arguments sont facultatifs.

Listes de membres pour additionalChildren

Lorsque vous ajoutez plusieurs enfants, vous fournissez une liste de descriptions des enfants. Si vous ajoutez les enfants à l'aide du format d'objet Liste Python, vous créez une liste de listes pour additionalChildren.

Le format Liste Python a cinq arguments, comme décrit dans la table suivante.

Argument

Type

Description

type

requis

Une des valeurs suivantes : "Point", "Multi-points", "Polyligne", "Polygone", "Table", "Raster", "Annotation", "Dimension"

name

requis

Le nom du jeu de données. Cela peut être simplement le nom de base du jeu de données ("streets") ou l'intégralité du chemin d'accès de catalogue ("E:\mydata\test.gdb\infrastructure\streets"). Lorsqu'un chemin d'accès de catalogue complet est fourni, tout est ignoré à l'exception du nom de base ("streets").

champ

facultatif

Une liste Python d'objets champ. Elle contient les champs qui figurent sur l'enfant, s'ils sont connus.

extent

facultatif

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

spatial reference

facultatif

Un objet de référence spatiale.

Contenu de la liste des enfants

Ces arguments doivent être fournis dans l'ordre indiqué. Pour ignorer un argument facultatif, utilisez le mot-clé Python None ou "#".

Voici quelques exemples de la définition d'une structure d'espace de travail. Les exemples sont basés sur un outil de script contenant les arguments suivants :

Nom de paramètre

Propriétés

0

Input feature class

Feature class—input.

1

Input table

Table—input.

2

Input workspace

Workspace—input (un espace de travail existant qui contient les résultats de l'outil).

3

Derived workspace

Espace de travail - Derived output, obtenu à partir de Input_workspace. La structure de cet espace de travail est modifiée pour contenir des enfants supplémentaires.

Exemples de paramètres d'outil

L'outil prend la table et la classe d'entités 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 seulement à illustrer la définition d'une structure d'espace de travail.) Les exemples de code suivants découlent les uns des autres, en commençant par l'utilisation simple de additionalChildren. Si vous choisissez d'implémenter et de tester certains des exemples de code ci-dessous, vous pouvez tester le code à l'aide du modèle indiqué.

Modèle utilisé pour afficher les résultats de la validation

Dans initializeParameters(), l'espace de travail en 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 se prémunir contre la suppression de la dépendance dans les propriétés de l'outil.

class ToolValidator:
  def __init__(self):
     import arcpy 
     self.params = arcpy.GetParameterInfo()

  def initializeParameters(self):
    self.params[3].parameterDependencies = [2]  # input workspace
    self.params[3].schema.clone = True  # Copy all existing contents to output
    return

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

def updateParameters(self):
  inFC = self.params[0].value     # input feature class
  inTable = self.params[1].value  # input table
  inWS = self.params[2].value     # input workspace
  if inFC and inTable and inWS:
    self.params[3].schema.additionalChildren = [inFC, inTable]
  return

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

children = []    # New empty list
children.append(inFC)
children.append(inTable)
children.append(["polygon", "SummaryPolygon"])
self.params[3].schema.additionalChildren = children

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

# Create a field object with the name "Category" and type "Long"
#
newField = arcpy.Field()
newField.name = "Category"
newField.type = "Long"

# Describe the input feature class in order to get its list of fields. The 9.3
#  version of the geoprocessing object returns fields in a Python list, unlike
#  previous versions, which returned fields in an enumerator.
#
desc = arcpy.Describe(inFC)
fieldList = desc.fields

# Add the new field to the list
#
fieldList.append(newField)

# Create a new child based on the input feature class, but with the 
#  additional field added
#
newChild = [desc.shapeType, desc.catalogPath, fieldList,
            desc.extent, desc.spatialReference]

# Now create our list of children and add to the schema
#
children = []
children.append(newChild)
children.append(inTable)
children.append(["polygon", "SummaryPolygon"])
self.params[3].schema.additionalChildren = children

Pour créer des champs pour SummaryPolygon (la nouvelle classe d'entités surfaciques), créez une liste d'objets champ semblable au modèle indiqué dans l'exemple précédent.

Exemple : entrée à valeurs multiples

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

# 0 - input features (multivalue)
# 1 - input workspace
# 2 - derived workspace

class ToolValidator:
  def __init__(self):
     import arcpy 
     self.params = arcpy.GetParameterInfo()

  def initializeParameters(self):
    self.params[2].parameterDependencies = [1]
    self.params[2].schema.clone = True
    return

  def updateParameters(self):
    inVT = self.params[0].value   # multivalue ValueTable
    inWS = self.params[1].value   # WorkSpace

    # Add each feature class to the output workspace. In addition,
    #  add a new field "ProjectID" to each feature class
    #
    if inVT and inWS:
        rowCount = inVT.rowCount  # Number of rows in the MultiValue table
        children = []
        newField = arcpy.Field()
        newField.name = "ProjectID"
        newField.type = "Long"
        for row in range(0, rowCount):
            value = inVT.getValue(row, 0)
            if value:
                d = arcpy.Describe(value)
                fieldList = d.fields

                # Note -- not checking if field already exists
                #
                fieldList.append(newField)

                # Create new child with additional ProjectID field and
                #  add child to list of children
                #
                child = [d.shapeType, d.catalogPath, fieldList]
                children.append(child)            
                      
        self.params[2].schema.additionalChildren = children
    return

  def updateMessages(self):
    return

Objet filter

L'objet filter vous permet de spécifier les choix disponibles pour un paramètre. Par exemple, vous pouvez définir un filtre de champ qui limite les choix uniquement aux champs de texte. Un filtre effectue trois tâches :

Il existe deux façons de spécifier des filtres :

Il existe six types de filtres, comme indiqué dans la table ci-dessous :

Type de filtre

Valeurs

ValueList

Liste de valeurs de type chaîne ou numériques. Utilisé avec des types de données String, Long, Double et Boolean.

Plage

Valeurs minimale et maximale. Utilisé avec les types de données Long et Double.

FeatureClass

Liste des types de classe d'entités autorisés, spécifiés par les valeurs "Point", "Multi-points", "Polyligne", "Polygone", "MultiPatch", "Sphère", "Annotation" et "Dimension". Plusieurs valeurs peuvent être appliquées au filtre.

Fichier

Une liste de suffixes de fichier, par exemple, ".txt", ".e00", ".ditamap".

Champ

Liste des types de champs autorisés, spécifiés par les valeurs "Court", "Entier long", "Réel simple", "Réel double", "Texte", "Date", "OID", "Géométrie", "Blob", "Raster", "GUID", "ID global" et "XML". Plusieurs valeurs peuvent être appliquées au filtre.

Espace de travail

Liste des types d'espace de travail autorisés, spécifiés par les valeurs "FileSystem", "LocalDatabase" et "RemoteDatabase". Plusieurs valeurs peuvent être appliquées.

Type de filtre et valeurs

Propriétés

Propriété

Description

type

Type de filtre (ValueList, Range, FeatureClass, File, Field et Workspace). Vous pouvez définir le type de filtre lorsque vous utilisez des paramètres Long et Double (consultez la remarque ci-dessous). Pour les autres types de paramètres, il existe un seul type de filtre valide, la définition du type pour ces paramètres est donc ignorée. Si vous ne voulez pas filtrer les valeurs, définissez la propriété list sur une liste vide.

list

Liste Python de valeurs pour le filtre. Si vous ne voulez pas filtrer les valeurs, définissez la propriété list sur une liste vide.

Propriétés filter

ValueList

ValueList pour les paramètres String

Pour un paramètre de type String, la liste peut contenir n'importe quel nombre de chaînes. Voici un exemple de définition de la liste de valeurs de chaîne dans initializeParameters(). Le paramètre contient deux options, "NEW_FORMAT" et "OLD_FORMAT".

def initializeParameters(self):
    # Set the fixed list of "file format type" parameter choices and its
    #  default value
    #
    self.params[1].filter.list = ["OLD_FORMAT", "NEW_FORMAT"]
    self.params[1].value = "OLD_FORMAT"
    return

Dans l'exemple précédent, vous auriez également pu facilement définir la liste de valeurs dans l'onglet Paramètres de la boîte de dialogue Propriétés de l'outil. En réalité, si vous aviez défini la liste de valeurs sur une autre valeur (telle que "OLD" et "NEW") dans les propriétés de l'outil, ces valeurs seraient remplacées par "OLD_FORMAT" et "NEW_FORMAT" lorsque la méthode initializeParameters() est appelée. Cela vaut également pour la valeur par défaut : elle peut être définie dans la boîte de dialogue Propriétés de l'outil, puis réinitialisée dans ToolValidator.

RemarqueRemarque :

la liste de valeurs que vous fournissez dans ToolValidator remplace toujours les valeurs définies dans la boîte de dialogue Propriétés de l'outil. Ce comportement vous permet de mettre à jour les valeurs basées sur d'autres paramètres.

En poursuivant avec cet exemple, le code ci-dessous montre updateParameters() modifiant une liste de valeurs dans un autre paramètre si l'utilisateur a sélectionné "OLD_FORMAT" ou "NEW_FORMAT" :

def updateParameters(self):
    # Update the value list filter of the "feature type in file" parameter 
    #   depending on the "file format type" parameter.
    #
    if self.params[1].value.upper() == "OLD_FORMAT":
      self.params[2].filter.list = ["POINT", "LINE", "POLYGON"]
    elif self.params[1].value.upper() == "NEW_FORMAT":
      self.params[2].filter.list = ["POINT", "LINE", "POLYGON", 
                                    "POINT_WITH_ANNO", 
                                    "LINE_WITH_ANNO", 
                                    "POLYGON_WITH_ANNO"]

    # Provide default value for "feature type in file" parameter
    #
    if not self.params[2].altered:
      self.params[2].value = "POINT"

ValueList pour les paramètres Long et Double

Un paramètre Long ou Double peut avoir une liste de valeurs numériques. L'utilisateur peut sélectionner ou saisir des valeurs qui sont dans la liste.

# Set filter for a Long parameter
#
self.params[7].filter.list = [10, 20, 30, 40, 50]

# Set filter for a Double parameter
#
self.params[8].filter.list = [10.0, 12.5, 15.0]

ValueList pour les paramètres Boolean

Il existe deux valeurs pour un paramètre booléen : la valeur true et la valeur false. La valeur True est toujours la première valeur dans la liste.

def initializeParameters(self):
  # Set the Boolean choice for including or excluding angles
  #
  self.params[6].filter.list = ["ANGLE", "NO_ANGLE"]

  # Set the default value to false (no angle)
  #
  self.params[6].value = "NO_ANGLE"
  return

def updateParameters(self):
  # Enable angle format parameter if user wants angles
  #
  if self.params[6].value.upper() == "ANGLE":
    self.params[7].enabled = True

Plage

Un paramètre Long ou Double peut avoir un filtre Plage. Les filtres Plage ont deux valeurs, une valeur minimale et une valeur maximale. La première valeur de la liste est la valeur minimale. La plage est inclusive, les valeurs minimale et maximale sont donc des choix valides.

def initializeParameters(self):
  # Utility values must be between -10 and 10.
  #
  self.params[7].filter.list = [-10, 10]

Définition du type de filtre sur les paramètres long et double

Pour les paramètres Long et Double, le type de filtre par défaut est ValueList. Si vous voulez que ce soit un filtre Plage, définissez le type de filtre dans initializeParameters(), comme suit :

def initializeParameters(self):
  # Set the 'score' value parameters to a range filter
  #
  self.params[7].filter.type = "Range"
  self.params[7].filter.list = [-10, 10]

Vous pouvez uniquement définir le type de filtre pour les paramètres Long et Double.

FeatureClass

L'exemple suivant montre comment définir le type d'entités d'un paramètre en entrée selon le type d'entités d'un autre paramètre en entrée.

def updateParameters(self):
    # Set the input feature type of the second parameter based
    #  on the feature type of the first parameter.
    #
    if self.params[0].value:
      desc = arcpy.Describe(self.params[0].value)
      feature_type = desc.shapeType.lower()

      if feature_type == "polygon":
        self.params[1].filter.list = ["point", "multipoint"]

      elif feature_type == "polyline":
        self.params[1].filter.list = ["polygon"]
      
      elif feature_type == "point" or \
           feature_type == "multipoint":
        self.params[1].filter.list = ["polyline"]

      else:
        self.params[1].filter.list = []
      
    return

Fichier

Le filtre de fichier contient une liste des suffixes acceptés par un fichier, tels que ".txt" (fichier texte simple) et ".csv" (valeurs séparées par des virgules). Le suffixe peut être n'importe quel texte : il n'a pas besoin d'être reconnu par ArcGIS. La longueur du suffixe est illimitée et les points ne sont pas acceptés. L'exemple suivant montre comment définir le filtre pour un paramètre File en entrée.

def initializeParameters(self):
  # Set the input file type to our recognized options file suffixes
  #
  self.params[0].filter.list = ["opt56", "opt57", "globalopt"]
  return

Champ

Le filtre de champ définit les types de champs autorisés. Les valeurs peuvent être les suivantes : "Court", "Entier long", "Flottant", "Réel simple", "Réel double", "Texte", "Date", "OID", "Géométrie", "Blob", "Raster", "GUID", "ID global" et "XML".

Nom complet et nom interne

Il existe quatre types de champs qui ont un nom interne, comme indiqués dans la table ci-dessous.

Nom complet

Nom interne

Court

SmallInteger

Long

Entier

Flottant

Single

Texte

Chaîne

Alias du filtre de champ

Lorsque vous spécifiez un filtre de champ, vous pouvez utiliser le nom complet ou le nom interne. Autrement dit, les deux lignes de code suivantes sont équivalentes :

self.params[1].filter.list = ["short", "long", "float", "text"]
self.params[1].filter.list = ["smallinteger", "integer", "single", "string"]

Si vous fournissez le nom complet, tel que "short", il est converti et stocké dans le filtre comme "SmallInteger". Vous n'aurez que rarement besoin d'accéder aux valeurs dans le filtre de champ, mais, le cas échéant, souvenez-vous que le nom interne est stocké. L'extrait de code suivant vous montre un exemple :

self.params[1].filter.list = ["short", "long"]
# 
if self.params[1].filter.list[0].lower() == "smallinteger":
  # do something

Définition d'une valeur de champ par défaut

Vous pouvez fournir une valeur par défaut pour un paramètre de champ. Pour ce faire, parcourez les champs sur la table en entrée et sélectionnez le premier champ qui correspond au filtre, comme suit :

def initializeParameters(self):
  self.params[1].filter.list = ["short", "long", "float", "double"]
  return

def updateParameters(self):
  if self.params[0].value and not self.params[1].altered:
    self.params[1].value = ""
    desc = arcpy.Describe(self.params[0].value)
    fields = desc.fields

    # Set default to the first field that matches our filter
    #
    for field in fields:
      fType = field.type.lower()
      if fType in ["smallinteger", "integer", "single", "double"]:
        self.params[1].value = field.name
        break
  return
AttentionAttention :

n'utilisez pas la fonction de géotraitement ListFields dans ToolValidator. Utilisez plutôt la fonction Describe comme indiqué ci-dessus.

Espace de travail

Le filtre d'espace de travail spécifie les types d'espaces de travail en entrée autorisés. Trois valeurs sont disponibles :

Filtre Espace de travail

Description

"FileSystem"

Un dossier système utilisé pour stocker des fichiers de formes, des couvertures, des tables INFO et des grilles

"LocalDatabase"

Une géodatabase fichier ou personnelle

"RemoteDatabase"

Une connexion à une base de données ArcSDE

Thèmes connexes

5/10/2014