Release Notes

 

Open Inventor® 9.5.2 (Sept2015) 

Older release notes

The following document contains the release notes for the latest minor release 9.5 (February 2015)

The current service release is 9.5.2. See the bugs fixed section for a complete list of issues resolved for each version. Make sure to read the Compatibility Notes as well. They contain information about important changes in this release.

Finally, check the Life cycle topic for important information about Open Inventor platform support changes in upcoming release.

See below the complete list of enhancements and new features included in Open Inventor 9.5.



Open Inventor 9.5 comes with an important set of new features including: 

  • New CAD Reader supporting more CAD formats, STL export, better performance and PMI import

  • New flexible render area for developing custom viewers

  • New nodes to support multiple instances and GPU generated shapes

This release also includes a lot of improvements to existing features, for example, the support of huge orthoslices and a new class SoFenceSliceDetail in VolumeViz. ImageViz is no longer in beta version and comes with a set of performance improvements and several new operators. 

VisualStudio upgrade

Open Inventor windows package is upgraded to

  • Visual Studio 2012 update 4 (previous was update 3), 
  • Visual Studio 2013 update 4 (previous was update 1),

see System Requirement page for more details. 

Open Inventor

New flexible RenderArea

New classes SoRenderAreaCore and SoEventBuilder to develop new custom RenderArea. Note that these classes are GUI independent.

In the package new examples are available for most parts of the user interface:

  • QT (also Qt 5.4 could be used, see System Requirement for more details)
  • Win32
  • MFC
  • WPF
  • AWT
  • SWT

New examples are provided to show how to use these interface. The examples in 9.5 were modified and a new folder gui was added to collect all new examples objects and libraries.

Open Inventor API modifications include: 

  • Enhancements to SoCameraInteractor and new classes SoEventBuilder and SoRenderAreaCore.
  • New interface SoSystemTimer.  Timer implementations usually depend on the window toolkit used (Qt for C++ API, Awt for Java API, ...). The main use of this class is to expose a common interface for system dependent timers. The timer class allows Inventor to manage its sensors queue (for timers, animation) when creating custom viewers.
  • A new method in Open Inventor was added to set the timer (SoDB::setSystemTimer()).

Modification of classes provided as source code:

  • Enhancements in SceneExaminer.
  • New class SceneInteractor is now the parent class of SceneExaminer.

Other classes provided as source code for each graphic user interface:

  • New Open Inventor C++ Qt viewer components (compatible with QT4 and QT5).
    This example shows how to use following objects:
    • QEventToSoEvent: tool that build OpenInventEvent from Qt event
    • QtTimer: QT implementation of the new interface SoSystemTimer
    • RenderArea: new example implementation of a Qt render area that uses SoRenderAreaCore
    • RenderAreaInteractive: extension of RenderArea that handles Qt events by using the QEventToSoEvent tool and handles Open Inventor timer and animation with the new QtTimer
    • RenderAreaExaminer: extension of RenderAreaInteractive that uses a SceneExaminer as the root of the scene graph

Below there is a diagram of the main classes related to the Qt user interface:

New flexible Render Areas

Blue classes: In Open Inventor API and GUI independent. 

Green classes: GUI dependent and the source code is delivered in the example folder.

  • New Java examples viewer components for AWT using either gl canvas or newt canvas:
    • AWTEventToSoEvent and NewtEventToSoEvent: tools that build Open Inventor events from awt events.
    • RenderArea: new example implementation of a Jogl render area that uses SoRenderAreaCore.
    • RenderAreaInteractive: extension of RenderArea that handles awt events by using either AWTEventToSoEvent or NewtEventToSoEvent tools.
    • RenderAreaExaminer: extension of RenderAreaInteractive that uses a SceneExaminer as root of the scene graph.

New simple examples provided in both Qt and Java/Jogl/AWT: 

  • RenderArea: use a RenderArea to do a static rendering of an SoCone.
  • RenderAreaExaminer: use a RenderAreaExaminer to render an SoCone with camera manipulatation in "examiner" mode.
  • RenderAreaGuiIntegration: like the RenderAreaExaminer example but inserts some gui buttons to load an Open Inventor graph file.

New algebraic shape nodes

