CurveSkelTabbMedeiros
A curve skeletonization method for elongated objects that may be noisy.
view repo
We consider the problem of extracting curve skeletons of threedimensional, elongated objects given a noisy surface, which has applications in agricultural contexts such as extracting the branching structure of plants. We describe an efficient and robust method based on breadthfirst search that can determine curve skeletons in these contexts. Our approach is capable of automatically detecting junction points as well as spurious segments and loops. All of that is accomplished with only one useradjustable parameter. The run time of our method ranges from hundreds of milliseconds to less than four seconds on large, challenging datasets, which makes it appropriate for situations where realtime decision making is needed. Experiments on synthetic models as well as on data from real world objects, some of which were collected in challenging field conditions, show that our approach compares favorably to classical thinning algorithms as well as to recent contributions to the field.
READ FULL TEXT VIEW PDF
Manmade objects usually exhibit descriptive curved features (i.e., curv...
read it
In this paper, we analyze the planar cubic Alternative curve to determin...
read it
We propose to synthesize feasible caging grasps for a target object thro...
read it
We present a temporal 6DOF tracking method which leverages deep learnin...
read it
Calibration refers to the process of adjusting features of a computation...
read it
Motivated by the important archaeological application of exploring cultu...
read it
Visual analysis of temporal networks comprises an effective way to under...
read it
A curve skeletonization method for elongated objects that may be noisy.
The threedimensional reconstruction of complex objects under realistic data acquisition conditions results in noisy surfaces. We describe a method to extract the curve skeleton of such noisy, discrete surfaces for the eventual purpose of making decisions based on the curve skeleton. Much work has been done in the computer graphics community on the problem of skeletonization. In general, curve skeletonization converts a 3D model to a simpler representation, which facilitates editing or visualization [7] as well as shape searching and structure understanding [3, 11, 16]. However, the work in the computer graphics community usually assumes noiseless surfaces or surfaces with negligible noise levels. In this work, we intend to use curve skeletons as an intermediate step between surface reconstruction and computing measurements of branches for automation applications in which robustness to noise and fast execution are important, such as in the automatic modeling of fruit trees in an orchard [28].
There are two commonlyused types of skeletons, the medial axis transform (MAT) skeleton, and the curve skeleton. Skeletons using MAT are curves in 2D while in 3D they are locally planar. They allow for the original model to be reconstructed but are very sensitive to local perturbations [19]. Curve skeletons consist of onedimensional curves for surfaces in 3D, which provides a simpler representation than MATtype skeletons (see [7] for a comprehensive review). However, because there are different definitions of curve skeletons, there is an abundance of methods, with different advantages and disadvantages.
The problem we explore in this paper is to compute curve skeletons of discrete 3D models represented by voxels, which may be sparse, noisy, and are characterized by elongated shapes. The curve skeleton must be thin and onedimensional except in the case of junction points, which should be detected during the computation of the curve skeleton. The skeleton must also be centered, but because of noise and the use of voxels we use the relaxed centeredness assumption (see [7] for more details). To make our approach robust to noise, we identify spurious curve skeleton segments in the course of the algorithm, which removes the need for a separate pruning step [4, 21, 31]. Finally, since our work is mainly concerned with real trees, branch crossings occur and support poles may be attached to the trees via ties. As a result, our datasets include loops and cycles and breaking a loop is not desirable. Hence, our method is able to determine that curve skeleton segments which do not terminate at a surface voxel are part of a loop.
We propose a pathbased algorithm for the realtime computation of curve skeletons of elongated objects with noisy surfaces that takes into account all of the criteria above. Specifically, our contributions are: 1) our method is robust to noise and there is no requirement for additional pruning, 2) it has time complexity – where is the number of occupied voxels in 3D space – and as a result is suitable for automation contexts, 3) the method can handle loops, 4) we provide an extensive evaluation on synthetic models as well as on realworld objects, and 5) we provide source code that is publicly available [27].
Using laser data, there has been some related work on the problem of extracting cylinders from point cloud data [6, 15, 17, 24, 29]. Such methods cannot be used for the datasets we consider because these works assume that the underlying shapes are cylinders. While elongated shapes may be locally cylindrical, they may have many curves and cylinder fitting may not be appropriate for these shapes.
In [2], the authors compute MATstyle skeletons and combine those ideas with those of traditional thinning, for the purposes of object recognition and classification with an emphasis on reconstruction. Their algorithm is efficient, but like many other algorithms it depends on a pruning step which requires parameter setting. Other works which combine the ideas of thinning with computing skeletons are [10], where a bisector function is used to compute a surface skeleton, and [5] where new kernels are used for thinning.
In [30], the authors provide an algorithm for computing a curve skeleton from a discrete 3D model, assuming that some noise is present. This is accomplished by a shrinking step that preserves topology, as well as a thinning step to create 1D structures, and finally a pruning step. While that method is able to deal with some noise, the shrinking step involved in the algorithm would result in missing some branches with small scale.
A recent approach that is most similar to the method we present was proposed by Jin et al. in [12, 13]. In these works, curve skeletons are extracted from medical data that contains noise, and once a seed voxel has been identified, new curve skeleton segments are found via searches based on the geodesic distance. While our method shares a similar overall structure in that paths are iteratively discovered, we do not make assumptions concerning the thickness and lengths of neighboring branches. In addition, that method was not designed to handle loops. Finally, in that work, the authors note the problems with computational speed in their approach because of the use of geodesic path computations. Our method was conceived to be executed in realtime and is hence computationally inexpensive.
The proposed method to compute a curve skeleton is composed of four main steps:
[leftmargin=*, nolistsep]
Determine the seed voxel for the search for curve skeleton segments (Section 3.2);
Determine potential endpoints for curve skeleton segments (Section 3.3);
Determine prospective curve segments (Section 3.4);
Identify and discard spurious segments and detect loops (Section 3.5).
Step 1 is executed once at initialization, whereas the remaining steps are executed iteratively until all curve segments have been identified. These steps are described in detail below and the entire process is illustrated in Figure 9. In this description, we assume that there is only one connected component, but if there are additional connected components, all four steps are performed for each component.



