1 / 45

CSE 554 Lecture 5: Contouring (faster)

CSE 554 Lecture 5: Contouring (faster). Fall 2014. Review. Iso -contours Points where a function evaluates to be a given value ( iso -value) Smooth thresholded boundaries Contouring methods Primal methods Marching Squares (2D) and Cubes (3D) Placing vertices on grid edges

felicia-clay
Télécharger la présentation

CSE 554 Lecture 5: Contouring (faster)

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. CSE 554Lecture 5: Contouring (faster) Fall 2014

  2. Review • Iso-contours • Points where a function evaluates to be a given value (iso-value) • Smooth thresholded boundaries • Contouring methods • Primal methods • Marching Squares (2D) and Cubes (3D) • Placing vertices on grid edges • Dual methods • Dual Contouring (2D,3D) • Placing vertices in grid cells Primal Dual

  3. Efficiency • Iso-contours are ubiquitous for medical data visualization • Challenges: • The data can be large (e.g, 1000^3) • The user often needs to change iso-values on the fly • An efficient contouring algorithm is needed • Optimized for viewing one volume at multipleiso-values

  4. Marching Squares - Revisited • Activecell/edge • A grid cell/edge where {min, max} of its corner/end values encloses the iso-value • Algorithm • Visit each cell. • If active, create vertices on active edges and connect them by lines • Time complexity? • n: the number of all grid cells • k: the number of active cells 1 2 3 2 1 2 3 4 3 2 3 4 5 4 3 O(n) 2 3 4 3 2 O(k) 1 2 3 2 1 O(n+k) Iso-value = 3.5

  5. Marching Squares - Revisited Marching Squares O(n+k) Running time (seconds) Only visiting each square and checking if it is active (without creating vertices and edges) O(n) Iso-value

  6. Speeding Up Contouring • Data structures that allow faster query of active cells • Quadtrees (2D), Octrees (3D) • Hierarchical spatial structures for quickly pruning large areas of inactive cells • Complexity: O(k*Log(n)) • Interval trees • An optimal data structure for range finding • Complexity: O(k+Log(n))

  7. Interval Trees Marching Squares O(n+k) Running time (seconds) Quadtree O(k*Log(n)) Interval tree O(k+Log(n)) Iso-value

  8. Speeding Up Contouring • Data structures that allow faster query of active cells • Quadtrees (2D), Octrees (3D) • Hierarchical spatial structures for quickly pruning large areas of inactive cells • Complexity: O(k*Log(n)) • Interval trees • An optimal data structure for range finding • Complexity: O(k+Log(n))

  9. Quadtrees (2D) • Basic idea: coarse-to-fine search • Start with the entire grid: • If the {min, max} of all grid values does not enclose the iso-value, stop. • Otherwise, divide the grid into four sub-grids and repeat the check within each sub-grid. If the sub-grid is a unit cell, it’s an active cell.

  10. Quadtrees (2D) • Basic idea: coarse-to-fine search • Start with the entire grid: • If the {min, max} of all grid values does not enclose the iso-value, stop. • Otherwise, divide the grid into four sub-grids and repeat the check within each sub-grid. If the sub-grid is a unit cell, it’s an active cell. Iso-value not in {min,max} Iso-value in {min,max}

  11. Quadtrees (2D) • Basic idea: coarse-to-fine search • Start with the entire grid: • If the {min, max} of all grid values does not enclose the iso-value, stop. • Otherwise, divide the grid into four sub-grids and repeat the check within each sub-grid. If the sub-grid is a unit cell, it’s an active cell. Iso-value not in {min,max} Iso-value in {min,max}

  12. Quadtrees (2D) • Basic idea: coarse-to-fine search • Start with the entire grid: • If the {min, max} of all grid values does not enclose the iso-value, stop. • Otherwise, divide the grid into four sub-grids and repeat the check within each sub-grid. If the sub-grid is a unit cell, it’s an active cell. Iso-value not in {min,max} Iso-value in {min,max}

  13. Quadtrees (2D) • Basic idea: coarse-to-fine search • Start with the entire grid: • If the {min, max} of all grid values does not enclose the iso-value, stop. • Otherwise, divide the grid into four sub-grids and repeat the check within each sub-grid. If the sub-grid is a unit cell, it’s an active cell. Iso-value not in {min,max} Iso-value in {min,max}

  14. Quadtrees (2D) • Basic idea: coarse-to-fine search • Start with the entire grid: • If the {min, max} of all grid values does not enclose the iso-value, stop. • Otherwise, divide the grid into four sub-grids and repeat the check within each sub-grid. If the sub-grid is a unit cell, it’s an active cell. Iso-value not in {min,max} Iso-value in {min,max}

  15. Quadtrees (2D) • A degree-4 tree • Root node: entire grid • Each node maintains: • {min, max} in the enclosed part of the image • (in a non-leaf node) 4 children nodes for the 4 quadrants {1,5} 1 2 3 Root node 2 3 4 Grid {1,3} {2,4} {2,4} {3,5} Level-1 nodes (leaves) Quadtree 3 4 5

  16. Quadtrees (2D) {1,5} • Tree building: bottom-up • Each grid cell becomes a leaf node • Assign a parent node to every group of 4 nodes • Compute the {min, max} of the parent node from those of the children nodes • Padding dummy leaf nodes (e.g., {∞,∞}) if the dimension of grid is not power of 2 Root node {1,3} {2,4} Leaf nodes {2,4} {3,5} 1 2 3 2 3 4 Grid 3 4 5

  17. Quadtrees (2D) • Tree building: a recursive algorithm • // A recursive function to build a single quadtree node • // for a sub-grid at corner (lowX, lowY) and with length len • buildNode (lowX, lowY, len) • If (lowX, lowY) is out of range: Return a leaf node with {∞,∞} • If len = 1: Return a leaf node with {min, max} of corner values • Else • c1 = buildNode (lowX, lowY, len/2) • c2 = buildNode (lowX + len/2, lowY, len/2) • c3 = buildNode (lowX, lowY + len/2, len/2) • c4 = buildNode (lowX + len/2, lowY + len/2, len/2) • Return a node with children {c1,…,c4} and {min, max} of all {min, max} of these children // Building a quadtree for a grid whose longest dimension is len Return buildNode (1, 1, 2^Ceiling[Log[2,len]])

  18. Quadtrees (2D) {1,5} • Tree building: bottom-up • Each grid cell becomes a leaf node • Assign a parent node to every group of 4 nodes • Compute the {min, max} of the parent node from those of the children nodes • Padding background leaf nodes (e.g., {∞,∞}) if the dimension of grid is not power of 2 • Complexity: O(n) • But we only need to do this once (after that, the tree can be used to speed up contouring at any iso-value) Root node {1,3} {2,4} Leaf nodes {2,4} {3,5} 1 2 3 2 3 4 Grid 3 4 5

  19. {1,3} {2,4} Leaf nodes {2,4} {3,5} 1 2 3 2 3 4 Grid 3 4 5 Quadtrees (2D) {1,5} • Contouring with a quadtree: top-down • Starting from the root node • If {min, max} of the node encloses the iso-value • If it is not a leaf, continue onto its children • If the node is a leaf, contour in that grid cell Root node iso-value = 2.5

  20. Quadtrees (2D) • Contouring with a quadtree: a recursive algorithm • // A recursive function to contour in a quadtree node • // for a sub-grid at corner (lowX, lowY) and with length len • contourNode (node, iso, lowX, lowY, len) • If iso is within {min, max} of node • If len = 1: do Marching Squares in this grid square • Else (let the 4 children be c1,…,c4) • contourNode (c1, iso, lowX, lowY, len/2) • contourNode (c2, iso, lowX + len/2, lowY, len/2) • contourNode (c3, iso, lowX, lowY + len/2, len/2) • contourNode (c4, iso, lowX + len/2, lowY + len/2, len/2) // Contouring using a quadtree whose root node is Root // for a grid whose longest dimension is len contourNode (Root, iso, 1, 1, 2^Ceiling[Log[2,len]])

  21. {1,3} {2,4} Leaf nodes {2,4} {3,5} 1 2 3 2 3 4 Grid 3 4 5 Quadtrees (2D) {1,5} • Contouring with a quadtree: top-down • Starting from the root node • If {min, max} of the node encloses the iso-value • If the node is an intermediate node, search within each of its children nodes • If the node is a leaf, output contour in that grid square • Complexity: (at most) O(k*Log(n)) • Much faster than O(k+n) (Marching Squares) if k<<n • But not efficient when k is large (can be as slow as O(n)) Root node iso-value = 2.5

  22. Quadtrees (2D) Marching Squares O(n+k) Running time (seconds) Quadtree O(k*Log(n)) Iso-value

  23. Quadtrees (2D): Summary • Algorithm • Preprocessing: building the quad tree • Independent of iso-values • Contouring: traversing the quad tree • Both are recursive algorithms • Time complexity • Tree building: O(n) • Slow, but one-time only • Contouring: O(k*Log(n))

  24. Octrees (3D): Overview • Algorithm: similar to quadtrees • Preprocessing: building the octree • Each non-leaf node has 8 children nodes, one for each octant of grid • Contouring: traversing the octree • Both are recursive algorithms • Time complexity: same as quadtrees • Tree building: O(n) • Slow, but one-time only • Contouring: O(k*Log(n))

  25. Speeding Up Contouring • Data structures that allow faster query of active cells • Quadtrees (2D), Octrees (3D) • Hierarchical spatial structures for quickly pruning large areas of inactive cells • Complexity: O(k*Log(n)) • Interval trees • An optimal data structure for range finding • Complexity: O(k+Log(n))

  26. 0 255 Interval Trees • Basic idea • Each grid cell occupies an interval of values {min, max} • An active cell’s interval intersects the iso-value • Stores all intervals in a search tree for efficient intersection queries • Minimizes the “path” from root to all leaves intersecting any given iso-value Iso-value

  27. Interval Trees • A binary tree • Root node: all intervals in the grid • Each node maintains: • δ: Median of end values of all intervals (used to split the children intervals) • (in a non-leaf node) Two children nodes • Left child: intervals strictly lower than δ • Right child: intervals strictly higher than δ • Two sorted lists of intervals intersecting δ • Left list (AL): ascending order of min-end of each interval • Right list (DR): descending order of max-end of each interval

  28. Interval Trees AL: d,e,f,g,h,i DR: i,e,g,h,d,f AL: a,b,c DR: c,a,b AL: j,k,l DR: l,j,k δ=7 AL: m DR: m Interval tree: δ=4 δ=10 δ=12 Intervals:

  29. Interval Trees • A binary tree • Root node: all intervals in the grid • Each node maintains: • δ: Median of end values of all intervals (used to split the children intervals) • (in a non-leaf node) Two children nodes • Left child: intervals strictly lower than δ • Right child: intervals strictly higher than δ • Two sorted lists of intervals intersecting δ • Left list (AL): ascending order of min-end of each interval • Right list (DR): descending order of max-end of each interval • Depth: O(Log(n))

  30. Interval Trees • Intersection queries: top-down • Starting with the root node • If the iso-value is smaller than δ • Scan through AL: output all intervals whose min-end is smaller than iso-value. • Go to the left child. • If the iso-value is larger than δ • Scan through DR: output all intervals whose max-end is larger than iso-value. • Go to the right child. • If iso-value equalsδ • Output AL (or DR).

  31. Interval Trees AL: d,e,f,g,h,i DR: i,e,g,h,d,f iso-value = 9 AL: a,b,c DR: c,a,b AL: j,k,l DR: l,j,k δ=7 AL: m DR: m Interval tree: δ=4 δ=10 δ=12 Intervals:

  32. Interval Trees AL: d,e,f,g,h,i DR: i,e,g,h,d,f iso-value = 9 AL: a,b,c DR: c,a,b AL: j,k,l DR: l,j,k δ=7 AL: m DR: m Interval tree: δ=4 δ=10 δ=12 Intervals:

  33. Interval Trees AL: d,e,f,g,h,i DR: i,e,g,h,d,f iso-value = 9 AL: a,b,c DR: c,a,b AL: j,k,l DR: l,j,k δ=7 AL: m DR: m Interval tree: δ=4 δ=10 δ=12 Intervals:

  34. Interval Trees • Intersection queries: top-down • Starting with the root node • If the iso-value is smaller than δ • Scan through AL: output all intervals whose min-end is smaller than iso-value. • Go to the left child. • If the iso-value is larger than δ • Scan through DR: output all intervals whose max-end is larger than iso-value. • Go to the right child. • If iso-value equalsδ • Output AL (or DR). • Complexity: O(k + Log(n)) • k: number of intersecting intervals (active cells) • Much faster than O(k+n) (Marching squares/cubes)

  35. Interval Trees Marching Squares O(n+k) Running time (seconds) Quadtree O(k*Log(n)) Interval tree O(k+Log(n)) Iso-value

  36. Interval Trees • Tree building: top-down • Starting with the root node (which includes all intervals) • To create a node from a set of intervals, • Find δ (the median of all ends of the intervals). • Sort all intervals intersecting with δ into the AL, DR • Construct the left (right) child from intervals strictly below (above) δ • A recursive algorithm

  37. Interval Trees Interval tree: Intervals:

  38. Interval Trees AL: d,e,f,g,h,i DR: i,e,g,h,d,f δ=7 Interval tree: Intervals:

  39. Interval Trees AL: d,e,f,g,h,i DR: i,e,g,h,d,f AL: a,b,c DR: c,a,b δ=7 Interval tree: δ=4 Intervals:

  40. Interval Trees AL: d,e,f,g,h,i DR: i,e,g,h,d,f AL: a,b,c DR: c,a,b AL: j,k,l DR: l,j,k δ=7 Interval tree: δ=4 δ=10 Intervals:

  41. Interval Trees AL: d,e,f,g,h,i DR: i,e,g,h,d,f AL: a,b,c DR: c,a,b AL: j,k,l DR: l,j,k δ=7 AL: m DR: m Interval tree: δ=4 δ=10 δ=12 Intervals:

  42. Interval Trees • Tree building: top-down • Starting with the root node (which includes all intervals) • To create a node from a set of intervals, • Find δ (the median of all ends of the intervals). • Sort all intervals intersecting with δ into the AL, DR • Construct the left (right) child from intervals strictly below (above) δ • A recursive algorithm • Complexity: O(n*Log(n)) • O(n) at each level of the tree (after pre-sorting all intervals in O(n*Log(n))) • Depth of the tree is O(Log(n)) • Again, this is one-time only 

  43. Interval Trees: Summary • Algorithm • Preprocessing: building the interval tree • Independent of iso-values • Contouring: traversing the interval tree • Both are recursive algorithms • Tree-building and traversing are same in 2D and 3D • Time complexity • Tree building: O(n*log(n)) • Slow, but one-time • Contouring: O(k+log(n))

  44. Further Readings • Quadtree/Octrees: • “Octrees for Faster Isosurface Generation”, Wilhelms and van Gelder (1992) • Interval trees: • “Dynamic Data Structures for Orthogonal Intersection Queries”, by Edelsbrunner (1980) • “Speeding Up Isosurface Extraction Using Interval Trees”, by Cignoni et al. (1997)

  45. Further Readings • Other acceleration techniques: • “Fast Iso-contouring for Improved Interactivity”, by Bajaj et al. (1996) • Growing connected component of active cells from pre-computed seed locations • “View Dependent Isosurface Extraction”, by Livnat and Hansen (1998) • Culling invisible mesh parts • “Interactive View-Dependent Rendering Of Large Isosurfaces”, by Gregorski et al. (2002) • Level-of-detail: decreasing mesh resolution based on distance from the viewer Livnat and Hansen Gregorski et al.

More Related