cse 554 lecture 5 contouring faster
Download
Skip this Video
Download Presentation
CSE 554 Lecture 5: Contouring (faster)

Loading in 2 Seconds...

play fullscreen
1 / 45

CSE 554 Lecture 5: Contouring (faster) - PowerPoint PPT Presentation


  • 109 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' CSE 554 Lecture 5: Contouring (faster)' - felicia-clay


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
review
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

efficiency
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
marching squares revisited
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

marching squares revisited1
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

speeding up contouring
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))
interval trees
Interval Trees

Marching Squares O(n+k)

Running time (seconds)

Quadtree

O(k*Log(n))

Interval tree

O(k+Log(n))

Iso-value

speeding up contouring1
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))
quadtrees 2d
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.
quadtrees 2d1
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}

quadtrees 2d2
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}

quadtrees 2d3
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}

quadtrees 2d4
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}

quadtrees 2d5
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}

quadtrees 2d6
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

quadtrees 2d7
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

quadtrees 2d8
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]])

quadtrees 2d9
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

quadtrees 2d10

{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

quadtrees 2d11
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]])

quadtrees 2d12

{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

quadtrees 2d13
Quadtrees (2D)

Marching Squares O(n+k)

Running time (seconds)

Quadtree

O(k*Log(n))

Iso-value

quadtrees 2d summary
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))
octrees 3d overview
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))
speeding up contouring2
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))
interval trees1

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

interval trees2
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
interval trees3
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:

interval trees4
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))
interval trees5
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).
interval trees6
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:

interval trees7
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:

interval trees8
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:

interval trees9
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)
interval trees10
Interval Trees

Marching Squares O(n+k)

Running time (seconds)

Quadtree

O(k*Log(n))

Interval tree

O(k+Log(n))

Iso-value

interval trees11
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
interval trees12
Interval Trees

Interval tree:

Intervals:

interval trees13
Interval Trees

AL: d,e,f,g,h,i

DR: i,e,g,h,d,f

δ=7

Interval tree:

Intervals:

interval trees14
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:

interval trees15
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:

interval trees16
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:

interval trees17
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 
interval trees summary
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))
further readings
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)
further readings1
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.

ad