# Slide 13

Electronics - Devices

Nov 26, 2013 (4 years and 5 months ago)

123 views

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

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.

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:

NE

1

NW

2

SE

4

SW

3

1

NE

2

NW

4

SE

3

SW

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

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.

Scene gives

un
-

neighbor squares with

un
-
balanced sides

resulting mesh has

tiny angles

To achieve conformity and satisfy angle
-
bounds (aspect ratio),

We need to
balance

side
-
length ratio of any 2 neighboring squares = O(1).

Two squares are neighbors if they have overlapping sides but disjoint interiors.

balanced

if any two
leaf

neighboring squares

differ in side
-
length by at most 2, i.e, have
depth difference

1
.

Two squares are neighbors if they have overlapping sides but disjoint interiors.

balanced

if any two
leaf

neighboring squares

differ in side
-
length by at most 2, i.e, have
depth difference

1
.

BALANCING

s

= a
leaf
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

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

).

ALGORITHM
T

)

Input
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.

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

-
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

-
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
-
-
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

What is the number of added new nodes?

THEOREM:

Let
T

-
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
-
-
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

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

-
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
-
-
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

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

㠠瑩浥献

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.

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)).

-
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).

[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

).

-
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.
-
-
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

-

7.
-
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

-
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.
-
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.