Reconstruction algorithm and parameters¶

Assumptions¶

The following assumptions are made in the reconstruction algorithm:

Roof shapes are approximated with planar faces extracted from a point cloud – in other words, they are piecewise planar,
Building models are 2.5D with vertical walls. This simplifies the problem and results in a fast algorithm and makes sense for Airborne lidar scans; however, this also means that features like roof overhangs and balconies cannot be modelled.
Point clouds and footprints are properly aligned. Not only must the input data be in the same coordinate reference system (CRS), but also the positional error (horizontal shift) is assumed to be minimal.
Point clouds should be free of outliers and classified with at least buildings and terrain classes. In case the building points contain vegetation and other off-ground artefacts it might interfere with the reconstruction. For more information on the requirements of the input data, see Requirements on the input data.

Algorithm overview¶

The roofer building reconstruction algorithm consists of the following steps:

Plane detection: Roofplanes are detected in the point cloud using a region growing algorithm. Planes are used to approximate the roof shape.
Line detection: Rooflines are detected by intersecting the roofplanes and by fitting lines to the edges of the plane segments. The edges of the planes are detected using \(\alpha\)-shapes.
Line clustering and regularisation: The detected lines are clustered by their orientation and distance to eachother. For each cluster one represenative line is selected.
Initial roof-partition: The regularised rooflines are used to partition the roofprint polygon into faces. This results in a 2D arrangement that we call the roof-partition.
Graph-cut optimisation: The roof-partition is optimised using a graph-cut algorithm. The algorithm minimises the energy function that balances the data term \(D_p\left(f_p\right)\) and the smoothness term \(S_{p, q}\left(f_p, f_q\right)\):

\[\begin{split}E(f) &= \lambda \sum_{p \in P} D_p\left (f_p\right) \\ &+ \left( 1 - \lambda \right) \sum_{\{p, q\} \in N} S_{p, q}\left(f_p, f_q\right)\end{split}\]

During this optimisation step each face \(p\) is assigned one of the detected roofplanes \(f_p\). When to adjacent faces get assigned the same roofplane, the shared edge is removed. The result is the final roof-partition. \(\lambda\) is the complexity factor.
Extrusion: The final roof-partition is extruded to a 3D building model with the help of the assigned plane labels.

The roofer building reconstruction algorithm is largely data-driven, so the quality of the result depends on the quality of the input data. The following parameters can be tuned to optimise the performance for a given point cloud.

Parameters¶

float complexity_factor = 0.888

Complexity factor for building model geometry.

A number between 0.0 and 1.0. Higher values lead to more detailed building models, lower values to simpler models.

bool clip_ground = true

Set to true to activate the procedure that clips parts from the input footprint wherever patches of ground points are detected.

May cause irregular outlines in reconstruction result.

int lod = 22

Requested Level of Detail.

12: LoD 1.2
13: LoD 1.3
22: LoD 2.2

float lod13_step_height = 3.

Step height used for LoD13 generalisation, i.e.

roofparts with a height discontinuity that is smaller than this value are merged. Only affects LoD 1.3 reconstructions. Unit: meters.

float floor_elevation = 0.: Floor elevation in case it is not provided by the footprint (API only).

bool override_with_floor_elevation = false: Force flat floor instead of using the elevation of the footprint (API only).

int plane_detect_k = 15: Number of points used in nearest neighbour queries during plane detection.

int plane_detect_min_points = 15: Minimum number of points required for detecting a plane.

float plane_detect_epsilon = 0.300000

# Maximum distance from candidate points to plane during plane fitting procedure.

Higher values offer more robustness against oversegmentation in plane detection, lower values give more planes that are closer to the point cloud. Unit: meters.

float plane_detect_normal_angle = 0.750000

Maximum allowed angle between points inside the same detected plane.

This value is compared to the dot product between two unit normals. Eg. 0 means 90 degrees (orthogonal normals), and 1.0 means 0 degrees (parallel normals)

float line_detect_epsilon = 1.000000

Maximum distance from candidate points to line during line fitting procedure.

Higher values offer more robustness against irregular lines, lower values give more accurate lines (ie. more closely wrapping around point cloud). Unit: meters.

float thres_alpha = 0.250000

Distance used in computing alpha-shape of detected plane segments prior to line detection.

Higher values offer more robustness against irregular lines, lower values give more accurate lines (ie. more closely wrapping around point cloud). Unit: meters.

float thres_reg_line_dist = 0.800000

Maximum distance to merge lines during line regularisation (after line detection).

Approximately parallel lines that are closer to each other than this threshold are merged. Higher values yield more regularisation, lower values preserve more finer details. Unit: meters.

float thres_reg_line_ext = 3.000000

Extension of regularised lines prior to optimisation.

Used to compensate for undetected parts in the roofpart boundaries. Use higher values when the input pointcloud is less dense. However, setting this too high can lead to unrealistic reconstruction results. Unit: meters.