Mixed 1D/2D Simplicial Approximation of Volumetric Medial Axis by Direct Palpation of Shape Diameter Function

Abstract

In the domain of Shape Encoding, the approximation of the Medial Axis of a solid region in ${\mathbb{R}}^3$ with Boundary Representation M, is relevant because the Medial Axis is an efficient encoding for M in Design, Manufacturing, and Shape Learning. Existing Medial Axis approximations include (a) full Voronoi and (b) and partial Shape Diameter Function (SDF)-based ones. Methods (a) produce large high-frequency data, which must then be pruned. Methods (b) reduce computing expenses at the price of not handling some shapes (e.g., prismatic), and currently, they only synthesize 1D Medial Axes. To partially overcome these limitations, this investigation performs a direct synthesis of a 1D and 2D simplex-based Medial Axis approximation by a combination of stochastic geometric reasoning and graph operations on the SDF-originated point cloud. Our method covers one- and two-dimensional Simplicial Complex Medial Axes, thus improving on 1D Medial Axes approximation methods. Our approach avoids the expensive full computing plus pruning of Medial Axis based on Voronoi methods. Future work is needed in the synthesis of Medial Axis approximation for high-frequency neighborhoods of mesh M.

1. Introduction

Skeletal representations allow for the synthesis of the underlying geometry and topology properties of a 3D object. They have been useful in applications such as shape reconstruction [1,2,3], segmentation [4], abstraction [5], recognition [6,7], and animation [8], among others.

The Medial Axis (MA) is a commonly used skeletal representation. The MA of a 3D body $\mathcal{B}$ is defined as the set of centers and their respective radii of all the maximally inscribed balls (medial balls) in $\mathcal{B}$ [9]. This MA generally contains intermixed 1D and 2D elements. Therefore, a Piecewise Linear (PL) representation of MA is generally a non-manifold simplicial complex. A full MA of $\mathcal{B}$ normally contains highly fibrous (small hair-like or sheet-like) structures. Hence, a simplification is usually applied to the Medial Axis after its computation in order to obtain a less noisy result (which in this manuscript we call Skeleton).

Notice that each point of the skin $\partial \mathcal{B}$ of $\mathcal{B}$ is related to the ball centered in a point of the Medial Axis, with radius r, which is tangent to that point of the skin $\partial \mathcal{B}$. This theoretical and exhaustive Medial Axis Radius scalar field is approximated by a more economical version, called the Shape Diameter Function (SDF [10]). Obviously, the Shape Diameter Function approximates twice the corresponding radius r (SDF $\approx 2r$).

The Shape Diameter Function (SDF [10]) is an economical intermediate scalar field, useful to approximate the Medial Axis for particular classes of solids. SDF is defined as the “thickness” of the solid at each point on its surface, and it is a scalar function $\mathrm{SDF}:M⟶{\mathbb{R}}^{+}$. The SDF-based point cloud is the locus of the “midpoints” of the thickness segment for all points of M (see Section 3.5 for formal definition). Therefore, the point cloud derived from the SDF scalar field is an approximation of the Medial Axis.

This investigation executes a direct palpation of the SDF-based point cloud. The term “palpation” is analogous to the actions executed by a blind person, who seeks to apprehend the nature of a point cloud: the person would directly touch the point cloud neighborhoods, seeking to identify 1D (PL curve) or 2D (PL surface) regions. This direct palpation executes the synthesis of the 1D/2D Simplicial Complex, which approximates the Medial Axis of the solid, and, unlike previous SDF approaches, ours includes the mixture of 1D and 2D simplicial Medial Axes. Additionally, unlike other approximations of Medial Axis by Voronoi methods, which require extensive pruning of MA fibrosities, ours computes a Skeleton directly, without generating fibrosities.

Our method inherits the advantages of SDF of being an economical estimation of the Medial Axis Radius Scalar Field. However, it also inherits the disadvantage of SDF of failing to approximate the Medial Axis Radius scalar field in the cases of prismatic regular solids.

This manuscript is divided as follows: Section 2 reviews the existing literature and draws the conclusions about the current status. Section 3 explains the applied methodology. Section 4 displays the results of our implementation, and Section 5 concludes the article and sketches possible future research directions.

A glossary of terms is provided at the end of the manuscript, before the references, to help readers clarify terminology as needed.

2. Literature Review

We review some of the most relevant existing 3D shape skeletonization methods. For more exhaustive information on different methods, we refer the reader to Tagliasacchi et al. [11].

2.1. Mesh Contraction

The Mesh Contraction method [12] iteratively performs geometry collapses on an input surface mesh until the shape volume is close to zero. Constrained Laplacian smoothing is used for the geometry collapses and then the contracted mesh is converted into a curve Skeleton. Cao et al. [13] extends the Mesh Contraction method by allowing point cloud inputs and improving on the conversion from the contracted shape to a curve Skeleton.

2.2. Sphere-Meshes

Thiery et al. [14] proposes a different shape approximation structure called Sphere-Meshes. Given a surface mesh input, their algorithm produces a user-specified number of connected spheres that minimize a distance function with respect to the input mesh.

2.3. Voxel Thinning

Voxel thinning methods [15,16] use an image model of the input shape and the output Skeleton. These methods work mainly by removing boundary voxels according to different criteria until a thin model is obtained. Moreno et al. [17] produces a Graph Skeleton from the result of the thinning process. In both [17,18], it is shown that when trying to force a curve Skeleton representation for a general 3D shape, the thinning algorithm produces more fibrosities.

2.4. Shape Diameter Function-Based Methods

Shapira et al. [10] present a method that uses Moving Least Squares projections on an SDF-based point cloud to build a Medial Axis approximation. However, the obtained Skeleton consists only of 1D segments, failing to accurately represent shapes with 2D structures. We have not found references in addition to [10] for MA using SDF-based point clouds. This absence has a relation to our decision to work in this direction.

