GitLab

(cherry picked from commit f2439b95)

This commit adds support for Lagrange cells of the following shape:
curve, triangle, quadrilateral, tetrahedron, hexahedron, and wedge.
The new cell types may have arbitrary order, up to a compile-time maximum of 10.
The maximum may be changed easily.
The order is inferred from the number of points defining the cell
and is assumed to be the same along each coordinate axis.

Visualization operations that cells must provide (contouring, clipping, cutting)
are implemented by approximating each higher-order cell as a collection of
multi-linear "primitive" cells of the same shape.

Note that the wedge element, when asked for boundary faces, returns faces
with outward-pointing normals. This is not the same convention as vtkWedge
but is the same as other VTK cell shapes.

See the vtkCellTypeSource class in vtkFiltersSources for an example of how
cell connectivity is specified. In general, the shape corner points are
specified first, matching the linear cell counterparts. Then points on
edges and faces bounding the shape are listed. Finally, interior points
are listed. This will allow simpler connectivity entries in the future
where points on edges and faces may only require 2 numbers each instead
of a number proportional to the order raised to the parametric dimension
of the boundary.

T. J. Corona provided the triangle and tetrahedron implementations.

This reverts commit 13647772.

This reverts commit 61908bd7.

In this commit, we provide a complete revision and extension of support for
hypertreegrid objects and filters, hereby entirely superseding the first
versions thereof which we developed in 2011-2012.
When compared to those obtained by constructing an intermediate
unstructured mesh with fully described connectivity, this new structure
demonstrates a gain of at least 80% in terms of memory footprint,
with a better rendering while retaining similar execution speed.

All ancillary structures such as cursors and supercursors have also
been entirely refactored, for the sake of performance as well as of
ease of maintenance. Existing native filters, i.e., that operate
directly on hypertreegrid objects, have been revised accordingly.
In addition, several new native filters have been added, together with
a large set of non-regression tests and baseline images.

This commit also implements an adaptive approach in order to accelerate the
rendering of 2-dimensional hypertreegrids, hereby solving the problem posed
by the loss of interactivity that occurs when dealing with large and/or
deeply refined meshes. Specifically, view parameters are taken into account,
in order to: on one hand, avoid creating surface elements that are
outside of  the view area; on the other hand, utilize level-of-detail
properties to cull those cells that are deemed too small to be visible
with respect to the given view parameters. This adaptive approach typically
results in a massive increase in rendering performance.

Please refer to the following articles for a comprehensive description:
https://arxiv.org/abs/1702.04852
https://arxiv.org/abs/1703.00212

This commit is the initial set of classes and implementation for
a new cell locator. It uses a threaded implementation to support
high-performance construction of the locator. It is based on a
uniform binning and vtkSMPTools.

Proj Upstream authored Mar 08, 2016 and Lipsa, Dan committed Mar 08, 2016

Code extracted from:

    https://gitlab.kitware.com/third-party/proj.git

at commit 41bdf05361007f8c5186f3df9944d86bb273ed13 (for/vtk).

Flying edges is now interpolating point attribute data when the
flag InterpolateAttributes is set.

Also made some minor performance tweaks to make up for the extra work.

Cleaned up and modernized vtkSortDataArray. Using std::sort and
threaded the sort operation (with vtkSMPTools). Removed static
variable that made it non-thread-safe. Added the ability to sort
in ascending as well as descending order. Expanded and improved
the test TestSortDataArray.

Note that the code handles vtkStdString and vtkVariant.

Note also: various types of arrays, including the vtkIdList, needed
to be expanded so the SetArray() (or equivalent operation to
specify the under-the-hood array to use). This is so the sort
can swap out the data once the data is shuffled.

Fully implemented classes, expanded testing.

A templated static cell links class was created for performance
and memory reasons. However, to enhance usability, a instantiated
version based on vtkIdType was created so that it could be accessed
from wrapped languages (e.g., Python).

This is a threaded implementation of cell links construction. This
class generates links from each point to all of the cells that use
it. It is non-incremental, meaning that it it built once (statically)
and if the underlying topology changes, it must be built again.

A new class for constructing a point locator. The class is threaded
and templated for performance. It is a static locator, meaning that
it can only be built once (and incremental insertion is not allowed).
The code also specially treats 32-bit versus 64-bit id types for
performance and to reduce memory consumption.

Additional documentation and code enhancements were made to related
classes. A minor bug in vtkPointLocator related to not using the
right distance measure (dist2 vs maxDist2) was also corrected.

This makes the python wrappers ignore WRAP_EXCLUDE, and instead use
the new property WRAP_EXCLUDE_PYTHON that excludes fewer classes.
The WRAP_SPECIAL flag, which used to act as a whitelist for python,
has been removed.

