Mise à jour du schéma dans une boîte à outils Python

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 :

  1. 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).
  2. Une fois que l'utilisateur a interagi d'une manière quelconque avec la boîte de dialogue de l'outil, updateParameters est appelé.
  3. updateParameters peut modifier l'objet Schema pour prendre en compte le comportement dynamique qui ne peut pas être déterminé à partir des dépendances de paramètres, comme par exemple l'ajout d'un nouveau champ tel qu'Ajouter un champ.
  4. Après avoir été renvoyées à partir 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.
  5. updateMessages est alors appelé. Vous pouvez examiner les messages d'avertissement et d'erreur que la validation interne a pu créer et les modifier ou ajouter vos propres messages d'avertissement et d'erreur personnalisés.

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

Nom de la propriété

Valeur(s)

type

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

clone

Booléen

featureTypeRule

Chaîne : "AsSpecified", "FirstDependency"

featureType

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

geometryTypeRule

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

geometryType

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

extentRule

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

extent

Objet Extent

fieldsRule

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

additionalFields

Liste Python d'objets champ

cellSizeRule

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

cellsize

Double

rasterRule

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

rasterFormatRule

Chaîne : "Img", "Grid"

additionalChildren

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

Propriétés des objets Schema

Utilisation de FirstDependency

Plusieurs des règles peuvent être définies sur "FirstDependency", ce qui équivaut à utiliser la valeur du premier paramètre figurant dans la table des dépendances de paramètres dé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
#
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.

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

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.

"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)
#
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.

Valeurs de fieldsRule

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.

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.

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 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

Thèmes connexes

9/12/2013