2.5. Voronoi Medial Axis Simplification

The Voronoi Medial Axis simplification methods first extract an initial, large, noisy Medial Axis using Voronoi diagrams. Later, according to different criteria, pruning or mesh simplification is iteratively performed. Medial Meshes [19] simplify the initial Medial Axis by iteratively performing edge contractions until a shape approximation error reaches a threshold.

In $\lambda$-MAT [20], medial balls are discarded so that only those that have a radius of at least $\lambda$ are preserved. $\lambda$-MAT can lead to an important loss of features at different scale structures of the input shape.

Scale Axis Transform (SAT) [21] scales the medial balls by some factor $s>1$ and deletes those that end up contained in another ball, i.e., are no longer maximal. Then, it scales the medial balls back by a factor $1/s$. Progressive Medial Axis [22] extends SAT by performing edge collapses based on ball absorption. SAT computes multiple Voronoi diagrams, which result in low computational efficiency.

Mean Curvature Skeletons [23] perform iterative Mesh Contraction based on the Mean Curvature Flow due to its area-reducing properties. However, it requires the input mesh to be significantly dense.

Q-MAT [24] iteratively performs edge collapses on the initial Voronoi extracted MA based on the QEM framework [25]. Q-MAT final result depends on the quality of the initial MA used for simplification. To yield a better quality initial MA, Q-MAT+ [26] uses the SDF to identify thin parts and increases the sampling density in those thin regions.

Coverage Axis [27] uses the Set Cover Problem to select a minimum number of inner points whose dilated balls cover a set of sampled points that lie on the object’s surface. Then, Coverage Axis follows the approach of Q-MAT [24] to obtain a connected MAT, with the addition of preserving the previously identified inner points. However, Coverage Axis [27] suffers from a high computational burden for shapes with planar structures. Coverage Axis++ [28] formulates a different inner point selection algorithm that runs more efficiently.

2.6. Point Cloud Skeletons

Point cloud skeletonization methods allow for inputs lacking manifold information about the shape’s underlying surface. Least Squares MAT [29] computes a Skeleton using information of a Signed Distance Function from an oriented point cloud.

The Iterative Medial Axis Transform [30], iteratively identifies a set of maximally inscribed balls that minimizes a shape disparity function.

Ma et al. [31] compute a set of Medial Axis points from an oriented point cloud sampled from a surface. For each sampled point p, a ball tangent to p is iteratively shrunk until it is maximal. The ball has the restriction of having its center located along the line that passes through p in the direction of the normal of point p. The aforementioned methods, however, lack topology information in the Medial Axis.

Jalba et al. [32] improve Ma et al. [31] performance and proposes methods to obtain a surface Skeleton from the computed Medial Axis points by applying Delaunay triangulation or a Ball Pivoting Algorithm on said points.

Coverage Axis [27] also allows for point cloud inputs, in which case it uses the Power Diagram following Amenta et. al. [2].

2.7. Learning-Based Medial Axis

Point2MM [33] learns a geometric transformation to predict the medial spheres of a point cloud. Later, it predicts the connectivity of the medial spheres to form a medial mesh. Neural Skeleton [34] uses Implicit Neural Representation training on a point cloud to extract skeletal points. Then, it follows Coverage Axis [27] to retrieve the Skeleton mesh. These methods suffer mainly from requiring training time and data in order to achieve satisfactory results.

The present manuscript does not intend to explore Artificial Intelligence learning methods for Shape Encoding. Our work strictly lies in the domain of Applied Computational Geometry.

2.8. Conclusions of Literature Review

We present the conclusions of the Literature Review in

Table 1. Conclusions of the literature review. Our approach is compared against relevant Medial Axis approximation methods. First column: name of the approach. Second column: references for the corresponding approach. Third and fourth columns: main advantages and disadvantages of each corresponding approach, respectively.

Approach	Refs.	Main Advantages	Main Disadvantages
Mesh Contraction	[12,13]	(1) Can handle noisy input. (2) The Skeletons produced are pose invariant.	(1) Computationally expensive. (2) Only produces 1D Skeletons.
Sphere-Meshes	[14]	(1) Can handle incomplete datasets. (2) Represents shapes using very few primitives.	(1) The produced Skeleton can lie outside the input mesh. (2) Topology is not always preserved.
Voxel Thinning	[15,16,17,18]	(1) Direct compatibility with volumetric data. (2) Can soften the effect of noise on surfaces.	(1) The Skeleton is constrained to the fixed Voxel grid. (2) Skeleton centeredness can be lost.
Voronoi Medial Axis Simplification	[20,21,22,23,24,26,27]	(1) Can be error-controllable. (2) Have topological information. (3) Allows for a high accurate approximation of the input shape.	(1) Highly dependent on the initial Medial Axis quality. (2) Large noise can yield unstable results.
Point Cloud Skeletons	[27,29,30,31]	(1) Can handle both mesh and point cloud inputs. (2) Can handle noisy input.	(1) Lacks connectivity information.
Learning-based Medial Axis	[33,34,35]	(1) Can handle input with missing parts for trained data.	(1) Poor results for new data. (2) Requires training time for satisfactory results.
Direct Palpation on the SDF-based Point Cloud	Our approach	(1) Does not require the full computation of Voronoi-based Medial Axis with all fibrillations, which then must be eliminated. (2) Delivers mixed 1D/2D Medial Axes, unlike competitor SDF-based methods [10].	(1) The SDF-based point cloud does not always approximate the Medial Axis. (2) It is vulnerable in high-frequency neighborhoods of M (creases, pits, joints).

, where we mention relevant Medial Axis approximation approaches and some of their main advantages and disadvantages.

