#ifndef DOXYGEN_AUTODOC_FUNCTIONS_H

#define DOXYGEN_AUTODOC_FUNCTIONS_H

#include "/root/robotpkg/path/py-hpp-fcl/work/hpp-fcl-2.4.1/doc/python/doxygen.hh"

#include <hpp/fcl/shape/geometric_shapes.h>

#include <hpp/fcl/narrowphase/gjk.h>

#include <hpp/fcl/serialization/memory.h>

#include <hpp/fcl/serialization/BVH_model.h>

#include <hpp/fcl/data_types.h>

#include <hpp/fcl/broadphase/detail/hierarchy_tree_array-inl.h>

#include <hpp/fcl/broadphase/detail/hierarchy_tree-inl.h>

#include <hpp/fcl/broadphase/broadphase_spatialhash.h>

#include <hpp/fcl/math/transform.h>

#include <hpp/fcl/hfield.h>

#include <hpp/fcl/serialization/AABB.h>

#include <hpp/fcl/serialization/BV_node.h>

#include <hpp/fcl/serialization/BV_splitter.h>

#include <hpp/fcl/serialization/collision_data.h>

#include <hpp/fcl/serialization/collision_object.h>

#include <hpp/fcl/serialization/convex.h>

#include <hpp/fcl/serialization/eigen.h>

#include <hpp/fcl/serialization/geometric_shapes.h>

#include <hpp/fcl/serialization/hfield.h>

#include <hpp/fcl/serialization/OBB.h>

#include <hpp/fcl/serialization/OBBRSS.h>

#include <hpp/fcl/serialization/quadrilateral.h>

#include <hpp/fcl/serialization/RSS.h>

#include <hpp/fcl/serialization/triangle.h>

#include <hpp/fcl/internal/traversal_node_setup.h>

#include <hpp/fcl/broadphase/default_broadphase_callbacks.h>

#include <hpp/fcl/BV/AABB.h>

#include <hpp/fcl/BV/BV.h>

#include <hpp/fcl/BV/kDOP.h>

#include <hpp/fcl/BV/kIOS.h>

#include <hpp/fcl/BV/OBB.h>

#include <hpp/fcl/BV/OBBRSS.h>

#include <hpp/fcl/BV/RSS.h>

#include <hpp/fcl/BVH/BVH_front.h>

#include <hpp/fcl/BVH/BVH_utility.h>

#include <hpp/fcl/collision.h>

#include <hpp/fcl/collision_data.h>

#include <hpp/fcl/collision_utility.h>

#include <hpp/fcl/distance.h>

#include <hpp/fcl/internal/BV_fitter.h>

#include <hpp/fcl/internal/tools.h>

#include <hpp/fcl/mesh_loader/assimp.h>

#include <hpp/fcl/octree.h>

#include <hpp/fcl/shape/geometric_shape_to_BVH_model.h>

#include <hpp/fcl/shape/geometric_shapes_utility.h>

#include <BV/OBB.h>

#include <narrowphase/details.h>

namespace doxygen {

{

