vtkCellTypes::DeepCopy(vtkCellTypes *src) was calling Allocate() after
the member arrays were DeepCopy'ed, but this overwrites the
just-copied arrays. Remove the allocate to prevent this (the member
arrays are allocated and copied in DeepCopy()), and added some copying
of member variables that were formerly copied within Allocate().

vtkDataSet::GetCellTypes() iterates over all cells and builds the list
of types. Override this function in vtkUnstructuredGrid so that the
computation is multithreaded and performed only when the cell types
may have been modified.

Also clean up some of the enum code by adding "PyVTKEnum.cxx".

Introduced in c392f54f

This allows users to build the locator in a single thread, before calling FindCell (the thread-safe version with a vtkGenericCell as argument) from different threads.
Without this function, users simply might think the FindCell is never threadsafe, or have to build the locator e.g. by first calling FindPoint once, which is hidden logic.

vtkPlanes::SetFrustumPlanes(double planes[24]) method got plane positions in double, but the vtkPoints object that stored them used just floats. This caused loss of precision and warning "Common/Core/vtkAOSDataArrayTemplate.txx:132:38: runtime error: 1e+299 is outside the range of representable values of type 'float'" in TestLabelPlacementMapper.

Fixed by creating vtkPoints object using vtkPoints::New(VTK_DOUBLE).

First issue is that a tolerance squared was being passed
into a function needing distance. Needed a sqrt.
The second issue is that the default computed tolerance for
the proble filter was absurd and wasn't computed at all
just hardcoded to max double which causes numerous overflows
and incorrect behavior. Changed the logic to look at some
actual cells and compute a tolerance from them.

CMake Warning:
  Value of _vtk_thread_impl_output contained a newline; truncating

Nearly everyone will NOT need the scaled SOA vtkDataArrays and it
will add some to the library size so it should be disabled by
default. It was enabled before this in order to force all the
dashboards to actually test the code changes.

For zero-copying arrays for in situ work, this allows the situation
where we want to scale the values that are stored in the memory
by a constant value. This is useful for a simulation code that
has multiple physics/simulation codes working together with
different scalings in each physics/simulation so that when we
get to doing zero-copy of their memory we can scale their field
data into a common scale/unit.

This header wasn't installed or wrapped because it wasn't listed
in the cmake files.  It also needed some modifications to enable
it to be wrapped (the wrappers needed help to distinguish between
template args and greater than, less than operators in two lines).

vtkCellLocator crashed if input data set had no cells (due to accessing this->Tree[n] with this->Tree == nullptr).
Now we check if this->Tree is initialized after each BuildLocatorIfNeeded call and return with an error or empty selection if the tree is invalid.

This helper class transforms the output of imaging filters that produce
vtkPointSets (e.g., vtkPolyData) to apply origin, spacing and direction.

Co-Authored-By: Will Schroeder <will.schroeder@kitware.com>

nothing significant in terms of bad code, just minor optimizations

This adds a new UserData parameters to FunctionValues
so any type of data can be passed down.

This adds a new UserData parameter, that can be used to transfer any kind of pointer

check and return 0.0 in Normalize() method

When the prominence is zero we have to eval every tuple

Fix braces in initializer list to eliminate Clang warning.

some fixes some suppressions some comments

This test creates simple (2, 2, 2) hexahedron and translates them
into polyhedron describing the same geometry.
The convexity is tested using vtkCellValidator, which calls the
polyhedron's `IsConvex` method internally.

Fixing errors within vtkCellValidator that caused a wrong state mask
evaluation, returning wrong error messages in case of errors.
Changing the IsConvex method of vtkPolyhedron to use local instead
of global face ids to access points. Global face ids resulted in accessing
the wrong points causing erroneous face centroids and normals.

This was modified in !5223 into a constructor, but it seems that it was
not brought back as an operator.

remove useless code

This reaplace the easier usage of vtkMutexLock with std::mutex
Actual deprecation of vtkMutexLock will need more work and design.

Fixes compilation of vtkDebugLeaks when VTK_DEBUG_LEAKS is off.