1 / 42

Efficient Iso-Contouring Methods for Visualizing 3D Volumes

Learn about iso-contours, efficient contouring algorithms, and the use of quadtrees and octrees for faster contouring. See how to optimize viewing different iso-values in large volume data.

lmartinez
Download Presentation

Efficient Iso-Contouring Methods for Visualizing 3D Volumes

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 3: Contouring II Fall 2011

  2. Review • Iso-contours • Points where a function evaluates to a same 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 is very often used for visualizing 3D volumes • The volume data can be large (e.g, 1000^3) • MRI, CT, Ultrasound, EM, etc. • The user often needs to view surfaces at varying iso-values • An efficient contouring algorithm is needed • Optimized for viewing one volume at multiple iso-values

  4. Marching Squares - Revisited • Active square • A grid square where {min, max} of 4 corner values encloses the iso-value • Algorithm • Visit each square. • If active, create vertices and edges • Time complexity: O(n+k) • n: the number of all grid squares • k: the number of active squares 1 2 3 2 1 2 3 4 3 2 O(n) 3 4 5 4 3 O(k) 2 3 4 3 2 1 2 3 2 1 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. 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 grid square, output contour there.

  8. 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 grid square, output contour there. Iso-value not in {min,max} Iso-value in {min,max}

  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 grid square, output contour there. Iso-value not in {min,max} Iso-value in {min,max}

  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 grid square, output contour there. 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 grid square, output contour there. 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 single cell, output contour there. Iso-value not in {min,max} Iso-value in {min,max}

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

  14. 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 Root node {1,3} {2,4} Leaf nodes {2,4} {3,5} 1 2 3 2 3 4 Grid 3 4 5

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

  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 background leaf nodes (e.g., {-∞,-∞}) if the dimension of grid is not power of 2 • Complexity: O(n) • Total number of nodes in the tree is < 2n • But we only need to do this once Root node {1,3} {2,4} Leaf nodes {2,4} {3,5} 1 2 3 2 3 4 Grid 3 4 5

  17. {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 not a leaf, search within each of its children • If the node is a leaf, contour in that grid cell Root node iso-value = 2.5

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

  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 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)) • The depth of the tree is Log(n) • Much faster than O(k+n) (Marching Squares) if k<<n Root node iso-value = 2.5

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

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

  22. Octrees (3D) • 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))

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

  24. 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 Iso-value

  25. Interval Trees • A binary tree • Root node: all intervals in the grid • Each node maintains: • δ: Median of end values of all 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

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

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

  28. Interval Trees Interval tree: Intervals:

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

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

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

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

  33. 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)) • A linear sweep at each level of the tree • Depth of the tree is Log(n) • Again, this is one-time only 

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

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

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

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

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

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

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

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

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