1 Introduction

Meshes are employed in a number of applications, particularly in finite element discretizations, and are key tools in scientific computing. In this field of study, common meshes are Delaunay tessellations. For a d-dimensional point set, a Delaunay tessellation is described as a mesh in which the d-dimensional ball of each polytope lacks inner points. These meshes are popular mainly because they can be built rapidly and have very appealing geometric properties; for example, the Voronoi diagram, a dual mesh of the Delaunay tessellation, may capture proximity (Gonzaga de Oliveira et al. 2014). Furthermore, Delaunay tessellations are used to represent discrete places of a continuous space in a manner that permits the use of numerical methods to compute characteristics of that space (Edelsbrunner 2001). Delaunay tessellations and Voronoi diagrams have been employed in several applications in science and engineering, such as computer graphics, industrial design, medical applications, the modeling of composite and porous materials, deformable objects, molecules, and terrain, the tessellation of solid shapes, and video games (Gonzaga de Oliveira et al. 2014).

Currently, incremental algorithms may be seen as the lowest-cost computational methods to generate Delaunay tessellations in several point distributions. In particular, Liu et al. (2013) showed simulations in which an incremental algorithm with point-insertion order given by the cut-longest-edge kd-tree outperformed the previous possible state-of-the-art algorithm [an incremental algorithm with point-insertion order given by the Hilbert curve (Liu and Snoeyink 2005)] for this task in several 3-D point distributions.

It should be noticed that algorithms for Delaunay tessellations may have different performances in different point distributions. Since Liu et al. (2013) applied the computational geometry algorithms library (CGAL) in their implementation, our approach employs a specific implementation to verify if similar results are found. Moreover, a comparison of different point-insertion sequences for incremental Delaunay tessellation algorithms is conducted with various point distributions, from uniform cases to non-uniform cases. Computational cost and memory requirements are measured. To be more precise, in our approach, eight incremental algorithms were implemented using our own geometric methods. It is important to remark that the execution time under diverse implementations will differ. In our assessment, given the fact that we are re-implementing the Liu–Yan–Lo and Hilbert-curve incremental algorithms, it is possible to verify whether the same behavior of the computational costs and memory requirements is encountered. Then, we could investigate the influence of the CGAL framework in the results. Thereby, our approach focuses on implementation details of incremental algorithms using deterministic orders (without randomness) to generate Delaunay triangulations in seven 3-D point distributions [the same ones employed by Liu et al. (2013)] and also in six 2-D point distributions. To provide more specific detail, our domains are the unit cube and unit square, instead of integer domains, such as employed by Schrijvers et al. (2013) and other authors. Thus, eight point-insertion sequences are evaluated in the 2-D and 3-D unit intervals:

  1. 1.

    the Hilbert space-filling curve (Liu and Snoeyink 2005);

  2. 2.

    the Lebesgue curve, also called Z-order and Morton order (Bader 2012);

  3. 3.

    the H-indexing (Niedermeier et al. 2002);

  4. 4.

    the spiral ordering;

  5. 5.

    the random order;

  6. 6.

    the cut-longest-edge kd-tree (Liu et al. 2013);

  7. 7.

    the in-order and level-order red–black tree traversals.

To our knowledge, this paper is the first (published) instance employing the H-indexing scheme (Niedermeier et al. 2002), the spiral ordering and the in-order and level-order red–black tree traversals being used in incremental algorithms for Delaunay tessellations. In particular, the Peano and Sierpiński curves were not evaluated in this study because Schrijvers et al. (2013) found that the performances shown by these curves are inferior to the performance shown by the Hilbert curve in incremental algorithms.

Additionally, for seven incremental algorithms – that is, except the incremental algorithm using the cut-longest-edge kd-tree – three approaches are evaluated that seek the tetrahedron that contains the point inserted most recently into the tessellation. The Liu–Yan–Lo incremental algorithm (Liu et al. 2013) was implemented for the cut-longest-edge kd-tree.