    return "Build a convex hull based on Qhull library and store the vertices and optionally the triangles. \n"

"\n"

"\n"

"Param\n"

"  - points, num_points the points whose convex hull should be computed. \n"

"  - keepTriangles if true, returns a Convex<Triangle> object which contains the triangle of the shape. \n"

"  - qhullCommand the command sent to qhull.\n"

"- if keepTriangles is true, this parameter should include \"Qt\". If NULL, \"Qt\" is passed to Qhull.\n"

"- if keepTriangles is false, an empty string is passed to Qhull. \n"

"\n"

"\n"

"\n"

}

template <typename HashTable>

inline const char* member_func_doc (void (*function_ptr) (std::vector< hpp::fcl::CollisionObject * > &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast<void (*) (std::vector< hpp::fcl::CollisionObject * > &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &)>(&hpp::fcl::SpatialHashingCollisionManager <HashTable >::computeBound))

    return "compute the bound for the environent ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) ( hpp::fcl::CollisionObject *,  hpp::fcl::CollisionObject *, void *))

{

  if (function_ptr == static_cast<bool (*) ( hpp::fcl::CollisionObject *,  hpp::fcl::CollisionObject *, void *)>(&hpp::fcl::defaultCollisionFunction))

    return "Provides a simple callback for the collision query in the hpp::fcl::BroadPhaseCollisionManager. It assumes the data parameter is non-null and points to an instance of hpp::fcl::CollisionData. It simply invokes the collide() method on the culled pair of geometries and stores the results in the data's hpp::fcl::CollisionResult instance. \n"

"\n"

"This callback will cause the broadphase evaluation to stop if:\n"

"- the collision requests *disables* cost *and*\n"

"- the collide() reports a collision for the culled pair, *and*\n"

"- we've reported the number of contacts requested in the hpp::fcl::CollisionRequest.\n"

"\n"

"\n"

"For a given instance of hpp::fcl::CollisionData, if broadphase evaluation has already terminated (i.e., defaultCollisionFunction() returned true), subsequent invocations with the same instance of hpp::fcl::CollisionData will return immediately, requesting termination of broadphase evaluation (i.e., return true).\n"

"\n"

"Param\n"

"  - o1 The first object in the culled pair. \n"

"  - o2 The second object in the culled pair. \n"

"  - data A non-null pointer to a hpp::fcl::CollisionData instance. \n"

"\n"

"Return: true if the broadphase evaluation should stop. \n"

"\n"

"\n"

"Templateparam\n"

"  - S The scalar type with which the computation will be performed. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) ( hpp::fcl::CollisionObject *,  hpp::fcl::CollisionObject *, void *,  hpp::fcl::FCL_REAL &))

{

  if (function_ptr == static_cast<bool (*) ( hpp::fcl::CollisionObject *,  hpp::fcl::CollisionObject *, void *,  hpp::fcl::FCL_REAL &)>(&hpp::fcl::defaultDistanceFunction))

    return "Collision data for use with the DefaultContinuousCollisionFunction. It stores the collision request and the result given by the collision algorithm (and stores the conclusion of whether further evaluation of the broadphase collision manager has been deemed unnecessary). \n"

"\n"

"Provides a simple callback for the continuous collision query in the hpp::fcl::BroadPhaseCollisionManager. It assumes the data parameter is non-null and points to an instance of DefaultContinuousCollisionData. It simply invokes the collide() method on the culled pair of geometries and stores the results in the data's ContinuousCollisionResult instance.\n"

"This callback will never cause the broadphase evaluation to terminate early. However, if the done member of the DefaultContinuousCollisionData is set to true, this method will simply return without doing any computation.\n"

"For a given instance of DefaultContinuousCollisionData, if broadphase evaluation has already terminated (i.e., DefaultContinuousCollisionFunction() returned true), subsequent invocations with the same instance of hpp::fcl::CollisionData will return immediately, requesting termination of broadphase evaluation (i.e., return true).\n"

"\n"

"Param\n"

"  - o1 The first object in the culled pair. \n"

"  - o2 The second object in the culled pair. \n"

"  - data A non-null pointer to a hpp::fcl::CollisionData instance. \n"

"\n"

"Return: True if the broadphase evaluation should stop. \n"

"\n"

"\n"

"Templateparam\n"

"  - S The scalar type with which the computation will be performed.\n"

"\n"

"Provides a simple callback for the distance query in the hpp::fcl::BroadPhaseCollisionManager. It assumes the data parameter is non-null and points to an instance of hpp::fcl::DistanceData. It simply invokes the distance() method on the culled pair of geometries and stores the results in the data's hpp::fcl::DistanceResult instance.\n"

"This callback will cause the broadphase evaluation to stop if:\n"

"- The distance is less than or equal to zero (i.e., the pair is in contact).\n"

"\n"

"\n"

"For a given instance of hpp::fcl::DistanceData, if broadphase evaluation has already terminated (i.e., defaultDistanceFunction() returned true), subsequent invocations with the same instance of hpp::fcl::DistanceData will simply report the previously reported minimum distance and request termination of broadphase evaluation (i.e., return true).\n"

"\n"

"Param\n"

"  - o1 The first object in the culled pair. \n"

"  - o2 The second object in the culled pair. \n"

"  - data A non-null pointer to a hpp::fcl::DistanceData instance. \n"

"  - dist The distance computed by distance(). \n"

"\n"

"Return: true if the broadphase evaluation should stop. \n"

"\n"

"\n"

"Templateparam\n"

"  - S The scalar type with which the computation will be performed. ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::AABB (*function_ptr) (const hpp::fcl::AABB &, const hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast< hpp::fcl::AABB (*) (const hpp::fcl::AABB &, const hpp::fcl::Vec3f &)>(&hpp::fcl::translate))

    return "translate the center of hpp::fcl::AABB by t ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::AABB &, const hpp::fcl::AABB &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::AABB &, const hpp::fcl::AABB &)>(&hpp::fcl::overlap))

    return "Check collision between two aabbs, b1 is in configuration (R0, T0) and b2 is in identity. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::AABB &, const hpp::fcl::AABB &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::AABB &, const hpp::fcl::AABB &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &)>(&hpp::fcl::overlap))

    return "Check collision between two aabbs, b1 is in configuration (R0, T0) and b2 is in identity. ";

  return "";

}

template <typename BV1, typename BV2>

inline const char* member_func_doc (void (*function_ptr) (const BV1 &, const hpp::fcl::Transform3f &, BV2 &))

{

  if (function_ptr == static_cast<void (*) (const BV1 &, const hpp::fcl::Transform3f &, BV2 &)>(&hpp::fcl::convertBV))

    return "Convert a bounding volume of type BV1 in configuration tf1 to bounding volume of type BV2 in identity configuration. ";

  return "";

}

template <typename BV1, typename BV2>

inline const char* member_func_doc (void (*function_ptr) (const BV1 &, BV2 &))

{

  if (function_ptr == static_cast<void (*) (const BV1 &, BV2 &)>(&hpp::fcl::convertBV))

    return "Convert a bounding volume of type BV1 to bounding volume of type BV2 in identity configuration. ";

  return "";

}

template <short N>

inline const char* member_func_doc ( hpp::fcl::KDOP < N > (*function_ptr) (const hpp::fcl::KDOP < N > &, const hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast< hpp::fcl::KDOP < N > (*) (const hpp::fcl::KDOP < N > &, const hpp::fcl::Vec3f &)>(&hpp::fcl::translate))

    return "translate the hpp::fcl::KDOP BV ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::kIOS (*function_ptr) (const hpp::fcl::kIOS &, const hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast< hpp::fcl::kIOS (*) (const hpp::fcl::kIOS &, const hpp::fcl::Vec3f &)>(&hpp::fcl::translate))

    return "Translate the hpp::fcl::kIOS BV. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::kIOS &, const hpp::fcl::kIOS &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::kIOS &, const hpp::fcl::kIOS &)>(&hpp::fcl::overlap))

    return "Check collision between two kIOSs, b1 is in configuration (R0, T0) and b2 is in identity. \n"

"\n"

"TodoNot efficient ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::kIOS &, const hpp::fcl::kIOS &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::kIOS &, const hpp::fcl::kIOS &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &)>(&hpp::fcl::overlap))

    return "Check collision between two kIOSs, b1 is in configuration (R0, T0) and b2 is in identity. \n"

"\n"

"TodoNot efficient ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::FCL_REAL (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::kIOS &, const hpp::fcl::kIOS &,  hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *))

{

  if (function_ptr == static_cast< hpp::fcl::FCL_REAL (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::kIOS &, const hpp::fcl::kIOS &,  hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *)>(&hpp::fcl::distance))

    return "Approximate distance between two hpp::fcl::kIOS bounding volumes. \n"

"\n"

"TodoP and Q is not returned, need implementation ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::OBB (*function_ptr) (const hpp::fcl::OBB &, const hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast< hpp::fcl::OBB (*) (const hpp::fcl::OBB &, const hpp::fcl::Vec3f &)>(&hpp::fcl::translate))

    return "Translate the hpp::fcl::OBB bv. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBB &, const hpp::fcl::OBB &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBB &, const hpp::fcl::OBB &)>(&hpp::fcl::overlap))

    return "Check collision between two obbs, b1 is in configuration (R0, T0) and b2 is in identity. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBB &, const hpp::fcl::OBB &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBB &, const hpp::fcl::OBB &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &)>(&hpp::fcl::overlap))

    return "Check collision between two obbs, b1 is in configuration (R0, T0) and b2 is in identity. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &)>(&hpp::fcl::obbDisjoint))

    return "Check collision between two boxes \n"

"Param\n"

"  - B, T orientation and position of first box, \n"

"  - a half dimensions of first box, \n"

"  - b half dimensions of second box. The second box is in identity configuration. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBBRSS &, const hpp::fcl::OBBRSS &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBBRSS &, const hpp::fcl::OBBRSS &)>(&hpp::fcl::overlap))

    return "Check collision between two hpp::fcl::OBBRSS, b1 is in configuration (R0, T0) and b2 is in indentity. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBBRSS &, const hpp::fcl::OBBRSS &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBBRSS &, const hpp::fcl::OBBRSS &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &)>(&hpp::fcl::overlap))

    return "Check collision between two hpp::fcl::OBBRSS \n"

"Param\n"

"  - R0, T0 configuration of b1 \n"

"  - b1 first hpp::fcl::OBBRSS in configuration (R0, T0) \n"

"  - b2 second hpp::fcl::OBBRSS in identity position \n"

"\n"

"\n"

"Retval\n"

"  - sqrDistLowerBound squared lower bound on the distance if hpp::fcl::OBBRSS do not overlap. ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::FCL_REAL (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBBRSS &, const hpp::fcl::OBBRSS &,  hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *))

{

  if (function_ptr == static_cast< hpp::fcl::FCL_REAL (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::OBBRSS &, const hpp::fcl::OBBRSS &,  hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *)>(&hpp::fcl::distance))

    return "Computate distance between two hpp::fcl::OBBRSS, b1 is in configuation (R0, T0) and b2 is in indentity; P and Q, is not NULL, returns the nearest points. ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::FCL_REAL (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::RSS &, const hpp::fcl::RSS &,  hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *))

{

  if (function_ptr == static_cast< hpp::fcl::FCL_REAL (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::RSS &, const hpp::fcl::RSS &,  hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *)>(&hpp::fcl::distance))

    return "distance between two hpp::fcl::RSS bounding volumes P and Q (optional return values) are the closest points in the rectangles, not the hpp::fcl::RSS. But the direction P - Q is the correct direction for cloest points Notice that P and Q are both in the local frame of the first hpp::fcl::RSS (not global frame and not even the local frame of object 1) ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::RSS &, const hpp::fcl::RSS &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::RSS &, const hpp::fcl::RSS &)>(&hpp::fcl::overlap))

    return "Check collision between two RSSs, b1 is in configuration (R0, T0) and b2 is in identity. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::RSS &, const hpp::fcl::RSS &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Matrix3f &, const hpp::fcl::Vec3f &, const hpp::fcl::RSS &, const hpp::fcl::RSS &, const hpp::fcl::CollisionRequest &,  hpp::fcl::FCL_REAL &)>(&hpp::fcl::overlap))

    return "Check collision between two RSSs, b1 is in configuration (R0, T0) and b2 is in identity. ";

  return "";

}

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::BVHFrontList *, unsigned int, unsigned int))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::BVHFrontList *, unsigned int, unsigned int)>(&hpp::fcl::updateFrontList))

    return "Add new front node into the front list. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc ( hpp::fcl::BVHModel < BV > * (*function_ptr) (const hpp::fcl::BVHModel < BV > &, const hpp::fcl::Transform3f &, const hpp::fcl::AABB &))

{

  if (function_ptr == static_cast< hpp::fcl::BVHModel < BV > * (*) (const hpp::fcl::BVHModel < BV > &, const hpp::fcl::Transform3f &, const hpp::fcl::AABB &)>(&hpp::fcl::BVHExtract))

    return "Extract the part of the hpp::fcl::BVHModel that is inside an hpp::fcl::AABB. A triangle in collision with the hpp::fcl::AABB is considered inside. ";

  return "";

}

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *,  hpp::fcl::Triangle *, unsigned int *, unsigned int,  hpp::fcl::Matrix3f &))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *,  hpp::fcl::Triangle *, unsigned int *, unsigned int,  hpp::fcl::Matrix3f &)>(&hpp::fcl::getCovariance))

    return "Compute the covariance matrix for a set or subset of points. if ts = null, then indices refer to points directly; otherwise refer to triangles. ";

  return "";

}

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *,  hpp::fcl::Triangle *, unsigned int *, unsigned int, const hpp::fcl::Matrix3f &,  hpp::fcl::Vec3f &,  hpp::fcl::FCL_REAL[2],  hpp::fcl::FCL_REAL &))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *,  hpp::fcl::Triangle *, unsigned int *, unsigned int, const hpp::fcl::Matrix3f &,  hpp::fcl::Vec3f &,  hpp::fcl::FCL_REAL[2],  hpp::fcl::FCL_REAL &)>(&hpp::fcl::getRadiusAndOriginAndRectangleSize))

    return "Compute the hpp::fcl::RSS bounding volume parameters: radius, rectangle size and the origin, given the BV axises. ";

  return "";

}

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *,  hpp::fcl::Triangle *, unsigned int *, unsigned int,  hpp::fcl::Matrix3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *,  hpp::fcl::Triangle *, unsigned int *, unsigned int,  hpp::fcl::Matrix3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &)>(&hpp::fcl::getExtentAndCenter))

    return "Compute the bounding volume extent and center for a set or subset of points, given the BV axises. ";

  return "";

}