Because this change causes classes to be wrapped in python by default,
some third-party VTK packages might break until they modify their own
CMakeLists.txt files to add WRAP_EXCLUDE_PYTHON where necessary.

Thanks to David Gobbi again, these still need to be in WRAP_EXLUDE
so that the wrappers ignore them, and then added to WRAP_SPECIAL so
that the Python wrappers can wrap them. This should fix the issues
seen on the dashboards introduced by this branch.

Thanks to David Gobbi for the suggestion, and Jean Favre for raising
the issue on our mailing list.

vtkExplicitCell may be leftover from some early experiments.

Co-authored-by: Yuanxin Liu <leo.liu@kitware.com>
Co-authored-by: Berk Geveci <berk.geveci@kitware.com>

 -The semantics of each unsigned char in the ghost arrays changes:
  Instead of storing a numeric value representing how far a cell is
  from the boundary, it is now a bit field specified by
  vtkDataSetAttributes::CellGhostTypes and
  vtkDataSetAttributes::PointGhostTypes.  The bit field is consistent
  with VisIt specs.

- Previously, filters strip all ghost cells they request from upstream
  before finalizing the output. This is no longer done.

- vtkUniform grids previously supported blanking through member arrays
  vtkUniformGrid::CellVisibility and
  vtkUniformGrid::PointVisibility. These arrays are removed and the
  blanking functionality are supported through the new ghost arrays
  instead.

- the "vtkGhostLevel" arrays for cell and point data are renamed to
  vtkDataSetAttributes::GhostArrayName() ("vtkGhostType").

- the version for VTK Legacy files is increased to 4.0 and the version for
  VTK XML files is increased to 2.0. When reading older files we
  convert vtkGhostLevels array to vtkGhostType.

The class was referred to as both "vtkBoundingBox.cxx" and as
"vtkBoundingBox.cxx".  When file properties are set, the .cxx
should always be used unless the class is header-only.

This reverts commit 6b4ea15f.

This commit breaks the Python API because it removes an overload which
is used internally in the Python API.

Change-Id: I2037b977b0fc23ea3ea3547af81801f97ea2239c

It requires vtkDataObject which is in vtkCommonDataModel, but adding the
dependency link creates a circular dependency graph. Instead, move the
implementations of the convenience methods to the correct library and
export them from there.

Change-Id: I8bf68670aff5f703688cf9cbae83e683bd457f0f

This is split so that vtkIOXML loses its dependency on vtkFiltersAMR
which drags in vtkParallelCore. The parallel-related code can instead be
split out and the core utilities be moved into Common/DataModel.

Change-Id: I621cc40f2afb1831d25e0701a0075ad88dc3e149

This commit updates the extract/sub-sample structured data filters
to reflect the changes of refactoring the piece and extent in VTK.
Namely, vtkExtractGrid, vtkExtractVOI and vtkExtractRectilinearGrid,
which operate on vtkStructuredGrid, vtkImageData, and vtkRectilinearGrid
respectively, are updated.

These datatypes, albeit different, they share common functionality. To
avoid replicating essentially the same code in all of these three classes,
a helper class, called vtkExtractStructuredGridHelper, is introduced. This
new class is part of VTK's vtkCommonDataModel module since it needs to be
used by both the vtkImagingCore and vtkFiltersExtraction module.

One minor caveat, is that Imaging algorithms/tests require that the origin
of the image to be retained and that the output extent is w.r.t.
to the input extent, when there is no sub-sampling. For that reason,
when there is no sub-sampling vtkExtractVOI, will yield an output extent
that is with respect to the origin. All other filters re-number the
output extent starting from zero. The output extent is always re-numbered
when the data is sub-sampled.

Change-Id: I26fe5a115032333db9814987a6c9dc949e51ef52

- Removed unused extent translator subclasses
- Removed unnecessary refereces to the extent translator
- Moved extent translator into Common/ExecutionModel

Change-Id: Idc53dd66891297b1f6a06ea3eb1baf394cb24b20

Change-Id: Ie302abbcf17f66ceab26f341cba61f111c955a37

Change-Id: I046d14b271d9d9693c9caa4b9b86836f85120c0c

This class provides some additional cell API on top of
vtkPointSet, but does not contain the implementation-specific
public methods in vtkUnstructuredGrid. Similar to
vtkMappedDataArray, this interface is used to map native
simulation data structures into an interface that VTK
understands.

Change-Id: Ifdc21b3d704854bfd53a198d3d3d0f7415577479

This provides a generic method for traversing cells in
subclasses of vtkDataSet. Three implementations of the
vtkCellIterator interface are provided:

* vtkDataSetCellIterator: Use vtkDataSet API to look up cells
  using random access.