In this paper, we present a method for the computation of the Skeleton of a mesh M in an economical and faster way than existing approaches. We do not deal with the reconstruction based on Skeleton or object skin segmentation, which are downstream applications of the Medial Axes.

3. Methodology

3.1. Scope

We want to reiterate that Medial Axes or Skeletons are essentially filters. Therefore, according to the characteristics of the filter, some parts of the original solid may be lost. It is not within the scope of this paper to quantify the effect of the filter on the reconstruction of the object based on the Skeleton.

It is also important to note that, in our approach, we frequently use local Principal Component Analysis (PCA) in order to identify Piecewise Linear approximations for curves and surfaces within a point cloud. We do not try to approximate a curve or a surface with only one straight edge or only one planar surface. In any case, the initial triangular meshes must be very dense in high frequency neighborhoods in order to respect the Whittaker–Nyquist–Shannon theorem [36], regardless of any ulterior computation (e.g., Medial Axis, Resampling, Finite Element, etc.).

A glossary is presented at the end of this manuscript, before the references, providing definitions for terms used throughout the text.

3.2. Manifold Learning by Direct Palpation

Our algorithm probes local neighborhoods of the SDF-based point cloud, seeking locally planar surfaces or locally straight segments. This means our algorithm tests the local neighborhoods of the SDF-based point cloud for compliance with the definition of a 2-manifold with border or a 1-manifold with border. Such definitions follow [37].

Definition 1 

(k-manifold with border. k = 1 for 1-manifolds or curves, k = 2 for 2-manifolds for surfaces). A set $M\subset {\mathbb{R}}^3$ is a k-manifold with Border if for each point $p\in M$ there exists a $\delta \in {\mathbb{R}}^{+}$ such that for all radius r with $0<r<\delta$, $B(p,r)\cap M$ is isomorphic to either (1) the disk $S^k$ or (2) the half-disk $S^k/2$.

This definition informally means that, locally, the neighborhoods look like (a) flat surfaces (2-manifolds) of (b) straight line segments (1-manifolds). Therefore, they can be identified with Principal Component Analysis (PCA).

Our algorithm attempts to identify all point cloud regions that are locally homeomorphic to a plane or to a straight segment. This is an instance of Manifold Learning. This identification is executed through PCA. The regions in which this probe fails (i.e., are neither planes or lines) are graded as “Gray” and processed differently, as they indicate high frequency regions/junctions (Section 3.7).

PCA has been extensively used in processing and characterizing point cloud data. For example, in [38,39] PCA is used for plane fitting on local point cloud regions.

3.3. Simplices and Simplicial Complexes

We use the following definitions of simplices and simplicial complexes [40]:

The simplexes considered in this manuscript are 0-simplex (vertex), 1-simplex (straight edge), 2-simplex (triangular area), and 3-simplex (solid tetrahedron). The face of a 3-simplex is a 2-simplex (triangular area). A face of a 2-simplex is a 1-simplex (straight edge). The face of a 1-simplex is a 0-simplex (vertex). The faces of a k-simplex include all its constitutive $k-1,k-2,\dots$ simplexes. For example, the faces of a tetrahedron are all its triangles, edges, and vertices.

Definition 2 

(Simplicial Complex). A simplicial complex $\mathcal{S}$ is a set of simplexes, and their faces, which satisfy that for all $s_k,s_w\in \mathcal{S}$, either (1) $s_k\cap s_w=⌀$, or (2) $s_k\cap s_w\in \mathcal{S}$.

3.4. Overview of Direct Palpation Skeleton Identification

The proposed method consists of first identifying subsets of the SDF-based point cloud that exhibit 1D or 2D nature. Then, build piecewise linear curves C [41] from the 1D point cloud subsets $P_C$, and surface meshes S from the 2D point cloud subsets $P_S$. This yields a set of disconnected Skeleton regions.

To obtain a fully connected Skeleton, we use data from unclassified SDF-based point cloud subsets (neither 1D nor 2D) to help establish connections in the regions where the Skeleton is missing. The pipeline of our approach is shown in Figure 1.

Algorithm 1: One-dimensional and 2D MA region building

Algorithm 2: Identification of Bridges between MA subsets

Algorithm 3: Line Generation between Skeleton subsets through a Bounding Box

3.5. Shape Radius Function

The Shape Diameter Function is defined as a scalar function $\mathrm{SDF}:M\to {\mathbb{R}}^{+}$ representing the neighborhood diameter of M at each point $p\in M$ [10]. We obtain an SDF-based point cloud following Shapira et al.’s [10] procedure. Each SDF-based point is generated as follows:

$${\mathbf{p}}_i={\mathbf{z}}_i-\left({\mathrm{SDF}}_i/2\right){\mathbf{n}}_i$$

(1)

where ${\mathbf{z}}_i$ and ${\mathrm{SDF}}_i$ are the incenter and the SDF value of the ith triangle, respectively. ${\mathbf{n}}_i$ corresponds to the ith triangle normal. In this manuscript, to compute the SDF, instead of multi-ray tracing using multiple oscillations of the normal of each triangle [10] we use 1-ray tracing using an averaged local normal vector, since this helps to speed up the computation of the SDF while maintaining its accuracy. From now on, we refer to the SDF-based point cloud as the Shape Radius Function (SRF) point cloud $P_{\mathrm{SRF}}$. An example of the SRF point cloud is shown in Figure 2.

3.6. Dimension Identification of Skeleton Subregions

Our approach first identifies points on $P_{\mathrm{SRF}}$ that will serve as centers to perform Principal Component Analysis (PCA). To obtain said centers, $P_{\mathrm{SRF}}$ is downsampled by applying a 3D box grid filter to it.

