New results on
mesh refinement
Benoît Hudson, CMU
Joint work with
Gary Miller and Todd Phillips
Papers available at
http://www.cs.cmu.edu/~bhudson
CAD model
Will it work?
Equations
Navier-Stokes:
Heat transfer:
Run simulations!
Mesh
Partial Diff. Eqs.
Weak form
CAD model
Solve
Visualize
Input
Points
Segments
Polygons
Input
Points
Segments
Polygons
‘P’ courtesy of Shewchuk
Output
‘P’ courtesy of Shewchuk
Simpler Input
Two possible meshes
Which is better?
Example:
f(x,y) = 1-x2
This is a bad mesh
f(x,y) = 1-x2
0
At mesh vertices:
0
• read the value
At other points p:
• Find t that contains p 0
• Weighted average of
points of t
0
1
1
1
0
0
0
0
This is a better mesh
Still bad at boundary
0
f(x,y) = 1-x2
At mesh vertices:
0
• read the value
At other points p:
• Find t that contains p 0
• Weighted average of
points of t
0
1
1
1
0
0
0
0
Good aspect ratio  good
interpolation
R
Good aspect ratio if:
r
Equivalent: all angles  a
Aspect ratio
Bad aspect ratio if:
R
r
Equivalent: some angle < a
This is a better mesh
Still bad at boundary
0
This mesh is Delaunay:
best possible
0
for those points
0
0
1
1
1
0
0
0
0
This is a good mesh
Add Steiner points
This is a good mesh
Formal problem
• Input:
– Piecewise Linear Complex (PLC)
• points, segments, polygons, …
– quality bound: angle  a
• Output:
– quality triangulation (angle  a)
– all features appear (perhaps subdivided)
– O(mopt) vertices
Good aspect ratio
 bounded degree
Big features
Big triangles
Grading
Good aspect ratio
 good grading
Small feature
Small triangles
Grade linearly
away from small
feature
Outline
• Two older methods
– quadtree refinement
– Delaunay refinement
• Our algorithm: SVR as a hybrid
• Parallel SVR
Dynamic meshing: too much for this
talk. See me afterwards.
Older Solutions
• 1950-now: construct mesh by hand!
– Takes days to months.
• Automatic methods: ca. 1980-now
– no quality, size, or time bounds
• BEG90: quality and size in O(n lg n + m)
(buggy proof, fixed in BET93)
• Rup92: smaller in practice, no time bound.
Simpler input
Just points for now
Quadtree refinement
[BEG90, MV92, BET93]

Quadtree rules
Crowded
• two points
in cell, or
• one point in
cell, one in
neighbour
Unbalanced
• Neighbor is small
Quadtree
Quadtree
Quadtree
Quadtree in a word
• Quality mesh (17)
• O(mopt) output size
• O(n lg n + m) runtime
(think: binary search tree)
• General approach: top-down
Delaunay Refinement
[Rup92, She97]
Add a bounding box
Triangulate (use Delaunay)
Identify skinny triangle
Find circumcenter
Insert, retriangulate
Find more skinny triangles
Find more skinny triangles
Find more skinny triangles
Find more skinny triangles
Find more skinny triangles
Find more skinny triangles
Ruppert’s algorithm in a word
• Quality mesh (any a  20.7)
• O(mopt) output size
• O(n2 + m) runtime worst case
– works fast in practice
• General approach: bottom-up
In practice, 35
often works.
Compare and contrast
35 triangles, 30
69 triangles, 17
Ruppert’s algorithm in a word
• Quality mesh
• O(mopt) output size
– smaller than quadtree in practice
• O(n2 + m) runtime worst case
– works fast in practice
• General approach: bottom-up
Restrictions
• Ruppert’s algorithm handles segments only
at 60 angles to each other.
• 3d extensions [She97, MPW02]:
segment segment 60
segment face ~70
face
face
90
Smaller angles
may cause
infinite loops
Meshing well, quickly
Hudson, Miller, Phillips 2006
Sparse Voronoi Refinement
15th International Meshing Roundtable
The Goal
Ruppert’s small meshes
Quadtree’s fast runtime
In dimension 3+!
The intuition
Quadtree’s fast time: slowly zero in on small
features, keep mesh good quality always. Large
size: warp to input too late.
SVR: always good quality, resolve when necessary
Ruppert’s small size: immediately resolve all
features. Ruppert’s bad timing: allow horrid
mesh quality.
SVR
Add a bounding box
Triangulate just the box!
Triangles keep
track of points
Apply splitting rules
1. If a triangle is skinny,
split it.
2. If a triangle contains
input, split it.
Apply splitting rules
1. If a triangle is skinny,
split it.
2. If a triangle contains
input, split it.
Split
1. If a triangle is skinny,
split it.
2. If a triangle contains
input, split it.
Split(t)
1. Draw circle
2. Shrink by k
3. Choose a point
4. Insert it, retriangulate
Apply splitting rules
1. If a triangle is skinny,
split it.
2. If a triangle contains
input, split it.
Split(t)
1. Draw circle
2. Shrink by k
3. Choose a point
4. Insert it, retriangulate
Apply splitting rules
1. If a triangle is skinny,
split it.
2. If a triangle contains
input, split it.
Apply splitting rules
1. If a triangle is skinny,
split it.
2. If a triangle contains
input, split it.
General flavour
Like quadtree, refine
top-down
Like Ruppert, use input
points and circumcenters
L: largest distance
s: smallest distance
L/s  spread
Normally:
 poly(n)