* vtkPointSetCellIterator: Use the vtkPointSet API to look up
  cells using random access. Advantage over
  vtkDataSetCellIterator is that points are looked up as a batch
  operation.
* vtkUnstructuredGridCellIterator: Use the vtkUnstructuredGrid
  internals to perform efficient sequential iteration without
  vtkCellLinks.

Change-Id: I5893dab945115721d2291b2eff83bf7e71632230

* Parallelization:
Support for Multiblock datasets and MPI parallel usage. Three compositing
strategies are provided, with a heuristic to automatically make a reasonable
selection between them. [1] INPLACE, [2] INPLACE_DISJOINT, [3] BALANCED.
The inplace strategy processes data where it falls given its parallel domain
decomposition and projection to the screen. For simple surfaces such as
slices where ranks/blocks data does not overlap in screen space this is the
most efficient approach. However where ranks/blocks data have large amount
of screen space overlap, this approach has high communication/compositing
and overhead and a large amount of redundant computation that's discarded.
The inplace-disjoint strategy was designed to address these issues. It
leaves data inplace as much as possible but will assign pixels to ranks
uniquely eliminating redundant computation. The communication costs are
the same as the inplace strategy however they are split into two temporally
disjoint parts with computation in between which tends to reduce congestion
and contention. The balanced strategy divides the screen into equally sized
disjoint regions and assigns each rank a region. This strategy can suffer
from load balancing issues, and because no account is made of the initial
data distribution it may have higher communication/compositing costs than
the others. The parallel implementations have been tested with IceT in
ParaView. The compositors uses non-blocking mpi communications, MPI
subarrays for describing non-contoguous memory extents, and communicates
efficiently by pasing mpi gpu mapped memory via extensions made to
vtkPixelBufferObject. An object factory is used to override the serial
objects with their parallel counterparts  when the parallel module is
linked.

* Contrast and Color Contrast Enhancement:
The new contrast enhancement feature increases both dynamic range contrast
while preserving patterns in the LIC. Contrast enhancment is implemented using
histogram stretching. The color contrast enhancement is made in HSL space on
the L channel to minimize color distortions. During the "enhanced" LIC mode
contrast enhancement is also applied after the first pass of LIC compution.
This helps strengthen streaking patterns.

* Enhanced scalar color shading:
A new mode has been added to the shader that shades surface geometry combining
both LIC and scalar colors. The new shader produces bright colors without
diminishing the visibility of the LIC by multiplying colored lit surface with
computed LIC texture. The original blending implementation is left in place
as it works well in many situations.

* Noise texture customization:
A new noise texture generator has been added to improve control over "streaking"
in the convolved texture. The noise textures produced are fully customizable over
9 degrees of freedom. [1] Noise distribution (Gaussian, Uniform, Perlin); [2] Noise
texture size [3] Noise grain size [4,5] Min/max noise values [6] Number of noise
levels; [7] Impulse noise probability; [8] Impulse noise background color; [9]
Noise generator seed

* Fragment masking controls:
The new fragment masking provides controls over the color and intensity of masked
fragments and their blending with scalars. Fragments are masked by threshold |V|<t,
where t is a user specified threshold value, and V are mask vectors. Masking vectors
can be optionally projected onto the surface or passed through un-modified so that
threshold is provided in the original vector units and matches scalar color shading.

* Vector Normalization Control:
The new vector normalization control lets the user turn on and off normalization
in the integrator. Disabling normalization can help highlight relative strengths
in strongly varying regions of a flow field by making the amount of smoothing that
occurs during convolution proportional to the flow strength.

* Antialiasing:
An optional anti-aliasing stage was added. In some cases the CE and EE stages
produce streaks with sharp jagged transitions from black to white. The AA stage
can be used to soften the result and smooth sharp transitions.

* Optimizations:
The implementation has been split into 8 major steps with the result of each stage
cached in a texture.[1] Vector projection and lighting calculation; [2] Gather;
[3] Compositingand guard pixel generation; [4] LIC Computation; [5] Scatter;
[6] Scalar coloring; [7] Color contrast enhance; [8] Depth test. During user
interaction stages that do not have modfied paramters or input data can be skiped
using the cahced result instead.  This can save large amount of time for expensive
operations such as projecting vectors, computing the LIC etc. Classes
were added to simplify monitoring of various system paramters that would trigger
an update, such as changes to lights, modelview or projection matrices, background
color, etc. A new framebuffer object has been introduced, designed specifically
for efficient buffer ping-pong, as well as efficiency improvements for setting
shader unfiorms on inner parts of buffer ping-pong loops.

* Porting and Testing:
The code has been ported to Apple + ATI systems, and to OS Mesa with the gallium
llvmpipe state tracker. A number of ctests have been introduced to excersize the
new features. Parallel features have testing coverage in ParaView.

