Usage

This class resorts to GLSL to implement GPU-based Line
Integral Convolution (LIC) for visualizing a 2D vector field
that may be obtained by projecting an original 3D vector
field onto a surface (such that the resulting 2D vector at
each grid point on the surface is tangential to the local
normal, as done in vtkSurfaceLICPainter).
As an image-based technique, 2D LIC works by (1) integrating
a bidirectional streamline from the center of each pixel (of
the LIC output image), (2) locating the pixels along / hit
by this streamline as the correlated pixels of the starting
pixel (seed point / pixel), (3) indexing a (usually white)
noise texture (another input to LIC, in addition to the 2D
vector field, usually with the same size as that of the 2D
vetor field) to determine the values (colors) of these
pixels (the starting and the correlated pixels), typically
through bi-linear interpolation, and (4) performing
convolution (weighted averaging) on these values, by
adopting a low-pass filter (such as box, ramp, and Hanning
kernels), to obtain the result value (color) that is then
assigned to the seed pixel.
The GLSL-based GPU implementation herein maps the
aforementioned pipeline to fragment shaders and a box kernel
is employed. Both the white noise and the vector field are
provided to the GPU as texture objects (supported by the
multi-texturing capability). In addition, there are four
texture objects (color buffers) allocated to constitute two
pairs that work in a ping-pong fashion, with one as the read
buffers and the other as the write / render targets.
Maintained by a frame buffer object
(GL_EXT_framebuffer_object), each pair employs one buffer to
store the current (dynamically updated) position (by means
of the texture coordinate that keeps being warped by the
underlying vector) of the (virtual) particle initially
released from each fragment while using the bother buffer to
store the current (dynamically updated too) accumulated
texture value that each seed fragment (before the 'mesh' is
warped) collects. Given NumberOfSteps integration steps in
each direction, there are a total of (2 * NumberOfSteps + 1)
fragments (including the seed fragment) are convolved and
each contributes 1 / (2 * NumberOfSteps

* 1) of the associated texture value to fulfill the box
  filter.

One pass of LIC (basic LIC) tends to produce low-contrast /
blurred images and vtkLineIntegralConvolution2D provides an
option for creating enhanced LIC images. Enhanced LIC
improves image quality by increasing inter-streamline
contrast while suppressing artifacts. It performs two passes
of LIC, with a 3x3 Laplacian high-pass filter in between
that processes the output of pass #1 LIC and forwards the
result as the input 'noise' to pass #2 LIC. Enhanced LIC
automatically degenerates to basic LIC during user
interaction.
vtkLineIntegralConvolution2D applies masking to zero-vector
fragments so that un-filtered white noise areas are made
totally transparent by class vtkSurfaceLICPainter to show
the underlying geometry surface.
.SECTION Required OpenGL Extensins
GL_ARB_texture_non_power_of_two GL_VERSION_2_0
GL_ARB_texture_float GL_ARB_draw_buffers
GL_EXT_framebuffer_object
To create an instance of class vtkLineIntegralConvolution2D,
simply invoke its constructor as follows

    obj = vtkLineIntegralConvolution2D



 Methods

The class vtkLineIntegralConvolution2D has several methods
that can be used. They are listed below. Note that the
documentation is translated automatically from the VTK
sources, and may not be completely intelligible. When in
doubt, consult the VTK website. In the methods listed below,
obj is an instance of the vtkLineIntegralConvolution2D
class.

* string = obj.GetClassName ()
* int = obj.IsA (string name)
* vtkLineIntegralConvolution2D = obj.NewInstance ()
* vtkLineIntegralConvolution2D = obj.SafeDownCast (vtkObject
  o)
* obj.SetEnhancedLIC (int ) - Enable/Disable enhanced LIC
  that improves image quality by increasing inter-streamline
  contrast while suppressing artifacts. Enhanced LIC
  performs two passes of LIC, with a 3x3 Laplacian high-pass
  filter in between that processes the output of pass #1 LIC
  and forwards the result as the input 'noise' to pass #2
  LIC. This flag is automatically turned off during user
  interaction.
