Keywords

These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

1 Introduction

Delaunay tessellations have been employed in various scientific and engineering applications, including FEM analysis, computer graphics, medical applications, the modeling of deformable objects, and terrain modeling [8]. In present day, incremental algorithms are considered as state-of-the-art methods to build Delaunay tessellations in various point distributions [7].

The efficiency of an incremental algorithm for generating Delaunay tessellations is profoundly influenced by the point-insertion sequence, as both the numbers of orientation operations and conflicting polytopes depend on the insertion order (e.g. see [9] and references therein). In addition, paging policies and modern hierarchical memory architecture benefit programs that consider locality of reference. In particular, spatial locality is achieved when a sequence of recent memory references is grouped locally rather than randomly in the memory address space. Therefore, spatial locality should be considered highly significant in the design of algorithms. Thus, an efficient incremental algorithm for Delaunay tessellations uses properly the cache hierarchy to obtain high cache hit rates.

In an important paper in this field, Amenta et al. [1] evaluated the sequence in which the points are added to the mesh with the Biased Randomized Insertion Order (BRIO) technique. In this approach, an adequate spatial location of points is assumed to produce a large amount of cache hits.

Liu and Snoeyink [10] presented an incremental algorithm for building Delaunay tessellations in which points are added to the mesh in the sequence provided by the Hilbert curve. Liu and Snoeyink [10] and Schrijvers et al. [11] provide a complete description about the influence of selecting the sequential order and the proper quantity of randomness. Zhou and Jones [14], Buchin [5, 6], and Boissonnat et al. [4] also evaluated methods that integrate randomness with deterministic orders. Thus, currently, the incremental algorithm for Delaunay tessellations implemented in the latest version of the Computational Geometry Algorithms Library (CGAL) [12] employs the Hilbert space-filling curve order combined with the BRIO scheme [1]. Specifically, the incremental algorithm that uses the BRIO–Hilbert strategy with spatial middle policy employed in CGAL [12] splits each partition exactly at its center [12] (https://doc.cgal.org/latest/Spatial_sorting/index.html). Instead of subdividing each partition in a rigid way at its center, the incremental algorithm that uses the BRIO–Hilbert strategy with spatial median policy employed in CGAL [12] subdivides each partition considering the median point alternately in each coordinate. To be more specific, these incremental algorithms implemented in CGAL [12] organize the point set in random buckets of increasing sizes, and the Hilbert order is used only inside a bucket [12]. Thus, these geometric algorithms available in CGAL [12] combine randomness and spatial locality [1]. A number of works [1, 4,5,6, 14] have demonstrated that this approach yields sufficient randomness to incorporate the gains of both random and locality provided by a space-filling curve order when generating Delaunay tessellations.

Liu et al. [9] presented an incremental method for generating 3-D Delaunay tessellations in which points are added to the mesh conforming to a level-order traversal of the cut-longest-edge kd–tree. Liu et al. [9] exhibited extensive experiments in which this incremental algorithm with point-insertion sequence provided by the cut-longest-edge kd–tree order outpaced the preceding possible state-of-the-art method (an incremental algorithm with point-insertion sequence provided by the Hilbert curve [10]) in various 3-D point distributions. Recently [7], this incremental algorithm with point-insertion sequence provided by the cut-longest-edge kd–tree surpassed incremental algorithms with several point-insertion sequences. In this publication [7], the experiments focused on implementation characteristics of incremental algorithms employing deterministic orders (i.e. without the use of randomness) to build Delaunay tessellations in seven 3-D point distributions (i.e. the same 3-D point distributions used by Liu et al. [9]).

Liu et al. [9] compared their algorithm with the incremental algorithm implemented in the 4.0 version of CGAL (in 2013), which did not use the middle and median policies. In particular, the median policy employed in the incremental algorithm for Delaunay tessellations implemented in the latest version of CGAL [12] is similar to the idea of the kd–tree order introduced by Liu et al. [9] in their algorithm. A difference in these schemes is that Liu et al. [9] used a cut-longest-edge strategy instead of splitting the partition alternately in each coordinate, which is the original approach of the kd–tree order [3].

The purpose of this present paper is to conduct a comparison of three state-of-the-art incremental algorithms for generating 3-D Delaunay tessellations. Specifically, this work evaluates the algorithm with point-insertion sequence provided by the cut-longest-edge kd–tree against the BRIO–Hilbert order (i.e. with the use of randomness) using spatial middle and median policies in inexact predicates employed in the 4.11 version of CGAL, which was released in September of 2017 [12].

To evaluate the three incremental algorithms for 3-D Delaunay tessellations, this present computational experiment uses eight 3-D point distributions, with sets ranging from 1 to 40 million points. Specifically, the unit interval is used as domain in our experiments. In addition, four 3-D test models are used in the experiments.

The remainder of this paper is structured as follows. Section 2 presents and analyzes the results. Finally, Sect. 3 addresses the conclusions.

2 Results and Analysis

The three incremental algorithms evaluated here were implemented in the C++ programming language. The g++ 4.6.3-1 compiler was used. The experiments were performed on an Intel® Xeon® E5620 CPU 2.40 GHz (12 MB cache, 24GB of main memory 1067MHz) (Intel; Santa Clara, CA, USA) workstation. The Ubuntu 16.04.3 64-bits operating system was used in this machine, with kernel 4.4.0-98-generic.

Table 1 and Figs. 1, 2, 3 and 4 show the results of execution times in eight point distributions in the 3-D unit cube when using three point-insertion sequences in incremental algorithms for building Delaunay tessellations: random points, points on a cylinder, points around a disk, points around three planes, points along three axes, points around a paraboloid, points around a spiral, and points on a saddle. Three executions were carried out for each point set, ranging from 1 to 40 million points. Numbers in bold face in Table 1 are the best results.

Table 1. Execution times (in seconds) of incremental algorithms with point-insertion sequence provided by three orders [CGAL BRIO–Hilbert order with spatial middle (SMi) and median (SMe) policies, and cut-longest-edge kd–tree (KDt)] in eight 3-D point distributions (\(N*10^6\)).
Full size table

Although the BRIO–Hilbert strategy together with the middle policy has obtained higher execution costs than the other two incremental algorithms evaluated here when applied to instances composed of 30 and 35 million points around a spiral, the BRIO–Hilbert order with middle policy obtained lower execution costs when applied to instances comprised of 40 million points in this 3-D point distribution. Thus, the trends remained consistent over the eight 3-D point distributions used. Although Table 1 shows that the execution times of the algorithm with point-insertion sequence provided by the BRIO–Hilbert order along with the spatial middle policy employed in the latest version of CGAL [12] are lower than the two other algorithms evaluated in the eight 3-D point distributions used, Figs. 1, 2, 3 and 4 indicate that in most of the cases the differences between the algorithms are rather small.

Fig. 1.
figure 1

Execution times (in seconds) of incremental algorithms with three point-insertion sequences evaluated in two point distributions (points along three axes and points on a cylinder) on the 3-D unit cube.

Full size image
Fig. 2.
figure 2

Execution times (in seconds) of incremental algorithms with three point-insertion sequences evaluated in two point distributions (points around a disk and points around a paraboloid) on the 3-D unit cube.

Full size image
Fig. 3.
figure 3

Execution times (in seconds) of incremental algorithms with three point-insertion sequences evaluated in two point distributions (points around three planes and random points) on the 3-D unit cube.

Full size image
Fig. 4.
figure 4

Execution times (in seconds) of incremental algorithms with three point-insertion sequences evaluated in two point distributions (points around a saddle and points around a spiral) on the 3-D unit cube.

Full size image

Figures 5, 6, 7 and 8 show that the memory requirements of the three point-insertion sequences in incremental algorithms for building 3-D Delaunay tessellations analyzed in this computational experiment are very similar when applied to instances arising from eight point distributions in the 3-D unit cube. In particular, we used the sysconf function to record the memory consumption. This computational experiment shows that the execution times and memory usage of the algorithm with point-insertion sequence provided by the BRIO–Hilbert order along with the spatial middle policy used in the latest version of Computational Geometry Algorithms Library [12] are slightly lower than the two other algorithms evaluated in the eight 3-D point distributions used.

Fig. 5.
figure 5

Memory requirements (MiB) of incremental algorithms with three point-insertion sequences evaluated in two point distributions (points along three axes and points on a cylinder) on the 3-D unit cube.

Full size image
Fig. 6.
figure 6

Memory requirements (MiB) of incremental algorithms with three point-insertion sequences evaluated in two point distributions (points around a disk and points around a paraboloid) on the 3-D unit cube.

Full size image
Fig. 7.
figure 7

Memory requirements (MiB) of incremental algorithms with three point-insertion sequences evaluated in two point distributions (points around three planes and random points) on the 3-D unit cube.

Full size image
Fig. 8.
figure 8

Memory requirements (MiB) of incremental algorithms with three point-insertion sequences evaluated in two point distributions (points around a saddle and points around a spiral) on the 3-D unit cube.

Full size image

Exploratory investigations with both schemes employed in CGAL [12] using exact predicates showed that the spatial median policy dominated the spatial middle policy in seven 3-D point distributions. Specifically, the incremental algorithm with point-insertion sequence provided by the BRIO–Hilbert order with spatial middle policy achieved lower execution times than the spatial median policy only when applied to instances from points along three axes.

Four 3-D test models available on two different repositories [2, 13] were used in this computational experiment. Table 2 and Fig. 9 show that the execution times of the incremental algorithm with point-insertion sequence provided by the cut-longest-edge kd–tree order were lower than the two other incremental algorithms evaluated in this computational experiment when applied to three (Vellum manuscript, Asian Dragon [13], and Napoleon [2]) 3-D test models used here. On the other hand, the incremental algorithm with point-insertion sequence provided by the BRIO–Hilbert order alongside spatial middle policy obtained lower execution times than the two other incremental algorithms evaluated in our experiments when applied to the Thai Statue 3-D test model [13] (see Fig. 10). In addition, Fig. 11 shows that the memory requirements of the incremental algorithm with point-insertion sequence provided by the cut-longest-edge kd–tree were slightly larger than the two other incremental algorithms evaluated here when applied to these four standard 3-D test models.

Table 2. Execution times (in seconds) of incremental algorithms with point-insertion sequence provided by three orders [CGAL BRIO–Hilbert order with spatial middle (SMi) and median (SMe) policies, and cut-longest-edge kd–tree (KDt)] applied to four 3-D test models (Vellum manuscript, Asian Dragon, Thai Statue [13], and Napoleon [2]).
Full size table
Fig. 9.
figure 9

Execution times (in seconds) of incremental algorithms with three point-insertion sequences evaluated for four 3-D test models (see Fig. 10).

Full size image
Fig. 10.
figure 10

Four 3-D test models: Vellum manuscript, Asian Dragon, Thai Statue [13], and Napoleon [2]).