EarlyL/s
evidence:
lgindistinguishable
L/s  lg n
from Ruppert’s
SVR in a word
• Quality mesh
• O(mopt) output size
• O(n lg L/s + m) runtime worst case
• General approach: hybrid
Overall Comparison
SVR [HMP06]
Quadtree [BEG90]
Ruppert [Rup92]
hybrid
top-down
bottom-up
Octtree [MV92]
Shewchuk [She97]
top-down
bottom-up
any d O(n lg L/s + m)
2d
O(n lg “n” + m)
2d
O(mn)
3d
3d
O(mn)
W(n2), O(m2n)
n: number of input points, segments, …
m: number of output points
[HPU05]:
L/s: spread
of the input
[Miller04]:
lg L/sL/s+ m)poly(n)
lg “n”:O(n
assumes
O((n lg G + m) lg m)
on point sets
O(n lg “n” + m)
Overall
Comparison
on point sets
SVR [HMP06]
Quadtree [BEG90]
Ruppert [Rup92]
hybrid
top-down
bottom-up
Octtree [MV92]
Shewchuk [She97]
top-down
bottom-up
any d O(n lg L/s + m)
2d
O(n lg “n” + m)
2d
O(mn)
3d
3d
O(mn)
W(n2), O(m2n)
n: number of input points, segments, …
W(n2) even
m: number of output points
L/s: spread of the input
on point sets
lg “n”: assumes L/s  poly(n)
In practice
n/2 points
along line
n/2 points
around circle
Delaunay has
n2/4 tets
In practice: n=2000
Algorithm Max #tets Output #tets Max degree
SVR
81K
81K
39
Shewchuk 1.014M
87K
~1,000
n/2 points
around circle
n/2 points
along line
In practice: n=20000
SVR: outputs 774K tets in 8 minutes
Shewchuk: thrashes, ^c after 4 hours
n/2 points
around circle
n/2 points
along line
(Calculate: Pyramid
needs 108 tets, each
tet is 8 pointers 
~ 3.2 GB)
Parallel SVR
Hudson, Miller, Phillips 2007
Sparse Parallel Delaunay Refinement
To appear, SPAA.
Why parallel?
• Low-end desktops have dual-core CPUs.
• Understanding the dependencies:
– Helps with constant factors in sequential case
– Helps with out-of-core, distributed,
compression, dynamic case, …
Parallel Comparison
Depth
SVR [HMP07]
Quadtree [BET93]
Ruppert [STU02]
any d O(lg (L/s) lg(m))
2d
O(lg “n”)
2d, 3d O(polylog(L/s))
Work
O(n lg L/s + m)
O(n lg “n” + m)
O( ??? )
n: number of input points, segments, …
m: number of output points
L/s: spread of the input
lg “n”: assumes L/s  poly(n)
A sample work set
What can we
do in parallel?
Conflict
Block
Moot
Independent events
The algorithm: parallel
• Build a bounding box
• While workset not empty
–
–
–
–
Compute conflicts, blocking, mooting
Defer blocked moves to later
Colour the conflict graph in colours {1..d}
for 1..d
• perform all the moves in parallel
• remove mooted moves
• collect new moves for next round
Why does it work?
• No move is blocked more than O(1) rounds
– either it happens
– or it gets mooted
• Proof:
–
–
–
–
If a break move blocks, there is a clean move nearby.
Clean moves don’t block.
By packing, only O(1) clean moves can be nearby.
QED.
Summary
• No move is blocked long
• Break moves are discovered quickly
• Thus the time bound of O(lg L/s) rounds
– And O(lg m) per round overhead
• In practice: we can use any number of
shared-memory processors
Conclusions: SVR
• O(n lg (L/s) + m) time
–
–
–
–
Matches best 2d bound
First sub-quadratic 3d time bound
First 4+d mesh refinement algorithm
Practical
• Parallelizes!
Open problems
(1) Constrained Delaunay
Refinement
• SVR meshes tiny gap.
• Gap is exterior: how
can we ignore it?
• Traditional method:
Constrained Delaunay
Triangulation.
• Hope: CDT/SVR
(2) Slivers
• Points almost coplanar
• Good radius/edge ratio
• Bad solid angles
 numerically bad
• Best proofs
guarantee 0.00…1
• In practice get ~10
(3) Small(ish) angles
• SVR needs  90
angles between faces
• 80? 60? 30?
(4) Small angles
• What if angle is 1?
– What’s a legal output?
• MPS07: guarantee no
large angles in 2d
– Extends to 3d?
(5) Curves
• CAD models use
curves, curved
surfaces
• No good theoretical
bounds on refining
curved surfaces
(6) Laundry list
• Dynamic meshing
– (my thesis topic)
•
•
•
•
Moving meshes
Streaming
Distributed-memory
CAD cleaning
• Handling large spread
• Non-Euclidian metrics
• Better constant bounds
Bibliography
[BEG90]: Bern, Eppstein, Gilbert “Provably good mesh generation”, 1994
[MV92]: Mitchell, Vavasis “Quality mesh generation …”, 2000
[Rup92]: Ruppert “A Delaunay refinement algorithm for …”, 1995
[BET93]: Bern, Eppstein, Teng “Parallel construction …”, 1999
[She97]: Shewchuk “Delaunay refinement mesh generation”, 1997
[MPW02]: Miller, Pav, Walkington “Fully incremental …”, 2002
[STU02]: Spielman, Teng, Ungor “Parallel Delaunay …”, 2002
[Mil04]: Miller, “A time-efficient Delaunay Refinement …”, 2004
[HPU05]: Har-Peled, Ungor, “A time-optimal Delaunay …”, 2005
[HMP06]: Hudson, Miller, Phillips, “Sparse Voronoi Refinement”, 2006
[HMP07]: ~, “Sparse Parallel Delaunay Refinement”, 2007
[MPS07]: Miller, Phillips, Sheehy, “Size competitive …”, submitted
[HA07]: Hudson, Acar, “Dynamic quad-tree mesh refinement”, submitted