# Virtual laser scanning with HELIOS++: A novel take on ray tracing-based
simulation of topographic 3D laser scanning

Lukas Winiwarter<EMAIL_ADDRESS>Alberto Manuel Esmorís
Pena  Hannah Weiser  Katharina Anders  Jorge Martínez Sanchez  Mark Searle
Bernhard Höfle<EMAIL_ADDRESS>3DGeo Research Group, Institute of
Geography, Heidelberg University, Germany  Centro Singular de Investigación en
Tecnoloxías Intelixentes, CiTIUS, USC, Spain  Interdisciplinary Center for
Scientific Computing (IWR), Heidelberg University, Germany

###### Abstract

Topographic laser scanning is a remote sensing method to create detailed 3D
point cloud representations of the Earth’s surface. Since data acquisition is
expensive, simulations can complement real data given certain premises are
available: i) a model of 3D scene and scanner, ii) a model of the beam-scene
interaction, simplified to a computationally feasible while physically
realistic level, and iii) an application for which simulated data is fit for
use. A number of laser scanning simulators for different purposes exist, which
we enrich by presenting HELIOS++. HELIOS++ is an open-source simulation
framework for terrestrial static, mobile, UAV-based and airborne laser
scanning implemented in C++. The HELIOS++ concept provides a flexible solution
for the trade-off between physical accuracy (realism) and computational
complexity (runtime, memory footprint), as well as ease of use and of
configuration. Unique features of HELIOS++ include the availability of Python
bindings (`pyhelios`) for controlling simulations, and a range of model types
for 3D scene representation. Such model types include meshes, digital terrain
models, point clouds and partially transmissive voxels, which are especially
useful in laser scanning simulations of vegetation. In a scene, object models
of different types can be combined, so that representations spanning multiple
spatial scales in different resolutions and levels of detail are possible. We
aim for a modular design, where the core components of platform, scene, and
scanner can be individually interchanged, and easily configured by working
with XML files and Python bindings. Virtually scanned point clouds may be used
for a broad range of applications. Our literature review of publications
employing virtual laser scanning revealed the four categories of use cases
prevailing at present: data acquisition planning, method evaluation, method
training and sensing experimentation. To enable direct interaction with 3D
point cloud processing and GIS software, we support standard data formats for
input models (Wavefront Objects, GeoTIFFs, ASCII xyz point clouds) and output
point clouds (LAS/LAZ and ASCII). HELIOS++ further allows the simulation of
beam divergence using a subsampling strategy, and is able to create full-
waveform outputs as a basis for detailed analysis. As generation and analysis
of waveforms can strongly impact runtimes, the user may set the level of
detail for the subsampling, or optionally disable full-waveform output
altogether. A detailed assessment of computational considerations and a
comparison of HELIOS++ to its predecessor, HELIOS, reveal reduced runtimes by
up to 83 %. At the same time, memory requirements are reduced by up to 94 %,
allowing for much larger (i.e. more complex) 3D scenes to be loaded into
memory and hence to be virtually acquired by laser scanning simulation.

###### keywords:

software , LiDAR simulation , point cloud , data generation , voxel ,
vegetation modelling , diffuse media

††journal: Remote Sensing of Environment

##  1 Introduction

Simulation of physical processes is often carried out when experiments are not
feasible or simply impossible, or to find parameters that produce a certain
outcome if inversion is non-trivial. In virtual laser scanning (VLS),
simulations of LiDAR (Light Detection and Ranging) create 3D point clouds from
models of scenes, platforms, and scanners (Figure 1), that aim to recreate
real-world scenarios of laser scanning acquisitions. Such simulated point
clouds may, for certain use cases, replace real data, and may even allow for
analyses where real data capture is not feasible, e.g. due to technical,
economical or logistic constraints, or when simulating hardware which is not
yet existing. However, there are use cases where VLS is not appropriate, for
example, when analysing effects only partially modelled in the simulation such
as penetration of the laser into opaque objects. In a similar argument,
(passive) photogrammetry is inadequate for the reconstruction of a non-
textured flat area, but still a useful method for many other tasks. Therefore,
VLS can be seen as a tool to acquire 3D geospatial data under certain
_premises_. These include:

  1. 1.

an adequate model of the 3D scene and the scanner, as well as the platform
behaviour,

  2. 2.

a simplification of the real-world beam-scene interactions to a
computationally feasible and physically realistic level, and finally,

  3. 3.

an application for which VLS data is fit for use.

VLS can easily and cheaply produce large amounts of data with very well
defined properties and known ground truth. Parameters (e.g. tree attributes
such as crown base height) can be extracted from the scene model (e.g. a mesh
object that is being scanned) automatically and without errors, and these
parameters can in turn be used for training or validation of algorithms that
attempt to extract them from point cloud data. Due to the low cost compared to
real data acquisitions, VLS can be combined with Monte-Carlo simulations to
solve non-continuous optimisation problems on scan settings and acquisition
strategies. In a research workflow, VLS experiments may be employed to
identify promising candidate settings before carrying out a selected number of
real experiments that are used to answer the respective research questions.

Figure 1: Schematic concept of HELIOS++, showcasing platforms (boxed labels)
and object models composing a scene (non-boxed labels). A variety of model
types to represent 3D scenes are supported: terrain models, voxel models
(custom .vox format or XYZ point clouds) and mesh models. For platforms, four
options are currently supported: airplane, multicopter, ground vehicle and
static tripod. A schematic diverging laser beam and its corresponding waveform
(magenta) is shown being emitted from the airplane and interacting with a mesh
model tree and the rasterised ground surface.

In this paper, we present a novel take on ray tracing-based VLS covering the
given premises (1-3). This is implemented as the open source software package
HELIOS++ (Heidelberg LiDAR Operations Simulator ++)111HELIOS++ is available on
GitHub (https://github.com/3dgeo-heidelberg/helios) and is licensed under both
GNU GPL and GNU LGPL. HELIOS++ is also indexed with Zenodo (Winiwarter et al.,
2021).. HELIOS++ is the successor of HELIOS (Bechtold and Höfle, 2016), with a
completely new code base, implemented in C++ (whereas the former version was
implemented in Java). HELIOS++ improves over HELIOS in terms of memory
footprint and runtime, and also in functionality, correctness of implemented
algorithms, and usability, making it versatile and highly performant to end
users.

We first motivate the need for a novel VLS framework by a survey of previous
methodologies to laser scanning simulation and their applications, and point
out the unique features of HELIOS++ (Section 2). In Section 3, we present the
architecture and design considerations of HELIOS++. We then show different
types of applications and conduct a systematic literature survey of uses of
HELIOS in Section 4. Technical considerations concerning the handling of big
3D scenes and ray tracing are dealt with in Section 5 and conclusions are
drawn in Section 6.

##  2 Existing implementations and state of the art virtual laser scanning

Simulating a process within a system always involves a simplified substitute
of reality. The complexity of this substitute depends on the process
understanding, on computational considerations and on the specific problem
that is to be solved. Approaches with different levels of simulation
complexity exist regarding i) the type of input scene model (e.g. 2.5D digital
elevation models (DEMs) vs. 3D meshes) and ii) how the interaction of beam and
object is modeled (e.g. single ray/echo vs. full-waveform). An overview of
publications of these approaches is listed in Table 1.

Publication | Platforms |  | Beam
---
div.
FWF | Scene | Comments
North (1996), North et al. (2010) | satellite | ✓ | ✓ | 3D | FLIGHT model
Lewis (1999) | ALS | ✓ | ✓ | 3D |  | used by
---
Calders et al. (2013) &
Disney et al. (2010)
Tulldahl and Steinvall (1999) | ALS | ✓ | ✓ | 3D | for bathymetry
Ranson and Sun (2000) |  | ALS
---
(nadir)
✓ | ✓ | 3D |
Holmgren et al. (2003) | ALS |  |  | 3D |
Goodwin et al. (2007) | ALS |  |  | 3D | LITE model
Lohani and Mishra (2007) | ALS |  |  | 2.5D |
Morsdorf et al. (2007) | ALS | ✓ | ✓ | 3D | using POVray
Kim et al. (2009) | ALS |  |  | 3D |
Kukko and Hyyppä (2009) | ALS, MLS | ✓ | ✓ | 2.5D |
Hodge (2010) | TLS | ✓ | ✓ | 2.5D |
Kim et al. (2012) | ALS | ✓ | ✓ | 3D |
Wang et al. (2013) | TLS |  |  | 3D |
Gastellu-Etchegorry et al. (2015) |  | satellite,
---
ALS, TLS
✓ | ✓ | 3D | DART model
Bechtold and Höfle (2016) |  | ALS, TLS,
---
MLS, ULS
✓ | ✓ | 3D | HELIOS
Table 1: Overview of virtual laser scanning simulators and associated
publications. For each simulator, a check mark (✓) is added if they support
simulation of finite (non-zero) beam divergence (”Beam div.”) and full
waveforms (”FWF”). Scene representation may be in full 3D or 2.5D, i.e.
raster-based.

A simple airborne laser scanning (ALS) simulator is presented by Lohani and
Mishra (2007) for use in research and education. Their tool comes with a user-
friendly graphical user interface (GUI) and allows selecting different scanner
and trajectory configurations. This simulator models the laser ray as an
infinitesimal beam with zero divergence to simplify the ray tracing procedure.
The scene is represented by a 2.5D elevation raster, which allows only a
simplified representation of the Earth’s surface.

In a different application, the interactions between laser beams and forest
canopies are investigated by Goodwin et al. (2007), Holmgren et al. (2003) and
Lovell et al. (2005). They present approaches of combining 3D forest modelling
and ALS simulation using ray tracing. As in Lohani and Mishra (2007), their
simulators all model the laser beam as an infinite straight line, which
intersects the scene in one distinct point.

Full-waveform laser scanners can record the full waveform of the backscattered
signal, providing information about the objects in a scene that are
illuminated by the conic beam. This waveform from a finite footprint was
specifically simulated by Ranson and Sun (2000) in the forestry context and by
Tulldahl and Steinvall (1999) for airborne LiDAR bathymetry. Morsdorf et al.
(2007) use the ray tracing software POV-Ray222http://www.povray.org/ to model
the waveform of laser scans of a 3D tree model from a combination of intensity
and depth images.