Full size image
Fig. 11.
figure 11

Memory requirements (MiB) of incremental algorithms with three point-insertion sequences evaluated for four 3-D test models (see Fig. 10).

Full size image

3 Conclusions

This work evaluated three point-insertion sequences in incremental algorithms for 3-D Delaunay tessellations. Experiments were performed in instances ranging from 1 to 40 million points.

The median policy implemented in the latest version of CGAL [12] is similar to the sequence provided by the kd–tree order. Despite this fact, the incremental algorithm with point-insertion sequence provided by the cut-longest-edge kd–tree order obtained, in a larger number of runs, lower execution costs than the BRIO–Hilbert order along with the median policy implemented in this version of CGAL [12]. Moreover, the incremental algorithm with point-insertion sequence provided by the cut-longest-edge kd–tree obtained overall lower execution costs than the two other incremental algorithms included in our experiments when applied to small 3-D test models (see Table 2). In spite of this and also despite the fact that the CGAL default constructor applies the median policy, the incremental algorithm with point-insertion sequence provided by the BRIO–Hilbert order combined with spatial middle policy employed in the latest version of CGAL [12] obtained slightly lower execution times and slightly smaller memory requirements than the two other algorithms evaluated in the eight 3-D point distributions and in the largest 3-D test model used. These results are consistent with the findings presented in the literature. Therefore, the incremental algorithm with point-insertion sequence provided by the BRIO–Hilbert order combined with spatial middle policy in inexact predicates employed in the latest version of CGAL [12] can be considered as the current state-of-the-art method for the building of Delaunay tessellations in the eight 3-D point distributions that were included in our experiments.

We plan to evaluate an incremental algorithm with point-insertion sequence provided by the cut-longest-edge kd–tree in tandem with the BRIO scheme against the other strategies analyzed in this appraisal. In addition, we intend to implement parallel versions of these methods.