Algebraic shapes introduce a new type of shape in Open Inventor that are not defined explicitly by a set of triangles but implicitly by an analytic formula. Implicit surfaces are 2-dimensional surfaces in 3-dimensional space defined as the locus of zeros of a given function. Sphere, cylinder or cone, for example, can be expressed like that, known as a quadric surfaces.

These shapes are computed and rendered on the GPU. A screen-aligned quad (i.e. the screen space bounding box of the shape) is ray-casted to define the displayed shape according to its implicit definition. The main advantage of this approach is a huge improvement in image quality for curved surfaces. These shapes are also drawn in a more efficient way than a geometric approach. Basic shapes: SoAlgebraicSphere, SoAlgebraicCylinder and SoAlgebraicCone are provided in Open Inventor and can be used in place of SoSphere, SoCylinder and SoCone. More complex shapes can be defined using this approach using the SoAlgebraicShape base class.

Below is a preview of the algebraic compared with the related standard shapes (see examples CustomAlgebraicShape and CustomComputeColor in the folder src/Inventor/examples/Features/AlgebraicShape):

Standard SoCone New SoAlgebraicCone SoAlgebraicCone (left) versus SoCone (right)
(Click the image for a better resolution)

Please note that in this release these shapes do not work with some other Open Inventor features like: clip planes, SoTexture2 (texture could be used by user-defined shader such as in CustomComputeColor demo), shape hints SoShapeHints, projection and wireframe visualization (because the shapes are not based on geometry).

The examples are available in C++ interface for all platforms. 

New node to handle multiple instances

A new instantiation node SoMultipleInstance provides an efficient way to render many instances of the same geometry in a scene graph. Each instance can be transformed in space by a predefined set of parameters: position, rotation and scale.

Below is a screenshot of the example MultiInstancingAlgebraicShapes (source code in folder src/Inventor/examples/Features/MultiInstancing) showing interactive rendering of one million algebraic shapes. This example shows how to use algebraic shapes with SoMultipleInstance node and how to customize the instance colors using custom shaders:


Multiple instances of algebraic shape nodes
( click on image to get full resolution)

 

Another example BufferedShapes (demos/MultiInstancingBufferedShape.exe) is available to show how to use the SoBufferedShape node with SoMultipleInstance.


Multiple instances of a complex SoBufferedShape

( click on image to get full resolution)

These examples are available in C++, Java and .NET for all supported platforms. Note that, for this release, only AlgebraicShapes and BufferedShapes are supported by multiple instances.

Anti-aliasing improvements : SMAA and Super Sampling

Open Inventor 9.5 introduces two new algorithms to enhance the quality of the rendering both dynamic than static.
 
  • Quality while keeping interactivity : introducing the SMAA post-rendering algorithm. 
SMAA enhances the existing FXAA algorithm. Like FXAA, SMAA is implemented as a post-rendering effect in Open Inventor. SMAA works well with lines and is less destructive on fonts compared to the existing FXAA method. Main advantages of this technique are reduced memory footprint and cost with a better image quality than the FXAA algorithm, as shown by the following comparison. SMAA give an enhanced quality without any impact on the interactivity. 
 
Comparison shot between FXAA (up) and SMAA (down)
 
 
  • Better quality at higher cost : introducing the Super Sampling algorithm
Open Inventor 9.5 brings also another improvement on anti-aliasing with a modern implementation of accumulation buffers algorithms. Called Super Sampling, this new technique is implemented on GPU with shaders and allow breaking limitations of CPU implementation. It's compatible with all transparency techniques implemented in Open Inventor, takes the gamma in account and runs on all platforms supporting shaders. Illustration below shows the level of quality given by this news algorithm compared to the SMAA.
 
Comparison shot between SMAA (up) and Super Sampling (down)
 
  • From SMAA to Super Sampling : Introducing the setStillSuperSampling new API
 
Because of its low memory cost and footprint and its results far better than FXAA, SMAA is now the new default algorithm for anti-aliasing in Open Inventor 9.5. Of course it's still possible to change manually this default value using the SoSceneManager::setAntialiasing  ( const float  quality, const AntialiasingMode  mode = AUTO) API with the parameter mode set to the desired value according to the enum AntialiasingMode defined in SoSceneManager class.
 