Kukko and Hyyppä (2009) aim for a more complete and universal LiDAR simulator
that considers platform and beam orientation, pulse transmission depending on
power distribution and laser beam divergence, beam interaction with the scene,
and full-waveform recording. Their approach models the physics involved in
LiDAR measurements in high detail, and is demonstrated for a use case in
forestry. Similar to the work by Lohani and Mishra (2007), they use 2.5D
elevation maps to represent the scene. This makes the simulator useful for
airborne simulations over terrain or building models, where the scene is
scanned from above and scene elements are assumed to be solid and opaque.
However, it is less suited for penetrable 3D objects such as vegetation or
overhanging geometries, especially for the simulation of ground-based
acquisitions which are less in a bird’s-eye view perspective. Kim et al.
(2012) present a similarly detailed simulator, which includes radiometric
simulation and recording of the waveform and includes explicit 3D object
representations. It is unclear if it also supports static platforms such as
TLS.

TLS simulations are the sole focus of some studies for specific applications,
such as leaf area index inversion (Wang et al., 2013) or TLS measurement error
quantification (Hodge, 2010). While Wang et al. (2013) use a more simple model
assuming no beam divergence, the simulation described by Hodge (2010) includes
both the modelling of beam divergence and recording of the waveform. Their
simulation again uses 2.5D elevation models to represent the scene, which is
appropriate for their particular objective of error quantification in high-
resolution, short-range TLS of natural surfaces, specifically fluvial sediment
deposits, of small scenes (area of $1\text{\times}1\text{\,}\mathrm{m}$).

Established Monte-Carlo ray tracing simulator are used and being extended for
airborne and satellite laser scanning simulations. The librat model (Calders
et al., 2013; Disney et al., 2009, 2010), a modular development of ARARAT
(Lewis and Muller, 1993) is such a Monte-Carlo simulator. Similarly, North et
al. (2010) extend the 3D radiative transfer model FLIGHT (North, 1996) to
model satellite LiDAR waveforms. Monte-Carlo methods represent a simple,
robust and versatile set of techniques to solve multi-dimensional problems by
repeatedly sampling from a probability density function describing the system
that is investigated (Disney et al., 2000). These stochastic methods are
useful for simulating multi-scattering processes, e.g. for modeling canopy
reflectance. The main drawback of Monte-Carlo ray tracing methods are high
computation times to simulate sufficient photons for the scattering model to
converge to an accurate solution (Disney et al., 2000; Gastellu-Etchegorry et
al., 2016). The LiDAR extension of the Discrete Anisotropic Radiative Transfer
(DART) model attempts to alleviate these restrictions by quickly selecting
scattering directions of simulated photons using the so-called Box method and
modeling their propagation and interaction using a Ray Carlo method, which
combines classical Monte-Carlo and ray tracing methods (Gastellu-Etchegorry et
al., 2016).

A comprehensive review of simulators for the generation of point cloud data,
including LiDAR simulators, is presented in Schlager et al. (2020) with focus
on their applicability to generate data in the context of driver assistance
systems and autonomous driving vehicles. In this context, they analyse
algorithms with respect to their fidelity, operating principles, considered
effects and possible improvements.

In contrast to most of the previously mentioned approaches, HELIOS++ provides
a framework for full 3D laser scanning simulation with multiple platforms
(terrestrial (TLS), mobile (MLS), UAV-borne (ULS) and airborne (ALS)), and a
flexible system to represent scenes, which allows combination of input data
from multiple sources and data formats (Figure 1). The simulation of beam
divergence and full waveform recording are supported. While HELIOS++ may not
be as realistic in terms of physical accuracy regarding the energy budget of a
single laser shot as, e.g., DART, it provides a sensible trade-off between
computational efforts and resulting point cloud quality. Users can simulate
VLS over a large range of scales, and even combine different scales in one
scene. For example, a highly detailed tree model with individual leaves might
be placed in a forest scene represented by (transmissive) voxels (Weiser et
al., 2021), while using a rasterised digital terrain model as ground surface.
This allows to model the influence of the surrounding of a particular object
of interest on the derived VLS point clouds. Furthermore, HELIOS++ aims for
high usability by providing a comprehensible set of parameters, while not
overwhelming the users with options. These parameters represent the state of
the art and are supported by peer-reviewed literature. Since HELIOS++ can be
used from the command line and from within Python, workflows integrating
HELIOS++ can be easily scripted and automated, as well as linked to external
software (e.g. GIS, 3D point cloud processing software, Jupyter Notebooks, and
others).

HELIOS++ comes with an extensive documentation of all algorithms that are used
in the simulations, including examples and references to the relevant
literature describing the implemented methods. Furthermore, the open source
implementation allows any user to i) inspect and ii) alter/adapt the source
code of the program. For ease of use, we provide pre-compiled versions that
are ready to use for major operating systems (Microsoft Windows 10 and Debian
Linux 10.7 Buster), and the option to use Python as a scripting language to
create, manipulate and simulate VLS data acquisition with HELIOS++.

##  3 Implementation of HELIOS++

This section introduces the concepts and interfaces of HELIOS++, for which the
important components are the overall architecture and modules (Section 3.1),
platforms (Section 3.2), scanners and laser beam deflectors (Section 3.3), the
waveform simulation (Section 3.4), input formats (Section 3.5) and output
formats (Section 3.6), and the aspect of randomness and repeatability of
results (Section 3.7).

###  3.1 Architecture and modules

The central element in HELIOS++ simulations is a _survey_. A survey contains
links to the _scene_ , which defines the objects that are scanned, the
_platform_ , on which the virtual scanner is mounted and moved through the
scene, and to the _scanner_ itself. Furthermore, a survey contains a number of
_legs_ , which represent waypoints for the platform. The scene consists of a
number of _parts_. Each part represents one input source, for example, a 3D
mesh file, or a voxel file. Multiple parts may be combined in a scene, and no
limitation to the combination of different data source types is imposed.
HELIOS++ uses internationally accepted standard file formats for input and
output. These elements are defined through Extensible Markup Language (XML)
files, that are referenced using (relative) file paths. XML is a text-based
format, which can easily be manipulated using a text editor or an XML editor.
Figure 2 presents the different files along with a subset of the parameters
that can be set in the respective files.

Figure 2: File structure of HELIOS++ survey, scene, platform, and scanner. A
survey consists of one or more legs, and a single scanner, platform, and
scene, respectively. A scene is built up from one or more parts, which can be
of different data type.

A survey may then be run through either i) the command line, where an
executable is provided or ii) the Python bindings `pyhelios`. The Python
bindings allow access to the simulation parameters as parsed from the XML
files, including changing the parameters programmatically for each simulation
run. For example, different scanners can be exchanged automatically and
simulated in sequence in a single Python script without changing any other
input and settings of the simulation. `pyhelios` furthermore allows access to
the simulation result, i.e. the point cloud and the platform trajectory, and
converts them into a NumPy array either at the end of the simulation run or
through a callback function that can be executed every $n$-th cast laser ray.
In this way, a live preview of the point cloud acquisition can be implemented
in Python to give a visual impression of the ongoing simulation. A Python
script distributed with HELIOS++ acts as such a visualiser, and is called with
the same commands as the standalone executable. A user may thus quickly switch
between using the pure C++ implementation without visualisation or the Python
bindings with visualisation, as presented in Listing 1.

Listing 1: Comparison between running HELIOS++ as an executable and through
the Python wrapper providing an interactive viewer

⬇

1run\helios.exe data\surveys\arbaro_demo.xml \--lasOutput \--writeWaveform

2python pyhelios\helios.py data\surveys\arbaro_demo.xml \--lasOutput
\--writeWaveform

With `pyhelios`, it is also possible to combine HELIOS++ with tools like
_Jupyter Notebooks_ , allowing for explanations along-side code and figures.
We include sample notebooks in the documentation of HELIOS++. One of these
samples is shown in Figure 3.

Figure 3: Screenshot of a Jupyter Notebook showcasing the Python bindings of
HELIOS++ by plotting the trajectory of a simulation over flat terrain.

###  3.2 Supported laser scanning platforms

Both static and dynamic platforms are supported by HELIOS++, which can
resemble an airplane (`LinearPath` platform), a multicopter (`Multicopter`
platform), a ground-based vehicle (`GroundVehicle` platform) or a static
tripod (`Static` platform). In the case of the `LinearPath` platform, the
vehicle is moved with a constant speed from one waypoint (leg) to the next
one. The orientation of the platform is always towards the next waypoint. The
`Multicopter` platform additionally simulates acceleration and deceleration of
the platform. In the turn mode _smooth_ , the platform banks to make more
smooth turns at the waypoints instead of stopping and turning on the spot.
This mode simulates the _banked angle turns_ available in the flight protocols
of major drone companies (e.g. DJI). Custom yaw angles for the beginning and
the end of each leg can be provided. The `GroundVehicle` platform is bound to
elements of the scene defined as ground in the respective material file (cf.
Section 3.5). Furthermore, it considers maximum turn radii and implements
three-point-turns to resemble a car or tractor on which a scanner is mounted
(i.e. MLS). The different platforms and scene types (Section 3.5) are shown in
Figure 1. As expected, choice of platform influences the resulting pointcloud,
which is shown in Figure 4.

Figure 4: Point clouds resulting from virtual laser scanning of the scene
shown in Figure 1, using (a) an airplane, (b) a multicopter, (c) a ground
vehicle and (d) a static tripod as platform. Since HELIOS++ records which
objects are generating which return, the points can be perfectly assigned to
the objects, here illustrated by distinct colouring.

###  3.3 Supported laser scanners and scan deflectors

The core component of the simulation is the laser scanner, which includes a
model for the scan deflector. The choice of the deflector influences the
resulting scan pattern (Fig. 5).

Figure 5: Different scan patterns depending on the deflector used in the
simulation: a) rotating mirror, b) fibre-optic line scanner, c) oscillating
mirror and d) slanted rotating mirror (Palmer scanner). The patterns shown
here result from simulations with HELIOS++ using the respective deflectors,
albeit with unrealistic settings of pulse repetition rate and scanning
frequency, in order to show the patterns more clearly.

