# Regularize Building Footprint

## Summary

Normalizes the footprint of building polygons by eliminating undesirable artifacts in their geometry.

## Usage

• This tool utilizes a polyline compression algorithm to correct distortions in building footprint polygons created through feature extraction workflows that may produce undesirable artifacts.

• The tolerance value defines the region surrounding the polygon's boundary that the regularized polygon must fit into. This region can best be visualized by converting the polygon's boundary to a line feature, and then buffering the line by the desired tolerance distance.

• If your building footprints contain circular structures, those features should be processed first. A compactness ratio can be used to identify circular buildings. To calculate this value, do the following:

1. Add a field of type double.
2. Use the field calculator to compute the following formula:
``(4 * 3.14159265358979 * !shape.area!) / !shape.length! ^ 2``
3. A perfect circle will have a value of 1, but since the polygons typically processed with this tool have some irregularity, values closer to 1 are more likely to have a circular shape. Evaluate your results to identify the minimum value of a circular building and select values greater than or equal to this value prior to executing this tool with the CIRCLE method.
• When the specified parameters cannot produce a regularized solution for a given input, the original feature is copied to the output. The value specified in the STATUS field will indicate whether the feature was regularized or not:

• 0—Regularized feature
• 1—Original feature
##### Note:

If your output contains features that could not be regularized, consider iteratively running the tool by selecting the unprocessed features and altering the parameters to identify a solution. Background imagery can be very helpful for evaluating the accuracy of the regularized output.

## Syntax

`RegularizeBuildingFootprint_3d (in_features, out_feature_class, method, tolerance, densification, precision, diagonal_penalty, min_radius, max_radius)`
 Parameter Explanation Data Type in_features The polygons that represent the building footprints to be regularized. Feature Layer out_feature_class The feature class that will be produced by this tool. Feature Class method The regularization method to be used in processing the input features. RIGHT_ANGLES —Useful for building footprints that are primarily defined by right anglesRIGHT_ANGLES_AND_DIAGONALS —Useful for buildings footprints that are comprised of right angles and diagonal sidesANY_ANGLE —Useful for buildings with highly irregular footprintsCIRCLE —Useful for buildings with circular characteristics, like grain silos and water towers String tolerance The maximum distance that the regularized footprint can deviate from the boundary of its originating feature. The specified value will be based on the linear units of the input feature's coordinate system. Double densification The sampling interval that will be used to evaluate whether the regularized feature will be straight or bent. The densification must be equal to or less than the tolerance value. This parameter is only used with methods that support right angle identification. Double precision The precision used by the spatial grid employed in the regularization process. Valid values range from 0.05 to 0.25. Double diagonal_penalty Controls the distance bias for creating right-angle connections. Distances smaller than the diagonal penalty will be used to create right angles.This parameter is only used with the RIGHT_ANGLES_AND_DIAGONALS method. Double min_radius The smallest radius that a regularized circle can have. A value of 0 implies there is no minimum size limit. This option is only available with the CIRCLE method. Double max_radius The largest radius that a regularized circular can have. This option is only available with the Circle method. Double

## Code sample

RegularizeBuildingFootprint example 1 (Python window)

The following sample demonstrates the use of this tool in the Python window.

``````arcpy.env.workspace = 'c:/data'
arcpy.ddd.RegularizeBuildingFootprint('rough_footprints.shp',
'regularized_footprints.shp',
RegularizeBuildingFootprint example 2 (stand-alone script)

The following sample demonstrates the use of this tool in a stand-alone Python script.

``````'''****************************************************************************
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())``````

## Licensing information

• Basic: Requires 3D Analyst
• Standard: Requires 3D Analyst