inline const char* member_func_doc (void (*function_ptr) (const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::FCL_REAL &))

{

  if (function_ptr == static_cast<void (*) (const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::FCL_REAL &)>(&hpp::fcl::circumCircleComputation))

    return "Compute the center and radius for a triangle's circumcircle. ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::FCL_REAL (*function_ptr) ( hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *,  hpp::fcl::Triangle *, unsigned int *, unsigned int, const hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast< hpp::fcl::FCL_REAL (*) ( hpp::fcl::Vec3f *,  hpp::fcl::Vec3f *,  hpp::fcl::Triangle *, unsigned int *, unsigned int, const hpp::fcl::Vec3f &)>(&hpp::fcl::maximumDistance))

    return "Compute the maximum distance from a given center point to a point cloud. ";

  return "";

}

inline const char* member_func_doc (std::size_t (*function_ptr) (const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionRequest &,  hpp::fcl::CollisionResult &))

{

  if (function_ptr == static_cast<std::size_t (*) (const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionRequest &,  hpp::fcl::CollisionResult &)>(&hpp::fcl::collide))

    return "Main collision interface: given two collision objects, and the requirements for contacts, including num of max contacts, whether perform exhaustive collision (i.e., returning returning all the contact points), whether return detailed contact information (i.e., normal, contact point, depth; otherwise only contact primitive id is returned), this function performs the collision between them. Return value is the number of contacts generated between the two objects. ";

  return "";

}

