diff --git a/include/hpp/fcl/BV/AABB.h b/include/hpp/fcl/BV/AABB.h
index 72954a64436a08f7d2bf41a19e7d6b3ba6664a67..55a5e4adb92a73b9d2b8416c487b1075a8bac831 100644
--- a/include/hpp/fcl/BV/AABB.h
+++ b/include/hpp/fcl/BV/AABB.h
@@ -46,6 +46,10 @@ namespace hpp
 namespace fcl
 {
   class CollisionRequest;
+/// @defgroup Bounding_Volume 
+/// regroup class of differents types of bounding volume.
+/// @{
+
 /// @brief A class describing the AABB collision structure, which is a box in 3D space determined by two diagonal points
 class AABB
 {
diff --git a/include/hpp/fcl/BV/BV.h b/include/hpp/fcl/BV/BV.h
index 3f03df66c96bf4e68105ecf237e00bc1aff3b66a..238ec16bfc416c9235741900d1f28c9577b931d2 100644
--- a/include/hpp/fcl/BV/BV.h
+++ b/include/hpp/fcl/BV/BV.h
@@ -47,7 +47,7 @@
 #include <hpp/fcl/BV/kIOS.h>
 #include <hpp/fcl/math/transform.h>
 
-/** \brief Main namespace */
+/** @brief Main namespace */
 namespace hpp
 {
 namespace fcl
diff --git a/include/hpp/fcl/BV/BV_node.h b/include/hpp/fcl/BV/BV_node.h
index e7fc637418af63b040efc47c7ff1427c77dda8ed..86e858f2f40b5da2857b229ceb9e8b6d13f32985 100644
--- a/include/hpp/fcl/BV/BV_node.h
+++ b/include/hpp/fcl/BV/BV_node.h
@@ -49,6 +49,10 @@ namespace hpp
 namespace fcl
 {
 
+/// @defgroup Construction_Of_BVH 
+/// regroup class which are used to build BVH (Bounding Volume Hierarchy)
+/// @{
+
 /// @brief BVNodeBase encodes the tree structure for BVH
 struct BVNodeBase
 {
diff --git a/include/hpp/fcl/BV/OBB.h b/include/hpp/fcl/BV/OBB.h
index 5dee5cb1824ab8dd648b07fd13a6062523c884af..32468de639bbef10eea0ac63c1b873e4b5d583ae 100644
--- a/include/hpp/fcl/BV/OBB.h
+++ b/include/hpp/fcl/BV/OBB.h
@@ -46,6 +46,9 @@ namespace fcl
 {
   class CollisionRequest;
 
+/// @addtogroup Bounding_Volume
+/// @{
+
 /// @brief Oriented bounding box class
 class OBB
 {
@@ -64,12 +67,12 @@ public:
   bool contain(const Vec3f& p) const;
 
   /// Check collision between two OBB
-  /// \return true if collision happens. 
+  /// @return true if collision happens. 
   bool overlap(const OBB& other) const;
 
   /// Check collision between two OBB
-  /// \return true if collision happens. 
-  /// \retval sqrDistLowerBound squared lower bound on distance between boxes if
+  /// @return true if collision happens. 
+  /// @retval sqrDistLowerBound squared lower bound on distance between boxes if
   ///         they do not overlap.
   bool overlap(const OBB& other, const CollisionRequest& request,
                FCL_REAL& sqrDistLowerBound) const;
@@ -141,9 +144,9 @@ bool overlap(const Matrix3f& R0, const Vec3f& T0, const OBB& b1,
 
 
 /// Check collision between two boxes
-/// \param B, T orientation and position of first box,
-/// \param a half dimensions of first box,
-/// \param b half dimensions of second box.
+/// @param B, T orientation and position of first box,
+/// @param a half dimensions of first box,
+/// @param b half dimensions of second box.
 /// The second box is in identity configuration.
 bool obbDisjoint(const Matrix3f& B, const Vec3f& T, const Vec3f& a, const Vec3f& b);
 }
diff --git a/include/hpp/fcl/BV/OBBRSS.h b/include/hpp/fcl/BV/OBBRSS.h
index 36c97e6143d73c530f31e31f124ebdf7b27d6277..def7ce67ddd35cc54d5bd654acdeb8c138b5622f 100644
--- a/include/hpp/fcl/BV/OBBRSS.h
+++ b/include/hpp/fcl/BV/OBBRSS.h
@@ -48,6 +48,9 @@ namespace fcl
 {
   class CollisionRequest;
 
+/// @addtogroup Bounding_Volume
+/// @{
+
 /// @brief Class merging the OBB and RSS, can handle collision and distance simultaneously
 class OBBRSS
 {
@@ -72,7 +75,7 @@ public:
   }
 
   /// Check collision between two OBBRSS
-  /// \retval sqrDistLowerBound squared lower bound on distance between
+  /// @retval sqrDistLowerBound squared lower bound on distance between
   ///         objects if they do not overlap.
   bool overlap(const OBBRSS& other, const CollisionRequest& request,
                FCL_REAL& sqrDistLowerBound) const
@@ -154,9 +157,9 @@ inline bool overlap(const Matrix3f& R0, const Vec3f& T0, const OBBRSS& b1, const
 }
 
 /// Check collision between two OBBRSS
-/// \param  b1 first OBBRSS in configuration (R0, T0)
-/// \param  b2 second OBBRSS in identity position
-/// \retval squared lower bound on the distance if OBBRSS do not overlap.
+/// @param  b1 first OBBRSS in configuration (R0, T0)
+/// @param  b2 second OBBRSS in identity position
+/// @retval squared lower bound on the distance if OBBRSS do not overlap.
 inline bool overlap(const Matrix3f& R0, const Vec3f& T0, const OBBRSS& b1,
                     const OBBRSS& b2, const CollisionRequest& request,
 	            FCL_REAL& sqrDistLowerBound)
diff --git a/include/hpp/fcl/BV/RSS.h b/include/hpp/fcl/BV/RSS.h
index b626e27edf8561a1c14211d2bffbc9be73d1a62c..a380de68c2b033bda110b5bee23d1dfa679058bb 100644
--- a/include/hpp/fcl/BV/RSS.h
+++ b/include/hpp/fcl/BV/RSS.h
@@ -48,6 +48,9 @@ namespace fcl
 {
 
   class CollisionRequest;
+/// @addtogroup Bounding_Volume
+/// @{
+
 /// @brief A class for rectangle sphere-swept bounding volume
 class RSS
 {
diff --git a/include/hpp/fcl/BV/kDOP.h b/include/hpp/fcl/BV/kDOP.h
index 61e43d90244dec4fab97de79c62992af18364ee6..6a5c6aabe88b7a3a8cb6398ef2365b8d41d0119f 100644
--- a/include/hpp/fcl/BV/kDOP.h
+++ b/include/hpp/fcl/BV/kDOP.h
@@ -48,6 +48,9 @@ namespace fcl
 
   class CollisionRequest;
 
+  /// @addtogroup Bounding_Volume
+  /// @{
+
 /// @brief KDOP class describes the KDOP collision structures. K is set as the template parameter, which should be 16, 18, or 24
 ///  The KDOP structure is defined by some pairs of parallel planes defined by some axes. 
 /// For K = 16, the planes are 6 AABB planes and 10 diagonal planes that cut off some space of the edges:
diff --git a/include/hpp/fcl/BV/kIOS.h b/include/hpp/fcl/BV/kIOS.h
index 2227c9754a9b07707534cfaba04ab898bf7f56bb..be1a4f0bb0d050646ed287c66245f940d43f3d3a 100644
--- a/include/hpp/fcl/BV/kIOS.h
+++ b/include/hpp/fcl/BV/kIOS.h
@@ -46,7 +46,10 @@ namespace hpp
 namespace fcl
 {
   class CollisionRequest;
- 
+
+/// @addtogroup Bounding_Volume
+/// @{
+
 /// @brief A class describing the kIOS collision structure, which is a set of spheres.
 class kIOS
 {
diff --git a/include/hpp/fcl/BVH/BVH_model.h b/include/hpp/fcl/BVH/BVH_model.h
index d6d200334f6a094f27c307b57c57d095cefb30d7..095ff21c250877fb5b5c42a94aa0b6a89d7b3756 100644
--- a/include/hpp/fcl/BVH/BVH_model.h
+++ b/include/hpp/fcl/BVH/BVH_model.h
@@ -50,6 +50,9 @@ namespace hpp
 namespace fcl
 {
 
+/// @addtogroup Construction_Of_BVH
+/// @{
+
 class ConvexBase;
 
 template <typename BV> class BVFitter;
@@ -338,7 +341,7 @@ private:
   /// @brief Recursive kernel for bottomup refitting 
   int recursiveRefitTree_bottomup(int bv_id);
 
-  /// @recursively compute each bv's transform related to its parent. For default BV, only the translation works. 
+  /// @ recursively compute each bv's transform related to its parent. For default BV, only the translation works. 
   /// For oriented BV (OBB, RSS, OBBRSS), special implementation is provided.
   void makeParentRelativeRecurse(int bv_id, Matrix3f& parent_axes, const Vec3f& parent_c)
   {
@@ -353,6 +356,7 @@ private:
   }
 };
 
+/// @}
 
 template<>
 void BVHModel<OBB>::makeParentRelativeRecurse(int bv_id, Matrix3f& parent_axes, const Vec3f& parent_c);
diff --git a/include/hpp/fcl/collision_data.h b/include/hpp/fcl/collision_data.h
index d6278c2e07acd5e531eb9611e83834b0395922c9..fdc9993acfe47bfe90f40230b8f9cb1730c8b0ec 100644
--- a/include/hpp/fcl/collision_data.h
+++ b/include/hpp/fcl/collision_data.h
@@ -215,7 +215,7 @@ public:
   Vec3f cached_gjk_guess;
 
   /// Lower bound on distance between objects if they are disjoint
-  /// \note computed only on request.
+  /// @note computed only on request.
   FCL_REAL distance_lower_bound;
 
 public:
diff --git a/include/hpp/fcl/collision_object.h b/include/hpp/fcl/collision_object.h
index 9af086f557c5555af4f00988f5d667d46b1e40ba..1e743dbd08709af80e789ca23e63901c97c0bf45 100644
--- a/include/hpp/fcl/collision_object.h
+++ b/include/hpp/fcl/collision_object.h
@@ -56,6 +56,9 @@ enum OBJECT_TYPE {OT_UNKNOWN, OT_BVH, OT_GEOM, OT_OCTREE, OT_COUNT};
 enum NODE_TYPE {BV_UNKNOWN, BV_AABB, BV_OBB, BV_RSS, BV_kIOS, BV_OBBRSS, BV_KDOP16, BV_KDOP18, BV_KDOP24,
                 GEOM_BOX, GEOM_SPHERE, GEOM_CAPSULE, GEOM_CONE, GEOM_CYLINDER, GEOM_CONVEX, GEOM_PLANE, GEOM_HALFSPACE, GEOM_TRIANGLE, GEOM_OCTREE, NODE_COUNT};
 
+/// @addtogroup Construction_Of_BVH
+/// @{
+
 /// @brief The geometry for the object for collision or distance computation
 class CollisionGeometry
 {
diff --git a/include/hpp/fcl/distance.h b/include/hpp/fcl/distance.h
index d04d2c8224abfdfc1cc25f33d33fb7dbf4929780..45bbcbd736a89d860e759cd1d61b49350584f403 100644
--- a/include/hpp/fcl/distance.h
+++ b/include/hpp/fcl/distance.h
@@ -33,7 +33,7 @@
  *  POSSIBILITY OF SUCH DAMAGE.
  */
 
-/** \author Jia Pan */
+/** @author Jia Pan */
 
 #ifndef HPP_FCL_DISTANCE_H
 #define HPP_FCL_DISTANCE_H
diff --git a/include/hpp/fcl/mesh_loader/loader.h b/include/hpp/fcl/mesh_loader/loader.h
index d72e5c6f48a7a5bb7e0d151655902bc2b1234d98..5039bc05fa6e97625313b6f39b34158e227a37d8 100644
--- a/include/hpp/fcl/mesh_loader/loader.h
+++ b/include/hpp/fcl/mesh_loader/loader.h
@@ -53,7 +53,7 @@ namespace fcl {
     public:
       virtual ~MeshLoader() {}
 
-       /// \param bvType ignored
+      /// \param bvType ignored
       /// \deprecated Use MeshLoader::load(const std::string&, const Vec3f&)
       BVHModelPtr_t load (const std::string& filename,
           const Vec3f& scale,
diff --git a/include/hpp/fcl/narrowphase/gjk.h b/include/hpp/fcl/narrowphase/gjk.h
index 07d8a1646398379503d5512ddce33da4e468beb8..6e7d25ffc487085b533802b52cf1fb94c67c93cb 100644
--- a/include/hpp/fcl/narrowphase/gjk.h
+++ b/include/hpp/fcl/narrowphase/gjk.h
@@ -54,21 +54,21 @@ Vec3f getSupport(const ShapeBase* shape, const Vec3f& dir, bool dirIsNormalized)
 
 /// @brief Minkowski difference class of two shapes
 ///
-/// \todo template this by the two shapes. The triangle / triangle case can be
+/// @todo template this by the two shapes. The triangle / triangle case can be
 ///       easily optimized computing once the triangle shapes[1] into frame0
 ///
-/// \note The Minkowski difference is expressed in the frame of the first shape.
+/// @note The Minkowski difference is expressed in the frame of the first shape.
 struct MinkowskiDiff
 {
   /// @brief points to two shapes
   const ShapeBase* shapes[2];
 
   /// @brief rotation from shape1 to shape0
-  /// such that \f$ p_in_0 = oR1 * p_in_1 + ot1 \f$.
+  /// such that @f$ p_in_0 = oR1 * p_in_1 + ot1 @f$.
   Matrix3f oR1;
 
   /// @brief translation from shape1 to shape0
-  /// such that \f$ p_in_0 = oR1 * p_in_1 + ot1 \f$.
+  /// such that @f$ p_in_0 = oR1 * p_in_1 + ot1 @f$.
   Vec3f ot1;
 
   typedef void (*GetSupportFunction) (const MinkowskiDiff& minkowskiDiff,
@@ -107,7 +107,7 @@ struct MinkowskiDiff
 
 /// @brief class for GJK algorithm
 ///
-/// \note The computations are performed in the frame of the first shape.
+/// @note The computations are performed in the frame of the first shape.
 struct GJK
 {
   struct SimplexV
@@ -166,7 +166,7 @@ struct GJK
   }
 
   /// Get the closest points on each object.
-  /// \return true on success
+  /// @return true on success
   static bool getClosestPoints (const Simplex& simplex, Vec3f& w0, Vec3f& w1);
 
   /// @brief get the guess from current simplex
@@ -174,7 +174,7 @@ struct GJK
 
   /// @brief Distance threshold for early break.
   /// GJK stops when it proved the distance is more than this threshold.
-  /// \note The closest points will be erroneous in this case.
+  /// @note The closest points will be erroneous in this case.
   ///       If you want the closest points, set this to infinity (the default).
   void setDistanceEarlyBreak (const FCL_REAL& dup)
   {
diff --git a/include/hpp/fcl/narrowphase/narrowphase.h b/include/hpp/fcl/narrowphase/narrowphase.h
index cea51139e33588431f71dbccf3e8c6c69fd329d6..2dedf459c939ebb0ce1e21729eafafd6f2837149 100644
--- a/include/hpp/fcl/narrowphase/narrowphase.h
+++ b/include/hpp/fcl/narrowphase/narrowphase.h
@@ -94,7 +94,7 @@ namespace fcl
     }
 
     //// @brief intersection checking between one shape and a triangle with transformation
-    /// \return true if the shape are colliding.
+    /// @return true if the shape are colliding.
     template<typename S>
     bool shapeTriangleInteraction
     (const S& s, const Transform3f& tf1, const Vec3f& P1, const Vec3f& P2,
diff --git a/include/hpp/fcl/profile.h b/include/hpp/fcl/profile.h
index 96d70d1cf8ec02916c1a608c3aef439c03d24155..a7e3f2780503a26cc021676e95cfec25d0f3dcbb 100644
--- a/include/hpp/fcl/profile.h
+++ b/include/hpp/fcl/profile.h
@@ -115,7 +115,7 @@ public:
   class ScopedBlock
   {
   public:
-    /// @brief Start counting time for the block named \e name of the profiler \e prof
+    /// @brief Start counting time for the block named @e name of the profiler @e prof
     ScopedBlock(const std::string &name, Profiler &prof = Profiler::Instance()) : name_(name), prof_(prof)
     {
       prof_.begin(name);
@@ -138,7 +138,7 @@ public:
   {
   public:
 
-    /// @brief Take as argument the profiler instance to operate on (\e prof)
+    /// @brief Take as argument the profiler instance to operate on (@e prof)
     ScopedStart(Profiler &prof = Profiler::Instance()) : prof_(prof), wasRunning_(prof_.running())
     {
       if (!wasRunning_)
diff --git a/include/hpp/fcl/shape/geometric_shapes.h b/include/hpp/fcl/shape/geometric_shapes.h
index 4e75a2c8471b4f88207281281379fb0bf391ddf0..68c5cf07aa0f9d6d5daa4f16ea208ddedb3859ae 100644
--- a/include/hpp/fcl/shape/geometric_shapes.h
+++ b/include/hpp/fcl/shape/geometric_shapes.h
@@ -62,6 +62,10 @@ public:
   OBJECT_TYPE getObjectType() const { return OT_GEOM; }
 };
 
+/// @defgroup Geometric_Shapes
+/// regroup class of differents types of geometric shapes.
+/// @{
+
 /// @brief Triangle stores the points instead of only indices of points
 class TriangleP : public ShapeBase
 {
@@ -281,6 +285,7 @@ public:
 class ConvexBase : public ShapeBase
 {
 public:
+
   virtual ~ConvexBase();
 
   /// @brief Compute AABB 
diff --git a/src/BVH/BVH_utility.cpp b/src/BVH/BVH_utility.cpp
index c3ac12c76dc9007e60ee5222682ebf770419f4ce..55c67d0025eaad5408b9b18881747703e149d133 100644
--- a/src/BVH/BVH_utility.cpp
+++ b/src/BVH/BVH_utility.cpp
@@ -218,7 +218,7 @@ void getCovariance(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, i
 }
 
 
-/** \brief Compute the RSS bounding volume parameters: radius, rectangle size and the origin.
+/** @brief Compute the RSS bounding volume parameters: radius, rectangle size and the origin.
  * The bounding volume axes are known.
  */
 void getRadiusAndOriginAndRectangleSize(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, const Matrix3f& axes, Vec3f& origin, FCL_REAL l[2], FCL_REAL& r)
@@ -499,7 +499,7 @@ void getRadiusAndOriginAndRectangleSize(Vec3f* ps, Vec3f* ps2, Triangle* ts, uns
 }
 
 
-/** \brief Compute the bounding volume extent and center for a set or subset of points.
+/** @brief Compute the bounding volume extent and center for a set or subset of points.
  * The bounding volume axes are known.
  */
 static inline void getExtentAndCenter_pointcloud(Vec3f* ps, Vec3f* ps2, unsigned int* indices, int n, Matrix3f& axes, Vec3f& center, Vec3f& extent)
@@ -544,7 +544,7 @@ static inline void getExtentAndCenter_pointcloud(Vec3f* ps, Vec3f* ps2, unsigned
 }
 
 
-/** \brief Compute the bounding volume extent and center for a set or subset of points.
+/** @brief Compute the bounding volume extent and center for a set or subset of points.
  * The bounding volume axes are known.
  */
 static inline void getExtentAndCenter_mesh(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, Matrix3f& axes, Vec3f& center, Vec3f& extent)
diff --git a/src/collision_node.h b/src/collision_node.h
index 10a89dba69e01fb1e04001004e69b28d7bab37f0..7f2ffbd2c6c6e1dd918ae73f179b48ac3e08abb9 100644
--- a/src/collision_node.h
+++ b/src/collision_node.h
@@ -35,15 +35,14 @@
 
 /** \author Jia Pan */
 
-
 #ifndef HPP_FCL_COLLISION_NODE_H
 #define HPP_FCL_COLLISION_NODE_H
 
+/// @cond INTERNAL
+
+#include <hpp/fcl/BVH/BVH_front.h>
 #include "traversal/traversal_node_base.h"
 #include "traversal/traversal_node_bvhs.h"
-#include <hpp/fcl/BVH/BVH_front.h>
-
-
 
 /// @brief collision and distance function on traversal nodes. these functions provide a higher level abstraction for collision functions provided in collision_func_matrix
 namespace hpp
@@ -54,16 +53,14 @@ namespace fcl
 
 /// collision on collision traversal node
 /// 
-/// \param node node containing both objects to test,
-/// \retval squared lower bound to the distance between the objects if they
+/// @param node node containing both objects to test,
+/// @retval squared lower bound to the distance between the objects if they
 ///         do not collide.
-/// \param front_list list of nodes visited by the query, can be used to
+/// @param front_list list of nodes visited by the query, can be used to
 ///        accelerate computation
-  void collide(CollisionTraversalNodeBase* node,
-               const CollisionRequest& request,
-               CollisionResult& result,
-	       BVHFrontList* front_list = NULL,
-               bool recursive = true);
+void collide(CollisionTraversalNodeBase* node, const CollisionRequest& request,
+             CollisionResult& result, BVHFrontList* front_list = NULL,
+             bool recursive = true);
 
 /// @brief distance computation on distance traversal node; can use front list to accelerate
 void distance(DistanceTraversalNodeBase* node, BVHFrontList* front_list = NULL, int qsize = 2);
@@ -71,4 +68,6 @@ void distance(DistanceTraversalNodeBase* node, BVHFrontList* front_list = NULL,
 
 } // namespace hpp
 
+/// @endcond
+
 #endif
diff --git a/src/distance_func_matrix.h b/src/distance_func_matrix.h
index f9a291ee897c58d895b960b2948999d12c416d6f..3a142614f523f3a9e35b285c248a46852edebd6f 100644
--- a/src/distance_func_matrix.h
+++ b/src/distance_func_matrix.h
@@ -34,12 +34,18 @@
 
 /** \author Florent Lamiraux */
 
+#ifndef HPP_FCL_DISTANCE_FUNC_MATRIX_H
+#define HPP_FCL_DISTANCE_FUNC_MATRIX_H
+
+/// @cond INTERNAL
+
 #include <hpp/fcl/collision_data.h>
 #include <hpp/fcl/narrowphase/narrowphase.h>
 
 namespace hpp
 {
-namespace fcl {
+namespace fcl
+{
   template<typename T_SH1, typename T_SH2>
     FCL_REAL ShapeShapeDistance
     (const CollisionGeometry* o1, const Transform3f& tf1,
@@ -56,3 +62,7 @@ namespace fcl {
 }
 
 } // namespace hpp
+
+/// @endcond
+
+#endif
\ No newline at end of file
diff --git a/src/intersect.h b/src/intersect.h
index fd8dfd559040d88bde32a6871dc1a385554b8a99..b0b397a3aeb3e4dcf5c4e4a55bdcc5fa331eb346 100644
--- a/src/intersect.h
+++ b/src/intersect.h
@@ -38,6 +38,8 @@
 #ifndef HPP_FCL_INTERSECT_H
 #define HPP_FCL_INTERSECT_H
 
+/// @cond INTERNAL
+
 #include <hpp/fcl/math/transform.h>
 #include <boost/math/special_functions/erf.hpp>
 
@@ -107,9 +109,9 @@ public:
                         Vec3f& VEC, Vec3f& X, Vec3f& Y);
 
   /// Compute squared distance between triangles
-  /// \param S and T are two triangles
-  /// \retval P, Q closest points if triangles do not intersect.
-  /// \return squared distance if triangles do not intersect, 0 otherwise.
+  /// @param S and T are two triangles
+  /// @retval P, Q closest points if triangles do not intersect.
+  /// @return squared distance if triangles do not intersect, 0 otherwise.
   /// If the triangles are disjoint, P and Q give the closet points of
   /// S and T respectively. However,
   /// if the triangles overlap, P and Q are basically a random pair of points
@@ -124,10 +126,10 @@ public:
 				  Vec3f& P, Vec3f& Q);
 
   /// Compute squared distance between triangles
-  /// \param S and T are two triangles
-  /// \param R, Tl, rotation and translation applied to T,
-  /// \retval P, Q closest points if triangles do not intersect.
-  /// \return squared distance if triangles do not intersect, 0 otherwise.
+  /// @param S and T are two triangles
+  /// @param R, Tl, rotation and translation applied to T,
+  /// @retval P, Q closest points if triangles do not intersect.
+  /// @return squared distance if triangles do not intersect, 0 otherwise.
   /// If the triangles are disjoint, P and Q give the closet points of
   /// S and T respectively. However,
   /// if the triangles overlap, P and Q are basically a random pair of points
@@ -138,10 +140,10 @@ public:
 				  Vec3f& P, Vec3f& Q);
 
   /// Compute squared distance between triangles
-  /// \param S and T are two triangles
-  /// \param tf, rotation and translation applied to T,
-  /// \retval P, Q closest points if triangles do not intersect.
-  /// \return squared distance if triangles do not intersect, 0 otherwise.
+  /// @param S and T are two triangles
+  /// @param tf, rotation and translation applied to T,
+  /// @retval P, Q closest points if triangles do not intersect.
+  /// @return squared distance if triangles do not intersect, 0 otherwise.
   /// If the triangles are disjoint, P and Q give the closet points of
   /// S and T respectively. However,
   /// if the triangles overlap, P and Q are basically a random pair of points
@@ -153,10 +155,10 @@ public:
 
 
   /// Compute squared distance between triangles
-  /// \param S1, S2, S3 and T1, T2, T3 are triangle vertices
-  /// \param R, Tl, rotation and translation applied to T1, T2, T3,
-  /// \retval P, Q closest points if triangles do not intersect.
-  /// \return squared distance if triangles do not intersect, 0 otherwise.
+  /// @param S1, S2, S3 and T1, T2, T3 are triangle vertices
+  /// @param R, Tl, rotation and translation applied to T1, T2, T3,
+  /// @retval P, Q closest points if triangles do not intersect.
+  /// @return squared distance if triangles do not intersect, 0 otherwise.
   /// If the triangles are disjoint, P and Q give the closet points of
   /// S and T respectively. However,
   /// if the triangles overlap, P and Q are basically a random pair of points
@@ -169,10 +171,10 @@ public:
 				  Vec3f& P, Vec3f& Q);
 
   /// Compute squared distance between triangles
-  /// \param S1, S2, S3 and T1, T2, T3 are triangle vertices
-  /// \param tf, rotation and translation applied to T1, T2, T3,
-  /// \retval P, Q closest points if triangles do not intersect.
-  /// \return squared distance if triangles do not intersect, 0 otherwise.
+  /// @param S1, S2, S3 and T1, T2, T3 are triangle vertices
+  /// @param tf, rotation and translation applied to T1, T2, T3,
+  /// @retval P, Q closest points if triangles do not intersect.
+  /// @return squared distance if triangles do not intersect, 0 otherwise.
   /// If the triangles are disjoint, P and Q give the closet points of
   /// S and T respectively. However,
   /// if the triangles overlap, P and Q are basically a random pair of points
@@ -186,10 +188,10 @@ public:
 
 };
 
-
 }
 
-
 } // namespace hpp
 
+/// @endcond
+
 #endif
diff --git a/src/narrowphase/details.h b/src/narrowphase/details.h
index a395abd75035d0b82a00b7b8f2a7d06fad146f0f..3b658753bf7296e33b4f5205cda22704bd238013 100644
--- a/src/narrowphase/details.h
+++ b/src/narrowphase/details.h
@@ -273,7 +273,7 @@ namespace fcl {
       return (dist >=0);
     }
 
-    /** \brief the minimum distance from a point to a line */
+    /** @brief the minimum distance from a point to a line */
     inline FCL_REAL segmentSqrDistance
       (const Vec3f& from, const Vec3f& to,const Vec3f& p, Vec3f& nearest)
     {
@@ -2092,11 +2092,11 @@ namespace fcl {
     }
 
     /// Taken from book Real Time Collision Detection, from Christer Ericson
-    /// \param pb the closest point to the sphere center on the box surface
-    /// \param ps when colliding, matches pb, which is inside the sphere.
+    /// @param pb the closest point to the sphere center on the box surface
+    /// @param ps when colliding, matches pb, which is inside the sphere.
     ///           when not colliding, the closest point on the sphere
-    /// \param normal direction of motion of the box
-    /// \return true if the distance is negative (the shape overlaps).
+    /// @param normal direction of motion of the box
+    /// @return true if the distance is negative (the shape overlaps).
     inline bool boxSphereDistance(const Box   & b, const Transform3f& tfb,
                                   const Sphere& s, const Transform3f& tfs,
                                   FCL_REAL& dist, Vec3f& pb, Vec3f& ps,
diff --git a/src/narrowphase/gjk.cpp b/src/narrowphase/gjk.cpp
index 230884e9831a93f141a7b99f574b970d6e3f7a46..ff094b80cac59e67ea9eca034c63a44c1b753fa4 100644
--- a/src/narrowphase/gjk.cpp
+++ b/src/narrowphase/gjk.cpp
@@ -1126,7 +1126,7 @@ EPA::SimplexF* EPA::newFace(SimplexV* a, SimplexV* b, SimplexV* c, bool forced)
   return NULL;
 }
 
-/** \brief Find the best polytope face to split */
+/** @brief Find the best polytope face to split */
 EPA::SimplexF* EPA::findBest()
 {
   SimplexF* minf = hull.root;
@@ -1258,7 +1258,7 @@ EPA::Status EPA::evaluate(GJK& gjk, const Vec3f& guess)
 }
 
 
-/** \brief the goal is to add a face connecting vertex w and face edge f[e] */
+/** @brief the goal is to add a face connecting vertex w and face edge f[e] */
 bool EPA::expand(size_t pass, SimplexV* w, SimplexF* f, size_t e, SimplexHorizon& horizon)
 {
   static const size_t nexti[] = {1, 2, 0};
diff --git a/src/traits_traversal.h b/src/traits_traversal.h
new file mode 100644
index 0000000000000000000000000000000000000000..312e27d5e2b613e82bac7dc350aaef812c91e149
--- /dev/null
+++ b/src/traits_traversal.h
@@ -0,0 +1,97 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2014, CNRS-LAAS
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** \author Florent Lamiraux */
+
+
+#include <hpp/fcl/collision_func_matrix.h>
+
+#include "traversal/traversal_node_setup.h"
+#include <../src/collision_node.h>
+#include <hpp/fcl/narrowphase/narrowphase.h>
+#include "distance_func_matrix.h"
+
+namespace hpp
+{
+namespace fcl
+{
+template <typename TypeA, typename TypeB>
+struct TraversalTraits
+{
+};
+
+template <typename T_SH>
+struct TraversalTraits <T_SH, OcTree>
+{
+  typedef ShapeOcTreeCollisionTraversalNode<T_SH, GJKSolver> CollisionTraversal_t;
+};
+
+template <typename T_SH>
+struct TraversalTraits <OcTree, T_SH>
+{
+  typedef OcTreeShapeCollisionTraversalNode<T_SH, GJKSolver> CollisionTraversal_t;
+};
+
+template <>
+struct TraversalTraits <OcTree, OcTree>
+{
+  typedef OcTreeCollisionTraversalNode<GJKSolver> CollisionTraversal_t;
+};
+
+template <typename T_BVH>
+struct TraversalTraits <OcTree, BVHModel<T_BVH>>
+{
+  typedef OcTreeMeshCollisionTraversalNode<T_BVH, GJKSolver> CollisionTraversal_t;
+};
+
+template <typename T_BVH>
+struct TraversalTraits <BVHModel<T_BVH>, OcTree>
+{
+  typedef MeshOcTreeCollisionTraversalNode<T_BVH, GJKSolver> CollisionTraversal_t;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+} //hpp
\ No newline at end of file
diff --git a/src/traversal/details/traversal.h b/src/traversal/details/traversal.h
index 2979a601f169303b8f3e6cf5b0a010c18d0e43fa..82553dcd6587be92f4279d1fae1f6077f5aa3e4b 100644
--- a/src/traversal/details/traversal.h
+++ b/src/traversal/details/traversal.h
@@ -34,10 +34,11 @@
 
 /** \author Joseph Mirabel */
 
-
 #ifndef HPP_FCL_TRAVERSAL_DETAILS_TRAVERSAL_H
 #define HPP_FCL_TRAVERSAL_DETAILS_TRAVERSAL_H
 
+/// @cond INTERNAL
+
 namespace hpp
 {
 namespace fcl
@@ -73,4 +74,6 @@ namespace details
 
 } // namespace hpp
 
+/// @endcond
+
 #endif
diff --git a/src/traversal/traversal_node_base.h b/src/traversal/traversal_node_base.h
index 2e5419598df8c78ae1d4dcfb6656350b11b3c027..6f6c41e32afcd3ddfbf79a11a32a6fefab5eab15 100644
--- a/src/traversal/traversal_node_base.h
+++ b/src/traversal/traversal_node_base.h
@@ -38,6 +38,8 @@
 #ifndef HPP_FCL_TRAVERSAL_NODE_BASE_H
 #define HPP_FCL_TRAVERSAL_NODE_BASE_H
 
+/// @cond INTERNAL
+
 #include <hpp/fcl/data_types.h>
 #include <hpp/fcl/math/transform.h>
 #include <hpp/fcl/collision_data.h>
@@ -48,6 +50,7 @@ namespace fcl
 {
 
 /// @brief Node structure encoding the information required for traversal.
+
 class TraversalNodeBase
 {
 public:
@@ -88,6 +91,10 @@ public:
   Transform3f tf2;
 };
 
+/// @defgroup Traversal_For_Collision
+/// regroup class about traversal for distance.
+/// @{
+
 /// @brief Node structure encoding the information required for collision traversal.
 class CollisionTraversalNodeBase : public TraversalNodeBase
 {
@@ -101,8 +108,8 @@ public:
   virtual bool BVDisjoints(int b1, int b2) const = 0;
 
   /// BV test between b1 and b2
-  /// \param b1, b2 Bounding volumes to test,
-  /// \retval sqrDistLowerBound square of a lower bound of the minimal
+  /// @param b1, b2 Bounding volumes to test,
+  /// @retval sqrDistLowerBound square of a lower bound of the minimal
   ///         distance between bounding volumes.
   virtual bool BVDisjoints(int b1, int b2, FCL_REAL& sqrDistLowerBound) const = 0;
 
@@ -128,6 +135,12 @@ public:
   bool enable_statistics;
 };
 
+/// @}
+
+/// @defgroup Traversal_For_Distance
+/// regroup class about traversal for distance.
+/// @{
+
 /// @brief Node structure encoding the information required for distance traversal.
 class DistanceTraversalNodeBase : public TraversalNodeBase
 {
@@ -137,8 +150,8 @@ public:
   virtual ~DistanceTraversalNodeBase();
 
   /// @brief BV test between b1 and b2
-  /// \return a lower bound of the distance between the two BV.
-  /// \note except for OBB, this method returns the distance.
+  /// @return a lower bound of the distance between the two BV.
+  /// @note except for OBB, this method returns the distance.
   virtual FCL_REAL BVDistanceLowerBound(int b1, int b2) const;
 
   /// @brief Leaf test between node b1 and b2, if they are both leafs
@@ -159,8 +172,13 @@ public:
   /// @brief Whether stores statistics 
   bool enable_statistics;
 };
+
+///@}
+
 }
 
 } // namespace hpp
 
-#endif
+/// @endcond
+
+#endif
\ No newline at end of file
diff --git a/src/traversal/traversal_node_bvh_shape.h b/src/traversal/traversal_node_bvh_shape.h
index b01351ac562581a0f09aef6e824a28091fb2ca75..0fb53f78a55fccd1267ba58f708160607db36b94 100644
--- a/src/traversal/traversal_node_bvh_shape.h
+++ b/src/traversal/traversal_node_bvh_shape.h
@@ -39,6 +39,8 @@
 #ifndef HPP_FCL_TRAVERSAL_NODE_MESH_SHAPE_H
 #define HPP_FCL_TRAVERSAL_NODE_MESH_SHAPE_H
 
+/// @cond INTERNAL
+
 #include <hpp/fcl/collision_data.h>
 #include <hpp/fcl/shape/geometric_shapes.h>
 #include "../src/shape/geometric_shapes_utility.h"
@@ -52,6 +54,9 @@ namespace hpp
 namespace fcl
 {
 
+/// @addtogroup Traversal_For_Collision
+/// @{
+
 /// @brief Traversal node for collision between BVH and shape
 template<typename BV, typename S>
 class BVHShapeCollisionTraversalNode : public CollisionTraversalNodeBase
@@ -176,8 +181,8 @@ public:
   }
 
   /// test between BV b1 and shape
-  /// \param b1 BV to test,
-  /// \retval sqrDistLowerBound square of a lower bound of the minimal
+  /// @param b1 BV to test,
+  /// @retval sqrDistLowerBound square of a lower bound of the minimal
   ///         distance between bounding volumes.
   /// @brief BV culling test in one BVTT node
   bool BVDisjoints(int b1, int /*b2*/, FCL_REAL& sqrDistLowerBound) const
@@ -326,7 +331,7 @@ public:
   }
 
   /// BV test between b1 and b2
-  /// \param b2 Bounding volumes to test,
+  /// @param b2 Bounding volumes to test,
   bool BVDisjoints(int /*b1*/, int b2) const
   {
     if(this->enable_statistics) this->num_bv_tests++;
@@ -337,8 +342,8 @@ public:
   }
 
   /// BV test between b1 and b2
-  /// \param b2 Bounding volumes to test,
-  /// \retval sqrDistLowerBound square of a lower bound of the minimal
+  /// @param b2 Bounding volumes to test,
+  /// @retval sqrDistLowerBound square of a lower bound of the minimal
   ///         distance between bounding volumes.
   bool BVDisjoints(int /*b1*/, int b2, FCL_REAL& sqrDistLowerBound) const
   {
@@ -459,6 +464,11 @@ public:
   }
 };
 
+/// @}
+
+/// @addtogroup Traversal_For_Distance
+/// @{
+
 /// @brief Traversal node for distance computation between BVH and shape
 template<typename BV, typename S>
 class BVHShapeDistanceTraversalNode : public DistanceTraversalNodeBase
@@ -681,7 +691,7 @@ static inline void distancePreprocessOrientedNode(const BVHModel<BV>* model1,
 
 
 
-/// @brief Traversal node for distance between mesh and shape, when mesh BVH is one of the oriented node (RSS, OBBRSS, kIOS)
+/// @brief Traversal node for distance between mesh and shape, when mesh BVH is one of the oriented node (RSS, kIOS, OBBRSS)
 template<typename S>
 class MeshShapeDistanceTraversalNodeRSS : public MeshShapeDistanceTraversalNode<RSS, S>
 {
@@ -838,6 +848,7 @@ public:
   const GJKSolver* nsolver;
 };
 
+/// @brief Traversal node for distance between shape and mesh, when mesh BVH is one of the oriented node (RSS, kIOS, OBBRSS)
 template<typename S>
 class ShapeMeshDistanceTraversalNodeRSS : public ShapeMeshDistanceTraversalNode<S, RSS>
 {
@@ -933,8 +944,13 @@ public:
   }
   
 };
+
+/// @}
+
 }
 
 } // namespace hpp
 
+/// @endcond
+
 #endif
diff --git a/src/traversal/traversal_node_bvhs.h b/src/traversal/traversal_node_bvhs.h
index b35e9783846d6618b792e8f6a3dd6828adc1d3e6..13d63f740829c6e9dbbc341a50d9343543066405 100644
--- a/src/traversal/traversal_node_bvhs.h
+++ b/src/traversal/traversal_node_bvhs.h
@@ -35,10 +35,11 @@
 
 /** \author Jia Pan */
 
-
 #ifndef HPP_FCL_TRAVERSAL_NODE_MESHES_H
 #define HPP_FCL_TRAVERSAL_NODE_MESHES_H
 
+/// @cond INTERNAL
+
 #include <hpp/fcl/collision_data.h>
 #include "traversal_node_base.h"
 #include <hpp/fcl/BV/BV_node.h>
@@ -55,11 +56,14 @@
 #include <vector>
 #include <cassert>
 
-
 namespace hpp
 {
 namespace fcl
 {
+
+/// @addtogroup Traversal_For_Collision
+/// @{
+
 /// @brief Traversal node for collision between BVH models
 template<typename BV>
 class BVHCollisionTraversalNode : public CollisionTraversalNodeBase
@@ -168,8 +172,8 @@ public:
   }
   
   /// BV test between b1 and b2
-  /// \param b1, b2 Bounding volumes to test,
-  /// \retval sqrDistLowerBound square of a lower bound of the minimal
+  /// @param b1, b2 Bounding volumes to test,
+  /// @retval sqrDistLowerBound square of a lower bound of the minimal
   ///         distance between bounding volumes.
   bool BVDisjoints(int b1, int b2, FCL_REAL& sqrDistLowerBound) const
   {
@@ -188,8 +192,8 @@ public:
 
   /// Intersection testing between leaves (two triangles)
   ///
-  /// \param b1, b2 id of primitive in bounding volume hierarchy
-  /// \retval sqrDistLowerBound squared lower bound of distance between
+  /// @param b1, b2 id of primitive in bounding volume hierarchy
+  /// @retval sqrDistLowerBound squared lower bound of distance between
   ///         primitives if they are not in collision.
   ///
   /// This method supports a security margin. If the distance between
@@ -197,7 +201,7 @@ public:
   /// considered as in collision. in this case a contact point is
   /// returned in the CollisionResult.
   ///
-  /// \note If the distance between objects is less than the security margin,
+  /// @note If the distance between objects is less than the security margin,
   ///       and the object are not colliding, the penetration depth is
   ///       negative.
   void leafCollides(int b1, int b2, FCL_REAL& sqrDistLowerBound) const
@@ -269,6 +273,8 @@ typedef MeshCollisionTraversalNode<RSS   , 0> MeshCollisionTraversalNodeRSS   ;
 typedef MeshCollisionTraversalNode<kIOS  , 0> MeshCollisionTraversalNodekIOS  ;
 typedef MeshCollisionTraversalNode<OBBRSS, 0> MeshCollisionTraversalNodeOBBRSS;
 
+/// @}
+
 namespace details
 {
   template<typename BV> struct DistanceTraversalBVDistanceLowerBound_impl
@@ -295,6 +301,9 @@ namespace details
   };
 } // namespace details
 
+/// @addtogroup Traversal_For_Distance
+/// @{
+
 /// @brief Traversal node for distance computation between BVH models
 template<typename BV>
 class BVHDistanceTraversalNode : public DistanceTraversalNodeBase
@@ -502,6 +511,8 @@ public:
   Vec3f T;
 };
 
+/// @}
+
 /// @brief for OBB and RSS, there is local coordinate of BV, so normal need to be transformed
 namespace details
 {
@@ -518,11 +529,12 @@ inline const Matrix3f& getBVAxes<OBBRSS>(const OBBRSS& bv)
   return bv.obb.axes;
 }
 
-
 }
 
 }
 
 } // namespace hpp
 
+/// @endcond
+
 #endif
diff --git a/src/traversal/traversal_node_octree.h b/src/traversal/traversal_node_octree.h
index 142531ef98a232910073b66ea5e0c9232be944f5..3042d43bf083aef5b102687c2374141bea520d93 100644
--- a/src/traversal/traversal_node_octree.h
+++ b/src/traversal/traversal_node_octree.h
@@ -38,6 +38,8 @@
 #ifndef HPP_FCL_TRAVERSAL_NODE_OCTREE_H
 #define HPP_FCL_TRAVERSAL_NODE_OCTREE_H
 
+/// @cond INTERNAL
+
 #include <hpp/fcl/collision_data.h>
 #include "traversal_node_base.h"
 #include <hpp/fcl/narrowphase/narrowphase.h>
@@ -885,8 +887,8 @@ private:
   }
 };
 
-
-
+/// @addtogroup Traversal_For_Collision
+/// @{
 
 /// @brief Traversal node for octree collision
 class OcTreeCollisionTraversalNode : public CollisionTraversalNodeBase
@@ -924,40 +926,6 @@ public:
   const OcTreeSolver* otsolver;
 };
 
-/// @brief Traversal node for octree distance
-class OcTreeDistanceTraversalNode : public DistanceTraversalNodeBase
-{
-public:
-  OcTreeDistanceTraversalNode()
-  {
-    model1 = NULL;
-    model2 = NULL;
-
-    otsolver = NULL;
-  }
-
-
-  FCL_REAL BVDistanceLowerBound(int, int) const
-  {
-    return -1;
-  }
-
-  bool BVDistanceLowerBound(int, int, FCL_REAL&) const
-  {
-    return false;
-  }
-
-  void leafComputeDistance(int, int) const
-  {
-    otsolver->OcTreeDistance(model1, model2, tf1, tf2, request, *result);
-  }
-
-  const OcTree* model1;
-  const OcTree* model2;
-
-  const OcTreeSolver* otsolver;
-};
-
 /// @brief Traversal node for shape-octree collision
 template<typename S>
 class ShapeOcTreeCollisionTraversalNode : public CollisionTraversalNodeBase
@@ -996,6 +964,7 @@ public:
 };
 
 /// @brief Traversal node for octree-shape collision
+
 template<typename S>
 class OcTreeShapeCollisionTraversalNode : public CollisionTraversalNodeBase
 {
@@ -1032,71 +1001,90 @@ public:
   const OcTreeSolver* otsolver;  
 };
 
-/// @brief Traversal node for shape-octree distance
-template<typename S>
-class ShapeOcTreeDistanceTraversalNode : public DistanceTraversalNodeBase
+/// @brief Traversal node for mesh-octree collision
+template<typename BV>
+class MeshOcTreeCollisionTraversalNode : public CollisionTraversalNodeBase
 {
 public:
-  ShapeOcTreeDistanceTraversalNode()
+ MeshOcTreeCollisionTraversalNode(const CollisionRequest& request) :
+  CollisionTraversalNodeBase (request)
   {
     model1 = NULL;
     model2 = NULL;
-    
+
     otsolver = NULL;
   }
 
-  FCL_REAL BVDistanceLowerBound(int, int) const
+  bool BVDisjoints(int, int) const
   {
-    return -1;
+    return false;
   }
 
-  void leafComputeDistance(int, int) const
+  bool BVDisjoints(int, int, FCL_REAL&) const
   {
-    otsolver->OcTreeShapeDistance(model2, *model1, tf2, tf1, request, *result);
+    return false;
   }
 
-  const S* model1;
+  void leafCollides(int, int, FCL_REAL&) const
+  {
+    otsolver->OcTreeMeshIntersect(model2, model1, tf2, tf1, request, *result);
+  }
+
+  const BVHModel<BV>* model1;
   const OcTree* model2;
 
+  Transform3f tf1, tf2;
+    
   const OcTreeSolver* otsolver;
 };
 
-/// @brief Traversal node for octree-shape distance
-template<typename S>
-class OcTreeShapeDistanceTraversalNode : public DistanceTraversalNodeBase
+/// @brief Traversal node for octree-mesh collision
+template<typename BV>
+class OcTreeMeshCollisionTraversalNode : public CollisionTraversalNodeBase
 {
 public:
-  OcTreeShapeDistanceTraversalNode()
+ OcTreeMeshCollisionTraversalNode(const CollisionRequest& request) :
+  CollisionTraversalNodeBase (request)
   {
     model1 = NULL;
     model2 = NULL;
-    
+
     otsolver = NULL;
   }
 
-  FCL_REAL BVDistanceLowerBound(int, int) const
+  bool BVDisjoints(int, int) const
   {
-    return -1;
+    return false;
   }
 
-  void leafComputeDistance(int, int) const
+  bool BVDisjoints(int, int, FCL_REAL&) const
   {
-    otsolver->OcTreeShapeDistance(model1, *model2, tf1, tf2, request, *result);
+    return false;
+  }
+
+  void leafCollides(int, int, FCL_REAL&) const
+  {
+    otsolver->OcTreeMeshIntersect(model1, model2, tf1, tf2, request, *result);
   }
 
   const OcTree* model1;
-  const S* model2;
+  const BVHModel<BV>* model2;
 
+  Transform3f tf1, tf2;
+    
   const OcTreeSolver* otsolver;
 };
 
-/// @brief Traversal node for mesh-octree collision
-template<typename BV>
-class MeshOcTreeCollisionTraversalNode : public CollisionTraversalNodeBase
+/// @}
+
+/// @addtogroup Traversal_For_Distance
+/// @{
+
+/// @brief Traversal node for octree distance
+class OcTreeDistanceTraversalNode : public DistanceTraversalNodeBase
 {
 public:
- MeshOcTreeCollisionTraversalNode(const CollisionRequest& request) :
-  CollisionTraversalNodeBase (request)
+  OcTreeDistanceTraversalNode()
   {
     model1 = NULL;
     model2 = NULL;
@@ -1104,63 +1092,85 @@ public:
     otsolver = NULL;
   }
 
-  bool BVDisjoints(int, int) const
+
+  FCL_REAL BVDistanceLowerBound(int, int) const
   {
-    return false;
+    return -1;
   }
 
-  bool BVDisjoints(int, int, FCL_REAL&) const
+  bool BVDistanceLowerBound(int, int, FCL_REAL&) const
   {
     return false;
   }
 
-  void leafCollides(int, int, FCL_REAL&) const
+  void leafComputeDistance(int, int) const
   {
-    otsolver->OcTreeMeshIntersect(model2, model1, tf2, tf1, request, *result);
+    otsolver->OcTreeDistance(model1, model2, tf1, tf2, request, *result);
   }
 
-  const BVHModel<BV>* model1;
+  const OcTree* model1;
   const OcTree* model2;
 
-  Transform3f tf1, tf2;
-    
   const OcTreeSolver* otsolver;
 };
 
-/// @brief Traversal node for octree-mesh collision
-template<typename BV>
-class OcTreeMeshCollisionTraversalNode : public CollisionTraversalNodeBase
+
+
+/// @brief Traversal node for shape-octree distance
+template<typename S>
+class ShapeOcTreeDistanceTraversalNode : public DistanceTraversalNodeBase
 {
 public:
- OcTreeMeshCollisionTraversalNode(const CollisionRequest& request) :
-  CollisionTraversalNodeBase (request)
+  ShapeOcTreeDistanceTraversalNode()
   {
     model1 = NULL;
     model2 = NULL;
-
+    
     otsolver = NULL;
   }
 
-  bool BVDisjoints(int, int) const
+  FCL_REAL BVDistanceLowerBound(int, int) const
   {
-    return false;
+    return -1;
   }
 
-  bool BVDisjoints(int, int, FCL_REAL&) const
+  void leafComputeDistance(int, int) const
   {
-    return false;
+    otsolver->OcTreeShapeDistance(model2, *model1, tf2, tf1, request, *result);
   }
 
-  void leafCollides(int, int, FCL_REAL&) const
+  const S* model1;
+  const OcTree* model2;
+
+  const OcTreeSolver* otsolver;
+};
+
+/// @brief Traversal node for octree-shape distance
+template<typename S>
+class OcTreeShapeDistanceTraversalNode : public DistanceTraversalNodeBase
+{
+public:
+  OcTreeShapeDistanceTraversalNode()
   {
-    otsolver->OcTreeMeshIntersect(model1, model2, tf1, tf2, request, *result);
+    model1 = NULL;
+    model2 = NULL;
+    
+    otsolver = NULL;
+  }
+
+  FCL_REAL BVDistanceLowerBound(int, int) const
+  {
+    return -1;
+  }
+
+  void leafComputeDistance(int, int) const
+  {
+    otsolver->OcTreeShapeDistance(model1, *model2, tf1, tf2, request, *result);
   }
 
   const OcTree* model1;
-  const BVHModel<BV>* model2;
+  const S* model2;
 
-  Transform3f tf1, tf2;
-    
   const OcTreeSolver* otsolver;
 };
 
@@ -1224,10 +1234,12 @@ public:
 
 };
 
-
+/// @}
 
 }
 
 } // namespace hpp
 
+/// @endcond
+
 #endif
diff --git a/src/traversal/traversal_node_setup.h b/src/traversal/traversal_node_setup.h
index 85cdfbc57c8d0868b54b13694af11625b38b1319..6c50a0e72616b103218a83831e267c90f9afb6c2 100644
--- a/src/traversal/traversal_node_setup.h
+++ b/src/traversal/traversal_node_setup.h
@@ -35,10 +35,11 @@
 
 /** \author Jia Pan */
 
-
 #ifndef HPP_FCL_TRAVERSAL_NODE_SETUP_H
 #define HPP_FCL_TRAVERSAL_NODE_SETUP_H
 
+/// @cond INTERNAL
+
 #include "traversal_node_bvhs.h"
 #include "traversal_node_shapes.h"
 #include "traversal_node_bvh_shape.h"
@@ -82,6 +83,7 @@ inline bool initialize(OcTreeDistanceTraversalNode& node,
                        const OcTreeSolver* otsolver,
                        const DistanceRequest& request,
                        DistanceResult& result)
+
 {
   node.request = request;
   node.result = &result;
@@ -886,4 +888,6 @@ bool initialize(ShapeMeshDistanceTraversalNodeOBBRSS<S>& node,
 
 } // namespace hpp
 
+/// @endcond
+
 #endif
diff --git a/src/traversal/traversal_node_shapes.h b/src/traversal/traversal_node_shapes.h
index 4344c4e57e3673681b736ba42fd0b2391583a705..a6d960603840be3de40ebbc0e4cf5b7cc1c36de4 100644
--- a/src/traversal/traversal_node_shapes.h
+++ b/src/traversal/traversal_node_shapes.h
@@ -35,21 +35,24 @@
 
 /** \author Jia Pan */
 
-
 #ifndef HPP_FCL_TRAVERSAL_NODE_SHAPES_H
 #define HPP_FCL_TRAVERSAL_NODE_SHAPES_H
 
+/// @cond INTERNAL
+
 #include <hpp/fcl/collision_data.h>
-#include "traversal_node_base.h"
 #include <hpp/fcl/narrowphase/narrowphase.h>
 #include <hpp/fcl/BV/BV.h>
 #include "../src/shape/geometric_shapes_utility.h"
+#include "traversal_node_base.h"
 
 namespace hpp
 {
 namespace fcl
 {
 
+/// @addtogroup Traversal_For_Collision
+/// @{
 
 /// @brief Traversal node for collision between two shapes
 template<typename S1, typename S2>
@@ -113,6 +116,11 @@ public:
   const GJKSolver* nsolver;
 };
 
+/// @}
+
+/// @addtogroup Traversal_For_Distance
+/// @{
+
 /// @brief Traversal node for distance between two shapes
 template<typename S1, typename S2>
 class ShapeDistanceTraversalNode : public DistanceTraversalNodeBase
@@ -148,8 +156,13 @@ public:
 
   const GJKSolver* nsolver;
 };
+
+/// @}
+
 }
 
 } // namespace hpp
 
+/// @endcond
+
 #endif
diff --git a/src/traversal/traversal_recurse.cpp b/src/traversal/traversal_recurse.cpp
index 5aa55c448893b536e1efc23988af5fda1597ed03..0a139b35f0c08230fd61740d54248ecffa41f2c2 100644
--- a/src/traversal/traversal_recurse.cpp
+++ b/src/traversal/traversal_recurse.cpp
@@ -220,17 +220,17 @@ void distanceRecurse(DistanceTraversalNodeBase* node, int b1, int b2, BVHFrontLi
 }
 
 
-/** \brief Bounding volume test structure */
+/** @brief Bounding volume test structure */
 struct BVT
 {
-  /** \brief distance between bvs */
+  /** @brief distance between bvs */
   FCL_REAL d;
 
-  /** \brief bv indices for a pair of bvs in two models */
+  /** @brief bv indices for a pair of bvs in two models */
   int b1, b2;
 };
 
-/** \brief Comparer between two BVT */
+/** @brief Comparer between two BVT */
 struct BVT_Comparer
 {
   bool operator() (const BVT& lhs, const BVT& rhs) const
@@ -275,7 +275,7 @@ struct BVTQ
 
   std::priority_queue<BVT, std::vector<BVT>, BVT_Comparer> pq;
 
-  /** \brief Queue size */
+  /** @brief Queue size */
   unsigned int qsize;
 };
 
diff --git a/src/traversal/traversal_recurse.h b/src/traversal/traversal_recurse.h
index f5a4e58e90f835286497ad81102aff23a3fe01af..f5ac757894a8cd7988593b8fda03c6ff72fe5645 100644
--- a/src/traversal/traversal_recurse.h
+++ b/src/traversal/traversal_recurse.h
@@ -35,14 +35,15 @@
 
 /** \author Jia Pan */
 
-
 #ifndef HPP_FCL_TRAVERSAL_RECURSE_H
 #define HPP_FCL_TRAVERSAL_RECURSE_H
 
-#include "traversal_node_base.h"
-#include "traversal_node_bvhs.h"
+/// @cond INTERNAL
+
 #include <hpp/fcl/BVH/BVH_front.h>
 #include <queue>
+#include "traversal_node_base.h"
+#include "traversal_node_bvhs.h"
 
 namespace hpp
 {
@@ -50,9 +51,9 @@ namespace fcl
 {
 
 /// Recurse function for collision
-/// \param node collision node,
-/// \param b1, b2 ids of bounding volume nodes for object 1 and object 2
-/// \retval sqrDistLowerBound squared lower bound on distance between objects.
+/// @param node collision node,
+/// @param b1, b2 ids of bounding volume nodes for object 1 and object 2
+/// @retval sqrDistLowerBound squared lower bound on distance between objects.
 void collisionRecurse(CollisionTraversalNodeBase* node, int b1, int b2,
 		      BVHFrontList* front_list, FCL_REAL& sqrDistLowerBound);
 
@@ -70,9 +71,10 @@ void propagateBVHFrontListCollisionRecurse
   (CollisionTraversalNodeBase* node, const CollisionRequest& request,
    CollisionResult& result, BVHFrontList* front_list);
 
-
 }
 
 } // namespace hpp
 
+/// @endcond
+
 #endif
diff --git a/test/obb.cpp b/test/obb.cpp
index 0536ef32acfbb399de9998170b38fb363c9a3c6d..fb4bd9a59cb40a5c9d4489a41c6ef0930f437b56 100644
--- a/test/obb.cpp
+++ b/test/obb.cpp
@@ -172,7 +172,7 @@ const Eigen::IOFormat py_fmt(Eigen::FullPrecision,
 
 namespace obbDisjoint_impls
 {
-  /// \return true if OBB are disjoint.
+  /// @return true if OBB are disjoint.
   bool distance (const Matrix3f& B, const Vec3f& T, const Vec3f& a, const Vec3f& b, FCL_REAL& distance)
   {
     GJKSolver gjk;