Despite its advantages in terms of rendering quality, the new super sampling algorithm is time-consuming and requires multiple passes to be very efficient. This could unfortunately impact the interactivity and, for this reason, it has not been set by default. But because it can be useful to reach the high level of quality super sampling provides for a final render, a new API has been defined in the SoSceneManager to allow the application switching from SMAA to super sampling when the scene has not been moved for a given elapsed time. With the SoSceneManager::setStillSuperSampling(float quality, float delay) API, any application can define the quality and the delay before the switch occurs.

The first parameter, quality,  defines the wanted quality of anti-aliasing. The value goes from 0 to 1 (0,5 being a typical value, 0 desavctivates the feature). The delay parameter defines the amount of time (in second) after which the scene will be supersampled when no interaction is detected on the scene.  

 

Delayed Sorted and Sorted  Pixels Blend Transparency: from A-Buffer to K-Buffer

In order to bypass the limitations of the A-Buffer algorithm that could lead to rendering artifacts when there is not enough GPU memory, the Delayed Sorted and Sorted Pixels Blend Transparency modes are now based on a K-Buffer algorithm (dual and single pass). Despite the advantage of avoiding rendering artifacts, this algorithm is more GPU intensive and for this reason the number of layers has been reduced, by default, to 4 where it used to be 16 with the previous algorithm. This could, potentially, lead to a difference in the final rendering in some cases. It is possible to increase the number of layers by using the API SoGLrenderAction::setSortedLayerNumPasses with the desired value (8, 16, etc.).

Here are pictures of the same scene rendered with two different values : 4 (up) and 16 layers (down). 

Introducing new CAD features

New CAD Reader features

Open Inventor 9.5 introduces a global rework of the CAD Readers in our product (only for C++ API in this release). First of all, in order to extend the support of CAD files, supported platforms have been extended. The CAD Readers package is now available for Visual Studio 2010, 2012, 2013 with, for each, 32 and 64 bits support. Henceforth the whole package is now entirely provided by just one DLL (provided in the installer), fei.inventor.io.cad.dll, avoiding the need for external libraries and additional package installation. 

This global rework allows Open Inventor to provide a new level of features:

  • Number of supported file formats has been greatly increased as Open Inventor now fully supports:
    CATIA V5 and CATIA V6, IGES, JT, ProE, Solide Edge, STEP, SolidWorks, UG, VDA and parasolid.
    Please note that (as before) a specific licence key is required for each of these formats. 
  • Loading times are drastically reduced
  • CAD Readers now support input parameters allowing the user to adjust the file import. This is done using the new SoCADInputReaderParameters class. It allows the application to activate or not the import of edges, open shell and product and manufacturing information (PMI). It is also possible to choose the level of tessellation either by choosing one of the predefined options (see SoCADInputReaderParameters::setTessellationOption (Quality quality = medium) with quality being LOW, MEDIUM or HIGH) or by setting values with the SoCADInputReaderParameters::TesselationOption() class.

Product Manufacturing Information (PMI) import
(Click on the picture to get a full resolution version)

 The API is available also for NET and soon the JAVA will be added.

STL Export

The global rework of CAD Readers now allows Open Inventor to support the STL file format. Using the new SoSTLWriteAction class, an Open Inventor application can export its scene graph to an STL format file. This feature brings to Open Inventor the opportunity to provide a fully functional workflow compatible with 3D printing from data acquisition to image processing through the final print process.


 

Open Inventor 9.5 also supports reading STL files. The class SoSTLFileFormat exposes needed methods to initialize the format and retrieve useful information, and the SoSTLInputReader class allows to build an Open inventor scene graph from a STL file.

 

VolumeViz

SoVolumeReader and TIFF3D

VolumeViz 9.5 introduces a new volume reader, SoVRTiffFileReader, that allows applications load TIFF3D files (TIFF files containing multiple slices). The reader can be explicitly instantiated by an application to open a TIFF file, but VolumeViz (as for other supported formats) will automatically instanciate this reader based on the filename given to the SoVolumeData nodeIf the file contains images of different sizes, the biggest one is used and only images with this size are loaded.

As for all VolumeViz supported file formats, SoVRTiffFileReader supports single channel (scalar) or UBYTE RGBA images.

SoVRDicomFileReader

Convenience features were added to SoVRDicomFileReader to ease loading DICOM data:

SoVRRasterStackReader