HELIOS++ supports polygonal mirror deflection, resulting in parallel scan
lines with even point density (Fig. 5a), fibre-optics, where the beam is fed
through fibreoptic cables to point in different directions, resulting in a
similar scan pattern to (a), but without the need of mechanically moving parts
(Fig. 5b), a swinging mirror, which results in a zig-zag-pattern with
increased point densities at the extrema (Fig. 5c) and rotating slanted
mirrors, resulting in a conical point pattern at a constant scan angle off-
nadir, also referred to as Palmer scanner (Fig. 5d).

###  3.4 Waveform simulation

During real LiDAR acquisitions, a laser beam sent out from the laser scanner
has a finite footprint, i.e. a non-zero area that intersects with the scene.
For every infinitesimal point in this area, energy is transmitted back to the
detector where it is recorded as the integral of intensities over the area. By
considering this received intensity over time, it is possible to extract
multiple echoes from one laser pulse, corresponding to multiple targets that
were hit by parts of the intersection area, respectively.

In HELIOS++, the non-zero beam divergence is simulated by subrays, that are
sampled in a regular pattern around the central ray (Fig. 6). Every subray has
its own base intensity, which is calculated according to Equation 1,
representing a 2D Gaussian power distribution (Carlsson et al., 2001).

$I=I_{0}\exp\left(-2r^{2}/w^{2}\right)$ (1)

where $I_{0}$ [$\mathrm{W}$] is the peak power, $w$ [$\mathrm{m}$] the local
beam divergence and $r$ [$\mathrm{m}$] the radial distance from the power
maximum, i.e. the ray centre. $w$ is calculated using Equation 2 from the beam
waist radius $w_{0}$ [$\mathrm{m}$], and the helper values
$\omega=\frac{\lambda R}{\pi w_{0}^{2}}$ and $\omega_{0}=\frac{\lambda
R_{0}}{\pi w_{0}^{2}}$ with $\lambda$ [$\mathrm{nm}$] as the wavelength, $R$
[$\mathrm{m}$] the range of the target and $R_{0}$ [$\mathrm{m}$] the focusing
length of the laser.

$w=w_{0}\sqrt{\omega_{0}^{2}+\omega^{2}}$ (2)

Every subray is individually cast into the scene and intersected with objects.
If it hits an object, a return is generated and recorded by the detector. The
respective subray does not continue in the scene through transmission or
reflection. In the case of the transmissive voxel model (cf. Section 3.5), a
subray may either fully traverse a voxel or produce a return, but never both.
Therefore, the property of transmissivity of a scene part is coupled to the
use of multiple subrays. The power returned from the object is further
dependent on the material specified in the scene definition (Section 3.5).

The number of subrays generated can be set by the user by providing the
`beamSampleQuality` parameter in the XML file of the scanner or the survey.
The `beamSampleQuality` corresponds to the number of concentric circles where
subrays are sampled. For each circle, the number of subrays is defined as
$\lfloor 2\pi i\rfloor$ where $i=1,\dots,$`beamSampleQuality` is the circle
index. This ensures that the angular distance between adjacent subrays is
approximately constant, i.e. each subray represents a solid angle of equal
size. A central subray is always added. Figure 6 shows the subray distribution
for three different beam sample qualities.

Figure 6: Subray configurations for beam sample qualities of (a) 2 (7
subrays), (b) 5 (93 subrays), and (c) 9 (279 subrays). The colour of the
subrays corresponds to the normalised intensity at this location within the
beam cone: low (purple) to high (yellow). The black circle represents the
single beam divergence (at the $1/e^{2}$ points, here:
$0.3\text{\,}\mathrm{mrad}$), the gray circle twice the beam divergence.

The pulse shape in time is approximated using bins of a regular, user-defined
size via the parameter `binWidth_ns`. Each bin’s power is calculated according
to Equation 3, where $t$ [$\mathrm{ns}$] is the time and $\tau$
[$\mathrm{ns}$] is the pulse length of the scanner divided by 1.75 (Carlsson
et al., 2001). $I$ [$\mathrm{W}$] is calculated for each subray according to
Equation 1.

$P(t)=I\left(\frac{t}{\tau}\right)^{2}\exp\left(-\frac{t}{\tau}\right)$ (3)

For every pulse, the subrays are collected as a representation of the full
returned waveform, and the recorded power for each bin is taken as the sum of
the subray’s waveforms, shifted according to the different ranges of the
subrays. Range difference is converted to time difference by using the speed
of light as a constant
($c=\;$$299,792,458\text{\,}\mathrm{m}\text{\,}{\mathrm{s}}^{-1}$). A local
maximum filter is then used on the summed waveform to detect peaks, which are
regarded as echoes and exported as points. Optionally, a Gaussian may be
fitted to the resulting waveform, to get a measure of echo width (i.e.
standard deviation of the Gaussian). The position of the point along the range
(time) axis, however, is taken from the local maximum, not from the fitted
Gaussian, as the outgoing waveform (Eq. 3) is not Gaussian.

###  3.5 Input scene models

HELIOS++ supports data formats that are (de-facto) standards in the field, and
can be created and manipulated with free software such as
QGIS333https://qgis.org/en/site/, CloudCompare444https://www.danielgm.net/cc/,
Blender555https://www.blender.org/ or AmapVOX666Vincent et al. (2017),
http://amap-dev.cirad.fr/projects/amapvox.

####  3.5.1 Wavefront objects

In wavefront object files (file extension .obj), meshes are represented as
lists of triangles (triples of point IDs) and points (triples of coordinates).
This allows opaque 3D models of arbitrary complexity. In addition, material
properties can be assigned to the objects in so-called material files (file
extension .mtl; Wavefront Technologies, 1992).

####  3.5.2 GeoTIFF models

Raster models created with common GIS tools, such as a digital elevation or a
digital surface model, can be included. The raster is converted to a
triangular mesh on import, where the pixel centres are interpreted as points.
Invalid pixels (i.e. no-data values) are ignored in the triangulation,
resulting in holes in the mesh. This data type allows an simple representation
of the Earth’s surface. As prescribed by the file format, only 2.5D-data is
supported.

####  3.5.3 Point clouds

In ASCII xyz files, point clouds can be used as a raw input to HELIOS++. On
import, the point clouds are voxelised using a voxel size defined by the user.
In addition, a normal vector used for intensity calculation can be assigned to
the voxels (by nearest neighbour or mean reducing) or calculated from the
point cloud on the spot (cf. Section 5). Alternatively, all laser rays can be
set to have an incidence angle of 0°, or the rays are intersected with the
actual faces of the cube representing the voxel. Material properties can be
defined in the respective scene part definition of the XML file.

####  3.5.4 Transmissive voxels

Especially for modelling vegetation, we include support for voxel data
containing plant area density information (e.g. created using the AmapVOX
software (Vincent et al., 2017), file extension .vox). Multiple modes are
supported in this case:

  * 1.

opaque voxels, where the voxels are represented by solid cubes with a fixed
side length equal to voxel resolution,

  * 2.

adaptive scaling of opaque voxel cubes (with optional random but reproducible
shift to avoid regular patterns in the result), where the scaling (side length
of a voxel $a$) is dependent on the plant area density $PAD$, the user-defined
scaling factor $\alpha$, the base voxel size $a_{0}$ and the maximum $PAD$,
related by Equation 4, and

  * 3.

transmissive voxels (explained in more detail in the following).

Point clouds resulting from a tree simulation using these different modes are
shown in Figure 7. The opaque voxel models also support the definition of
material properties through the scene part’s definition. A comprehensive study
on the effects of different levels of detail in modelling forests using the
first two modes on the extraction of forestry and point cloud parameters is
performed by Weiser et al. (2021).

$a=a_{0}\left(\frac{PAD}{PAD_{max}}\right)^{\alpha}$ (4)

Here, $a$ is the side length of the resulting cube, $a_{0}$ the base voxel
size, $PAD$ the plant area density of each individual voxel, $PAD_{max}$ a
maximum value for the plant area density and $\alpha$ a user-defined scaling
factor.

Figure 7: VLS point cloud of a tree based on different voxel modes, using a
UAV as a platform. Point clouds are simulated using input voxel models with
different fixed sizes (a-c), PAD-dependent scaled voxels (d and e) and
transmissive voxels (f).

The transmissive voxels use an extinction approach as presented by North
(1996). The extinction coefficient $\sigma$ is calculated following Equation
5:

$\sigma=\frac{\mu_{L}}{2\pi}\int_{0}^{2\pi}g_{L}\left|\Omega^{\prime}\cdot\Omega_{L}\right|d\Omega_{L}$
(5)

Here, $\mu_{L}$ is the plant area density (PAD) as defined in the .vox file,
$g_{L}$ is the probability taken from the leaf angle distribution at direction
L, and $\left|\Omega^{\prime}\cdot\Omega_{L}\right|$ is the cosine of the
angle between the incident ray $\Omega^{\prime}$ and the direction
$\Omega_{L}$. This leaf angle distribution is supplied via a look-up-table as
shown in Table 2, and examples for planophile, erectophile, plagiophile,
extremophile, spherical and uniform distributions are provided.

Subsequently, a random number $R$ is drawn from a uniform distribution
$\in[0,1)$. The expectation of the intersection of a subray with a voxel given
the extinction coefficient $\sigma$ is then given as in Equation 6, where $s$
is the distance of an echo after entering the voxel (i.e. traversed distance).

$s=\frac{-\ln(R)}{\sigma}$ (6)

If the actual length of the subray traversing the voxel is larger than $s$, no
echo is recorded for this ray in the voxel, and it is assumed to have
transmitted through the voxel, potentially intersecting the next voxel or
another object. Otherwise, an echo is created at distance $s$ from where the
subray first entered the respective voxel, and the subray is not continued
through the scene (North, 1996).

