Doxygen norme doc

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

include/hpp/fcl/BV/OBB.h

@@ -64,12 +64,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 +141,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);
 }

include/hpp/fcl/BV/OBBRSS.h

@@ -72,7 +72,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 +154,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)

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:

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,

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)
   {

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,

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_)

include/hpp/fcl/shape/geometric_shapes.h

@@ -281,6 +281,7 @@ public:
 class ConvexBase : public ShapeBase
 {
 public:
+
   virtual ~ConvexBase();
 
   /// @brief Compute AABB 

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)

src/collision_node.h

@@ -54,18 +54,18 @@ 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);
+/// @internal collide, private function.
+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
+/// @internal distance, private function.
 void distance(DistanceTraversalNodeBase* node, BVHFrontList* front_list = NULL, int qsize = 2);
 }
 

src/distance_func_matrix.h

@@ -39,7 +39,9 @@
 
 namespace hpp
 {
-namespace fcl {
+namespace fcl
+{
+  /// @internal ShapeShapeDistance, private function.
   template<typename T_SH1, typename T_SH2>
     FCL_REAL ShapeShapeDistance
     (const CollisionGeometry* o1, const Transform3f& tf1,
@@ -47,6 +49,7 @@ namespace fcl {
      const GJKSolver* nsolver, const DistanceRequest& request,
      DistanceResult& result);
 
+  /// @internal ShapeShapeCollide, private function.
   template<typename T_SH1, typename T_SH2>
     std::size_t ShapeShapeCollide
     (const CollisionGeometry* o1, const Transform3f& tf1,

src/intersect.h

@@ -47,6 +47,7 @@ namespace fcl
 {
 
 /// @brief CCD intersect kernel among primitives
+/// @internal Intersect, private class.
 class Intersect
 {
 public:
@@ -55,6 +56,7 @@ public:
 }; // class Intersect
 
 /// @brief Project functions
+/// @internal Project, private class.
 class Project
 {
 public:
@@ -94,6 +96,7 @@ public:
 };
 
 /// @brief Triangle distance functions
+/// @internal TriangleDistance, private class.
 class TriangleDistance
 {
 public:
@@ -107,9 +110,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 +127,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 +141,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 +156,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 +172,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 +189,8 @@ public:
 
 };
 
-
 }
 
-
 } // namespace hpp
 
 #endif

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,

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};

src/traversal/traversal_node_base.h

@@ -106,8 +106,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;
 
@@ -143,8 +143,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

src/traversal/traversal_node_bvh_shape.h

@@ -179,8 +179,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
@@ -331,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++;
@@ -342,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
   {

src/traversal/traversal_node_bvhs.h

@@ -170,8 +170,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
   {/// @internal MeshCollisionTraversalNode, private class.
@@ -190,8 +190,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
@@ -199,7 +199,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

src/traversal/traversal_node_shapes.h

@@ -52,6 +52,7 @@ namespace fcl
 
 
 /// @brief Traversal node for collision between two shapes
+/// @internal ShapeCollisionTraversalNode, private class.
 template<typename S1, typename S2>
 class ShapeCollisionTraversalNode : public CollisionTraversalNodeBase
 {
@@ -114,6 +115,7 @@ public:
 };
 
 /// @brief Traversal node for distance between two shapes
+/// @internal ShapeDistanceTraversalNode, private class.
 template<typename S1, typename S2>
 class ShapeDistanceTraversalNode : public DistanceTraversalNodeBase
 {

src/traversal/traversal_recurse.cpp

@@ -221,17 +221,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
@@ -276,7 +276,7 @@ struct BVTQ
 
   std::priority_queue<BVT, std::vector<BVT>, BVT_Comparer> pq;
 
-  /** \brief Queue size */
+  /** @brief Queue size */
   unsigned int qsize;
 };