This node defines a mapping from a range of scalar values to a set of color and alpha (inverse of transparency) values.

OIV.LDM.Nodes.SoTransferFunction has no effect on rendering an RGBA volume (OIV.VolumeViz.Nodes.SoVolumeData.m_dataRGBA field contains true). In this case the voxel values are explicitly color values already.

Data range

The range of scalar values is specified by an OIV.LDM.Nodes.SoDataRange node. If the application does not provide an OIV.LDM.Nodes.SoDataRange node, then the full range of the volume's data type is mapped into the color map. This can be appropriate and convenient for 8-bit (byte) data, but is usually incorrect for larger data types, especially float values. For example, DICOM data is normally stored in 16-bit voxels, which would have a default data range of 0..65535 (or -32767..32767 if signed). To get the correct image in this case the application should create an an OIV.LDM.Nodes.SoDataRange node and set the data range to the actual range of data values, for example 0..4095. If the actual range is not known, the min and max values can be queried using the OIV.VolumeViz.Nodes.SoVolumeData getMinMax methods. Note that the minValue and maxValue fields of this node have a different meaning that is described later. An example data-to-color-mapping looks like this:

Color maps

If no transfer function has been specified, VolumeViz rendering nodes automatically use the predefined GRAY color map. In this color map all the color values are 1,1,1 (full white) and the alpha values are a linear ramp from 0 to 1. This can be a useful starting point for volume rendering.

To use one of the predefined color maps, set the OIV.LDM.Nodes.SoTransferFunction.m_predefColorMap to a valid value other than NONE, for example INTENSITY. In this color map the color values are a linear ramp from 0 to 1 and all alpha values are 1 (full opaque). This can be a useful starting point for slice rendering.

To create a custom color map, set the OIV.LDM.Nodes.SoTransferFunction.m_predefColorMap field to NONE, set the OIV.LDM.Nodes.SoTransferFunction.m_colorMapType field to the appropriate type (RGBA is the default and most commonly used), then set the color map values in the OIV.LDM.Nodes.SoTransferFunction.m_colorMap field. The OIV.LDM.Nodes.SoTransferFunction.m_colorMap field contains an array of float values in the range [0,1]. The number of float values needed depends on the colorMapType. It is equal to the number of colors in the color map multiplied by the number of components in each color. An ALPHA color map has one component per color, a LUM_ALPHA (Luminance plus Alpha) color map has two components per color and an RGBA color map has four components per color. For example, for an RGBA color map of length N, there must be 4*N float values in the field.

As usual with SoMF fields, memory is automatically allocated as needed if you set the values one at a time using the Item property.This is convenient, but very inefficient. If you must set values one at a time, use the Count propertyto pre-allocate enough memory for all the float values. There is another reason not to set values one at a time. Changing a value in the colorMap field automatically updates the OIV.LDM.Nodes.SoTransferFunction.m_actualColorMap field on each change. To avoid performance problems, we recommend using the setValues() or setValuesBuffer() method to create the color map.

const int numColors = 256;
float[] colors = new float[4 * numColors];
for (int i = 0; i < numColors; ++i)
{
   float intensity = (numColors - i) / (float)numColors;
   int index = i * 4;
   colors[index] = intensity;
   colors[index + 1] = intensity;
   colors[index + 2] = intensity;
   colors[index + 3] = 1;
}
SoTransferFunction tf = new SoTransferFunction();
tf.predefColorMap.Value = SoTransferFunction.PredefColorMaps.NONE;
tf.colorMap.SetValues(0, colors);

Note that the meaning of the min and max fields in OIV.LDM.Nodes.SoDataRange is quite different than the meaning of the OIV.LDM.Nodes.SoTransferFunction.m_minValue and OIV.LDM.Nodes.SoTransferFunction.m_maxValue fields in OIV.LDM.Nodes.SoTransferFunction. The fields in OIV.LDM.Nodes.SoDataRange specify the range of voxel values that will be mapped into the full color map. But changing the minValue and maxValue fields in OIV.LDM.Nodes.SoTransferFunction "remaps" the color map, compressing the original list of color values into the specified range of entries. Entries outside this range are set to full transparent black (all components zero). This does not affect the mapping of scalar values to the color map, it just modifies the color map. Scalar values in the current data range are still mapped to the full range of color map entries. This is mainly useful if you are using one of the predefined color maps and want to quickly remove low value voxels that represent "noise" in the data or to use the first or last entry in the color map for "undefined" values. Visually the effect can be similar to changing the data range using OIV.LDM.Nodes.SoDataRange, and it is generally faster, but note that remapping effectively reduces the resolution of the color map. In general it's better to change the range of data values mapped into the color map using OIV.LDM.Nodes.SoDataRange.

To modify an existing color map, use the setValues() method (as discussed above) or use the start/finish editing methods. For example:

SoTransferFunction tf . . .
SbNativeArray<float> data = tf.colorMap.StartEditing();
data[0] = 1;
. . .
tf.colorMap.FinishEditing();