Irrespective of the input type, each scene part can be individually scaled,
rotated and translated within the scene, allowing the re-use of models to
create multiple instances of similar objects. These transformations can also
be manipulated using the Python bindings. For rotations, both extrinsic
(”global”, fixed coordinate axes) and intrinsic (”local”, rotating coordinate
axes) modes are supported.

HELIOS++ allows arbitrary combinations of all possible object models in a
scene. For example, a GeoTIFF can be used as digital terrain model on which a
vehicle is moving, combined with transmissive voxel models of trees, mesh
models for tree stems and a point cloud of buildings, which is voxelised by
HELIOS++ (Figure 1). Such combination allows highly versatile use of the scene
definition, while considering shadowing and overlapping effects between the
different types of object models, and is one of the key advantages over other
VLS software.

###  3.6 Output format and options

The simulated point clouds can be written either as LAS file (Version 1.0,
point format 1), according to the format definition by the American Society of
Photogrammetry and Remote Sensing (ASPRS, 2011), as LAZ file, which is a
lossless compression of LAS provided by the LASzip
library777https://laszip.org/, Isenburg (2013), or as ASCII file, where the
point coordinates and attributes are written in columns. The LAS/LAZ formats
allow for smaller file sizes and faster read/write access (cf. Section 5.4),
while the ASCII format can be parsed by any program working with text files.

In addition to creating compressed LAS files, HELIOS++ can also compress
output ASCII files, if smaller output sizes are required. Uncompressing LAZ or
compressed ASCII files is possible by invoking HELIOS++ using the `--unzip`
flag.

In the simulation of full waveforms (see Section 3.4), the echo width is
optionally estimated for every recorded return. Since this estimation uses a
non-linear least squares method and is hence expensive to calculate, the
estimation has to be switched on explicitly by the user. In typical use cases,
this increases the runtime of the simulation by a factor of 1.3.

If the full waveform is to be exported, a separate ASCII file will be written.
This file contains information about every beam that generated at least one
hit consisting in the beam origin and the beam direction, as well as the
sampled returned waveform. The bin size as well as the maximum length of this
sampled waveform can be defined by the user (Section 3.4). To connect the
point cloud output with the full waveform output, the point cloud has an
attribute `fullwaveIndex`, which corresponds to the `fullwaveIndex` in the
ASCII waveform output. Multiple points, if coming from the same beam, may have
the same `fullwaveIndex`. The output created by HELIOS++ can be easily
converted to standard waveform formats such as PulseWaves and LAS 1.4 WDP.

Furthermore, HELIOS++ comes with an option to export the trajectory of the
platform. The time interval between successive platform positions can be
defined by the user in the survey XML file. In addition to the time and the
position of the platform, the attitude angles of roll, pitch and yaw are
exported.

###  3.7 Randomness and repeatability

The trajectory of the platform, the scanner definitions and the ray-scene
interactions with the exception of transmissive voxels are deterministic. To
allow for more realistic point clouds, random noise sources may be introduced
at various points of the simulation. A single distance measurement is
attributed with a random ranging error, drawn from a normal distribution with
parameters defined for each scanner. Additionally, random platform noise can
be added to simulate trajectory estimation or scan position localisation
errors. By default, the system time is used to generate randomness, which
results in different outcomes for every simulation run. However, the ability
to produce the identical results in repeated simulation runs is a major
advantage of VLS over real data acquisitions and may be aspired for certain
use cases. To allow for repeatable survey results while using randomness,
there are additional options to define a custom seed for pseudo-randomness
generation. Still, when using multithreading, each thread accesses the
randomness generator in a non-deterministic order, resulting in different
outputs for every simulation run. This can be avoided by running HELIOS++ in
single-threaded mode and with a fixed seed. This will generate the exact same
result in repeated runs, even for transmissive voxels, as the random number
drawn from the uniform distribution is also created based on the seed.

##  4 Applications of laser scanning simulation

To investigate the usability of the HELIOS++ concept of providing a sensible
trade-off between physical reality and computational complexity, along with
the support of generic input files to create the 3D scene, we present
applications of laser scanning simulation. This literature survey is based on
studies that use HELIOS++’s predecessor, HELIOS (Bechtold and Höfle, 2016) or
pre-release versions of HELIOS++. Since the functionality of HELIOS, apart
from the visualisation module, is fully integrated in HELIOS++, the
publications presented in the following provide an adequate review of
simulation applications.

The analysis is conducted on all publications that cite the original
publication of Bechtold and Höfle (2016), and that actively use HELIOS in
their research according to the published article. It consists of journal
papers, conference contributions and posters. The following questions are
posed to analyse the contents of each publication.

  * 1.

What is the scientific target of the simulation?

  * 2.

How many simulations are carried out on which platform (ALS, TLS, ULS, MLS)?

  * 3.

Which type of model is employed to compose the scene for the simulation?

  * 4.

Which parameters are extracted from the point cloud, if applicable?

  * 5.

What is the resulting VLS point cloud compared to?

The synthesis of the literature review allows a grouping of the publications
and of the purposes of laser scanning simulation into four main categories:
(1) optimising or analysing different scan settings and acquisition modes, (2)
comparing parameters extracted from simulated data to error-free ground truth,
(3) generating training data for supervised machine learning, and (4) testing
and development of novel or future algorithms and sensors.

###  4.1 Data acquisition planning and scan setting effects

Data acquisition planning at its core is an optimisation problem. The goal is
to acquire data that is fit for the purpose of the analysis by minimal effort.
This can be a minimum number of scan positions, flight lines, etc., that is
sufficient for the specific requirement to the data, such as coverage of the
scene regarding occlusion or a certain point density. While flight planning
tools and visibility analysis-based methods can be used to create potential
acquisition plans, they usually lack methods to verify the fitness for use of
obtained data.

With virtual laser scanning, assuming that at least a coarse model of the area
of interest is available, a 3D point cloud can be generated and tested for its
fitness directly in the planned application. There is no need to define proxy
metrics like target point density, required accuracy and overlap as required
by simple survey planning tools. This way, users can ensure that the acquired
data will meet all requirements such as coverage, adequate representation of
geometry, and resolution before actually going to the field to collect the
data, by running their analyses on the simulated point clouds and interpreting
the results. Similarly, the effects of different scan settings on parameters
extracted from the simulated point clouds can be studied with HELIOS++, as
single variables can easily be manipulated in a way that is isolated from all
other influences, including environmental influences, which are very difficult
to control in repeated real-world acquisitions. For example, the effects of
flying height and maximum scan angle on the resulting ground point density and
resolution (i.e. illuminated area per beam) may be analysed. Similarly, TLS
scans of different resolution can be simulated and the effect of resolution on
the results of data analysis (e.g. the quality of extraction of tree stems)
can be quantified.

While the quality of the simulation in terms of being physically realistic
highly depends on the input models, even a coarse model can be useful to
estimate occlusion and resulting point densities. Such analyses, carried out
prior to real data acquisitions, can save valuable time in the field. Using a
Monte-Carlo approach, multiple simulations using different parameters are
carried out to create the optimal (in terms of number of positions, time,
etc.) acquisition plan.

Existing publications in this category include Backes et al. (2020), who use a
digital surface model created from photogrammetry to simulate acquisition of
an alpine valley by TLS and ULS. They estimate the minimal detectable change,
to optimise scan positions and trajectories for change analysis. Similar
analyses, but with focus on resulting point density and completeness of data
acquisition, are carried out based on a DEM provided by public agencies by Lin
and Wang (2019). They are able to show that a downsampled scene model can
provide accurate measures for simulated point densities when also reducing the
pulse frequency. This validates the simulation’s representation of spatial
scales.

A validation of scan position planning based on viewshed analysis is carried
out with respect to achieved accuracy, point density and completeness by
Previtali et al. (2019). Their use cases are acquisitions of complex
archaeological sites, where complete coverage is often difficult to achieve
due to occlusions. In two examples, they optimise the positions of 97 and 16
scan positions, respectively, to scan a basilica and part of an ancient food
storage in Italy.

The effect of scan settings on point cloud-based parameters is analysed for
forestry settings by Hämmerle et al. (2017), who extract understory tree
heights from TLS and ULS data. They use 3D models created with the Arbaro tree
generator888http://arbaro.sourceforge.net/ (Weber and Penn, 1995), on which
they densely sample points to create a reference point cloud as ground truth.
They find a favourable trade-off between acquisition effort and accuracy of
results for a number of three TLS scan positions around a tree object of
interest (Hämmerle et al., 2017). Similarly, Li et al. (2020) create 3D tree
models using ONYXTREE999http://www.onyxtree.com/ and evaluate the influence of
scan parameters on extracted values of diameter at breast height (DBH), tree
height, stem curve and crown volume. They succeed in reducing the root-mean-
squared error on these values by iteratively adapting scan parameters.

Weiser et al. (2021) analyse the different opaque voxel models at different
scales and their effect on common tree metrics, showing that a scaled voxel
model requires much less complexity (i.e., allows for a larger voxel size)
than binary voxels at a fixed scale. Schäfer et al. (2019) use the novel
transmissive voxel-support of HELIOS++ for similar analyses with ALS and ULS
data.

###  4.2 Algorithm and method evaluation: validation and calibration

In numerous point cloud analysis methods, the objective is to extract certain
parameters describing the objects of interest. For example, in forestry
applications, ALS and TLS point clouds are commonly used to derive the
diameter at breast height of trees, crown radii, tree heights, and tree
species (Giannetti et al., 2018). To calibrate the extraction algorithms as
well as to validate the results, in-situ measurements are required, which are
laborious and costly to acquire, and not free of error.

An alternative to this in-situ data acquisition can be provided by HELIOS++,
if the parameters to be extracted from the point cloud can be derived from the
objects within the scene, or the scene is created dynamically according to the
parameters. For example, a method may be designed to measure DBH from a point
cloud. In VLS, the true values of DBH can be derived from the stem models, or
the virtual tree models themselves may be generated according to given values
of DBH. In addition to being error-free, the domain of the parameters (e.g.
the range of DBH values) used in the simulation can be defined by the user. A
simulated example can therefore be picked to have exactly the properties
needed in a specific application (say, use case-specific DBH values between
$20\text{\,}\mathrm{cm}25\text{\,}\mathrm{cm}$), whereas real objects with the
required properties as ground truth may be hard to find.

