
 Usage

vtkHAVSVolumeMapper is a class that renders polygonal data
(represented as an unstructured grid) using the Hardware-
Assisted Visibility Sorting (HAVS) algorithm. First the
unique triangles are sorted in object space, then they are
sorted in image space using a fixed size A-buffer
implemented on the GPU called the k-buffer. The HAVS
algorithm excels at rendering large datasets quickly. The
trade-off is that the algorithm may produce some rendering
artifacts due to an insufficient k size (currently 2 or 6 is
supported) or read/write race conditions.
A built in level-of-detail (LOD) approach samples the
geometry using one of two heuristics (field or area). If LOD
is enabled, the amount of geometry that is sampled and
rendered changes dynamically to stay within the target frame
rate. The field sampling method generally works best for
datasets with cell sizes that don't vary much in size. On
the contrary, the area sampling approach gives better
approximations when the volume has a lot of variation in
cell size.
The HAVS algorithm uses several advanced features on
graphics hardware. The k-buffer sorting network is
implemented using framebuffer objects (FBOs) with multiple
render targets (MRTs). Therefore, only cards that support
these features can run the algorithm (at least an ATI 9500
or an NVidia NV40 (6600)).
.SECTION Notes
Several issues had to be addressed to get the HAVS algorithm
working within the vtk framework. These additions forced the
code to forsake speed for the sake of compliance and
robustness.
The HAVS algorithm operates on the triangles that compose
the mesh. Therefore, before rendering, the cells are
decomposed into unique triangles and stored on the GPU for
efficient rendering. The use of GPU data structures is only
recommended if the entire geometry can fit in graphics
memory. Otherwise this feature should be disabled.
Another new feature is the handling of mixed data types
(eg., polygonal data with volume data). This is handled by
reading the z-buffer from the current window and copying it
into the framebuffer object for off-screen rendering. The
depth test is then enabled so that the volume only appears
over the opaque geometry. Finally, the results of the off-
screen rendering are blended into the framebuffer as a
transparent, view-aligned texture.
Instead of using a preintegrated 3D lookup table for storing
the ray integral, this implementation uses partial pre-
integration. This improves the performance of dynamic
transfer function updates by avoiding a costly preprocess of
the table.
A final change to the original algorithm is the handling of
non-convexities in the mesh. Due to read/write hazards that
may create undesired artifacts with non-convexities when
using a inside/outside toggle in the fragment program,
another approach was employed. To handle non-convexities,
the fragment shader determines if a ray-gap is larger than
the max cell size and kill the fragment if so. This
approximation performs rather well in practice but may miss
small non-convexities.
For more information on the HAVS algorithm see:
"Hardware-Assisted Visibility Sorting for Unstructured
Volume Rendering" by S. P. Callahan, M. Ikits, J. L. D.
Comba, and C. T. Silva, IEEE Transactions of Visualization
and Computer Graphics; May/June 2005.
For more information on the Level-of-Detail algorithm, see:
"Interactive Rendering of Large Unstructured Grids Using
Dynamic Level-of-Detail" by S. P. Callahan, J. L. D. Comba,
P. Shirley, and C. T. Silva, Proceedings of IEEE
Visualization '05, Oct. 2005.
.SECTION Acknowledgments
This code was developed by Steven P. Callahan under the
supervision of Prof. Claudio T. Silva. The code also
contains contributions from Milan Ikits, Linh Ha, Huy T. Vo,
Carlos E. Scheidegger, and Joao L. D. Comba.
The work was supported by grants, contracts, and gifts from
the National Science Foundation, the Department of Energy,
the Army Research Office, and IBM.
The port of HAVS to VTK and ParaView has been primarily
supported by Sandia National Labs.
To create an instance of class vtkHAVSVolumeMapper, simply
invoke its constructor as follows

    obj = vtkHAVSVolumeMapper



 Methods

The class vtkHAVSVolumeMapper 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 vtkHAVSVolumeMapper class.

* string = obj.GetClassName ()
* int = obj.IsA (string name)
* vtkHAVSVolumeMapper = obj.NewInstance ()
* vtkHAVSVolumeMapper = obj.SafeDownCast (vtkObject o)
* obj.SetPartiallyRemoveNonConvexities (bool ) - regions by
  removing ray segments larger than the max cell size.
* bool = obj.GetPartiallyRemoveNonConvexities () - regions
  by removing ray segments larger than the max cell size.
* obj.SetLevelOfDetailTargetTime (float ) - Set/get the
  desired level of detail target time measured in frames/
  sec.
* float = obj.GetLevelOfDetailTargetTime () - Set/get the
  desired level of detail target time measured in frames/
  sec.
* obj.SetLevelOfDetail (bool ) - Turn on/off level-of-detail
  volume rendering
* bool = obj.GetLevelOfDetail () - Turn on/off level-of-
  detail volume rendering
* obj.SetLevelOfDetailMethod (int ) - Set/get the current
  level-of-detail method
* int = obj.GetLevelOfDetailMethod () - Set/get the current
  level-of-detail method
* obj.SetLevelOfDetailMethodField () - Set/get the current
  level-of-detail method
* obj.SetLevelOfDetailMethodArea () - Set the kbuffer size
* obj.SetKBufferSize (int ) - Set the kbuffer size
* int = obj.GetKBufferSize () - Set the kbuffer size
* obj.SetKBufferSizeTo2 () - Set the kbuffer size
* obj.SetKBufferSizeTo6 () - Check hardware support for the
  HAVS algorithm. Necessary features include off-screen
  rendering, 32-bit fp textures, multiple render targets,
  and framebuffer objects. Subclasses must override this
  method to indicate if supported by Hardware.
* bool = obj.SupportedByHardware () - Set/get whether or not
  the data structures should be stored on the GPU for better
  peformance.
* obj.SetGPUDataStructures (bool ) - Set/get whether or not
  the data structures should be stored on the GPU for better
  peformance.
* bool = obj.GetGPUDataStructures () - Set/get whether or
  not the data structures should be stored on the GPU for
  better peformance.


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