The set of occupied voxels in 3D space is , and is the number of occupied voxels. We note here that voxels are defined with respect to a uniform threedimensional grid, and we let the number of voxels (occupied and empty) in such a grid be . However, in this work, we only operate on occupied voxels, and since the objects we treat are elongated, . In the remainder of the document, voxels will mean occupied voxels. We interpret the voxels as nodes in a graph and assume that voxel labels are binary: occupied or empty. The edges of the graph are defined by a neighborhood relationship on the voxels. We represent the set of occupied neighbors for a voxel as . In our implementation we use a 26connected neighborhood. A surface voxel has and the set of surface voxels is .
Each segment of the curve skeleton is represented by a set of voxels. At each iteration of the skeletonization algorithm, a new curve skeleton segment is discovered. Then, the overall skeleton is represented by the set which is the set of skeleton segment sets:
(1) 
Our skeletonization method is heavily based on a proposed modification of breadthfirst search (BFS) which allows one to alter the rate at which nodes are discovered according to a weighting function. We now discuss this BFS modification generally and then show its application to our approach to curve skeletonization in future sections.
In classic BFS, there are three sets of nodes: nonfrontier, frontier, and undiscovered nodes and the result of the BFS is a label for each node in the graph. The starting node has a label of 0 and the labels of other nodes are the number of edges that need to be traversed on a shortest path from any node to the starting node. In our modified BFS algorithm, the labels represent the sum of pairwise distances along the shortest path to a given node.
Each voxel also has a weight assigned to it, . Voxels with smaller values of are incorporated into the frontier before neighboring voxels with higher weight values. The speed of discovery of nodes can thereby be altered to favor paths that go through voxels with characteristics which are desirable for a specific purpose as explained in detail in Section 3.3.
Our modified BFS is shown in Algorithm 5. The frontier for a particular iteration is , which is composed of two subsets, and . The initialization of depends on the intended use of the algorithm (details are given in Sections 3.3.1 and 3.4.1), and is always initially empty. The label of voxels is given by:
(2) 
The algorithm progresses as follows. A voxel has neighbors which had been discovered previously as well as neighbors that were discovered later than itself as determined by the labels of and its neighbors. In line 3, only neighbors discovered later than the voxels in are updated based on the label of , the weight , and the distance between the neighboring voxels. The set in line 6 is the set of frontier candidates beyond the current frontier at iteration . is used to select a label threshold, . If the voxels in have a label greater than this threshold, they remain in the frontier (specifically ) for the next iteration. If a voxel in has a label smaller than this threshold, then those neighbors of which were discovered later than are placed in and is removed from the frontier for the next iteration. The distinction between and allows for a more efficient implementation because only labels in must be updated in line 4.
As mentioned above, the first step of our skeletonization algorithm is the determination of the seed voxel. This step consists of two substeps: computation of distance labels, and localization of an extreme point as explained below.
To compute the distance labels , , we compute the distance transform using Euclidean distances so that represents the distance from to the closest voxel in , i.e., a surface voxel. To compute the distance labels efficiently, we use the lineartime algorithm of [18] on the occupied voxels in our graph representation (note that the pseudocode in [18] considers regular grids instead). In addition, in our implementation, the three scans of the algorithm are executed in parallel.
Once the distances are computed, we find the voxels with maximum distance label, , which ensures that the curve skeleton goes through the thickest part of the object. There may be several voxels with , and we arbitrarily select one of them to be . If a point of the curve skeleton is known to be a desirable seed point for a specific application, that point may be selected to serve as without affecting the subsequent steps we describe in this paper.
This section describes the first step to determine the curve skeleton segments : the identification of the endpoints of prospective segments that are connected to existing segments in the skeleton. This is done in two substeps. First, we compute the breadthfirst search distances from the existing curve segments to potential endpoints. We call this step BFS1. Then, a candidate endpoint is identified from the extreme points in this set. These substeps are described in detail below.
At the first iteration of our algorithm, the curve skeleton consists of a single voxel, . We initialize in Algorithm 5, and initialize the labels as in Equation 2. We then perform Algorithm 5 using weights , where and are the distance labels and the maximum distance label, respectively (shown in Figure (a)a). These weights increase linearly according to a voxel’s Euclidean distance to a surface voxel, i.e., surface voxels have . The overall effect of weighting the search in such a way is that paths which pass through the center of the object are explored first. This procedure finds the distances from each voxel to the existing curve skeleton along a centered path. As explained in detail below, points with maximal distance are endpoint candidates.
At each subsequent iteration of the algorithm, new curve skeleton segments (which are identified as described in Sections 3.4 and 3.5 below) are added to and the BFS1 labels are updated accordingly. For improved efficiency, on subsequent iterations, BFS1 labels are simply updated instead of computed from scratch. Suppose that on iteration the set of approved curve skeleton segment voxels is , so that . We leave the existing BFS1 labels from iteration unchanged, except for those in :
(3) 
Then Algorithm 5 progresses as usual given these labels.
We next identify candidate endpoint voxels of the curve skeleton. A candidate endpoint voxel is a surface voxel which is not yet connected to the curve skeleton. An endpoint candidate is given by the voxel such that the label of is greater than or equal to any other BFS1 label for any other surface voxels, i.e.,
(4) 
where is the BFS1 label of . There may be multiple voxels with the same maximum label value. As in the seed voxel selection step in Section 3.2.2, may be chosen arbitrarily from the set of voxels with the maximum label value.
The existing curve skeleton might be reachable from a proposed endpoint via more than one path (see Figure (h)h, for example). We use the breadthfirst search distance from the prospective endpoint to the existing curve skeleton to identify those branches and junction points. This is also done in two substeps. First, we compute the BFS distances from , which we call the BFS2 step. Then we determine the curve skeleton segments by analyzing connected components. These substeps are explained in detail below.
In order to determine where a proposed curve skeleton segment intersects with the existing curve skeleton, we use Algorithm 5 with weights , as in the BFS1 step. Unlike the BFS1 step, however, for each iteration of the algorithm, the labels are now initialized using Equation 2 with . When an existing curve skeleton section is encountered, the search is stopped for that region. The output of this step are the BFS2 labels.
Once the BFS2 labels are computed, the frontier arcs are then analyzed and grouped by connected components. The number of connected components in the frontier voxel set is the number of curve skeleton paths from to the existing curve skeleton.
Let a frontier connected component (FCC) from BFS2 be the set of voxels . We determine the voxels in that are neighbors of the existing curve skeleton and denote these voxels as :
(5) 
From we determine the voxel with the smallest BFS2 label in the set and denote this voxel as , i.e.,
(6) 
where is the BFS2 label. As before, there may be many voxels with the same smallest label, and one may be chosen arbitrarily. The next step is to determine the path from to such that the path is centered. We accomplish this with the BFS2 labels as well as the distance transform labels . This combination improves centeredness on curved portions as compared to only using BFS2 labels.
The process of determining a new curve skeleton segment is sketched in Algorithm 6. The sequence of current voxels creates a new curve skeleton segment. We start from the neighbor of the existing curve skeleton, , and set equal to . We determine by examining ’s neighbors and the BFS2 labels. Let the BFS2 label of be . is the maximum distance label of ’s neighbors whose distance labels are less than . Then is determined as the voxel, out of ’s neighbors, with the smallest BFS2 label among those voxels with distance transform label equal to . The practical ramifications for these choices are as follows. By choosing the next voxel as a voxel with a smaller BFS2 label value than , we are guaranteed to be moving towards within the voxels that are occupied. Secondly, by requiring that the next distance , we are choosing the voxel most in the center of all of the neighboring voxels that are on a path towards in the occupied voxels. Algorithm 6 is performed for all FCCs.
Due to the noisy nature of our surfaces, it is necessary to reject some of the curve skeleton segments identified in the previous step. In the next section, we describe our approach to classify curve skeleton segments as spurious or nonspurious using the frontier voxels from the BFS2 step. When the number of FCCs is one, the proposed curve segment
undergoes the spurious curve segment classification described in the next section. When the number of FCCs is greater than one, a loop is present, and this case is handled using the approach described in Section 3.5.2.Our classification approach assumes that the surface voxels are disturbed by additive threedimensional Gaussian noise and checks whether the endpoint of the proposed curve segment belongs to this distribution.^{3}^{3}3Although we used a Gaussian model for mathematical convenience, our experiments showed that the real noise distribution has little impact on the performance of our approach. That is the case for realworld data or even when a substantial amount of shotlike noise is introduced into the models (See Figures 16, 17, and the figures in the supplementary materials). If it does not, the segment is considered spurious. To compute this distribution, note that is composed of interior and surface voxels. Let the set of surface voxels from be , and let be the closest voxel from the existing skeleton to the proposed segment. For each voxel
, we determine the difference vector
. Then, the sample mean and the sample covariance of are given by and where .The squared difference vectors are
distributed with three degrees of freedom. In order to classify a curve segment
, we compute the probability that the shifted segment endpoint
belongs to this distribution. Let, its probability density function is given by
(7) 
If , where is a usersupplied acceptance probability, then the curve segment’s tip is considered part of the surface voxel’s distribution and consequently discarded as a spurious segment. Otherwise, is incorporated into the existing curve skeleton. This approach allows curve segments to be classified as spurious or not depending on local conditions and not on absolute parameters.
The presence of multiple FCCs indicates that one or more tunnels are present in the surface, which corresponds to one or more loops in the curve skeleton. In this case, we do not pursue the spurious curve classification step and instead handle the loop first (Algorithm 7); once the loop has been located, the algorithm returns to spurious curve segment classification (§3.5.1). Let the th FCC be represented by the set of voxels , where and is the number of FCCs. Then for each , we compute a proposed curve skeleton segment using Algorithm 6, and let this proposed curve skeleton segment be denoted . The proposed curve skeleton segments s have some voxels in common. In particular, all of the proposed segments travel through the region near the tip , which is a surface voxel. We remove this common region near the tip from all of the s (lines 1, 3). Then, the s are processed such that there are no redundancies between s (line 5) and added to the set of curve skeleton segments (line 6). A figure illustrating this process is in the supplemental materials.
Algorithm 8 summarizes the complete proposed approach. Line 3 corresponds to the seed localization step performed at initialization as described in Section 3.2. Lines 56 show the iterative endpoint localization method presented in Section 3.3. The determination of prospective segments of Section 3.4 is carried out by Lines 78. Finally, lines 912 perform the spurious segment classification and loop handling routines described in Section 3.5.
The computational complexity of the entire method is . As a matter of fact, the method runs in , where is the largest voxel to surface distance, and is the number of proposed endpoints . Since and tend to be orders of magnitude smaller than for elongated objects, the method runs extremely fast in practice. A detailed analysis of the computational complexity as well as a discussion of the topological stability of the proposed approach are included in the supplementary materials.
We evaluated our method and four comparison approaches that reflect the state of the art on curve skeletonization on real datasets consisting of nine different trees, denoted as trees A  I. These trees are realworld objects with an elongated shape. Most of the trees are three meters or taller, and the surfaces are noisy. The data for six out of the nine trees was acquired outdoors, and the reconstructions were generated using the method of [26], but other reconstruction algorithms could be applied (e.g., [23]). Table 1 lists the main characteristics of the nine datasets. All five methods were evaluated with respect to their accuracy and robustness to noise as well as run times. We additionally performed a qualitative evaluation of the performance of our method in nonelongated synthetic models commonly used in the evaluation of skeletonization algorithms.
ID  

