Régulariser l’emprise de bâtiment (3D Analyst)

Résumé

Normalise l'emprise des polygones représentant un bâtiment en éliminant les artefacts indésirables dans leur géométrie.

Illustration

Régulariser l'emprise de bâtiment

Utilisation

  • Cet outil utilise un algorithme de compression polyligne pour corriger les distorsions issues de la création des polygones d’emprise à l’aide de processus d’extraction d’entité qui peuvent générer des artefacts indésirables.

  • Si vos emprises de bâtiment contiennent des structures circulaires, traitez ces entités en premier. Un ratio de compacité permet d'identifier les bâtiments circulaires. Pour calculer cette valeur, procédez comme suit :

    1. Ajoutez un champ de type double.
    2. Utilisez le calculateur de champs pour la formule suivante :
      (4 * 3.14159265358979 * !shape.area!) / !shape.length! ** 2
    3. Un cercle parfait aura la valeur 1 ; néanmoins, comme les polygones généralement traités avec cet outil présentent des irrégularités, les valeurs plus proches de 1 sont davantage susceptibles d’avoir une forme circulaire. Évaluez vos résultats pour identifier la valeur minimum d’un bâtiment circulaire et sélectionnez les valeurs supérieures ou égales à cette valeur avant d’exécuter l’outil avec la méthode Circle (Cercle).
  • Envisagez d’utiliser la méthode Any Angle (Angle quelconque) si les emprises de bâtiment représentent des géométries avec des tronçons qui forment un ensemble d’angles incluant, sans s’y limiter, des virages à 45° et 90°. Commencez par sélectionner un sous-ensemble d’entités contenant des tronçons irréguliers et recherchez la valeur de pénalité diagonale qui donne le résultat souhaité. Si le résultat ne capture pas les tronçons diagonaux de manière adéquate, envisagez de modifier la valeur de tolérance afin de contraindre la zone de régularisation et de diminuer de manière incrémentielle la pénalité diagonale. Si la sortie inclut des tronçons indésirables avec des angles intérieurs aigus, exécutez l’outil de façon itérative tout en augmentant la pénalité diagonale par incréments jusqu’à obtenir la sortie souhaitée, puis utilisez cette valeur pour traiter l’intégralité du jeu de données.

  • Lorsque vous utilisez la méthode Any Angles (Angles quelconques) sur un ordinateur doté d’une carte graphique NVIDIA prenant en charge l’architecture CUDA et avec plus de 2 Go de mémoire, l’outil utilisera le GPU pour effectuer cette opération. Vous pouvez modifier ce comportement via le paramètre d’environnement Processor Type (Type de processeur). S’il existe plusieurs GPU, le GPU souhaité peut être spécifié grâce au paramètre d’environnement GPU ID (ID de GPU).

  • Lorsque les paramètres spécifiés ne peuvent pas générer de solution régularisée pour une entrée donnée, l'entité d'origine est copiée dans la sortie. La valeur spécifiée dans le champ STATUS indique si l’entité a été régularisée comme suit :

    • 0 : entité régularisée
    • 1 : entité d’origine

Syntaxe

RegularizeBuildingFootprint(in_features, out_feature_class, method, tolerance, densification, precision, diagonal_penalty, min_radius, max_radius)
ParamètreExplicationType de données
in_features

Polygones représentant les emprises de bâtiment à régulariser.

Feature Layer
out_feature_class

Classe d'entités qui va être produite par cet outil.

Feature Class
method

Méthode de régularisation à utiliser pour le traitement des entités en entrée.

  • RIGHT_ANGLESConstruit des formes composées d’angles à 90° entre des tronçons adjacents.
  • RIGHT_ANGLES_AND_DIAGONALSConstruit des formes composées d’angles à 45° et 90° entre des tronçons adjacents.
  • ANY_ANGLEConstruit des formes qui créent des angles quelconques entre des tronçons adjacents.
  • CIRCLEConstruit le cercle le plus adapté autour des entités en entrée.
String
tolerance

Distance maximale selon laquelle l'emprise régularisée peut s'écarter de la limite de son entité d'origine. La valeur spécifiée repose sur les unités linéaires du système de coordonnées de l'entité en entrée.

Double
densification

Intervalle d'échantillonnage qui permet de déterminer si l'entité régularisée est droite ou courbée. La densification doit être égale ou inférieure à la valeur de tolérance.

Ce paramètre est uniquement utilisé avec des méthodes prenant en charge l'identification des angles droits.

Double
precision

Précision de la grille spatiale utilisée au cours du processus de régularisation. Les valeurs correctes sont comprises entre 0.05 et 0.25.