Section 2 presents a brief review on insertion schemes in algorithms for generating Delaunay tessellations. Section 3 describes the incremental algorithms, with orders given by the eight point-insertion sequences implemented. Section 4 describes the tests. Section 5 presents and analyzes the results. Finally, Sect. 6 addresses the conclusions.

2 Review on insertion schemes

Delaunay and Voronoi tessellations have been broadly investigated, and many methods have been used to build these structures. A detailed description about the development of algorithms for generating these meshes is provided in Gonzaga de Oliveira et al. (2014). In particular, with the biased randomized insertion order (BRIO) algorithm, Amenta et al. (2003), considered the order in which the points are inserted into the tessellation. In this algorithm, the spatial location of points is deemed to cause a larger number of cache hits. In particular, some results with respect to cache misses are presented below (see Sect. 5).

Carey (1997) presented a number of techniques to generate the Delaunay tessellation, such as the incremental approach. This author explained that the Hilbert curve is a good choice of space-filling curve pattern in terms of minimizing the locality of objects within the multi-dimensional space. The Hilbert curve is easily constructed by means of repeated reflections and rotations. Since the Hilbert curve leads to a linear sequence, locality is preserved in this approach.

Based on the idea of a larger number of cache hits, Liu and Snoeyink (2005) proposed an incremental algorithm for generating Delaunay tessellations in which points are inserted into the tessellation in the order given by the Hilbert curve. Liu and Snoeyink (2005) and Schrijvers et al. (2013) give very detailed information about the various effects of choosing the order, choosing the right amount of randomness, etc. Moreover, Liu and Snoeyink (2005), Zhou and Jones (2005), Buchin (2005, (2007), and Boissonnat et al. (2009) have shown algorithms that use some combination of randomness and deterministic orders.

On the other hand, one can consider that it is more important that the various parts of the data structure and algorithms used work well together. This is also the key improvement of the Liu–Snoeyink algorithm (Liu and Snoeyink 2005) over the BRIO scheme (Amenta et al. 2003). This in turn means that it is quite important to also consider carefully the specifics of the Delaunay triangulation implementation used, if it is not a standard one (such as the one used here), because it may have a considerably higher effect on the performance than the specific order [see Liu and Snoeyink (2005); Zhou and Jones (2005); Buchin (2005, (2007); Boissonnat et al. (2009)].

Schrijvers et al. (2013) provided computational experiments showing that an algorithm with point-insertion order given by the Hilbert order (Liu and Snoeyink 2005) superseded several algorithms (including algorithms with some kind of randomness) in six 2-D data distributions (which three of them are also considered here). Despite several other proposals and simulations in the following years, probably until 2013, the Liu–Snoeyink algorithm (Liu and Snoeyink 2005) was the possible state-of-the-art algorithm for generating Delaunay tessellations. In 2013, Liu et al. (2013) proposed an incremental algorithm that outperformed the incremental algorithm using the Hilbert curve (Liu and Snoeyink 2005) to generate Delaunay tessellations in seven 3-D point distributions.

3 Description of point-insertion sequences in the incremental algorithms implemented

In incremental algorithms for Delaunay tessellations, the order in which the points are inserted into the tessellation influences the computational cost of the algorithm. It affects the time for both point location and structure update, and consequently the overall execution time of the incremental DT algorithm (Liu et al. 2013). This influence occurs because the computational costs of these algorithms depend on the number of tetrahedrons checked in the circumsphere test. In this test, a procedure verifies whether a point is inside a tetrahedron using a relatively expensive circumsphere test. Since a low-cost approach must check a small number of tetrahedrons, we evaluated three approaches (termed hist_tet, lst_tet, and tet_inc) to seek the tetrahedron that contains the most recently inserted point into the tessellation. We describe these approaches in Sect. 4. In addition, the computational costs of these algorithms also depend on updates in the tessellation, i.e., the computational cost for updating a Delaunay tessellation is proportional to the number of created and destroyed tetrahedrons.

Algorithm 1 shows a pseudocode related to the algorithms implemented in this work. Entry points of Algorithm 1 can be inserted into the tessellation through different ways. Consequently, entry points are ordered in line 2 of Algorithm 1.

figure a

The following is a brief description of point-insertion sequences in the incremental algorithms implemented.

  • Cut-longest-edge kd-tree: This is used in the incremental algorithm that is the possible state-of-the-art algorithm for generating Delaunay tessellations for seven 3-D point distributions (Liu et al. 2013). In this order, points are inserted into the tessellation according to a level-order traversal of the cut-longest-edge kd-tree (Liu et al. 2013).

  • Hilbert and Lebesgue curves: aiming to order the set of points using the 2-D or 3-D Hilbert and Lebesgue curves, the domain is divided into \(2^{2k}\) or \(2^{3k}\) subdivisions, respectively, where k is a number large enough so that each subdivision contains a small number of points. When necessary, these subdivisions are divided again until each subdivision contains only one point. The Hilbert curve was implemented here because it was used in the algorithm that was the possible state-of-the-art algorithm for the generation of Delaunay tessellations until 2013. Additionally, the Lebesgue curve was chosen to be implemented because Schamberger and Wierum (2005) noted that for data arranged in a spiral distribution and for data distributed uniformly, the Lebesgue curve showed better results than the \(\beta \Omega \)-indexing, Hilbert, and Sierpiński curves. The Lebesgue curve required a smaller quantity of domain partitions than the other three orders. Although the 3-D Lebesgue curve was also tested by Snoeyink and Liu (2005), these tests were not in the seven 3-D point distributions tested here and were not in the unit interval.

  • Spiral ordering: The domain subdivisions are traversed from left to right, bottom to top, from right to left, and from top to bottom. This path is performed again, more internally until all domain subdivisions are covered. By using the 3-D spiral ordering, initially, the points are ordered by their z coordinates; soon after, points with the same z coordinates are ordered using the spiral ordering. If two or more points are in the same subdivision, the indexing scheme is applied again in this subdivision. Duff and Meurant (1989) studied 17 ordering methods and their effects when ordering unknowns of linear systems arising from finite difference discretizations on the convergence of the Preconditioned Conjugate Gradient Method. These authors concluded, through testing, that the spiral ordering showed good results for all sets tested.

  • H-indexing: the H-indexing scheme is based on a 2-D variant of the Sierpiński curve. By using the 3-D H-indexing, initially, the points are ordered by their z coordinates; soon after, points with the same z coordinates are ordered using the H-indexing. It should be noticed that this ordering step is not necessary in 2-D point distributions. If two or more points are in the same subdivision, the indexing scheme is applied again in this subdivision. Niedermeier et al. (2002) proved that this scheme has better locality than the Hilbert indexes.

  • Red–black tree with in-order and level-order traversals: Duff and Meurant (1989) showed that the sequence given by the red–black tree was very competitive with other sequences tested.

  • Random order: this point-insertion sequence was evaluated here for being the most basic scheme for inserting points into a tessellation.

4 Description of the tests

The eight incremental algorithms were implemented in the C++ programming language. Specifically, the g++ 4.6.3-1 compiler was used, with the optimization flag –O3. A placement test was used to maintain tetrahedron points in a counterclockwise direction. This step was necessary for the circumsphere test to return consistent results. For all 2-D and 3-D point-insertion sequences, six and seven point distributions were used, which are shown in Figs. 1 and 2, respectively.

Fig. 1
figure 1

Six point distributions on the unit square: a random; b cross; c line; d cluster; e circle; and f spiral distributions. Each set was composed of 50,000 points

Full size image
Fig. 2
figure 2

Seven point distributions on the 3-D unit interval: a random points in a unit cube; b points on a cylinder; c points around a disk; d points around three planes; e points along three axes; f points around a paraboloid; and g points around a spiral. Each set was composed of 25,000 points

Full size image

Except for the incremental algorithm with a point-insertion sequence in the order given by the cut-longest-edge kd-tree, three approaches to seek a point p to be inserted into the tessellation were tested for the other seven incremental algorithms implemented. These three approaches are described below.

  • hist_tri (hist_tet): triangles (tetrahedrons) were verified in the reverse order in which they were inserted into the tessellation.

  • lst_tri (lst_tet): a breadth-first search beginning in the last triangle (tetrahedron) created was performed. To provide more specific detail, a procedure checks if the last polytope created (t) contains the point p. If p is not contained in t, its neighbors are checked. This procedure traverses the mesh in breadth-first order to find the polytope that contains p.

  • tri_inc (tet_inc): k incident triangles (tetrahedrons) to the last point p inserted into the tessellation were checked. If a circumcircle (circumsphere) of a triangle (tetrahedron) containing the point p was not found, adjacent triangles (tetrahedrons) to the k triangles (tetrahedrons) were also sought, from the least to the most recently verified triangle (tetrahedron).

These searches terminated when a circumcircle (circumsphere) of a triangle (tetrahedron) containing p was found. For the incremental algorithm with a point-insertion sequence given by the cut-longest-edge kd-tree, the search of the triangle (tetrahedron) containing a point p was performed as described by Liu et al. (2013).

The workstations used in the execution of the simulations contained the following (Intel® CoreTM; Santa Clara, CA, USA):

  • (M1) i3 CPU 550 3.20 GHz with 4 MB cache memory and 16 GB of main memory DDR3 1333 MHz;

  • (M2) i3-2120 CPU 3.30 GHz with 3 MB of cache memory and 8 GB of main memory DDR3 1333 MHz;

  • (M3) i3-2100 CPU 3.10 GHz with 3 MB of cache memory and 8 GB of main memory DDR3 1333 MHz;

  • (M4) i7-4790 K CPU 4,00 GHz with 8 MB of cache memory and 12 GB of main memory DDR3 1.6 GHz.

The Ubuntu 14-04 LTS 64-bits operating system was used in the four machines, with kernel 3.13.0-39 generic on the M1 machine, kernel 3.13.0-43 generic on the M2 and M3 machines, and kernel 3.19.0-31 generic on the M4 machine. Five executions were carried out for each instance.

It was not our intention that the results of the eight incremental algorithms implemented outperform results from highly enhanced versions that employ corresponding point-insertion sequences in incremental algorithms. Our purpose was to obtain reasonably efficient implementations of these algorithms to allow an appropriate comparison of their results. To provide more specific detail, our goal is to evaluate whether the CPU times of eight point-insertion sequences in these algorithms [such as the one proposed by Liu et al. (2013)] may be independent of a framework. For updated times in Delaunay mesh generation, for instance, we rely on Lo (2015). Lo (2015) reported low execution times when generating a 2-D Delaunay triangulation (1 million points). He argues that the speed of a triangulation is very sensitive to the order of how the points are processed, from a quasi-linear behavior (when applied to sorted data) to a quadratic behavior (when applied to unsorted data).

For the construction of the mesh, a data structure is used to store the point coordinates. More specifically, in this data structure, the coordinates and a unique number for each point are stored. In addition, for each tetrahedron, four indices are stored and each index refers to the number of a point. This number is employed when a tetrahedron is created. Additionally, an adjacency matrix was used.

The incremental algorithm with a point-insertion sequence given by the Hilbert and Lebesgue curves, and the H-indexing order use a C++ vector data structure to store points with indices repeated when applied to the spiral distribution. In addition, the incremental algorithm with a point-insertion sequence given by the H-indexing order sorts the points. A matrix was used to store the resulting order.

For the construction of the cut-longest-edge kd-tree, an array stores the point coordinates. In addition, a data structure keeps the largest difference between point coordinates. This data structure also stores the largest, smaller and median point coordinates in such interval. For each node inserted into the cut-longest-edge kd-tree, indices to child nodes are stored. Additionally, this data structure maintains a reference to the axis where the subdivision was carried out.

5 Results

This section presents results of computational costs and memory requirements in six 2-D and seven 3-D point distributions when using eight point-insertion sequences in incremental algorithms for generating Delaunay tessellations. In addition, three approaches were used to seek the circumcircle (circumsphere) of the triangle (tetrahedron) that contained the point most recently inserted into the tessellation, in instances up to 1,000,000 in six 2-D and 8,000,000 points in seven 3-D point distributions.

Executions that computed for more than 10 and 30 min in 2-D and 3-D point distributions to return a Delaunay tessellation were aborted, respectively. These executions are indicated as “-” in the following tables. Numbers in bold face are the best results.

Table 1 (Table 2, with respect to 3-D Delaunay tessellations) shows the results of the computational costs and memory requirements when using the incremental algorithms with point-insertion sequences given by the orders of Hilbert and Lebesgue curves, H-indexing, spiral ordering, orders given by the red–black tree with in-order and level-order traversals, and random insertion points, in six 2-D (seven 3-D) point distributions. Similarly, Fig. 3 (Fig. 4 with respect to 3-D Delaunay tessellations) illustrates the results of the computational costs when using the incremental algorithms with a point-insertion sequence given by the orders of Hilbert and Lebesgue curves, H-indexing, spiral ordering, and order given by the red–black tree with level-order traversal, in six 2-D (seven 3-D) point distributions (instances composed of 1,000,000 points). In general, these results corroborate the results obtained in smaller instances (25,000, 50,000, 100,000, 250,000, 500,000, and 750,000 points).

Table 1 Results of computational costs (in s) and memory requirements (in MB) of incremental algorithms with point-insertion sequences given by seven sequences, and with three approaches to seek the triangle that contains the most recently inserted point in six 2-D point distributions
Full size table
Table 2 Results of computational costs (in s) and memory requirements (in MB) of incremental algorithms with point-insertion sequences given by seven sequences, and with three approaches to seek the tetrahedron that contains the most recently inserted point in seven 3-D point distributions (random points, points on a cylinder, points around a disk, points around three planes, points along three axes, points around a paraboloid, and points around a spiral)
Full size table

Table 3 (Table 4 with respect to 3-D Delaunay tessellations) resumes the strategies that presented the lowest computational cost in each distribution. These simplex-search (triangle in 2-D and tetrahedron in 3-D Delaunay tessellations) strategies within the point-insertion sequence in the corresponding incremental algorithm were selected to be compared with the Liu–Yan–Lo incremental algorithm. The incremental algorithms with point-insertion sequences given by the random order and the red–black tree with level-order traversal were considered to be dominated by the other five incremental algorithms in all 2-D and 3-D point distributions. In particular, in accordance with the findings presented in the current literature (Liu et al. 2013), the incremental algorithm with random point-insertion sequence obtained a high computational cost, as shown in Tables 1, 2.

Fig. 3
figure 3

Computational costs (times lower than 300 s) of incremental algorithms with five point-insertion sequences and three approaches (hist_tri, lst_tri, and tri_inc) to seek the triangle that contains the most recently inserted point into the triangulation tested in six point distributions in the unit square (1,000,000 points): points randomly distributed, cross, straight-line, cluster, circle, and spiral distributions

Full size image
Fig. 4
figure 4

Computational costs of incremental algorithms with five point-insertion sequences with three approaches (hist_tet, lst_tet, and tet_inc) to seek the tetrahedron that contains the most recently inserted point into the tessellation tested in seven point distributions in the 3-D unit interval (1,000,000 points): random points, points on a cylinder, points around a disk, points around three planes, points along three axes, points around a paraboloid, and points around a spiral

Full size image

Table 5 and Figs. 5 and 6 (Table 6; Figs. 7, 8 with respect to 3-D Delaunay tessellations) show the average computational costs, largest standard deviations and coefficient of variations (in spite of the small number of executions for each algorithm in each instance), and memory requirements of the other six incremental algorithms with point-insertion sequences in six (seven) point distributions in the 2-D (3-D) unit interval: the cut-longest-edge kd-tree, the Hilbert curve, the Lebesgue curve, the H-indexing, the spiral ordering, and the red–black tree with in-order traversal.

One can observe that the incremental algorithms with a point-insertion sequence in the order given by the cut-longest-edge kd-tree and Hilbert curve dominated the other algorithms. Consequently, we performed tests with 8,000,000 points in seven 3-D point distribution only with these two algorithms (see Table 6). Moreover, Table 7 shows the results with respect to cache misses of our implementations for the incremental algorithms with a point-insertion sequence in the order given by the cut-longest-edge kd-tree and Hilbert curve. Cachegrind, a tool of the Valgrind tool suite (Nethercote and Seward 2007), was used as cache profiler (Cachegrind 2016). Additionally, Table 8 shows the results with respect to the number of circumsphere tests and the numbers of created and destroyed tetrahedrons using the incremental algorithms with a point-insertion sequence in the order given by the cut-longest-edge kd-tree and Hilbert curve. Table 9 shows experimental tests conducted in three dimensions, to evaluate how the incremental algorithms with a point-insertion sequence given by the cut-longest-edge kd-tree and Hilbert curve perform under the CGAL framework. In accordance with the findings presented in the current literature (Liu et al. 2013), the incremental algorithm with a point-insertion sequence in the order given by the cut-longest-edge kd-tree shows very stable performance, whereas the incremental algorithm with a point-insertion sequence in the order given by the Hilbert curve varies with point distributions.

6 Conclusions

Four point-insertion sequences in incremental algorithms for Delaunay tessellation were proposed: the order given by the red–black tree with in-order and level-order traversals; spiral ordering; and H-indexing. Computational costs and memory requirements of these incremental algorithms were compared to computational costs and memory requirements of four incremental algorithms with point-insertion sequences given by the cut-longest-edge kd-tree (Liu et al. 2013), Hilbert (Liu and Snoeyink 2005) and Lebesgue curves, and random order. Tests were performed in instances up to 8,000,000 points. It follows that the incremental algorithm with a point-insertion sequence given by the cut-longest-edge kd-tree showed the best computational costs in all six 2-D point distributions and in all seven 3-D point distributions tested, in all instances. Therefore, the Liu–Yan–Lo incremental algorithm (Liu et al. 2013) dominated the other seven algorithms, in all point distributions tested. Furthermore, results obtained in this study corroborate the tests presented by Liu et al. (2013), where the Hilbert-curve incremental algorithm was dominated by the cut-longest-edge kd-tree incremental algorithm.

Table 3 Approaches to seek the triangle that contains the most recently inserted point in six 2-D point distributions
Full size table
Table 4 Approaches to seek the tetrahedron that contains the most recently inserted point in seven 3-D point distributions
Full size table
Table 5 Computational costs (in s) and memory requirements (in MB) of six incremental algorithms to generate Delaunay triangulations in six point distributions (random, cross, line, cluster, circle, and spiral) in the unit square
Full size table

The incremental algorithm using the spiral ordering achieved smaller memory requirements than the cut-longest-edge kd-tree incremental algorithm (Liu et al. 2013) in the largest 2-D instances. In addition, the incremental algorithm using the in-order red–black tree traversal achieved smaller memory requirements than the cut-longest-edge kd-tree incremental algorithm (Liu et al. 2013) in two 3-D point distributions: points around a paraboloid and around a spiral. These results were obtained in the largest instances. However, the memory requirements of the Liu–Yan–Lo incremental algorithm was competitive with those algorithms in all tests. Therefore, the Liu–Yan–Lo incremental algorithm shows good scalability. Furthermore, one may implement this incremental algorithm with a smaller memory usage than the one used in this work. In particular, the computational costs of the Liu–Yan–Lo and Hilbert-curve incremental algorithms found in our appraisal are slightly higher than those encountered by Liu et al. (2013). This can be explained partly by our usage of specific implementations, and different machines used. To provide more specific detail, the Hilbert-curve and cut-longest-edge kd-tree implementations of Liu et al. (2013) employ the highly enhanced CGAL framework. Despite the higher computational cost encountered here, our programs without using the CGAL framework presented similar behavior to the Liu, Yan and Lo implementations (Liu et al. 2013). This shows evidence that the behavior of these algorithms are independent of implementation.

The Liu–Yan–Lo incremental algorithm (Liu et al. 2013) ensures a more uniform subdivision of the points in the tessellation than the other seven incremental algorithms tested in this computational experiment. Probably for this reason, a smaller number of circumcircle (in 2-D instances) or circumsphere (in 3-D instances), and orientation tests were carried out in relation to the other seven incremental algorithms, and a smaller number of created and destroyed tetrahedrons in the tessellation was required. Therefore, the Liu–Yan–Lo incremental algorithm may be seen as the state-of-the-art algorithm for the generation of Delaunay tessellations in the seven 3-D point distributions tested. Future works will be related to parallel implementations of these algorithms.

Fig. 5
figure 5

Computational costs and memory requirements of incremental algorithms with six point-insertion sequences tested in one point distributions in the unit square: a, b points randomly distributed

Full size image
Fig. 6
figure 6

Computational costs and memory requirements of incremental algorithms with six point-insertion sequences tested in five point distributions in the unit square: a, b cross distribution; c, d line distribution; e, f cluster distribution; g, h circle distribution; i, j spiral distribution

Full size image
Table 6 Computational costs (in s) and memory requirements (in MB) of six incremental algorithms to generate Delaunay tessellations in seven 3-D point distributions (random points, points on a cylinder, points around a disk, points around three planes, points along three axes, points around a paraboloid, and points around a spiral) in the 3-D unit interval
Full size table
Fig. 7
figure 7

Computational costs and memory requirements of incremental algorithms with six point-insertion sequences tested in four point distributions in the 3-D unit interval: a, b random points; c, d points on a cylinder; e, f points around a disk; g, h points around three planes; i, j points along three axes

Full size image
Fig. 8
figure 8

Computational costs and memory requirements of incremental algorithms with six point-insertion sequences tested in three point distributions in the 3-D unit interval: a, b points around a paraboloid; and c, d points around a spiral

Full size image
Table 7 Cache misses [independent first-level instruction (I1), number of L3 instruction misses (L3i), data cache (D1), number of L3 data misses (L3d), combined instruction and data figures for the L3 cache (L3) miss rates] of the implementations for the incremental algorithms with a point-insertion sequence in the order given by the cut-longest-edge kd-tree and Hilbert curve. Seven point distributions (random points, points on a cylinder, points around a disk, points around three planes, points along three axes, points around a paraboloid, and points around a spiral) were evaluated in the 3-D unit interval. Executions performed on the M4 machine
Full size table
Table 8 Number of circumsphere tests, and numbers of created and destroyed tetrahedrons of incremental algorithms with a point-insertion sequence in the order given by the cut-longest-edge kd-tree and Hilbert curve tested in seven point distributions (random points, points on a cylinder, points around a disk, points around three planes, points along three axes, points around a paraboloid, and points around a spiral) in the 3-D unit interval (\(8\times 10^6\) million points). Executions performed on the M4 machine
Full size table
Table 9 Results of incremental algorithms with a point-insertion sequence given by the cut-longest-edge kd-tree and Hilbert curve tested in seven point distributions (random points, points on a cylinder, points around a disk, points around three planes, points along three axes, points around a paraboloid, and points around a spiral) in the 3-D unit interval (\(10\times 10^6\) million points)
Full size table