A  55,156  27,744,000  16  15 
B  88,407  56,832,000  5  174 
C  88,798  45,240,000  7  145 
D  92,892  80,640,000  6  154 
E  98,228  58,464,000  9  50 
F  136,497  80,640,000  7  134 
G  158,686  64,512,000  9  128 
H  176,820  80,640,000  10  97 
I  246,654  80,640,000  10  83 
The first comparison method is the classical medialaxis thinning algorithm of [14], which maintains the Euler characteristics of the object during its execution. The second and third comparison methods, denoted PINK skel and PINK filter3d, are also medialaxis type thinning approaches based on the discrete bisector function [10] and critical kernels [5]. The fourth comparison method is the approach of Jin et al. [12, 13], discussed in Section 2.
We implemented our method in C/C++ on a machine with a 12 core Intel Xeon(R) 2.7 GHz processor and 256 GB RAM.^{4}^{4}4The source code is available at [27]. For all the results shown in this section, the spurious branch probability, the only parameter of our algorithm, was set to . The implementation of the thinning algorithm from [14] is provided through Fiji/ImageJ2 in the Skeletonize3D plugin, authored by Ignacio ArgandaCarreras. The implementations of [10] and [5] were provided by the scripts ‘skel’ and ‘skelfilter3d’, respectively, from the PINK library [9]. The implementation of the method of Jin et al. was kindly provided by the authors. We did try to evaluate our datasets using the curve skeleton algorithm and implementation of [8], but that approach failed to return a skeleton. We hypothesize that this failure is a result of the thinness of some of the structures in our datasets, which are sometimes only one voxel wide, since the discussion in [8] specifically mentions that the algorithm may fail for thin structures.
In order to illustrate the accuracy of our method in comparison with the stateoftheart approaches, Figure 16 shows the original surface and curve skeletons computed with all five methods for Dataset B. As expected, the thinning algorithm, PINK skel, and PINK filter3d methods were not able to deal adequately with the noise in our datasets, and created many extra, small branches. In addition, the PINK filter3d method removes some branches. Jin et al.’s method performed better than the thinning algorithms with respect to noise, although it still presented some small spurious branches. In addition, this method is unable to deal with loops or cycles in the original structure. Our method is robust to the noise in our datasets and also was able to deal with loops in the curve skeleton. Highresolution images and results for the other datasets are also available in the supplementary materials.
We also assessed the performance of our method under increasingly noisy conditions on a synthetic 3D model, which serves as a ground truth. We iteratively add noise to the ground truth model by randomly choosing, with uniform probability, surface voxels which have nonsurface neighbors to be deleted and another set of the same size to which a new neighboring voxel is added. The parameter represents the proportion of voxels to be altered, and in our experiments . For subsequent iterations, we repeat the process using the voxel occupancy map from the previous iteration such that, after iterations, the model has either noisy protrusions or depressions of at most voxels. A closeup view of the model without noise and with a noise level of as well as the corresponding curve skeletons computed using our method can be found in the supplementary materials.
To quantify the effect of noise on each of the skeletonization methods, we compute the root mean squared error (RMSE) of the skeletons generated by each approach in comparison with the ground truth skeleton. That is, for each voxel in the curve skeleton of the ground truth model, we find the closest voxel in the curve skeleton of the noisy model and use the sum of the squared closest distances to compute the RMSE. Figure 17 shows the corresponding results for our method and the comparison approaches. The xaxis in the graph represents the maximum voxel noise according to the process described in the preceding paragraph, and the yaxis shows the RMSE in terms of voxel distances. As the figure indicates, our method outperforms all the other approaches by a significant margin. The second best approach is given by the method of Jin et al., which has an average RMSE 20% higher than our method.
Figure 18 summarizes the time performance of the methods on the nine trees. A general ordering with respect to increasing run time is: 1) our method, 2) thinning, 3) PINK skel, 4) PINK filter3d, and 4) the Jin et al. method. The method proposed by Jin et al., which has as one of its components geodesic path computation, has the longest run time of the methods. Note that the run times of the comparison methods include loading and saving the results, whereas ours does not. The loading and saving portions required to run the thinning algorithm for dataset E, which has million voxels, is seconds. Since we do not have access to the source code of Jin et al., assessing the time spent loading and saving is difficult, but we assume that it is of the same order of magnitude. For the PINK scripts, intermediate results are loaded and saved in temporary locations, which affects run time. Nevertheless, our curve skeletonization method is able to compute curve skeletons one to three orders of magnitude faster than the other methods. It executes in less than four seconds even for very large models.
While we are interested in realworld, elongated, noisy objects, we also evaluated our method on some commonlyused smooth models. The proposed curve skeleton method used in the context of smooth models produced the general structure of those objects and was also able to detect loops when they were present, for instance for the camel and seahorse examples. We also performed experiments with the only usersupplied threshold in our method. When , no segments are discarded. The resulting curve skeleton resembles a more dense version of the thinning result. When , the result resembles the Jin et al. result except that loops are preserved. Results for both of these items are found in the supplementary materials.
Understanding the structure of complex elongated branching objects in the presence of noise is a challenging problem with important realworld applications. In this paper, we presented a fast and robust algorithm to compute curve skeletons of such realworld objects. These curve skeletons provide most of the information necessary to represent the structure of these objects. A large portion of the paper centered on how the ideas of BFS could be exploited to create an efficient curve skeletonization procedure. Our approach is able to detect connected segments and performs pruning in the course of the algorithm, so those steps do not need to be performed separately. The small run times of less than a few seconds make this method suitable for automation tasks where realtime decisions are required.
Extraction of cylinders and estimation of their parameters from point clouds.
Computers & Graphics, 46(0):345 – 357, 2015. Shape Modeling International 2014.In this section, we analyze the computational complexity of the algorithms in this paper. For reference ease, we include all of the algorithms from the main paper.
We now analyze the computational complexity of Algorithm 5. Note that a voxel is a member of for any exactly once. On line 8, voxels in and a voxel in cannot be in : (from line 6). In addition, the condition ensures that a voxel in has not already been discovered, meaning that voxels in cannot be members of the frontier at any previous iteration , . Hence for . Finally, since all voxels are eventually discovered, the sets form a partition of , implying
(S1) 
and
(S2) 
Consequently, for all iterations of Algorithm 5, line 2 will be performed times.
On the other hand, a voxel may be a member of multiple times, waiting for the condition to be true so that its neighbors are moved into (line 8). Because the conditions for computing set , and therefore (lines 6  7), for the members of are dependent on the composition of , cannot be stored from previous iterations and still be relevant.
Finding set in Algorithm 5 takes time per iteration , and line 7 can be computed while is found. Lines 8 and 9 also take time per iteration .
Since we know from Equation S2 that , the asymptotic lower bound is , and it is a strict bound. For instance, consider contains one voxel, which is an endpoint of a 1dimensional line in 3D space. In this case, and for all , and the maximum value of is .
Determining the value of in general is problematic as it depends strongly on the shape involved, on the composition of , and weights .
The Euclidean distance between neighboring voxels is . We claim that a voxel can only be in one of the frontier sets at most three times; first, it enters the frontier through , and if the voxel remains in the frontier, the only other sets it may belong to are and , at which point it exits the frontier sets. Hence
(S3) 
The asymptotic upper bound of Algorithm 5 is then .
Algorithm 5 using zero weights has many of the same characteristics as the breadthfirst distance transform described in Section V of [25]. One major difference is that in [25] neighbors are assumed to have the same distance from each other, which is not an assumption we share when working with 26connected voxels in 3D. However, the algorithm with zero weights retains the asymptotic upper bound of as the method in [25].
The complexity of the modified BFS algorithm with nonzero weights is , assuming that the weights are computed based on a distance transform .
Our discussion of Algorithm 5 for zero weights provided an asymptotic upper bound , and determining this bound came down to determining how many times a voxel could possibly be a member of the frontier. For the analysis of Algorithm 5 when weights are nonzero, we return to similar questions. From Algorithm 5, voxels are in once, and are in multiple times, until the condition is satisfied.
Let us determine the maximum number of times a voxel resides in the frontier sets. The maximum distance label is the maximum difference between any two distance labels, and the L2 norms between any two neighboring voxels belong to the set . Then, the maximum number of times a voxel can possibly be in the frontier sets is , leading to asymptotic upper bound . We consider shapes that produce the largest values of . The shape that maximizes is a sphere. In that scenario, is the radius of the sphere, and the relationship between and is . Then, performing the relevant substitutions we have the asymptotic upper bound of this step as .
We now consider the complexity of the curve skeleton method of Algorithm 8, excluding the complexity of the distance transform step, which is using the approach of [18]. Let the number of proposed endpoints, or iterations of Algorithm 8, be . Computing the BFS1 labels (step 2.1) and BFS2 labels (step 3.1) per iteration has asymptotic upper bound . The computation of the BFS1 and BFS2 labels is repeated times, giving as an upper bound. As in Section 6.3, we try to determine shapes that maximize to find an asymptotic upper bound on . We have given an example of a particular shape in Figure S1 where . More generally, the number of extremities can be no larger than the number of voxels, hence we can assume that . In summary, the asymptotic upper bound of the complete algorithm is .
We note that in our experiments involving elongated objects, both and are extremely small relative to as shown in Table 1. In those datasets, the maximum value of relative to is (Dataset B), and the greatest value of is , or in terms of , (Dataset A). Consequently, while the asymptotic upper bound is greater than quadratic, if and can be assumed to be small constants as in the case of elongated objects, in practice the algorithm runs quickly. This is highlighted in Figure S2, which shows the runtime of our method as a function of the number of occupied voxels for each of the datasets in Table 1. As the figure indicates, despite a four times increase in the number of occupied voxels between the smallest and the largest dataset, the run time of our algorithm increases slowly.
ID  