The transfer function is associated with the rendering node(s), not the volume data node. So for example it is possible to use one transfer function for volume rendering (OIV.VolumeViz.Nodes.SoVolumeRender) and a different transfer function for slices (e.g. OIV.VolumeViz.Nodes.SoOrthoSlice).

When rendering a single volume, there is only one transfer function active at a time and each rendering node uses the current (i.e. last traversed) transfer function in the traversal state, similar to the way materials apply to polygonal geometry.

The application may switch from one transfer function to a different one. For example, by putting multiple transfer functions under an OIV.Inventor.Nodes.SoSwitch node. The application may also dynamically modify the contents of a transfer function, even if using a predefined color map. See the OIV.LDM.Nodes.SoTransferFunction.m_colorMap and OIV.LDM.Nodes.SoTransferFunction.m_actualColorMap fields.

When combining multiple volumes using OIV.LDM.Nodes.SoMultiDataSeparator and OIV.VolumeViz.Nodes.SoVolumeShader it is possible to specify multiple transfer functions. All the transfer functions under the OIV.LDM.Nodes.SoMultiDataSeparator will be available to the shader program based on their OIV.LDM.Nodes.SoTransferFunction.m_transferFunctionId. The application should assign a unique id to each transfer function. See the description of the OIV.LDM.Nodes.SoTransferFunction.m_transferFunctionId field for more details.

When using volume masks (OIV.VolumeViz.Nodes.SoVolumeMask and OIV.VolumeViz.Nodes.SoVolumeMaskGroup), the OIV.LDM.Nodes.SoTransferFunction.m_transferFunctionId is also very important. In this case multiple transfer functions, with different id values, may exist in the traversal state simultaneously. Each mask region is only visible if there exists a transfer function with the same id as that region. Traversal order of the transfer functions is not important. Each region, including the original (unmasked) volume, is colored using the transfer function (if any) that has the same id value. See OIV.VolumeViz.Nodes.SoVolumeMask for more details.

It can be convenient to use the same color map for volume rendering and for slice rendering. But typically the volume rendering color map should have transparency (alpha values less than one) and the slice rendering color map should be opaque. It's not actually necessary to create two separate color maps. Set the alphaUse field in the slice node to ALPHA_OPAQUE and the slice will ignore the transparency values in the color map.

Applications are not limited to using an OIV.LDM.Nodes.SoTransferFunction node to specify the data to color mapping. The application can implement its own data to color mapping function in GLSL (OpenGL shader language). Use an OIV.VolumeViz.Nodes.SoVolumeShader node and replace the VVizComputeFragmentColor function. In this case OIV.LDM.Nodes.SoTransferFunction can still be used to load a color map (or maps) on the GPU, if desired, but the actual assignment of a color is done by the application's shader function.

More about data mapping

We have discussed above the basic concept of mapping scalar values to color values. Here we present more details, which may be important in some cases, for example when rendering a label volume. The way scalar values are mapped to indices in the color map depends on:

• The volume data type (OIV.VolumeViz.Nodes.SoVolumeData),

• The data range (OIV.LDM.Nodes.SoDataRange),

• The texture precision (OIV.VolumeViz.Nodes.SoVolumeData), and

• The color map size (OIV.LDM.Nodes.SoTransferFunction).

We have discussed all of these previously except for texture precision. The texturePrecision field of OIV.VolumeViz.Nodes.SoVolumeData effectively specifies the GPU data type, in other words the size (in bits) of the data values stored on the GPU. The default is 8 (1 byte), but VolumeViz also supports 16. Effectively a volume data value is normalized in the specified data range (OIV.LDM.Nodes.SoDataRange) then converted to a GPU data value in the range of values supported by the GPU data type (default 0..255). For 8-bit (byte) volume data this is a one-to-one mapping. For larger data types it is possible that more than one volume data value will map to the same GPU data value (value aliasing). During rendering the GPU data value is normalized to the number of entries in the color map then converted to an index into the list of colors. For 8-bit (byte) data, if the color map contains 256 entries, this is also a one-to-one mapping. But note that the GPU data values are usually interpolated before this step (see the interpolation field in, for example, OIV.VolumeViz.Nodes.SoVolumeRender).

The data values may also be explicitly rescaled before mapping onto the color map, using the OIV.LDM.Nodes.SoTransferFunction.m_shift and OIV.LDM.Nodes.SoTransferFunction.m_offset fields.

Label volumes

A label volume, also known as a label field, is usually the result of doing some sort of segmentation on a data volume. Each voxel value is an integer label (id) identifying which material, object, etc. that the voxel belongs to. There could be 100's or 1000's of labels, but there might be as few as 8 label values. For example, a simple label volume might have 7 opaque materials plus plus an "exterior" material that is completely transparent. Conceptually, there is one big difference between a (typical) data volume and a label volume. A data volume is conceptually a set of discrete samples taken from a continuous scalar field. So we know the exact value at the center of each voxel and interpolate between those values to get the value at any position in between voxels. In a label volume we normally consider each voxel to belong completely to one material, so the value is constant until we cross the boundary into the next voxel. Therefore we do not want to interpolate the label values. When rendering a label volume with volume rendering, set the shape node's interpolation field to NEAREST and leave the preintegrated field set to false (OIV.VolumeViz.Nodes.SoVolumeRenderingQuality). If rendering isosurfaces, set the segmentedInterpolation field to true (OIV.VolumeViz.Nodes.SoVolumeRenderingQuality).

