1 / 29

COSC 6114

COSC 6114. Prof. Andy Mirzaian. Quad Trees: Non-Uniform Mesh Generation. 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.

darena
Download Presentation

COSC 6114

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. COSC 6114 Prof. Andy Mirzaian Quad Trees: Non-Uniform Mesh Generation

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

  3. QUAD TREESNon-Uniform Mesh Generation • 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.

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

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

  6. Uniform vs Non-Uniform Mesh Unifrom Meshtoo many triangles

  7. Uniform vs Non-Uniform Mesh Non-Uniform mesh based on:Constrained Delaunay Triangulationsmall angels

  8. Uniform vs Non-Uniform Mesh Non-Uniform Mesh based on: QUAD TREE

  9. Quad Trees for point sets NW2 NE1 SW3 SE4 1 NE 2 NW 3 SW 4 SE

  10. Quad Trees for point sets 22 21 4 1 1 2 3 242 241 23 243 244 24 21 22 23 31 32 33 34 31 32 4 241 242 243 244 33 34

  11. Quad Trees for point sets • square/node: s • Point set P  [xs : x’s ]  [ys : y’s ] • xmid = (xs + x’s )/2 , ymid = (ys + y’s )/2 • PNE = { p P | px > xmid , py > ymid } • PNW = { p P | px xmid , py > ymid } • PSW = { p P | px xmid , py ymid } • PSE = { p P | px > xmid , py ymid } • Keep splitting a square if it contains more than one data point. edge side corner

  12. 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/2i , diagonal length (S2)/2i C • So, i  log (S2)/C = log S/C + ½ . • Deepest leaf has depth one more.

  13. Balanced Quad Trees Scene givesun-balanced Quad Tree neighbor squares withun-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).

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

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

  16. Balanced Quad Trees NN(s) • 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), EN(s), WN(s) defined similarly. WN(s) EN(s) s SN(s) SN(s) EN(s) s NN(s) WN(s)

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

  18. Balancing a Quad Tree ALGORITHM BalancedQuadTree(T ) Input: Quad Tree T Output: a balanced version of T L  list of all leaves of T while L   do remove a leaf s from L if s has to split then do add 4 children sNE , sNW , sSE , sSW to s in T & update their object contents insert sNE , sNW , sSE , sSW into L check if sNE , sNW , sSE , sSW have neighbors that should split & add them to L end-if end-while returnT end

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

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

  21. 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? Even though some leaf in s1 causes leaf s2to split, that splitting cannot propagate to theneighbor s3 of the same size. [Proof by induction on node depth difference.] NW NE SW SE s1 s2 s3

  22. 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? Even though some leaf in s1 causes leaf s2to split, that splitting cannot propagate to theneighbor s3 of the same size. [Proof by induction on node depth difference.] NW NE SW SE s1 s2 s3 charge 1 to neighbor of equal size that causes splitting each square is charged  8 times. range of influence:

  23. From Quad Trees to Meshes • Root square contains polygonal objects, all vertices at integer grid points (U=2j), 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 sdo: - 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.

  24. 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) log2 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) log2 U).

  25. 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 • 

  26. Exercises

  27. 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? • 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. • Describe an algorithm to construct an oct-tree of a given set P of n points in 3D. • 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? • 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?

  28. Suppose we make the balancing condition for quad-trees more severe: we no longer allowadjacent squares to differ by a factor two in sieze, but we require them to have exactly thesame size. Is the number of nodes in the new balanced version still linear in the number ofnodes of the original quad-tree? If not, can you say anything about this number? • A quad-tree can also be used to store a subdivision for efficient point location. The idea is tokeep splitting a bounding square of the subdivision until all leaf nodes correspond to squaresthat contain at most one vertex and only edges incident to that vertex, or no vertex and at mostone 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. • Quad-tree can be used to perform range queries. Describe an algorithm for querying a quad-treeon 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. • Compare quad-tree, kD-trees and range trees (studies previously). Discuss the advantagesand disadvantages of each of these data structures.

  29. END

More Related