Transcript AUFLIC: An Accelerated Algorithm for Unsteady Flow Line

AUFLIC: An Accelerated Algorithm for
Unsteady Flow Line Integral Convolution
Zhanping Liu
Robert J. Moorhead II
Visualization Analysis & Imaging Laboratory
MSU / NSF Engineering Research Center
May 27, 2002
Outline
 Introduction
 Vector field visualization
 LIC (Line Integral Convolution)
 UFLIC (Unsteady Flow Line Integral Convolution)
 Key points
 Basic idea
 Pipeline
 AUFLIC (Accelerated UFLIC)




Motivation
Flexible seeding strategy
Dynamic activation-deactivation scheme
Save & reuse pathlines
 Results
 Conclusions
Introduction—Vector Field Visualization
 Vector Field Visualization
 Challenges
Representation: magnitude & direction
Performance:
quality & speed
ROI:
feature extraction & tracking
Complexity:
unstructured grids & unsteady flow
 Methods
 Graphics Based
Hedgehogs:
arrows, wedges & headed lines
Lines:
streamlines, pathlines, streaklines & timelines
Surfaces:
stream-surfaces, stream-ribbons & stream-tubes
Volumes:
 Texture Based
Spot noise
flow volumes
Jark J. Van Wijk, Computer Graphics, 1991.
Line Integral Convolution
Introduction—LIC
(Image courtesy of Mike Chupa, ERC VAIL)
Introduction—LIC
 LIC (Line Integral Convolution)
Presented by Brian Cabral & Leith Caisey Leedom, SigGraph’93.
Low-pass filter noise texture along streamline, exploiting the correlation.
Produce a synthesized image with fine details.
Vector field (wind)
Noise texture (fine sands)
LIC image (pattern)
L
T (  (0)) 
 K ( )T (  ( ))d
L
L
 K ( )d
L
L: kernel length
K: convolution kernel
: streamline
T: noise texture value
Introduction—LIC
 Basic idea
 (  (
0
)
)
 (   0 )
2D Vector
(stream)Line
Integration
Streamlining by
bi-directional
integration
 ( 0 )

Noise texture
O
d
d (  ( ) )
LIC Image
  (  ( ) )
output pixel
value Convolution
N
 (   0 )   ( 0 )   (  ( 0 )) 
T ( P ) 
 T ( p )W
i
i 0
i
N
W
i 0
i
Introduction—LIC
Colored mapped with velocity magnitude (blue: lowest; red: highest)
Introduction—LIC
LIC Animation  shift periodic kernel phase frame by frame
Introduction—LIC
 Variations
 LIC on curvilinear grids Lisa K. Forssell & S. D. Cohen. 1995
 Fast LIC
Detlev Stalling & Hans-Christian Hege. 1995
 Parallel LIC
Detlev Stalling, and et al. 1996
 Multi-frequency LIC
Ming-Hoe Kiu and David C. Banks.1996
 Surface LIC
Christian Teitzel, and et al. 1997
 Oriented LIC
R. Wegenkittl, and et al. 1997
 Enhanced LIC
A. Okada & D. L. Kao. 1997
 Volume LIC
(Dye advection) Han-Wei Shen, and et al. 1996
Victoria Interrante & Chester Grosch. 1997
C. Rezk-Salama, and et al. 1999
Introduction—LIC
 Disadvantage  does not work for unsteady flow field
LIC fails to convey temporal coherence of unsteady flow.
Inter-frame pulsation is introduced to LIC animation.
UFLIC—Key Points
 Key Points
 Available methods for unsteady flow visualization
PLIC
 Vivek Verma, David Kao, and Alex Pang. 1999
Hardware-assisted texture advection
 Bruno Jobard, Gordon Erlebacher, and M. Yousuff Hussaini. 2000
UFLIC: Unsteady Flow Line Integral Convolution
 Han-Wei Shen & David L. Kao. 1997
UFLIC can maintain both spatial and temporal coherence.
 UFLIC vs. LIC
Method
Focus
Strategy
Line
Field
LIC
image-space
oriented
given a pixel in the output image, to locate the
correlated pixels & accept their contributions
streamline
steady
flow
object-space
oriented
given a particle at a time step, to locate on-pathline
particles & scatters its contribution to them
over time
UFLIC
pathline
unsteady
flow
UFLIC—Key Points
 Two principles
 Time Accurate-Value Scattering Scheme
Convolve along pathlines to exploit spatial & temporal correlation
 Texture Feed-Forward Strategy
Advect textures over time to enhance temporal coherence
 One intra-processing
Noise-Jittered High Pass Filtering
 High Pass Filtering
Pass vector direction information forward
 Noise Jittering
