Cse 554 lecture 5 contouring faster
This presentation is the property of its rightful owner.
Sponsored Links
1 / 45

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


  • 78 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

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


Cse 554 lecture 5 contouring faster

CSE 554Lecture 5: Contouring (faster)

Fall 2014


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.


  • Login