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.
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. |
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. |
Lecture/écriture | Liste Python | Liste des index de chaque paramètre dépendant. | |
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). |
Lecture seule | booléen | Valeur True si l'utilisateur a modifié la valeur. | |
Lecture seule | booléen | Valeur True si la routine de validation interne a vérifié le paramètre. | |
Lecture/écriture | Chaîne | Catégorie du paramètre. | |
Lecture seule | Objet GP Schema | Structure du jeu de données en sortie. | |
Lecture seule | Objet GP Filter | Filtre à appliquer aux valeurs dans le paramètre. | |
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. |
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. |
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)
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 ArcGIS Network Analyst outils utilisent des catégories, comme indiqué ci-dessous.
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"
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 :
- 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).
- Une fois que l'utilisateur a interagi d'une manière quelconque avec la boîte de dialogue de l'outil, updateParameters() est appelé.
- 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.
- 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.
- 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 |
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
- 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. |
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. |
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 :
|
"AsSpecified" | Le type de géométrie sera déterminé par la valeur de la propriété geometryType. |
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. |
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. |
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.
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. |
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). |
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.
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. |
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. |
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. |
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é.
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 :
- Un filtre présente uniquement à l'utilisateur les choix valides lors de la recherche de données. Si vous définissez votre filtre pour les classes d'entités ponctuelles, seules les classes d'entités ponctuelles sont montrées à l'utilisateur lors de la recherche de données. Si vous définissez votre filtre pour les champs de texte, la liste déroulante des champs affiche uniquement les champs de texte.
- Si un utilisateur saisit une valeur de paramètre (plutôt que de sélectionner une valeur dans la liste ou l'explorateur de fichiers), la valeur est comparée au filtre. Si l'utilisateur saisit une valeur incorrecte (un champ numérique au lieu d'un champ de texte, par exemple), un avertissement ou une erreur est automatiquement générée.
- Les valeurs étant comparées à leur filtre par validation interne, un filtre vous évite de devoir programmer votre propre validation personnalisée dans la classe ToolValidator.
Il existe deux façons de spécifier des filtres :
- Dans l'onglet Paramètres de la boîte de dialogue des propriétés de l'outil, cliquez sur le paramètre, puis cliquez sur la cellule située en regard de Filter et sélectionnez le type de filtre dans la liste déroulante. Après avoir sélectionné le type de filtre, une boîte de dialogue s'ouvre, dans laquelle vous spécifiez les valeurs pour le filtre.
- Vous pouvez définir les valeurs à l'aide d'un programme dans une classe ToolValidator (voir les exemples ci-dessous). Le géotraitement crée automatiquement des filtres pour les paramètres de type chaîne, long, double, classe d'entités, fichier, champ et espace de travail. Même si vous ne sélectionnez pas de filtre dans la boîte de dialogue des propriétés de l'outil, il y a toujours un filtre associé au paramètre, mais il est vide. Un filtre vide équivaut à n'avoir aucun filtre. En ajoutant des valeurs à un filtre vide, vous activez le filtre, et les choix de l'utilisateur sont limités par le contenu du filtre.
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. |
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. |
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.
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 |
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
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 |