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, 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, getParameterInfo 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", "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
#
parameters[2].parameterDependencies = [parameters[0].name, parameters[1].name]
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 getParameterInfo. 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 « Derived » (« 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 « Required » (« 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 (Vrai), 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
class ExampleClipTool1(object):
def __init__(self):
self.label = "Example Clip tool 1"
self.description = "Explicitly setting all rules"
def getParameterInfo(self):
# Input feature class
param0 = arcpy.Parameter(
displayName="Input Features",
name="in_features",
datatype="GPFeatureLayer",
parameterType="Required",
direction="Input")
# Input table
param1 = arcpy.Parameter(
displayName="Clip Features",
name="clip_features",
datatype="GPFeatureLayer",
parameterType="Required",
direction="Input")
# Input workspace
param2 = arcpy.Parameter(
displayName="Output Feature Class",
name="out_feature_class",
datatype="DEFeatureClass",
parameterType="Required",
direction="Output")
# Set the dependencies for the output and its schema properties
# The two input parameters are feature classes.
#
param2.parameterDependencies = [param0.name, param1.name]
# Feature type, geometry type, and fields all come from the first
# dependency (parameter 0), the input features
#
param2.schema.featureTypeRule = "FirstDependency"
param2.schema.geometryTypeRule = "FirstDependency"
param2.schema.fieldsRule = "FirstDependency"
# The extent of the output is the intersection of the input features
# and the clip features (parameter 1)
#
param2.schema.extentRule = "Intersection"
params = [param0, param1, param2]
return params
Exemple 2 : utilisation de clone pour définir les règles sur FirstDependency, puis remplacement de la règle Extent :
class ExampleClipTool2(object):
def __init__(self):
self.label = "Example Clip tool 2"
self.description = "Using clone to set rules to FirstDependency, then overriding the extent rule"
def getParameterInfo(self):
# Input feature class
param0 = arcpy.Parameter(
displayName="Input Features",
name="in_features",
datatype="GPFeatureLayer",
parameterType="Required",
direction="Input")
# Input table
param1 = arcpy.Parameter(
displayName="Clip Features",
name="clip_features",
datatype="GPFeatureLayer",
parameterType="Required",
direction="Input")
# Input workspace
param2 = arcpy.Parameter(
displayName="Output Feature Class",
name="out_feature_class",
datatype="DEFeatureClass",
parameterType="Required",
direction="Output")
# Set the dependencies for the output and its schema properties
# The two input parameters are feature classes.
#
param2.parameterDependencies = [param0.name, param1.name]
param2.schema.clone = True
params = [param0, param1, param2]
return params
def updateParameters(self, parameters):
# 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)
#
parameters[0].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)
#
parameters[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
parameters[2].schema.extentRule = "AsSpecified"
parameters[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]
parameters[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. |
additionalFields
Outre les champs ajoutés par l’application de fieldsRule, vous pouvez ajouter des champs supplémentaires à la sortie. additionalFields. Utilise 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 classes d’entités, 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 Sélectionner des données vous permet de sélectionner un jeu de données enfant figurant dans un container 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"). |
fields | facultative | Une liste Python d’objets champ. Elle contient les champs qui figurent sur l'enfant, s'ils sont connus. |
extent | facultative | Une chaîne ou une liste Python contenant l'étendue spatiale de l'enfant. |
spatial reference | facultative | 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 | Classe d'entités en entrée | Feature class—input. |
1 | Table en entrée | 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 getParameterInfo, l'espace de travail en sortie est cloné à partir de son paramètre dépendant (param2).
class ExampleTool(object):
def __init__(self):
self.label = "Example tool"
self.description = "Example of parameter dependencies"
def getParameterInfo(self):
#Define parameter definitions
# Input feature class
param0 = arcpy.Parameter(
displayName="Input feature class",
name="in_features",
datatype="GPFeatureLayer",
parameterType="Required",
direction="Input")
# Input table
param1 = arcpy.Parameter(
displayName="Input table",
name="in_table",
datatype="GPTableView",
parameterType="Required",
direction="Input")
# Input workspace
param2 = arcpy.Parameter(
displayName="Input workspace",
name="in_workspace",
datatype="DEWorkspace",
parameterType="Required",
direction="Input")
# Derived workspaces
param3 = arcpy.Parameter(
displayName="Derived workspace",
name="out_workspace",
datatype="DEWorkspace",
parameterType="Derived",
direction="Output")
# Set dependencies to the input workspace parameter
param3.parameterDependencies = [param0.name]
# Copy all existing contents to output
param3.schema.clone = True
params = [param0, param1, param2, param3]
return params
Exemple : copiez les deux entrées (aucune modification) dans l’espace de travail en sortie :
def updateParameters(self, parameters):
inFC = parameters[0].value # input feature class
inTable = parameters[1].value # input table
inWS = parameters[2].value # input workspace
if inFC and inTable and inWS:
parameters[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").
def updateParameters(self, parameters):
children = [] # New empty list
children.append(parameters[0].value)
children.append(parameters[1].value)
children.append(["polygon", "SummaryPolygon"])
parameters[3].schema.additionalChildren = children
return
Exemple : ajoutez un champ à la classe d’entités en entrée.
def updateParameters(self, parameters):
# 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(parameters[0].value)
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"])
parameters[3].schema.additionalChildren = children
return
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
def updateParameters(self, parameters):
inVT = parameters[0].value # multivalue ValueTable
inWS = parameters[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 # Row count in 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)
parameters[2].schema.additionalChildren = children
return