Maintain noisy characteristics in the forwarded texture
UFLIC—Basic Idea
 Basic Idea
time step t
Suppose 1 scattering process covers 3 time steps
time step t+2
time step t+1
The the
CURRENT
scattering
process
is now
Continue
value scattering
until
time step
t+4completed.
t+5
……
Now
take
texture
t+1
t+2
as
input
and
Convolve the scattered values and output texture t+3
t+1 as frame t+3.
t+2
t+1.
t+2.
begin
the
new
scattering
process
to
produce
frame
t+2
t+3
DIFFERENT
points
Apply Noise-jittered High Pass Filtering
to texture t+3
t+1
t+2
and then
but in scattering
the SAMEprocess.
pixel
take it as the input texture of the NEXT
DIFFERENT points
Release
Release aa NEW
NEW seed
seed from
from pixel-center
pixel-center
but in the SAME pixel
time step t+3
pathline3
pathline2
pathline1
integrate
locate
release a seed from pixel center
texture t
scatter value
texture t+1
texture t+2
texture t+3
 Pipeline
The duration (in terms of
the number of time steps,
usually = 4) in which a
particle scatters its value
to the succeeding particles
along the pathline
• Bucket
A ring-buffer by which
each pixel saves those
scattered values and the
weights for later
convolution
Feed Texture Forward
• Life span
White Noise
Disk Files(N time steps)
Input Texture
Vector Data Buffer
Time Accurate Value Scattering Process
Always Release New Seeds
Pathline Integration
if within life span
Refresh Convolution Buckets
Bucket Convolution
Noise-Jittered High Pass Filter
Frame
t=t+1
UFLIC—Pipeline
AUFLIC—Motivation
We proposed AUFLIC (Accelerated UFLIC)
 Motivation
 Problem — UFLIC is time consuming
• Pathline integration:
computationally expensive
• Multi-timestep value scattering: more computation needed
• Texture synthesis:
convolution & noise-jittered high pass filtering
Over 90% UFLIC computation time results from pathline integration
 Reason — pathline redundancy
• Always release a new seed from each pixel center at each time-step
• Generally, more than 2 pathlines pass through a pixel simultaneously
• Existing pathlines are not taken into considerations
 Solution — reuse pathlines
• Reuse existing pathlines as many as possible
• Much less integration, the same scattering effect
AUFLIC—Motivation
 Basic idea
