In release, the empty while loop were stuck. Making
m_status volatile would fix the issue, but here we
are dealing with a variable handled by multiple threads,
so making it atomic makes the most sense.

Geometry sprint



See merge request !80

Was removed in 33a65d44. Now wraps extractSurfaceMesh.

Removes lambda to inline the uniqueness check for performance.

Modifies surface extraction algorithm to search for unique triangle faces instead of O(N^2) search over tetrahedra.
It still takes longer in debug mode.

TODO: Explore faster ways to do the extraction.

Makes extract surface functionality as utility as utility instead
of hardwiring to extract the attached surface mesh.

A surfaceMesh will not be automatically extracted when
reading a volumetricMesh due to the long time necessary
for that process, which will be improved later on.
(vtkDatasetSurfaceFilter is 100x faster)

The user will have to call computeAttachedSurfaceMesh to
extract the surface mesh from its volumetricMesh if he
needs it.

The way its done the outer loop will not be traversed fully all the time. Fixes this bug in surface mesh extraction function.

Also implemented MappedVertexArray to map out structure
vertices to polydata points directly (no copy).

1) Only update the renderWindow in setRenderingMode if
the viewer is up and running

2) Do not set a renderMode when setting a new current
scene if the viewer is not yet rendering.

reads polydata and unstructured grid meshes

1) Clean up print methods
2) Put initialize, print, clear, getVolume on top
3) Add missing overrides
4) Replace extractSurfaceMesh by computeAttachedSurfaceMesh
5) Define Mesh::print
6) Use Mesh::clear in subclasses

Adds optimizer to the mesh. This algorithm rewires
the node order and triangle connectivity to optimize
for memory layout. Adds tests for the same.

The algorithm starts with a random node and flood-fills
in the triangular mesh space adds nodes and elements
at every iteration. The iteration ends when the surface
is "flooded". The algorithm assumes that the mesh is
one topologically connected entity.

TODO: Further optimization at each iteration. Extend to other mesh types.

Adds a function to check if a geometry is a mesh.
Adds printing to geometry class
Stylistic changes in extract mesh class

Fixes bugs and tests surface extraction.
Fixes bugs and tests one to one nodal map.

Adds comments to the classes and their functions in geometry module

Adds surface mesh extraction from tetrahedral mesh
TODO: code style check and test

Adds one to one nodal map between two meshes. There are compute and set options for the map.

1) readAsAbstractPolyData completed
2) readAsGenericFormatData still ongoing
3) implemented standard createSurfaceMesh in MeshReader

Check that visual geometry exists and that a delegate
has be created.

Make sure textureCoordinates exist, and compute the
vertice normals if they were not already computed.

- Add imstk::Mat4f and imstk::Mat4d
- Add imstk::MAX_D and imstk::MIN_D
- Remove 'Map' from GeometryMap functions
- Reorder functions in a consistent manner
- Correct reference returns
- remove unnecessary ismtk:: due to namespace
- rename vertex/triangle/hexadron/tetrahedron composed
methods with their plural form when needed
- follow style rule with return type on a line and
function name on the following one during declaration
- move print() to geometryMap base class and use it in
override functions
- use for each c++11 architecture when possible
- correct wrong iteration in HexahedralMesh::getVolume
- place conditions for return at the top of functions
- declare WeightsArray in TetrahedralMesh instead of
TetraTriangleMap
- Rename findEclosingTetrahedra to findEnclosingTetrahedra
- add override on virtual functions in child classes
- correct test function name in Sandbox

Minor fixes to returning references to locals in various places.

Adds tet-tri map and all the support functionality that it needs

Adds Tetra-Triangular mesh map.
TODO: Code check and add tests

Adds Identity map. Adds some safe gaurds.

(1) `SimulationManager::startSimulation()` will check if a Viewer is
already rendering, and will only start a rendering/interaction loop
in the main thread if it isn't. This allows us to work with two
possible cases:
(a) a QT Application with an existing widget for rendering, in which
case we do not want to control the rendering window ourself in a loop
(b) a standalone `vtkRenderWindow` application, in which case we do
want to create a window when our simulation starts and loop until the
window is closed.

(2) `SimulationManager::startSimulation()` can be launched with a debug
boolean option (off by default), which will allow to not automatically
simulate the dynamics of the scene, to be able to interact with the
scene beforehand (using the mouse).

(3) `imstk::InteractorStyle` is based on vtkInteractorStyle specifically
the trackballCamera and allows to ignore mouse events in simulation mode,
and uses key events to control the simulation:
's' : start simulation
'e' : end simulation
' ' (space) : pause/run simulation

(4) The `Viewer` class and the `InteractorStyle` class have been moved
to the `SimulationManager` module, since they are more drivers of the
application themselves.

(5) The 'Sandbox' example has been refactored to make it easier to test
autonomous tests, and updated to use the new driver architecture brought
with this commit.

Also merge Utility within Core.

- SIMULATION adds the object actors and set the
interactor style to no interactions.
- DEBUG adds additional actors to visualize
lights, the camera, axis, and set the interactor
style to trackball to interact with the scene.