On each center, a PCA ball is attached, which is an open ball $B(p,R_{\mathrm{PCA}})$ centered in p with radius $R_{\mathrm{PCA}}$. The PCA Ball radius $R_{\mathrm{PCA}}$ is computed as $R_{\mathrm{PCA}}=\epsilon d$, where d is the average edge length of M and $\epsilon$ is a safety factor, required to be input by the user.

The procedure for the construction of the 1D and 2D Skeleton subsets (C and S, respectively) from $P_{\mathrm{SRF}}$ is presented in Algorithm 1.

In the first 13 lines, we iterate over each PCA ball and check what points of $P_{\mathrm{SRF}}$ it encloses. PCA is performed with this enclosed point subset, and its dimension is established by checking the proportions of the magnitude of the three largest eigenvalues obtained by PCA. If there is no eigenvalue significantly larger or smaller than the others, the enclosed point subset is marked as neither 1D or 2D. By the end of the first 13 lines, we obtain the following $P_{\mathrm{SRF}}$ subsets: (1) 1D identified points $P_C$, (2) 2D identified points $P_S$ and (3) unidentified points $P_G$, also called Gray Zones.

The values for the 1st-to-2nd and 2nd-to-3rd eigenvalue ratios $\alpha$ and $\beta$ are manually input. The higher these values, the more the enclosed point subset needs to strictly resemble a curve or a surface. Figure 8 shows an overview of how these parameters are used in the overall pipeline (more details in Section 3.8).

From lines 14 to 23, we cluster the $P_C$ and $P_S$ point clouds, in order to later identify separate curves and surfaces.

One-dimensional clusters $P_C^{\ast }$. For each $P_C^{\ast }$ point set cluster, we fit a sequence of linear segments (PL approximation [41]). Notice that if a set of points resembles a line, PCA will associate the eigenvector (local line vector) with the largest eigenvalue of the point set auto-covariance matrix.

Two-dimensional clusters $P_S^{\ast }$. For each $P_S^{\ast }$ point set cluster, we apply ball-based PCA identifications, which render (point, normal) pairs. We use this point and normal information to perform point cloud triangulation (Point Cloud Library PCL [42]). Notice that if a set of points resembles a surface, PCA will associate the eigenvector (local surface normal) with the smallest eigenvalue of the point set auto-covariance matrix.

3.7. Junction of Disconnected Subregions

After obtaining all the sets of definite 1D and 2D Skeleton subsets C and S, we still need to achieve a fully connected Skeleton, because all C and S are disjointed, as shown in Figure 3b.

We use information from the Gray Zones point cloud $P_G$ to help establish connections between Skeleton subsets. In the SRF point cloud, subsets lacking a clear 1D or 2D character correspond to neighborhoods in the Skeleton where transitions between 1D and 2D structures appear. These regions are called “gray” in the manuscript. Thus, $P_G$ points are located in the missing Skeleton regions that bridge the various curves C and surfaces S.

Our objective is to create bridges or connections located in these Gray Zones. Bridges are surface meshes that serve as supports for connecting definite 1D/2D Skeleton subsets. The bridges do not reach the subsets that they communicate. Instead, a blend surface is later used to fill the remaining gap between the bridge and the Skeleton subsets, as described in Section Mesh Stitching.

As shown in Algorithm 2, we first cluster $P_G$, and for every cluster, an optimal bounding box is computed and scaled. We scale the bounding box to identify what points from all the Skeleton subsets are inside and thus involved in a joining process (Figure 4a). The disposition of these identified points will dictate the type of union to be performed.

Case 1. Boundary-based bridges among MA subsets. In the first case, N Skeleton subsets are to be connected through their boundaries. Joining lines are established between all the points enclosed by the bounding box (see Algorithm 3), except between those belonging to the same subset, as shown in Figure 4b.

After joining the points, the joining lines are sampled, as shown in Figure 4c. We want to later triangulate these sampled points to form a surface mesh. Thus, points too close to the line endpoints are discarded to avoid intersections with the Skeleton subsets. Finally, the resulting sampled point cloud is triangulated (Figure 4d), following the same approach as the 2D Skeleton subset triangulation in Section 3.6.

If only two Skeleton subsets are to be joined, we still create joining lines and sample them as in Case 1: Boundary-based bridges among MA subsets. However, we check if the sampled point cloud resembles a line by doing PCA with said point cloud [41]. If the point cloud was identified as 1D, we choose the joining line that is closer to the centroid of said point cloud and thus skip the process of creating a bridge mesh.

Case 2. Interior-based connections among MA subsets. When joining two Skeleton subsets and not all the candidate points lie on the boundaries, we do not create bridges and instead produce connections according to two main scenarios: (1) Candidate points resemble a polyline, and (2) candidate points do not resemble a polyline. The polylines do not need to be closed; however, we do not handle self-intersecting polylines. A combination of possible scenarios can be seen in Figure 5. In Section Mesh Stitching, we explain the algorithm to create the connections for said scenarios.

Mesh Stitching

Once a bridge is created, the next step is to fill the gap between the Skeleton subsets and the bridges in order to obtain a fully connected Skeleton. We first address the case where the bridge connects Skeleton subsets by its boundary.

We begin by identifying pairs of vertices between the Skeleton subset and the bridge that are within a specified proximity threshold ($d_{\mathrm{avg}}$). See Section 3.8. Using these matched vertices, we extract a sequence of connected points that forms a closed path spanning both the Skeleton subset and the bridge mesh.

This path contains points from both structures. To construct a blending structure in it, we apply Algorithm 4 as follows:

We first take the sequence of points from the Skeleton subset that lie on the path and iterate over them. For each pair of consecutive points, we attempt to form a triangle using those two points and an optimal third point selected from the bridge-side points along the path (lines 2–6). We then repeat the process symmetrically: iterating over the bridge-side points and selecting the third point from the Skeleton subset.

