9.1#

Released on 2021-11-04.

9.1.0 Release Notes#

Changes made since VTK 9.0.0 include the following.

Changes {#changes}#

Charts {#charts}#

  • vtkChartXYZ now applies matrix transformations in the right order (see issue 17542)

Data {#data}#

  • The node numbering for VTK_LAGRANGE_HEXAHEDRON has been corrected to match the numbering of VTK_QUADRATIC_HEXAHEDRON when the Lagrange cell is quadratic. Readers can internally convert data to the new numbering with XML file version 2.2 and legacy file version 5.1. The (0, 1) edge is swapped with the (1, 1) edge:

       quadratic                         VTK_QUADRATIC_HEXAHEDRON
VTK_LAGRANGE_HEXAHEDRON                  VTK_LAGRANGE_HEXAHEDRON
    before VTK 9.1                           VTK 9.1 and later

       +_____+_____+                        +_____+_____+
       |\          :\                       |\          :\
       | +         : +                      | +         : +
       |  \     19 +  \                     |  \     18 +  \
    18 +   +-----+-----+                 19 +   +-----+-----+
       |   |       :   |                    |   |       :   |
       |__ | _+____:   |                    |__ | _+____:   |
       \   +        \  +                    \   +        \  +
        +  |         + |                     +  |         + |
         \ |          \|                      \ |          \|
           +_____+_____+                        +_____+_____+

  • vtkPolyData::ComputeBounds() used to ignore points that do not belong to any cell which was not consistent with other vtkPointSet subclasses. See [ParaView issue #20354][paraview-issue20354]. The previous behavior is available through vtkPolyData::ComputeCellsBounds() and vtkPolyData::GetCellsBounds() (usually for rendering purposes).

Filters {#filters}#

  • The VTK::FlowPaths and VTK::ParallelFlowPaths filters now use a vtkSignedCharArray rather than a vtkCharArray since the latter is ambiguous as to whether it is signed or unsigned. This affects the protected API available to subclasses and the usage of the output’s ParticleSourceId point data array.

  • vtkStaticCellLocator::FindCellsAlongLine() now uses a tolerance for intersections with boxes.

  • The tolerance used in vtkStaticCellLocator is now retrieved from the locator’s tolerance rather than relying on the size of the dataset. Previous behavior may be restored using the UseDiagonalLengthTolerance property.

  • vtkTubeFilter now increases the radius of tubes linearly with respect to the norm of the input vector when the radius is selected to vary by the vector’s norm.

  • vtkArrayCalculator has been updated to use C++ containers rather than raw pointers.

  • vtkArrayCalculator no longer supports the old dot syntax by default and the dot() function must be used instead.

  • vtkArrayCalculator can now use exprtk to parse expressions (the new default). This brings in functionality, but cannot define functions that return vectors.

  • vtkArrayCalculator’s input variable names must now be sanitized or quoted.

I/O {#io}#

  • There is a new VTK::IOChemistry module which contains chemistry-related readers. Moved classes:

    • vtkCMLMoleculeReader: from VTK::DomainsChemistry

    • vtkGaussianCubeReader: from VTK::IOGeometry

    • vtkGaussianCubeReader2: from VTK::IOGeometry

    • vtkMoleculeReaderBase: from VTK::IOGeometry

    • vtkPDBReader: from VTK::IOGeometry

    • vtkVASPAnimationReader: from VTK::DomainsChemistry

    • vtkVASPTessellationReader: from VTK::DomainsChemistry

    • vtkXYZMolReader: from VTK::IOGeometry

    • vtkXYZMolReader2: from VTK::IOGeometry

  • vtkOpenFOAMReader no longer supports the include compatibility keyword (deprecated in 2008).

  • vtkOpenFOAMReader no longer treats uniformFixedValue as special. Proper support requires logic that would require VTK to use OpenFOAM libraries.

  • vtkOpenFOAMReader no longer supports OpenFOAM 1.3 cloud naming (deprecated in 2007).

Rendering {#rendering}#

  • vtkVolumeMapper and its subclasses now accept vtkDataSet input, but ignore any type that is not a vtkImageData or vtkRectilinearGrid (or their subclasses). Derived classes may need to SafeDownCast if the input is assumed to be vtkImageData.

  • OpenGL framebuffers are now handled using a RenderFramebuffer that is internally managed rather than destinations such as BackLeft and Front. If SwapBuffers is on, then the RenderFramebuffer will be blitted to a DisplayFramebuffer (twice for stereo rendering). The vtkOpenGLRenderWindow::BlitToRenderFramebuffer may be used to blit the current read framebuffer to the render framebuffer to initialize color and depth data. The vtkOpenGLRenderWindow::FrameBlitMode property may be set to control the following behavior:

    • BlitToHardware: blit to hardware buffers (such as BACK_LEFT)

    • BlitToCurrent: blit to the bound draw framebuffer

    • NoBlit: blitting will be handled externally

  • vtkTexture’s API now more closely matches OpenGL’s API. Instead of Repeat and EdgeClamp properties, Wrap is provided using values such as ClampToEdge, Repeat, MirroredRepeat, and ClampToBorder. A border color may be selected when using ClampToBorder.

Java {#java}#

  • The byte, short, long, and float types may now be exposed in the wrapped Java APIs. The Java API now uses types as close as possible to the C++ types used in the wrapped API.

Python {#python}#

  • VTK now defaults to Python 3.x rather than Python 2.

  • The VTK::WebPython module no longer supports Python 2.

  • Python 2.6, 3.2, and 3.3 are no longer supported. Python 3.6 or higher is recommended.

  • VTK’s web support now requires wslink>=1.0.0. This slims down the dependency tree by dropping Twisted in favor of asyncio and aiohttp.

  • VTK’s wheels are now built via CI (rather than by hand). Wheels are available for:

    • Python versions 3.6, 3.7, 3.8, and 3.9

    • Platforms manylinux2014, macos10.10, and windows

    • Python 3.9 also supports macos11.0 arm64

    • Official wheels do not use any external dependencies, but see build.md for instructions on building custom wheels.

  • VTK object repr() now shows the address of the underlying C++ vtkObjectBase and the Python object itself:

    • <vtkmodules.vtkCommonCore.vtkFloatArray(0xbd306710) at 0x69252b820>.

  • VTK objects which are not derived from vtkObjectBase now have a repr() that shows the construction method (though this is dependent on how the backing type serializes itself, so it may not be 100% accurate; please file issues for types which look “odd”):

    • vtkmodules.vtkCommonCore.vtkVariant("hello")

    • vtkmodules.vtkCommonDataModel.vtkVector3f([1.0, 2.0, 3.0])

Rendering {#rendering}#

  • vtkTextProperty::LineSpacing now defaults to 1.0 rather than 1.1.

Infrastructure {#infrastructure}#

  • VTK’s deprecation mechanism now marks specific APIs as deprecated so that compilers may warn about its usage. Clients still requiring older APIs can suppress warnings by defining VTK_DEPRECATION_LEVEL to VTK_VERSION_CHECK(x, y, z) to suppress warnings about APIs deprecated after x.y.z.

New Features {#new-features}#

Algorithms {#algorithms}#

  • vtkFFT is now available to perform discrete Fourier transformations.

Core {#core}#

  • The vtkGaussianRandomSequence::GetNextScaledValue(), vtkMinimalStandardRandomSequence::GetNextRangeValue(), and vtkRandomSequence::GetNextValue() APIs have been added to avoid the ->Next(), ->GetValue() ping-ponging.

  • vtkVariant::ToString() and vtkVariant::ToUnicodeString() now support formatting and precision arguments when processing numerical values or arrays.

Charts {#charts}#

  • vtkChartMatrix may now share x and/or y axes between charts using the Link(c1, c2) and Unlink(c1, c2) methods. Labels for the axes may be set using the LabelOuter(leftBottom, rightTop) method.

  • vtkChartMatrix now supports nested vtkChartMatrix items.

  • vtkChartMatrix::Paint and vtkChartMatrix::GetChartIndex methods have been refactored to use an iterator-based API.

  • vtkChartXYZ now resizes dynamically with the scene by managing its margins). Manual calls to SetGeometry is no longer necessary.

  • vtkChartXYZ now supports removing plots.

  • vtkChartXYZ can now turn off its clipping planes to avoid disappearing plots when zooming in.

  • vtkChartXYZ can now zoom the axes along with the data.

  • vtkChartXYZ now supports axes labels.

  • vtkChartXYZ now uses vtkTextProperty for its text rendering.

Data {#data}#

  • vtkDataObjectTypes::TypeIdIsA may be used to determine if a type is the same as or a specialization of another type.

  • vtkDataObjectTypes::GetCommonBaseTypeId may be used to find the first common base class of two types.

  • vtkPartitionedDataSetCollection and vtkDataAssembly has been introduced to represent hierarchical datasets rather than vtkMultiBlockDataSet and vtkMultiPieceDataSet. The new vtkConvertToPartitionedDataSetCollection filter can be used to convert any dataset into a vtkPartitionedDataSetCollection with vtkDataAssembly representing any hierarchical organization within a vtkMultiBlockDataSet. Converting back may be performed with vtkPConvertToMultiBlockDataSet or vtkConvertToMultiBlockDataSet.

  • vtkUnstructuredGrid::GetCell is now thread-safe.

Documentation {#documentation}#

  • VTK’s Doxygen documentation now cross-references pages with the vtk-examples website to examples using the class. Images for the classes are now embedded into the class documentation as well.

Doxygen Examples

Geometry {#geometry}#

  • The vtkCell API now includes support for the 19-node-pyramid named vtkTriQuadraticPyramid. Along with the addition of this API, several filters, readers and tests have been updated to incorporate vtkTriQuadraticPyramid:

    • Filters:

      • vtkCellValidator

      • vtkUnstructuredGridGeometryFilter

      • vtkReflectionFilter

      • vtkBoxClipDataset

      • vtkCellTypeSource

    • Readers:

      • vtkIossReader

Filters {#filters}#

  • vtk3DLinearGridPlaneCutter has been updated to also handle cell data. Each triangle of the output dataset contains the attributes of the cell it originated from. Using this class should be faster than using the vtkUnstructuredGridCutter or the vtkDataSetCutter and should avoid some small projection error. The vtkCutter has also been updated to benefit from these changes.

  • vtkMergeVectorComponents has been added to the VTK::FiltersGeneral module which supports vtkDataSet objects and may be used to combine three arrays of components into a new output array. This filter supports multithreading via vtkSMPTools.

  • vtkArrowSource now has an option to be placed and oriented around its center which makes placing it after scaling and rotation much easier.

  • vtkDataSetSurfaceFilter can now extract surfaces from all structured data sets including vtkImageData, vtkStructuredGrid, and vtkRectilinearGrid when they have blanked cells marked using a ghost array.

  • vtkDataSetSurfaceFilter has a “fast mode” which only considers the outer-most surface without considering external faces within the outer shell which is intended for rendering purposes.

  • vtkExtractExodusGlobalTemporalVariables now supports field data arrays.

  • vtkExtractEdges now supports a UseAllPoints to use a non-Locator-based strategy to skip selecting only the points which are used and instead assumes that all points will be present in the output.

  • The vtkGhostCellsGenerator filter is now available to generate ghost cells. It uses DIY for MPI communication internally and can handle any vtkMultiBlockDataSet, vtkPartitionedDataSet, and vtkPartitionedDataSetCollection that is filled with the supported input dataset types including vtkImageData, vtkRectilinearGrid, vtkStructuredGrid, vtkUnstructuredGrid, and vtkPolyData. Ghost cells are only exchanged with elements of the same type and are treated as the “closest” supported common ancestor class. Note that vtkHyperTreeGrid is not supported and vtkHyperTreeGridGhostCellsGenerator should be used for it instead.

  • vtkGroupDataSetsFilter may be used to combine input datasets into a vtkMultiBlockDataSet, vtkPartitionedDataSet, or vtkPartitionedDataSetCollection. Each input is added as an individual block and may be named using SetInputName.

  • vtkGroupTimeStepsFilter may be used to turn temporal data into a single vtkMultiBlockDataSet or vtkPartitionedDataSetCollection with all of the temporal data. The output type is vtkPartitionedDataSetCollection unless the input is vtkMultiBlockDataSet in which case another vtkMultiBlockDataSet is output.

  • vtkVortexCore’s output points now include interpolated variables of the input points.

  • vtkVortexCore is now fully multithreaded using vtkSMPTools.

  • vtkMergeTimeFilter may be used to synchronize multiple input temporal datasets. The output is a vtkMultiBlockDataSet with one block per input element. The output timestep may be either a union or intersection of the input timestep lists (which may be de-duplicated with either absolute or relative tolerances).

  • vtkResizingWindowToImageFilter may be used as an alternative to vtkWindowToImageFilter to create screenshots of any size and aspect ratio using the SetSize(width, height) method regardless of the window size. Note that offscreen buffers are used and therefore memory usage is higher than vtkWindowToImageFilter. Memory usage may be limited using the SetSizeLimit(width, height) method (defaulting to (4000, 4000)). For images larger than the limit the filter will fallback to vtkWindowToImageFilter in order to save memory.

  • vtkExtractVectorComponents can now work multithreaded using vtkSMPTools.

  • vtkPartitionedDataSetCollectionSource is now available to programmatically produce a vtkPartitionedDataSetCollection.

  • vtkThresholdPoints::InputArrayComponent has been added to enable selection of a single component within the active data array. If a value larger than the number of components is used, the magnitude of each array tuple will be used.

  • vtkTubeBender is now provided in order to generate better paths for tubes in vtkTubeFilter. This is particularly visible when generating tubes around acute angles.

  • vtkArrayCalculator now supports multithreading via vtkSMPTools.

  • vtkVectorFieldTopology may be used to compute the topological skeleton of a 2D or 3D vector field given as a set of critical points and separatrices. Separatrices are lines in 2D and surfaces in 3D (computed via vtkStreamSurface).

  • vtkTableFFT now offers a frequency column in the output table.

  • vtkTableFFT can now compute the FFT per block and then average these results.

  • vtkTableFFT can now apply a windowing function before computing the FFT.

  • vtkMergeCells can now merge points using double precision tolerances.

  • vtkTemporalPathLineFilter can now manage backwards times using its SetBackwardTime() method. When using backwards time, each vtkDataObject::DATA_TIME_STEP() from subsequent ::RequestData() method calls will decrease.

  • vtkPlaneCutter used to always generate a vtkMultiBlockDataSet regardless of input type. Now vtkPlaneCutter decides what the output type will be based on the input type.

    • If input type is vtkUniformGridAMR or vtkMultiBlockDataSet, the output type will be vtkMultiBlockDataSet.

    • If input type is vtkPartitionedDataSetCollection, the output type will be vtkPartitionedDataSetCollection.

    • If input type is vtkDataSet or vtkPartitionedDataSet, the output type will be vtkPartitionedDataSet.

  • The RemapPointIds functor of vtkRemoveUnusedPoints has now been multithreaded properly. (#18222)

Imaging {#imaging}#

  • The vtkImageProbeFilter works like vtkProbeFilter, but is designed for image data. It uses vtkImageInterpolator rather than cell and point interpolations. The filter supports SMP acceleration.

I/O {#io}#

  • VTK can now read ADIOS2 files or data streams using Fides. This can be provided as a JSON file containing the data model or Fides can generate its own data model automatically (see Fides documentation for details). Fides converts the ADIOS2 data to a VTK-m dataset and the vtkFidesReader creates partitioned datasets that contain either native VTK datasets or VTK VTK-m datasets. Time and time streaming is supported. Note that the interface for time streaming is different and requires calling PrepareNextStep() and Update() for each new step.

  • The vtkCONVERGECFDReader has been added to read CONVERGE CFD (version 3.1) files containing meshes, surfaces, and parcels as well as support for time series data. Each stream is considered its own block. Cell and point data arrays may be selected using the CellArrayStatus and ParcelArrayStatus APIs. Note that parallel support is not yet available.

  • vtkEnSightGoldBinaryReader now supports reading undefined and partial variables from per-node and per-element files.

  • VTK’s EnSight Gold support can now read asymmetric tensors. This is not supported in EnSight6 files yet.

  • The vtkIossReader has been added which supports reading CGNS and Exodus databases and files. The output is provided as a vtkPartitionedDataSetCollection with vtkDataAssembly representing the logical structure. Note that not all CGNS files are supported; only the subset supported by the backing IOSS library. Eventually, the vtkExodusIIReader will be deprecated in preference for this reader.

  • The vtkMP4Writer writer may be used to write H.264-encoded MP4 files on Windows using the Microsoft Media Foundation API. The Rate property is available to set the framerate and the BitRate property may be used to set the quality of the output.

  • vtkOMFReader may be used to read Open Mining Format files. The output is a vtkPartitionedDataSetCollection with each vtkPartitionedDataSet is one OMF element (point set, line set, surface, or volume).

  • vtkOpenVDBWriter may be used to write OpenVDB files. MPI is supported by writing separate files for each rank. Temporal data is also written to a separate file for each timestep.

  • vtkTGAReader may be used to read TGA images.

  • vtkPDBReader now supports reading PDB files with multiple models.

  • vtkPDBReader now generates an array containing the model each atom belongs to.

  • vtkVelodyneReader may be used to read Velodyne AMR files.

AMR-Detonation

  • vtkNrrdReader can now read gzip-encoded compressed NRRD files.

  • vtkOpenFOAMReader now supports reading internal dimensioned fields.

  • vtkOpenFOAMReader now supports string expansion syntaxes from OpenFOAM v1806 (#include, <case>, <constant>, <system>).

  • vtkOpenFOAMReader now handles mixed-precision workflows much more robustly.

  • vtkOpenFOAMReader now handles multi-region cases without a default region.

  • vtkOpenFOAMReader now respects the inGroups boundary entry for selection of multiple patches by group.

  • vtkOpenFOAMReader now properly handles empty zones and has basic support for face zones.

  • vtkOpenFOAMReader respects point patch value fields using the correct visitation order.

  • vtkOpenFOAMReader no longer has hard-coded limits on polyhedral size.

  • vtkOpenFOAMReader now preserves uncollated Lagrangian information.

  • vtkOpenFOAMReader now avoids naming ambiguities for Lagrangian and region names using a /regionName/ prefix for non-default regions.

Interaction {#interaction}#

  • A new 3D camera orientation widget. The widget’s representation is synchronized with the camera of the owning renderer. The widget may be used to select an axis or using its handles.

  • vtkSelectionNode now supports BLOCK_SELECTORS to select whole blocks from a composite dataset using a selector expression for hierarchy or an associated vtkDataAssembly for vtkPartitionedDataSetCollections.

  • Interactive 2D widgets have been added (ported from ParaView). The vtkEqualizerFilter and vtkEqualizerContextItem are now available using this feature.

    • Source data: Equalizer filter and Interactive 2D

    • After applying the filter: Equalizer filter and Interactive 2D

  • VTK’s OpenVR’s input model has been updated to be action-based and supports binding customization within the OpenVR user interface. This includes controller labeling and user configuration.

  • vtkEventData now understands an “Any” device so that handlers can look for all events and do filtering internally. See merge request 7557 for an example of how to update custom 3D event handling.

  • vtkResliceCursorWidget now refreshes when scrolling.

  • Frustum selection of lines and polylines now only considers the line itself, not their containing area (i.e., they were treated as polygons during selection).

  • Selections of vtkDataAssembly may be limited to a subset of blocks using a collection of xpath selectors for the dataset.

  • vtkChartXYZ can now be controlled using the arrow keys for rotation.

  • vtkScalarBarActor now supports custom tick locations via vtkScalarBarActor::SetCustomLabels() and vtkScalarBarActor::SetUseCustomLabels().

Java {#java}#

  • Java 1.7 is now required (bumped from 1.6).

  • The wrapped Java API now handles strings more efficiently by handling encoding in the Java wrappers directly. No APIs are affected.

Python {#python}#

  • vtkPythonInterpreter::SetRedirectOutput can be used to disable Python output to vtkOutputWindow.

  • VTK now offers two CMake options for deployments that can help to handle Python 3.8’s DLL loading policy changes on Windows. This allows import vtkmodules to handle PATH manipulations to ensure VTK can be loaded rather than relying on vtkpython to do this work.

    • VTK_UNIFIED_INSTALL_TREE: This option can be set to indicate that VTK will share an install tree with its dependencies. This allows VTK to avoid doing extra work that doesn’t need to be done in such a situation. This is ignored if VTK_RELOCATABLE_INSTALL is given (there’s no difference there as VTK assumes that how VTK is used in such a case is handled by other means).

    • VTK_DLL_PATHS: A list of paths to give to Python to use when loading DLL libraries.

  • Python wrappers will now generate deprecation warnings when the underlying VTK API is deprecated. Since Python silences DeprecationWarning by default, the warnings must be allowed via:

import warnings
warnings.filterwarnings("default", category=DeprecationWarning)

  • With Python 3.6 and newer, VTK APIs marked with attributes that indicate that paths are expected will now support pathlike objects.

  • Wrapped Python APIs now contain docstrings with type hints as described in PEP 484. This will help with IDE tab completion and hinting.

  • VTK’s vtkmodules package and vtk module now provide __version__ attributes.

  • The vtkmodules.web.render_window_serializer module may be used to additionally serialize vtkPolyData, vtkImageData, and mergeToPolyData optionally using the requested_fields=['*'] argument.

Qt {#qt}#

  • VTK now supports Qt6 using the VTK_QT_VERSION variable. This may be set to Auto in which case the first of Qt6 or Qt5 found will be used.

  • The VTK::GUISupportQtQuick module has been added which supports the necessary integration classes as well as the QML module infrastructure required to import VTK into a QtQuick application.

Rendering {#rendering}#

  • The vtkOutlineGlowRenderPass renders a scene as a glowing outline. Combined with layered renderers this creates a very visible highlight without altering the highlighted object.

  • VisRTX and OptiX now offer trace-level debugging information to determine why they may not be available.

  • vtkMultiBlockUnstructuredGridVolumeMapper has been added to volume render the entirety of a multi-block unstructured grid without merging them.

  • The physical-based render shader now supports anisotropic materials. This may be modified using the Anisotropy and AnisotropyRotation properties. Support for these values from a texture is also available.

  • vtkBlockItem may now resize itself based on the label specified. Additionally, options for the brush, pen, and text, padding, margins are available.

  • Multi-volume ray-casting now supports shading.

  • vtkMatplotlibMathTextUtilities now supports multi-line (using \n) and multi-column (using | separators) text. vtkTextProperty now has a CellOffset property to control the spaces between columns (in pixels).

  • The GPU-based ray-casting volume mapper now supports rendering non-uniform rectilinear grids. Volume streaming via block partitioning is not yet supported.

Rectilinear-Grid-Volume

  • vtkOpenGLMovieSphere may be used to display spherical movies using OpenGL. Both regular 360° video and stereo 360° video is supported where stereo streams are split into left and right eye rendering passes. The video is sent to the graphics card as YUV textures which are decoded to RGB in the associated shaders.

  • VTK’s VisRTX support is now compatible with OSPRay 2.0.

  • The OpenGL vtkPolyData mappers now provide a way to handle jitter introduced by rendering with single-precision vertex coordinates far from the origin. The PauseShiftScale parameter may be used to suspend updates during user interactions.

  • vtkResliceCursorRepresentation::BoundPlane() is now offered to show the entire resliced image when rotating.

  • vtkOpenGLPolyDataMapper now supports a vtkSelection object to display selected ids or values directly from the mapper itself. Selections are rendered in a second pass as a wireframe using the vtkProperty::SelectionColor color.

  • The GPU-based ray-casting volume mapper now supports direct volume rendering with the blanking of cells and points defined by individual ghost arrays.

    • Uniform grid with blanking:

Uniform-Grid-Blanking

  • Image data with ghost cells and points:

ImageData-Ghost-Arrays

  • Volume rendering may now use independent scalar arrays for the x and y dimensions of 2D transfer functions.

Web {#web}#

  • render_window_serializer.py now supports serialization of a vtkRenderWindow that contains vtkVolume, vtkVolumeProperty, or vtkVolumeMapper.

SMP {#smp}#

  • vtkSMPTools::For() can now be used on iterators and ranges. This can be especially useful for containers that are not indexed such as std::map and std::set.

  • vtkSMPTools::LocalScope may be used to call a vtkSMPTools method with a specific configuration within a scope. The configuration structure takes a maximum thread number and/or a backend.

  • vtkSMPTools now has an STDThreads backend which uses C++’s std::thread.

  • vtkSMPTools::Transform and vtkSMPTools::Fill may be used as replacements for std::transform and std::fill.

  • Multiple backends may now be compiled into VTK at build time rather than a separate build per backend. The default may be selected using the VTK_SMP_IMPLEMENTATION_TYPE CMake variable or the VTK_SMP_BACKEND_IN_USE environment variable at runtime. Enabling a backend is controlled by the VTK_SMP_ENABLE_<backend> CMake variable at build time.

  • The VTK_SMP_MAX_THREADS environment variable is now available to limit the number of threads any SMP task will use.

  • vtkSMPTools now supports nested parallelism using the NestedParallelism property (defaults to false) and the IsParallelScope query to detect such scoping.

Wrapping {#wrapping}#

  • Wrapped classes no longer require a vtk prefix.

  • Hierarchy files are used exclusively for type checking.

  • The wrapping tools now keep an internal cache of which header files exist where on the system to avoid repeated lookups when resolving #include search paths.

Module System {#module-system}#

  • The vtk_module_add_module(NOWRAP_HEADERS) argument may be used to list public and installed headers which should not be exposed for wrapping purposes.

  • The vtk_module_add_module(NOWRAP_CLASSES) argument may be used to list class names for which the headers are treated as NOWRAP_HEADERS arguments.

  • The vtk_module_add_module(HEADER_DIRECTORIES) argument may be used to indicate that the relative path of headers from the current source or binary directory should be preserved upon installation.

  • The vtk_module_install_headers(USE_RELATIVE_PATHS) argument may be used to indicate that the relative path of headers from the current source or binary directory should be preserved upon installation.

  • The vtk_module_build, vtk_module_wrap_python, and vtk_module_wrap_java APIs now support a UTILITY_TARGET argument. The target named using this argument will be privately linked into every library created under these APIs. This may be used to provide compile or link options to every target. Note that the target given must be installed, but it may be installed with the same export set given to any of these APIs.

  • The module system now supports target-specific components using the vtk_module_build(TARGET_SPECIFIC_COMPONENTS) argument.

Infrastructure {#infrastructure}#

  • VTK plans to hold to a new minor (or major) release every six months with releases in or around April and October each year.

  • VTK now uses GitLab-CI for testing.

  • OSPRay support now detects Apple’s Rosetta translation environment and refuses to run due to the environment not supporting instructions used within OSPRay.

  • vtkGetEnumMacro and vtkSetEnumMacro are now available to work with enum class properties.

  • VTK now requires CMake 3.12 to build and to consume. This is mainly due to the usage of SHELL: syntax to properly support some MPI use cases.

  • vtkSOADataArrayTemplate compilation should use less memory now that its template instantiations are split into separate TU compilations.

  • The VTK_TARGET_SPECIFIC_COMPONENTS option may be specified to provide target-specific installation components.

Third Party {#third-party}#

  • An external ioss library may now be provided to VTK’s build.

  • An external pegtl library may now be provided to VTK’s build.

  • exprtk is now included in VTK (an external copy is supported).

  • fmt is now included in VTK (an external copy is supported, though VTK requires patches which have been merged upstream but not yet released).

  • VTK’s embedded third party packages have been updated:

    • cli11 2.0.0

    • eigen 3.3.9

    • exodusII 2021-05-12

    • expat 2.4.1

    • freetype 2.11.0

    • glew 2.2.0

    • hdf5 1.12.1

    • jpeg 2.1.0

    • libxml2 2.9.12

    • lz4 1.9.3

    • lzma 5.2.5

    • mpi4py 3.0.3

    • netcdf 4.8.0

    • ogg 1.3.5

    • pugixml 1.11.4

    • sqlite 3.36.0

    • tiff 4.3.0

Deprecated and Removed Features {#deprecated-and-removed-features}#

Legacy {#legacy}#

Some APIs had been deprecated for a long time. The following APIs are now removed.

  • vtkDataArrayTemplate (deprecated since Dec 2015)

  • vtkObjectBase::PrintRevisions and vtkObjectBase::CollectRevisions (deprecated since 2012)

  • VTK___INT64 and VTK_UNSIGNED___INT64 (deprecated since Mar 2017)

  • vtkArrayCalculator::SetAttributeMode* and VTK_ATTRIBUTE_MODE_* macros (deprecated in Jun 2017)

  • vtkContourGrid::ComputeGradients (deprecated in Dec 2018)

  • vtkSMPContourGridManyPieces, vtkSMPTransform, vtkThreadedSynchronizedTemplates3D, and vtkThreadedSynchronizedTemplatesCutter3D (deprecated in Sep 2017)

  • vtkAbstractImageInterpolator::GetWholeExtent (deprecated in Mar 2016)

  • vtkImageStencilData::InsertLine (an overload) (deprecated in Nov 2014)

  • The RemoveBlockVisibilites method from vtkCompositeDataDisplayAttributes, vtkCompositeDataDisplayAttributesLegacy, and vtkCompositePolyDataMapper2 (deprecated in Jul 2017)

  • vtkOpenVRPropPicker (deprecated in Apr 2018)

Core {#core}#

  • vtkLegacy.h and VTK_LEGACY_REMOVE are now deprecated and vtkDeprecation.h and its mechanisms should be used instead.

  • Building with kits is no longer supported with static builds. Since the goal of a kit build is to reduce the number of runtime libraries needed at startup, a static kit build does not make much sense. Additionally, some dependency setups could not be resolved in such a build (as witnessed by ParaView) and a proper fix is not easy, so disabling the support makes more sense at this time.

  • The vtkToolkits.h header provided preprocessor definitions indicating some features within VTK’s build. However, these were inaccurate in single-configure builds since the information was not available when the header was configured.

    • VTK_USE_VIDEO_FOR_WINDOWS: now available in vtkIOMovieConfigure.h

    • VTK_USE_VFW_CAPTURE: now available in vtkIOVideoConfigure.h as VTK_USE_VIDEO_FOR_WINDOWS_CAPTURE, but the old name is given for compatibility.

  • vtkUnicodeString and vtkUnicodeStringArray are now deprecated since VTK, since 8.2, has assumed UTF-8 for all string APIs. As such, vtkUnicodeString and vtkUnicodeStringArray did not provide any additional information. Users which used them to convert UTF-8 to UCS-2 for Windows API usages should instead use VTK::vtksys’s SystemTools APIs for converting such strings.

  • vtkAtomic is removed in favor of std::atomic. As such, vtkAtomic.h and vtkAtomicTypeConcepts.h are no longer provided.

  • Threading-related classes are now deprecated in favor of C++11 standard library mechanisms.

    • vtkConditionVariable: std::condition_variable_any

    • vtkCriticalSection: std::mutex

    • vtkMutexLock: std::mutex

    • vtkSimpleConditionVariable: std::condition_variable_any

    • vtkSimpleCriticalSection: std::mutex

    • vtkSimpleMutexLock: std::mutex

    • vtkThreadMessanger: std::mutex and std::condition_variable_any

  • vtkSetGet.h no longer includes <math.h>.

  • vtkVariant.h methods Is__Int64 and IsUnsigned__Int64 were marked deprecated, though they have been unconditionally returning false since 2015.

Filters {#filters}#

  • vtkDataSetSurfaceFilter no longer supports generation of triangle strips. The vtkStripper filter may be used to generate them if needed.

  • vtkConfigure.h is now deprecated and split into more focused headers. The headers which now contain the information:

    • vtkBuild.h: VTK_BUILD_SHARED_LIBS

    • vtkCompiler.h: Compiler detection and compatibility macros.

    • vtkDebug.h: VTK_DEBUG_LEAKS and VTK_WARN_ON_DISPATCH_FAILURE

    • vtkDebugRangeIterators.h: VTK_DEBUG_RANGE_ITERATORS and VTK_ALWAYS_OPTIMIZE_ARRAY_ITERATORS

    • vtkEndian.h: VTK_WORDS_BIGENDIAN

    • vtkFeatures.h: VTK_ALL_NEW_OBJECT_FACTORY and VTK_USE_MEMKIND

    • vtkLegacy.h: VTK_LEGACY_REMOVE, VTK_LEGACY_SILENT, and VTK_LEGACY

    • vtkOptions.h: VTK_USE_64BIT_IDS and VTK_USE_64BIT_TIMESTAMPS

    • vtkPlatform.h: VTK_REQUIRE_LARGE_FILE_SUPPORT and VTK_MAXPATH

    • vtkSMP.h: VTK_SMP_${backend} and VTK_SMP_BACKEND

    • vtkThreads.h: VTK_USE_PTHREADS, VTK_USE_WIN32_THREADS, VTK_MAX_THREADS

      • Also includes VTK_THREAD_RETURN_VALUE and VTK_THREAD_RETURN_TYPE, but vtkMultiThreader.h is guaranteed to provide this.

  • Old ghost cell filters are deprecated in favor of vtkGhostCellsGenerator.

    • vtkUnstructuredGridGhostCellsGenerator

    • vtkPUnstructuredGridGhostDataGenerator

    • vtkStructuredGridGhostDataGenerator

    • vtkPStructuredGridGhostDataGenerator

    • vtkUniformGridGhostDataGenerator

    • vtkPUniformGridGhostDataGenerator

  • vtkThreshold’s ThresholdByLower(), ThresholdByUpper(), and ThresholdBetween() methods are deprecated in favor of vtkThreshold::LowerThreshold, vtkThreshold::UpperThreshold, and vtkThreshold::ThresholdFunction properties.

Python {#python}#

  • Python 2 support, which reached its end-of-life in January 2020 is deprecated.

Soft deprecations {#soft-deprecations}#

Some groundwork has been laid down to deprecate existing classes with new features in this release, but have not been formally deprecated yet. Users are encouraged to use the new APIs to help ensure that the transition when they are deprecated is smoother.

  • vtkMultiBlockDataGroupFilter usage should be replaced by vtkGroupDataSetsFilter.

  • vtkMultiBlockFromTimeSeriesFilter usage should be replaced by vtkGroupDataSetsFilter.

  • vtkExodusIIReader usage should be replaced by vtkIossReader.

  • The random number APIs from vtkMath should be moved to vtkGaussianRandomSequence or vtkMinimalStandardRandomSequence as needed.

Other Changes {#other-changes}#