1. Meshes. D7013E Lecture 14

Transcription

1 D7013E Lecture 14 Quadtrees Mesh Generation 1. Meshes Input: Components in the form of disjoint polygonal objects Integer coordinates, 0, 45, 90, or 135 angles Output: A triangular mesh Conforming: A triangle is not allowed to have a vertex in the interior of one of its edges Respects the input: The input edges must be contained in the union of mesh edges Well-shaped: Triangle angles must be at least Example About Meshes Compare with general triangulations of simple polygons (Ch. 3) and sets of points (Ch. 9, Delaunay triangulation) A mesh is more restricted Difference: We are allowed to add extra points, called Steiner points, to make triangles well-shaped 3 4

2 Steiner Points Without Steiner points angles in triangles could end up being very small The Delaunay triangulation, that maximizes the minimum angle, has an angle of 5 here: Uniform and Non-Uniform Meshes The uniform mesh has 512 triangles, the nonuniform 52 Note: Just 45 and 90 angles in both Uniform Non-uniform Quadtrees An Example of a Quadtree A Quadtree is a rooted tree in which every node has four (4) children Each node corresponds to a square in the plane Each of the children of a node corresponds to a quadrant of the square of the node A quadtree induces a subdivision of the square of the root Terminology: Corners, sides, edges, and neighbors A Quadtree can be used for storing a non-uniform mesh in an efficient manner NW SW NE SE 7 8

3 Another view Usage in Computer Graphics Constructing a Quadtree Side-lengths Could store different types of data Here: Sets of points Principle: Split squares (into smaller squares) until each square contains at most one input point Recursive construction: Start with a square containing all points, if there are more than one point in the square then split it in 4 quadrants, compute which points end up in which quadrant, and Special rule for points on the border between squares recur on each of the quadrants The side lengths of squares in a Quadtree halves with increasing depth (8 = 2 3 ) 11 12

4 Unbalanced Quadtrees Note that the Quadtree ends up unbalanced when many points lie close to each other 13 Properties Lemma 14.1: Let c be the smallest distance between any two points in a set P, and let s be the side length of the initial (biggest) square in a quadtree Q Then the depth of Q is at most log (s/c) + 3/2 Proof sketch: At depth i, a square S of a node has side s/2 i Maximal distance in S is 2 (s/2 i ) So, 2 (s/2 i ) c => i log(s/c) (log 2 = log = 0.5 log 2) Def. of "depth of a quadtree" = max depth of an internal node Properties Lemma 14.2: A quadtree Q of depth d storing a set of n points has O((d +1)n) nodes and can be constructed in O((d+1)n) time Proof sketch (a, b, c): a) Number of leaves: Let D = arity/outdegree. Q has L leaves and N internal nodes Number of children: N + L - 1 "-1" because the root is not a child (has no parent) Number of parents: (N + L - 1)/D Each child has exactly one parent Each parent has exactly D children All parents are internal nodes => N = (N + L -1)/D <=> L=(D-1)N+1, so D=4 => L=3N+1 (D=4 because we deal with quadtrees) Properties Lemma 14.2: A quadtree Q of depth d storing a set of n points has O((d +1)n) nodes and can be constructed in O((d+1)n) time Proof sketch (a, b, c): b) Number of internal nodes: Let N i be number of internal nodes at depth i N = N i The square of an internal node contains 1 point NB! We do not consider the leaves Squares at depth i are disjoint and cover the initial square => N i n => at most O(dn) space c) Time: On each level, it takes O(1) time to find out where a point belongs and to add new branches 15 16

5 2.2 Neighbour Finding in Quadtrees A Quadtree is a subdivision into regions A typical operation on a Quadtree involves moving around among the regions Neighbor finding: Query: Given a node v (a square) and a direction north, south, west, or east which node (square) lies adjacent to v in the given direction? Finding a Neighbour Algorithm to find the north neighbor of v: If v is an SW- or SE-child, then the north neighbor is one of its siblings Otherwise, climb the tree until a node w is reached that is an SW- or SE-child If there is no such node we report this and halt and descend down into the north neighbor of w finding the SW or SE node at the same depth as v This also works for finding a south, west, or east neighbor Time to Find a Neighbour 2.3 Balanced Quadtrees Theorem 14.3: The neighbour of a given node in a Quadtree of depth d can be found in O(d + 1) time A Quadtree is balanced if any two neighbouring nodes differ at most one in depth North neighbour of the SE-child an SE-child The north neighbour of v An unbalanced quadtree subdivision v 19 20