Several optimizations have been made to the VolumeViz stack reader for better performance:
  • Automatically load every file in the directory that is a valid DICOM file: SoVRRasterStackReader::setDirectory(...)
  • Reader is now thread safe, meaning multiple threads can read from the same file (using SoVrRasterStackReader) without any risk of corruption.
  • Memory consumption for reading JPEG 2000 and 3D TIFF image stacks has been drastically reduced. Now only the needed part of the image is accessed, avoiding loading unneeded data and reducing peak memory usage.

SoVRRasterStackReader Memory usage optimization in VolumeViz 9.5

 

Configurable subsampling algorithm for SoVRLdmFileBorderReader

A new API has been added to SoVRLdmFileBorderReader (new reader introduced in Open Inventor 9.4.1) to select the subsampling method to use for building low resolution tiles. DECIMATION (default) and AVERAGE are two different algorithms allowing better interpolation management regarding values in the colormap.

Huge slice support available via SoOrthoSlice

The SoOrthoSlice node is now able to display images much larger than the hardware imposed GL_MAX_TEXTURE_SIZE limit. 

Large slice (60000x30000 ~1716MB) displayed using VolumeViz 9.5

 

SoFenceSliceDetail class to handle ray pick action on SoFenceSlice node.

SoFenceSliceDetail (derived from SoVolumeDetail) returns information about the first (closest) non-transparent voxel along the pick ray and/or information about all the voxels intersected by the pick ray (called a profile). For the first non-transparent voxel (if any) on the pick ray, it returns XYZ position, IJK location, and data value. 

Yellow: two profile points - Green: values along the profile - Blue: first non-transparent value 

 

New predefined colormaps

Two new colormaps have been added into node SoColorMap : VOLREND_RED and VOLREND_GREEN are now available as new values of predefined colormap and will match very well with medical datas.
New colormap SoColorMap::VOLREND_RED New colormap SoColorMap::VOLREND_GREEN

 

MeshViz XLM

C++ API Specific

Non-indexed mesh (VertexHexahedronIJK)

Extended support for non-indexed meshes: Isosurface, slice (plane, cylinder, sphere) and outline representations have been added.

Click on image to see the Isosurface in full resolution

Click on image to see the Planeslice in full resolution version

New isosurface extractor instance is available in MiIsosurfExtractorIjk when calling getNewInstance() with an MiVolumeMeshVertexHexahedronIjk implementation. MoMeshIsosurface node now supports MiVolumeMeshVertexHexahedronIjk for isosurface display.

New slice extractor instance is available in MiPlaneSliceExtractorIjk, MiSphereSliceExtractorIjkMiCylinderSliceExtractorIjk  when calling getNewInstance() with an MiVolumeMeshVertexHexahedronIjk implementation. MoMeshPlaneSlice, MoMeshCylinderSlice and MoMeshSphereSlice nodes now support MiVolumeMeshVertexHexahedronIjk for slice display.

New outline extractor instance is available in MiOutlineExtractIjk when calling getNewInstance() with an MiVolumeMeshVertexHexahedronIjk implementation. MoMeshOutline node now supports MiVolumeMeshVertexHexahedronIjk for outline display.

Isosurface and Plane slice extraction optimizations

Several optimizations have been done to the C++ version of MeshVizXLM in Open Inventor 9.5. for isosurface and plane slice extraction from various Mesh. More than ever, the extraction process now takes full advatange of multi core processors. The gain goes from 20% for unstructured mesh to x2 for structured ones. Following charts show benefits of those enhancements.

 

  
Isosurface / Plane slice extraction benchmark results
(click on any image to get higher resolution version )

 

 

JAVA / .NET API 

HexahedronIJK Mesh sub-range support 

A sub-range of cells specifies a "region of interest" within the mesh. This is much more efficient than selecting cells using a cell filter. This feature, previously available in C++, is now available for the Java and .NET API for a skin extraction. Two fields have been added to the MoMeshSkin class allowing the application to define the minimum (minCellRanges) and the maximum (maxCellRanges) of the wanted range. 
 

Click on image to see it in full resolution

 
A demo under demos\meshviz\meshvizdatamapping\skin is available to illustrate the feature and show how to start.
 

New Java interface MiVolumeMeshVertexHexahedronIjk