A  55,156  27,744,000  16  15 
B  88,407  56,832,000  5  174 
C  88,798  45,240,000  7  145 
D  92,892  80,640,000  6  154 
E  98,228  58,464,000  9  50 
F  136,497  80,640,000  7  134 
G  158,686  64,512,000  9  128 
H  176,820  80,640,000  10  97 
I  246,654  80,640,000  10  83 
There are three steps in the algorithm where decisions may be made deterministically or randomly in the case of equal labels:(1) the selection of in Section 3.2, (2) endpoint candidates in 3.3.2, and (3) frontier connecting voxel in 3.4.2. If topological stability is desired, the following protocol could be employed to deterministically select a voxel when there are multiple voxels with the same label. The voxels of equal label are placed into a vector, and then the coordinates would be sorted as specified by the user. One such ordering would be to sort the coordinates by value, and then in case of ties by value, and then in case of ties by . This kind of repeatable ordering would produce reproducible results that would be more topologically stable than a random ordering.
Figure S11 shows the models used for the simulated noise experiment, and computed curve skeletons using our proposed method.
As in the experiments with the real datasets, the comparison methods are characterized by greater numbers of spurious voxels than our method as the noise level increases. We represent this in Figure S20, which shows the number of voxels in the curve skeletons for each of the methods as a function of the noise level. The figure shows that, as the noise level rises, the number of voxels also increases for all the methods. For the thinning and PINK methods, this increase is dramatic, in some cases up to 9 times the initial value. The Jin et al. method also shows some additional voxels as the noise rises, particularly for noise levels higher than 6, showing a total increase of approximately 50% from zero noise to noise level 14. Our method has the least additional voxels, showing a total increase of only 4%.
Figures S24 to S92 show high resolution images of the nine real trees used to evaluate our method as described in Table 1 of the main paper. See the discussion in the main paper in the Experiments section for a more detailed description of the figures below.
The curve skeleton algorithm is demonstrated on commonlyused computer graphics models in Figures S97S97. Surfaces shown in (a)a to (a)a provided courtesy of INRIA, owner of (c)c unknown, all via AIM@SHAPEVISIONAIR Shape Repository [1]. All models were converted from mesh to voxels using the algorithm of [22] as implemented in [20].
We performed some experiments with the one usersupplied threshold, in our method, and show results in Figure S117. When , no segments are discarded. The resulting curve skeleton resembles a more dense version of the thinning result. When , the result resembles the Jin et al. result except that loops are preserved. All results generated in this paper for the proposed method, except in this section, were generated with . Consequently, different values of may be chosen depending on the application.
To further illustrate the performance of our approach, Figures S120 to S147 show additional high resolution images of results obtained using our method.
Comments
There are no comments yet.