In other words, we extract a sequence of points P from the Skeleton subset and a sequence of points Q from the bridge, and pass these as inputs to Algorithm 4.

Algorithm 4: Blend Creation via Simple Loop Traversing

    Figure 6 illustrates an example in which the algorithm is applied twice to connect a bridge with two different Skeleton subsets.

In the first step, the black point cloud is partitioned into P and Q, where P consists of a sequence of points on the 1D Skeleton subset, and Q consists of the corresponding point sequence on the bridge. The blending mesh is computed using these inputs. In the second step, the red point cloud is similarly divided into P and Q, and the algorithm is applied again.

The resulting blending meshes connect the bridge to the Skeleton subsets, as shown in Figure 6b.

The bottom line of the described Algorithm 4 is the creation of a blend between two polylines. Therefore, the same algorithm can be applied to join the identified points in Case 2: Interior based connections among MA subsets, where the candidate points do not lie on the boundary but do resemble a polyline (Figure 5a,b).

In the case where candidates in neither Skeleton subset resemble a polyline (Figure 5c), we choose the joining line that is closer to the centroid of the candidate points. An example of this type of union is presented in Figure 7.

3.8. Parameter Tuning

Currently, our approach requires the manual input of the parameters $\epsilon$, $\alpha$ and $\beta$. To compute the PCA ball radius we opt for making the radius a function of an statistical value based on the edge lengths of the input shape M, in this case $R_{\mathrm{PCA}}=\epsilon d_{\mathrm{avg}}$.

Since the parameters $\alpha$ and $\beta$ dictate the identified dimension of $P_{\mathrm{SRF}}$ subsets, they can be tuned to obtain Medial Axes that are fully 1D or 2D. In our experiments, we found that a value of $\epsilon =3$ allows for a good dimension identification process, along with $\alpha =4, \beta =4$.

An overview of the parameter tuning process is shown in Figure 8, and it goes as follows: we first extract an average length value $d_{\mathrm{avg}}$ from the set of edges $E_M$ of the input mesh. We use this value to compute each PCA ball radius $R_{\mathrm{PCA}}$. We then use $\alpha$ and $\beta$ to identify Curves, Surfaces, and a Gray Zone point cloud $P_G$. The point cloud is clustered by grouping points that are closer than $d_{\mathrm{avg}}$ to each other. Finally, with the clustered Gray Zones $P_G^{\ast }$, we carry out the joining process of the Skeleton.

3.9. Parameter Influence

The parameter $\epsilon$ directly influences the size of the PCA Balls used to classify local neighborhoods of the SRF point cloud. We compute the radii of the PCA Balls as $R_{\mathrm{PCA}}=\epsilon d_{\mathrm{avg}}$, where $d_{\mathrm{avg}}$ is the average edge length of the input mesh. This means that bigger $\epsilon$ values will generate bigger PCA Balls.

Ideally, the PCA Balls must be large enough to correctly capture the underlying dimension of each local neighborhood of the SRF Point Cloud $P_{\mathrm{SRF}}$, but not too large that a single PCA Ball encloses unrelated $P_{\mathrm{SRF}}$ regions. In Figure 9, a $P_{\mathrm{SRF}}$ that samples (with noise) a circumference is used to show how the value of $\epsilon$ may change the underlying dimension of the enclosed point cloud subsets.

The values for $\epsilon$ that we provide in the following paragraphs correspond to results from our experiments, where $d_{\mathrm{avg}}$ was, on average, 1% of the length of the diagonal bounding box of the input mesh.

If $\epsilon$ is too small (e.g., $1<\epsilon <2$), the enclosed point cloud subsets of the $P_{\mathrm{SRF}}$ will lack a clear tendency towards a curve or a surface. This case is shown in Figure 9a, where each enclosed point cloud subset resembles a solid sphere, causing eigenvalue ratios of ${\lambda }_1/{\lambda }_2\approx 1$ and ${\lambda }_2/{\lambda }_3\approx 1$, i.e., they resemble a solid.

Moderate $\epsilon$ values (e.g., $3<\epsilon <6$) create PCA Balls that enclose point cloud subsets with clearer curve or surface tendencies. This case is shown in Figure 9b, where each enclosed point cloud subset resembles a solid but tubular shape, causing the eigenvalue ratios ${\lambda }_1/{\lambda }_2\approx 4$ and ${\lambda }_2/{\lambda }_3\approx 1$, i.e., each point cloud subset potentially samples a curve. This is the desired behavior in this particular example, given that $P_{\mathrm{SRF}}$ originally samples a 1D structure.

Too large $\epsilon$ values (e.g., $\epsilon >7$) can create PCA Balls that enclose very large portions of the $P_{\mathrm{SRF}}$, which could cause loss of detail or misidentification of the underlying Skeleton structure. In Figure 9c, the resulting enclosed point subset is the entire $P_{\mathrm{SRF}}$, causing the eigenvalue ratios to be ${\lambda }_1/{\lambda }_2\approx 1$ and ${\lambda }_2/{\lambda }_3\approx 12$, i.e., the points potentially sample a surface. This is an undesired behavior, since $P_{\mathrm{SRF}}$ originally samples a 1D structure.

Let ${\lambda }_1>{\lambda }_2>{\lambda }_3$ be the eigenvalues obtained from applying PCA on a local neighborhood of the SRF point cloud (Algorithm 1 line 4). $\alpha$ is the minimum ratio ${\lambda }_1/{\lambda }_2>\alpha$ that must be satisfied in order for the enclosed point cloud subset to be classified as belonging to a curve. $\beta$ is the minimum ratio ${\lambda }_2/{\lambda }_3>\beta$ that must be satisfied in order for the enclosed point cloud subset to be classified as belonging to a surface.

