COSC 6114
Prof. Andy Mirzaian
References
:
•
[M. de Berge et al] chapter 14
•
Marshal Bern [1997],
“Triangulations,”
in
Handbook of Discrete and Computational Geometry,
J.E. Goodman & J. O’Rourke (editors), chapter 22,
413

428.
Applications
:
•
VLSI circuits in electrical devices
•
heat emission
–
a design issue
•
experiment with prototype
•
automated simulation by finite

element methods
•
MESH (uniform / non

uniform)
Applications & Methodology
:
•
VLSI circuits in electrical devices
•
heat emission
–
a design issue
•
experiment with prototype;
reject faulty design
(expensive, time consuming)
•
automated simulation by
finite

element methods
•
subdivide regions into sufficiently fine
triangles or quadrangles:
MESH (uniform/non

uniform)
•
what is the influence of one mesh
element on neighboring elements?
•
mesh should be more refined near the
“objects” and gracefully get coarser further away
•
avoid mesh elements that have extreme
aspect ratios (bounded angles)
•
mesh elements should respect object borders.
QUAD TREES
Non

Uniform Mesh Generation
Uniform vs Non

Uniform Mesh
Uniform Mesh
•
Sufficiently refined.
•
Too many mesh elements (time & space)
U
U
U = 2
j
integer
grid
Uniform vs Non

Uniform Mesh
Non

Uniform Mesh
•
Conforming
•
Respect Input
•
Well Shaped: bounded aspect ratio (e.g., angels
[45
: 90
])
•
Steiner Points
Uniform vs Non

Uniform Mesh
Unifrom Mesh
too many triangles
Uniform vs Non

Uniform Mesh
Non

Uniform mesh
based on:
Constrained
Delaunay Triangulation
small angels
Uniform vs Non

Uniform Mesh
Non

Uniform Mesh
based on:
QUAD TREE
Quad Trees for point sets
NE
1
NW
2
SE
4
SW
3
1
NE
2
NW
4
SE
3
SW
Quad Trees for point sets
1
21
22
23
242
241
243
244
31
32
33
34
4
1
4
2
3
21
22
23
24
31
32
33
34
241
242
243
244
Quad Trees for point sets
corner
•
square/node:
s
•
Point set P
[x
s
: x’
s
]
[y
s
: y’
s
]
•
x
mid
= (x
s
+ x’
s
)/2 ,
y
mid
= (y
s
+ y’
s
)/2
•
P
NE
= { p
P ⁼† p
x
> x
mid
, p
y
> y
mid
}
•
P
NW
= { p
P ⁼†⁰
x
x
mid
, p
y
> y
mid
}
•
P
SW
= { p
P ⁼ †p
x
x
mid
, p
y
y
mid
}
•
P
SE
= { p
P†簠 ⁰
x
> x
mid
, p
y
y
mid
}
•
Keep
splitting
a square if it contains
more than one
data point.
LEMMA:
P = a set of points in the plane,
S = side length of root square for Quad Tree of P,
C = smallest distance between pair of points in P,
D = depth of Quad Tree.
Then, D
log S/C + 3/2 .
Proof:
•
Any internal node contains at least 2 points of P.
•
Node at depth i has side

length S/2
i
, diagonal length (S
2)
/2
i
C
•
So, i
log (S
2)
/C = log S/C + ½ .
•
Deepest leaf has depth one more.
Balanced Quad Trees
Scene gives
un

balanced Quad Tree
neighbor squares with
un

balanced sides
resulting mesh has
tiny angles
To achieve conformity and satisfy angle

bounds (aspect ratio),
We need to
balance
the QuadTree.
Balanced QuadTree:
side

length ratio of any 2 neighboring squares = O(1).
Balanced Quad Trees
Two squares are neighbors if they have overlapping sides but disjoint interiors.
Quad Tree is
balanced
if any two
leaf
neighboring squares
differ in side

length by at most 2, i.e, have
depth difference
1
.
Balanced Quad Trees
Two squares are neighbors if they have overlapping sides but disjoint interiors.
Quad Tree is
balanced
if any two
leaf
neighboring squares
differ in side