6 Balancing a Quadtree Add nodes! An Algorithm for Adding Nodes Check neighbors on all four sides; split if there are adjacent squares of size < ½ size of σ(µ) Check again for neighbors on all four sides, but now for those larger than σ(µ); if found, split Complexity 3. From Quadtrees to Meshes Theorem 14.4: The balanced version of a Quadtree with m nodes has O(m) nodes and can be constructed in O((d+1)m) time. Proof sketch: A bound by relating "old" squares to "new" squares Observation: A split => Number of nodes increase by 4 Show that with m nodes -> at most 8m splits => at most 32m extra nodes ( =O(m) ) Claim: Each square that is split has an old neighbor Since each old square can border at most 8 new squares => if true, we would be done Assume not, let σ be a smallest square with just new neighbors Since σ is being split, is borders squares < ½ its size Let σ' be a square of size ½ of σ containing one such small square => σ' lies in a new square (neighboring σ so must be new) => σ' must have been split (can't be an old square) => But then all 8 (equal-sized) neighbors of σ' must also be new Either in σ (which is split so that its sub-squares will be new) or in a neighbor of σ (which is already new, and so all its subsquares) This contradicts the fact that σ is smallest 23 Input is a grid with 2 j 2 j small squares We want a triangular mesh where both the inside as well as outside of components is partitioned into triangles that are conforming, input respecting, and well-shaped Build a quadtree: Split until no component edge crosses over a square.. but don't split so squares end up smaller than 1 1 This gives small squares at component edges (and larger ones further away) 24

7 From Quadtrees to Meshes (2) An edge of a component can only cross a square as a diagonal (go between vertices) Make the quadtree balanced Add a Steiner point in the middle and produce triangles, where needed From Quadtrees to Meshes (3) The triangular mesh is stored as a DCEL (Doubly- Connected Edge List) Theorem 14.5: Let S be a set of disjoint polygonal components with vertices on a grid [0,U] [0,U]. Then 1. there exists a non-uniform triangular mesh for S that is conforming, respects the input, and has only well-shaped triangles, 2. the number of triangles is O(p(S) log U), where p(s) is the sum of the (lengths of) the perimeters of the components, and 3. the mesh can be constructed in O(p(S) log 2 U) Extra: Point location on maps 27 28

8 The image cannot be displayed. Your computer may not have enough memory to open the image, or the image may have been corrupted. Restart your computer, and then open the file again. If the red x still appears, you may have to delete the image and then insert it again. Point location on maps Levels and size of squares The idea is to cut up the map into squares like in a Quadtree (Eastern US in the figure to the right) We divide squares as long as they contain more than one vertex (Sub-) polygons of the map are stored in the leaves only (Lists of states in the squares) We assume maps are somewhat realistic For example: The out degree of its vertices is bounded by a constant We could naively search down the Quadtree until we reach a leaf, and then we go through the list in the leaf Can we do better? Let s se! 2 0 = = 1/2 Level 0 Level -1 Level = 1/8 Level -3 Level = 1/ = 1/ Global ID:s If we treat all squares on a level L as forming a grid, all rows and columns in this grid are numbered from 0 to 2 -L -1 Each square gets the id (L, row, column) On level L, point (x, y) [0..1] [0..1] lies in square ( x/2 L, y/2 L ) Example: On level -2, point (0.3, 0.6) lies in square ( 0.3/2-2, 0.6/2-2 ) = ( 0.3/(1/4), 0.6/(1/4) ) = ( 1.2, 2.4 ) = (1,2) Important: Given a level L and a point p, we can compute in constant time in which square on level L point p lies Level -2 Squares Level 0 Level -1 Level -2 Level -3 Level -4 Leaf Quadtree Inner nodes 31 32

9 Idea to do point location The answer to a point location query is stored in a leaf If we only knew the level where the leaf is, we could answer in constant time What if we could do some cleaver search along the path in the Quadtree from the root to the leaf..?! It turns out there is a way to do (exponential) binary search along the path!! Perfect hashing To enable the binary search, we store all ID:s of squares in a perfect hashtable Triplets (L, row, column), for all L, rows, and columns We use the same ID for the nodes Perfect hashing can be used when the set we search in is static Lookup takes constant time in the worst case We have pointers between squares and nodes Both ways Answering a query Let h be the minimum level in the tree and q the query point Remember that numbers of levels are negative We are looking for the smallest level L [0,h] such that (L, q x /2 L, q y /2 L ) is a leaf To find L, we do a binary search over the levels, staring with h (h, q x /2 L, q y /2 L ) If h is too large, and (h, q x /2 L, q y /2 L ) not in the hashtable, we try with h/2 Then h/4, h/8, h/16 etc In each step, we cut in half the interval containing L (h < -9) Analysis Each lookup in the hashtable takes O(1) time So, the binary search takes O(log h) time Interesting: Assume the tree is balanced with depth O(log n), the point location takes O(log log n) time(!!!) Example: If the maps contains 2 32 pieces ( ), locating the point takes 5 steps (+the constant out degree to find out exactly which subpolygon) (h < -9)