* int = obj.GetEnhancedLIC () - Enable/Disable enhanced LIC
  that improves image quality by increasing inter-streamline
  contrast while suppressing artifacts. Enhanced LIC
  performs two passes of LIC, with a 3x3 Laplacian high-pass
  filter in between that processes the output of pass #1 LIC
  and forwards the result as the input 'noise' to pass #2
  LIC. This flag is automatically turned off during user
  interaction.
* obj.EnhancedLICOn () - Enable/Disable enhanced LIC that
  improves image quality by increasing inter-streamline
  contrast while suppressing artifacts. Enhanced LIC
  performs two passes of LIC, with a 3x3 Laplacian high-pass
  filter in between that processes the output of pass #1 LIC
  and forwards the result as the input 'noise' to pass #2
  LIC. This flag is automatically turned off during user
  interaction.
* obj.EnhancedLICOff () - Enable/Disable enhanced LIC that
  improves image quality by increasing inter-streamline
  contrast while suppressing artifacts. Enhanced LIC
  performs two passes of LIC, with a 3x3 Laplacian high-pass
  filter in between that processes the output of pass #1 LIC
  and forwards the result as the input 'noise' to pass #2
  LIC. This flag is automatically turned off during user
  interaction.
* obj.SetLICForSurface (int )
* int = obj.GetLICForSurface ()
* obj.LICForSurfaceOn ()
* obj.LICForSurfaceOff ()
* obj.SetNumberOfSteps (int ) - Number of streamline
  integration steps (initial value is 1). In term of visual
  quality, the greater (within some range) the better.
* int = obj.GetNumberOfSteps () - Number of streamline
  integration steps (initial value is 1). In term of visual
  quality, the greater (within some range) the better.
* obj.SetLICStepSize (double ) - Get/Set the streamline
  integration step size (0.01 by default). This is the
  length of each step in normalized image space i.e. in
  range [0, 1]. In term of visual quality, the smaller the
  better. The type for the interface is double as VTK
  interface is, but GPU only supports float. Thus it will be
  converted to float in the execution of the algorithm.
* double = obj.GetLICStepSizeMinValue () - Get/Set the
  streamline integration step size (0.01 by default). This
  is the length of each step in normalized image space i.e.
  in range [0, 1]. In term of visual quality, the smaller
  the better. The type for the interface is double as VTK
  interface is, but GPU only supports float. Thus it will be
  converted to float in the execution of the algorithm.
* double = obj.GetLICStepSizeMaxValue () - Get/Set the
  streamline integration step size (0.01 by default). This
  is the length of each step in normalized image space i.e.
  in range [0, 1]. In term of visual quality, the smaller
  the better. The type for the interface is double as VTK
  interface is, but GPU only supports float. Thus it will be
  converted to float in the execution of the algorithm.
* double = obj.GetLICStepSize () - Get/Set the streamline
  integration step size (0.01 by default). This is the
  length of each step in normalized image space i.e. in
  range [0, 1]. In term of visual quality, the smaller the
  better. The type for the interface is double as VTK
  interface is, but GPU only supports float. Thus it will be
  converted to float in the execution of the algorithm.
* obj.SetNoise (vtkTextureObject noise) - Set/Get the input
  white noise texture (initial value is NULL).
* vtkTextureObject = obj.GetNoise () - Set/Get the input
  white noise texture (initial value is NULL).
* obj.SetVectorField (vtkTextureObject vectorField) - Set/
  Get the vector field (initial value is NULL).
* vtkTextureObject = obj.GetVectorField () - Set/Get the
  vector field (initial value is NULL).
* obj.SetComponentIds (int , int ) - If VectorField has >= 3
  components, we must choose which 2 components form the (X,
  Y) components for the vector field. Must be in the range
  [0, 3].
* obj.SetComponentIds (int a[2]) - If VectorField has >= 3
  components, we must choose which 2 components form the (X,
  Y) components for the vector field. Must be in the range
  [0, 3].
* int = obj. GetComponentIds () - If VectorField has >= 3
  components, we must choose which 2 components form the (X,
  Y) components for the vector field. Must be in the range
  [0, 3].
