Desktop Help 10.0 - 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é symbologie.

  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.

Remarque :

la liste des paramètres démarre à 0, la position zéro est donc attribuée au premier paramètre de la liste. Ainsi, 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.
valeur	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.
structure	Lecture seule	Objet GP Schema	Structure du jeu de données en sortie.
filtrer	Lecture seule	Objet GP Filter	Filtre à appliquer aux valeurs dans le paramètre.
d'origine	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. Reportez-vous aux méthodes 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]

valeur

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 (afficher un exemple).

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.

Une valeur est un objet avec une représentation de chaîne. 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 == "Get Spatial Weights From File":
      self.params[8].enabled = True
  else:
      self.params[8].enabled = False

Le test dans le code ci-dessus ne fonctionnerait pas si le type de données du paramètre était une classe d'entités ou toute valeur représentant un jeu de données. Les valeurs qui représentent des données sur le disque, telles que les classes d'entités et les rasters, doivent être converties en chaînes avant d'effectuer des opérations de chaînes. La fonction str intégrée de Python convertit les objets Value en chaînes, comme suit :

  if str(self.params[0].value) == "E:/data/example.gdb/roads":

Il vous suffit d'utiliser la fonction str pour les valeurs avec des types de données qui représentent des jeux de données. Pour ces types de valeurs, la fonction str renvoie le chemin d'accès de catalogue au jeu de données. Il n'est pas nécessaire d'utiliser cette fonction pour d'autres types de données, tels que les unités linéaires ou longues, puisque ces types de données ne représentent pas de jeux de données et sont automatiquement convertis en chaînes.

Attention :

lors de l'utilisation de la méthode Describe() de géotraitement dans ToolValidator, n'utilisez jamais la représentation de chaîne de la valeur.

Incorrect (fonction str utilisée) :

  desc = arcpy.Describe(str(self.params[0].value))

Correct : (fonction str non utilisée)

  desc = arcpy.Describe(self.params[0].value)

Vous ne devez pas utiliser la représentation de chaîne pour les jeux de données (qui détermine le chemin d'accès de catalogue au jeu de données) car le jeu de données peut ne pas exister : il peut être une variable de modèle, et le modèle doit être exécuté avant que le jeu de données existe sur le disque. Si vous utilisez la représentation de chaîne pour le jeu de données, la fonction Describe peut échouer si le jeu de données n'existe pas encore sur le disque.

Attention :

n'utilisez pas les méthodes d'objet de géotraitement qui utilisent un chemin d'accès de catalogue, telles que ListFields, dans ToolValidator. 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. (Dans le cas de ListFields, vous pouvez utiliser la propriété fields de l'objet Describe à la place.)

Lorsque vous testez l'équivalence des chaînes, vous devez utiliser des comparaisons insensibles à la casse. Le code suivant montre l'utilisation de la fonction Python lower pour écrire le type de forme d'une classe d'entités en minuscules et comparer les chaînes en minuscules. (Vous pouvez également utiliser la fonction upper pour comparer des chaînes en majuscules.)

  fc = self.params[0].value
  shapetype = arcpy.Describe(fc).shapeType.lower()
    if shapetype == "point" or shapetype == "multipoint":

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

d'origine

La propriété symbology associe un fichier de couches (.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 :

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 d'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", "FirstDependencyFIDsOnly", "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éfini 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 a pour valeur "Dérivé", une copie exacte est effectué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 de 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 de 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, tel que dans initializeParameters().
"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 de 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 de 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.
"FirstDependencyFIDsOnly"	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 de 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 de 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 de 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. Exemple : inFeatures = self.params[0].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.

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. Exemple :

inFeatures = self.params[0].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 ("SummaryPoly") 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.

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.
liste	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é

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.

liste

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 de l'objet 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 initializeParameters() est appelé. 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.

Remarque :

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", "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
Entier long	Entier
Flottant	Simple
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 == "smallinteger" or \
               fType == "integer" or \
               fType == "single" or \
               fType == "double":
                self.params[1].value = field.name
                break
    return

Attention :

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 :

" FileSystem"
Un dossier système utilisé pour stocker des fichiers de formes, des couvertures ArcInfo, des tables INFO et des grilles
" LocalDatabase"
Une géodatabase fichier ou personnelle
" RemoteDatabase"
Une connexion à une base de données ArcSDE

7/10/2012

Programmation d'une classe ToolValidator

Objet Parameter

Accès aux paramètres de l'outil

Ordre des paramètres

Méthodes

Propriétés

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

parameterDependencies

valeur

altered

hasBeenValidated

category

d'origine

Objet Schema

Utilisation de FirstDependency

type

clone

featureTypeRule

featureType

geometryTypeRule

geometryType

extentRule

extent

fieldsRule

additionalFields

cellSizeRule

cellSize

rasterRule

rasterFormatRule

additionalChildren

Objet filter

Propriétés

ValueList

ValueList pour les paramètres String

ValueList pour les paramètres Long et Double

ValueList pour les paramètres Boolean

Plage

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

FeatureClass

Fichier

Champ

Nom complet et nom interne

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

Espace de travail