The current dependency relationship in vtk is unclear and misleading.
This MR tries to rewrite them based on header files inclusion of headers
and source files in each module. Corner cases are considered and
modules are sorted in alphabetical order to facilitate future reference.
See details in my gitlab python based script project. In future we can continue
using this script to clean the VTK Dependency easily from
time to time.

This is a fix for:
vtk/vtk#14310

Windows applications that run for a long time report that rendered
objects do not change. This is because the modified time on a Windows
system is 32 bits. This causes overflows that defeat the modified time
mechanism. This patch defines a new type, vtkMTimeType that is 64
unsigned integer regardless of the architecture.

A mechanism to provide backward compatibility is introduced. The
preprocessor define "VTK_HAS_MTIME_TYPE" can be used in applications
that must build against VTK versions that use the "unsigned long" type
for MTime's.

Methodology used to find MTime occurences:
1) Identify files as follows:
   git grep "unsigned long" | grep ime | cut -d":" -f1,1 | sort | uniq
2) Hand edit each of those files replacing "unsigned long" with
   "vtkMTimeType" where appropriate.
3) Temporarily change typedef for vtkMTimeType to "double" to detect
   missing conversions

It doesn't seem to have got everything, but it's a start.

Some resulting whitespace is suboptimal, but one day
we can fix that with clang-format. :)

Just ran this command:
run-clang-tidy.py -checks=-*,modernize-use-override -fix

(I actually had to build my own clang to make clang-tidy
output "VTK_OVERRIDE" instead of "override".)

There wasn't much left.

Notably, don't #define vtkstd at all anymore.

Since VS 2015 now supports proper snprintf,
VTK can just start using it anywhere as normal
with the workaround moved to vtkConfigure.h.

One day the pre-VS2015 workaround can be removed.

vtk(.*)\(const vtk\1&\);\s*//\s*Not implemented[\.]*
to
vtk\1(const vtk\1\&) VTK_DELETE_FUNCTION;

vtk(.*)\(const vtk\1 &\);\s*//\s*Not implemented[\.]*
to
vtk\1(const vtk\1 \&) VTK_DELETE_FUNCTION;

vtk(.*)\( const vtk\1 & \);\s*//\s*Not implemented[\.]*
to
vtk\1( const vtk\1 \& ) VTK_DELETE_FUNCTION;

vtk(.*)\( const vtk\1& \);\s*//\s*Not implemented[\.]*
to
vtk\1( const vtk\1\& ) VTK_DELETE_FUNCTION;

vtk(.*) \(const vtk\1&\);\s*//\s*Not implemented[\.]*
to
vtk\1 (const vtk\1\&) VTK_DELETE_FUNCTION;

(operator\s*=.*);\s*//\s*Not\s*implemented[\.]*
to
\1 VTK_DELETE_FUNCTION;

After that, this finds basically nothing:

operator.*implemented

then manually reverted changed files in VPIC and KWSys folders.

Since modern VS finally supports snprintf,
only fall back to _snprinf for older versions.

This method creates a new object, so it is necessary to provide a hint
for the wrappers so that they do not leak the object.

Kitware Robot authored May 24, 2016 and David Gobbi committed May 25, 2016

Perl was used to remove all the BTX and ETX markers from the code.
The specific command that was run on all "vtk*.h" files was this:
    perl -0777 -i -pe 's/(\n* *\/\/ *[BE]TX *\n+)+/\n\n/g'

This regex replaces each BTX/ETX line, plus any leading or trailing
blank lines, with a single blank line.

SafeDownCast performs a series of virtual calls and string comparisons,
which is quite slow, especially when used in worker functions.

vtkArrayDownCast will switch between SafeDownCast and the more
efficient FastDownCast (only available for common vtkAbstractArray
subclasses) depending on whether or not FastDownCast is defined for
the specific array type.

Kitware Robot authored Mar 08, 2016 and Dan Lipsa committed Mar 08, 2016

Code extracted from:

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

at commit 41bdf05361007f8c5186f3df9944d86bb273ed13 (for/vtk).

vtkDataArray subclasses now use

ComponentValue --> TypedComponent
TupleValue --> TypedValue

for their type-specific methods.

# Conflicts:
#	Rendering/Annotation/vtkScalarBarActor.cxx

Infuriatingly, Visual Studio has not supported C99’s snprintf until VS2015.

Modify a couple of workaround hacks to only apply to pre-VS2015.

This is more than just a cleanup.  snprintf guarantees null
termination, _snprintf does not!  The return values are also different,
though rarely used.

VTK no longer supports any compilers that do not provide this type.
Therefore all code conditional on VTK_TYPE_USE_LONG_LONG can be made
unconditional.  Leave the macro defined to tell dependent projects that
APIs using the type are available in case they still support versions of
VTK that make it conditional.

