All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Functions | Variables
hpp::fcl::details Namespace Reference

for OBB and RSS, there is local coordinate of BV, so normal need to be transformed More...

Classes

struct  MinkowskiDiff
 Minkowski difference class of two shapes. More...
 
struct  GJK
 class for GJK algorithm More...
 
struct  EPA
 class for EPA algorithm More...
 
struct  RelativeTransformation
 
struct  RelativeTransformation< false >
 
struct  DistanceTraversalBVTesting_impl
 
struct  DistanceTraversalBVTesting_impl< OBB >
 
struct  ContactPoint
 

Functions

Vec3f getSupport (const ShapeBase *shape, const Vec3f &dir)
 the support function for shape More...
 
template<typename BV >
const Matrix3fgetBVAxes (const BV &bv)
 
template<>
const Matrix3fgetBVAxes< OBBRSS > (const OBBRSS &bv)
 
template<typename S , typename BV , typename NarrowPhaseSolver , template< typename, typename > class OrientedNode>
static bool setupShapeMeshDistanceOrientedNode (OrientedNode< S, NarrowPhaseSolver > &node, const S &model1, const Transform3f &tf1, const BVHModel< BV > &model2, const Transform3f &tf2, const NarrowPhaseSolver *nsolver, const DistanceRequest &request, DistanceResult &result)
 
static void lineSegmentPointClosestToPoint (const Vec3f &p, const Vec3f &s1, const Vec3f &s2, Vec3f &sp)
 
bool sphereCapsuleIntersect (const Sphere &s1, const Transform3f &tf1, const Capsule &s2, const Transform3f &tf2, Vec3f *contact_points, FCL_REAL *penetration_depth, Vec3f *normal_)
 
