SoFenceSlice Class Reference
[Nodes]

Fence slice shape node. More...

#include <VolumeViz/nodes/SoFenceSlice.h>

Inheritance diagram for SoFenceSlice:

Public Types
enum	Axis { X, Y, Z }
Public Member Functions
virtual SoType	getTypeId () const
	SoFenceSlice ()
virtual bool	intersect (SoLDMNodeFrontManager *nfm, const SoLDMTileID &tileId)
Static Public Member Functions
static SoType	getClassTypeId ()
static SbBool	isSupported (SoState *state=NULL)
Public Attributes
SoMFVec2f	points
SoSFEnum	axis

Detailed Description

Fence slice shape node.

This node renders a strip (connected series) of slices. The strip is defined by a set of 2D vertices that form a polyline. Each segment of the polyline is extruded along the axis specified in the axis field to form (in effect) an oblique slice. The default axis is Z, so the 2D points are treated as (X,Y) values. The points may be outside the 3D extent of the volume, but only the portion of the slice inside the volume will be drawn (subject to region of interest and other clipping nodes).

A similar effect could be obtained using volume geometry (e.g. SoVolumeFaceSet), but SoFenceSlice is more convenient and is optimized for this specific case.

The 2D coordinates are interpreted according to the following table. See the code example below.

Fence axis	Coordinate axes
X	Y , Z
Y	Z , X
Z	X , Y

For a non-RGBA (scalar valued) volume, each voxel's RGBA value is determined by the current SoDataRange and SoTransferFunction. The current diffuse color and transparency (set, for example, with an SoMaterial node) modify the appearance of the slice. This means that, for example, the current transparency can be used as a global alpha value to modulate the overall opacity of the slice. For an RGBA volume each voxel's RGBA value comes directly from the volume data.

The interpolation field controls how the texture is interpolated.

The alphaUse field (SoSlice) controls how the voxel's alpha component is used when drawing the fence slice.

Optionally a bump mapping effect may be applied. Normal vectors are automatically computed from the data value gradient. The enableBumpMapping and bumpScale fields (SoSlice) control whether bump mapping is active and the intensity of the effect.

Notes:

Transformation matrices:
The volume size and orientation (like geometry) can be modified by transformation nodes in the scene graph and this in turn modifies the appearance of volume visualization nodes. However the same transformation must be applied to the volume data node and all volume visualization nodes associated with that volume. So effectively any transformation nodes that affect the volume must be placed before the volume data node.

Picking:
The entire slice is pickable, even where it is transparent as a result of the current transfer function. Currently SoFenceSlice does not provide an SoDetail object.

Interpolation:
Interpolation is specified using the interpolation field. The default (LINEAR) does bi-linear interpolation between voxel values. The NEAREST value can be used to display individual voxels. For best image quality we recommend using the MULTISAMPLE_12 value.

Data range:
By default VolumeViz maps the entire range of the voxel's data type (e.g. 0..65535 for unsigned short) into the colormap. This is often correct for byte (8 bit) voxels, but seldom correct for 16 bit voxels and never correct for floating point voxels. Use an SoDataRange node to specify the actual (or desired) range of data values to be mapped. Also use an SoDataRange node to implement brightness/contrast control like the Window/Level setting commonly used with medical images.

Clipping:
Volume primitives can be clipped using a region of interest (SoROI), geometry (SoVolumeClippingGroup) and/or height fields (SoUniformGridClipping). They are also clipped by OpenGL clipping planes (SoClipPlane), but we recommend using the VolumeViz clipping nodes instead.

Material:
The color of each voxel is modulated by the current diffuse color in the traversal state. The default diffuse color is 0.8,0.8,0.8. This results in full intensity values in the color map being displayed as 80% intensity. Therefore we recommend adding an SoMaterial node before the slice and setting its diffuseColor field to full white (1,1,1).

Transparency:
- Typically the color map (SoTransferFunction) used for volume rendering (SoVolumeRender) assigns transparency (alpha < 1) to some voxel values. If you want to use the same color map for slice rendering, but render the slice completely opaque, set the alphaUse field to ALPHA_OPAQUE. This overrides the alpha values in the color map (or an RGBA volume). However it does not affect transparency assigned using an SoMaterial node.
- If you want to adjust the overall transparency of the slice, add an SoMaterial node and set its transparency field (keeping alphaUse set to ALPHA_AS_IS). Effectively a scale factor 1-transparency is applied to each voxel's alpha value.
- Intersecting transparent slices cannot be rendered correctly by the basic blending transparency algorithms. To render this case correctly, set the transparency algorithm to SORTED_PIXELS_BLEND (or similar value) using the viewer class or SoGLRenderAction.

Voxel edges:
The edges of the voxels can also be rendered. See options in the SoVolumeRenderingQuality node.