VTK no longer supports any compilers that have `__int64` but not a
`long` or `long long` that is 64-bit.  Therefore all code that is
conditional on VTK_TYPE_USE___INT64 is never used and can be dropped.

Valgrind detected an unitialized memory read. When setting member
data in a constructor, avoid using the Set method for that data since
the Set macro tests against the existing value, which will be
undefined in the constructor. Instead, directly set the member data.

Since the FrontBuffer option was taken out, the testing framework
will first test the backbuffer, and if that fails, then test the front
buffer.

However, if a test fails, the images uploaded to CDash show the wrong
data. For instance:

https://open.cdash.org/testDetails.php?test=373277492&build=4009262

shows the valid image as completely black, while the actual failure:

https://open.cdash.org/testDetails.php?test=374725352&build=4016849

shows that the number of labels displayed has changed.

This is part of removing ftgl for android compilation. Also took out
the text rendering benchmark, as it's rather pointless without this
class.

We no longer need this compatibility layer for the compilers we support.
Use the following commands to switch to standard header and namespace:

 git grep -l vtksys/ios/ | xargs sed -i 's|vtksys/ios/||'
 git grep -l vtksys_ios | xargs sed -i 's|vtksys_ios|std|g'

In the early days of VTK, support for stl was not portable. vtksys_stl
and vtksys_ios provided a portable implementation of the stl. Now, all
of the VTK supported compilers have portable stl implementations.

This patch:
  1) Replaces the vtksys_ios:: with std::.
  2) Replaces the vtksys_stl:: with std::.
  3) Removes "using" statements for stl

When interactively selecting data with multiple sources
(select the cell/point under the mouse pointer)
you want to see a label for the source where the field exists
and not see it if the field does not exit.

Not seeing the label is enough indication that the array does not
exist.

This is not supported by the new OpenGL2 backend, and doesn't support
new text features, like MathText, FontConfig, or custom font files.

It only implements vtkTextMapper, which now will use a texture-based
implementation, similar to vtkTextActor and friends.

vtkLabelPlacementMapper wasn't freeing the render strategy's
resources.

Also removed some dead code as a consequence,
like setting the deallocated pointer to null
then to a new address.

Also removed setting some ivars to null in dtors.

Mostly dead code, unused variables, or type
conversion warnings.

Fixes clang -Wunreachable-code warning.

Change-Id: I70e251edbcb5d788d190a803c5d6f5337adb27c2

Used the following command:

find . \( -iname *.h -and -type f \) -exec perl -pi -w -e 's/__vtk(.*)_h/vtk$1_h/g;' {} \;

Fixes many, but not all, clang -Wreserved-id-macro warnings.

Change-Id: I694ff053cb204c70e37b261296f496064d91fc07

A reference to a class member cannot be NULL, and checking if it is
NULL results in a compiler warning in clang 3.3.

Change-Id: I3bcb0d37ab3a202f2bea92cba0238a5fe96aa2b2

This change makes more modules dynamically switch between the
rendering backends if they have no OpenGL code, or introduces some
ifdefs in the case of RenderingParallel (which may not be functional
at this stage). Added RenderingFreeTypeOpenGL2 which will also need
some additional work before it is properly integrated with the new
rendering backend, but it surprisingly seems to render on the
desktop.

This commit contains everything needed to get a minimal ParaView
build using the new rendering backend for polygonal rendering.

Change-Id: If8676d41d263b046a54060965fc760b5d4bd64a1

The former is more C, the latter is more C++.

Change-Id: Id70453243c3d1b3e9cf85aacce5a167da19ffec6

The source file suffixes were missing for some tests, which meant that
vtk_add_test_* couldn't recognize them as tests. Fixed this by adding
the missing extensions.

Change-Id: Ibf5c6bc3226e0c05588a0aa2ffc6b362066de08b

The main kits are:

    vtkCommon
    vtkFilters
    vtkIO
    vtkImaging
    vtkInteraction
    vtkOpenGL (required due to a dependency cycle from
               vtkRenderingOpenGL on vtkImagingHybrid)
    vtkParallel
    vtkRendering
    vtkViews
    vtkWrapping

Modules which deal with a specialization of another module belong to the
kit related to the specialization (i.e., FiltersParallel and
IOParallelXML both belong to the vtkParallel kit) to avoid circular
dependencies that arise when put into the same kit as the "lesser"
module.

Change-Id: Icae0baa78d62cc0dcce84546541df600d4f311dd

They were moved from vtkRenderingOpenGL, and they obviously relied
on the vtkRenderingFreeTypeOpenGL overrides to produce the expected
baseline image.

Change-Id: Ic6b33f314a308204a2125d5bc84f3ca056b76b9b