time step t+2
time step t+1
time step t
: Scattering process t
: Scattering process t+1
Life span = 3 time steps
time step t+3
: Scattering process t+2
Begin
scattering
process
t to
t+1
t+2
to
produce
frame
frame
t+1saved
t+2 on-pathline point
t+3
Instead,
reuse
this previously
on-pathline
point
Scattering
process
Instead,
tsaved
t+1
isreuse
now
is produce
now
this
completed.
completed.
previously
(NOT
necessarily
thethe
pixel-center)
Convolve
thebegin
scattered
values
and
(NOT
output
necessarily
texture
the
t+1pixel-center)
t+2
as
t+1.
Now,
From
here,
the
to save
on-pathline
on-pathline
points
(pixels)
points
(pixels).
to frame
be t+2.
as the
seed
to scatter
the
pixel
value
DIRECTLY
to the
Apply
Noise-jittered
asreused
High
the seed
Pass
toFiltering
scatter
the
to texture
pixel
value
t+1 and
t+2
DIRECTLY
then
to the
They
saved
will
will
be
be
reused
during
during
scattering
scattering
process
process
t+1,
t+2,
Now
further
advect
the
pathline
ONLY
1
time
step
ahead
time step t+4).
succeedingpoints
(pixels)
along
pathline
take
it as
the
input
succeedingpoints
texture
ofalready-known
the NEXT
(pixels)scattering
along
theprocess.
already-known (to
pathline
For
this
pixel,
NO
need
to the
release
t+2,
t+3,
t+3,
t+4,
……
Save the new on-pathline pointsand let them ACCEPT the scattered value
a new seed from the pixel-centerFor this pixel, NO need to release
a new seed from the pixel-center
pathline
integrate
locate
release a seed from pixel center
texture t
scatter value
texture t+1
texture t+2
texture t+3
AUFLIC—Flexible Seeding Strategy
 Flexible Seeding Strategy
 How flexible a seed particle can be?
• Freely positioned
It is NOT necessarily located exactly on the pixel center.
Whatever particle within the pixel qualifies for scattering the pixel value.
• Possibly extracted
A seed may be extracted from the existing pathlines used during the
previous scattering processes.
A scattering process: the procedure in which a seed particle scatters
its value within its whole life span covering several (4) time steps.
• Adaptively released
A new seed is released when no extracted seed for the pixel is available.
Condition: ALL pixels seeded
At each time step, there is at least 1 seed from each pixel to scatter value.
AUFLIC—Flexible Seeding Strategy
 How old a pathline can be?
• UFLIC pathlines die younger
An UFLIC pathline is forcibly terminated as soon as the life span expires.
The life span is usually set to 4 time steps.
• AUFLIC pathlines live older
An AUFLIC pathline will NOT stop its advection until:
 it reaches the flow field boundaries
 it meets a critical point
 it is deactivated by the Dynamic Activation-Deactivation Scheme
• The older, the more reused, the less computation
Older pathlines can be repeatedly used during subsequent scattering
processes without much effort of expensive integration calculation.
AUFLIC—Flexible Seeding Strategy
 Flexible seeding strategy
Large amount of new seeds are cancelled due to those extracted seeds.
Excessive new pathlines’ integration is therefore avoided.
St+2
St
St+1
: the reused pathline
St+3
: the pathlines cancelled
before births
St+4
: the seed actually released from the pixel center at time step t
: the seeds extracted from the existing pathline at time step t+1, t+2, t+3, and t+4, called potential seeds
: the actually cancelled seeds at the pixel-centers
AUFLIC—Dynamic Activation-Deactivation Scheme
 Dynamic Activation-Deactivation Scheme
 Problems
As pathlines are released, reused & advected over time, problems arise:
• Un-evenly distributed pathlines
 Too many potential seeds passing through a pixel simultaneously
scatter the same pixel value
 There are so many pixels NOT visited by any potential seeds
• Excessivly & un-necessarily reused pathlines
 Too many active pathlines inevitably degrade acceleration performance
 No sufficient memory to save the pathlines
AUFLIC—Dynamic Activation-Deactivation Scheme
 Dynamic Activation-Deactivation Scheme
• pixel Mutex — an exclusion flag
 A cleared mutex (= 0): there has been NO active seed from the pixel
A
set mutex (= 1): there has been an active seed from the pixel
• Current-Mutex — whether to release a new seed or NOT
Indicate pixel status during the current scattering process
• Next-Mutex — whether to activate or de-activate a potential seed
Indicate pixel status during the next scattering process
• Dynamically updating Current-Mutex & Next-Mutex
Release new seeds ONLY on REAL demand.
Excessive & un-necessary “potential” seeds are actually cancelled.
The least necessary pathlines are maintained for enough value-scattering.
AUFLIC—Save & Reuse Pathlines
 Save & Reuse Pathlines
During each scattering process, pixels along each pathline are saved in a
pixel-ring-buffer when necessary and N (<= xres×yres) pathlines are
stored in a pathline-list for subsequent access and reuse.
suppose
(Next-Mutex
=pixel
==0),
check
the potential-seed’s
the
pixel’s
Current-Mutex
=flag
0,
the
active
seed
scatters
the
pixel
value Next-Mutex
to the
update all
theCurrent-Mutex
pixel
status
to
refuse
other
pathlines:
=1
(Next-Mutex
=Next-Mutex
=span
0)from
save
the
pathline
&
are
inited
to 0
soif release
a the
new
seed
the
pixel
center
life
just
expires,
succeeding
(pixels)
along the pathline
begin
to
save thepoints
pathline
as the
continues
else
dosave
NOT
save
the pathline
the
tailadvection
seed
NOT saved
time step 0
time step 1
save this part and insert it into the pathline-list
time step 2
time step 3
time step 4
time step 5
life span = 4 time steps
:active seed
:potential seed
:tail seed
scattering process 0 (time step 0 ~ time step 4) works to produce frame 0
:non-seed point
AUFLIC—Save & Reuse Pathlines
 Save & Reuse Pathlines
During each scattering process, pixels along each pathline are saved in a
pixel-ring-buffer when necessary and N (<= xres×yres) pathlines are
stored in a pathline-list for subsequent access and reuse.
check the pixel status
if(Next-Mutex
1)After
delete
the pixels
pathline
from
thescattering
pathline
list
firstly
update
ALL
pixel’s
two Mutex
activate =the= seed
check
the
pixel
flag
ALL
complete
process1,
After
all
pixels
complete
scattering
process
0,
suppose
(Current-Mutex
=
=
1)
the
life
span
just
expires
elseCurrent-Mutex
keep
the
pathline
still
in
the
pathline
list
let
=
Next-Mutex;
to
check
if
a
new
seed
is
needed
if(Current-Mutex
=
=
0)
release
a
new
seed
from
the
pixel
center
convolve
the
pixel-buckets
toto
produce
frame
10to release.
let
the
tail
seed
advect
the
pathline
directly
scatter
the
pixel
value
to
the
already-known
on-pathline
points
(pixels) forward,
convolve
the
pixel-buckets
produce
frame
load the=(Next-Mutex
pathline
information
during
the
last
scattering
process
Suppose
= =to0)
save
this
into
the
existing
pathline
let Next-Mutex
0;
choose
thesaved
lastest
the
FIRST
pathline
pathline
ispart
saved
forinthe
a pixel-ring-buffer
next
scattering
process
else
reuse
the
saved
pathline
information
and begin calculations
to save the new points into the existing pathline
without pathline integration
cut this part and keep the rest still in the pathline
list the updated
pathline in
still
the pathline list
and thekeep
ring-buffer
stay inserted
theinpathline-list
time step 0
time step 1
time step 2
time step 3
time step 4
time step 5
life span = 4 time steps
:active seed
:potential seed
:tail seed
scattering process 0 (time step 0 ~ time step 4) works to produce frame 0
scattering process 1 (time step 1 ~ time step 5) works to produce frame 1
:non-seed point
Results
 Platform
SGI Onyx2 with four 400MHZ MIPS R12000 processors
4GB memory
 2D unsteady flow data sets & parameters
2D Data set
Resolution
Time steps
Life span
Output frames
Pixel ring-buffer size
Weather
576 × 291
41
4 time steps
37
72
Vortex
397 × 397
101
4 time steps
97
72
 Concerns
• Image quality
• Acceleration
• Memory cost
Results—Image Quality
 Image Quality
(A) UFLIC image
weather data set
576 × 291
(B) AUFLIC image
weather data set
576 × 291
Results—Image Quality
(C) UFLIC image
vortex data set
397 × 397
(D) AUFLIC image
vortex data set
397 × 397
Results—Acceleration
 Acceleration
AUFLIC is designed to accelerate the value scattering process in the
UFLIC pipeline. Theoretically, AUFLIC & UFLIC are exactly in the same
speed for pipeline’s other stages.
AUFLIC compared with UFLIC in breakdown of the computation time (in second)
method
data loading
scattering
convolution
filtering
color&output
total
AUFLIC / UFLIC
UFLIC
5.00
635.35
3.77
3.37
1.06
648.55
52.94 %
AUFLIC
4.77
330.35
3.86
3.43
0.93
343.34
(A) weather data; resolution: 576 × 291; life span: 4; 37 frames / 41 time steps; pixel-ring-buffer size: 72.
method
data loading
scattering
convolution
filtering
color&output
total
AUFLIC / UFLIC
UFLIC
13.19
1551.17
9.32
8.42
2.39
1584.49
56.96 %
AUFLIC
12.58
869.89
9.05
8.64
2.35
902.51
(B) vortex data; resolution: 397 × 397; life span: 4; 97 frames / 101 time steps; pixel-ring-buffer size: 72.
Results—Memory Cost
 Memory Cost
 Pathline statistics
AUFLIC
UFLIC
items
released pathlines
1762823
6201792
release
28.42 %
100 %
un-reused pathlines
568155
6201792
reused
pathlines
1194668
reuse
percentage
items
total
method
percentage
reuse times
average reuse times
de-activated pathlines
total
pixels
average pathline length
AUFLIC
UFLIC
released pathlines
3500366
15288073
release
22.90 %
100 %
un-reused pathlines
1263664
15288073
0
reused
pathlines
2236702
0
67.77 %
0%
reuse
percentage
63.90 %
0%
4438969
0
total
11787707
0
3.72
0
average reuse times
5.27
0
561402
0
de-activated pathlines
1511223
0
146728381
309044731
total
357898668
739725898
83.23 pixels
49.83 pixels
average pathline length
102.25 pixels
48.39 pixels
(A) weather data;
resolution: 576 × 291;
life span: 4;
37 frames / 41 time steps; pixel-ring-buffer size: 72.
method
percentage
reuse times
pixels
(B) vortex data;
resolution: 397 × 397;
life span: 4;
97 frames / 101 time steps; pixel-ring-buffer size: 72.
Results—Memory Cost
 Memory consumption for saving pathlines
• Low memory cost
Peak : 80.46MB
• Steady consumption
69.36 ~ 70.86MB
Conclusions
 AUFLIC is proposed to speed up UFLIC computation for
unsteady flow visualization in value scattering process
 Flexible Seeding Strategy  reuse existing pathlines from last scattering process
 Dynamic Activation-Deactivation Scheme  maintain the least necessary pathlines
 No image quality degradation
 Nearly half time saved
 High reuse percentage
 Very low & quite steady memory consumption
 Easily extended to 3D case
 Future work
 Enhanced with feature-driven seeding strategy
 Extended to 3D unsteady flow field
Thank You！