View
215
Download
0
Category
Preview:
DESCRIPTION
CSE554Contouring IISlide 3 Efficiency Iso-contours are often used for visualizing (3D) medical images – The data can be large (e.g, 500^3) – The user often wants to change iso-values and see the result in real-time An efficient contouring algorithm is needed – Optimized for viewing one volume at multiple iso-values
Citation preview
CSE554 Contouring II Slide 1
CSE 554Lecture 5: Contouring (faster)
Fall 2015
CSE554 Contouring II Slide 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 cellsPrimal Dual
CSE554 Contouring II Slide 3
Efficiency
• Iso-contours are often used for visualizing (3D) medical images– The data can be large (e.g, 500^3)
– The user often wants to change iso-values and see the result in real-time
• An efficient contouring algorithm is needed– Optimized for viewing one volume at multiple iso-values
CSE554 Contouring II Slide 4
Marching Squares - Revisited
• Active cell/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
2 3 4 3 2
1 2 3 2 1
Iso-value = 3.5
O(n)
O(k)
O(n+k)
CSE554 Contouring II Slide 5
0 50 10 0 150 200 250
0 .2
0 .4
0 .6
0 .8
1 .0
1 .2
0 50 10 0 150 200 250
0 .2
0 .4
0 .6
0 .8
1 .0
1 .2
Marching Squares - Revisited
Running time (seconds)
Iso-value
Only visiting each square and checking if it is active (without creating vertices and edges) O(n)
Marching Squares O(n+k)
CSE554 Contouring II Slide 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))
CSE554 Contouring II Slide 7
0 50 100 150 200 250
0 .2
0 .4
0 .6
0 .8
1 .0
1 .2
Interval Trees
Running time (seconds)
Iso-value
Marching Squares O(k+n)
QuadtreeO(k*Log(n))
Interval treeO(k+Log(n))
CSE554 Contouring II Slide 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))
CSE554 Contouring II Slide 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.
CSE554 Contouring II Slide 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 in {min,max}
Iso-value not in {min,max}
CSE554 Contouring II Slide 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 in {min,max}
Iso-value not in {min,max}
CSE554 Contouring II Slide 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 in {min,max}
Iso-value not in {min,max}
CSE554 Contouring II Slide 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 in {min,max}
Iso-value not in {min,max}
CSE554 Contouring II Slide 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 in {min,max}
Iso-value not in {min,max}
CSE554 Contouring II Slide 15
Quadtrees (2D)
• A degree-4 tree– Root node represents the entire image
– Each node represents a square part of the image:
• {min, max} in the square
• (in a non-leaf node) one child node for each quadrant of the square
1 2 3
2 3 4
3 4 5
{1,5}
{1,3} {2,4} {2,4} {3,5}Grid
Level-1 nodes(leaves)
Root node
Quadtree
CSE554 Contouring II Slide 16
Quadtrees (2D)
• Tree building (pre-computation)– 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
{1,3} {2,4}
{3,5}{2,4}
1 2 3
2 3 4
3 4 5
{1,5}
Grid
Leaf nodes
Root node
CSE554 Contouring II Slide 17
• Tree building: a recursive algorithm
Quadtrees (2D)
// A recursive function to build a single quadtree node// for a sub-grid at corner (lowX, lowY) and with length lenbuildSubTree (lowX, lowY, len)1. If (lowX, lowY) is out of range: Return a leaf node with {∞,∞}2. If len = 1: Return a leaf node with {min, max} of corner values3. Else
1. c1 = buildSubTree (lowX, lowY, len/2)2. c2 = buildSubTree (lowX + len/2, lowY, len/2)3. c3 = buildSubTree (lowX, lowY + len/2, len/2)4. c4 = buildSubTree (lowX + len/2, lowY + len/2, len/2)5. 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 lenReturn buildSubTree (1, 1, 2^Ceiling[Log[2,len]])
CSE554 Contouring II Slide 18
Quadtrees (2D)
• Tree building: bottom-up– 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)
CSE554 Contouring II Slide 19
Quadtrees (2D)
• 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
{1,5}
{1,3} {2,4}
{3,5}{2,4}
Leaf nodes
Root node
1 2 3
2 3 4
3 4 5
Grid
iso-value = 2.5
CSE554 Contouring II Slide 20
Quadtrees (2D)
// A recursive function to contour in a quadtree node // for a sub-grid at corner (lowX, lowY) and with length lenctSubTree (node, iso, lowX, lowY, len)1. If iso is within {min, max} of node
1. If len = 1: do Marching Squares in this grid square2. Else (let the 4 children be c1,…,c4)
1. ctSubTree (c1, iso, lowX, lowY, len/2)2. ctSubTree (c2, iso, lowX + len/2, lowY, len/2)3. ctSubTree (c3, iso, lowX, lowY + len/2, len/2)4. ctSubTree (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 lenctSubTree (Root, iso, 1, 1, 2^Ceiling[Log[2,len]])
• Contouring with a quadtree: a recursive algorithm
CSE554 Contouring II Slide 21
Quadtrees (2D)
• Contouring with a quadtree: top-down– Complexity (a loose bound): 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))
CSE554 Contouring II Slide 22
0 50 100 150 200 250
0 .2
0 .4
0 .6
0 .8
1 .0
1 .2
Quadtrees (2D)
Running time (seconds)
Iso-value
Marching Squares O(n+k)
QuadtreeO(k*Log(n))
CSE554 Contouring II Slide 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))
CSE554 Contouring II Slide 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))
CSE554 Contouring II Slide 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))
CSE554 Contouring II Slide 26
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
0 255
Iso-value
CSE554 Contouring II Slide 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 child nodes
– Left child: intervals < δ
– Right child: intervals > δ
• 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
CSE554 Contouring II Slide 28
Interval Trees
Intervals:
Interval tree:
δ=7
δ=4 δ=10
AL: d,e,f,g,h,iDR: i,e,g,h,d,f
AL: j,k,lDR: l,j,k
AL: mDR: m
AL: a,b,cDR: c,a,b
δ=12
CSE554 Contouring II Slide 29
Interval Trees• Intersection queries: top-down
– Starting with the root node
• If the iso-value is smaller than median δ
– Scan through AL: output all intervals whose min-end <= iso-value.
– Go to the left child.
• If the iso-value is larger than δ
– Scan through DR: output all intervals whose max-end >= iso-value.
– Go to the right child.
• If iso-value equals δ
– Output AL (or DR).
CSE554 Contouring II Slide 30
Interval Trees
Intervals:
Interval tree:
δ=7
δ=4 δ=10
AL: d,e,f,g,h,iDR: i,e,g,h,d,f
AL: j,k,lDR: l,j,k
AL: mDR: m
AL: a,b,cDR: c,a,b
δ=12
iso-value = 9
CSE554 Contouring II Slide 31
Interval Trees
Intervals:
Interval tree:
δ=7
δ=4 δ=10
AL: d,e,f,g,h,iDR: i,e,g,h,d,f
AL: j,k,lDR: l,j,k
AL: mDR: m
AL: a,b,cDR: c,a,b
δ=12
iso-value = 9
CSE554 Contouring II Slide 32
Interval Trees
Intervals:
Interval tree:
δ=7
δ=4 δ=10
AL: d,e,f,g,h,iDR: i,e,g,h,d,f
AL: j,k,lDR: l,j,k
AL: mDR: m
AL: a,b,cDR: c,a,b
δ=12
iso-value = 9
CSE554 Contouring II Slide 33
Interval Trees• Intersection queries: top-down
– Complexity: O(k + Log(n))
• Much faster than O(k+n) (Marching squares/cubes)
CSE554 Contouring II Slide 34
0 50 100 150 200 250
0 .2
0 .4
0 .6
0 .8
1 .0
1 .2
Interval Trees
Running time (seconds)
Iso-value
Marching Squares O(n+k)
QuadtreeO(k*Log(n))
Interval treeO(k+Log(n))
CSE554 Contouring II Slide 35
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
CSE554 Contouring II Slide 37
Interval Trees
Intervals:
Interval tree:
δ=7
AL: d,e,f,g,h,iDR: i,e,g,h,d,f
CSE554 Contouring II Slide 38
Interval Trees
Intervals:
Interval tree:
δ=7
δ=4
AL: d,e,f,g,h,iDR: i,e,g,h,d,f
AL: a,b,cDR: c,a,b
CSE554 Contouring II Slide 39
Interval Trees
Intervals:
Interval tree:
δ=7
δ=4 δ=10
AL: d,e,f,g,h,iDR: i,e,g,h,d,f
AL: j,k,lDR: l,j,k
AL: a,b,cDR: c,a,b
CSE554 Contouring II Slide 40
Interval Trees
Intervals:
Interval tree:
δ=7
δ=4 δ=10
AL: d,e,f,g,h,iDR: i,e,g,h,d,f
AL: j,k,lDR: l,j,k
AL: mDR: m
AL: a,b,cDR: c,a,b
δ=12
CSE554 Contouring II Slide 41
Interval Trees
• Tree building: top-down – 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
CSE554 Contouring II Slide 42
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))
CSE554 Contouring II Slide 43
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)
CSE554 Contouring II Slide 44
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 Gregorski et al.
Livnat and Hansen
Recommended