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

Résumé

Régularise les emprises de bâtiment ayant des limites communes.

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.

  • Lors de la régularisation d’emprises de bâtiment dérivées de données raster, la tolérance de régularisation doit être plus élevée que la résolution du raster source.

  • Les entités ayant des limites adjacentes doivent avoir une valeur attributaire commune afin de créer une limite régularisée qui ne recouvre pas une autre entité. Si aucun attribut commun n’est disponible, suivez les étapes suivantes :

    1. Utilisez l’outil Buffer (Zone tampon) avec une distance de zone tampon qui corresponde à la tolérance de régularisation souhaitée.
    2. Traitez les entités surfaciques bufférisées à l’aide de l’outil Union (Agréger) afin de créer une seule entité pour les polygones qui se superposent.
    3. Utilisez l’outil Spatial Join (Jointure spatiale) pour ajouter l’ID unique des polygones agrégés aux entités en entrée d’origine qui seront régularisées.
    4. Exécutez l’outil Regularize Adjacent Building Footprint (Régulariser l’emprise de bâtiment adjacente) avec le champ contenant l’ID unique spécifié dans Grouping Field (Champ de regroupement) (paramètre group dans Python).
  • Envisagez d’utiliser la méthode Any Angles (Tous les angles) pour les entités en entrée constituées d’angles intérieurs aigus ou réflexes, ou lorsque la courbure angulaire entre deux segments ne tombe pas sur un intervalle à 45 ° entre 90 ° et 180 °.

  • 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

RegularizeAdjacentBuildingFootprint(in_features, group, out_feature_class, method, tolerance, precision, angular_limit)
ParamètreExplicationType de données
in_features

Entités en entrée à traiter.

Feature Layer
group

Le champ utilisé pour déterminer si les entités partagent des limites coïncidentes, non superposées.

Field
out_feature_class

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

Feature Class
method

La méthode utilisée pour régulariser les entités en entrée.

  • RIGHT_ANGLESIdentifie les meilleurs segments de ligne qui correspondent aux sommets des entités en entrée selon des angles de 90 ° et 180 °.
  • RIGHT_ANGLES_AND_DIAGONALSIdentifie les meilleurs segments de ligne qui correspondent aux sommets des entités en entrée selon des angles intérieurs de 90°, 135 ° et 180 °.
  • ANY_ANGLESIdentifie la ligne de compromis quel que soit l’angle suivi tout en réduisant le nombre total de sommets 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.

Linear Unit
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
angular_limit

L’écart maximum par rapport aux angles intérieurs de la ligne de compromis qui sera toléré lors de l’utilisation de la méthode Right Angles and Diagonals (Angles droits et diagonales) (RIGHT_ANGLES_AND_DIAGONALS). Pour de meilleurs résultats, cette valeur doit rester inférieure à 5 °. Ce paramètre est désactivé pour les autres méthodes de régularisation.

Double

Exemple de code

Exemple 1 d’utilisation de l’outil RegularizeAdjacentBuildingFootprint (fenêtre Python)

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

arcpy.env.workspace = 'c:/data'
arcpy.ddd.RegularizeAdjacentBuildingFootprint('rough_footprints.shp', 'Block_ID',
                                              'regularized_footprints.shp', 
                                              'RIGHT_ANGLES_AND_DIAGONALS', 
                                              '2 Meters', 0.10)
Exemple 2 d’utilisation de l’outil RegularizeAdjacentBuildingFootprint (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