Change-Id: I26f90a4e1e4e204289d38993d1e32fe5493b7a0d

Headers to be wrapped by python can be marked WRAP_SPECIAL.

Change-Id: Ia505e0684517d8cd50bd4aa371ff49ac51e5fd13

This moves the Python wrapping to the end of the build process, using
the information exported by the module files.

Change-Id: I711382f79fc1fdb15cd80c87f55dd2f97a2c5cd8

Change-Id: I519f20b46a43d58531c0d57f3deffa742514da8e

Deprecate the "--abstract" and "--concrete" options for wrapper
tools.  Also deprecate specifying an output file without "-o",
and remove the old "infile [hintsfile] concrete outfile" calling
convention, which hasn't been used since VTK 5.6 and was broken.

The wrappers now ignore the ABSTRACT property in cmake, instead
they automatically detect concrete classes by searching for the
New() method.

Some classes were marked as ABSTRACT, even though they had a New()
method that returned a valid instance.  The ABSTRACT property
has been removed from these classes, for consistency.

Note that the vtkInstantiator classes still rely on the ABSTRACT
property, so the ABSTRACT property cannot yet be removed from the
cmake files.

Change-Id: I05ebf42e69367fd4ce7256864a25d1f0c16ed4b8

This move is necessary to be able to derive vtkQuaternion from
vtkTuple and be able to use vtkQuaternion in the class
vtkQuaternionInterpolator (in Common/Math)

This will not change anything for the other classes in Common/DataModel
as they depend on vtkCommonMath.

Change-Id: I06b6c64119304b6241ae41c44aeb0aec2c5af886

Change-Id: I29bc1b3548ee326f9368dfc9cde743918b2f0c61

The main motivation for the changes is to improve the efficiency
of AMR data structures by replacing the data set containers and meta
data representation with new data structures.

First, the meta data associated with the AMR data is moved from
vtkInformation to a new class vtkAMRInformation so that they do not
have to be deep copied. Related changes also include:

- Before, when the LOAD_REQUESTED_BLOCKS() key is not set, the reader
  would recompute AMR meta data based on the requested blocks.  This
  is no longer done: meta data always represents what is on file.
  The reason is to avoid the sensitive meta data computation that
  depends on connectivitiy of the requested blocks.

- Processor ranks are no longer stored in the meta data. Filters
  can easily generate them by using
  vtkAMRUtilities::DistributeProcessInformation

- There used to be two types of 1D indices used to reference blocks in
  an AMR: vtkOverlappingAMR::GetFlatIndex and
  vtkOverlappingAMR::GetCompositeIndex. Now only the latter is used.
  The "other" 1D index is file type specific so now only the readers
  reference them (vtkAMRInformation::GetAMRBlockSourceIndex())

- To make it easy to traversal the bounding boxes in the meta data. A
  new key vtkObject::BOUNDING_BOX() has been added that works with
  vtkOverlappingAMRDataIterator. See its use in vtkCompositeCutter for
  an example.

- In a multiprocess setting, vtkAMRSliceFilter for each process computes
  the complete meta data to avoid communication

- Many functions in vtkAMRUtilities are removed because they provide
  support for computing meta data from data sets. In the new design,
  meta information is always created before data sets are constructed.

Second, VtkUniformGridAMR now use a more compact representation of the grid
blocks than the tree implementation done previously. To facilicate
this, vtkCompositeDataSet now becomes a fully abstract class and all
concrete implementation gest pushed to the class vtkDataObjectTree.
In the new implementation, the non-null blocks are stored in an stl
vector. So traversing them (using vtkUniformGridAMRDataIterator) is
efficient.
- The AMRBox has been reduced to store only the lower and upper
  corners.  Information such as origin and spacing are moved to the
  container class vtkAMRInformation, since they are often common to
  all boxes or boxes on the same level.

- File reoganization: - AMR File readers are moved from Filters/AMR to
  IO/AMR - AMR algorithms (vtk*AMR*Algorithm) are moved from
  Filters/General to Common/ExecutionModel

Finally, tkAMRVolumeWrapper is moved from filters to rendering.
The dependency on vtkAMRResampler and vtkParallelCore makes it
difficult for it go to Rendering/Volume so a new module
Rendering/VolumeAMR is created.

Change-Id: Id73d214e6a5ac4d4a08fde5d979365f46edfa390

This patch implements an "indexed" color mode for `vtkLookupTable`.
When `IndexedLookup` is true, the scalar range and log/linear settings are disabled;
`MapScalars` and `MapValue` require an exact match to an annotated value
in order to return a valid color.
All other values are mapped to `NanColor`.

Change-Id: I9805ab6b4398db479c0ae6b0d239886850c2e187