-
MESH SIZE FUNCTIONS FOR IMPLICIT GEOMETRIES
AND PDE-BASED GRADIENT LIMITING
Per-Olof Persson
Dept. of Mathematics, Massachusetts Institute of Technology,
[email protected]
ABSTRACT
Mesh generation and mesh enhancement algorithms often require a
mesh size function to specify the desired size ofthe elements. We
present algorithms for automatic generation of a size function,
discretized on a background grid,by using distance functions and
numerical PDE solvers. The size function is adapted to the
geometry, taking intoaccount the local feature size and the
boundary curvature. It also obeys a grading constraint that limits
the sizeratio of neighboring elements. We formulate the feature
size in terms of the medial axis transform, and show howto compute
it accurately from a distance function. We propose a new Gradient
Limiting Equation for the meshgrading requirement, and we show how
to solve it numerically with Hamilton-Jacobi solvers. We show
examples ofthe techniques using Cartesian and unstructured
background grids in 2-D and 3-D, and applications with
numericaladaptation and mesh generation for images.
Keywords: mesh generation, size function, background grid,
Hamilton-Jacobi, gradation control
1. INTRODUCTION
Unstructured mesh generators use varying elementsizes to resolve
fine features of the geometry but havea coarse grid where possible
to reduce total mesh size.The element sizes can be described by a
mesh sizefunction h(x) which is determined by many factors.At
curved boundaries, h(x) should be small to resolvethe curvature. In
region with small local feature size(“narrow regions”), small
elements have to be used toget well-shaped elements. In an adaptive
solver, con-straints on the mesh size are derived from an
errorestimator based on a numerical solution. In addition,h(x) must
satisfy any restrictions given by the user,such as specified sizes
close to a point, a boundary, or asubdomain of the geometry.
Finally, the ratio betweenthe sizes of neighboring elements has to
be limited,which corresponds to a constraint on the magnitudeof
∇h(x).
In many mesh generation algorithms it is advanta-geous if an
appropriate mesh size function h(x) isknown prior to computing the
mesh. This includesthe advancing front method [1], the paving
method for
quadrilateral meshes [2], and smoothing-based meshgenerators
such as the one we proposed in [3],[4]. Thepopular Delaunay
refinement algorithm [5], [6] typi-cally does not need an explicit
size function since goodelement sizing is implied from the quality
bound, buthigher quality meshes can be obtained with good a-priori
size functions.
Many techniques have been proposed for automaticgeneration of
mesh size functions, see [7], [8], [9]. Acommon solution is to
represent the size function in adiscretized form on a background
grid and obtain theactual values of h(x) by interpolation, as
described inSection 2.1.
We present several new approaches for automatic gen-eration of
mesh size functions. We represent the geom-etry by its signed
distance function (distance to theboundary). We compute the
curvature and the me-dial axis directly from the distance function,
and wepropose a new skeletonization algorithm with subgridaccuracy.
The gradient limiting constraint is expressedas the solution of our
gradient limiting equation, a hy-perbolic PDE which can be solved
efficiently using fast
-
solvers.
2. DISCRETIZATION AND PROBLEMSTATEMENT
We represent the mesh size function h(x) approxi-mately on a
discretized grid. We store the functionvalues at a finite set of
points xi (node points) anduse interpolation to approximate the
function for ar-bitrary x. These node points and their
connectivitiesare part of the background mesh and below we dis-cuss
different options. We also describe briefly how tocompute a
discretized signed distance function for thegeometry, which we will
use in the calculation of localfeature sizes in Section 4.
2.1 Background Meshes
The simplest background mesh is a Cartesian grid(Figure 1, top).
The node points are located on auniform grid, and the grid elements
are rectangles intwo dimensions and blocks in three dimensions.
In-terpolation is fast for Cartesian grids. For each pointx we find
the enclosing rectangle and the local coor-dinates by a few scalar
operations, and use bilinearinterpolation within the rectangle.
This scheme is very simple to implement and theCartesian grid is
particularly good for implementinglevel set schemes and fast
marching methods (see Sec-tion 2.2). However, if any part of the
geometry needssmall cells to be accurately resolved, the entire
gridhas to be refined. This combined with the fact thatthe number
of node points grows quadratically withthe resolution (cubically in
three dimensions) makesthe Cartesian background grid memory
consuming forcomplex geometries.
An alternative is to use an adapted background grid,such as an
octree structure (Figure 1, center). Thecells are still rectangles
or blocks like in the Carte-sian grid, but their sizes vary across
the region. Sincehigh resolution is only needed close to the
boundary(for the distance function), this gives an asymptoticmemory
requirement proportional to the length of theboundary curve (or the
area of the boundary surfacein three dimensions). The grid can also
be adaptedto the mesh size function to accurately resolve partsof
the domain where h(x) has large variations. Theadapted grid is
conveniently stored in an octree datastructure, and the cell
enclosing an arbitrary point xis found in a time proportional to
the logarithm of thenumber of cells.
A third possibility is to discretize using an
arbitraryunstructured mesh (Figure 1, bottom). This pro-vides the
freedom of using varying resolution overthe domain, and the
asymptotic storage requirements
Cartesian
Octree
Unstructured
Figure 1: Background grids for discretization of the dis-tance
function and the mesh size function.
are similar to the octree grid. An additional advan-tage with
unstructured meshes is that they can bealigned with the domain
boundaries, making the dis-tance function accurate and the
curvature adaptationeasier (see Section 3). An unstructured
backgroundmesh can be used to remesh an existing triangula-tion in
order to refine, coarsen, or improve the elementqualities (mesh
smoothing). The unstructured back-ground grid is also appropriate
for moving meshes andnumerical adaptation, where the mesh from the
previ-
-
ous time step (or iteration) is used. Finding the trian-gle (or
tetrahedron) enclosing an arbitrary point x canstill be done in
logarithmic time, but the algorithm isslower and more
complicated.
2.2 Initialization of the Distance Function
The signed distance function φ(x) for a geometry givesthe
shortest distance from x to the boundary, with anegative sign
inside the domain. The geometry bound-ary is given by φ(x) = 0, and
the normal vectorn(x) = ∇φ(x). This representation is used in
thelevel set method [10], where the boundary can be prop-agated in
time by solving a Hamilton-Jacobi equation.
To initialize φ(x) on our background mesh, we com-pute the
distances to the geometry boundary for thenodes in a narrow band
around the boundary (typi-cally a few node points wide). We then
use the FastMarching Method (Sethian [11], see also Tsitsiklis
[12])to calculate the distances at all the remaining nodepoints.
The computed values are considered “knownvalues”, and their
neighbors can be updated and in-serted into a priority queue. The
node with smallestunknown value is removed and its neighbors are
up-dated and inserted into the queue. This is repeateduntil all
node values are known, and the total compu-tation requires O(n log
n) operations for n nodes.
If the geometry is given in a triangulated form, wehave to
compute signed distances to the triangles. Foreach triangle, we
find a band of background grid nodesaround the triangle (only a few
nodes wide) and com-pute the distances explicitly. The sign can be
com-puted using the normal vector, assuming the geometryis well
resolved. The remaining nodes are again ob-tained with the fast
marching method. We also men-tion the closest point transform by
Mauch [13], whichgives exact distance functions in the entire
domain inlinear time.
A general implicit function φ can be reinitialized toa distance
function in several ways. Sussman et al[14] proposed integrating
the reinitialization equationφt + sign(φ)(|∇φ| − 1) = 0 for a short
period of time.Another option is to explicitly compute the
distancesto the zero level set for nodes close to the boundary(e.g.
using the approximate projections in [4]), and usethe fast marching
method for the rest of the domain.
2.3 The Mesh Size Function
For a given geometry, we define our mesh size func-tion h(x) by
the following five properties. The scalarparameters K, R, G may all
be functions of space, andin Section 7.3 we even allow G to be a
function of themesh size h(x).
1. Curvature Adaptation On the boundaries, werequire h(x) ≤
1/K|κ(x)|, where κ is the bound-ary curvature. The resolution is
controlled by theparameter K which is the number of elements
perradian in 2-D (it is related to the maximum span-ning angle θ by
1/K = 2 sin(θ/2)).
2. Local Feature Size Adaptation Everywherein the domain, h(x) ≤
lfs(x)/R. The localfeature size lfs(x) is, loosely speaking, half
thewidth of the geometry at x. The parameter Rgives half the number
of elements across narrowregions of the geometry.
3. Non-geometric Adaptation An additional ex-ternal spacing
function hext(x) might be given byan adaptive numerical solver or
as a user-specifiedfunction (often at isolated points or
boundaries).We then require that h(x) ≤ hext(x).
4. Grading Limiting The grading requirementmeans that the size
of two neighboring elementsin a mesh should not differ by more than
a factorG, or hi ≤ Ghj for all neighboring elementsi, j. The
continuous analogue of this is that themagnitude of the gradient of
the size functionis limited by |∇h(x)| ≤ g, where g depends onthe
interpretation of the element sizes but isapproximately G− 1.
5. Optimality In addition to the above require-ments (which are
all upper bounds), we requirethat h(x) is as large as possible at
all points.
We now show how to create a size function h(x) ac-cording to
these requirements, starting from an im-plicit boundary definition
by its signed distance func-tion φ(x), with a negative sign inside
the geometry.
3. CURVATURE ADAPTATION
To resolve curved boundaries accurately, we want toimpose the
curvature adaptation h(x) ≤ hcurv(x) onthe boundaries, with�
hcurv(x) = 1/K|κ(x)|, if φ(x) = 0,
∞, if φ(x) 6= 0,(1)
where κ(x) is the curvature at x. In three dimensionswe use the
maximum principal curvature in order toresolve the smallest radius
of curvature.
For an unstructured background grid, where the ele-ments are
aligned with the boundaries, we simply as-sign values for h(x) on
the boundary nodes and setthe remaining nodal values to infinity.
Later on, thegradient limiting will propagate these values into
therest of the region. The boundary curvature might be
-
available as a closed form expression (e.g. by a
CADrepresentation), or it can be approximated from thesurface
triangulation.
For an implicit boundary discretization on a Cartesianbackground
grid we can compute the curvature fromthe distance function, for
example in 2-D:
κ = ∇ ·∇φ
|∇φ|=
φxxφ2y − 2φyφxφxy + φyyφ
2x
(φ2x + φ2y)3/2. (2)
In 3-D similar expressions give the mean curvature κHand the
Gaussian curvature κK , from which the princi-pal curvatures are
obtained as κ1,2 = κH±�κ2H − κK .On a Cartesian grid, we use
standard second-order dif-ference approximations for the
derivatives.
These difference approximations give us accurate cur-vatures at
the node points, and we could computemesh sizes directly according
to (1) on the nodes closeto the boundary, and set the remaining
interior andexterior nodes to infinity. However, since in
generalthe nodes are not located on the boundary, we geta poor
approximation of the true, continuous, curva-ture requirement (1).
Below we show how to modifythe calculations to include a correction
for node pointsnot aligned with the boundaries.
In two dimensions, suppose we calculate a curvatureκij at the
grid point xij . This point is generally notlocated on the
boundary, but a distance |φij | away.If we set hcurv(xij) =
1/(K|κij |) we introduce twosources of errors:
• We use the curvature at xij instead of at theboundary. We can
compensate for this by addingφij to the radius of curvature:
κbound =1
1
κij+ φij
=κij
1 + κijφij(3)
Note that we keep the signs on κ and φ. If, forexample, φ > 0
and κ > 0, we should increasethe radius of curvature. This
expression is ex-act for circles, including the limiting case of
zerocurvature (a straight line).
• Even if we use the corrected curvature κbound, weimpose our
hcurv at the grid point xij instead ofat the boundary. However, the
grid point will beaffected indirectly by the gradient limiting,
andwe can get a better estimate of the correct h byadding g|φij |.
Interpolation of the absolute func-tion is inaccurate, and again we
keep the sign ofφ and subtract gφij (that is, we add the
distanceinside the region and subtract it outside).
Putting this together, we get the following definition
of hcurv in terms of the grid spacing ∆x:
hcurv(xij) =
� ���1+κijφijKκij���− gφij , |φij | ≤ 2∆x,
∞, |φij | > 2∆x.(4)
This will limit the edge sizes in a narrow band aroundthe
boundaries, but it will not have any effect in theinterior of the
region. A similar expression can be usedin three dimensions, where
the curvature is replacedby maximum principal curvature as before,
and thecorrection makes the expression exact for spheres
andplanes.
4. FEATURE SIZE ADAPTATION
For feature size adaptation, we want to impose thecondition h(x)
≤ hlfs(x) everywhere inside our do-main, where�
hlfs(x) = lfs(x)/R, if φ(x) ≤ 0,
∞, if φ(x) > 0.(5)
The local feature size lfs(x) is a measure of the
distancebetween nearby boundaries. It is defined by Ruppert[5] as
“the larger distance from x to the closest twonon-adjacent
polytopes [of the boundary]”. For ourimplicit boundary definitions,
there is no clear notionof adjacent polytopes, and we use instead
the sim-ilar definition (inspired by the definition for
surfacemeshes in [15]) that the local feature size at a bound-ary
point x is equal to the smallest distance betweenx and the medial
axis. The medial axis is the set ofinterior points that have equal
distance to two or morepoints on the boundary.
For geometries with sharp corners that consist of sepa-rate
boundary sections, we exclude medial axis pointsthat have equal
distance to two neighboring bound-aries. The feature size should
not be larger than anedge or face connecting sharp corners. Our
medial axisbased method will in some cases not detect this sinceit
is a result of having sharp corners and not becauseof the actual
boundary. However, this effect on thefeature size is local and it
is easily incorporated by ex-plicit constraints on h(x) along the
edge or the face(possibly with a correction −gφ like in the
curvatureadaptation).
The definition of local feature size can be extendedto the
entire domain in many ways. We simply addthe distance function for
the domain boundary to thedistance functions for the medial axis,
to obtain ourdefinition:
lfsMA(x) = |φ(x)|+ |φMA(x)|, (6)
where φ(x) is the distance function for the domainand φMA(x) is
the distance to its medial axis (MA).
-
The distances φMA(x) are always positive, but we takeits
absolute value to emphasize that we always addpositive
distances.
The expression (6) obviously reduces to the definitionin [15] at
boundary points x, since then φ(x) = 0.For a narrow region with
parallel boundaries, lfs(x)is exactly half the width of the region,
and a value ofR = 1 would resolve the region with two elements.
To compute the local feature size according to (6), wehave to
compute the medial axis transform φMA(x) inaddition to the given
distance function φ(x). If weknow the location of the medial axis
we can use thetechniques described in Section 2.2, for example
ex-plicit distance calculations near the medial axis andthe fast
marching method for the remaining nodes.The identification of the
medial axis is often referredto as skeletonization, and a large
number of algorithmshave been proposed. Many of them, including the
orig-inal Grassfire algorithm by Blum [16], are based onexplicit
representations of the geometry. Kimmel etal [17] described an
algorithm for finding the medialaxis from a distance function in
two dimensions, bysegmenting the boundary curve with respect to
cur-vature extrema. Siddiqi et al [18] used a divergencebased
formulation combined with a thinning processto guarantee a correct
topology. Telea and Wijk [19]showed how to use the fast marching
method for skele-tonization and centerline extraction.
Although in principle we could use any existing al-gorithm for
skeletonization using distance functions,we have developed a new
method mainly because ourrequirements are different than those in
other appli-cations. Maintaining the correct topology is not ahigh
priority for us, since we do not use the skele-ton topology (and if
we did, we could combine ouralgorithm with thinning, as in [18]).
This means thatsmall “holes” in the skeleton will only cause a
minorperturbation of the local feature size. However, an in-correct
detection of the skeleton close to the boundaryis worse, since our
definition (6) would set the featuresize to a very small value
close to that point.
We also need a higher accuracy of the computed me-dial axis
location. Applications in image processingand computer graphics
often work on a pixel level, andhaving a higher level of detail is
referred to as subgridaccuracy. A final desired requirement is to
have a min-imum number of user parameters, since the
algorithmshould work in an automated way. Other algorithmstypically
use fixed parameters to eliminate incorrectskeleton points close to
curved regions. We use thecurvature to determine if candidate
points should beaccepted based on only one parameter specifying
thesmallest resolved curvature.
Our method uses a Cartesian grid, but should be easy
x
x
y
φ
p1
p2
Contours of φ(x, y) and shock
φ(x, j), p1(x), p2(x)
j
j + 1
i− 2
i− 2
i− 1
i− 1
i
i
i + 1
i + 1
i + 2
i + 2
i + 3
i + 3
φmin
Figure 2: Detection of shock in the distance functionφ(x, y)
along the edge (i, j), (i + 1, j). The location ofthe shock is
given by the crossing of the two parabolasp1(x) and p2(x).
to extend to other background meshes. For all edgesin the
computational grid, we fit polynomials to thedistance function at
each side of the edge, and de-tect if they cross somewhere along
the edge (Figure 2).Such a crossing becomes a candidate for a new
skeletonpoint and we apply several tests, more or less heuristic,to
determine if the point should be accepted.
The complete algorithm is shown in Table 1. We scalethe domain
to have unit spacing, and for each edge weconsider the interval s ∈
[−2, 3] where s ∈ [0, 1] corre-sponds to the edge. Next we fit
quadratic polynomialsp1 and p2 to the values of the distance
function atthe two sides of the edge, and compute their cross-ings.
Our tests to determine if a crossing should beconsidered a skeleton
point are summarized below:
• There should be exactly one root s0 along theedge s ∈ [0,
1].
• The derivative of p2 should be strictly greaterthan the
derivative of p1 in s ∈ [−2, 3] (it is suffi-cient to check the
endpoints, since the derivativesare linear)
-
Algorithm 1 - Skeletonization usingDistance Function
Description: Detect medial axisInput: Grid xijk, dist. func.
φijk, parameters γ,κtolOutput: Crossings pi and neighboring
distances φMA
Normalize xijk and φijk to have unit grid spacingApproximate
∇φijk with one-sided finite differencesApproximate max. principal
curvature κijk from φijkfor all consecutive six nodes
xi−2:i+3,j,k
Define φ1, . . . , φ6 = φi−2,j,k, . . . , φi+3,j,kFit parabolas
p1(s) and p2(s) to the data points
(s, φ) = (−2, φ1), (−1, φ2), (0, φ3), and
(s, φ) = (1, φ4), (2, φ5), (3, φ6)
Find real roots of ∆p(s) = p2(s)− p1(s)if one root s0 in [0, 1]
and d∆p/ds > 0 in [−2, 3]
Let κ1 = κi−1,j,k and κ2 = κi+2,j,kCompute dot product α between
fronts
α = ∇φi,j,k · ∇φi+1,j,k
if α < 1− γ2 max(κ21, κ22, κ
2tol)/2:
Accept p = xijk + e1hs0 as a MA pointCompute medial axis
normal:
n = (nx, ny, nz) =∇φi,j,k −∇φi+1,j,k‖∇φi,j,k −∇φi+1,j,k‖
Compute neighboring distances
φMA,1 = |nxhs|
φMA,2 = |nxh(1− s0)|
end if
end if
end for
In each interval keep only pi with largest d∆p/ds(s0)Repeat for
consecutive nodes in y- and z-direction
Table 1: The algorithm for detecting the medial axis ina
discretized distance function and computing the dis-tances to
neighboring nodes.
• The dot product α between the two propaga-tion directions
should be smaller than a tolerance,which depends on the curvatures
of the two fronts(see below).
• We reject the point if another crossing is detectedwithin the
interval [−2, 3] with a larger derivativedifference dp2/ds− dp1/ds
at the crossing s0.
The dot product α is evaluated from one-sided differ-ence
approximations of ∇φ. This is compared to theexpected dot product
between two front from a cir-
Figure 3: Examples of medial axis calculations for someplanar
geometries.
cle of radius 1/|κ|, where κ is the largest curvatureat the two
points. With one unit separation betweenthe points and an angle θ
between the fronts, this dotproduct is
cos θ = 1− 2 sin2(θ/2) = 1− 2(|κ|/2)2 = 1− κ2/2(7)
We reject the point if the actual dot product α is largerthan
this for any of the curvatures κ1, κ2 at the twosides of the edge
or the given tolerance κtol. We cal-culate κ using difference
approximations, and to avoidthe shock we evaluate it one grid point
away from theedge. To compensate for this we include a tolerance
γin the computed curvatures.
If the point is accepted as a medial axis point, weobtain the
normal of the medial axis by subtractingthe two gradients. The
distance from the medial axisto the two neighboring points are then
|nxhs0| and|nxh(1− s0)|. These are used as boundary conditionswhen
solving for φMA(x) in the entire domain usingthe fast marching
method.
Some examples of medial axis detections are shown inFigure 3.
Note how the three parabolas (top right)are handled correctly with
the curvature dependenttolerances.
-
5. GRADIENT LIMITING
An important requirement on the size function is thatthe ratio
of neighboring element sizes in the generatedmesh is less than a
given value G. This corresponds toa limit on the gradient |∇h(x)| ≤
g where g ≈ G− 1.Note that we need a linear increase in the size
func-tion to obtain a geometric progression of the elementsizes. To
see this, consider a a simple one-dimensionalproblem with mesh size
specified at a boundary pointh(x0) = h0. Generate a mesh in an
advancing front-like manner by the algorithm xi+1 = xi +h(xi).
Witha linear size function of the form h(x) = h0 +g(x−x0)we get a
constant ratio between neighboring elements:
h(xi+1)
h(xi)=
h(xi + h(xi))
h(xi)=
h0 + g(xi + h(xi)− x0)
h(xi)
=h(xi) + gh(xi)
h(xi)= 1 + g.
In some simple cases, this linear increase can be builtinto the
size function explicitly. For example, a “point-source” size
constraint h(y) = h0 in a convex domaincan be extended as h(x) = h0
+ g|x − y|, and simi-larly for other shapes such as edges. For more
complexboundary curves, local feature sizes, user constraints,etc,
such an explicit formulation is difficult to createand expensive to
evaluate. It is also harder to extendthis method to non-convex
domains (such as the ex-ample in Figure 6), or to non-constant g
(Figures 14and 15).
One way to limit the gradients of a discretized sizefunction is
to iterate over the edges of the backgroundmesh and update the size
function locally for neigh-boring nodes [20]. When the iterations
converge, thesolution satisfies |∇h(x)| ≤ g only approximately, in
away that depends on the mesh. Another method is tobuild a balanced
octree, and let the size function berelated to the size of the
octree cells [21]. This datastructure is used in the quadtree
meshing algorithm[22], and the balancing guarantees a limited
variationin element sizes, by a maximum factor of two
betweenneighboring cells. However, when used as a size func-tion
for other meshing algorithms it provides an ap-proximate discrete
solution to the original problem,and it is hard to generalize the
method to arbitrarygradients g or different background meshes.
We present a new technique to handle the gradientlimiting
problem, by a continuous formulation of theprocess as a
Hamilton-Jacobi equation. Since the meshsize function is defined as
a continuous function of x,it is natural to formulate the gradient
limiting as aPDE with solution h(x) independently of the
actualbackground mesh. We can see many benefits in doingthis:
• The analytical solution is exactly the optimal gra-
dient limited size function h(x) that we want,as shown by
Theorem 5.1. The only errorscome from the numerical discretization,
whichcan be controlled and reduced using known so-lution techniques
for hyperbolic PDEs.
• By relying on existing well-developed Hamilton-Jacobi solvers
we can generalize the algorithm ina straightforward way to
– Cartesian grids, octree grids, or fully un-structured
meshes
– Higher order discretizations
– Space and solution dependent g
– Regions embedded in higher-dimensionalspaces, for example
surface meshes in 3-D.
• We can compute the solution in O(n log n) timeusing a modified
fast marching method.
5.1 The Gradient Limiting Equation
We now consider how to limit the magnitude of thegradients of a
function h0(x), to obtain a new gradi-ent limited function h(x)
satisfying |∇h(x)| ≤ g every-where. We require that h(x) ≤ h0(x),
and at everyx we want h to be as large as possible. We claimthat
h(x) is the steady-state solution to the followingGradient Limiting
Equation:
∂h
∂t+ |∇h| = min(|∇h|, g), (8)
with initial condition
h(x, t = 0) = h0(x). (9)
When |∇h| ≤ g, (8) gives that ∂h/∂t = 0, and h willnot change
with time. When |∇h| > g, the equationwill enforce |∇h| = g
(locally), and the positive signmultiplying |∇h| ensures that
information propagatesin the direction of increasing values. At
steady-statewe have that |∇h| = min(|∇h|, g), which is the sameas
|∇h| ≤ g.
For the special case of a convex domain in Rn and con-stant g,
we can derive an analytical expression for thesolution to (8),
showing that it is indeed the optimalsolution:
Theorem 5.1. Let Ω ⊂ Rn be a bounded convexdomain, and I = (0, T
) a given time interval. Thesteady-state solution h(x) = limT→∞
h(x, T ) to�
∂h∂t
+ |∇h| = min(|∇h|, g) (x, t) ∈ Ω× I
h(x, t)|t=0 = h0(x) x ∈ Ω(10)
is
h(x) = miny
(h0(y) + g|x− y|). (11)
-
Proof. The Hopf-Lax theorem [23] states that the so-lution to
the Hamilton-Jacobi equation du
dt+F (∇u) =
0 with initial condition u(x, 0) = u0(x) and convexF (w) is
given by
u(x, t) = miny
[u0(y) + tF∗ ((x− y)/t)] , (12)
where F ∗(u) = maxw(wu − F (w)) is the conjugatefunction of F
.
For our equation (10), rewrite as ∂h∂t
+F (∇h) = 0, withF (w) = |w| −min(|w|, g). The conjugate
function is
F ∗(u) = maxw
(wu− F (w))
= maxw
(wu− |w|+ min(|w|, g))
=
�g|u|, if |u| < 1,
+∞ if |u| ≥ 1.(13)
Using (12), we get
h(x, t) = miny
[h0(y) + tF∗ ((x− y)/t)]
= miny
|x−y|≤t
(h0(y) + g|x− y|). (14)
Let t→∞ to get the steady-state solution to (10):
h(x) = miny
(h0(y) + g|x− y|). (15)
Note that the solution (11) is composed of infinitelymany
point-source solutions as described before. Wecould in principle
define an algorithm based on (11)for computing h from a given h0
(both discretized).Such an algorithm would be trivial to implement,
butits computational complexity would be proportionalto the square
of the number of node points. Instead,we solve (10) using efficient
Hamilton-Jacobi solvers.
The gradient limiting is illustrated by a one dimen-sional
example in Figure 4, where (10) is solved usingdifferent values of
g and a simple scalar function asinitial condition. Note how the
large gradients are re-duced exactly the amount needed, without
affectingregions far away from them. This is very differentfrom
traditional smoothing, which affects all data andgives excessive
perturbation of the original functionh0(x). Our solution is not
necessarily smooth, but itis continuous and |∇h| ≤ g
everywhere.
5.2 Implementation
One advantage with the continuous formulation of theproblem is
that a large variety of solvers can be usedalmost as black-boxes.
This includes solvers for struc-tured and unstructured grids,
higher-order methods,and specialized fast solvers.
Max Gradient g = 4 Max Gradient g = 2
Max Gradient g = 1 Max Gradient g = 0.5
Figure 4: Illustration of gradient limiting by ∂h/∂t +|∇h| =
min(|∇h|, g). The dashed lines are the initialconditions h0 and the
solid lines are the gradient limitedsteady-state solutions h for
different parameter values g.
On a Cartesian background grid, the equation (8) canbe solved
with just a few lines of code using the fol-lowing iteration:
hn+1ijk = hnijk + ∆t �min(∇+ijk, g)−∇+ijk� (16)
where
∇+ijk = �max(D−xhnijk, 0)2 + min(D+xhnijk, 0)2+max(D−yhnijk,
0)
2 + min(D+yhnijk, 0)2+
max(D−zhnijk, 0)2 + min(D+zhnijk, 0)
2�1/2(17)
Here, D−x is the backward difference operator in thex-direction,
D+x the forward difference operator, etc.The iterations are
initialized by h0 = h0, and we iter-ate until the updates ∆h(x) are
smaller than a giventolerance. The ∆t parameter is chosen to
satisfy theCFL-condition, we use ∆t = ∆x/2. The boundariesof the
grid do not need any special treatment since allcharacteristics
point outward.
The iteration (16) converges relatively fast, althoughthe number
of iterations grows with the problem sizeso the total computational
complexity is superlinear.Nevertheless, the simplicity makes this a
good choicein many situations. If a good initial guess is
avail-able, this time-stepping technique might even be su-perior to
other methods. This is the case for prob-lems with moving
boundaries, where the size functionfrom the last mesh is likely to
be close to the new sizefunction, or in numerical adaptivity, when
the originalsize function already has relatively small gradients
be-cause of numerical properties of the underlying PDE.
-
The scheme (16) is first-order accurate in space, andhigher
accuracy can be achieved by using a second-order solver. See [10]
and [24] for details.
For faster solution of (8) we use a modified versionof the fast
marching method (see Section 2.2). Themain idea for solving our PDE
(8) is based on thefact that the characteristics point in the
direction ofthe gradient, and therefore smaller values are
neveraffected by larger values. This means we can start byfixing
the smallest value of the solution, since it willnever be modified.
We then update the neighbors ofthis node by a discretization of our
PDE, and repeatthe procedure. To find the smallest value
efficientlywe use a min-heap data structure.
During the update, we have to solve for a new hijkin ∇+ijk = g,
with ∇
+
ijk from (17). This expression issimplified by the fact that
hijk should be larger thanall previously fixed values of h, and we
can solve aquadratic equation for each octant and set hijk to
theminimum of these solutions.
Our fast algorithm is summarized as pseudo-code inTable 2.
Compared to the original fast marchingmethod, we begin by marking
all nodes as TRIALpoints, and we do not have any FAR points. The
ac-tual update involves a nonlinear right-hand side, butit always
returns increasing values so the update pro-cedure is valid. The
heap is large since all elementsare inserted initially, but the
access time is still onlyO(log n) for each of the n nodes in the
backgroundgrid. In total, this gives a solver with
computationalcomplexity O(n log n). For higher-order accuracy,
thetechnique described in [11] can be applied.
An unstructured background grid gives a more
efficientrepresentation of the size function and higher
flexibil-ity in terms of node placement. A common choice isto use
an initial Delaunay mesh, possibly with a fewadditional
refinements. Several methods have beendeveloped to solve
Hamilton-Jacobi equations on un-structured grids, and we have
implemented the posi-tive coefficient scheme by Barth and Sethian
[25]. Thesolver is slightly more complicated than the
Cartesianvariants, but the numerical schemes can essentially beused
as black-boxes. A triangulated version of the fastmarching method
was given in [26], and in [27] the al-gorithm was generalized to
arbitrary node locations.
One particular unstructured background grid is theoctree
representation, and the Cartesian methods ex-tend naturally to this
case (both the iteration and thefast solver). The values are
interpolated on the bound-aries between cells of different sizes.
We mentioned inthe introduction that octrees are commonly used
torepresent size functions, because of the possibility tobalance
the tree and thereby get a limited variationof cell sizes. Here, we
propose to use the octree as
Algorithm 2 -Fast Gradient Limiting
Description: Solve (8) on a Cartesian gridInput: Initial
discretized h0, grid spacing ∆xOutput: Discretized solution h
Set h = h0Insert all hijk in a min-heap with back pointerswhile
heap not empty
Remove smallest element IJK from heapfor neighbors ijk of IJK
still in heap:
compute upwind |∇hijk|if |∇hijk| > g
Solve for hnewijk in ∇+
ijk = g from (17)Set hijk ← min(hijk, h
newijk )
end if
end for
end while
Table 2: The fast gradient limiting algorithm for Carte-sian
grids. The computational complexity is O(n log n),where n is the
number of nodes in the background grid.
a convenient and efficient representation, but the ac-tual
values of the size function are computed usingour PDE. This gives
higher flexibility, for example thepossibility to use different
values of g.
6. RESULTS
We are now ready to put all the pieces together anddefine the
complete algorithm for generation of a meshsize function. The size
functions from curvature andfeature size are computed as described
in the previoussections. The external size function hext(x) is
providedas input. Our final size function must be smaller thanthese
at each point in space:
h0(x) = min(hcurv(x), hlfs(x), hext(x)) (18)
Finally, we apply the gradient limiting algorithm fromSection 5
on h0 to get the mesh size function h, bysolving:
∂h
∂t+ |∇h| = min(|∇h|, g) (19)
with initial condition h(x, t = 0) = h0(x).
We now show a number of examples, with differentgeometries,
background grids, and feature size defini-tions. All triangular and
tetrahedral meshes are gen-erated with the smoothing-based mesh
generator fordistance functions in [3], [4]. For some of the
2-Dexamples we have also generated meshes using an ad-vancing front
generator with similar results.
-
Figure 5: Example of gradient limiting with an unstruc-tured
background grid. The size function is given at thecurved boundaries
and computed by (8) at the remainingnodes.
6.1 Mesh Size Functions in 2-D and 3-D
We begin with a simple example of gradient limiting intwo
dimensions on a triangular mesh. For the geome-try in Figure 5, we
set h0(x) proportional to the radiusof curvature on the boundaries,
and to ∞ in the in-terior. We solve our gradient limiting equation
usingthe positive coefficient scheme to get the mesh sizefunction
in the middle plot. A sample mesh using thisresult is shown in the
right plot.
This example shows that we can apply size constraintsin an
arbitrary manner, for example only on some ofthe boundary nodes.
The PDE will propagate the val-ues in an optimal way to the
remaining nodes, andpossibly also change the given values if they
violatethe grading condition. For this very simple geometry,we can
indeed write the size function explicitly as
h(x) = mini
(hi + gφi(x)). (20)
Here, φi and hi are the distance functions and theboundary mesh
size for each of the three curvedboundaries. But consider, for
example, a curvedboundary with a non-constant curvature. The
analyt-ical expression for the size function of this boundaryis
non-trivial (it involves the curvature and distancefunction of the
curve). One solution would be to putpoint-sources at each node of
the background mesh,but the complexity of evaluating (20) grows
quicklywith the number of nodes. By solving our gradientlimiting
equation, we arrive at the same solution in anefficient and simple
way.
Mesh Size Function h(x)
Mesh Based on h(x)
Figure 6: Another example of gradient limiting, showingthat
non-convex regions are handled correctly. The smallsizes at the
curved boundary do not affect the regionat the right, since there
are no connections across thenarrow slit.
In Figure 6 we show a size function for a geometrywith a narrow
slit, again generated using the unstruc-tured gradient limiting
solver. The initial size functionh0(x) is based on the local
feature size and the curvedboundary at the top. Note that although
the regionson the two sides of the slit are close to each other,the
small mesh size at the curved boundary does notinfluence the other
region. This solution is harder toexpress using source expressions
such as (20), wheremore expensive geometric search routines would
haveto be used.
A more complicated example is shown in Figure 7.Here, we have
computed the local feature size every-where in the interior of the
geometry. We computethis using the medial axis based definition
from Sec-tion 4. The result is stored on a Cartesian grid. Insome
regions the gradient of the local feature size isgreater than g,
and we use the fast gradient limitingsolver in Algorithm 2 to get a
well-behaved size func-tion. We also use curvature adaptation as
before. Notethat this mesh size function would be very
expensive
-
Medial Axis and Feature Size
Mesh Size Function h(x)
Mesh Based on h(x)
Figure 7: A mesh size function taking into account bothfeature
size, curvature, and gradient limiting. The fea-ture size is
computed as the sum of the distance functionand the distance to the
medial axis.
to compute explicitly, since the feature size is
definedeverywhere in the domain, not just on the boundaries.
As a final example of 2-D mesh generation, we showan object with
smooth boundaries in Figure 8. We usea Cartesian grid for the
background grid and solve thegradient limiting equation using the
fast solver. Thefeature size is again computed using the medial
axisand the distance function, and the curvature is givenby the
expression with grid correction (4) since thegrid is not aligned
with the boundaries.
The PDE-based formulation generalizes to arbitrarydimensions,
and in Figure 9 we show a 3-D example.
Medial Axis and Feature Size
Mesh Size Function h(x)
Mesh Based on h(x)
Figure 8: Generation of a mesh size function for a geom-etry
with smooth boundaries.
Here, the feature size is computed explicitly from thegeometry
description, the curvature adaptation is ap-plied on the boundary
nodes, and the size function iscomputed by gradient limiting with g
= 0.2. This re-sults in a well-shaped tetrahedral mesh, in the
bottomplot.
-
Mesh Size Function h(x)
Mesh Based on h(x)
Figure 9: Cross-sections of a 3-D mesh size function anda sample
tetrahedral mesh.
A more complex model is shown in Figure 10.1 Weapply gradient
limiting with g = 0.3 on a size func-tion which is computed
automatically, taking into ac-count curvature adaptation and
feature size adapta-tion (from the medial axis, as described
before). Theplots show the final mesh size function and an
examplemesh.
1This model was obtained from the The Stanford 3DScanning
Repository.
Mesh Size Function h(x)
Mesh Based on h(x)
Split view
Figure 10: A 3-D mesh size function and a sample tetra-hedral
mesh. Note the small elements in the narrow re-gions, given by the
local feature size, and the smoothincrease in element sizes.
-
# Nodes Edge Iter. H-J Iter. H-J Fast
10,000 0.009s 0.060s 0.006s40,000 0.068s 0.470s 0.030s
160,000 0.844s 3.625s 0.181s640,000 6.609s 28.422s 1.453s
Table 3: Performance of the edge-based iterative solver,the
Hamilton-Jacobi iterative solver, and the Hamilton-Jacobi fast
gradient limiting solver.
6.2 Performance and Accuracy
To study the performance and the accuracy of ouralgorithms, we
consider a simple model problem inΩ = (−50, 50) × (−50, 50) with
two point-sources,h(−10, 0) = 1 and h(10, 0) = 5, and g = 0.3.
Thetrue solution is given by (11), and we solve the prob-lem on a
Cartesian grid of varying resolution.
In Table 3 we compare the execution times for threedifferent
solvers – edge-based iterations, Hamilton-Jacobi iterations, and
the Hamilton-Jacobi fast gra-dient limiting solver. The edge-based
iterative solverloops until convergence over all neighboring
nodesi, j and updates the size function locally by hj ←min(hj , hi
+ g|xj − xi|) (assuming hj > hi). Theiterative Hamilton-Jacobi
solver is based on the iter-ation (16) with a tolerance of about
two digits. Allalgorithms are implemented in C++ using the
sameoptimizations, and the tests were done on a PC withan Athlon XP
2800+ processor.
The table shows that the iterative Hamilton-Jacobisolver is
about five times slower than the simple edge-based iterations. This
is because the update for-mula for the edge-based iterations is
simpler (all edgelengths are the same) and since the
Hamilton-Jacobisolver requires more iterations for high accuracy
(al-though their asymptotic behavior should be the same).The fast
solver is better than the iterative solvers, andthe difference gets
bigger with increasing problem size(since it is asymptotically
faster). Note that thesebackground meshes are relatively large and
that allsolvers probably are sufficiently fast in many
practicalsituations.
We also mention that simple algorithms based on theexplicit
expression (11) for convex domains or geomet-ric searches for
non-convex domains might be fasterfor a small number of
point-sources. However, thesemethods are not practical for larger
problems becauseof the O(n2) complexity.
Next we compare the accuracy of the edge-based solverand
Hamilton-Jacobi discretizations of first and secondorder accuracy.
The true solution is given by (11), andan algorithm based on this
expression would of coursebe exact to full precision. Figure 11
shows solutions
True Solution Edge-Based
H-J, First Order H-J, Second Order
Figure 11: Comparison of the accuracy of the discreteedge-based
solver and the continuous Hamilton-Jacobisolver on a Cartesian
background mesh. The edge-basedsolver does not capture the
continuous nature of thepropagating fronts.
for a 100 × 100 grid, and it is clear that the edge-based solver
is highly inaccurate since it does not takeinto account the
continuous nature of the problem. Ithas a maximum error of 7.79,
compared to 0.38 and0.10 for the Hamilton-Jacobi solvers. This is
similar tothe error in solving the Eikonal equation using
Dijk-stra’s shortest path algorithm instead of the contin-uous fast
marching method [11]. The error with theedge-based solver might be
even larger for unstruc-tured background meshes which often have
low ele-ment qualities.
7. OTHER APPLICATIONS
In this section we show some special applications ofmesh size
functions and the gradient limiting equation– numerical adaptation,
mesh generation for images,and non-constant g values.
7.1 Numerical Adaptation
Numerical adaptation is a technique for solving PDEsusing mesh
size functions that are automatically gener-ated to reduce the
discretization error. From an errorestimator in each element, a new
mesh size functionis computed. The mesh can then be updated,
eitherby local refinements or remeshing. The procedure isrepeated
until the desired accuracy is achieved.
-
One problem when regenerating the mesh is that thesize function
h(x) from the adaptive solver might behighly irregular. The error
estimation often varies be-tween neighboring elements, giving high
gradients alsoin the size function. A simple solution is to smooth
thesize function, e.g. using Laplacian smoothing. How-ever, this
introduces large deviations from the originalsize function, even
where the gradient is small. A bet-ter method is to use gradient
limiting and solve (8) onthe same unstructured mesh that the size
function isdefined on, see [28] for further details.
Figure 12 shows an example of adaptive meshing fora compressible
flow simulation over a bump at Mach0.95. We solve the Euler
equations with a finite vol-ume solver, and use a simple adaptive
scheme basedon second-derivatives of the density to determine
newsize functions [1]. These resolve the shock accuratelybut the
sizes increase sharply away from the shock,giving low-quality
triangles (top figure). After gra-dient limiting the mesh size
function is well-behavedand a high-quality mesh can be generated
(bottom fig-ure). We have also generated meshes for this
problemusing the advancing front method. With the originalsize
function we were unable to create a mesh becauseof the large
gradients, but after gradient limiting weobtained a well-shaped
mesh.
7.2 Meshing Images
Images are special cases of implicit geometry defini-tions,
since the boundaries of objects in the image arenot available in an
explicit form. These object bound-aries can be detected by edge
detection methods [29],but these typically work on a pixel level
and do notproduce smooth boundaries. A more natural approachis to
keep the image-based representation, and forman implicit function
with a level set representing theboundary.
Before doing this, we have to identify the objects thatshould be
part of the domain, in other words to seg-ment the image. Many
methods have been developedfor this, and we use the standard tools
available in im-age manipulation programs. This will result in a
new,binary image, which represents our domain. We alsomention that
image segmentation based on the levelset method, for example Chan
and Vese’s active con-tours without edges [30], might be a good
alternative,since they produce distance functions directly from
thesegmentation.
Given a binary image A with values 0 for pixels out-side the
domain and 1 for those inside, we smooththe image with a low-pass
filter and create the signeddistance function for the domain using
approximateprojections and the fast marching method (see [4]
formore details).
Without Gradient Limiting
With Gradient Limiting
Figure 12: Numerical adaptation for compressible flowover a bump
at Mach 0.95. The second-derivative basederror estimator resolves
the shock accurately, but gradi-ent limiting is required to
generate a new mesh of highquality.
Figure 13 shows an example with a picture of a fewobjects taken
with a standard digital camera. Weisolate the objects using the
segmentation feature ofan image manipulation program, and create a
binarymask. Next we create the distance function as de-scribed
above, and a good mesh size function based oncurvature, feature
size from the medial axis (shown inFigure 3), and gradient
limiting. For the skeletoniza-tion we increase κtol to compensate
for the slightlynoisy distance function close to the boundary.
All techniques used for meshing the two dimensionalimages extend
directly to higher dimensions. The im-age is then a
three-dimensional array of pixels, andthe binary mask selects a
subvolume. Examples of thisare the sampled density values produced
by computedtomography (CT) scans in medical imaging, which
wecreated mesh size functions and tetrahedral meshes forin [4].
7.3 Space and Solution Dependent g
The solution of the gradient limiting equation
remainswell-defined if we make g(x) a function of space.
Thenumerical schemes in Section 5.2 are still valid, and wereplace
for example g in (16) with gijk. An application
-
Original Image
Size Function
Triangular Mesh
Figure 13: Meshing objects in an image. The segmen-tation is
done with an image manipulation program, thedistance function is
computed by smoothing and approx-imate projections, and the size
function uses the curva-ture, the feature size, and gradient
limiting.
Maximum Gradient g(x)
g = 0.4 g = 0.2
Mesh Size Function h(x)
Mesh Based on h(x)
Figure 14: Gradient limiting with space-dependent g(x).
of this is when some regions of the geometry requirehigher
element qualities, and therefore also a smallermaximum gradient in
the size function.
Figure 14 shows a simple example. The initial meshsize h0 is
based on curvatures and feature sizes. Theleft and the right parts
of the region have differentvalues of g, and the gradient limiting
generates a newsize function h satisfying |∇h| ≤ g(x)
everywhere.
Another possible extension is to let g be a function ofthe
solution h(x) (although it is then not clear if thegradient
limiting equation has one unique solution).This can be used, for
example, to get a fast increasefor small element sizes but smaller
variations for largeelements. In a numerical solver this might be
com-pensated by the smaller truncation error for the smallelements.
A simple example is shown in Figure 15,where g(h) varies smoothly
between 0.6 (for small el-ements) and 0.2 (for large elements).
-
Maximum Gradient g(h)
0 0.1 0.2 0.3 0.4 0.50.2
0.3
0.4
0.5
0.6g(h
)
h
Mesh Size Function h(x)
Mesh Based on h(x)
Figure 15: Gradient limiting with solution-dependentg(h). The
distances between the level sets of h(x) aresmaller for small h,
giving a faster increase in mesh size.
In the iterative solver, we replace g with g(hijk), and ifthe
iterations converge we have obtained a solution. Inthe fast solver,
we solve a (scalar) non-linear equation∇+ijk = g(hijk) at every
update.
8. CONCLUSIONS
We have presented new techniques for automatic gen-eration of
mesh size functions. The distance functionis used to compute the
medial axis transform, fromwhich the local feature size is derived.
We introduceda new, continuous formulation of the gradient
limitingprocedure, which is an important part in the genera-tion of
good mesh size functions. We showed severalexamples of high-quality
meshes generated with ourmesh size functions, and we gave an
example of gradi-ent limiting for an adaptive finite element solver
andmesh generation for regions in images.
We give several suggestions for future development:
• Other feature size algorithms. We have exper-imented with a
PDE-based algorithm that con-vect the distance function along its
characteris-tics, and a simpler direct algorithm that finds
thelargest spheres without first extracting the medialaxis.
• Other background meshes for the feature size.We have worked
exclusively with Cartesian andoctree grids for the medial axis
based featuresize calculations, and a version for
unstructuredmeshes would be useful.
• Implementing a fast marching based solver
fortriangular/tetrahedral background meshes. Themethods described
in [26] and [27] should be ap-plicable in a straightforward
way.
• Extending the gradient limiting to anisotropicmesh size
functions. There might be a PDE simi-lar to the gradient limiting
equation (or a systemof PDEs) based on general metrics [20].
• Adaptive generation of background meshes. Zhuet al [8]
discussed an intuitive, iterative approachfor refinement of
background meshes. With ourPDE-based formulation, we can achieve
this in astrict and systematic way by applying error esti-mators
for numerical adaptive solvers [31] on thediscretized solution
h(x).
References
[1] Peraire J., Vahdati M., Morgan K., ZienkiewiczO.C. “Adaptive
Remeshing for CompressibleFlow Computations.” J. Comput. Phys.,
vol. 72,no. 2, 449–466, 1987
[2] Blacker T.D., Stephenson M.B. “Paving: ANew Approach to
Automated Quadrilateral MeshGeneration.” Internat. J. Numer.
Methods En-grg., vol. 32, 811–847, 1991
[3] Persson P.O., Strang G. “A Simple Mesh Gener-ator in
MATLAB.” SIAM Review, vol. 46, no. 2,329–345, June 2004
[4] Persson P.O. Mesh Generation for ImplicitGeometries. Ph.D.
thesis, Massachusetts Insti-tute of Technology, 2005
[5] Ruppert J. “A Delaunay refinement algorithmfor quality
2-dimensional mesh generation.” J.Algorithms, vol. 18, no. 3,
548–585, 1995
[6] Shewchuk J.R. “Delaunay refinement algorithmsfor triangular
mesh generation.” Comput. Geom.,vol. 22, no. 1-3, 21–74, 2002
-
[7] Owen S.J., Saigal S. “Surface mesh sizingcontrol.” Internat.
J. Numer. Methods Engrg.,vol. 47, no. 1-3, 497–511, 2000
[8] Zhu J., Blacker T., Smith R. “Background Over-lay Grid Size
Functions.” Proceedings of the11th International Meshing
Roundtable, pp. 65–74. Sandia Nat. Lab., September 2002
[9] Zhu J. “A New Type of Size Function Respect-ing Premeshed
Entities.” Proceedings of the 11thInternational Meshing Roundtable,
pp. 403–413.Sandia Nat. Lab., September 2003
[10] Osher S., Sethian J.A. “Fronts propagating
withcurvature-dependent speed: algorithms basedon Hamilton-Jacobi
formulations.” J. Comput.Phys., vol. 79, no. 1, 12–49, 1988
[11] Sethian J.A. “A fast marching level set methodfor
monotonically advancing fronts.” Proc. Nat.Acad. Sci. U.S.A., vol.
93, no. 4, 1591–1595, 1996
[12] Tsitsiklis J.N. “Efficient algorithms for glob-ally optimal
trajectories.” IEEE Trans. Automat.Control, vol. 40, no. 9,
1528–1538, 1995
[13] Mauch S.P. Efficient Algorithms for Solving Sta-tic
Hamilton-Jacobi Equations. Ph.D. thesis, Cal-tech, 2003
[14] Sussman M., Smereka P., Osher S. “A level setapproach for
computing solutions to incompress-ible two-phase flow.” J. Comput.
Phys., vol. 114,no. 1, 146–159, 1994
[15] Amenta N., Bern M. “Surface reconstruction byVoronoi
filtering.” SCG ’98: Proceedings of thefourteenth annual symposium
on Computationalgeometry, pp. 39–48. ACM Press, 1998
[16] Blum H. “Biological Shape and Visual Science(Part I).”
Journal of Theoretical Biology, vol. 38,205–287, 1973
[17] Kimmel R., Shaked D., Kiryati N., BrucksteinA.M.
“Skeletonization via Distance Maps andLevel Sets.” Computer Vision
and Image Under-standing: CVIU, vol. 62, no. 3, 382–391, 1995
[18] Siddiqi K., Bouix S., Tannenbaum A., ZuckerS. “The
Hamilton-Jacobi Skeleton.” Interna-tional Conference on Computer
Vision (ICCV),pp. 828–834. 1999
[19] Rumpf M., Telea A. “A continuous skeletoniza-tion method
based on level sets.” Proceedings ofthe symposium on Data
Visualisation 2002, pp.151–ff. Eurographics Association, 2002
[20] Borouchaki H., Hecht F., Frey P.J. “Mesh Gra-dation
Control.” Proceedings of the 6th Interna-tional Meshing Roundtable,
pp. 131–141. SandiaNat. Lab., October 1997
[21] Frey P.J., Marechal L. “Fast Adaptive QuadtreeMesh
Generation.” Proceedings of the 7th Inter-national Meshing
Roundtable, pp. 211–224. San-dia Nat. Lab., October 1998
[22] Yerry M.A., Shephard M.S. “A ModifiedQuadtree Approach to
Finite Element Mesh Gen-eration.” IEEE Comp. Graph. Appl., vol. 3,
no. 1,39–46, 1983
[23] Hopf E. “Generalized solutions of non-linearequations of
first order.” J. Math. Mech., vol. 14,951–973, 1965
[24] Harten A., Engquist B., Osher S., ChakravarthyS.R.
“Uniformly High Order Accurate EssentiallyNon-Oscillatory Schemes.”
J. Comput. Phys.,vol. 71, no. 2, 231–303, 1987
[25] Barth T.J., Sethian J.A. “Numerical schemes forthe
Hamilton-Jacobi and level set equations ontriangulated domains.” J.
Comput. Phys., vol.145, no. 1, 1–40, 1998
[26] Kimmel R., Sethian J.A. “Fast Marching Meth-ods on
Triangulated Domains.” Proceedings ofthe National Academy of
Sciences, vol. 95, pp.8341–8435. 1998
[27] Covello P., Rodrigue G. “A generalized frontmarching
algorithm for the solution of the eikonalequation.” J. Comput.
Appl. Math., vol. 156,no. 2, 371–388, 2003
[28] Persson P.O. “Size Functions and Mesh Gen-eration for
High-Quality Adaptive Remeshing.”Proc. of the Third MIT Conference
on Compu-tational Fluid and Solid Mechanics. Cambridge,MA, 2005
[29] Gonzalez R.C., Woods R.E. Digital ImageProcessing. Prentice
Hall, 2 edn., 2002
[30] Chan T., Vese L. “Active contours withoutedges.” IEEE
Trans. Image Processing, vol. 10,no. 2, 266–277, 2001
[31] Eriksson K., Estep D., Hansbo P., Johnson C.Computational
differential equations. CambridgeUniversity Press, Cambridge,
1996
