Performance Analysis

In the following, we provide a performance analysis for the computation of the se- quenceV including a complexity analysis for practical cases. The running time and the memory consumption of our algorithm are measured for different kinds of data sets. All measurements were done on an Intel Xeon E5530 2.4 GHz system.

Applying Algorithm 14 to different data sets, we observed that noise significantly increased the running time. Therefore, we consider a random field as a practical worst case. We measured the behavior of the simplification algorithm with increasing data size for two different scalar fields. The first one is a uniform random field of size 2563

with a range[−0.5, 0.5], from which we took nested subfields of dimensions 323_{, 64}3_,

1283and 2563. For each of the subfields, we computed the complete sequenceV using Algorithm 14. The second field is a signed distance field of a microporous structure. In the same way as for the random field, we have chosen a nested sequence of subfields. Figure 3.12 shows in logarithmic scaling the running time and memory consumption for both sequences.

Computational Complexity

The computational complexity heavily depends on the topological complexity of the input data: the number of critical points and their connectivity. Both are a priori not know. Especially, the 1-separation lines are crucial. Such lines could be space filling, i.e., the lines cover the entire combinatorial separation surfaces which themselves can cover the entire domain, and their computation is no longer of the complexity of a line- integration but of a volume-integration. The design of a function with such kind of space-filling curves is a non-trivial task. However, most of the input data are well de- fined avoiding such behavior. In the following, we provide an analysis of Algorithm 14

saddles (line 3) avoiding multiple traversals of the links. A reasonable upper bound for the size of a surface is n2/3. Since the integration is done for all 2-saddles, the com- putation of the combinatorial surfaces is of complexity O(|C2_{| n}2/3_{) ⊂ O(n}5/3_{) with}

|C2_{| denoting the number of 2-saddles.}

The computation of the 1-separation lines is restricted to the separation surfaces S, and each link in S is only traversed once (Algorithm 4, line 4). According to Sec- tion 3.4.3, the complexity of Algorithm 4 is O(|I|) ⊂ O(|S|) ⊂ O(n2/3_).

The crucial part in Algorithm 14 is the while-loop (line 5). The heap h consists of all saddles. Each saddle is inserted with its ’best’ minimum, opposite saddle, and maximum. Hence, the size of h is bounded by const c with c denoting the number of 1- and 2-saddles. In line 10, the weight of the current saddle is checked whether it is the currently smallest weight. In the worst case, all saddles are deferred, and every time we need to iterate over the complete heap h to find the pair with the smallest height difference. In practical cases, however, only const c-operations are needed to do so.

In Algorithm 16, the pair that represents the smallest height difference is com- puted. Algorithm 17 computes the 0- or 2-separation line connecting the saddle to the extrema. In practical cases, those lines are not space filling and their integration is a line-integration of complexity O(n1/3_).

The computation of the 1-separation lines, on the other hand, is more intricate. The local intersection is extracted from the global set of links I. Considering non- degenerated cases, the separation surfaces are not space filling. However, noise in the input data may create surface-filling 1-separation lines that often merge and split. An upper bound is therefore n2/3. Each link is only traversed once (Algorithm 18). Therefore, the practical complexity of Algorithm 16 is O(n2/3_).

In summary, the practical complexity to compute the hierarchy is: O(|S| + |I| + c n2/3_{) ⊂ O(n}5/3_{+ n + c n}2/3_{) ⊂ O(n}5/3_{). We want to note that the the-}

oretical worst-case complexity is O(n3_{) due to the possible saddle-deferring in the}

while-loop.

While we observed the practical complexity for the artificial random field, we ob- served almost linear running time for the distance function (see Figure 3.12a). This indicates that the 1-separation lines are well distributed on well-defined data.

Memory Consumption

The following analysis of the memory consumption is given for a cubical complex, i.e., the degree of the nodes N in G is constant.

For the construction of the sequence, a Boolean vector, whose size is given by the number of links in G, is needed to represent the current matching. The number of nodes in the cell graph is eight times the number of vertices in the input grid. The number of links in G is therefore bounded by 24 times the number of vertices. Since the size of a Boolean is 1/32th of a single precision number, we need a factor of 0.75 of the input data to represent the matching. Three additional Boolean vectors of size |N| are needed: the surface integration, its intersection, and the node matching. The total factor is therefore 1.5 of the input data.

(a) Running time. (b) Memory consumption.

Figure 3.12: Performance of Algorithm 14. The red solid lines show the running time and the memory consumption for a uniform random field, the blue solid line for a dis- tance field. The axes are shown in a loglog-scale. The full sequenceV was measured in all cases. The black dotted lines indicate a complexity of O(n) and O(n5/3_).

Robins et al. [RWS11] proved that the critical points are in a 1-1 correspondence to the topological changes in the lower level sets. Since (3.3) only decreases the number of critical nodes, the size of the heap is given by the number of critical nodes in the input field. In practice, there are much fewer critical nodes than regular nodes. Hence, the size of the h is negligible. Note that only the scalar values for these critical points need to be stored. They define the weight of an augmenting path.

The theoretical maximal memory consumption for separation surfaces is bounded by the number of 1- and 2-nodes in G. Space filling surfaces, however, do not appear in practice, and this bound is much lower, in general. Hence, the relative amount of memory needed by Algorithm 14 is constant which is substantiated by the results shown in Figure 3.12b.