Custom shaders:
The current SoVolumeShader node, if any, allows custom shaders to be defined for special computation or rendering effects, including blending multiple volumes.

Performance:
- Tile size:
  For backward compatibility, the default tile size is still only 64. This is quite small for modern CPU/GPU hardware. The smaller the tile size, the larger the total number of tiles that must be managed by VolumeViz. This overhead can be significant, especially for operations that require reloading the data textures on the GPU, for example, changing the data range (SoDataRange). For smaller volumes, like 512^3, it can be efficient to set the tile size large enough to contain the entire volume. For very large volumes, larger tile sizes are efficient for SoVolumeRender but somewhat inefficient for slice rendering because complete tiles must be loaded even though the slice only uses part of the data. Applications should experiment.
  For volumes stored in LDM file format, the tile size must be specified when the volume is converted to LDM (see SoConverter and the "-t" option). For other data data formats the tile size can be specified using the SoVolumeData node's ldmResourceParameters field, but only after setting the filename field or calling the setReader() method.
- LDM_USE_IN_MEM_COMPRESSION
  VolumeViz always manages data as "tiles", regardless of the data format. In many cases VolumeViz must create (or uncompress) the tiles at run time. These cases include in-memory volumes, any volume reader that does not implement the readTile() method (this includes all built-in formats except LDM, e.g. DICOM, SEGY, ...) and compressed LDM format files. If this variable is true (the default), VolumeViz only keeps a small cache of created/uncompressed tiles in CPU memory. If a tile's data is needed and that tile is not in the cache, the tile must be recreated. This overhead can be significant, especially for operations that require recreating all the data textures on the GPU, for example changing the data range (SoDataRange). We recommend setting this variable to false (see SoPreferences) unless saving CPU memory is critical.

Hardware requirements:
This node needs a graphic card with support for GLSL shader, vertex buffer objects (VBO) and framebuffer object (FBO). Use the isSupported() method to check if the current graphics board can render a FenceSlice.

EXAMPLE

   SoFenceSlice* pFenceSlice = new SoFenceSlice;
     pFenceSlice->axis = SoFenceSlice::Y;
     pFenceSlice->points.set1Value( 0, SbVec2f(-0.2f, -0.66f) );
     pFenceSlice->points.set1Value( 1, SbVec2f( 0.2f, -0.4f ) );
     pFenceSlice->points.set1Value( 2, SbVec2f(-0.2f,  0.4f ) );
     pFenceSlice->points.set1Value( 3, SbVec2f( 0.2f,  0.66f) );

Fence slice on Y axis (Colt example data set):

Fence slice on X axis (Colt example data set):

Fence slice on Z axis (Colt example data set):

FILE FORMAT/DEFAULT

points	[ ]
axis	Z
interpolation	LINEAR
alphaUse	ALPHA_BINARY
useRGBA	FALSE
alternateRep	NULL
enableBumpMapping	FALSE
bumpScale	1.0

ACTION BEHAVIOR

SoGetBoundingBoxAction
Computes the bounding box that encloses the fence slice.

Member Enumeration Documentation

enum SoFenceSlice::Axis

Enumerator:

X
Y
Z	(Default)

Constructor & Destructor Documentation

SoFenceSlice::SoFenceSlice ( )

Constructor.

Member Function Documentation

static SoType SoFenceSlice::getClassTypeId ( ) [static]

Returns the type identifier for this class.

Reimplemented from SoSlice.

virtual SoType SoFenceSlice::getTypeId ( ) const [virtual]

Returns the type identifier for this specific instance.

Reimplemented from SoSlice.

virtual bool SoFenceSlice::intersect	(	SoLDMNodeFrontManager *	nfm,
		const SoLDMTileID &	tileId
	)			`[virtual]`

Returns true if the shape intersects the given tile.

Reimplemented from SoLdmShape.

static SbBool SoFenceSlice::isSupported ( SoState * state = NULL ) [static]

Returns true if graphic card can render an SoFenceSlice.

GPU must support GLSL. When using a debug build of Open Inventor, some "no context available" warning messages may be generated. You can ignore them or see SoGLExtension for an example of using SoGLContext to avoid them.

Member Data Documentation

SoSFEnum SoFenceSlice::axis

Extrusion axis: X, Y, or Z.

Use enum Axis. Default is Z.

SoMFVec2f SoFenceSlice::points

Set of points defining a lineset.

If axis is:

X: points are Y,Z coordinates
Y: points are Z,X coordinates
Z: points are X,Y coordinates

All points should be inside the 3D extent of the volume.

The documentation for this class was generated from the following file:

VolumeViz/nodes/SoFenceSlice.h

SoFenceSlice Class Reference [Nodes]

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes