# 9.3.0 Release Notes Changes made since VTK 9.2.0 include the following. ---------------------------------------- ## Changes {#changes} ### Build {#build} - Compile fixes for C++20 builds with gcc11. - Apply /utf-8 option for MSVC builds for standardization. - Headers `vtkBlockSortHelper.h` from `VTK::RenderingVolume` and `vtkDIYKdTreeUtilities.h` from `VTK::FiltersParallelDIY2` are now installed. - The `vtk-config.cmake` CMake package no longer permits unknown components to be listed and will report them as not found. This helps ensure the usability `VTK::Component` when `VTK_Component_FOUND` is set. - The `vtk_encode_string` CMake API now supports the `ABI_MANGLE_SYMBOL_BEGIN`, `ABI_MANGLE_SYMBOL_END`, and `ABI_MANGLE_HEADER` arguments to specify a mangling mechanism. Previously (where mangling was supported), it was hard-coded to VTK's own mangling decisions. - Updated the vendored `fmt` library has been to 10.1.1. - The vendored `fmt` library has been updated to 10.1.1 to aid with C++17 compatibility. ### Charts {#charts} - Uniformize the `vtkPlot` API for color setters/getter, in order to fit the API of `vtkPen` and `vtkBrush`. Methods using floating point parameters (e.g. `vtkPlot::SetColor(double r, double g, double b)`) are now suffixed with `F` to avoid confusion with equivalent functions using unsigned chars. The former ones are marked as deprecated. - `vtkChartParallelCoordinates`'s default selection behavior has been simplified. Multiple selection is no longer supported in `SELECTION_DEFAULT`. ### Copyright {#copyright} - SPDX information have been added and replace all previous copyright declaration in all of VTK. See [more information][spdx-copyright] on the process used. [spdx-copyright]: https://gitlab.kitware.com/vtk/vtk/-/commit/987d39ac31203df75281f0ab4be135dfc3c42d89 ### Core {#core} - OSPRay has been disabled for older x86\_64 processors which do not support SSE4.1. - Removed hidden private dependency of `CommonCore` on `CommonDataModel`. - Nested parallelism has been disabled by default for all backends except TBB, which should improve performance. Enabling nested parallelism is still possible when sub-task are coarse enough, using the `SetNestedParallelism` method or a `LocalScope`. - Improved `vtkSMPTools` STDThread backend. A common, global, thread pool is now shared between all SMP calls, so they no longer create threads. ### Data {#data} - `vtkPolyLine::Clip` improved to generate polylines whenever possible. - `vtkCompositeDataSet::ShallowCopy` now does an actual shallow copy up to array pointers. - Fixed calculation of `vtkPyramid` centroid. ### Filters {#filters} - VTK's interruption method has been updated to use `CheckAbort`. `CheckAbort` will check the current filter's `AbortExecute` flag as well as any upstream filter's `AbortExecute` flag. If any are set, the filter will output empty data and tell downstream filters to abort as well. Currently, `vtkContourGrid`, `vtkClipDataSet`, `vtkShrinkFilter`, and `vtkRTAnalyticSource`. - `vtkmContour`'s `ComputeScalars` parameter has been fixed to behave like `vtkContourFilter`. - `vtkExtractCells` has been relocated from `Filters/Extraction` to `Filters/Core`. - `vtkTemporalDataSetCache` now deep copies data by default. - Fix SIGSEGV on `vtkCompositeDataProbeFilter`. - vtkDataSetAttributesFieldList::vtkInternals.NumberOfInputs was initialized to be -1, which causes UnionFieldList to pass wrong argument to PreExtendForUnion. It is now fixed to be 0. - Add `ComponentName` in `vtkImageAlgorithm` and subclasses. - All vtkImageAlgorithm subclasses will now respect and pass on the component names associated with data arrays that their processing. ### Geovis {#geovis} - Moved `vtkCompassWidget` and `vtkCompassRepresentation` from `Geovis/Core` to `Interaction/Widgets`. ### Interaction {#interaction} - `vtkSelectPolyData` now passes cell data attributes to the selected and unselected outputs. - Output support fixed for `vtkSelectPolyData` when `GenerateSelectionScalars` is enabled. ### I/O {#io} - `vtkPLYReader` changed to use new `vtkResourceStream` IO. - `vtkPLY::get_ascii_item` signature changed from `void(const char*, int, int*, unsigned int*, double*)` to `void(vtkResourceParser*, int, int*, unsigned int*, double*)` - `vtkPLY::ply_read` signature changed from `PlyFile*(std::istream*, int*, char***)` to `PlyFile*(vtkResourceStream*, int*, char***)` - `vtkPLY::get_words` signature changed from `void(std::istream* is, std::vector* words, char line_words[], char orig_line[])` to `void(vtkResourceParser* is, std::vector* words, char line_words[], char orig_line[])` - `vtkPIOReader::GetTimeDataArray` now returns `nullptr` when the index is out-of-range. - CGNS fixed compilation with HDF5 1.12. - `vtkSTLReader` fixed to not consume new lines erroneously. - Fix UT record support in `vtkDICOMParser` - Previously, vtkDICOMParser failed to parse DICOM files with UT records due to incorrectly reading their length field. This has now been fixed. - Fix for reading binary XML files > 2Gb on Windows. - Fix an error encountered when reading binary format XML files on Windows - a missing define for Expat caused the offset used reading the position in the file to be limited to 2Gb. Fix the define, and add a check when using external Expat that the necessary feature, `XML_LARGE_SIZE`, is enabled. ### Python {#python} - OSMesa VTK wheels are now provided. These are available on VTK's official channels (the VTK repository's Python index and `vtk.org`), but not PyPI because OSMesa conflicts with other OpenGL packages. - The numpy adapter (`util.numpy_support`) converts `numpy.int8` arrays to `vtkSignedCharArray` rather than `vtkCharArray`, to ensure that signedness is preserved by the conversion. ### Rendering {#rendering} - Fix wireframe render shading issues for some GPUs. - VTK previously exported a lot of its shader strings from its libraries. Now only those that are available through installed headers are available. These include: - `vtkTextureObjectVS` from `VTK::RenderingOpenGL2` - `vtkCompositeZPassFS` from `VTK::RenderingParallel` - Volume label mapping improved to properly index upto 256 labels each with their own color, opacity and gradient transfer functions. ### System {#system} - `vtkExecutableRunner`'s argument splitting system has been overhauled. There are now 2 modes to execute a command using the `ExecuteInSystemShell` flag: - When `ExecuteInSystemShell` is `true` (default), the class will execute the given command in the system shell, leaving the actual argument split to the shell. - When `ExecuteInSystemShell` is `false`, you will have to split the command and its arguments yourself using the new `AddArgument` API. ### Third Party {#third-party} - VTK's vendored `zlib` library has been updated to 1.2.13. - VTK's vendored `fmt` library has been updated to 9.1.0. - VTK's vendored `ioss` library has been updated to the 2022-10-14 release. - VTK's vendored `libtiff` library has been updated to 4.6.0. The new version fixes a number of CVEs. - VTK's vendored `netcdf` library has been updated to 4.9.2. - VTK's vendored `mpi4py` library has been updated to 3.1.4. - VTK's vendored `expat` library has been updated to 2.4.8. - VTK's vendored `libxml2` library has been updated to 2.10.1. - VTK's vendored `PDAL` library has been updated to 2.1. - Added fix for `Proj` compatibility with `windows.h` with the VTK `STRICT` definition. ---------------------------------------- ## New Features {#new-features} ### ABI Namespace {#abi-namespace} - VTK is now wrapped in a customizable `inline namespace` (`VTK_ABI_NAMESPACE`). To wrap code in the ABI namespace use `VTK_ABI_NAMESPACE_BEGIN` and `VTK_ABI_NAMESPACE_END`. This change means you can now link different versions of VTK into the same runtime without generating conflicts between VTK symbols. Note: this does not prevent conflicts with third-part symbol (including VTK-m). - Where to put namespaces: - Around classes, functions, variables, typedefs (optional). - Inner most named namespaces, there is no need to use the ABI namespace inside of an anonymous namespace. - ABI namespace should never be around a named namespace. - Forward declarations of classes/functions/variables/typedefs require ABI namespace if their implementation/declarion was inside the ABI namespace. - Where not to put namespace: - Do not namespace around non-exported classes/functions/variables/typedefs (usually found in tests). - Do not namespace around main functions. - Python bindings cannot be namespaced. - Most Utilities are not namespaced, including vtksys/vtkmeta/ksys. - It doesn't hurt anything, but it is not required to namespace symbols that are compiled into a driver (such as Wrapping Tools). - Some VTK modules have C interfaces that cannot be mangled: - VTK::CommonCore (GetVTKVersion) - VTK::IOXML (Provides a C API, `vtkXMLWriterC_-`) - VTK::WrappingPythonCore (Python Wrapping cannot have mangling) - Thirdpary Libraries and their VTK module wrappers do not have mangling: - VTK::metaio - VTK::xdmf2 - VTK::vpic - All C libraries (ie. HDF5, netCDF, etc.) - VTKm CUDA Accelerators do not get mangled: - VTK::AcceleratorsVTKmCore - VTK::AcceleratorsVTKmDataModel - VTK::AcceleratorsVTKmFilters ### Build {#build} - `VTK_LOGGING_TIME_PRECISION` can be used to change the precision of loguru timing output (when `VTK_ENABLE_LOGGING` is ON). - `VTK_ZSPACE_USE_COMPAT_SDK` can be used to control runtime search for zSpace Core Compatibility libraries. Default is ON, disabling the search. - `VTK_GENERATE_SPDX` can be used to generate [SPDX][spdx-docs] files for each VTK module. Default is OFF. The generation of SPDX files is considered experimental. - Added `VTK_USE_FUTURE_BOOL` configure-time variable. The codebase contains many variables typed as `int` that really should be `bool`. But changing them breaks backwards compatibility, and so a `vtkTypeBool` typedef was introduced which is defined to either `int` or `bool` depending on the new `VTK_USE_FUTURE_BOOL` configure-time variable. This allows for the piecemeal changing of many `int` variables to `vtkTypeBool`. [spdx-docs]: https://docs.vtk.org/en/latest/advanced/spdx_and_sbom.html ### Charts {#charts} - `vtkChartParallelCoordinates` now has a chart legend which can be toggled with the `SetShowLegend` method. This legend can be customized using the `vtkChartLegend` API. - `vtkPlotParallelCoordinates` now has the option to set a preconfigured color array using `SetColorModeToDefault`. - Fixed bug where calling `vtkPlotBar.GetLookupTable` caused a segmentation fault when no data had been plotted. - You can now set an array name for the `vtkPlotHistogram2D`. This allows you to set an array that is not scalar, ie. an array with a number of components greater than 1. ### Core {#core} - `vtkMath::GetPointAlongLine` can be used to compute a point along a line defined by two points and an offset. - `vtkValueFromString` is a new low-level function that converts a string to an integer, a floating-point value or a boolean. `vtkValueFromString` is faster than standard library functions such as the `std::strto*` function family. - VTK now provides a way to obtain type names at compile time in the `Common/Core/vtkTypeName.h` header: ```c++ #include "vtkTypeName.h" // ... std::string typeName = vtk::TypeName(); std::cout << typeName << std::endl; ``` - The `vtkStringToken` class introduces a utility for hashing strings at either compile or run-time and using the resulting integers as tokens. Additional utilities regarding compile-time hashing have also been added: - `vtkStringManager` holds strings hashed at runtime. This makes it possible for the string-token class to return the original string to you in some cases. Because the manager holds a map from string-hash to string, only a single copy of the string is stored no matter how many copies of the token exist. - Added new `vtk::literals` namespace for creating hashes and tokens at compile time. - `""_hash` - returns a 32-bit integer hash of the given string. - `""_token` - returns a `vtkStringToken` instance of the given string. Note that because the hash is computed during compilation, you may not call the token's `Data()` method to retrieve the string unless it is inserted at run time by some other code. - Since hashing is performed at build time, the following example is possible: ```cpp #include "vtkStringToken.h" using namespace vtk::literals; vtkStringToken t; switch (t.GetId()) { case "foo"_hash: foo(); break; case "bar"_hash: bar(); break; default: vtkErrorMacro("Unknown token " << t.Data()); break; } ``` - VTK now provides a way to iterate over a class and all its ancestor types (as long as they inherit `vtkObjectBase` and use the `vtkTypeMacro()` to define `Superclass` type-aliases). The `vtk::ParentClasses::enumerate()` function will invoke a functor you pass on `T` and each superclass of `T`. This is used by a new `vtk::Inheritance()` function that inserts the name of each class inherited by `T` into a container you pass to it. See `Common/Core/Testing/Cxx/TestInherits` for example usage. - `vtkThreadedCallbackQueue` can be used to run functions in the background on different threads. Use the `Push` method to add functions to the queue. The `Push` method returns a `vtkSmartPointer`, which lets users synchronize tasks. ### Data {#data} - Added `vtkImplicitArray` template class that implements a read-only `vtkGenericDataArray` interface which transforms an implicit function mapping integers to values into a practically zero cost `vtkDataArray`. This is helpful in cases where one needs to attach data to data sets and memory efficiency is paramount. - Additional backends have been added in the `vtkImplicitArray` framework: - `vtkAffineArray` that gets constructed with a slope and intercept and then returns values linearly depending on the queried index. - `vtkCompositeArray` that takes an `std::vector` at construction and returns values as if the list has been concatenated into one array. - `vtkConstantArray` that gets constructed with a given value and then returns that same value regardless of the index queried. - `vtkStdFunctionArray` which uses a `std::function` backend capable of covering almost any function one might want to use. - `vtkIndexedArray` that takes an indexing array (either `vtkIdList` or `vtkDataArray`) and a base `vtkDataArray` at construction and returns values indirected using the indexing array to give access to a shuffled array without the memory cost. - Read more about `vtkImplicitArrays` [here][add-vtkImplicitArrays]. - `ProcessIds` data array is now accessible directly from `vtkDataSetAttributes` just like any other data array (e.g GlobalIds or Normals). - Added `vtkCellGrid`. It exists to support finite element techniques using novel function spaces, which violate vtkDataSet's assumptions -- especially discontinuous Galerkin (DG) elements. - `vtkPolyhedronUtilities` added to support polyhedron decomposition into tetrahedra. Improves downstream filter results (e.g. contours) on polyhedrons with concave faces. - Added new `vtkPolyhedron::TriangulateFaces` method. - Added new `vtkStaticFaceHashLinksTemplate` templated class that can be used to group faces of an unstructured grid and eliminates duplicates. - Added `vtkHyperTreeGridGeometricLocator` which is a geometric locator for `vtkHyperTreeGrid` datasets. - `vtkHyperTreeGrid` has a new type of cursor, called `unlimited` cursors. `vtkHyperTreeGridNonOrientedUnlimitedMooreSuperCursor` and `vtkHyperTreeGridNonOrientedUnlimitedGeometryCursor` have been added. - `vtkDataSet::GetCellNumberOfFaces` can be used to get the number of faces in a given cell. - `vtkBoundingBox::ComputeBounds` added to compute the bounds for a set of points. This is used for the `GetCellBounds` method in `vtkUnstructuredGrid`, `vtkPolyData`, and `vtkExplicitStructuredGrid`. - Added `vtkCompositeDataSet::CompositeShallowCopy` which shallow copies up to dataset pointers only. - Add new `vtkNonLinearCell::StableClip` method and `vtkQuadraticTetra::StableClip` implementation. The goal of this clip is to only decompose a cell if its actually clipped, otherwise keep the non-linear cell in its entirety. Note: this clipping approach will lead to topological holes between decomposed cells and the remaining non-linear cells. - `vtkPolyData::BuildCells` has been multithreaded. - Improved performance of `vtkUnstructuredGrid`'s `IsCellBoundary`/`GetCellNeighbors` methods. - Improved stability of `vtkCellLocator::FindClosestPointWithinRadius`. - Fix `ResampleWithDataSet` with an HTG source using MPI. - In previous versions, distributed HTG where incorrectly resampled, which could led to the apparition of undesired NaN values in the output. Now, the ResampleWithDataset filter works as expected for distributed HTG. - Fix `HyperTree` iterator in `ExtractElements` method. - This branch fixes a bug when using Hover On Cell on a composite HTG Hercule base. The indexes used in the ExtractElements method in order to sanitize the output HTG can be wrong for some bases. One need to use the appropriate HyperTreeGridIterator to get correct indexes. [add-vtkImplicitArrays]: https://gitlab.kitware.com/vtk/vtk/-/blob/ba9fa5b5c9afe4e84174ac04dfa8e023ae1291bc/Documentation/release/dev/add-vtkImplicitArrays.md ### Documentation {#documentation} - The VTK documentation has undergone a major update and consolidation to enhance its usefulness for developers. The `/Documentation/docs` directory now contains the contents and configuration for the Sphinx-based website, published on the ReadTheDocs platform at https://docs.vtk.org. This consolidates all existing documentation for VTK, including the newly added list of supported data formats, API of all VTK public CMake modules, the VTK formats specification (previously part of vtk-examples), and the general information about the VTK project. Software process and conventions documentation has also been moved from docs.google.com to the new website. - In addition to the documentation website, two new resources have been introduced: the VTK book, which hosts the markdown version of the VTK book at https://book.vtk.org and VTK examples at https://examples.vtk.org, which contain many examples with redirects put in place to ensure the previous URL remains functional. Many other updates to the documentation have also been made, including improved documentation structure, removal of obsolete documents, and addition of imported third-party projects to the developer guide. VTK documentation now follows a versioning system and is actively maintained alongside the code. - Contributions and feedback are welcome for all three websites to ensure that the VTK documentation remains up-to-date. - **Next steps** - The next steps for the VTK documentation project include setting up a versioning system for docs, doxygen, and the book. Work is also underway to include a description of each `Modules` (as well as a `README.md` file) in `docs.vtk.org`. And there are plans to explore the possibility of using merge request previews for the documentation so that contributors don't have to compile it themselves. - For `examples.vtk.org`, the plan is to consolidate examples from VTK and `vtk-examples`. - Pages on the `mediawiki` site will be marked as deprecated, and a link to `docs.vtk.org` will be included. - These efforts will help ensure that VTK documentation remains user-friendly and accessible to all developers. ### Filters {#filters} - Added Filters/GeometryPreview module which include filters for creating a preview of the geomertry of a dataset. Current GeometryPreview filters are: - `vtkPointSetToOctreeImageFilter`, used to convert a `vtkPointSet` into an image with a number of points per cell target and an `unsigned char` octree cell array. - `vtkOctreeImageToPointSetFilter`, used to convert an image with an `unsigned char` octree cell array to a `vtkPointSet`. - `vtkPointSetStreamer`, used to stream points as buckets. - `vtkImageReslice` now supports oriented images, and can reslice an image into a new orientation via the new `SetOutputDirection()` method. - `vtkDistancePolyDataFilter` can now output directions in conjunction with the (signed/unsigned) distances. This is enabled using `ComputeDirection` (default:off). - `vtkVortexCore` now outputs 2 extra arrays, `vorticity` and `vorticity_magnitude`. - `vtkQuadricDecimation` has the following changes: - Added new `MapPointData` property to which maps input point data to its decimated output. - Added regularization mode. This is enabled by setting `vtkQuadricDecimation::SetRegularize(true)` and `vtkQuadricDecimation::SetRegularization(value)` where `value` is the standard deviation used in the Gaussian distribution. - `vtkHyperTreeGridGradient` has added support for vector fields. The resulting gradient has 3 times the number of components as the input field. Additionally, vorticity, divergence and Q-Criterion can now be computed. - `vtkHyperTreeGridContour` now has 2 contour strategies in the 3D case: the former behavior called `USE_VOXELS`, and the new `USE_DECOMPOSED_POLYHEDRA` which can produce better contour results when the generated dual cells used for contouring appear to be concave. Note: `USE_DECOMPOSED_POLYHEDRA` is much slower than the former strategy. - `vtkExtractCells` has new flags `PassThroughCellIds` and `OutputPointsPrecision`. - `vtkProbeFilter` has new flag `SnapToCellWithClosestPoint` which can be used with `vtkPointSet` inputs to snap the probe points to the cell with the closest point. - `vtkPlaneCutter` has new flags `OutputPointsPrecision` and `MergePoints`. - `vtkPCANormalEstimation` has two new search modes used for the selection of neighbor points: KNN and RADIUS. - Various optimizations for `vtkGeometryFilter`: - Significant memory reduction (x5) with the introduction of `vtkStaticFaceHashLinksTemplate`. - Significant speedup (x100) for `vtkGeometryFilter`'s conversion of `vtkUnstructuredGrid` to `vtkPolyData` if the `vtkUnstructuredGrid` has only either vertices, or lines, or polys, or strips. - Improved performance of `vtkResampleToImage`. - Improved performance of `vtkDistancePolyDataFilter`. - Improved performance of `vtkFrustumSelector`. - Improved performance of `vtkExtractSelection`. - Improved memory performance for `vtkCellDataToPointData`. - Added more VTK-m accelerated filter overrides. If the `VTK::AcceleratorsVTKmFilters` is enabled and the CMake option `VTK_ENABLE_VTKM_OVERRIDES` is ON, the following filters will be overridden: - `vtkGradientFilter` -> `vtkmGradient` - `vtkTableBasedClipDataSet` -> `vtkmClip` - `vtkCutter` -> `vtkmSlice` - `vtkThreshold` -> `vtkmThreshold` - `vtkCellDataToPointData` -> `vtkmAverageToPoints` - `vtkPointDataToCellData` -> `vtkmAverageToCells` - The following filter components have been multithreaded: - `vtkRectilinearGrid::GetPoints` - `vtkExtractCells` - `vtkExtractSelection::ExtractSelectedCells` - `vtkExtractSelection::ExtractSelectionPoints` - `vtkExtractGeometry` - `vtkPolyDataNormals` - `vtkProbeFilter::ProbeEmptyPoints` - `vtkTableBasedClipDataSet` - `vtkThreshold` - New filter `vtkHyperTreeGridPProbeFilter` can be used to probe a `vtkHyperTreeGrid` using `vtkDataSet`. - New filter `vtkFieldDataToDataSetAttribute` provides a way to efficiently pass FieldData single-value arrays to other AttributeData. This is useful for composite data, where FieldData can be used to store a single scalar, varying at block level only. Moving this scalar, for instance, to PointData, allows to use it in your pipeline. - New filter `vtkTensorPrincipalInvariants` computes principal values and vectors from 2D and 3D symmetric tensors. - The new `vtkYieldCriteria` filter computes different yield criteria from given 2D or 3D symmetric tensors. Available yield criteria currently include: - Tresca criterion - Von Mises criterion - Added support for `vtkHyperTreeGrid` with `vtkValueSelector`, `vtkLocationSelector` and `vtkFrustumSelector`. The selections generate can also now be extracted with the `vtkExtractSelection` filter. - Added `HyperTreeGridToUnstructuredGrid` boolean flag to `vtkExtractSelection` filter to control whether to output an unstructured grid (when `true`) or a hyper try grid (when `false`, the default). - Fix `vtkHyperTreeGridAxisClip` when `insideout` is `true`. - The `vtkHyperTreeGridGeometry` filter now provides `PassThroughCellIds` (default `false`) to pass through original cell IDs from the input `vtkHyperTreeGrid` to the output `vtkPolyData`. - Added support for `vtkHyperTreeGrid` resampling with `vtkResampleWithDataSet` and `vtkPResampleWithDataSet` filters. - `vtkPolyDataToUnstructuredGrid` is a new multithreaded filter that converts\ `vtkPolyData` to `vtkUnstructuredGrid`. - Added `vtkAttributeDataToTableFilter` filter to VTK from ParaView. It serves to turn a data object into a table by shallow copying its attributes into row data. This replaces `vtkDataObjectToTable`, which has been deprecated. - `vtkBoundaryMeshQuality` filter added to compute quality metrics for boundary meshes. - `vtkGenerateProcessIds` filter added to generate process ids for both PointData and CellData, and store it via ProcessIds attribute. This filter replaces `vtkProcessIdScalars`, which has been deprecated. - Added `PointDataWeighingStrategy` option to `vtkCleanUnstructuredGrid` for choosing how to collapse point data. Previously, when merging duplicate points, the point with the lowest index had its data transported to the merged output point. With this new option, you can now choose between: - `vtkCleanUnstructuredGrid::FIRST_POINT` (for backwards compatibility): where the point with the lowest index in the input gets the ownership of the merged point. - `vtkCleanUnstructuredGrid::AVERAGING`: where the data on the merged output point is the number average of the input points. - `vtkCleanUnstructuredGrid::SPATIAL_DENSITY`: where the merged point data is averaged using a partition of the volumes in the cells attached to each point being merged. - `vtkTableFFT` no longer adds or squeezes certain arrays, like those starting with `vtk`, when the input and the output have a different size. - `vtkTableFFT` now supports complex valued FFTs. - Added hemispherical capping support along with texture coordinates for `vtkCylinderSource` to replace the `vtkCapsuleSource` which has now been deprecated. - `vtkClipClosedSurface` now provides the ability to clip on the reverse side of the clipping planes and also provides the new triangulated geometry created by clipping as a second output. ### I/O {#io} - VTK now supports [URI](https://datatracker.ietf.org/doc/html/rfc3986) parsing, resolution and loading through the two new classes `vtkURI` and `vtkURILoader`. URI support as been implemented to enable resource stream support in readers that need to access multiple resources. For more information about URI usage and loading, please refer to the `vtkURILoader` documentation. - `vtkResourceStream` added as customizable replacement for standard istreams. Added `vtkFileResourceStream` and `vtkMemoryResourceStream` implementations. - `vtkResourceParser` added as a high-performance formatted input parser. `vtkResourceParser` parses strings, floats, integers and booleans from any `vtkResourceStream`. Most `std::istream` common features have equivalent methods in `vtkResourceParser`, making migration mostly trivial. - Added `vtkPLYReader`, `vtkGLTFReader` and `vtkOBJReader` support for reading from `vtkResourceStream`. - `vtkMemoryResourceStream` can now own a streamed buffer, meaning you can free the source buffer after setting it. You can now set source buffer as a `std::string`, a `std::vector` or a `vtkBuffer*`. - Added `vtkNek5000Reader` to support NEK5000 data format. - Added `vtkOpenVDBReader` in the `IOOpenVDB` module read to .vdb files. - Added `vtkIOSSWriter` writer for the Exodus file format implemented using the [IOSS library](https://sandialabs.github.io/seacas-docs). Input can be `vtkPartitionedDataSetCollection`, `vtkPartitionedDataSet` or `vtkDataSet`. `vtkIOSSWriter` can be executed in parallel. - Added support for higher-order Lagrange cells with `vtkIOSSReader`. - `vtkIOSSReader` now supports mixed-order, 12-node wedge elements. - Added flag `ReadAllFilesToDetermineStructure` to `vtkIOSSReader` which toggles reading all files or only reading the first file to determine mesh structure. - Added `vtkNetCDFUGRIDReader` support for reading 2D meshes from NetCDF UGRID files. - `VTKHDF`'s major version has been incremented to 2 due to the following additions: - Added `VTKHDF` support for both static and transient `vtkPolyData` files. The metadata schematic for how transient data is read is shown below (first image). - Added `VTKHDF` support for transient `ImageData` and `UnstructuredGrid` data. The metadata schematic for how transient data is read is shown below (second image). - Specific documentation related to the evolution of the `VTKHDF` format can be found [here](https://kitware.github.io/vtk-examples/site/VTKFileFormats/). - Added ANSYS Fluent CFF Reader (Common Fluid Format) into its own dedicated module `VTK::IOFLUENTCFF`, which currently supports the new `vtkFLUENTCFFReader`. See further documentation [here][fluent-ccf-docs]. - Added `vtkNumberToString::SetHighExponent` and `vtkNumberToString::SetLowExponent` to control the exponent range for scientific or fixed notation. - Fixed reading fault on vector fields with `vtkXMLHyperTreeGridReader`. - Added support for mixed cell unstructured grids in `vtkConduitSource`. See `ValidateMeshTypeMixed` and `ValidateMeshTypeMixed2D` tests in `IO/CatalystConduit/Testing/Cxx/TestConduitSource.cxx` for more details. - `vtkDataObjectToConduit` now supports polygons, `vtkPolyData` and mixed shapes `vtkUnstructuredGrid` topologies. ![poly data hdf schema](imgs/9.3/poly_data_hdf_schema.png) ![schema](imgs/9.3/transient_hdf_schema.png) - Add `vtkMPICommunicator` support for MPI message lengths > MAX_INT, which can now occur in MPI 4.X and later. - Added `vtkMPICommunicator::NoBlockSend` method that allows for dynamic MPI types. - Fixed bugs in `vtkMPICommunicator::Test*` and `vtkMPICommunicator::Wait*` that prevented them from being called repeatedly. - `vtkIOSSReader` can now merge entity blocks into a single block for the exodus format using the flag `MergeExodusEntityBlocks` which is off by default. This is useful e.g. for cases where the entity blocks just represent different cell types but they actually describe the same block. - Incorrect `vtkEnSightWriter` output has been fixed for `VTK_POLYGON`, `VTK_WEDGE`, `VTK_QUADRATIC_WEDGE`, `VTK_QUADRATIC_EDGE` or `VTK_CONVEX_POINT_SET` cell types. Support for `VTK_POLYHEDRON` has also been added. - Added flag `WriteNodeIDs` to `vtkEnSightWriter`, which toggles writing node and element IDs to the EnSight data. This makes the output geometry file significantly smaller. - Added property `SizeAverageCellToPoint` to `vtkOpenFOAMReader` that allows the user to weigh the cell point averaging operation by cell size. [fluent-ccf-docs]: https://docs.vtk.org/en/latest/modules/vtk-modules/IO/FLUENTCFF/README.html ### Interaction {#interaction} - Add support for removing intermediate layers with `vtkExpandMarkedElements`. Added boolean flags `RemoveSeed` and `RemoveIntermediateLayers`. Using these flags will remove their respective layers, keeping only the final expansion layer. This functionality has been extended for use in `vtkSelectionSource` and `vtkSelector`. - `vtkAppendSelection` `SetColorArray`, `SetInputColor` and `GetInputColor` methods added to associate colors to selections which are used to generate a color array. - `vtkCamera`s can now be oriented with the `vtkCamera3DWidget` and its representation `vtkCamera3DRepresentation`. The representation allows you to move the camera position, target position, to rotate the view up and to update its view angle. See example: ![camera widget example](imgs/9.3/camera_widget.png) - Added `vtk3DCursorWidget` and `vtk3DCursorRepresentation` to track mouse in a scene. The 3D cursor follows the mouse and is placed on the surface of the actor's scene. Note: this behavior does not currently support volumes. - Added `SetForce3DArcPlacement` API to `vtkAngleRepresentation2D` which allows users to force correct the 3D placement of arcs that may be misalligned. - Moved `vtkCompassWidget` and `vtkCompassRepresentation` from `Geovis/Core` to `Interaction/Widgets`. Previously these classes were in a non-working state, but have been fixed with the following changes: - `vtkSliderRepresentation` and subclasses: Fixes were applied to correctly calculate the local coordinate for the slider position. They also now honor their `Visibility` parameter. - In `vtkCompassWidget` you can now adjust the update `TimerDuration`, `TiltSpeed` and `DistanceSpeed` when clicking on the slider end caps. - Added standardized color setters (`SetForegroundColor`, `SetHandleColor` and `SetInteractionColor`) to several widgets used by ParaView. These widgets include `vtkBoxRepresentation`, `vtkCurveRepresentation`, `vtkLineRepresentation`, `vtkSphereRepresentation`, `vtkImplicitCylinderRepresentation`, `vtkImplicitPlaneRepresentation`, `vtkDisplaySizedImplicitPlaneRepresentation` and `vtkPointHandleRepresentation3D`. Description of added methods: The intended use of these colors is as follows: | Color | Description | | ----------- | ----------- | | `HandleColor` | Widget handles that are available to interact with via click+drag. | | `InteractionColor` | Widget handles the user is interacting with (via a click+drag) or hovering over. | | `ForegroundColor` | Widget elements meant to contrast with the background and which are not interactive. | - Added `vtkOrientationWidget` and its representation `vtkOrientationRepresentation` which are used to rotate any actor. The appearance of widget controls are customizable through the representation. See examples: ![orientation widget demonstration](imgs/9.3/orientation_widget_demo.gif) ![orientation widget representations](imgs/9.3/orientation_widget_states.gif) ### Math {#math} - Add `GetOctaveFrequencyRange` computation to `vtkFFT` which gets lower/upper frequencies of octaves. Parameters include `octaveSubdivision`, from which you can choose one-third, half, or full octave frequency ranges (default is full) as well as `baseTwo` which toggles between base 2 and base 10 power (default is base 2). ### Module System {#module-system} - Added `vtk_module_wrap_python(HEADERS_DESTINATION)` argument. This argument adds a header into the install tree that initializes the builtin module table for statically built Python modules. This header had not been installed previously. ### Python {#python} - Added `ModernizePythonImports.py` script that parse Python scripts and replaces "import vtk" with module specific imports for performance. - `vtkDataObject`'s now support pickling by the Python [`pickle` module](https://docs.python.org/3/library/pickle.html). - To use this new feature in python, you must first run: ```python import vtkmodules.util.pickle_support ``` - Once you have imported the module the pickling of data objects is straightforward: ```python from vtkmodules.vtkFiltersSources import vtkSphereSource import vtkmodules.util.pickle_support import pickle sphereSrc = vtkSphereSource() sphereSrc.Update() pickled = pickle.dumps(sphereSrc.GetOutput()) unpickled = pickle.loads(pickled) print(unpickled) ``` - Python 3.12 wheels are now provided for the following platforms: - Linux x86\_64 - Linux x86\_64 (with OSMesa) - macOS x86\_64 - macOS arm64 - Windows x86\_64 - Windows x86\_64 (with OSMesa) ### Qt {#qt} - Added minimal Qt/VTK example application `MinimalQtVTKApp`. - QML integration support has been upgraded to allow a vtkRenderWindow per QQuick item. - Added custom cursor methods to `QVTKOpenGLStereoWidget` and `QVTKOpenGLNativeWidget` that get/set the cursor shape. ### Rendering {#rendering} - Added `VTK_USE_WIN32_OPENGL` option to disable Win32 API in `VTK::RenderingOpenGL2` on Windows. This enables OSMesa support on Windows. - Improved performance of `vtkTupleInterpolator`. - Added new module providing `zSpace` support to VTK, implementing render window, interactor style, camera, etc. Supports both the "Core zSpace API" (legacy) and the "Core Compatibility zSpace API" (latest). - `vtkAxisActor2D` labels now use `UseFontSizeFromProperty`, which was formerly used exclusively by the title. - `vtkImageResliceMapper` now fully supports oriented images, in the same manner as `vtkImageSliceMapper`. This allows the display of arbitrary oblique slices of oriented images, including those where the orientation matrix has a negative determinant. - Improved performance and consistency of `vtkRenderWindowInteractor::ProcessEvents` across all platforms. - `vtkCompositePolyDataMapper` can now color separate blocks with different scalar arrays. To use this functionality, turn on `ScalarVisibility` and select a `ScalarMode` and/or a `ColorMode`. - Improved performance of `vtkContext2D` for rendering large numbers of points. - `vtkCompositePolyDataMapper` can now use separate lookup tables and interpolation modes for different blocks in a composite dataset. You can override lookup table and other related attributes like scalar interpolation and scalar ranges. Refer to `vtkMapper` documentation. Here's a summary: - `ScalarVisibility`: True/False - `UseLookupTableScalarRange`: When true, the mapper shall import the range from the lookup table. - `InterpolateScalarsBeforeMapping`: Applies when mesh is colored using point scalars. This flag decides whether point colors are sampled using texture maps instead of interpolating colors on the GPU after scalars are mapped to colors. - `ColorMode`: Specifies whether to map scalars to colors or directly use the scalars as RGB(A) values. - `ScalarRange`: Specifies a range of scalars for color mapping. - `LookupTable`: Specifies a lookup table. - `vtkCompositePolyDataMapper` in VTK::RenderingCore has been improved to efficiently render large datasets. It now performs as well as `vtkCompositePolyDataMapper2` in the VTK::RenderingOpenGL2 module, which has now been deprecated. This refactor has significantly impacted the following VTK modules: - `vtkCompositePolyDataMapper` now has an API similar to `vtkCompositePolyDataMapper2`. - `vtkCompositeSurfaceLICMapper` derives `vtkCompositePolyDataMapper` instead of `vtkCompositePolyDataMapper2`. - The OSPRay module uses `vtkCompositePolyDataMapper` instead of `vtkCompositePolyDataMapper2`. - `vtkVtkJSSceneGraphSerializer` uses `vtkCompositePolyDataMapper` instead of `vtkCompositePolyDataMapper2`. - Added new `vtkOpenGLES30PolyDataMapper` supports polydata and composite dataset rendering with OpenGL ES 3.0. If VTK was configured with `VTK_OPENGL_USE_GLES=ON`, this mapper is an override for `vtkPolyDataMapper`. - Fixed `vtkSurfaceLICMapper` crash when rendering lines as tubes or points as spheres. - `vtkTextureObject` can now be used to create texture buffers on all OpenGL implementations that support 2D textures. - Fixed `vtkCamera` CAVE bugs for head tracking and volume rendering. - Fixed compositing artifacts when volume rendering in parallel with the OSPRay raycaster. This fix adds a new `VolumeSamplingRate` parameter to `vtkOSPRayRendererNode`. - `vtkPolarAxesActor` has a number of new features. - Radial/polar axes and arc ticks are now customizable. `SetRequestedNumberOfRadialAxes`, `SetRequestedDeltaAngleRadialAxes`, `SetArcTickMatchesRadialAxes`, `SetRequestedNumberOfPolarAxes`, `SetRequestedDeltaAnglePolarAxes`, `SetArcTickMatchesPolarAxes`, `SetDeltaAngleMajor`, and `SetDeltaAngleMinor` are all new methods. - Tick size is now computed as a ratio of maximum radius by default. You can specify a value for this ratio using `SetTickRatioRadiusSize`, default is 0.02. - You can now change polar arcs resolution per degree. See `SetPolarArcResolutionPerDegree`, default is 0.2. - Text offsets are now customizable with `SetPolarTitleOffset`, `SetRadialTitleOffset`, `SetPolarLabelOffset` and `SetPolarExponentOffset`. - `vtkMultiVolume` now supports RGBA volume inputs in a similar way to the existing single-input volume rendering. When turning off the `IndependentComponent` flag of the `vtkVolumeProperty` and providing 4-components to the mapper values are interpreted as RGBA. - Added new gradient background modes. You can select from various gradient background modes with `vtkViewport::SetGradientMode`. The following modes are available: - `VTK_GRADIENT_VERTICAL` Background color is used at the bottom, Background2 color is used at the top. - `VTK_GRADIENT_HORIZONTAL` Background color on the left, Background2 color on the right. - `VTK_GRADIENT_RADIAL_VIEWPORT_FARTHEST_SIDE` Background color in the center, Background2 color on and beyond the circle ellipse edge. Circle/Ellipse touches all sides of the square/rectangle viewport. - `VTK_GRADIENT_RADIAL_VIEWPORT_FARTHEST_CORNER` Background color in the center, Background2 color on and beyond the circle/ ellipse edge. Circle/Ellipse touches all corners of the square/rectangle viewport. See gradient background examples: - Fix incorrect values from `vtkOpenGLRenderWindow::GetZBufferData` in OpenGL ES 3.0. - `vtkOpenGLRenderWindow::GetZBufferData` now returns the correct depth values in OpenGL ES 3.0 where the depth component is typically only 24-bit wide. - Fix GPU Ray Cast Volume Rendering with `ModelTransformMatrix`. - For CAVE environments, the `vtkCamera` class provides a `ModelTransformMatrix` as a means of manipulating all the objects in a scene. However, actually using this matrix effectively changes the position of the camera (or eye), which is used by the `vtkOpenGLGPUVolumeRayCastMapper`. This issue prevented CAVE users from interacting with volume data in the CAVE, as written up [here](https://gitlab.kitware.com/paraview/paraview/-/issues/21471). This change fixes the gpu volume rendering mapper by removing from developers the responsibility to pass the cameraPos uniform so that it matches the actual transformations applied to each vertex in the vertex shader. Instead, the effective eye position in dataspace is computed automatically. Furthermore, this is done on the cpu, saving a matrix/matrix multiply and several matrix/vector multiplies in the fragment shader. - Fix Off-axis stereo image separation issue. - Fix how the final transformation, T, described in "Generalized Perspective Projection" is applied when doing off-axis projection. This transform encapsulates the viewpoint offset, and should be computed using the same eye positions used to compute the rest of the projection matrix, but was inadvertently computed using the single EyePosition. The result of the bug was that stereo images of an object were always a fixed distance apart from each other, regardless of the objects location w.r.t. the screen, and regardless of the the eye position w.r.t. the object and screen. This change moves computation of the left/right eye into a new method GetStereoEyePosition() and uses that from both the projection and view transform computations. Also adds a test to render three disks at different locations with respect to the screen to ensure the stereo image pairs behave correctly. - Fix Display Attribute Inheritance For `vtkOpenGLGlyph3DMapper`. - The vtkOpenGLGlyph3DMapper can now correctly override visibility, colors, opacities and pickability of individual blocks. ![vtkViewport gradient modes example](imgs/9.3/add-radial-gradient-background.png) ### Third Party {#third-party} - `fast_float` added as a vendored package. It is available using the `VTK::fast_float` module. ### VTK-m {#vtk-m} - VTK-m submodule has been updated to the latest release, VTK-m 2.0.0. Being a major update, it significantly breaks compatibility with the API provided by VTK-m 1.X. Thus, many changes were needed in VTK to make it compatible with VTK-m 2.0.0. - All VTK-m cmake targets are now prefixed with `vtkm_`. Exceptions have been made for `vtkm::cuda` and `vtkm::kokkos_hip`, for compatibility with external VTK-m imports. - VTK-m VTK module is now called `vtk::vtkvtkm` as opposed to `vtk::vtkm`. - `vtkmlib` functions that translate VTK to VTK-m data structures now respect coordinates system changes. Coordinates systems are now represented as a field inside the VTK-m dataset rather than a special/unique component. - The Fides library has been updated upstream to ensure compatibility with VTK-m 2.0.0. This update in upstream has been brought to VTK to enable using VTK-m 2.0.0 and Fides through VTK. ---------------------------------------- ## Deprecated and Removed Features {#deprecated-and-removed-features} ### Legacy {#legacy} The following APIs were deprecated in 9.1 or earlier and are now removed: - Python 2 support has been removed. - Threading types (use C++ `std` classes instead): - `vtkSimpleConditionVariable` (`std::condition_variable`) - `vtkConditionVariable` (`std::condition_variable`) - `vtkMutexType` - `vtkSimpleMutexLock` (`std::mutex`) - `vtkMutexLock` (`std::lock_guard`) - `vtkCritSecType` - `vtkSimpleCriticalSection` (`std::mutex`) - The `EvaluateLocationProjectedNode` method has been removed on the following classes; use `EvaluateLocation` instead: - `vtkBezierCurve` - `vtkBezierHexahedron` - `vtkBezierQuadrilateral` - `vtkBezierTetra` - `vtkBezierTriangle` - `vtkBezierWedge` - `vtkBezierInterpolation::flattenSimplex` has been renamed to `::FlattenSimplex` - `vtkBezierInterpolation::unflattenSimplex` has been renamed to `::UnFlattenSimplex` - `vtkBezierInterpolation::deCasteljauSimplex` has been renamed to `::DeCasteljauSimplex` - `vtkBezierInterpolation::deCasteljauSimplexDeriv` has been renamed to `::DeCasteljauSimplexDeriv` - `vtkHigherOrderHexahedron::getEdgeCell` has been renamed to `::GetEdgeCell` - `vtkHigherOrderHexahedron::getFaceCell` has been renamed to `::GetFaceCell` - `vtkHigherOrderHexahedron::getInterp` has been renamed to `::GetInterpolation` - `vtkHigherOrderQuadrilateral::getEdgeCell` has been renamed to `::GetEdgeCell` - `vtkHigherOrderTetra::getEdgeCell` has been renamed to `::GetEdgeCell` - `vtkHigherOrderTetra::getFaceCell` has been renamed to `::GetFaceCell` - `vtkHigherOrderTriangle::eta` has been renamed to `::Eta` - `vtkHigherOrderTriangle::deta` has been renamed to `::Deta` - `vtkHigherOrderTriangle::getEdgeCell` has been renamed to `::GetEdgeCell` - `vtkHigherOrderQuadrilateral::getBdyQuad` has been renamed to `::GetBoundaryQuad` - `vtkHigherOrderQuadrilateral::getBdyTri` has been renamed to `::GetBoundaryTri` - `vtkHigherOrderQuadrilateral::getEdgeCell` has been renamed to `::GetEdgeCell` - `vtkHigherOrderQuadrilateral::getInterp` has been renamed to `::GetInterpolation` - `vtkIncrementalOctreeNode::InsertPoint` without `numberOfNodes` is removed for the variant with it - `vtkLine::Intersection3D` has been replaced by `vtkLine::Intersection` - `vtkPointData::NullPoint` has been replaced by `vtkFieldData::NullData` - `vtkSelectionNode::INDEXED_VERTICES` has been removed - `vtkReaderExecutive` has been removed - `vtkThreadMessager` has been removed; use C++ `std` threading support instead - `vtkPassThroughFilter` has been replaced by `vtkPassThrough` - `vtkXMLPPartitionedDataSetWriter` has been replaced by `vtkXMLPartitionedDataSetWriter` - `vtkBlueObeliskData::GetWriteMutex` has been replaced by `::LockWriteMutex` and `::UnlockWriteMutex` - `vtkThreshold::ThresholdByLower` has been replaced by `::SetLowerThreshold` or `::SetThresholdFunction` - `vtkThreshold::ThresholdByUpper` has been replaced by `::SetUpperThreshold` or `::SetThresholdFunction` - `vtkThreshold::ThresholdBetween` has been replaced by `::SetLowerThreshold` and `::SetUpperThreshold` or `::SetThresholdFunction` - `vtkMultiBlockFromTimeSeriesFilter` has been replaced by `vtkGroupTimeStepsFilter` - `vtkDataSetGhostGenerator` has been replaced by `vtkGhostCellsGenerator` - `vtkDataSetSurfaceFilter` methods `::GetUseStrips`, `::SetUseStrips`, `::UseStripsOn`, and `::UseStripsOff` have been removed - `vtkStructuredGridGhostDataGenerator` has been replaced by `vtkGhostCellsGenerator` - `vtkUniformGridGhostDataGenerator` has been replaced by `vtkGhostCellsGenerator` - `vtkUnstructuredGridGhostCellsGenerator` has been replaced by `vtkGhostCellsGenerator` - `vtkPDataSetGhostGenerator` has been replaced by `vtkGhostCellsGenerator` - `vtkPStructuredGridGhostDataGenerator` has been replaced by `vtkGhostCellsGenerator` - `vtkPUniformGridGhostDataGenerator` has been replaced by `vtkGhostCellsGenerator` - `vtkPUnstructuredGridGhostCellsGenerator` has been replaced by `vtkGhostCellsGenerator` - `vtkOpenGLRenderer::HaveApplePrimitiveIdBug` has been removed as no supported macOS release has the issue anymore - `vtkOpenGLRenderWindow` has removed the following methods: - `::GetBackLeftBuffer` - `::GetBackRightBuffer` - `::GetFrontLeftBuffer` - `::GetFrontRightBuffer` - `::GetBackBuffer` - `::GetFrontBuffer` - `vtkOpenGLRenderWindow::GetOffScreenFramebuffer` has been replaced by `::GetRenderFramebuffer` - `vtkDataEncoder::PushAndTakeReference` has been replaced by `::Push` - `vtkGenericOpenGLRenderWindow::IsDrawable` is removed - `vtkIOSRenderWindow::IsDrawable` is removed - `vtkCocoaRenderWindow::IsDrawable` is removed - `vtkRenderWindow::IsDrawable` is removed - `vtkDIYUtilities::GetDataSets` is replaced by `vtkCompositeDataSet::GetDataSets` - `vtkCurveRepresentation::*DirectionalLine*` methods have been renamed to `::*Directional*` - `vtkSimpleImageFilterExample` has been removed - `vtkExodusIIReaderPrivate::PrintData` has been renamed to `::PrintSelf` - `vtkEnSightReader::ReplaceWildcards` has been replaced by `vtkGenericEnSightReader::ReplaceWildcardsHelper` - `vtkQtSQLDatabase::*Port` has been renamed to `::*DbPort` to avoid Windows SDK macro collisions - The `vtkDataSetSurfaceFilter::GetInterpolatedPointId` overload without `weights` has been replaced by the one with it ### Charts {#charts} - `vtkPlot` color setter/getter methods with floating point parameters are now suffixed with `F`. The former methods without the suffix have been deprecated. For example: - `vtkPlot::SetColor(double r, double g, double b)` has been moved to `vtkPlot::SetColorF(double r, double g, double b)`. ### Core {#core} - The `vtkStdString` implicit conversion to `const char*` is deprecated. Instead, call `.c_str()` explicitly on the instance. - `vtkVariant::ToX` and related string parsing no longer supports `[-]infinity` as a valid float conversion. Only `[-]inf` is now supported. ### Data {#data} - Deprecated `vtkCompositeDataSet::RecursiveShallowCopy`, use `vtkCompositeDataSet::ShallowCopy` instead. - `vtkUnstructuredGrid::GetCellLinks` has been deprecated, `vtkUnstructuredGrid::GetLinks` instead. - `vtkAbstractCellLinks::BuildLinks(vtkDataSet*)` has been deprecated, use `vtkAbstractCellLinks::BuildLinks()` instead. ### Filters {#filters} - `vtkDataObjectToTable` is deprecated in favor of `vtkAttributeDataToTableFilter`, which has the same functionality. - `vtkProcessIdScalars` is deprecated in favor of `vtkGenerateProcessIds`. The following is a migration example: - Deprecated `vtkProcessIdScalars` code: ```cpp vtkNew processIdsGenerator; processIdsGenerator->SetInputConnection(someData->GetOutputPort()); processIdsGenerator->SetScalarModeToCellData(); processIdsGenerator->Update(); vtkDataSet* pidGeneratorOutput = processIdsGenerator->GetOutput(); vtkIntArray* pidArray = vtkIntArray::SafeDownCast(pidGeneratorOutput->GetCellData()->GetArray("ProcessId")); ``` - New `vtkGenerateProcessIds` code: ```cpp vtkNew processIdsGenerator; processIdsGenerator->SetInputConnection(someData->GetOutputPort()); processIdsGenerator->GeneratePointDataOff(); processIdsGenerator->GenerateCellDataOn(); processIdsGenerator->Update(); vtkDataSet* pidGeneratorOutput = processIdsGenerator->GetOutput(); vtkIdTypeArray* pidArray = vtkIdTypeArray::SafeDownCast(pidGeneratorOutput->GetCellData()->GetProcessIds()); ``` - `vtkCapsuleSource` is deprecated in favor of `vtkCylinderSource::SetCapping(true)` and `vtkCylinderSource::SetCapsuleCap(true)`, which has the same functionality. ### I/O {#io} - `vtkOpenFOAMReader` support for polyhedral decomposition, `SetDecomposePolyhedra`, has been deprecated. - `vtkNumberToString::operator()` has been deprecated in favor of `vtkNumberToString::Convert`. ### Python {#python} - The VTK wheels no longer provide the `VTK::PythonInterpreter` module as it is unnecessary in such situations. ### Rendering {#rendering} - `vtkXOpenGLRenderWindow::SetSizeNoXResize()` has been deprecated due to structural RenderingUI changes in VTK 9.0. - `vtkOutputWindowCleanup` has been deprecated as it is no longer used. - `vtkCompositePolyDataMapper2` has been deprecated in favor of `vtkCompositePolyDataMapper` following the latter's performance improvements. ---------------------------------------- ## Other Changes {#other-changes}