bool sphereCapsuleDistance (const Sphere &s1, const Transform3f &tf1, const Capsule &s2, const Transform3f &tf2, FCL_REAL &dist, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool sphereCylinderDistance (const Sphere &s1, const Transform3f &tf1, const Cylinder &s2, const Transform3f &tf2, FCL_REAL &dist, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool sphereSphereIntersect (const Sphere &s1, const Transform3f &tf1, const Sphere &s2, const Transform3f &tf2, Vec3f *contact_points, FCL_REAL *penetration_depth, Vec3f *normal)
 
bool sphereSphereDistance (const Sphere &s1, const Transform3f &tf1, const Sphere &s2, const Transform3f &tf2, FCL_REAL &dist, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
FCL_REAL segmentSqrDistance (const Vec3f &from, const Vec3f &to, const Vec3f &p, Vec3f &nearest)
 the minimum distance from a point to a line More...
 
bool projectInTriangle (const Vec3f &p1, const Vec3f &p2, const Vec3f &p3, const Vec3f &normal, const Vec3f &p)
 Whether a point's projection is in a triangle. More...
 
bool sphereTriangleIntersect (const Sphere &s, const Transform3f &tf1, const Vec3f &P1, const Vec3f &P2, const Vec3f &P3, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal_)
 
bool sphereTriangleDistance (const Sphere &sp, const Transform3f &tf, const Vec3f &P1, const Vec3f &P2, const Vec3f &P3, FCL_REAL *dist)
 
bool sphereTriangleDistance (const Sphere &sp, const Transform3f &tf, const Vec3f &P1, const Vec3f &P2, const Vec3f &P3, FCL_REAL *dist, Vec3f *p1, Vec3f *p2)
 
bool sphereTriangleDistance (const Sphere &sp, const Transform3f &tf1, const Vec3f &P1, const Vec3f &P2, const Vec3f &P3, const Transform3f &tf2, FCL_REAL *dist, Vec3f *p1, Vec3f *p2)
 
static void lineClosestApproach (const Vec3f &pa, const Vec3f &ua, const Vec3f &pb, const Vec3f &ub, FCL_REAL *alpha, FCL_REAL *beta)
 
static int intersectRectQuad2 (FCL_REAL h[2], FCL_REAL p[8], FCL_REAL ret[16])
 
static void cullPoints2 (int n, FCL_REAL p[], int m, int i0, int iret[])
 
int boxBox2 (const Vec3f &side1, const Matrix3f &R1, const Vec3f &T1, const Vec3f &side2, const Matrix3f &R2, const Vec3f &T2, Vec3f &normal, FCL_REAL *depth, int *return_code, int maxc, std::vector< ContactPoint > &contacts)
 
bool compareContactPoints (const ContactPoint &c1, const ContactPoint &c2)
 
bool boxBoxIntersect (const Box &s1, const Transform3f &tf1, const Box &s2, const Transform3f &tf2, Vec3f *contact_points, FCL_REAL *penetration_depth_, Vec3f *normal_)
 
template<typename T >
halfspaceIntersectTolerance ()
 
template<>
float halfspaceIntersectTolerance ()
 
template<>
double halfspaceIntersectTolerance ()
 
bool sphereHalfspaceIntersect (const Sphere &s1, const Transform3f &tf1, const Halfspace &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool boxHalfspaceIntersect (const Box &s1, const Transform3f &tf1, const Halfspace &s2, const Transform3f &tf2)
 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 More...
 
bool boxHalfspaceIntersect (const Box &s1, const Transform3f &tf1, const Halfspace &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool capsuleHalfspaceIntersect (const Capsule &s1, const Transform3f &tf1, const Halfspace &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool cylinderHalfspaceIntersect (const Cylinder &s1, const Transform3f &tf1, const Halfspace &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool coneHalfspaceIntersect (const Cone &s1, const Transform3f &tf1, const Halfspace &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool convexHalfspaceIntersect (const Convex &s1, const Transform3f &tf1, const Halfspace &s2, const Transform3f &tf2, Vec3f *contact_points, FCL_REAL *penetration_depth, Vec3f *normal)
 
bool halfspaceTriangleIntersect (const Halfspace &s1, const Transform3f &tf1, const Vec3f &P1, const Vec3f &P2, const Vec3f &P3, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool planeHalfspaceIntersect (const Plane &s1, const Transform3f &tf1, const Halfspace &s2, const Transform3f &tf2, Plane &pl, Vec3f &p, Vec3f &d, FCL_REAL &penetration_depth, int &ret)
 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. More...
 
bool halfspaceIntersect (const Halfspace &s1, const Transform3f &tf1, const Halfspace &s2, const Transform3f &tf2, Vec3f &p, Vec3f &d, Halfspace &s, FCL_REAL &penetration_depth, int &ret)
 @ 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. More...
 
template<typename T >
planeIntersectTolerance ()
 
template<>
double planeIntersectTolerance< double > ()
 
template<>
float planeIntersectTolerance< float > ()
 
bool spherePlaneIntersect (const Sphere &s1, const Transform3f &tf1, const Plane &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool boxPlaneIntersect (const Box &s1, const Transform3f &tf1, const Plane &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 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. More...
 
bool boxSphereDistance (const Box &b, const Transform3f &tfb, const Sphere &s, const Transform3f &tfs, FCL_REAL &dist, Vec3f &pb, Vec3f &ps, Vec3f &normal)
 Taken from book Real Time Collision Detection, from Christer Ericson. More...
 
bool capsulePlaneIntersect (const Capsule &s1, const Transform3f &tf1, const Plane &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool cylinderPlaneIntersect (const Cylinder &s1, const Transform3f &tf1, const Plane &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 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 More...
 
bool conePlaneIntersect (const Cone &s1, const Transform3f &tf1, const Plane &s2, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool convexPlaneIntersect (const Convex &s1, const Transform3f &tf1, const Plane &s2, const Transform3f &tf2, Vec3f *contact_points, FCL_REAL *penetration_depth, Vec3f *normal)
 
bool planeTriangleIntersect (const Plane &s1, const Transform3f &tf1, const Vec3f &P1, const Vec3f &P2, const Vec3f &P3, const Transform3f &tf2, FCL_REAL &distance, Vec3f &p1, Vec3f &p2, Vec3f &normal)
 
bool halfspacePlaneIntersect (const Halfspace &s1, const Transform3f &tf1, const Plane &s2, const Transform3f &tf2, Plane &pl, Vec3f &p, Vec3f &d, FCL_REAL &penetration_depth, int &ret)
 
bool planeIntersect (const Plane &s1, const Transform3f &tf1, const Plane &s2, const Transform3f &tf2, Vec3f *, FCL_REAL *, Vec3f *)
 
FCL_REAL computePenetration (const Vec3f &P1, const Vec3f &P2, const Vec3f &P3, const Vec3f &Q1, const Vec3f &Q2, const Vec3f &Q3, const Transform3f &tf1, const Transform3f &tf2, Vec3f &normal)
 

Variables

static const size_t EPA_MAX_FACES = 128
 
static const size_t EPA_MAX_VERTICES = 64
 
static const FCL_REAL EPA_EPS = 0.000001
 
static const size_t EPA_MAX_ITERATIONS = 255
 

Detailed Description

for OBB and RSS, there is local coordinate of BV, so normal need to be transformed

Function Documentation

int hpp::fcl::details::boxBox2 ( const Vec3f &  side1,
const Matrix3f &  R1,
const Vec3f &  T1,
const Vec3f &  side2,
const Matrix3f &  R2,
const Vec3f &  T2,
Vec3f &  normal,
FCL_REAL *  depth,
int *  return_code,
int  maxc,
std::vector< ContactPoint > &  contacts 
)
inline
bool hpp::fcl::details::boxBoxIntersect ( const Box &  s1,
const Transform3f &  tf1,
const Box &  s2,
const Transform3f &  tf2,
Vec3f *  contact_points,
FCL_REAL *  penetration_depth_,
Vec3f *  normal_ 
)
inline
bool hpp::fcl::details::boxHalfspaceIntersect ( const Box &  s1,
const Transform3f &  tf1,
const Halfspace &  s2,
const Transform3f &  tf2 
)
inline

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

References hpp::fcl::Transform3f::getRotation(), hpp::fcl::Transform3f::getTranslation(), hpp::fcl::Halfspace::n, hpp::fcl::Box::side, hpp::fcl::Halfspace::signedDistance(), and hpp::fcl::transform().

bool hpp::fcl::details::boxHalfspaceIntersect ( const Box &  s1,
const Transform3f &  tf1,
const Halfspace &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::boxPlaneIntersect ( const Box &  s1,
const Transform3f &  tf1,
const Plane &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline

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.

References hpp::fcl::Plane::distance(), hpp::fcl::Transform3f::getRotation(), hpp::fcl::Transform3f::getTranslation(), hpp::fcl::Plane::n, hpp::fcl::Box::side, hpp::fcl::Plane::signedDistance(), and hpp::fcl::transform().

bool hpp::fcl::details::boxSphereDistance ( const Box &  b,
const Transform3f &  tfb,
const Sphere &  s,
const Transform3f &  tfs,
FCL_REAL &  dist,
Vec3f &  pb,
Vec3f &  ps,
Vec3f &  normal 
)
inline

Taken from book Real Time Collision Detection, from Christer Ericson.

Parameters
pbthe closest point to the sphere center on the box surface
pswhen colliding, matches pb, which is inside the sphere. when not colliding, the closest point on the sphere
normaldirection of motion of the box
Returns
true if the distance is negative (the shape overlaps).

References hpp::fcl::Transform3f::getRotation(), hpp::fcl::Transform3f::getTranslation(), hpp::fcl::Sphere::radius, and hpp::fcl::Box::side.

bool hpp::fcl::details::capsuleHalfspaceIntersect ( const Capsule &  s1,
const Transform3f &  tf1,
const Halfspace &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::capsulePlaneIntersect ( const Capsule &  s1,
const Transform3f &  tf1,
const Plane &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::compareContactPoints ( const ContactPoint &  c1,
const ContactPoint &  c2 
)
inline
FCL_REAL hpp::fcl::details::computePenetration ( const Vec3f &  P1,
const Vec3f &  P2,
const Vec3f &  P3,
const Vec3f &  Q1,
const Vec3f &  Q2,
const Vec3f &  Q3,
const Transform3f &  tf1,
const Transform3f &  tf2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::coneHalfspaceIntersect ( const Cone &  s1,
const Transform3f &  tf1,
const Halfspace &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::conePlaneIntersect ( const Cone &  s1,
const Transform3f &  tf1,
const Plane &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::convexHalfspaceIntersect ( const Convex &  s1,
const Transform3f &  tf1,
const Halfspace &  s2,
const Transform3f &  tf2,
Vec3f *  contact_points,
FCL_REAL *  penetration_depth,
Vec3f *  normal 
)
inline
bool hpp::fcl::details::convexPlaneIntersect ( const Convex &  s1,
const Transform3f &  tf1,
const Plane &  s2,
const Transform3f &  tf2,
Vec3f *  contact_points,
FCL_REAL *  penetration_depth,
Vec3f *  normal 
)
inline
static void hpp::fcl::details::cullPoints2 ( int  n,
FCL_REAL  p[],
int  m,
int  i0,
int  iret[] 
)
inlinestatic

Referenced by boxBox2().

bool hpp::fcl::details::cylinderHalfspaceIntersect ( const Cylinder &  s1,
const Transform3f &  tf1,
const Halfspace &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::cylinderPlaneIntersect ( const Cylinder &  s1,
const Transform3f &  tf1,
const Plane &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline

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

References hpp::fcl::Transform3f::getRotation(), hpp::fcl::Transform3f::getTranslation(), hpp::fcl::Cylinder::lz, hpp::fcl::Plane::n, hpp::fcl::Cylinder::radius, hpp::fcl::Plane::signedDistance(), and hpp::fcl::transform().

template<typename BV >
const Matrix3f& hpp::fcl::details::getBVAxes ( const BV &  bv)
inline
template<>
const Matrix3f& hpp::fcl::details::getBVAxes< OBBRSS > ( const OBBRSS &  bv)
inline
Vec3f hpp::fcl::details::getSupport ( const ShapeBase *  shape,
const Vec3f &  dir 
)
bool hpp::fcl::details::halfspaceIntersect ( const Halfspace &  s1,
const Transform3f &  tf1,
const Halfspace &  s2,
const Transform3f &  tf2,
Vec3f &  p,
Vec3f &  d,
Halfspace &  s,
FCL_REAL &  penetration_depth,
int &  ret 
)
inline

@ 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

References hpp::fcl::Halfspace::d, hpp::fcl::Halfspace::n, and hpp::fcl::transform().

template<typename T >
T hpp::fcl::details::halfspaceIntersectTolerance ( )
inline
template<>
float hpp::fcl::details::halfspaceIntersectTolerance ( )
inline
template<>
double hpp::fcl::details::halfspaceIntersectTolerance ( )
inline
bool hpp::fcl::details::halfspacePlaneIntersect ( const Halfspace &  s1,
const Transform3f &  tf1,
const Plane &  s2,
const Transform3f &  tf2,
Plane &  pl,
Vec3f &  p,
Vec3f &  d,
FCL_REAL &  penetration_depth,
int &  ret 
)
inline
bool hpp::fcl::details::halfspaceTriangleIntersect ( const Halfspace &  s1,
const Transform3f &  tf1,
const Vec3f &  P1,
const Vec3f &  P2,
const Vec3f &  P3,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
static int hpp::fcl::details::intersectRectQuad2 ( FCL_REAL  h[2],
FCL_REAL  p[8],
FCL_REAL  ret[16] 
)
static

Referenced by boxBox2().

static void hpp::fcl::details::lineClosestApproach ( const Vec3f &  pa,
const Vec3f &  ua,
const Vec3f &  pb,
const Vec3f &  ub,
FCL_REAL *  alpha,
FCL_REAL *  beta 
)
inlinestatic

Referenced by boxBox2().

static void hpp::fcl::details::lineSegmentPointClosestToPoint ( const Vec3f &  p,
const Vec3f &  s1,
const Vec3f &  s2,
Vec3f &  sp 
)
inlinestatic
bool hpp::fcl::details::planeHalfspaceIntersect ( const Plane &  s1,
const Transform3f &  tf1,
const Halfspace &  s2,
const Transform3f &  tf2,
Plane &  pl,
Vec3f &  p,
Vec3f &  d,
FCL_REAL &  penetration_depth,
int &  ret 
)
inline

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

References hpp::fcl::Halfspace::d, hpp::fcl::Plane::d, hpp::fcl::Halfspace::n, hpp::fcl::Plane::n, and hpp::fcl::transform().

Referenced by halfspacePlaneIntersect().

bool hpp::fcl::details::planeIntersect ( const Plane &  s1,
const Transform3f &  tf1,
const Plane &  s2,
const Transform3f &  tf2,
Vec3f *  ,
FCL_REAL *  ,
Vec3f *   
)
inline
template<typename T >
T hpp::fcl::details::planeIntersectTolerance ( )
inline
template<>
double hpp::fcl::details::planeIntersectTolerance< double > ( )
inline
template<>
float hpp::fcl::details::planeIntersectTolerance< float > ( )
inline
bool hpp::fcl::details::planeTriangleIntersect ( const Plane &  s1,
const Transform3f &  tf1,
const Vec3f &  P1,
const Vec3f &  P2,
const Vec3f &  P3,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::projectInTriangle ( const Vec3f &  p1,
const Vec3f &  p2,
const Vec3f &  p3,
const Vec3f &  normal,
const Vec3f &  p 
)
inline

Whether a point's projection is in a triangle.

Referenced by sphereTriangleIntersect().

FCL_REAL hpp::fcl::details::segmentSqrDistance ( const Vec3f &  from,
const Vec3f &  to,
const Vec3f &  p,
Vec3f &  nearest 
)
inline

the minimum distance from a point to a line

Referenced by sphereTriangleIntersect().

template<typename S , typename BV , typename NarrowPhaseSolver , template< typename, typename > class OrientedNode>
static bool hpp::fcl::details::setupShapeMeshDistanceOrientedNode ( OrientedNode< S, NarrowPhaseSolver > &  node,
const S &  model1,
const Transform3f &  tf1,
const BVHModel< BV > &  model2,
const Transform3f &  tf2,
const NarrowPhaseSolver *  nsolver,
const DistanceRequest &  request,
DistanceResult &  result 
)
inlinestatic
bool hpp::fcl::details::sphereCapsuleDistance ( const Sphere &  s1,
const Transform3f &  tf1,
const Capsule &  s2,
const Transform3f &  tf2,
FCL_REAL &  dist,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::sphereCapsuleIntersect ( const Sphere &  s1,
const Transform3f &  tf1,
const Capsule &  s2,
const Transform3f &  tf2,
Vec3f *  contact_points,
FCL_REAL *  penetration_depth,
Vec3f *  normal_ 
)
inline
bool hpp::fcl::details::sphereCylinderDistance ( const Sphere &  s1,
const Transform3f &  tf1,
const Cylinder &  s2,
const Transform3f &  tf2,
FCL_REAL &  dist,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::sphereHalfspaceIntersect ( const Sphere &  s1,
const Transform3f &  tf1,
const Halfspace &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::spherePlaneIntersect ( const Sphere &  s1,
const Transform3f &  tf1,
const Plane &  s2,
const Transform3f &  tf2,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::sphereSphereDistance ( const Sphere &  s1,
const Transform3f &  tf1,
const Sphere &  s2,
const Transform3f &  tf2,
FCL_REAL &  dist,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal 
)
inline
bool hpp::fcl::details::sphereSphereIntersect ( const Sphere &  s1,
const Transform3f &  tf1,
const Sphere &  s2,
const Transform3f &  tf2,
Vec3f *  contact_points,
FCL_REAL *  penetration_depth,
Vec3f *  normal 
)
inline
bool hpp::fcl::details::sphereTriangleDistance ( const Sphere &  sp,
const Transform3f &  tf,
const Vec3f &  P1,
const Vec3f &  P2,
const Vec3f &  P3,
FCL_REAL *  dist 
)
inline
bool hpp::fcl::details::sphereTriangleDistance ( const Sphere &  sp,
const Transform3f &  tf,
const Vec3f &  P1,
const Vec3f &  P2,
const Vec3f &  P3,
FCL_REAL *  dist,
Vec3f *  p1,
Vec3f *  p2 
)
inline
bool hpp::fcl::details::sphereTriangleDistance ( const Sphere &  sp,
const Transform3f &  tf1,
const Vec3f &  P1,
const Vec3f &  P2,
const Vec3f &  P3,
const Transform3f &  tf2,
FCL_REAL *  dist,
Vec3f *  p1,
Vec3f *  p2 
)
inline
bool hpp::fcl::details::sphereTriangleIntersect ( const Sphere &  s,
const Transform3f &  tf1,
const Vec3f &  P1,
const Vec3f &  P2,
const Vec3f &  P3,
FCL_REAL &  distance,
Vec3f &  p1,
Vec3f &  p2,
Vec3f &  normal_ 
)
inline

Variable Documentation

const FCL_REAL hpp::fcl::details::EPA_EPS = 0.000001
static
const size_t hpp::fcl::details::EPA_MAX_FACES = 128
static
const size_t hpp::fcl::details::EPA_MAX_ITERATIONS = 255
static
const size_t hpp::fcl::details::EPA_MAX_VERTICES = 64
static