* obj.SetGridSpacings (double , double ) - Set/Get the
  spacing in each dimension of the plane on which the vector
  field is defined. This class performs LIC in the
  normalized image space and hence generally it needs to
  transform the input vector field (given in physical space)
  to the normalized image space. The Spacing is needed to
  determine the tranform. Default is (1.0, 1.0). It is
  possible to disable vector transformation by setting
  TransformVectors to 0.
* obj.SetGridSpacings (double a[2]) - Set/Get the spacing in
  each dimension of the plane on which the vector field is
  defined. This class performs LIC in the normalized image
  space and hence generally it needs to transform the input
  vector field (given in physical space) to the normalized
  image space. The Spacing is needed to determine the
  tranform. Default is (1.0, 1.0). It is possible to disable
  vector transformation by setting TransformVectors to 0.
* double = obj. GetGridSpacings () - Set/Get the spacing in
  each dimension of the plane on which the vector field is
  defined. This class performs LIC in the normalized image
  space and hence generally it needs to transform the input
  vector field (given in physical space) to the normalized
  image space. The Spacing is needed to determine the
  tranform. Default is (1.0, 1.0). It is possible to disable
  vector transformation by setting TransformVectors to 0.
* obj.SetTransformVectors (int ) - This class performs LIC
  in the normalized image space. Hence, by default it
  transforms the input vectors to the normalized image space
  (using the GridSpacings and input vector field
  dimensions). Set this to 0 to disable tranformation if the
  vectors are already tranformed.
* int = obj.GetTransformVectorsMinValue () - This class
  performs LIC in the normalized image space. Hence, by
  default it transforms the input vectors to the normalized
  image space (using the GridSpacings and input vector field
  dimensions). Set this to 0 to disable tranformation if the
  vectors are already tranformed.
* int = obj.GetTransformVectorsMaxValue () - This class
  performs LIC in the normalized image space. Hence, by
  default it transforms the input vectors to the normalized
  image space (using the GridSpacings and input vector field
  dimensions). Set this to 0 to disable tranformation if the
  vectors are already tranformed.
* obj.TransformVectorsOn () - This class performs LIC in the
  normalized image space. Hence, by default it transforms
  the input vectors to the normalized image space (using the
  GridSpacings and input vector field dimensions). Set this
  to 0 to disable tranformation if the vectors are already
  tranformed.
* obj.TransformVectorsOff () - This class performs LIC in
  the normalized image space. Hence, by default it
  transforms the input vectors to the normalized image space
  (using the GridSpacings and input vector field
  dimensions). Set this to 0 to disable tranformation if the
  vectors are already tranformed.
* int = obj.GetTransformVectors () - This class performs LIC
  in the normalized image space. Hence, by default it
  transforms the input vectors to the normalized image space
  (using the GridSpacings and input vector field
  dimensions). Set this to 0 to disable tranformation if the
  vectors are already tranformed.
* obj.SetMagnification (int ) - The the magnification factor
  (default is 1.0).
* int = obj.GetMagnificationMinValue () - The the
  magnification factor (default is 1.0).
* int = obj.GetMagnificationMaxValue () - The the
  magnification factor (default is 1.0).
* int = obj.GetMagnification () - The the magnification
  factor (default is 1.0).
* obj.SetVectorShiftScale (double shift, double scale) -
  Returns if the context supports the required extensions.
* int = obj.Execute () - Perform the LIC and obtain the LIC
  texture. Return 1 if no error.
* int = obj.Execute (int extent[4]) - Same as Execute()
  except that the LIC operation is performed only on a
  window (given by the extent) in the input VectorField. The
  extent is relative to the input VectorField. The output
  LIC image will be of the size specified by extent.
* int = obj.Execute (int extent[4]) - Same as Execute()
  except that the LIC operation is performed only on a
  window (given by the extent) in the input VectorField. The
  extent is relative to the input VectorField. The output
  LIC image will be of the size specified by extent.
* obj.SetLIC (vtkTextureObject lic) - LIC texture (initial
  value is NULL) set by Execute().
* vtkTextureObject = obj.GetLIC () - LIC texture (initial
  value is NULL) set by Execute().


* FreeMat_Documentation
* Visualization_Toolkit_Rendering_Classes
* Generated on Thu Jul 25 2013 17:18:35 for FreeMat by
  doxygen_ 1.8.1.1