MiVolumeMeshVertexHexahedronIjk is an interface used to represent a non Indexed Hexahedron IJK mesh. This interface defines a structured mesh as a 3D grid of hexahedrons. Each hexahedron is defined by 8 explicit coordinates. This mesh type does not use indexed vertices, so the topology of the mesh is just the I, J and K dimensions of the 3D grid.
 
MeshVizXLM 9.5. also supports Skin and Slab extraction and representation on this new mesh interface.
 
Slab and Skin demo are available under demos\meshviz\meshvizdatamapping to illustrate this new feature.
 

RemoteViz

RemoteViz 9.5 introduces new features and improves performance. The number of frames per second received by the clients has been improved by 20-30% depending on the resolution and the dataset complexity.

.NET and JAVA

In addition to C++, you can now develop a RemoteViz Service in .NET or Java on Windows. RemoteViz .NET and Java offers the same level of feature as the C++ API. All the RemoteViz C++ examples have been ported in .NET and Java.

Secure Connections

Communication between Client and Service can now be secured using Transport Layer Security (TLS) or Secure Sockets Layer (SSL) protocols (see ServiceSettings::enableSecureConnection). The RemoteViz documentation has been updated to explain how to configure servers with TLS/SSL.

A SecureConnection example has been added to show how to enable secure connection between the service and the clients.


  

 

NodeJS Support

RemoteViz now supports NodeJS proxy. Documentation has been added to explain how to configure a NodeJS server to handle normal page requests and websocket traffic over the same port and domain (see SetupServers/NodeJS).

 

ImageViz

Previously in a beta state, the ImageViz extension is now fully released. With Open Inventor 9.5, ImageViz is now available for 64-bit Linux (gcc 4.1 and 4.4) and for OS X (gcc 4.2). The ImageViz API is also now available in C# (.NET) and provides the same level of features as the C++ API. 

New operators available

Several new operators are available with Open Inventor 9.5.

These two engines apply a morphological LUT (Lookup table) on a given image. These tables are generally used to change the display of graylevels from an image, associating them to another gray value or an RGB color. They may also be used to store some neighborhood configurations where each element of the LUT represents a kernel and the corresponding value indicates if this configuration has to be detected or not. For instance in 2D, a 512 element LUT represents all the binary configurations of a 3x3 kernel. Applying this kind of LUT allows you to perform morphological operations like thinning, thickening or hit-or-miss.

In the images below the red pixels represent the original image and the blue pixels represent the transformed image after five iterations of a specific morphological LUT.
Prune thinning by morphological LUT

Thickening by morphological LUT

This engine performs a "region growing" operation in 2D or in 3D. Starting from a voxel seed, the algorithm selects the largest connected area that contains the voxel itself and all voxels with gray values lying inside the input range. The input range is specified via the thresholdLevel field.

Original image with seed position (red cross) Flood fill result

 

This engine creates a binary image containing a random distribution of spheres. The application can specify size, distance, type of distribution and how many spheres to be generated.

The image below shows an example of the result with the default parameters.

Example of a 10 sphere generation

 

This engine applies a given lookup table (LUT) to the input image. For instance, it may be useful to apply the same label to different segmented objects. This engine also allows you to select the input range of the image. E.g., you can change only the grey level values between 100 and 150.

Here is a example of the application of a grayscale LUT: [255, 254, ..., 1, 0] on an image.

Left: original input image - Right: image after applying grayscale LUT 

 

New node SoDataMeasureAttributes 

The SoDataMeasureAttributes node allows you to set values for measures with specific attributes such as angle distribution for feret diameters, size of bins for measures based on histogram analysis and more. These attributes can be set in engines working on measures through an SoSFDataMeasureAttributes field. A series of predefined useful measures applicable on image data input can be found in the SoDataMeasurePredefined class.

New convenient voxelSize methods and extend field are added for SoImageDataAdapter

For instance an area measurement would be expressed in the adapted square unit if the calibration has been set, else it will be in square pixels. For now any measurement is expressed in pixels since it is impossible to modify the extent size.

 

HardCopy

SoToPDFAction and PDF model tree

SoToPDFAction now defines node names properly (i.e. using the name in the Open Inventor scene graph) while building the model tree of a PDF document. In the case where no name has been given to a node in the scene graph, a name is generated with a repeatable algorithm so the name remains the same every time the action is run on the scene graph.