VTK renaming

Renamed everything that uses VTK. Some of these classes will need an interface eventually, but that can be done as the Vulkan renderer gets built so that we can abstract the important common characteristics.

See merge request !106

Refactor physics module

**Summary**:  
*  Modifies the Dynamical objects realted classes to generalize for any problem state. This allows for rigid bodies, deformable bodies using FEM and pbd under one dynamicalObject base class.
* Adds common interface for pbd solver and FE solvers to allow simpler code in SceneManager
* Refactors all the PBD classes for bugs, style, warnings and efficiency.
* Misc. modifications including rearranging folders, example codes, renaming classes and clearing some warnings.

See merge request !103

Use HTTPS for external dependencies

As noted by @NickMilef in the developers mailing list, `googletest` git repository was using the SSH protocol instead of HTTPS, which requires users to add an ssh_key on github.com.

We switch all those external projects to HTTPS protocol, but keep the ones hosted by ourselves on gitlab.kitware.com in SSH since we might be contributing back to those during development

See merge request !105

1. Enforces style to move one line code to one line
2. Move multiple lines to .cpp
3. make epsilon part of the class
4. SolvePositionConstraint in the base class is made pure virtual

googletest git repository was using the SSH protocol
instead of HTTPS, which requires users to add an
ssh_key on github.com.

We switch all those external projects to HTTPS protocol,
but keep the ones hosted by ourselves on gitlab.kitware.com
in SSH since we might be contributing back to those
during development.

Rename NewtonMethod to NewtonSolver and the files accordingly

1. Make solve in solverBase class pure virtual
2. Rename DeformableObject to FEMDeformableObject and files accordingly
3. Efficient way to do checks in FEMDeformableObject::initialize() and pbdObject::initialize()
4. Add variable to address which map to apply for the visual geometry

Removes problemState base class
Initialize methods now return bool

Make PbdConstraint abstract base class with solvePositionConstraint to be implemted in base class

1. Template parameter in the DunamicalObject and DynamicalModel is named to StateType
2. Rename paramerts in the initialization of the pbd constraints
3. Remove unnecessary APIs in scene object hierarchy

Renames pbd constraint classes.
Renames the selfUpdate to updateGeometries

Add testing framework

Add testing with google test framework in the superbuild.

See merge request !104

Update Geometry and Sphere to have scaling and
radius respectively > 0;

With the superbuild architecture, the inner project
is not added as a subdirectory in the superbuild project,
but configured through ExternalProject_Add(). For this
reason, the CTestTestfile.cmake at the top level (superbuild
project) does not add the Innerbuild directory in which
there is another CTestTestfile.cmake referencing the tests
of the inner project.

This commit includes the file `imstkCTestAddInnerbuild.cmake.in`
which calls `subdirs()` on the Innerbuild directory. That file
is configured in the top-level build directory, and added as
the TEST_INCLUDE_FILE property to that directory. This will
include that file to the top-level CTestTestfile.cmake, which
will therefore be able to reach the CTestTestfile.cmake in the
Innerbuild directory when running ctest.

Use this commit to also only solve external dependencies
in the superbuild tree, no need to to it in the innerbuild tree.

By adding testing source files in the same directory
than the target source files, those first ones were
included in the target executables by mistake.

ctests would currently only be created for each test file,
but the GTEST_ADD_TESTS function[1] could allow to register
all gtests as independent tests.

[1] https://cmake.org/cmake/help/v3.0/module/FindGTest.html

However, that function would not allow the use of a driver
executable, since it would force the `gtest_filter` flag to
appear right after the executable name in the command, while
a driver executable would need the name of the test file
beforehand.

This commit introduces a custom version of GTEST_ADD_TESTS
where `extra_args` is called before the `gtest_filter` flag
to allow the use of an executable driver.

Note: as noted in the doc above[1], testing each gtest is
slow since they all necessite the startup of an executable.
The previous option of testing per file is therefore kept
but commented. A future focus of interest could be to
customize `add_test` to then run all gtests at once like
GoogleTest does by default.

Allows to create tests in iMSTK using google test and ctest.
Ctests are created by test files, and not by gtest functions.

Requirements:
- Requires a 'Testing' subdirectory with cpp files for each
  class to test.
- Google Test and Google Mock should be used to create unit
  tests, see the documentation below:
  https://github.com/google/googletest/blob/master/googletest/docs/Documentation.md
  https://github.com/google/googletest/blob/master/googlemock/docs/Documentation.md
- Test files should be constructed as described under\
  `imstk_add_test()` declaration

Fix fixed node constraint bug in PbdVolumeConstraint.

1. Adds self update to the scene objects. The objects now can update themselves instead of explicit way of updating in the sceneManager class.
2. Clear warnings in PbdVolumeeConstraint, DeformableModel, PbdModel, NewtonMethod classes
3. Clean the main() in the sandbox example