inline const char* member_func_doc (std::size_t (*function_ptr) (const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionObject *,  hpp::fcl::CollisionRequest &,  hpp::fcl::CollisionResult &))

{

  if (function_ptr == static_cast<std::size_t (*) (const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionObject *,  hpp::fcl::CollisionRequest &,  hpp::fcl::CollisionResult &)>(&hpp::fcl::collide))

    return "Note: this function update the initial guess of request if requested. See QueryRequest::updateGuess ";

  return "";

}

inline const char* member_func_doc (std::size_t (*function_ptr) (const hpp::fcl::CollisionGeometry *, const hpp::fcl::Transform3f &, const hpp::fcl::CollisionGeometry *, const hpp::fcl::Transform3f &,  hpp::fcl::CollisionRequest &,  hpp::fcl::CollisionResult &))

{

  if (function_ptr == static_cast<std::size_t (*) (const hpp::fcl::CollisionGeometry *, const hpp::fcl::Transform3f &, const hpp::fcl::CollisionGeometry *, const hpp::fcl::Transform3f &,  hpp::fcl::CollisionRequest &,  hpp::fcl::CollisionResult &)>(&hpp::fcl::collide))

    return "Note: this function update the initial guess of request if requested. See QueryRequest::updateGuess ";

  return "";

}