length by at most 2, i.e, have
depth difference
1
.
BALANCING
Balanced Quad Trees
s
= a
leaf
of Quad Tree
T
NN(
s
⤠‽
North Neighbor of
s,
is a node
s
’ in
T
s.t.
(i) north edge of
s
is shared by
s
’
(ii) depth(
s
’)
depth(
s
)
(i.e., square
s
’ not smaller than
s
)
(iii)
s
’ is the smallest such square in
T.
SN(
s
⤬⁅)(
s
⤬⁗丨
s
)
defined similarly.
EN
(s)
WN
(s)
SN
(s)
NN
(s)
EN
(s)
SN
(s)
WN
(s)
NN
(s)
s
s
Balanced Quad Trees
LEMMA:
Given a leaf
s
in
T
,
NN(
s
), NN(
s
), NN(
s
), NN(
s
) can be obtained in O( depth(
s
)).
Proof:
Let
s
’ = NN(
s
). From
s
, go up in
T
to lowest common ancestor
of
s
&
s
’, then come down to
s
’.
LEMMA:
Leaf
s
should split
leaf
s
’
in
T
, s.t.
s
is one of NN(
s
’
)
, NN(
s
’), NN(
s
’), or NN(
s
’), &
depth(
s
’)
2 +
depth(
s
).
These take O(D) time, D = height(
T
).
Balancing a Quad Tree
ALGORITHM
BalancedQuadTree(
T
)
Input
: Quad Tree
T
Output
: a balanced version of
T
1.
L
list of all leaves of
T
2.
while
L
do
3.
remove a leaf
s
from
L
4.
if
s
has to split
then do
5.
add 4 children
s
NE
,
s
NW
,
s
SE
,
s
SW
to
s
in
T
&
update their object contents
6.
insert
s
NE
,
s
NW
,
s
SE
,
s
SW
into
L
7.
check if
s
NE
,
s
NW
,
s
SE
,
s
SW
have neighbors that
should split & add them to
L
8.
end

if
9.
end

while
10.
return
T
end
THEOREM:
Let
T
be a quad

tree with m nodes and height D.
Then, the above algorithm constructs a balanced version
of
T
that has O(m) nodes in O(Dm) time.
THEOREM:
Let
T
be a quad

tree with m nodes and height D.
Then, the above algorithm constructs a balanced version
of
T
that has O(m) nodes in O(Dm) time.
Proof:
Step 1: takes O(m) time.
Steps 2

9: each iteration adds 4

1 = 3 nodes to
T
& takes O(D) time
to check O(1) neighboring nodes in
L
.
Therefore, total time for the while

loop is O(D
# new nodes added).
What is the number of added new nodes?
THEOREM:
Let
T
be a quad

tree with m nodes and height D.
Then, the above algorithm constructs a balanced version
of
T
that has O(m) nodes in O(Dm) time.
Proof:
Step 1: takes O(m) time.
Steps 2

9: each iteration adds 4

1 = 3 nodes to
T
& takes O(D) time
to check O(1) neighboring nodes in
L
.
Therefore, total time for the while

loop is O(D
# new nodes added).
What is the number of added new nodes?
NE
NW
SE
SW
s
2
s
3
Even though some leaf in
s
1
causes leaf
s
2
to split, that splitting cannot propagate to the
neighbor
s
3
of the same size.
[Proof by induction on node depth difference.]
s
1
THEOREM:
Let
T
be a quad

tree with m nodes and height D.
Then, the above algorithm constructs a balanced version
of
T
that has O(m) nodes in O(Dm) time.
Proof:
Step 1: takes O(m) time.
Steps 2

9: each iteration adds 4

1 = 3 nodes to
T
& takes O(D) time
to check O(1) neighboring nodes in
L
.
Therefore, total time for the while

loop is O(D
# new nodes added).
What is the number of added new nodes?
NE
NW
SE
SW
s
2
s
3
Even though some leaf in
s
1
causes leaf
s
2
to split, that splitting cannot propagate to the
neighbor
s
3
of the same size.
[Proof by induction on node depth difference.]
s
1
range of influence:
charge 1 to
neighbor of
equal size
that causes
splitting
each square is
charged
㠠瑩浥献
From Quad Trees to Meshes
Root square contains polygonal objects, all vertices at integer grid points (
U=2
j
),
all edges are at angels 0
, 45
, 90
, 135
.
Stop splitting when the square no longer intersects with any object edge, or when
it has unit size.
Balance the resulting Quad Tree
for
each leaf square
s
do:

if there is a diagonal object edge, fine; otherwise, add one such diagonal.

to make
s
conform to a neighboring smaller leaf, add O(1) horizontal or
vertical or diagonal lines also.
all angels
45
or 90
.
THEOREM:
Let S = a set of disjoint polygonal components inside
the square [0 : U]
[0 : U] with properties stated earlier, &
p(S) = total perimeter length of components in S.
Then, there is a non

uniform triangular mesh for S that is:
•
conforming,
•
respects the input,
•
triangle angles are 45
or 90
,
•
# triangles = O(p(S) log U),
•
Construction time = O(p(S) log
2
U).
Proof:
•
# triangles incident to an input segment of length L is
2(L+2).
•
Thus, # cells in the quad

tree at the same depth is O(p(S)).
•
Depth of quad

tree is at most O(log U).
•
Thus, total # nodes in quad

tree is O(p(S) log U).
•
The rest follows from previous discussion:
m = O(p(S) log U)
D = O(log U)
O(Dm) = O(p(S) log
2
U).
Notes & Comments
[Bern 1997]: any polygonal domain with n vertices & no obtuse angles
has a mesh consisting of O(n) non

obtuse triangles (i.e., all angels
90
).
Other applications of quad

trees (oct

trees in
3
):
computer graphics
image analysis
range queries
hidden surface removal
ray tracing
medial axis transforms
overlay of raster maps
nearest neighbor query processing
Exercises
1.
Suppose a triangular mesh is needed inside a rectangle whose sides have length 1
and length k > 1. Steiner points may not be used on the sides, but they may be used
inside the rectangles. Also assume that all triangles msut have angles between 30
and
90
. Is it always possible to create a triangular mesh with these properties?
Suppose it is possible to create a mesh for a particular input, what is the minimum
number of Steiner points needed?
2.
The algorithm described produces non

obtuse triangulated mesh (provided all angles
in the input have no obtuse angles). Prove that if a triangulation of a set P of points in
the plane contains only non

obtuse triangles, then it must be the Delaunay
triangulation of P.
3.
Describe an algorithm to construct an oct

tree of a given set P of n points in 3D.
4.
It is possible to reduce the size of a quad

tree of height D for a set of points (with real
coordinates) inside a square from O((D+1)n) to D(n). The idea is to discard any node
v that has only one child under which points are stored. The node is discarded by
replacing the pointer from the parent of v to v with the pointer from parent to the only
interesting child of v. Prove that the resulting tree has linear size. Can you also
improve upon the O((D+1)n) construction time?
5.
We called a quad

tree balanced if every two adjacent squares of the quad

tree
subdivision differ by no more that a factor of two in size. To save a constant factor in
the number of extra nodes needed to balance a quad

tree, we could weaken the
balance condition by allowing adjacent squares to differ by a factor of four in size.
Can you still complete such a weakly balanced quad

tree subdivision to a mesh such
that all angles are between
45
and
90
by using only O(1) triangles per square?
6.
Suppose we make the balancing condition for quad

trees more severe: we no longer allow
adjacent squares to differ by a factor two in sieze, but we require them to have exactly the
same size. Is the number of nodes in the new balanced version still linear in the number of
nodes of the original quad

tree? If not, can you say anything about this number?
7.
A quad

tree can also be used to store a subdivision for efficient point location. The idea is to
keep splitting a bounding square of the subdivision until all leaf nodes correspond to squares
that contain at most one vertex and only edges incident to that vertex, or no vertex and at most
one edge.
(a) Since a vertex can be incident to many edges, we need an additional data structure at the
quad

tree leaves storing vertices. Which data structure would you use?
(b) Describe the algorithm for constructing the point location data structure in detail, and
analyze its running time.
(c) Describe the query algorithm in detail, and analyze its running time.
8.
Quad

tree can be used to perform range queries. Describe an algorithm for querying a quad

tree
on a set P of points with a query region R. Analyze the worst

case query time for the case
where R is a rectangle, and for the case where R is a half

plane bounded by a vertical line.
9.
Compare quad

tree, kD

trees and range trees (studies previously). Discuss the advantages
and disadvantages of each of these data structures.
END
Comments 0
Log in to post a comment