Setting $\alpha =1$ means that all local neighborhoods of the SRF point cloud $P_{\mathrm{SRF}}$ will pass the check of curve tendency, since the eigenvalues from each PCA Ball will always hold that ${\lambda }_1/{\lambda }_2\ge 1$.

In the same way, setting $\beta =1$ means that all point subsets of $P_{\mathrm{SRF}}$ will pass the check of surface tendency, since the eigenvalues from each PCA Ball will always hold that ${\lambda }_2/{\lambda }_3\ge 1$.

This means that, if $\alpha =\beta =1$, all the local neighborhoods within the SRF point cloud will be classified exclusively as 1D or 2D, depending on the order in which the eigenvalue ratios are checked (see Algorithm 1 lines 4 to 12).

Figure 10 shows how the final dimension of the Skeleton of an input mesh M changes depending on the values set for $\alpha$ and $\beta$. If $\alpha \approx \beta$ (e.g., $\alpha =\beta =3$) then the Skeleton will likely have a mixture of 1D and 2D elements. This behavior can be seen in Figure 10b.

If $\alpha \gg \beta$ (e.g., $\alpha =100$ and $\beta =1$) then all local neighborhoods of $P_{\mathrm{SRF}}$ will likely fail the curve tendency test and will pass the surface tendency test. This means that all the local neighborhoods of $P_{\mathrm{SRF}}$ can be used only to build 2D structures, leading to pure 2D Skeletons (Figure 10c).

If $\beta \gg \alpha$ (e.g., $\alpha =1$ and $\beta =100$) then all local neighborhoods of $P_{\mathrm{SRF}}$ will likely fail the surface tendency test and will pass the curve tendency test. In this setting, all the local neighborhoods of $P_{\mathrm{SRF}}$ will be used to build 1D structures, leading to pure 1D Skeletons (Figure 10d).

Figure 10d also shows that forcing apparent 2D Skeleton regions to be 1D can lead to artifacts in the final Skeleton, such as loss of centrality.

Scale Invariance

Let $P=\left\{p_0,p_1,\dots ,p_n\right\}$, $p_i\in {\mathbb{R}}^3$ be an arbitrary 3D point cloud, and let $\overline{p}$ denote its centroid. The covariance matrix K can be computed as

$$K={\displaystyle \frac{1}{n}}\sum _{i=0}^n\left(p_i-\overline{p}\right){\left(p_i-\overline{p}\right)}^T$$

(2)

If the point cloud is uniformly scaled by a factor s, the new covariance matrix $K^{\prime }$ becomes

$$K^{\prime }={\displaystyle \frac{1}{n}}\sum _{i=0}^n\left(s{p}_i-s\overline{p}\right){\left(s{p}_i-s\overline{p}\right)}^T=s^2\sum _{i=0}^n\left(p_i-\overline{p}\right){\left(p_i-\overline{p}\right)}^T=s^{2}K$$

(3)

This shows that uniformly scaling the input by a factor s results in the covariance matrix being scaled by a factor of $s^2$. Moreover, if $\lambda$ is an eigenvalue of K, with corresponding eigenvector v, then

$$K^{\prime }v=\left(s^{2}K\right)v=s^2\left(Kv\right)=s^2\lambda v$$

(4)

Thus, if $\lambda$ is an eigenvalue of the original covariance matrix K, then $s^2\lambda$ is an eigenvalue of the scaled covariance matrix $K^{\prime }=s^{2}K$. Additionally, the eigenvectors remain unchanged. In other words, scaling a point cloud by a factor s scales the eigenvalues produced by PCA by $s^2$, while preserving the eigenvectors.

In our method, the local structure of the SRF point cloud $P_{\mathrm{SRF}}$ is classified using the ratios of the eigenvalues ${\lambda }_1,{\lambda }_2,{\lambda }_3$ obtained from local PCA. Specifically, a region is classified as curve-like if ${\lambda }_1/{\lambda }_2>\alpha$, and as surface-like if ${\lambda }_2/{\lambda }_3>\beta$. When the input mesh is scaled by a factor s, the point cloud $P_{\mathrm{SRF}}$ is also scaled accordingly. The new eigenvalue ratios become:

$${\displaystyle \frac{s^2{\lambda }_1}{s^2{\lambda }_2}}={\displaystyle \frac{{\lambda }_1}{{\lambda }_2}},{\displaystyle \frac{s^2{\lambda }_2}{s^2{\lambda }_3}}={\displaystyle \frac{{\lambda }_2}{{\lambda }_3}}$$

(5)

This demonstrates that the eigenvalue ratios are invariant to the scale of the input data. Consequently, the parameters $\alpha$ and $\beta$ are independent of the scale of the point cloud. Similarly, the parameter $\epsilon$ is also scale-invariant, since it appears in the expression $R_{\mathrm{PCA}}=\epsilon d_{\mathrm{avg}}$, where $d_{\mathrm{avg}}$ is the average edge length of the input mesh, and therefore scales as $s{d}_{\mathrm{avg}}$.

This scale invariance makes our method robust across datasets with different units or scale conventions (e.g., meters vs millimeters).

4. Results

In this section, we present the results, timing, and complexity comparisons of our algorithm with the other two relevant Medial Axis approximation approaches, which have publicly available code: QMAT [24] and Mean Curvature Skeletons (MCS) [23].

In Figure 11, we show the Skeletons obtained with QMAT, MCS, and our approach for several datasets. For our method, Green and yellow triangles indicate the bridges and connections, respectively, previously explained in Section 3.7.

For clarity, abbreviations and terms used in this manuscript appear in a glossary, which is presented at the end of this manuscript, before the references.

4.1. Experimental Setup

