1. CSE 554 Lecture 5: Contouring (faster)
Fall 2016

2. Review Iso-contours Contouring methods
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 often used for visualizing (3D) medical images
The data can be large (e.g, 512^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

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
O(n)
O(k) 2 3 4 3 2 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/k))
Interval trees
An optimal data structure for range finding
Complexity: O(k+Log(n))

7. Interval Trees Running time (seconds) Iso-value
Marching Squares O(k+n)
Running time (seconds)
Quadtree
O(k*Log(n/k))
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 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,5}
Root node 1 2 3 2 3 4
Grid
{1,3}
{2,4}
{2,4}
{3,5}
Level-1 nodes
(leaves)
Quadtree 3 4 5

16. Quadtrees (2D) Tree building: bottom-up
{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 {min, max} 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
buildSubTree (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 = buildSubTree (lowX, lowY, len/2)
c2 = buildSubTree (lowX + len/2, lowY, len/2)
c3 = buildSubTree (lowX, lowY + len/2, len/2)
c4 = buildSubTree (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 buildSubTree (1, 1, 2^Ceiling[Log[2,len]])

18. Quadtrees (2D) Tree-building: time complexity? Pre-computation O(n)
We only need to do this once (after that, the tree can be used to speed up contouring at any iso-value)

19. Quadtrees (2D) Contouring with a quadtree: top-down
{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
{1,3}
{2,4}
{3,5}
Leaf nodes 1 2 3 4 5
Grid

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
ctSubTree (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)
ctSubTree (c1, iso, lowX, lowY, len/2)
ctSubTree (c2, iso, lowX + len/2, lowY, len/2)
ctSubTree (c3, iso, lowX, lowY + len/2, len/2)
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 len
ctSubTree (Root, iso, 1, 1, 2^Ceiling[Log[2,len]])

21. Quadtrees (2D) Contouring with a quadtree: time complexity?
O(k*Log(n/k))
Faster than O(k+n) (Marching Squares) if k<<n
But not efficient when k is large (can be as slow as O(n))

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

23. Quadtrees (2D): Summary
Preprocessing: building the tree bottom-up
Independent of iso-values
Contouring: traversing the tree top-down
For a specific iso-value
Both are recursive algorithms

24. Octrees (3D) Each tree node has 8 children nodes
Similar algorithms and same complexity as quadtrees

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/k))
Interval trees
An optimal data structure for range finding
Complexity: O(k+Log(n))

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
255
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 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

28. Interval Trees Interval tree: Intervals: δ=7 δ=4 δ=10 δ=12
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:
AL: m
DR: m
δ=4
δ=10
δ=12
Intervals:

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

30. Interval Trees Interval tree: Intervals: δ=7 δ=4 δ=10 δ=12
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
Interval tree:
AL: m
DR: m
δ=4
δ=10
δ=12
Intervals:

31. Interval Trees Interval tree: Intervals: δ=7 δ=4 δ=10 δ=12
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
Interval tree:
AL: m
DR: m
δ=4
δ=10
δ=12
Intervals:

32. Interval Trees Interval tree: Intervals: δ=7 δ=4 δ=10 δ=12
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
Interval tree:
AL: m
DR: m
δ=4
δ=10
δ=12
Intervals:

33. Interval Trees Intersection queries: time complexity? O(k + Log(n))
Much faster than O(k+n) (Marching squares/cubes)

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

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

36. Interval Trees
Interval tree:
Intervals:

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

38. Interval Trees Interval tree: Intervals: δ=7 δ=4 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:

39. Interval Trees Interval tree: Intervals: δ=7 δ=4 δ=10 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:

40. Interval Trees Interval tree: Intervals: δ=7 δ=4 δ=10 δ=12
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:
AL: m
DR: m
δ=4
δ=10
δ=12
Intervals:

41. Interval Trees Tree building: time 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))

42. Interval Trees: Summary
Preprocessing: building the tree top-down
Independent of iso-values
Contouring: traversing the tree top-down
For a specific iso-value
Both are recursive algorithms

43. Further Readings Quadtree/Octrees: Interval trees:
“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)

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
Livnat and Hansen
Gregorski et al.