inline const char* member_func_doc (const char * (*function_ptr) ( hpp::fcl::NODE_TYPE))

{

  if (function_ptr == static_cast<const char * (*) ( hpp::fcl::NODE_TYPE)>(&hpp::fcl::get_node_type_name))

    return "Returns the name associated to a NODE_TYPE. ";

  return "";

}

inline const char* member_func_doc (const char * (*function_ptr) ( hpp::fcl::OBJECT_TYPE))

{

  if (function_ptr == static_cast<const char * (*) ( hpp::fcl::OBJECT_TYPE)>(&hpp::fcl::get_object_type_name))

    return "Returns the name associated to a OBJECT_TYPE. ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::FCL_REAL (*function_ptr) (const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionObject *, const hpp::fcl::DistanceRequest &,  hpp::fcl::DistanceResult &))

{

  if (function_ptr == static_cast< hpp::fcl::FCL_REAL (*) (const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionObject *, const hpp::fcl::DistanceRequest &,  hpp::fcl::DistanceResult &)>(&hpp::fcl::distance))

    return "Main distance interface: given two collision objects, and the requirements for contacts, including whether return the nearest points, this function performs the distance between them. Return value is the minimum distance generated between the two objects. ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::FCL_REAL (*function_ptr) (const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionObject *,  hpp::fcl::DistanceRequest &,  hpp::fcl::DistanceResult &))

{

  if (function_ptr == static_cast< hpp::fcl::FCL_REAL (*) (const hpp::fcl::CollisionObject *, const hpp::fcl::CollisionObject *,  hpp::fcl::DistanceRequest &,  hpp::fcl::DistanceResult &)>(&hpp::fcl::distance))

    return "Note: this function update the initial guess of request if requested. See QueryRequest::updateGuess ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::FCL_REAL (*function_ptr) (const hpp::fcl::CollisionGeometry *, const hpp::fcl::Transform3f &, const hpp::fcl::CollisionGeometry *, const hpp::fcl::Transform3f &,  hpp::fcl::DistanceRequest &,  hpp::fcl::DistanceResult &))

{

  if (function_ptr == static_cast< hpp::fcl::FCL_REAL (*) (const hpp::fcl::CollisionGeometry *, const hpp::fcl::Transform3f &, const hpp::fcl::CollisionGeometry *, const hpp::fcl::Transform3f &,  hpp::fcl::DistanceRequest &,  hpp::fcl::DistanceResult &)>(&hpp::fcl::distance))

    return "Note: this function update the initial guess of request if requested. See QueryRequest::updateGuess ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::Vec3f *, unsigned int, BV &))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::Vec3f *, unsigned int, BV &)>(&hpp::fcl::fit))

    return "Compute a bounding volume that fits a set of n points. ";

  return "";

}

template <typename Derived, typename Vector>

inline const char* member_func_doc (void (*function_ptr) (const Eigen::MatrixBase< Derived > &, typename Derived::Scalar[3], Vector *))

{

  if (function_ptr == static_cast<void (*) (const Eigen::MatrixBase< Derived > &, typename Derived::Scalar[3], Vector *)>(&hpp::fcl::eigen))

    return "compute the eigen vector and eigen vector of a matrix. dout is the eigen values, vout is the eigen vectors ";

  return "";

}

template <class BoundingVolume>

inline const char* member_func_doc (void (*function_ptr) (const std::string &, const hpp::fcl::Vec3f &, const shared_ptr< hpp::fcl::BVHModel < BoundingVolume > > &))

{

  if (function_ptr == static_cast<void (*) (const std::string &, const hpp::fcl::Vec3f &, const shared_ptr< hpp::fcl::BVHModel < BoundingVolume > > &)>(&hpp::fcl::loadPolyhedronFromResource))

    return "Read a mesh file and convert it to a polyhedral mesh. \n"

"\n"

"\n"

"Param\n"

"  - resource_path Path to the ressource mesh file to be read \n"

"  - scale Scale to apply when reading the ressource \n"

"  - polyhedron The resulted polyhedron ";

  return "";

}

inline const char* member_func_doc (void (*function_ptr) (const hpp::fcl::AABB &, unsigned int,  hpp::fcl::AABB &))

{

  if (function_ptr == static_cast<void (*) (const hpp::fcl::AABB &, unsigned int,  hpp::fcl::AABB &)>(&hpp::fcl::computeChildBV))

    return "compute the bounding volume of an octree node's i-th child ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::OcTreePtr_t (*function_ptr) (const Eigen::Matrix< hpp::fcl::FCL_REAL , Eigen::Dynamic, 3 > &, const hpp::fcl::FCL_REAL))

{

  if (function_ptr == static_cast< hpp::fcl::OcTreePtr_t (*) (const Eigen::Matrix< hpp::fcl::FCL_REAL , Eigen::Dynamic, 3 > &, const hpp::fcl::FCL_REAL)>(&hpp::fcl::makeOctree))

    return "Build an hpp::fcl::OcTree from a point cloud and a given resolution. \n"

"\n"

"\n"

"Param\n"

"  - point_cloud The input points to insert in the hpp::fcl::OcTree \n"

"  - resolution of the octree.\n"

"\n"

"Return: An hpp::fcl::OcTree that can be used for collision checking and more. ";

  return "";

}

template <typename T>

inline const char* member_func_doc (size_t (*function_ptr) (const T &))

{

  if (function_ptr == static_cast<size_t (*) (const T &)>(&hpp::fcl::computeMemoryFootprint))

    return "Returns the memory footpring of the input object. For POD objects, this function returns the result of sizeof(T) \n"

"\n"

"\n"

"Param\n"

"  - object whose memory footprint needs to be evaluated.\n"

"\n"

"Return: the memory footprint of the input object. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Box &, const hpp::fcl::Transform3f &))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Box &, const hpp::fcl::Transform3f &)>(&hpp::fcl::generateBVHModel))

    return "Generate BVH model from box. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Sphere &, const hpp::fcl::Transform3f &, unsigned int, unsigned int))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Sphere &, const hpp::fcl::Transform3f &, unsigned int, unsigned int)>(&hpp::fcl::generateBVHModel))

    return "Generate BVH model from sphere, given the number of segments along longitude and number of rings along latitude. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Sphere &, const hpp::fcl::Transform3f &, unsigned int))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Sphere &, const hpp::fcl::Transform3f &, unsigned int)>(&hpp::fcl::generateBVHModel))

    return "Generate BVH model from sphere The difference between generateBVHModel is that it gives the number of triangles faces N for a sphere with unit radius. For sphere of radius r, then the number of triangles is r * r * N so that the area represented by a single triangle is approximately the same.s. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Cylinder &, const hpp::fcl::Transform3f &, unsigned int, unsigned int))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Cylinder &, const hpp::fcl::Transform3f &, unsigned int, unsigned int)>(&hpp::fcl::generateBVHModel))

    return "Generate BVH model from cylinder, given the number of segments along circle and the number of segments along axis. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Cylinder &, const hpp::fcl::Transform3f &, unsigned int))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Cylinder &, const hpp::fcl::Transform3f &, unsigned int)>(&hpp::fcl::generateBVHModel))

    return "Generate BVH model from cylinder Difference from generateBVHModel: is that it gives the circle split number tot for a cylinder with unit radius. For cylinder with larger radius, the number of circle split number is r * tot. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Cone &, const hpp::fcl::Transform3f &, unsigned int, unsigned int))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Cone &, const hpp::fcl::Transform3f &, unsigned int, unsigned int)>(&hpp::fcl::generateBVHModel))

    return "Generate BVH model from cone, given the number of segments along circle and the number of segments along axis. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (void (*function_ptr) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Cone &, const hpp::fcl::Transform3f &, unsigned int))

{

  if (function_ptr == static_cast<void (*) ( hpp::fcl::BVHModel < BV > &, const hpp::fcl::Cone &, const hpp::fcl::Transform3f &, unsigned int)>(&hpp::fcl::generateBVHModel))

    return "Generate BVH model from cone Difference from generateBVHModel: is that it gives the circle split number tot for a cylinder with unit radius. For cone with larger radius, the number of circle split number is r * tot. ";

  return "";

}

template <typename BV, typename S>

inline const char* member_func_doc (void (*function_ptr) (const S &, const hpp::fcl::Transform3f &, BV &))

{

  if (function_ptr == static_cast<void (*) (const S &, const hpp::fcl::Transform3f &, BV &)>(&hpp::fcl::computeBV))

    return "calculate a bounding volume for a shape in a specific configuration ";

  return "";

}

inline const char* member_func_doc (void (*function_ptr) (const hpp::fcl::AABB &,  hpp::fcl::Box &,  hpp::fcl::Transform3f &))

{

  if (function_ptr == static_cast<void (*) (const hpp::fcl::AABB &,  hpp::fcl::Box &,  hpp::fcl::Transform3f &)>(&hpp::fcl::constructBox))

    return "construct a box shape (with a configuration) from a given bounding volume ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (bool (*function_ptr) ( hpp::fcl::detail::NodeBase < BV > *,  hpp::fcl::detail::NodeBase < BV > *, int))

{

  if (function_ptr == static_cast<bool (*) ( hpp::fcl::detail::NodeBase < BV > *,  hpp::fcl::detail::NodeBase < BV > *, int)>(&hpp::fcl::detail::nodeBaseLess))

    return "Compare two nodes accoording to the d-th dimension of node center. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (size_t (*function_ptr) (const hpp::fcl::detail::NodeBase < BV > &, const hpp::fcl::detail::NodeBase < BV > &, const hpp::fcl::detail::NodeBase < BV > &))

{

  if (function_ptr == static_cast<size_t (*) (const hpp::fcl::detail::NodeBase < BV > &, const hpp::fcl::detail::NodeBase < BV > &, const hpp::fcl::detail::NodeBase < BV > &)>(&hpp::fcl::detail::select))

    return "select from node1 and node2 which is close to a given query. 0 for node1 and 1 for node2 ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (size_t (*function_ptr) (const BV &, const hpp::fcl::detail::NodeBase < BV > &, const hpp::fcl::detail::NodeBase < BV > &))

{

  if (function_ptr == static_cast<size_t (*) (const BV &, const hpp::fcl::detail::NodeBase < BV > &, const hpp::fcl::detail::NodeBase < BV > &)>(&hpp::fcl::detail::select))

    return "select from node1 and node2 which is close to a given query bounding volume. 0 for node1 and 1 for node2 ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (size_t (*function_ptr) (size_t, size_t, size_t,  hpp::fcl::detail::implementation_array::NodeBase < BV > *))

{

  if (function_ptr == static_cast<size_t (*) (size_t, size_t, size_t,  hpp::fcl::detail::implementation_array::NodeBase < BV > *)>(&hpp::fcl::detail::implementation_array::select))

    return "select the node from node1 and node2 which is close to the query-th node in the nodes. 0 for node1 and 1 for node2. ";

  return "";

}

template <typename BV>

inline const char* member_func_doc (size_t (*function_ptr) (const BV &, size_t, size_t,  hpp::fcl::detail::implementation_array::NodeBase < BV > *))

{

  if (function_ptr == static_cast<size_t (*) (const BV &, size_t, size_t,  hpp::fcl::detail::implementation_array::NodeBase < BV > *)>(&hpp::fcl::detail::implementation_array::select))

    return "select the node from node1 and node2 which is close to the query hpp::fcl::AABB. 0 for node1 and 1 for node2. ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::Vec3f (*function_ptr) (const hpp::fcl::ShapeBase *, const hpp::fcl::Vec3f &, bool, int &))

{

  if (function_ptr == static_cast< hpp::fcl::Vec3f (*) (const hpp::fcl::ShapeBase *, const hpp::fcl::Vec3f &, bool, int &)>(&hpp::fcl::details::getSupport))

    return "the support function for shape \n"

"\n"

"\n"

"Param\n"

"  - hint use to initialize the search when shape is a hpp::fcl::ConvexBase object. ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::FCL_REAL (*function_ptr) (const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast< hpp::fcl::FCL_REAL (*) (const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &)>(&hpp::fcl::details::segmentSqrDistance))

    return "the minimum distance from a point to a line ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &)>(&hpp::fcl::details::projectInTriangle))

    return "Whether a point's projection is in a triangle. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Box &, const hpp::fcl::Transform3f &, const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Box &, const hpp::fcl::Transform3f &, const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &)>(&hpp::fcl::details::boxHalfspaceIntersect))

    return "box half space, a, b, c = +/- edge size n^T * (R(o + a v1 + b v2 + c v3) + T) <= d so (R^T n) (a v1 + b v2 + c v3) + n * T <= d check whether d - n * T - (R^T n) (a v1 + b v2 + c v3) >= 0 for some a, b, c the max value of left side is d - n * T + |(R^T n) (a v1 + b v2 + c v3)|, check that is enough ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Plane &, const hpp::fcl::Transform3f &, const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &,  hpp::fcl::Plane &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::FCL_REAL &, int &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Plane &, const hpp::fcl::Transform3f &, const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &,  hpp::fcl::Plane &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::FCL_REAL &, int &)>(&hpp::fcl::details::planeHalfspaceIntersect))

    return "return whether plane collides with halfspace if the separation plane of the halfspace is parallel with the plane return code 1, if the plane's normal is the same with halfspace's normal and plane is inside halfspace, also return plane in pl return code 2, if the plane's normal is oppositie to the halfspace's normal and plane is inside halfspace, also return plane in pl plane is outside halfspace, collision-free if not parallel return the intersection ray, return code 3. ray origin is p and direction is d ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &, const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Halfspace &,  hpp::fcl::FCL_REAL &, int &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &, const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Halfspace &,  hpp::fcl::FCL_REAL &, int &)>(&hpp::fcl::details::halfspaceIntersect))

    return "@ brief return whether two halfspace intersect if the separation planes of the two halfspaces are parallel return code 1, if two halfspaces' normal are same and s1 is in s2, also return s1 in s; return code 2, if two halfspaces' normal are same and s2 is in s1, also return s2 in s; return code 3, if two halfspaces' normal are opposite and s1 and s2 are into each other; collision free, if two halfspaces' are separate; if the separation planes of the two halfspaces are not parallel, return intersection ray, return code 4. ray origin is p and direction is d collision free return code 0 ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &, const hpp::fcl::ShapeBase &, const hpp::fcl::Transform3f &,  hpp::fcl::FCL_REAL &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Halfspace &, const hpp::fcl::Transform3f &, const hpp::fcl::ShapeBase &, const hpp::fcl::Transform3f &,  hpp::fcl::FCL_REAL &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &)>(&hpp::fcl::details::halfspaceDistance))

    return "Param\n"

"  - p1 closest (or most penetrating) point on the hpp::fcl::Halfspace, \n"

"  - p2 closest (or most penetrating) point on the shape, \n"

"  - normal the halfspace normal. \n"

"\n"

"Return: true if the distance is negative (the shape overlaps). ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Box &, const hpp::fcl::Transform3f &, const hpp::fcl::Plane &, const hpp::fcl::Transform3f &,  hpp::fcl::FCL_REAL &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Box &, const hpp::fcl::Transform3f &, const hpp::fcl::Plane &, const hpp::fcl::Transform3f &,  hpp::fcl::FCL_REAL &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &)>(&hpp::fcl::details::boxPlaneIntersect))

    return "box half space, a, b, c = +/- edge size n^T * (R(o + a v1 + b v2 + c v3) + T) ~ d so (R^T n) (a v1 + b v2 + c v3) + n * T ~ d check whether d - n * T - (R^T n) (a v1 + b v2 + c v3) >= 0 for some a, b, c and <=0 for some a, b, c so need to check whether |d - n * T| <= |(R^T n)(a v1 + b v2 + c v3)|, the reason is as follows: (R^T n) (a v1 + b v2 + c v3) can get |(R^T n) (a v1 + b v2 + c v3)| for one a, b, c. if |d - n * T| <= |(R^T n)(a v1 + b v2 + c v3)| then can get both positive and negative value on the right side. ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Box &, const hpp::fcl::Transform3f &, const hpp::fcl::Sphere &, const hpp::fcl::Transform3f &,  hpp::fcl::FCL_REAL &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Box &, const hpp::fcl::Transform3f &, const hpp::fcl::Sphere &, const hpp::fcl::Transform3f &,  hpp::fcl::FCL_REAL &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &)>(&hpp::fcl::details::boxSphereDistance))

    return "Taken from book Real Time Collision Detection, from Christer Ericson \n"

"Param\n"

"  - pb the closest point to the sphere center on the box surface \n"

"  - ps when colliding, matches pb, which is inside the sphere. when not colliding, the closest point on the sphere \n"

"  - normal direction of motion of the box \n"

"\n"

"Return: true if the distance is negative (the shape overlaps). ";

  return "";

}

inline const char* member_func_doc (bool (*function_ptr) (const hpp::fcl::Cylinder &, const hpp::fcl::Transform3f &, const hpp::fcl::Plane &, const hpp::fcl::Transform3f &,  hpp::fcl::FCL_REAL &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast<bool (*) (const hpp::fcl::Cylinder &, const hpp::fcl::Transform3f &, const hpp::fcl::Plane &, const hpp::fcl::Transform3f &,  hpp::fcl::FCL_REAL &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &)>(&hpp::fcl::details::cylinderPlaneIntersect))

    return "cylinder-plane intersect n^T (R (r * cosa * v1 + r * sina * v2 + h * v3) + T) ~ d need one point to be positive and one to be negative (n^T * v3) * h + n * T -d + r * (cosa * (n^T * R * v1) + sina * (n^T * R * v2)) ~ 0 (n^T * v3) * h + r * (cosa * (n^T * R * v1) + sina * (n^T * R * v2)) + n * T - d ~ 0 ";

  return "";

}

inline const char* member_func_doc ( hpp::fcl::FCL_REAL (*function_ptr) (const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &))

{

  if (function_ptr == static_cast< hpp::fcl::FCL_REAL (*) (const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &,  hpp::fcl::Vec3f &)>(&hpp::fcl::details::computePenetration))

    return "See the prototype below. ";

  return "";

}

inline const char* member_func_doc (void (*function_ptr) (const hpp::fcl::Vec3f &, const aiScene *, unsigned,  hpp::fcl::internal::TriangleAndVertices &))

{

  if (function_ptr == static_cast<void (*) (const hpp::fcl::Vec3f &, const aiScene *, unsigned,  hpp::fcl::internal::TriangleAndVertices &)>(&hpp::fcl::internal::buildMesh))

    return "Recursive procedure for building a mesh. \n"

"\n"

"\n"

"Param\n"

"  - scale Scale to apply when reading the ressource \n"

"  - scene Pointer to the assimp scene \n"

"  - vertices_offset Current number of vertices in the model \n"

"  - tv Triangles and Vertices of the mesh submodels ";

  return "";

}

template <class BoundingVolume>

inline const char* member_func_doc (void (*function_ptr) (const hpp::fcl::Vec3f &, const aiScene *, const shared_ptr< hpp::fcl::BVHModel < BoundingVolume > > &))

{

  if (function_ptr == static_cast<void (*) (const hpp::fcl::Vec3f &, const aiScene *, const shared_ptr< hpp::fcl::BVHModel < BoundingVolume > > &)>(&hpp::fcl::internal::meshFromAssimpScene))

    return "Convert an assimp scene to a mesh. \n"

"\n"

"\n"

"Param\n"

"  - scale Scale to apply when reading the ressource \n"

"  - scene Pointer to the assimp scene \n"

"  - mesh The mesh that must be built ";

  return "";

}

} // namespace doxygen

#endif // DOXYGEN_AUTODOC_FUNCTIONS_H