Methods BVTesting with sqrDistLowerBound as output argument were not defined.
  Instead the implementation of the base class BVHCollisionTraversalNode <BV>
  was called instead. Unfortunately, in the base class, the meshes and
  bounding volume hierarchy were moved to the position given for collision
  testing, but not in the derived classes. Method overlap were then called with
  wrong argument for position and orientation.

  - This member is used to convert a octomap to a set of boxes.

  from BVHCollisionTraversalNode::leafTesting to
  GJKSolver_indep::shapeDistance<TriangleP, TriangleP>.

  - do not run EPA algorithm to compute penetration depth and normal.

  - Collision detection calls distance computation and returns collision
    if the distance between objects is below the security margin.
  - This modification requires a modification in the structure of the software
    to make collision detection and distance computation closer.
  - GJKSolver_indep::shapeTriangleDistance and
    GJKSolver_indep::shapeTriangleIntersect have been replaced by
    GJKSolver_indep::shapeTriangleInteraction.

  - this member stores the normal (direction object 2 should be translated by
    the penetration depth to make objects collision free) in case boths objects
    are in collision.

  instead of -1.

  - use GJK algorithm to detect collision between triangles.
  - Remove methods
    - MeshCollisionTraversalNodeOBB::leafTesting,
    - MeshCollisionTraversalNodeRSS::leafTesting,
    - MeshCollisionTraversalNodekIOS::leafTesting,
    - MeshCollisionTraversalNodeOBBRSS::leafTesting,
    use parent class implementation instead.

  - old constructor is deprecated.

  - store const CollisionRequest& as a member instead of CollisionRequest,
  - remove member CollisionRequest::enable_distance_lower_bound,
  - modify constructors of all derived classes.

  - overlap method without sqrDistLowerBound as an argument call the method
    with sqrDistLowerBound as an argument.

  Simplex::c -> Simplex::vertex.
  Simplex::p -> Simplex::coefficient.

  - security_margin is the distance below which collision test returns
    collision,
  - break_distance is the distance below which bounding boxes are broken
    down.

  void collide(CollisionTraversalNodeBase* node, FCL_REAL& sqrDistLowerBound,
               BVHFrontList* front_list) ->
  void collide(CollisionTraversalNodeBase* node,
               const CollisionRequest& request, CollisionResult& result,
               BVHFrontList* front_list),
  void propagateBVHFrontListCollisionRecurse (CollisionTraversalNodeBase* node,
                                              FCL_REAL& sqrDistLowerBound,
                                              BVHFrontList* front_list) ->
  void propagateBVHFrontListCollisionRecurse (CollisionTraversalNodeBase* node,
                                              const CollisionRequest& request,
                                              CollisionResult& result,
                                              BVHFrontList* front_list)

  - void selfCollisionRecurse(CollisionTraversalNodeBase* node, int b,
                              BVHFrontList* front_list),
  - void selfCollide(CollisionTraversalNodeBase* node,
                     BVHFrontList* front_list).

  - collide2,
  - bool MeshCollisionTraversalNodeOBB::BVTesting(int b1, int b2,
         const Matrix3f& Rc, const Vec3f& Tc) const,
  - void MeshCollisionTraversalNodeOBB::leafTesting(int b1, int b2,
         const Matrix3f& Rc, const Vec3f& Tc,FCL_REAL& sqrDistLowerBound) const