All programs were run on a Windows 10 PC with an Intel Core i5-7500 CPU 3.4 GHz and 8 GB of RAM. All the reported timings correspond to a value averaged over 5 runs.

For QMAT, the number of vertices that the final Skeleton will have must be specified. We used a value of 500 vertices, since it generally yields a good enough approximation for the Medial Axis, as can be seen in their work [24]. For MCS, we used the default parameter values that their software provided, with an iteration number of 5. For our algorithm, we used values of $\epsilon =3$, $\alpha =4$ and $\beta =4$ for all the presented datasets.

4.2. Performance Analysis

The time taken for the Medial Axis approximation algorithms to run is presented in

Table 2. Execution Processor time comparison. Our method vs. [23,24]. First column: model name. Second and 3rd columns: number of vertices and faces of the model, respectively. Fourth column: QMAT [24]. Displayed times (seconds) in software QMAT^TM [43]. 5th column: MCS [23]. Displayed times (seconds) in software STARLAB^TM [44]. 6th column: Our approach. Processor Usage times (seconds). Compilable version of QMAT [24] was not found.

Dataset	Verts	Faces	QMAT [24]	MCS [23]	Ours
Airplane	7739	15,474	4.52	0.856	0.183
Ant	5867	11,730	3.57	0.769	0.17
Bird	6351	12,698	3.76	0.716	0.149
Chair	10,500	21,008	6.81	1.128	0.202
Cup	7652	15,304	4.33	1.004	0.168
Hand	5468	10,932	3.26	0.667	0.146

and Figure 12, where it can be seen that QMAT is the approach that took longer to run, followed by MCS and finally by our approach, which was the fastest in all the evaluated datasets.

Notice that it is unclear if the displayed time of our competitors refers to wall clock time, Processor Usage time, or another kind of metric.

In addition to the timing table, we present an algorithm time complexity analysis in

Table 3. Time complexities of different Medial Axis approximation methods. Our method vs. [10,23,24]. n is the number of points in the input model. The complexity was calculated based on the standard costs of each different task.

Shape Diameter Function Approaches
Approach	Shape Diameter Function	Synthesis of $P_{\mathrm{SRF}}$	Dimension Identification	Medial Axis Building	Overall
Shapira et al. [10]	$O\left(n^2\right)$	$O\left(n\right)$	—	$O\left(n^2\right)$	$O\left(n^2\right)$
Ours	$O\left(n^2\right)$	$O\left(n\right)$	$O(nlogn)$	$O(nlogn)$	$O\left(n^2\right)$
Voronoi Approaches
Approach	Preprocessing	Voronoi Medial Axis	Parameter Initialization	Medial Axis Simplification	Overall
QMAT [24]	$O\left(n\right)$	$O\left(n^2\right)$	$O\left(n\right)$	$O(nlogn)$	$O\left(n^2\right)$
MCS [23]	$O\left(n^3\right)$	$O\left(n^2\right)$	$O\left(n^2\right)$	$O\left(n^3\right)$	$O\left(n^3\right)$

based on the number of vertices of the input mesh. The complexity was calculated by using the standard costs of each different task.

In Table 3, it is shown that our algorithm maintains the overall time complexity of Shapira et al. [10] but with the advantage of being able to handle mixed 1D/2D Skeletons, unlike Shapira’s which only produces 1D Skeletons. Besides, in comparison with QMAT and MCS, our approach does not increase complexity.

The Shape Diameter Function has a complexity of $O\left(n^2\right)$, as we cast a ray for each triangle in the mesh and check for intersections. Notice that this operation can be optimized using data structures like Bounding Volume Hierarchies (BVH) or by leveraging the GPU, both of which are efficient for ray-triangle queries and can significantly reduce the complexity. However, to ensure fair comparisons in the complexity analysis, we use the standard costs for the core steps across all methods.

The SRF point cloud $P_{\mathrm{SRF}}$ is computed in $O\left(n\right)$ time, since for each triangle of the input mesh we generate a point (see Section 3.5).

In the dimension identification step of our method, we downsample $P_{\mathrm{SRF}}$ to obtain center points for the PCA balls. This downsampling can be performed using a voxel grid filter, with linear complexity $O\left(n\right)$. For each center, we identify the point subset from $P_{\mathrm{SRF}}$ that are contained in a sphere centered at the current point. These neighborhood queries are executed using a kd tree, which has a build complexity of $O(nlogn)$ and a per-query complexity of $O(logn+k)$, where k is the number of points returned. Each PCA computation is $O\left(k\right)$. Since $k\ll n$, and the number of centers is much less than n, the total complexity is dominated by the kd tree construction, resulting in an overall complexity of $O(nlogn)$ for the dimension identification step.

In the Medial Axis building step, we cluster point clouds using PCL’s Euclidean Cluster Extraction [42], with complexity $O(nlogn)$. Piecewise linear approximations involve PCA to estimate directions (for curves) and normals (for surfaces), along with k-d tree queries, also at $O(nlogn)$. Bounding box computation and point-in-box checks each run in $O\left(n\right)$. Assuming the Skeleton includes bridges and connections, the overall complexity of the building step is $O(nlogn)$. Consequently, the total time complexity of our method (including all steps) is $O\left(n^2\right)$.

Shapira et al. [10] do not perform a dimension identification step, as their method assumes that Skeletons are always 1D. Neighborhood queries are performed for all n input points in order to estimate local 1D structures. Each query may involve comparing against all other points, leading to a complexity of $O\left(n^2\right)$. Additional steps, such as grouping and connecting these local structures, do not introduce higher asymptotic costs. Therefore, the overall complexity of the method is $O\left(n^2\right)$.