In addition to parameter extraction, perfect ground truth can be used to
evaluate the performance of classification algorithms. Currently,
classification methods are difficult to compare, as authors use different
evaluation approaches, mainly due to the lack of semantic reference data.
Since in VLS the interaction between the laser beam and the scene can be
attributed to the exact mesh face that is hit during ray casting, and
therefore to a specific object, the ground truth data is free of error even in
highly complex and multi-echo scenarios. This has compelling advantages:
First, reference data can be created automatically, drastically cutting costs
and providing the possibility of generating massive amounts. And second, it
removes labelling errors, as manual labelling will always include some degree
of human error.

Considerable research using HELIOS to validate or calibrate extracted
parameters has been undertaken in multiple forestry applications. Liu et al.
(2019a) and Liu et al. (2019b) estimated leaf angles on trees, where ground
truth is practically impossible to obtain, because in real settings, leaves
are continuously moving due to wind. VLS allows to validate their approach of
leaf angle estimation and subsequently apply it to real data. Wang et al.
(2020) validate their calculation of photon recollision probability over
spatial locations using VLS data. Zhu et al. (2020) use two different methods
to assess Leaf Area Index (LAI) and compare these methods with ground truth
obtained from the object models, allowing them a comparison with the true LAI
of the input objects. For tree segmentation, ground truth is also difficult to
obtain, as tree canopies often intersect each other. By using HELIOS, Wang
(2020) and Xiao et al. (2019) obtain perfect ground truth for training and
validation of their segmentation methods. Wang (2020) achieve 2.9 % and 19.8 %
RMSE for tree height and crown diameter estimates.

In a non-forestry application, road curves are reconstructed and the
reconstruction is compared with the model parameters (Zhang et al., 2019),
achieving a relative accuracy of 0.6 % in circle radii estimation using VLS
data. Requirements for Building Information Modelling (BIM) are evaluated by
(Rebolj et al., 2017), who generate around 100 point clouds to ascertain the
influence of parameter values. They define accuracy criteria for the
successful identification of building elements in the scans. Bechtold et al.
(2016) test a segmentation tool for rock outcrops by using HELIOS as a
simulator. They show the value of simulated test data for method development
by easily generating point clouds with different occlusions and scan settings,
resulting in a multitude of point densities and point patterns.

###  4.3 Method training

With the advent of neural networks as supervised machine learning method in
geospatial domains, the need for training data has grown almost indefinitely.
While raster-based approaches can make use of existing pre-trained networks by
domain transfer (Pires de Lima and Marfurt, 2019), no such networks exist for
point-based deep learning such as PointNet/PointNet++ (Qi et al., 2017).

Simulated data, though only replicating parts of reality, can be used by
neural networks to learn basic descriptors which describe point cloud
neighbourhoods, e.g. planes, corners or edges. From these descriptors, higher-
level features are derived, which are subsequently used in classification or
regression (Winiwarter et al., 2019).

Once a network has learned to represent data in form of these features, it can
be adjusted to real data by adding relatively small amounts of training data,
in approaches shown to work for the image domain (Danielczuk et al., 2019).
Further research is needed on this approach especially for point cloud data,
but HELIOS++ allows easy and fast generation of labelled training data, which
does not suffer from ground truth errors.

As an example application of this purpose, Martínez Sánchez et al. (2019) use
HELIOS-simulated data to train and evaluate a semantic classification of an
urban scene created from OpenStreetMap101010https://www.openstreetmap.org/
models. The use of VLS allowed a quantification of their classifier’s total
error, which amounts to 0.5 % on simulated point clouds.

###  4.4 Sensing experimentation

The fourth category summarises publications concerned with the development of
novel sensors and methods, such as Park et al. (2020), who present a new Time-
of-Flight sensor and compare its results to a HELIOS simulation. In general,
the parameters of the virtual sensors can be tuned to resemble a non-existent
sensor, the performance of which can then be simulated without the need of
actually building a prototype. Especially when looking for potential
improvements of current sensors, this enables the identification of weak links
or bottlenecks for certain use cases.

More in-depth experimentation is also conceivable, where e.g. a novel
deflector model shall be simulated. Due to the open-source license, a
developer may take the HELIOS++ framework and would only have to implement a
new deflection method, whereas the scene and all other components can be used
as is to run a simulation, testing the usability of the novel deflector model.

Especially when considering the short lifecycle of current hardware,
simulation may be the only way to ensure fitness for use of the sensor.
Equivalent simulators are widely used in remote sensing, as especially tools
working with data acquired by satellites can be developed using the simulated
data, and are then ready to use as soon as the first real data is delivered.

##  5 Computational considerations

Since modern laser scanners can measure millions of points per second, it is
crucial to have an efficient implementation for the ray-scene intersection. In
this section, we first present theoretical considerations on the ray tracing
implemented in HELIOS++, the modelling of vegetation and options of generating
large and complex scenes. In Section 5.4, a comparison between HELIOS++ and
its predecessor HELIOS is carried out.

###  5.1 Ray tracing implementation using a kD-Tree

A scene $S$ in HELIOS++ context can be mathematically described as a set of
primitives, so $S=\\{P_{1},\ldots,P_{n}\\}$. For each primitive $P$ its
boundaries are defined considering an axis-aligned bounding box, its centroid,
and the set of vertices $V=\\{v_{1},\ldots,v_{m}\\}$ composing the primitive.
Each primitive supports rotation, scaling and translation together with a
material specification defining its reflectance and specularity. Certain
primitives, such as transmissive voxels, also support a look-up table which
can be used for vegetation modelling, as explained in Section 5.2.

The scene building process consists in generating the set of primitives
composing the scene. Multiple input sources are supported (cf. Section 3.5),
so it is possible to build a scene considering Wavefront Object files, point
clouds as ASCII files specifying $(X,Y,Z)$ coordinates for each point, GeoTIFF
files, or a custom voxel file format based on AMAPVox (Vincent et al., 2017).
When building a scene, different sources can be considered, as each one is
associated to its own scene part. It is also possible to apply aforementioned
affine transformations to an entire scene part. This can be used, for
instance, to load the same object multiple times in one scene and placing it
in different locations through translations. Saving and loading already built
scenes is relying on boost serialisation technology (Ramey, 2004).

Ray intersections are computed through a recursive search performed over a kD-
Tree containing all primitives (Bentley, 1975). Let $O$ be the ray origin and
$\hat{v}$ the normalised ray direction vector. When recursively searching
through the kD-Tree starting at $O$, $\hat{v}$ is used to consider which node
must be visited until a leaf node is reached. For each recursive search
operation $s$, coordinates are analysed, so $s\equiv 0\mod 3$ means the $X$
coordinate splits the space, $s\equiv 1\mod 3$ means the Y coordinate splits
the space, and $s\equiv 2\mod 3$ means the Z coordinate splits the space. Once
inside a leaf node, ray intersections with respect to each primitive are
computed. The minimum distance intersection $t_{0}$ is the time the ray needed
to enter the primitive while $t_{1}$ is the time the ray needed to leave it.
It is possible to have only $t_{0}$ determined, as is the case for triangles,
since they are only intersected once per ray.

For the special case of primitives which support multiple ray intersections,
such as transmissive voxels, the process is repeated considering consecutive
origins. Suppose we have a transmissive voxel intersected by a ray
$\\{O_{1},\hat{v}\\}$: If this voxel lets the ray pass through it, then the
next ray intersection will be found considering the ray $\\{O_{2},\hat{v}\\}$,
with $O_{2}=O_{1}+(t_{1}+\varepsilon)\hat{v}$, where $\varepsilon$ is a small
decimal number to assure getting out of the previously intersected primitive.

###  5.2 Vegetation modelling: Transmissive voxels

Beam horizontal component | Beam vertical component | Hit probability $g_{L}$
---|---|---
1.000000 | 0.000000 | 0.424413
0.999683 | 0.025180 | 0.424682
0.998732 | 0.050345 | 0.425489
$\vdots$ | $\vdots$ | $\vdots$
0.009444 | 0.999955 | 0.848789
0.000000 | 1.000000 | 0.848822
Table 2: Values from a look-up table (LUT) for the hit probability $g_{L}$ at
a given beam direction $L$, represented by horizontal and vertical component.
The numbers here correspond to an erectophile distribution and are obtained
using a numerical integration method on the formulae from North (1996). The
probability $g_{L}$ is normalised over $2\pi$.

One of the new functionalities of HELIOS++ is vegetation modelling through
transmissive voxel primitives. For this purpose, a look-up table for leaf
angle distribution is used to compute ray intensity with respect to a $\sigma$
(cross-section) value obtained from it. The values in this look-up table
represent a hit probability $g_{L}$ given the horizontal and vertical
component of the beam vector (Tab. 2). The intensity $I$ is calculated
according to Equation 7 where $P$ is the emitted power from Equation 3
(Carlsson et al., 2001), $d$ is the distance between ray origin and
intersection point, $\alpha^{2}$ is the square of the scanner receiver
diameter, $\beta^{2}$ is the square of the scanner beam divergence and
$\lambda$ is the product between atmospheric factor and scanner efficiency.
The $\sigma$ value can be seen as function of ray direction vector
$\sigma(\hat{v})$, so it will have a different value depending on ray
incidence.

$I\propto\lambda\sigma\frac{P\alpha^{2}}{4{\pi}d^{4}\beta^{2}}$ (7)

Voxels can operate in transmissive mode. This implies the voxel will let the
ray continue and not return a signal after intersection if $\sigma=0$. If
$\sigma>0$, then the return of the ray is randomly determined by sampling a
value $u$ from a uniform distribution $\in[0,1)$ and computing
$s=\frac{-\log(u)}{\sigma}$. If the value of $s$ is greater than the distance
between both intersection points at the voxel, the ray will continue.
Otherwise, the ray will stop at the voxel. For the non-transmissive mode, only
voxels with transmittance $1.0$ will allow rays to continue.