Double
diagonal_penalty

Si vous utilisez la méthode RIGHT_ANGLES_AND_DIAGONALS, cette valeur dicte la probabilité de créer des angles droits ou des tronçons diagonaux entre deux segments adjacents. Si vous utilisez la méthode ANY_ANGLES, cette valeur dicte la probabilité de créer des tronçons diagonaux qui ne sont pas conformes aux tronçons préférés déterminés par l’algorithme de l’outil. Généralement, plus la valeur est élevée, plus il devient improbable qu’un tronçon diagonal soit créé.

Double
min_radius

Plus petit rayon autorisé pour un cercle régularisé. La valeur 0 indique qu'aucune limite de taille minimum n'est imposée. Cette option est uniquement disponible avec la méthode CIRCLE.

Double
max_radius

Plus grand rayon autorisé pour un cercle régularisé. Cette option est uniquement disponible avec la méthode CIRCLE.

Double

Exemple de code

Exemple 1 d'utilisation de l'outil RegularizeBuildingFootprint (fenêtre Python)

L'exemple suivant illustre l'utilisation de cet outil dans la fenêtre Python.

arcpy.env.workspace = 'c:/data'
arcpy.ddd.RegularizeBuildingFootprint('rough_footprints.shp', 
                                      'regularized_footprints.shp',
                                      method='Circle', tolerance=1.5, min_radius=10, 
                                      max_radius=20)
Exemple 2 d'utilisation de l'outil RegularizeBuildingFootprint (script autonome)

L'exemple suivant illustre l'utilisation de cet outil dans un script Python autonome.

'''****************************************************************************
       Name: Classify Lidar & Extract Building Footprints
Description: Extract footprint from lidar points classified as buildings, 
             regularize its geometry, and calculate the building height.

****************************************************************************'''
import arcpy

lasd = arcpy.GetParameterAsText(0)
dem = arcpy.GetParameterAsText(1)
footprint = arcpy.GetParameterAsText(2)

try:
    desc = arcpy.Describe(lasd)
    if desc.spatialReference.linearUnitName in ['Foot_US', 'Foot']:
        unit = 'Feet'
    else:
        unit = 'Meters'
    ptSpacing = desc.pointSpacing * 2.25
    sampling = '{0} {1}'.format(ptSpacing, unit)
    # Classify overlap points
    arcpy.ddd.ClassifyLASOverlap(lasd, sampling)
    # Classify ground points
    arcpy.ddd.ClassifyLasGround(lasd)
    # Filter for ground points
    arcpy.management.MakeLasDatasetLayer(lasd, 'ground', class_code=[2])
    # Generate DEM
    arcpy.conversion.LasDatasetToRaster('ground', dem, 'ELEVATION', 
                                        'BINNING NEAREST NATURAL_NEIGHBOR', 
                                        sampling_type='CELLSIZE', 
                                        sampling_value=desc.pointSpacing)
    # Classify noise points
    arcpy.ddd.ClassifyLasNoise(lasd, method='ISOLATION', edit_las='CLASSIFY', 
                               withheld='WITHHELD', ground=dem, 
                               low_z='-2 feet', high_z='300 feet', 
                               max_neighbors=ptSpacing, step_width=ptSpacing, 
                               step_height='10 feet')
    # Classify buildings
    arcpy.ddd.ClassifyLasBuilding(lasd, '7.5 feet', '80 Square Feet')
    #Classify vegetation
    arcpy.ddd.ClassifyLasByHeight(lasd, 'GROUND', [8, 20, 55], 
                                  compute_stats='COMPUTE_STATS')
    # Filter LAS dataset for building points
    lasd_layer = 'building points'
    arcpy.management.MakeLasDatasetLayer(lasd, lasd_layer, class_code=[6])
    # Export raster from lidar using only building points
    temp_raster = 'in_memory/bldg_raster'
    arcpy.management.LasPointStatsAsRaster(lasd_layer, temp_raster,
                                           'PREDOMINANT_CLASS', 'CELLSIZE', 2.5)
    # Convert building raster to polygon
    temp_footprint = 'in_memory/footprint'
    arcpy.conversion.RasterToPolygon(temp_raster, temp_footprint)
    # Regularize building footprints
    arcpy.ddd.RegularizeBuildingFootprint(temp_footprint, footprint, 
                                          method='RIGHT_ANGLES')

except arcpy.ExecuteError:
    print(arcpy.GetMessages())

Informations de licence

  • Basic: Requiert 3D Analyst
  • Standard: Requiert 3D Analyst
  • Advanced: Requiert 3D Analyst

Rubriques connexes