In QMAT [24], the input mesh must first be sampled to enable the initial computation of the Medial Axis. Assuming uniform sampling, this step has a linear complexity of $O\left(n\right)$. The computation of the initial Medial Axis involves constructing a Delaunay triangulation, which can have a complexity of $O\left(n^2\right)$ in 3D. Before simplifying the Medial Axis, Q-MAT computes both the optimal contraction target and the collapse cost for each edge, which is a linear operation $O\left(n\right)$. The subsequent simplification of the Medial Axis adopts the edge collapse strategy introduced by Garland and Heckbert [25], which has a complexity of $O(nlogn)$. The overall time complexity of the QMAT is then $O\left(n^2\right)$.

In MCS [23], the input mesh is finely remeshed and sampled to obtain high-quality Voronoi poles. This preprocessing step can take up to $O\left(n^3\right)$, depending on the desired quality. Computing the initial Voronoi diagram takes $O\left(n^2\right)$. Medial Axis simplification is performed iteratively, with a cost of $O\left(n^2\right)$ for structure preparation (e.g., Laplacian computation, weight assignment, remeshing), followed by linear system solving at up to $O\left(n^3\right)$. Thus, the overall time complexity of MCS is $O\left(n^3\right)$.

We present a comparison of the evolution of the execution times with larger input sizes (Figure 13), between our method and QMAT. The MCS software did not admit the computation of the Skeleton for meshes with a large amount of triangles (more than 600,000), which is why it is excluded from this analysis.

Figure 13a shows that both methods (Ours and QMAT) exhibit quadratic growth in execution time as input size increases. However, our method has a smaller constant factor and demonstrates better practical scalability. The log–log plot in Figure 13b supports this observation: both methods have slopes near 2, indicating near-quadratic time complexity. Specifically, our method has a slope of 1.8, compared with QMAT’s 1.9, and our fitted line lies below QMAT’s, reflecting lower execution times across all input sizes. The fact that the slopes deviate slightly from 2 may be due to implementation-specific optimizations, deviations from worst-case behavior, or measurement variability.

4.3. Robustness to Noise

In this section, we evaluate the effect of noise of the input mesh M vertices on our computed Skeleton. Noise is created by displacing the vertices of M along their normals by a random value between 0 and ${ϵ}_{\max }$ (Noise Level). Noise Level is measured in percentage with respect to the length of the diagonal of the bounding box of M. Notice that the Noise Level is conditioned by the fact that M must preserve its manifoldness.

Figure 14 shows the effect of noise on a Cup dataset. For this analysis, we used $ϵ=4$, $\alpha =6$ and $\beta =4$. The Hausdorff distance metric was used to measure the error between the computed Skeletons and the Skeleton corresponding to the zero noise mesh.

Naturally, as the Noise Level increases, so does the error in the resulting Skeletons. As the SRF point cloud $P_{\mathrm{SRF}}$ becomes more scattered, the quality of local geometric estimates deteriorates, resulting in approximated structures that are increasingly irregular and less smooth. This behavior is expected, since it is well known that, in manifold learning, the density and uniformity of data sampling critically influence the accuracy of local neighborhood approximations.

At noise levels too high, all the local neighborhoods of $P_{\mathrm{SRF}}$ fail the test for curve or surface tendency, causing our algorithm to classify all local neighborhoods as Gray Zones. Since no Curve or Surface could be identified, no Skeleton can be built.

4.4. Limitations

Our method inherits the advantages and disadvantages of the Shape Diameter Function, which means that we benefit from qualities such as pose invariance and fast computation [10]. However, for some solids (e.g., symmetric prismatic shapes), the SDF is not able to generate a sampling of the Medial Axis and thus its computation can not be performed.

Figure 15 illustrates this limitation using a 2D square and rectangle. In both cases, the SRF point cloud $P_{\mathrm{SRF}}$ does not capture parts of the Medial Axis, especially near the corners, and includes points where the Medial Axis does not exist. In the square, only one point from $P_{\mathrm{SRF}}$ lies on the true Medial Axis. In the rectangle, more points fall along the central segment, but the diagonal branches near the corners remain unsampled. Several points still appear in regions unrelated to the Medial Axis.

This behavior is not caused by errors in our method. Instead, it follows directly from the definition of the $P_{\mathrm{SRF}}$: points projected inward from triangle incenters (or edge midpoints in 2D) at half the local thickness, given by the Shape Diameter Function (SDF). The limitation is therefore inherent to the use of SDF-based point clouds, not to the algorithm itself.

5. Conclusions and Future Work

We present a method to compute a Medial Axis approximation of a triangular mesh M by doing Direct Palpation on a point cloud derived from the Shape Diameter Function of M. Unlike existing Voronoi-based methods that rely on the computation of an initial fibrous Medial Axis and then simplify it, ours do not require performing simplification and instead build a Skeleton directly. In comparison with the SDF-based method presented by Shapira et al. [10], ours is capable of producing mixed 1D and 2D Skeletons.

Future work includes a generalization for the problem of joining disconnected Medial Axes subsets, as our current method only addresses specific scenarios that depend on the disposition of identified points on the MA subsets (Figure 5). Future work also includes reducing the amount of manually input parameters for the method so that it is completely self-tuning.

The geometric cues present in the SRF point cloud also open the door to learning-based strategies. These might assist in estimating the optimal value for parameters ($ϵ$, $\alpha$, $\beta$) or eliminating their need at all. Learning methods could also be explored to assist in deciding how to join disconnected Skeleton components or in predicting the complete Skeleton structure from the SRF point cloud.

To better handle high-frequency neighborhoods, our method might benefit from incorporating local surface descriptors or adaptive sampling to better capture fine details. However, prismatic shapes and sharp corners remain challenging because the SRF point cloud does not represent them well for the purpose of Skeleton extraction. This limitation might be alleviated by combining SRF data with other geometric representations suited to such cases.