It is also important to set the data range, texture precision and color map size carefully. In particular, take care that the number of values in the data range and the number of entries in the color map are exactly equal and a "power of 2" (8, 16, 32, ...). For example, if you have 6 label values, you might (logically) set the data range to 0..5 (min = 0 and max = 5) and create a label color map with 6 color values. That will work most of the time, but in a some cases (that are difficult to predict), loss of precision in the mapping arithmetic can cause a data value to map to the wrong color. In the previous example, with 6 label values, we recommend setting the data range to 0..7 and creating a color map with 8 color values (the last two values can be anything since they will not be used).

If you need more than 256 label values (this is not common, but it is possible), follow the above recommendation and also set the texturePrecision field to 16 (the default is 8). This ensures that each label value maps to a unique GPU data value. For example, if you have 1000 labels, we recommond setting the data range to 0..1024, setting texturePrecision to 16 and creating a color map with 1024 color values.

Finally, if you're rendering a label volume and you want to "remove" one of the materials (i.e. make it invisible), you cannot do this in the usual data volume way by modifying the data range in the OIV.LDM.Nodes.SoDataRange node or changing the min/max values in the OIV.LDM.Nodes.SoTransferFunction node. Doing either of those change will cause label values to map to different colors. Instead you should directly modify the values in the color map. In other words, for the color entry corresponding to the material id, change the Alpha value to zero.

Faux shading

This node also supports a "faux shading" technique that can produce results somewhat similar to surface shading without the performance penalty for computing lighting. Faux shading modifies the lower portion of the color map so that color and opacity ramp down to zero. Faux shading is controlled by the OIV.LDM.Nodes.SoTransferFunction.m_fauxShadingLength, OIV.LDM.Nodes.SoTransferFunction.m_fauxShadingStrength, and OIV.LDM.Nodes.SoTransferFunction.m_fauxShadingDarkenThreshold fields.

No Faux Shading	Faux Shading

The OIV.LDM.Nodes.SoTransferFunction.m_actualColorMap field always contains the actual color values (after remapping, faux shading, etc have been applied) that will be used for rendering.

LIMITATIONS

• Maximum color map size. In the most common case the volume contains scalar data values, scalar values are loaded on the GPU and the color map is applied on the GPU. In this case the color map size (number of colors) cannot be larger than the OpenGL maximum texture size. (Because the color map is stored in an OpenGL texture.) This value is generally 16384 on modern GPUs. Use the OpenGL function glGetIntegerv(GL_MAX_TEXTURE_SIZE) to get this value if necessary. If it is necessary to use a larger color map, set the usePalettedTexture field to false in the OIV.VolumeViz.Nodes.SoVolumeData node. In this case the color map is applied on the CPU and RGBA values are loaded on the GPU. The color map can be any size. However rendering may be different because the GPU will interpolate between color values rather than data values and modifying the color map will be much slower because data must be reloaded on the GPU.

• Node order: When using an OIV.VolumeViz.Nodes.SoVolumeGroup, the OIV.LDM.Nodes.SoTransferFunction node must be inserted after the OIV.VolumeViz.Nodes.SoVolumeData, not before.

• Shape nodes: This node only affects VolumeViz shape nodes (OIV.VolumeViz.Nodes.SoVolumeRender, OIV.VolumeViz.Nodes.SoOrthoSlice, OIV.VolumeViz.Nodes.SoObliqueSlice, OIV.VolumeViz.Nodes.SoVolumeSkin, etc). For Open Inventor nodes see OIV.Inventor.Nodes.SoColorMap.

• Multi-volume combining When using OIV.LDM.Nodes.SoMultiDataSeparator, all transfer functions must have the same 'colorMapType' and must have the same number of entries.

• Old graphics boards: On very old graphics boards, modifying the color map when using RGBA (not paletted) textures will usually force the textures to be recreated, which may be slow. See the OIV.VolumeViz.Nodes.SoVolumeData.m_usePalettedTexture field of OIV.VolumeViz.Nodes.SoVolumeData.

FILE FORMAT/DEFAULT

TransferFunction {

shift	0
offset	0
predefColorMap	NONE
colorMapType	RGBA
colorMap	0
actualColorMap	0
transferFunctionId	0
minValue	0
maxValue	255
fauxShadingStrength	1
fauxShadingLength	0
fauxShadingDarkenThreshold	1

}

ACTION BEHAVIOR

OIV.Inventor.Actions.SoCallbackAction, OIV.Inventor.Actions.SoGLRenderAction Sets transfer function parameters in the traversal state.

Reference