Thus, by using detailed voxels operating in transmissive mode together with an
appropriate look-up table specification, HELIOS++ is capable of simulating
laser scanning of vegetation from a precomputed leaf angle distribution
following North (1996). To achieve high-quality output, it is recommended to
apply individual leaf angle distributions for each vegetation type within a
scene.

###  5.3 Strategy to handle large and complex scenes

When loading point clouds from ASCII xyz files, big files might not be
entirely containable in memory. For this purpose, a two-stage algorithm is
used to digest point clouds of arbitrary size. The first stage simply finds
the minimum and maximum values for each coordinate and counts the total number
of points. The second stage builds all necessary voxels to represent the point
cloud inside HELIOS++. For this purpose, a voxel grid is allocated. Then,
voxels which have points inside them are built as HELIOS++ primitives. For
each voxel its spatial coordinates $(X,Y,Z)$, normal vector components
$(N_{x},N_{y},N_{z})$ and colour components $(R,G,B)$ are considered, if
available, as may be the case for photogrammetric point clouds.

The colour for the voxel is computed as the average of each colour component
for all points inside the voxel. We approximate the sRGB color space by
averaging the squares of the red, green, and blue values, and taking the
square root of this average as the resulting value for the voxel. If normals
are provided, the voxel normal can be determined either as the normal of the
point which is closest to the voxel centre or the average of each normal
component for all points.

In case no normal vectors are provided, HELIOS++ can estimate them using
singular value decomposition (SVD, Golub and Kahan (1965)). All points inside
a voxel are considered to build a matrix of coordinates, for which singular
values and singular vectors are obtained. Then, the singular vector of the
smallest singular value is the orthonormal vector defining the plane which
best fits the point set in terms of the smallest sum of squared orthogonal
residuals. It can hence be understood as the voxel normal vector. The normal
estimation method can be applied to the entire input point cloud in a single
stage for small point clouds. If the size of input point cloud is too big with
respect to RAM, the normal estimation is performed in batch mode, dividing the
workload into smaller parts. Each batch extracts points inside its voxels
while ignoring points outside its scope.

###  5.4 Performance comparison

As the direct successor of HELIOS (Bechtold and Höfle, 2016), it is
interesting to compare the performance of HELIOS++ with the original
implementation in Java. However, HELIOS++ was not just a port of the code, but
also comes with multiple computational improvements over its predecessor. One
of these improvements concerns the ability for the user to better leverage
accuracy at the cost of runtime, or vice versa, by setting parameters
accordingly. For some tasks, a rough, thereby faster simulation may suffice,
whereas for other tasks very detailed simulation is required, but smaller
sample sizes can be used or long processing times are acceptable.

Another improvement concerns the binning mechanism for the full-waveform
simulation, which is used for maxima detection even if the waveform is not
written to an output file. In HELIOS++, we use the parameters `binSize_ns` and
`maxFullwaveRange_ns` for this binning, where the bin size is used for both
the outgoing pulse and the returned waveform. To limit the impact on
performance of very low-incidence rays with a high sampling quality, the user
can provide a maximum length of the recorded waveform, beyond which any
further echoes are discarded.

To compare the performances of HELIOS++ (Version 1.0.0) and HELIOS (Version
2018-09-24), we carry out a number of simulations using different parameter
settings, and record the runtime as well as peak memory usage. We present
three different scenes, at three different complexity levels, and make use of
the option in HELIOS++ to write different file types and to skip the echo
width determination, if not required.

The first example scenario represents an ALS survey over terrain, which is
created by loading a digital terrain model in GeoTIFF format as described in
Section 3.5. Since the GeoTIFF loader in the Java version was faulty and this
version is no longer maintained, we created a mesh in Wavefront Object format
as an input for the Java version. We simulate two flight lines at an altitude
of $1,500\text{\,}\mathrm{m}\,\mathrm{a}\mathrm{s}\mathrm{l}$ over terrain
with an extent of $26\text{\times}17.8\text{\,}\mathrm{km}$. As scanner we use
a _Leica ALS50-II_ , and a Cessna SR-22 as platform. The scene is shown in
Figure 8.

Figure 8: Visualisation of example survey for airborne laser scanning (ALS),
using a digital terrain model as object and a standard ALS instrument as
scanner. The 3”-SRTM model by the USGS is used as input raster.

The second scenario represents a mobile laser scan of an urban area, where a
car is driving through downtown buildings modelled as prisms, cylinders and
pyramids (Figure 9). The trajectory of the car is $208\text{\,}\mathrm{m}$
long and its average speed is
$20\text{\,}\mathrm{m}\text{\,}{\mathrm{s}}^{-1}$. The scanner is an oblique-
mounted _RIEGL VUX-1UAV_.

Figure 9: Visualisation of example survey for mobile laser scanning (MLS),
with a car driving between objects of simple geometry. The yellow points show
the acquired point cloud of scanned parts.

In the third and final scenario, we present a TLS survey of a vegetation scene
with a large potential for multi-echoes, as it represents two trees generated
with the Arbaro Tree Simulator (Weber and Penn, 1995), scanned using a _RIEGL
VZ-400_ from two static positions. This simulation has a large number of
geometric primitives. A visual is depicted in Figure 10.

Figure 10: Visualisation of example survey for terrestrial laser scanning
(TLS), scanning two highly complex tree models created using the Arbaro Tree
Simulator. The yellow points show the acquired point cloud of scanned parts.

Each simulation scenario was carried out three times on an Intel-i9-7900 @
$3.3\text{\,}\mathrm{GHz}$ with $64\text{\,}\mathrm{GB}$ of RAM, and I/O on an
SSD connected via SATA. The average runtime and memory consumption values are
given in Table 3.

|  | HELIOS (Java)
---
Version 2018-09-24
| HELIOS++
---
Version 1.0.0
Echo width | ✓ | ✓ |  |
Waveform output | ✓ | ✓ | ✓ |
File format | XYZ | XYZ | XYZ | LAS
| Scene 1
---
(ALS, GeoTIFF)
| $4,712.1\pm 613.8\text{\,}\mathrm{s}$
---
$6,570\text{\,}\mathrm{MB}$
| $2,773.0\pm 53.8\text{\,}\mathrm{s}$
---
$2,246\text{\,}\mathrm{MB}$
| $2,403.8\pm 18.0\text{\,}\mathrm{s}$
---
$2,246\text{\,}\mathrm{MB}$
| $1,912.1\pm 20.22\text{\,}\mathrm{s}$
---
$2,246\text{\,}\mathrm{MB}$
| Scene 2
---
(MLS, geometric
primitives)
| $68.0\pm 2.3\text{\,}\mathrm{s}$
---
$560\text{\,}\mathrm{MB}$
| $23.9\pm 0.2\text{\,}\mathrm{s}$
---
$24\text{\,}\mathrm{MB}$
| $23.0\pm 0.3\text{\,}\mathrm{s}$
---
$24\text{\,}\mathrm{MB}$
| $16.1\pm 0.6\text{\,}\mathrm{s}$
---
$24\text{\,}\mathrm{MB}$
| Scene 3
---
(TLS, tree models)
| $362.6\pm 6.7\text{\,}\mathrm{s}$
---
$5,360\text{\,}\mathrm{MB}$
| $97.2\pm 1.3\text{\,}\mathrm{s}$
---
$314\text{\,}\mathrm{MB}$
| $74.4\pm 1.0\text{\,}\mathrm{s}$
---
$314\text{\,}\mathrm{MB}$
| $62.4\pm 0.3\text{\,}\mathrm{s}$
---
$314\text{\,}\mathrm{MB}$

Table 3: Performance comparison of HELIOS and HELIOS++ with different options.
We use default parameters for waveform modelling (``beamSampleQuality=3— and
``binSize_ns=0.25—; ``numBins=100— and ``numFullwaveBins=200— for HELIOS++ and
HELIOS, respectively). Runtimes are average of three runs ($\pm$ standard
deviation), memory footprint is the highest value (maximum) during the full
run.

In the case with largest improvement over HELIOS, runtimes of HELIOS++ are
lower by 83 % (TLS) while using only 6 % of the previously required memory.
Especially for large scenes, the issue of memory footprint has been a limiting
factor for the usability of HELIOS. In the case of the ALS scene, the memory
consumption can be reduced by 66 %, from more than $6\text{\,}\mathrm{GB}$ to
just above $2\text{\,}\mathrm{GB}$, with a runtime reduction of 51 %. For the
MLS scene using the simple geometric shapes, the reduced processing overhead
leads to a reduction of 96 % in memory usage and 76 % in runtime. From these
results we deduce a significant improvement both in runtime and memory
footprint when comparing any configuration of HELIOS++ to the previous Java
version.

##  6 Conclusions

With HELIOS++, we present an open-source laser scanning simulation framework
that enables highly performant virtual laser scanning (VLS). In its C++
implementation and with the possibility to use the `pyhelios` package in
Python to manipulate simulation parameters, we opt for an efficient and easy-
to-use software. While physical accuracy and realism may be superseded by
complementing simulation software, HELIOS++ provides a flexible solution to
balance computational requirements (runtime, memory footprint) and quality of
results (physical realism), while being easy to use and configure for users.

Different studies using the HELIOS concept demonstrate the usefulness of
virtually acquired laser scanning data for analyses in different categories of
purpose. The main categories are (a) planning of flight patterns (ULS, ALS) or
scan positions (TLS); (b) generation of ground-truth data for validation of
algorithms that extract parameters (i.a. for forestry) from point clouds, (c)
generation of training data for supervised machine learning, and (d) testing
and development of novel sensors and algorithms.

The novel object model of HELIOS++, the transmissive voxel, allows a
stochastic simulation of penetrable objects, such as vegetation canopy,
without the need for a highly detailed 3D mesh model. Generally, HELIOS++
performs up to of $5.8\,\times$ faster than its predecessor HELIOS on common
scenes, and allows the user to omit intensive calculations if not required
(e.g. the calculation of the echo width for returned pulses).

To summarise, HELIOS++ is a versatile, easy-to-use, well documented scientific
software for virtual laser scanning simulations that provides a tool to
generate VLS data, thereby complementing data obtained by real-world laser
scanning. The framework invites users to experiment and develop new ideas,
while being able to rely on established algorithms from the literature.

#### Acknowledgements

The authors wish to acknowledge the contribution of Patrick Herbers (Ruhr-
Universität Bochum), for the improvement the triangle-ray intersection in C++,
which helped to significantly reduce the runtime of HELIOS++.

Figures 1, 4, 5, and 8 show an airplane model CC-BY Emmanuel Beranger. Figures
1 and 4 show a house model by free3d.com user `gerhald3d`, and a drone model
by cgtrader.com user `CGaxr`.

## References

  * ASPRS (2011) ASPRS, 2011.  LAS specification.  https://www.asprs.org/wp-content/uploads/2010/12/LAS_1_4_r13.pdf.
  * Backes et al. (2020) Backes, D., Smigaj, M., Schimka, M., Zahs, V., Grznárová, A., Scaioni, M., 2020\.  River Morphology Monitoring of a Small-Scale Alpine Riverbed using Drone Photogrammetry and LiDAR.  ISPRS - International Archives of the Photogrammetry, Remote Sensing and Spatial Information Sciences XLIII-B2-2020, 1017–1024.  doi:10.5194/isprs-archives-XLIII-B2-2020-1017-2020.
  * Bechtold et al. (2016) Bechtold, S., Hämmerle, M., Höfle, B., 2016.  Simulated full-waveform laser scanning of outcrops for development of point cloud analysis algorithms and survey planning: An application for the HELIOS LiDAR simulation framework, in: Proceedings of the 2nd Virtual Geoscience Conference, Bergen, Norway, pp. 57–58.  URL: http://lvisa.geog.uni-heidelberg.de/papers/2016/Bechtold_et_al_2016.pdf.
  * Bechtold and Höfle (2016) Bechtold, S., Höfle, B., 2016\.  HELIOS: A Multi-Purpose LiDAR Simulation Framework for Research, Planning and Training of Laser Scanning Operations with Airborne, Ground-Based Mobile and Stationary Platforms.  ISPRS Annals of Photogrammetry, Remote Sensing and Spatial Information Sciences III–3, 161–168.  doi:10.5194/isprs-annals-III-3-161-2016.
  * Bentley (1975) Bentley, J.L., 1975.  Multidimensional binary search trees used for associative searching.  Communications of the ACM 18, 509–517.  doi:https://doi.org/10.1145/361002.361007.
  * Calders et al. (2013) Calders, K., Lewis, P., Disney, M., Verbesselt, J., Herold, M., 2013.  Investigating assumptions of crown archetypes for modelling LiDAR returns.  Remote Sensing of Environment 134, 39–49.  doi:10.1016/j.rse.2013.02.018.
  * Carlsson et al. (2001) Carlsson, T., Steinvall, O., Letalick, D., 2001.  Signature simulation and signal analysis for 3-D laser radar.
  * Danielczuk et al. (2019) Danielczuk, M., Matl, M., Gupta, S., Li, A., Lee, A., Mahler, J., Goldberg, K., 2019.  Segmenting Unknown 3D Objects from Real Depth Images using Mask R-CNN Trained on Synthetic Data, in: 2019 International Conference on Robotics and Automation (ICRA), pp. 7283–7290.  doi:10.1109/ICRA.2019.8793744.
  * Disney et al. (2000) Disney, M., Lewis, P., North, P., 2000.  Monte Carlo ray tracing in optical canopy reflectance modelling.  Remote Sensing Reviews 18, 163–196.  doi:10.1080/02757250009532389.
  * Disney et al. (2010) Disney, M.I., Kalogirou, V., Lewis, P., Prieto-Blanco, A., Hancock, S., Pfeifer, M., 2010\.  Simulating the impact of discrete-return lidar system and survey characteristics over young conifer and broadleaf forests.  Remote Sensing of Environment 114, 1546–1560.  doi:10.1016/j.rse.2010.02.009.
  * Disney et al. (2009) Disney, M.I., Lewis, P.E., Bouvet, M., Prieto-Blanco, A., Hancock, S., 2009.  Quantifying Surface Reflectivity for Spaceborne LiDAR via Two Independent Methods.  IEEE Transactions on Geoscience and Remote Sensing 47, 3262–3271.  doi:10.1109/TGRS.2009.2019268.
  * Gastellu-Etchegorry et al. (2015) Gastellu-Etchegorry, J.P., Yin, T., Lauret, N., Cajgfinger, T., Gregoire, T., Grau, E., Feret, J.B., Lopes, M., Guilleux, J., Dedieu, G., Malenovský, Z., Cook, B., Morton, D., Rubio, J., Durrieu, S., Cazanave, G., Martin, E., Ristorcelli, T., 2015\.  Discrete Anisotropic Radiative Transfer (DART 5) for Modeling Airborne and Satellite Spectroradiometer and LIDAR Acquisitions of Natural and Urban Landscapes.  Remote Sensing 7, 1667–1701.  doi:10.3390/rs70201667.
  * Gastellu-Etchegorry et al. (2016) Gastellu-Etchegorry, J.P., Yin, T., Lauret, N., Grau, E., Rubio, J., Cook, B.D., Morton, D.C., Sun, G., 2016\.  Simulation of satellite, airborne and terrestrial LiDAR with DART (I): Waveform simulation with quasi-Monte Carlo ray tracing.  Remote Sensing of Environment 184, 418–435.  doi:10.1016/j.rse.2016.07.010.
  * Giannetti et al. (2018) Giannetti, F., Puletti, N., Quatrini, V., Travaglini, D., Bottalico, F., Corona, P., Chirici, G., 2018.  Integrating terrestrial and airborne laser scanning for the assessment of single-tree attributes in Mediterranean forest stands.  European Journal of Remote Sensing 51, 795–807.  doi:10.1080/22797254.2018.1482733.
  * Golub and Kahan (1965) Golub, G., Kahan, W., 1965.  Calculating the Singular Values and Pseudo-Inverse of a Matrix.  Journal of the Society for Industrial and Applied Mathematics Series B Numerical Analysis 2, 205–224.  doi:https://doi.org/10.1137/0702016.
  * Goodwin et al. (2007) Goodwin, N.R., Coops, N.C., Culvenor, D.S., 2007.  Development of a simulation model to predict LiDAR interception in forested environments.  Remote Sensing of Environment 111, 481–492.  doi:10.1016/j.rse.2007.04.001.
  * Hodge (2010) Hodge, R.A., 2010.  Using simulated Terrestrial Laser Scanning to analyse errors in high-resolution scan data of irregular surfaces.  ISPRS Journal of Photogrammetry and Remote Sensing 65, 227–240.  doi:10.1016/j.isprsjprs.2010.01.001.
  * Holmgren et al. (2003) Holmgren, J., Nilsson, M., Olsson, H., 2003.  Simulating the effects of LiDAR scanning angle for estimation of mean tree height and canopy closure.  Canadian Journal of Remote Sensing 29, 623–632.  doi:10.5589/m03-030.
  * Hämmerle et al. (2017) Hämmerle, M., Lukač, N., Chen, K.C., Koma, Z., Wang, C.K., Anders, K., Höfle, B., 2017.  Simulating Various Terrestrial and UAV LiDAR Scanning Configurations for Understory Forest Structure Modelling.  ISPRS Annals of Photogrammetry, Remote Sensing and Spatial Information Sciences IV-2/W4, 59–65.  doi:10.5194/isprs-annals-IV-2-W4-59-2017.
  * Isenburg (2013) Isenburg, M., 2013.  LASzip: lossless compression of LiDAR data.  Photogrammetric Engineering and Remote Sensing 79, 209–217.  URL: https://www.cs.unc.edu/~isenburg/lastools/download/laszip.pdf.
  * Kim et al. (2012) Kim, S., Lee, I., Lee, M., 2012.  LiDAR Waveform Simulation over Complex Targets.  ISPRS - International Archives of the Photogrammetry, Remote Sensing and Spatial Information Sciences XXXIX-B7, 517–522.  doi:10.5194/isprsarchives-XXXIX-B7-517-2012.
  * Kim et al. (2009) Kim, S., Min, S., Kim, G., Lee, I., Jun, C., 2009\.  Data simulation of an airborne lidar system, in: Turner, M.D., Kamerman, G.W. (Eds.), Laser Radar Technology and Applications XIV, SPIE. p. 73230C.  doi:10.1117/12.818545.
  * Kukko and Hyyppä (2009) Kukko, A., Hyyppä, J., 2009\.  Small-footprint Laser Scanning Simulator for System Validation, Error Assessment, and Algorithm Development.  Photogrammetric Engineering & Remote Sensing 75, 1177–1189.  doi:10.14358/PERS.75.10.1177.
  * Lewis (1999) Lewis, P., 1999.  Three-dimensional plant modelling for remote sensing simulation studies using the Botanical Plant Modelling System.  Agronomie 19, 185–210.  doi:10.1051/agro:19990302.
  * Lewis and Muller (1993) Lewis, P., Muller, J.P., 1993\.  The advanced radiometric ray tracer: Ararat for plant canopy reflectance simulation.  Proc. 29th Conf. Int. Soc. Photogramm. Remote Sens. 29.  URL: http://www.isprs.org/proceedings/XXIX/congress/part7/26_XXIX-part7.pdf.
  * Li et al. (2020) Li, L., Mu, X., Soma, M., Wan, P., Qi, J., Hu, R., Zhang, W., Tong, Y., Yan, G., 2020.  An Iterative-Mode Scan Design of Terrestrial Laser Scanning in Forests for Minimizing Occlusion Effects.  IEEE Transactions on Geoscience and Remote Sensing , 1–20doi:10.1109/TGRS.2020.3018643.
  * Pires de Lima and Marfurt (2019) Pires de Lima, R., Marfurt, K., 2019\.  Convolutional Neural Network for Remote-Sensing Scene Classification: Transfer Learning Analysis.  Remote Sensing 12, 86\.  URL: http://dx.doi.org/10.3390/rs12010086, doi:10.3390/rs12010086.
  * Lin and Wang (2019) Lin, C.H., Wang, C.K., 2019\.  Point Density Simulation for ALS Survey, in: Proceedings of the 11th International Conference on Mobile Mapping Technology (MMT2019), pp. 157–160.  URL: https://www.geog.uni-heidelberg.de/md/chemgeo/geog/gis/mmt2019-lin_and_wang_compr.pdf.
  * Liu et al. (2019a) Liu, J., Skidmore, A.K., Wang, T., Zhu, X., Premier, J., Heurich, M., Beudert, B., Jones, S., 2019a.  Variation of leaf angle distribution quantified by terrestrial LiDAR in natural European beech forest.  ISPRS Journal of Photogrammetry and Remote Sensing 148, 208–220.  doi:10.1016/j.isprsjprs.2019.01.005.
  * Liu et al. (2019b) Liu, J., Wang, T., Skidmore, A.K., Jones, S., Heurich, M., Beudert, B., Premier, J., 2019b.  Comparison of terrestrial LiDAR and digital hemispherical photography for estimating leaf angle distribution in European broadleaf beech forests.  ISPRS Journal of Photogrammetry and Remote Sensing 158, 76–89.  doi:10.1016/j.isprsjprs.2019.09.015.
  * Lohani and Mishra (2007) Lohani, B., Mishra, R.K., 2007\.  Generating LiDAR Data in Laboratory: LiDAR Simulator, in: ISPRS Workshop on Laser Scanning 2007 and SilviLaser 2007, pp. 264–269.  URL: https://www.isprs.org/proceedings/XXXVI/3-W52/final_papers/Lohani_2007.pdf.
  * Lovell et al. (2005) Lovell, J.L., Jupp, D., Newnham, G.J., Coops, N.C., Culvenor, D.S., 2005.  Simulation study for finding optimal LiDAR acquisition parameters for forest height retrieval.  Forest Ecology and Management 214, 398–412.  doi:10.1016/j.foreco.2004.07.077.
  * Martínez Sánchez et al. (2019) Martínez Sánchez, J., Váquez Alvarez, A., López Vilarino, D., Fernández Rivera, F., Cabaleiro Domínguez, J.C., Fernández Pena, T., 2019.  Fast Ground Filtering of Airborne LiDAR Data Based on Iterative Scan-Line Spline Interpolation.  Remote Sensing 11, 2256\.  doi:10.3390/rs11192256.
  * Morsdorf et al. (2007) Morsdorf, F., Frey, O., Koetz, B., Meier, E., 2007\.  Ray Tracing for Modeling of Small Footprint Airborne Laser Scanning Returns.  doi:10.3929/ETHZ-B-000107380.
  * North (1996) North, P., 1996.  Three-dimensional forest light interaction model using a Monte Carlo method.  IEEE Transactions on Geoscience and Remote Sensing 34, 946–956.  doi:10.1109/36.508411.
  * North et al. (2010) North, P.R.J., Rosette, J.A.B., Suárez, J.C., Los, S.O., 2010\.  A Monte Carlo radiative transfer model of satellite waveform LiDAR.  International Journal of Remote Sensing 31, 1343–1358.  doi:10.1080/01431160903380664.
  * Park et al. (2020) Park, M., Baek, Y., Dinare, M., Lee, D., Park, K.H., Ahn, J., Kim, D., Medina, J., Choi, W.J., Kim, S., et al., 2020.  Hetero-integration enables fast switching time-of-flight sensors for light detection and ranging.  Scientific Reports 10, 2764\.  doi:10.1038/s41598-020-59677-x.
  * Previtali et al. (2019) Previtali, M., Díaz-Vilariño, L., Scaioni, M., Frías Nores, E., 2019\.  Evaluation of the Expected Data Quality in Laser Scanning Surveying of Archaeological Sites, in: 4th International Conference on Metrology for Archaeology and Cultural Heritage, Florence, Italy, pp. 19–24.  URL: https://re.public.polimi.it/retrieve/handle/11311/1124569/476842/Previtali%20et%20al%202019%20MetroArchaeo.pdf.
  * Qi et al. (2017) Qi, C.R., Yi, L., Su, H., Guibas, L.J., 2017.  PointNet++: Deep hierarchical feature learning on point sets in a metric space, in: Advances in Neural Information Processing Systems, pp. 5099–5108.
  * Ramey (2004) Ramey, R., 2004.  C++ BOOST Serialization.  URL: https://www.boost.org/doc/libs/1_72_0/libs/serialization/doc/index.html.
  * Ranson and Sun (2000) Ranson, K.J., Sun, G., 2000\.  Modeling LiDAR Returns from Forest Canopies.  IEEE Transactions on Geoscience and Remote Sensing 38, 2617–2626.  doi:10.1109/36.885208.
  * Rebolj et al. (2017) Rebolj, D., Pučko, Z., Babič, N.C., Bizjak, M., Mongus, D., 2017.  Point cloud quality requirements for Scan-vs-BIM based automated construction progress monitoring.  Automation in Construction 84, 323–334.  doi:10.1016/j.autcon.2017.09.021.
  * Schlager et al. (2020) Schlager, B., Muckenhuber, S., Schmidt, S., Holzer, H., Rott, R., Maier, F.M., Saad, K., Kirchengast, M., Stettinger, G., Watzenig, D., Ruebsam, J., 2020.  State-of-the-Art Sensor Models for Virtual Testing of Advanced Driver Assistance Systems/Autonomous Driving Functions.  SAE International Journal of Connected and Automated Vehicles 3, 233–261.  doi:10.4271/12-03-03-0018.
  * Schäfer et al. (2019) Schäfer, J., Faßnacht, F., Höfle, B., Weiser, H., 2019\.  Das SYSSIFOSS-Projekt: Synthetische 3D-Fernerkundungsdaten für verbesserte Waldinventurmodelle, in: 2\. Symposium zur angewandten Satellitenerdbeoachtung, Cologne, Germany.  URL: https://www.dialogplattform-erdbeobachtung.de/downloads/cms/Stele3/EO-Symposium_Jannika.Schaefer.pdf.
  * Tulldahl and Steinvall (1999) Tulldahl, H.M., Steinvall, K.O., 1999\.  Analytical waveform generation from small objects in LiDAR bathymetry.  Applied optics 38, 1021–1039.  doi:10.1364/ao.38.001021.
  * Vincent et al. (2017) Vincent, G., Antin, C., Laurans, M., Heurtebize, J., Durrieu, S., Lavalley, C., Dauzat, J., 2017.  Mapping plant area index of tropical evergreen forest by airborne laser scanning. A cross-validation study using LAI2200 optical sensor.  Remote Sensing of Environment 198, 254 – 266.  URL: http://www.sciencedirect.com/science/article/pii/S003442571730233X, doi:https://doi.org/10.1016/j.rse.2017.05.034.
  * Wang (2020) Wang, D., 2020.  Unsupervised semantic and instance segmentation of forest point clouds.  ISPRS Journal of Photogrammetry and Remote Sensing 165, 86–97.  doi:10.1016/j.isprsjprs.2020.04.020.
  * Wang et al. (2020) Wang, D., Schraik, D., Hovi, A., Rautiainen, M., 2020\.  Direct estimation of photon recollision probability using terrestrial laser scanning.  Remote Sensing of Environment 247, 111932.  doi:10.1016/j.rse.2020.111932.
  * Wang et al. (2013) Wang, Y., Xie, D., Yan, G., Zhang, W., Mu, X., 2013\.  Analysis on the inversion accuracy of LAI based on simulated point clouds of terrestrial LiDAR of tree by ray tracing algorithm, in: IGARSS 2013-2013 IEEE International Geoscience and Remote Sensing Symposium, IEEE, Piscataway. pp. 532–535.  doi:10.1109/IGARSS.2013.6721210.
  * Wavefront Technologies (1992) Wavefront Technologies, 1992.  Appendix B1. Object Files (.obj), Advanced Visualizer Manual.  URL: http://fegemo.github.io/cefet-cg/attachments/obj-spec.pdf.
  * Weber and Penn (1995) Weber, J., Penn, J., 1995.  Creation and rendering of realistic trees, in: Mair, S.G., Cook, R. (Eds.), Computer graphics proceedings, Association for Computing Machinery, New York, NY. pp. 119–128.  doi:10.1145/218380.218427.
  * Weiser et al. (2021) Weiser, H., Winiwarter, L., Fassnacht, F., Höfle, B., 2021\.  Opaque Voxel-based Tree Models for Virtual Laser Scanning in Forestry Applications.  In preparation.
  * Winiwarter et al. (2019) Winiwarter, L., Mandlburger, G., Schmohl, S., Pfeifer, N., 2019\.  Classification of ALS Point Clouds Using End-to-End Deep Learning.  PFG – Journal of Photogrammetry, Remote Sensing and Geoinformation Science URL: https://doi.org/10.1007/s41064-019-00073-0, doi:10.1007/s41064-019-00073-0.
  * Winiwarter et al. (2021) Winiwarter, L., Pena, A.M.E., Weiser, H., Anders, K., Saches, J.M., Searle, M., Höfle, B., 2021.  3dgeo-heidelberg/helios: Version 1.0.0.  URL: https://doi.org/10.5281/zenodo.4452871, doi:10.5281/zenodo.4452871.
  * Xiao et al. (2019) Xiao, W., Zaforemska, A., Smigaj, M., Wang, Y., Gaulton, R., 2019.  Mean shift segmentation assessment for individual forest tree delineation from airborne lidar data.  Remote Sensing 11, 1263\.  doi:10.3390/rs11111263.
  * Zhang et al. (2019) Zhang, Z., Li, J., Guo, Y., Yang, C., Wang, C., 2019\.  3D Highway Curve Reconstruction From Mobile Laser Scanning Point Clouds.  IEEE Transactions on Intelligent Transportation Systems , 1–11doi:10.1109/TITS.2019.2946259.
  * Zhu et al. (2020) Zhu, X., Liu, J., Skidmore, A.K., Premier, J., Heurich, M., 2020.  A voxel matching method for effective leaf area index estimation in temperate deciduous forests from leaf-on and leaf-off airborne LiDAR data.  Remote Sensing of Environment 240\.  doi:10.1016/j.rse.2020.111696.