1. Seperate files for separate Pbd colliison constrain classes
2. Preincrement lop variables
3. Refactor collision constraint classes: remove raw pointers, using auto, style corrections
4. Move pbd constraints to seperate folder within constraint folder
5. Clears warnings in Physics module

Place all dynamicalModel related into separate folder.
SceneElements now has just the tangable and intangable objects.

1. Dynamical object classes are templated with the problem state
   (Deformable bodies use vectorized state. Pbd objects use pbdState.)
2. Pbd state is refactored to have only the current state
3. Rename deformableBodyState to VectorizedState which can be used in
   future by all the finite element and vectorized formulations
4. Remove unnecessary mappnig for the cloth example
5. Adds queries to sceneobject for visible, collidable and physics
6. Optional allocation of internal states for pbdState
7. Removes the specialized calls in the sceneManager::runModule.
   This will be further cleaned.
8. Correct ifdef in imstkNewmarkBeta.h

Rename DeformableBodyState to VectorizedState
Make the ifDefs consistent in style
Place and correct the headers in some files. This has to be done for all files at some point.

Replace int by size_t in pbdModel
Rename constraintProjection to projectConstraints

Clean the pbdState to just have body states.
All the physics related parameters, time step size and time
integration routines are moved to pbdModel

Adds a solver base class so that both nonlinear solvers and the pbd solver derives from it.
This simplifies the SceneManager::runModule()

Make a base class for problem state. All math models uses states that are derived from this class.
Rename ProblemState class to DeformableBodyState
Rename positionBasedModel to positionBasedDynamicsModel
Replace raw pointers with smart pointers in pbdModel class
rename class functions in pbdModel
pbdState: move function definitions to .ccp & replace int by size_t

Make locals const where ever possible in PBD constraint classes
Create separate files for each of PBD constraint classes

Move the implementation to .cpp for ProblemState class.
Adds missing comments for functions in ProblemState class.
Make DynamicObject derive from collidableObject rather than sceneObject.

- Corrects wrongly named controller objects
in the Sandbox example

- Corrects wrong construtor call to the PBDObject

Refactor controllers

This MR aims to refactor the VirtualCouplingObject class into a SceneObjectController, as well as correct some style and architecture issues.

### STYLE: correct identation 97fc549f
Convert tabs to 4 spaces

### ENH: simplify TrackingController constructor fbc48bae
- Get rid of scaling in constructor (too many parameters, why choose scaling and not others? Use `setTranslationScaling` instead) 
- No more default `nullptr` value for `DeviceClient` in controller constructor

### ENH: Implement getMasterGeometry 85470771
Returns the master geometry. A geometry is qualified master by the direction of the geometry maps of the object. For example with a dynamic object, physic geometry will drive the changes to the colliding geometry, which will drive the changes to the visual geometry...

### ENH: Divide SceneObject & CollidingObject d8fee1f4 (fixes #84)
Colliding geometry is only in `CollidingObject, not `SceneObject`.  To do this, we also had to :
- Have `PbdObject` inherit `CollidingObject` *(in the future there should not be a distinct object class just for Pbd : there should just be dynamical objects that can use different models, like Pbd or FEM)*
- Remove useless checks when creating interactions: even two colliding objects (not dynamic, aka static) could be interacting if they are both controlled by devices

### STYLE: correct some includes and forward declarations 0340bde7

### ENH: remove interface for transforming geometry in RigidObject 7c272963
We are still wondering how to store/apply our geometries. Having yet another interface to only wrap the API to transform the geometry is not needed: we can directly call them on the geometry themselves for more transparency on what geometry is being updated. *This should be investigated later on when we will work with rigid body dynamics.*

### ENH: Refactor VirtualCouplingObject in a controller  (fixes #99)
- `SceneObjectController`: similar to cameraController, it subclasses trackingController to update the transformation of an object master geometry, instead of updating itself. 
- `SceneObject`: similar to camera, has an interface to easily setup a controller using a device client. 
- `CollidingObject`: stores the force vector that needs to be applied to the device.
- `SceneManager`: make the API calls from controller instead of object

### STYLE: Rename cameraController attribute to controller 9e199a30

See merge request !102

SceneObjectController: similar to cameraController, it
subclasses trackingController to update the transformation
of an object master geometry, instead of updating itself.

SceneObject: similar to camera, has an interface to easily
setup a controller using a device client.

CollidingObject: stores the force vector that is to be
applied to the device.

SceneManager: make the API calls from controller instead
of object

We are still wondering how to store/apply our geometries.
Having yet another interface to only wrap the API to
transform the geometry is not needed: we can directly
call them on the geometry themselves for more transparency
on what geometry is being updated.

This will be investigated later on when we will work with
rigib body dynamics.