collision_func_matrix.cpp
Go to the documentation of this file.
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Copyright (c) 2011-2014, Willow Garage, Inc.
5  * Copyright (c) 2014-2015, Open Source Robotics Foundation
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * * Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  * * Redistributions in binary form must reproduce the above
15  * copyright notice, this list of conditions and the following
16  * disclaimer in the documentation and/or other materials provided
17  * with the distribution.
18  * * Neither the name of Open Source Robotics Foundation nor the names of its
19  * contributors may be used to endorse or promote products derived
20  * from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33  * POSSIBILITY OF SUCH DAMAGE.
34  */
35 
38 #include <hpp/fcl/collision_func_matrix.h>
39 
40 #include <hpp/fcl/internal/traversal_node_setup.h>
41 #include <../src/collision_node.h>
42 #include <hpp/fcl/narrowphase/narrowphase.h>
43 #include <hpp/fcl/internal/shape_shape_func.h>
44 #include <hpp/fcl/shape/geometric_shapes_traits.h>
45 #include <../src/traits_traversal.h>
46 
47 namespace hpp {
48 namespace fcl {
49 
50 #ifdef HPP_FCL_HAS_OCTOMAP
51 
52 template <typename TypeA, typename TypeB>
53 std::size_t OctreeCollide(const CollisionGeometry* o1, const Transform3f& tf1,
54  const CollisionGeometry* o2, const Transform3f& tf2,
55  const GJKSolver* nsolver,
56  const CollisionRequest& request,
57  CollisionResult& result) {
58  if (request.isSatisfied(result)) return result.numContacts();
59 
60  if (request.security_margin < 0)
61  HPP_FCL_THROW_PRETTY(
62  "Negative security margin are not handled yet for Octree",
63  std::invalid_argument);
64 
65  typename TraversalTraitsCollision<TypeA, TypeB>::CollisionTraversal_t node(
66  request);
67  const TypeA* obj1 = dynamic_cast<const TypeA*>(o1);
68  const TypeB* obj2 = dynamic_cast<const TypeB*>(o2);
69  OcTreeSolver otsolver(nsolver);
70 
71  initialize(node, *obj1, tf1, *obj2, tf2, &otsolver, result);
72  collide(&node, request, result);
73 
74  return result.numContacts();
75 }
76 
77 #endif
78 
79 namespace details {
80 template <typename T_BVH, typename T_SH>
81 struct bvh_shape_traits {
82  enum { Options = RelativeTransformationIsIdentity };
83 };
84 #define BVH_SHAPE_DEFAULT_TO_ORIENTED(bv) \
85  template <typename T_SH> \
86  struct bvh_shape_traits<bv, T_SH> { \
87  enum { Options = 0 }; \
88  }
89 BVH_SHAPE_DEFAULT_TO_ORIENTED(OBB);
90 BVH_SHAPE_DEFAULT_TO_ORIENTED(RSS);
91 BVH_SHAPE_DEFAULT_TO_ORIENTED(kIOS);
92 BVH_SHAPE_DEFAULT_TO_ORIENTED(OBBRSS);
93 #undef BVH_SHAPE_DEFAULT_TO_ORIENTED
94 } // namespace details
95 
100 template <typename T_BVH, typename T_SH,
101  int _Options = details::bvh_shape_traits<T_BVH, T_SH>::Options>
102 struct HPP_FCL_LOCAL BVHShapeCollider {
103  static std::size_t collide(const CollisionGeometry* o1,
104  const Transform3f& tf1,
105  const CollisionGeometry* o2,
106  const Transform3f& tf2, const GJKSolver* nsolver,
107  const CollisionRequest& request,
108  CollisionResult& result) {
109  if (request.isSatisfied(result)) return result.numContacts();
110 
111  if (request.security_margin < 0)
112  HPP_FCL_THROW_PRETTY(
113  "Negative security margin are not handled yet for BVHModel",
114  std::invalid_argument);
115 
116  if (_Options & RelativeTransformationIsIdentity)
117  return aligned(o1, tf1, o2, tf2, nsolver, request, result);
118  else
119  return oriented(o1, tf1, o2, tf2, nsolver, request, result);
120  }
121 
122  static std::size_t aligned(const CollisionGeometry* o1,
123  const Transform3f& tf1,
124  const CollisionGeometry* o2,
125  const Transform3f& tf2, const GJKSolver* nsolver,
126  const CollisionRequest& request,
127  CollisionResult& result) {
128  if (request.isSatisfied(result)) return result.numContacts();
129 
130  MeshShapeCollisionTraversalNode<T_BVH, T_SH,
131  RelativeTransformationIsIdentity>
132  node(request);
133  const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
134  BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
135  Transform3f tf1_tmp = tf1;
136  const T_SH* obj2 = static_cast<const T_SH*>(o2);
137 
138  initialize(node, *obj1_tmp, tf1_tmp, *obj2, tf2, nsolver, result);
139  fcl::collide(&node, request, result);
140 
141  delete obj1_tmp;
142  return result.numContacts();
143  }
144 
145  static std::size_t oriented(const CollisionGeometry* o1,
146  const Transform3f& tf1,
147  const CollisionGeometry* o2,
148  const Transform3f& tf2, const GJKSolver* nsolver,
149  const CollisionRequest& request,
150  CollisionResult& result) {
151  if (request.isSatisfied(result)) return result.numContacts();
152 
153  MeshShapeCollisionTraversalNode<T_BVH, T_SH, 0> node(request);
154  const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
155  const T_SH* obj2 = static_cast<const T_SH*>(o2);
156 
157  initialize(node, *obj1, tf1, *obj2, tf2, nsolver, result);
158  fcl::collide(&node, request, result);
159  return result.numContacts();
160  }
161 };
162 
168 template <typename BV, typename Shape>
169 struct HPP_FCL_LOCAL HeightFieldShapeCollider {
170  typedef HeightField<BV> HF;
171 
172  static std::size_t collide(const CollisionGeometry* o1,
173  const Transform3f& tf1,
174  const CollisionGeometry* o2,
175  const Transform3f& tf2, const GJKSolver* nsolver,
176  const CollisionRequest& request,
177  CollisionResult& result) {
178  if (request.isSatisfied(result)) return result.numContacts();
179 
180  const HF& height_field = static_cast<const HF&>(*o1);
181  const Shape& shape = static_cast<const Shape&>(*o2);
182 
183  HeightFieldShapeCollisionTraversalNode<BV, Shape, 0> node(request);
184 
185  initialize(node, height_field, tf1, shape, tf2, nsolver, result);
186  fcl::collide(&node, request, result);
187  return result.numContacts();
188  }
189 };
190 
191 namespace details {
192 template <typename OrientedMeshCollisionTraversalNode, typename T_BVH>
193 std::size_t orientedMeshCollide(const CollisionGeometry* o1,
194  const Transform3f& tf1,
195  const CollisionGeometry* o2,
196  const Transform3f& tf2,
197  const CollisionRequest& request,
198  CollisionResult& result) {
199  if (request.isSatisfied(result)) return result.numContacts();
200 
201  OrientedMeshCollisionTraversalNode node(request);
202  const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
203  const BVHModel<T_BVH>* obj2 = static_cast<const BVHModel<T_BVH>*>(o2);
204 
205  initialize(node, *obj1, tf1, *obj2, tf2, result);
206  collide(&node, request, result);
207 
208  return result.numContacts();
209 }
210 
211 } // namespace details
212 
213 template <typename T_BVH>
214 std::size_t BVHCollide(const CollisionGeometry* o1, const Transform3f& tf1,
215  const CollisionGeometry* o2, const Transform3f& tf2,
216  const CollisionRequest& request,
217  CollisionResult& result) {
218  if (request.isSatisfied(result)) return result.numContacts();
219 
220  MeshCollisionTraversalNode<T_BVH> node(request);
221  const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
222  const BVHModel<T_BVH>* obj2 = static_cast<const BVHModel<T_BVH>*>(o2);
223  BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
224  Transform3f tf1_tmp = tf1;
225  BVHModel<T_BVH>* obj2_tmp = new BVHModel<T_BVH>(*obj2);
226  Transform3f tf2_tmp = tf2;
227 
228  initialize(node, *obj1_tmp, tf1_tmp, *obj2_tmp, tf2_tmp, result);
229  fcl::collide(&node, request, result);
230 
231  delete obj1_tmp;
232  delete obj2_tmp;
233 
234  return result.numContacts();
235 }
236 
237 template <>
238 std::size_t BVHCollide<OBB>(const CollisionGeometry* o1, const Transform3f& tf1,
239  const CollisionGeometry* o2, const Transform3f& tf2,
240  const CollisionRequest& request,
241  CollisionResult& result) {
242  return details::orientedMeshCollide<MeshCollisionTraversalNodeOBB, OBB>(
243  o1, tf1, o2, tf2, request, result);
244 }
245 
246 template <>
247 std::size_t BVHCollide<OBBRSS>(const CollisionGeometry* o1,
248  const Transform3f& tf1,
249  const CollisionGeometry* o2,
250  const Transform3f& tf2,
251  const CollisionRequest& request,
252  CollisionResult& result) {
253  return details::orientedMeshCollide<MeshCollisionTraversalNodeOBBRSS, OBBRSS>(
254  o1, tf1, o2, tf2, request, result);
255 }
256 
257 template <>
258 std::size_t BVHCollide<kIOS>(const CollisionGeometry* o1,
259  const Transform3f& tf1,
260  const CollisionGeometry* o2,
261  const Transform3f& tf2,
262  const CollisionRequest& request,
263  CollisionResult& result) {
264  return details::orientedMeshCollide<MeshCollisionTraversalNodekIOS, kIOS>(
265  o1, tf1, o2, tf2, request, result);
266 }
267 
268 template <typename T_BVH>
269 std::size_t BVHCollide(const CollisionGeometry* o1, const Transform3f& tf1,
270  const CollisionGeometry* o2, const Transform3f& tf2,
271  const GJKSolver* /*nsolver*/,
272  const CollisionRequest& request,
273  CollisionResult& result) {
274  return BVHCollide<T_BVH>(o1, tf1, o2, tf2, request, result);
275 }
276 
277 CollisionFunctionMatrix::CollisionFunctionMatrix() {
278  for (int i = 0; i < NODE_COUNT; ++i) {
279  for (int j = 0; j < NODE_COUNT; ++j) collision_matrix[i][j] = NULL;
280  }
281 
282  collision_matrix[GEOM_BOX][GEOM_BOX] = &ShapeShapeCollide<Box, Box>;
283  collision_matrix[GEOM_BOX][GEOM_SPHERE] = &ShapeShapeCollide<Box, Sphere>;
284  collision_matrix[GEOM_BOX][GEOM_CAPSULE] = &ShapeShapeCollide<Box, Capsule>;
285  collision_matrix[GEOM_BOX][GEOM_CONE] = &ShapeShapeCollide<Box, Cone>;
286  collision_matrix[GEOM_BOX][GEOM_CYLINDER] = &ShapeShapeCollide<Box, Cylinder>;
287  collision_matrix[GEOM_BOX][GEOM_CONVEX] = &ShapeShapeCollide<Box, ConvexBase>;
288  collision_matrix[GEOM_BOX][GEOM_PLANE] = &ShapeShapeCollide<Box, Plane>;
289  collision_matrix[GEOM_BOX][GEOM_HALFSPACE] =
290  &ShapeShapeCollide<Box, Halfspace>;
291  collision_matrix[GEOM_BOX][GEOM_ELLIPSOID] =
292  &ShapeShapeCollide<Box, Ellipsoid>;
293 
294  collision_matrix[GEOM_SPHERE][GEOM_BOX] = &ShapeShapeCollide<Sphere, Box>;
295  collision_matrix[GEOM_SPHERE][GEOM_SPHERE] =
296  &ShapeShapeCollide<Sphere, Sphere>;
297  collision_matrix[GEOM_SPHERE][GEOM_CAPSULE] =
298  &ShapeShapeCollide<Sphere, Capsule>;
299  collision_matrix[GEOM_SPHERE][GEOM_CONE] = &ShapeShapeCollide<Sphere, Cone>;
300  collision_matrix[GEOM_SPHERE][GEOM_CYLINDER] =
301  &ShapeShapeCollide<Sphere, Cylinder>;
302  collision_matrix[GEOM_SPHERE][GEOM_CONVEX] =
303  &ShapeShapeCollide<Sphere, ConvexBase>;
304  collision_matrix[GEOM_SPHERE][GEOM_PLANE] = &ShapeShapeCollide<Sphere, Plane>;
305  collision_matrix[GEOM_SPHERE][GEOM_HALFSPACE] =
306  &ShapeShapeCollide<Sphere, Halfspace>;
307  collision_matrix[GEOM_SPHERE][GEOM_ELLIPSOID] =
308  &ShapeShapeCollide<Sphere, Ellipsoid>;
309 
310  collision_matrix[GEOM_ELLIPSOID][GEOM_BOX] =
311  &ShapeShapeCollide<Ellipsoid, Box>;
312  collision_matrix[GEOM_ELLIPSOID][GEOM_SPHERE] =
313  &ShapeShapeCollide<Ellipsoid, Sphere>;
314  collision_matrix[GEOM_ELLIPSOID][GEOM_CAPSULE] =
315  &ShapeShapeCollide<Ellipsoid, Capsule>;
316  collision_matrix[GEOM_ELLIPSOID][GEOM_CONE] =
317  &ShapeShapeCollide<Ellipsoid, Cone>;
318  collision_matrix[GEOM_ELLIPSOID][GEOM_CYLINDER] =
319  &ShapeShapeCollide<Ellipsoid, Cylinder>;
320  collision_matrix[GEOM_ELLIPSOID][GEOM_CONVEX] =
321  &ShapeShapeCollide<Ellipsoid, ConvexBase>;
322  // TODO Louis: Ellipsoid - Plane
323  // TODO Louis: Ellipsoid - Halfspace
324  collision_matrix[GEOM_ELLIPSOID][GEOM_ELLIPSOID] =
325  &ShapeShapeCollide<Ellipsoid, Ellipsoid>;
326 
327  collision_matrix[GEOM_CAPSULE][GEOM_BOX] = &ShapeShapeCollide<Capsule, Box>;
328  collision_matrix[GEOM_CAPSULE][GEOM_SPHERE] =
329  &ShapeShapeCollide<Capsule, Sphere>;
330  collision_matrix[GEOM_CAPSULE][GEOM_CAPSULE] =
331  &ShapeShapeCollide<Capsule, Capsule>;
332  collision_matrix[GEOM_CAPSULE][GEOM_CONE] = &ShapeShapeCollide<Capsule, Cone>;
333  collision_matrix[GEOM_CAPSULE][GEOM_CYLINDER] =
334  &ShapeShapeCollide<Capsule, Cylinder>;
335  collision_matrix[GEOM_CAPSULE][GEOM_CONVEX] =
336  &ShapeShapeCollide<Capsule, ConvexBase>;
337  collision_matrix[GEOM_CAPSULE][GEOM_PLANE] =
338  &ShapeShapeCollide<Capsule, Plane>;
339  collision_matrix[GEOM_CAPSULE][GEOM_HALFSPACE] =
340  &ShapeShapeCollide<Capsule, Halfspace>;
341  collision_matrix[GEOM_CAPSULE][GEOM_ELLIPSOID] =
342  &ShapeShapeCollide<Capsule, Ellipsoid>;
343 
344  collision_matrix[GEOM_CONE][GEOM_BOX] = &ShapeShapeCollide<Cone, Box>;
345  collision_matrix[GEOM_CONE][GEOM_SPHERE] = &ShapeShapeCollide<Cone, Sphere>;
346  collision_matrix[GEOM_CONE][GEOM_CAPSULE] = &ShapeShapeCollide<Cone, Capsule>;
347  collision_matrix[GEOM_CONE][GEOM_CONE] = &ShapeShapeCollide<Cone, Cone>;
348  collision_matrix[GEOM_CONE][GEOM_CYLINDER] =
349  &ShapeShapeCollide<Cone, Cylinder>;
350  collision_matrix[GEOM_CONE][GEOM_CONVEX] =
351  &ShapeShapeCollide<Cone, ConvexBase>;
352  collision_matrix[GEOM_CONE][GEOM_PLANE] = &ShapeShapeCollide<Cone, Plane>;
353  collision_matrix[GEOM_CONE][GEOM_HALFSPACE] =
354  &ShapeShapeCollide<Cone, Halfspace>;
355  collision_matrix[GEOM_CONE][GEOM_ELLIPSOID] =
356  &ShapeShapeCollide<Cone, Ellipsoid>;
357 
358  collision_matrix[GEOM_CYLINDER][GEOM_BOX] = &ShapeShapeCollide<Cylinder, Box>;
359  collision_matrix[GEOM_CYLINDER][GEOM_SPHERE] =
360  &ShapeShapeCollide<Cylinder, Sphere>;
361  collision_matrix[GEOM_CYLINDER][GEOM_CAPSULE] =
362  &ShapeShapeCollide<Cylinder, Capsule>;
363  collision_matrix[GEOM_CYLINDER][GEOM_CONE] =
364  &ShapeShapeCollide<Cylinder, Cone>;
365  collision_matrix[GEOM_CYLINDER][GEOM_CYLINDER] =
366  &ShapeShapeCollide<Cylinder, Cylinder>;
367  collision_matrix[GEOM_CYLINDER][GEOM_CONVEX] =
368  &ShapeShapeCollide<Cylinder, ConvexBase>;
369  collision_matrix[GEOM_CYLINDER][GEOM_PLANE] =
370  &ShapeShapeCollide<Cylinder, Plane>;
371  collision_matrix[GEOM_CYLINDER][GEOM_HALFSPACE] =
372  &ShapeShapeCollide<Cylinder, Halfspace>;
373  collision_matrix[GEOM_CYLINDER][GEOM_ELLIPSOID] =
374  &ShapeShapeCollide<Cylinder, Ellipsoid>;
375 
376  collision_matrix[GEOM_CONVEX][GEOM_BOX] = &ShapeShapeCollide<ConvexBase, Box>;
377  collision_matrix[GEOM_CONVEX][GEOM_SPHERE] =
378  &ShapeShapeCollide<ConvexBase, Sphere>;
379  collision_matrix[GEOM_CONVEX][GEOM_CAPSULE] =
380  &ShapeShapeCollide<ConvexBase, Capsule>;
381  collision_matrix[GEOM_CONVEX][GEOM_CONE] =
382  &ShapeShapeCollide<ConvexBase, Cone>;
383  collision_matrix[GEOM_CONVEX][GEOM_CYLINDER] =
384  &ShapeShapeCollide<ConvexBase, Cylinder>;
385  collision_matrix[GEOM_CONVEX][GEOM_CONVEX] =
386  &ShapeShapeCollide<ConvexBase, ConvexBase>;
387  collision_matrix[GEOM_CONVEX][GEOM_PLANE] =
388  &ShapeShapeCollide<ConvexBase, Plane>;
389  collision_matrix[GEOM_CONVEX][GEOM_HALFSPACE] =
390  &ShapeShapeCollide<ConvexBase, Halfspace>;
391  collision_matrix[GEOM_CONVEX][GEOM_ELLIPSOID] =
392  &ShapeShapeCollide<ConvexBase, Ellipsoid>;
393 
394  collision_matrix[GEOM_PLANE][GEOM_BOX] = &ShapeShapeCollide<Plane, Box>;
395  collision_matrix[GEOM_PLANE][GEOM_SPHERE] = &ShapeShapeCollide<Plane, Sphere>;
396  collision_matrix[GEOM_PLANE][GEOM_CAPSULE] =
397  &ShapeShapeCollide<Plane, Capsule>;
398  collision_matrix[GEOM_PLANE][GEOM_CONE] = &ShapeShapeCollide<Plane, Cone>;
399  collision_matrix[GEOM_PLANE][GEOM_CYLINDER] =
400  &ShapeShapeCollide<Plane, Cylinder>;
401  collision_matrix[GEOM_PLANE][GEOM_CONVEX] =
402  &ShapeShapeCollide<Plane, ConvexBase>;
403  collision_matrix[GEOM_PLANE][GEOM_PLANE] = &ShapeShapeCollide<Plane, Plane>;
404  collision_matrix[GEOM_PLANE][GEOM_HALFSPACE] =
405  &ShapeShapeCollide<Plane, Halfspace>;
406  // TODO Louis: Ellipsoid - Plane
407 
408  collision_matrix[GEOM_HALFSPACE][GEOM_BOX] =
409  &ShapeShapeCollide<Halfspace, Box>;
410  collision_matrix[GEOM_HALFSPACE][GEOM_SPHERE] =
411  &ShapeShapeCollide<Halfspace, Sphere>;
412  collision_matrix[GEOM_HALFSPACE][GEOM_CAPSULE] =
413  &ShapeShapeCollide<Halfspace, Capsule>;
414  collision_matrix[GEOM_HALFSPACE][GEOM_CONE] =
415  &ShapeShapeCollide<Halfspace, Cone>;
416  collision_matrix[GEOM_HALFSPACE][GEOM_CYLINDER] =
417  &ShapeShapeCollide<Halfspace, Cylinder>;
418  collision_matrix[GEOM_HALFSPACE][GEOM_CONVEX] =
419  &ShapeShapeCollide<Halfspace, ConvexBase>;
420  collision_matrix[GEOM_HALFSPACE][GEOM_PLANE] =
421  &ShapeShapeCollide<Halfspace, Plane>;
422  collision_matrix[GEOM_HALFSPACE][GEOM_HALFSPACE] =
423  &ShapeShapeCollide<Halfspace, Halfspace>;
424  // TODO Louis: Ellipsoid - Halfspace
425 
426  collision_matrix[BV_AABB][GEOM_BOX] = &BVHShapeCollider<AABB, Box>::collide;
427  collision_matrix[BV_AABB][GEOM_SPHERE] =
428  &BVHShapeCollider<AABB, Sphere>::collide;
429  collision_matrix[BV_AABB][GEOM_CAPSULE] =
430  &BVHShapeCollider<AABB, Capsule>::collide;
431  collision_matrix[BV_AABB][GEOM_CONE] = &BVHShapeCollider<AABB, Cone>::collide;
432  collision_matrix[BV_AABB][GEOM_CYLINDER] =
433  &BVHShapeCollider<AABB, Cylinder>::collide;
434  collision_matrix[BV_AABB][GEOM_CONVEX] =
435  &BVHShapeCollider<AABB, ConvexBase>::collide;
436  collision_matrix[BV_AABB][GEOM_PLANE] =
437  &BVHShapeCollider<AABB, Plane>::collide;
438  collision_matrix[BV_AABB][GEOM_HALFSPACE] =
439  &BVHShapeCollider<AABB, Halfspace>::collide;
440  collision_matrix[BV_AABB][GEOM_ELLIPSOID] =
441  &BVHShapeCollider<AABB, Ellipsoid>::collide;
442 
443  collision_matrix[BV_OBB][GEOM_BOX] = &BVHShapeCollider<OBB, Box>::collide;
444  collision_matrix[BV_OBB][GEOM_SPHERE] =
445  &BVHShapeCollider<OBB, Sphere>::collide;
446  collision_matrix[BV_OBB][GEOM_CAPSULE] =
447  &BVHShapeCollider<OBB, Capsule>::collide;
448  collision_matrix[BV_OBB][GEOM_CONE] = &BVHShapeCollider<OBB, Cone>::collide;
449  collision_matrix[BV_OBB][GEOM_CYLINDER] =
450  &BVHShapeCollider<OBB, Cylinder>::collide;
451  collision_matrix[BV_OBB][GEOM_CONVEX] =
452  &BVHShapeCollider<OBB, ConvexBase>::collide;
453  collision_matrix[BV_OBB][GEOM_PLANE] = &BVHShapeCollider<OBB, Plane>::collide;
454  collision_matrix[BV_OBB][GEOM_HALFSPACE] =
455  &BVHShapeCollider<OBB, Halfspace>::collide;
456  collision_matrix[BV_OBB][GEOM_ELLIPSOID] =
457  &BVHShapeCollider<OBB, Ellipsoid>::collide;
458 
459  collision_matrix[BV_RSS][GEOM_BOX] = &BVHShapeCollider<RSS, Box>::collide;
460  collision_matrix[BV_RSS][GEOM_SPHERE] =
461  &BVHShapeCollider<RSS, Sphere>::collide;
462  collision_matrix[BV_RSS][GEOM_CAPSULE] =
463  &BVHShapeCollider<RSS, Capsule>::collide;
464  collision_matrix[BV_RSS][GEOM_CONE] = &BVHShapeCollider<RSS, Cone>::collide;
465  collision_matrix[BV_RSS][GEOM_CYLINDER] =
466  &BVHShapeCollider<RSS, Cylinder>::collide;
467  collision_matrix[BV_RSS][GEOM_CONVEX] =
468  &BVHShapeCollider<RSS, ConvexBase>::collide;
469  collision_matrix[BV_RSS][GEOM_PLANE] = &BVHShapeCollider<RSS, Plane>::collide;
470  collision_matrix[BV_RSS][GEOM_HALFSPACE] =
471  &BVHShapeCollider<RSS, Halfspace>::collide;
472  collision_matrix[BV_RSS][GEOM_ELLIPSOID] =
473  &BVHShapeCollider<RSS, Ellipsoid>::collide;
474 
475  collision_matrix[BV_KDOP16][GEOM_BOX] =
476  &BVHShapeCollider<KDOP<16>, Box>::collide;
477  collision_matrix[BV_KDOP16][GEOM_SPHERE] =
478  &BVHShapeCollider<KDOP<16>, Sphere>::collide;
479  collision_matrix[BV_KDOP16][GEOM_CAPSULE] =
480  &BVHShapeCollider<KDOP<16>, Capsule>::collide;
481  collision_matrix[BV_KDOP16][GEOM_CONE] =
482  &BVHShapeCollider<KDOP<16>, Cone>::collide;
483  collision_matrix[BV_KDOP16][GEOM_CYLINDER] =
484  &BVHShapeCollider<KDOP<16>, Cylinder>::collide;
485  collision_matrix[BV_KDOP16][GEOM_CONVEX] =
486  &BVHShapeCollider<KDOP<16>, ConvexBase>::collide;
487  collision_matrix[BV_KDOP16][GEOM_PLANE] =
488  &BVHShapeCollider<KDOP<16>, Plane>::collide;
489  collision_matrix[BV_KDOP16][GEOM_HALFSPACE] =
490  &BVHShapeCollider<KDOP<16>, Halfspace>::collide;
491  collision_matrix[BV_KDOP16][GEOM_ELLIPSOID] =
492  &BVHShapeCollider<KDOP<16>, Ellipsoid>::collide;
493 
494  collision_matrix[BV_KDOP18][GEOM_BOX] =
495  &BVHShapeCollider<KDOP<18>, Box>::collide;
496  collision_matrix[BV_KDOP18][GEOM_SPHERE] =
497  &BVHShapeCollider<KDOP<18>, Sphere>::collide;
498  collision_matrix[BV_KDOP18][GEOM_CAPSULE] =
499  &BVHShapeCollider<KDOP<18>, Capsule>::collide;
500  collision_matrix[BV_KDOP18][GEOM_CONE] =
501  &BVHShapeCollider<KDOP<18>, Cone>::collide;
502  collision_matrix[BV_KDOP18][GEOM_CYLINDER] =
503  &BVHShapeCollider<KDOP<18>, Cylinder>::collide;
504  collision_matrix[BV_KDOP18][GEOM_CONVEX] =
505  &BVHShapeCollider<KDOP<18>, ConvexBase>::collide;
506  collision_matrix[BV_KDOP18][GEOM_PLANE] =
507  &BVHShapeCollider<KDOP<18>, Plane>::collide;
508  collision_matrix[BV_KDOP18][GEOM_HALFSPACE] =
509  &BVHShapeCollider<KDOP<18>, Halfspace>::collide;
510  collision_matrix[BV_KDOP18][GEOM_ELLIPSOID] =
511  &BVHShapeCollider<KDOP<18>, Ellipsoid>::collide;
512 
513  collision_matrix[BV_KDOP24][GEOM_BOX] =
514  &BVHShapeCollider<KDOP<24>, Box>::collide;
515  collision_matrix[BV_KDOP24][GEOM_SPHERE] =
516  &BVHShapeCollider<KDOP<24>, Sphere>::collide;
517  collision_matrix[BV_KDOP24][GEOM_CAPSULE] =
518  &BVHShapeCollider<KDOP<24>, Capsule>::collide;
519  collision_matrix[BV_KDOP24][GEOM_CONE] =
520  &BVHShapeCollider<KDOP<24>, Cone>::collide;
521  collision_matrix[BV_KDOP24][GEOM_CYLINDER] =
522  &BVHShapeCollider<KDOP<24>, Cylinder>::collide;
523  collision_matrix[BV_KDOP24][GEOM_CONVEX] =
524  &BVHShapeCollider<KDOP<24>, ConvexBase>::collide;
525  collision_matrix[BV_KDOP24][GEOM_PLANE] =
526  &BVHShapeCollider<KDOP<24>, Plane>::collide;
527  collision_matrix[BV_KDOP24][GEOM_HALFSPACE] =
528  &BVHShapeCollider<KDOP<24>, Halfspace>::collide;
529  collision_matrix[BV_KDOP24][GEOM_ELLIPSOID] =
530  &BVHShapeCollider<KDOP<24>, Ellipsoid>::collide;
531 
532  collision_matrix[BV_kIOS][GEOM_BOX] = &BVHShapeCollider<kIOS, Box>::collide;
533  collision_matrix[BV_kIOS][GEOM_SPHERE] =
534  &BVHShapeCollider<kIOS, Sphere>::collide;
535  collision_matrix[BV_kIOS][GEOM_CAPSULE] =
536  &BVHShapeCollider<kIOS, Capsule>::collide;
537  collision_matrix[BV_kIOS][GEOM_CONE] = &BVHShapeCollider<kIOS, Cone>::collide;
538  collision_matrix[BV_kIOS][GEOM_CYLINDER] =
539  &BVHShapeCollider<kIOS, Cylinder>::collide;
540  collision_matrix[BV_kIOS][GEOM_CONVEX] =
541  &BVHShapeCollider<kIOS, ConvexBase>::collide;
542  collision_matrix[BV_kIOS][GEOM_PLANE] =
543  &BVHShapeCollider<kIOS, Plane>::collide;
544  collision_matrix[BV_kIOS][GEOM_HALFSPACE] =
545  &BVHShapeCollider<kIOS, Halfspace>::collide;
546  collision_matrix[BV_kIOS][GEOM_ELLIPSOID] =
547  &BVHShapeCollider<kIOS, Ellipsoid>::collide;
548 
549  collision_matrix[BV_OBBRSS][GEOM_BOX] =
550  &BVHShapeCollider<OBBRSS, Box>::collide;
551  collision_matrix[BV_OBBRSS][GEOM_SPHERE] =
552  &BVHShapeCollider<OBBRSS, Sphere>::collide;
553  collision_matrix[BV_OBBRSS][GEOM_CAPSULE] =
554  &BVHShapeCollider<OBBRSS, Capsule>::collide;
555  collision_matrix[BV_OBBRSS][GEOM_CONE] =
556  &BVHShapeCollider<OBBRSS, Cone>::collide;
557  collision_matrix[BV_OBBRSS][GEOM_CYLINDER] =
558  &BVHShapeCollider<OBBRSS, Cylinder>::collide;
559  collision_matrix[BV_OBBRSS][GEOM_CONVEX] =
560  &BVHShapeCollider<OBBRSS, ConvexBase>::collide;
561  collision_matrix[BV_OBBRSS][GEOM_PLANE] =
562  &BVHShapeCollider<OBBRSS, Plane>::collide;
563  collision_matrix[BV_OBBRSS][GEOM_HALFSPACE] =
564  &BVHShapeCollider<OBBRSS, Halfspace>::collide;
565  collision_matrix[BV_OBBRSS][GEOM_ELLIPSOID] =
566  &BVHShapeCollider<OBBRSS, Ellipsoid>::collide;
567 
568  collision_matrix[HF_AABB][GEOM_BOX] =
569  &HeightFieldShapeCollider<AABB, Box>::collide;
570  collision_matrix[HF_AABB][GEOM_SPHERE] =
571  &HeightFieldShapeCollider<AABB, Sphere>::collide;
572  collision_matrix[HF_AABB][GEOM_CAPSULE] =
573  &HeightFieldShapeCollider<AABB, Capsule>::collide;
574  collision_matrix[HF_AABB][GEOM_CONE] =
575  &HeightFieldShapeCollider<AABB, Cone>::collide;
576  collision_matrix[HF_AABB][GEOM_CYLINDER] =
577  &HeightFieldShapeCollider<AABB, Cylinder>::collide;
578  collision_matrix[HF_AABB][GEOM_CONVEX] =
579  &HeightFieldShapeCollider<AABB, ConvexBase>::collide;
580  collision_matrix[HF_AABB][GEOM_PLANE] =
581  &HeightFieldShapeCollider<AABB, Plane>::collide;
582  collision_matrix[HF_AABB][GEOM_HALFSPACE] =
583  &HeightFieldShapeCollider<AABB, Halfspace>::collide;
584  collision_matrix[HF_AABB][GEOM_ELLIPSOID] =
585  &HeightFieldShapeCollider<AABB, Ellipsoid>::collide;
586 
587  collision_matrix[HF_OBBRSS][GEOM_BOX] =
588  &HeightFieldShapeCollider<OBBRSS, Box>::collide;
589  collision_matrix[HF_OBBRSS][GEOM_SPHERE] =
590  &HeightFieldShapeCollider<OBBRSS, Sphere>::collide;
591  collision_matrix[HF_OBBRSS][GEOM_CAPSULE] =
592  &HeightFieldShapeCollider<OBBRSS, Capsule>::collide;
593  collision_matrix[HF_OBBRSS][GEOM_CONE] =
594  &HeightFieldShapeCollider<OBBRSS, Cone>::collide;
595  collision_matrix[HF_OBBRSS][GEOM_CYLINDER] =
596  &HeightFieldShapeCollider<OBBRSS, Cylinder>::collide;
597  collision_matrix[HF_OBBRSS][GEOM_CONVEX] =
598  &HeightFieldShapeCollider<OBBRSS, ConvexBase>::collide;
599  collision_matrix[HF_OBBRSS][GEOM_PLANE] =
600  &HeightFieldShapeCollider<OBBRSS, Plane>::collide;
601  collision_matrix[HF_OBBRSS][GEOM_HALFSPACE] =
602  &HeightFieldShapeCollider<OBBRSS, Halfspace>::collide;
603  collision_matrix[HF_OBBRSS][GEOM_ELLIPSOID] =
604  &HeightFieldShapeCollider<OBBRSS, Ellipsoid>::collide;
605 
606  collision_matrix[BV_AABB][BV_AABB] = &BVHCollide<AABB>;
607  collision_matrix[BV_OBB][BV_OBB] = &BVHCollide<OBB>;
608  collision_matrix[BV_RSS][BV_RSS] = &BVHCollide<RSS>;
609  collision_matrix[BV_KDOP16][BV_KDOP16] = &BVHCollide<KDOP<16> >;
610  collision_matrix[BV_KDOP18][BV_KDOP18] = &BVHCollide<KDOP<18> >;
611  collision_matrix[BV_KDOP24][BV_KDOP24] = &BVHCollide<KDOP<24> >;
612  collision_matrix[BV_kIOS][BV_kIOS] = &BVHCollide<kIOS>;
613  collision_matrix[BV_OBBRSS][BV_OBBRSS] = &BVHCollide<OBBRSS>;
614 
615 #ifdef HPP_FCL_HAS_OCTOMAP
616  collision_matrix[GEOM_OCTREE][GEOM_BOX] = &OctreeCollide<OcTree, Box>;
617  collision_matrix[GEOM_OCTREE][GEOM_SPHERE] = &OctreeCollide<OcTree, Sphere>;
618  collision_matrix[GEOM_OCTREE][GEOM_CAPSULE] = &OctreeCollide<OcTree, Capsule>;
619  collision_matrix[GEOM_OCTREE][GEOM_CONE] = &OctreeCollide<OcTree, Cone>;
620  collision_matrix[GEOM_OCTREE][GEOM_CYLINDER] =
621  &OctreeCollide<OcTree, Cylinder>;
622  collision_matrix[GEOM_OCTREE][GEOM_CONVEX] =
623  &OctreeCollide<OcTree, ConvexBase>;
624  collision_matrix[GEOM_OCTREE][GEOM_PLANE] = &OctreeCollide<OcTree, Plane>;
625  collision_matrix[GEOM_OCTREE][GEOM_HALFSPACE] =
626  &OctreeCollide<OcTree, Halfspace>;
627  collision_matrix[GEOM_OCTREE][GEOM_ELLIPSOID] =
628  &OctreeCollide<OcTree, Ellipsoid>;
629 
630  collision_matrix[GEOM_BOX][GEOM_OCTREE] = &OctreeCollide<Box, OcTree>;
631  collision_matrix[GEOM_SPHERE][GEOM_OCTREE] = &OctreeCollide<Sphere, OcTree>;
632  collision_matrix[GEOM_CAPSULE][GEOM_OCTREE] = &OctreeCollide<Capsule, OcTree>;
633  collision_matrix[GEOM_CONE][GEOM_OCTREE] = &OctreeCollide<Cone, OcTree>;
634  collision_matrix[GEOM_CYLINDER][GEOM_OCTREE] =
635  &OctreeCollide<Cylinder, OcTree>;
636  collision_matrix[GEOM_CONVEX][GEOM_OCTREE] =
637  &OctreeCollide<ConvexBase, OcTree>;
638  collision_matrix[GEOM_PLANE][GEOM_OCTREE] = &OctreeCollide<Plane, OcTree>;
639  collision_matrix[GEOM_HALFSPACE][GEOM_OCTREE] =
640  &OctreeCollide<Halfspace, OcTree>;
641 
642  collision_matrix[GEOM_OCTREE][GEOM_OCTREE] = &OctreeCollide<OcTree, OcTree>;
643 
644  collision_matrix[GEOM_OCTREE][BV_AABB] =
645  &OctreeCollide<OcTree, BVHModel<AABB> >;
646  collision_matrix[GEOM_OCTREE][BV_OBB] =
647  &OctreeCollide<OcTree, BVHModel<OBB> >;
648  collision_matrix[GEOM_OCTREE][BV_RSS] =
649  &OctreeCollide<OcTree, BVHModel<RSS> >;
650  collision_matrix[GEOM_OCTREE][BV_OBBRSS] =
651  &OctreeCollide<OcTree, BVHModel<OBBRSS> >;
652  collision_matrix[GEOM_OCTREE][BV_kIOS] =
653  &OctreeCollide<OcTree, BVHModel<kIOS> >;
654  collision_matrix[GEOM_OCTREE][BV_KDOP16] =
655  &OctreeCollide<OcTree, BVHModel<KDOP<16> > >;
656  collision_matrix[GEOM_OCTREE][BV_KDOP18] =
657  &OctreeCollide<OcTree, BVHModel<KDOP<18> > >;
658  collision_matrix[GEOM_OCTREE][BV_KDOP24] =
659  &OctreeCollide<OcTree, BVHModel<KDOP<24> > >;
660 
661  collision_matrix[BV_AABB][GEOM_OCTREE] =
662  &OctreeCollide<BVHModel<AABB>, OcTree>;
663  collision_matrix[BV_OBB][GEOM_OCTREE] = &OctreeCollide<BVHModel<OBB>, OcTree>;
664  collision_matrix[BV_RSS][GEOM_OCTREE] = &OctreeCollide<BVHModel<RSS>, OcTree>;
665  collision_matrix[BV_OBBRSS][GEOM_OCTREE] =
666  &OctreeCollide<BVHModel<OBBRSS>, OcTree>;
667  collision_matrix[BV_kIOS][GEOM_OCTREE] =
668  &OctreeCollide<BVHModel<kIOS>, OcTree>;
669  collision_matrix[BV_KDOP16][GEOM_OCTREE] =
670  &OctreeCollide<BVHModel<KDOP<16> >, OcTree>;
671  collision_matrix[BV_KDOP18][GEOM_OCTREE] =
672  &OctreeCollide<BVHModel<KDOP<18> >, OcTree>;
673  collision_matrix[BV_KDOP24][GEOM_OCTREE] =
674  &OctreeCollide<BVHModel<KDOP<24> >, OcTree>;
675 #endif
676 }
677 // template struct CollisionFunctionMatrix;
678 } // namespace fcl
679 
680 } // namespace hpp
hpp::fcl::GEOM_BOX
Definition: collision_object.h:75
hpp::fcl::Transform3f
Simple transform class used locally by InterpMotion.
Definition: transform.h:54
traversal_node_setup.h
hpp::fcl::Ellipsoid
Ellipsoid centered at point zero.
Definition: shape/geometric_shapes.h:258
hpp::fcl::BVHCollide< kIOS >
std::size_t BVHCollide< kIOS >(const CollisionGeometry *o1, const Transform3f &tf1, const CollisionGeometry *o2, const Transform3f &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:258
hpp::fcl::BV_OBBRSS
Definition: collision_object.h:71
hpp::fcl::details::BVH_SHAPE_DEFAULT_TO_ORIENTED
BVH_SHAPE_DEFAULT_TO_ORIENTED(OBB)
hpp::fcl::GEOM_CONE
Definition: collision_object.h:78
hpp::fcl::Cylinder
Cylinder along Z axis. The cylinder is defined at its centroid.
Definition: shape/geometric_shapes.h:501
hpp
Main namespace.
Definition: broadphase_bruteforce.h:44
collision_func_matrix.h
gjk.tf2
tuple tf2
Definition: test/scripts/gjk.py:37
initialize
bool initialize(MeshCollisionTraversalNode< BV, RelativeTransformationIsIdentity > &node, BVHModel< BV > &model1, Transform3f &tf1, BVHModel< BV > &model2, Transform3f &tf2, CollisionResult &result, bool use_refit=false, bool refit_bottomup=false)
Initialize traversal node for collision between two meshes, given the current transforms.
Definition: traversal_node_setup.h:423
hpp::fcl::Halfspace
Half Space: this is equivalent to the Plane in ODE. The separation plane is defined as n * x = d; Poi...
Definition: shape/geometric_shapes.h:729
hpp::fcl::BVHShapeCollider::aligned
static std::size_t aligned(const CollisionGeometry *o1, const Transform3f &tf1, const CollisionGeometry *o2, const Transform3f &tf2, const GJKSolver *nsolver, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:122
hpp::fcl::CollisionResult::numContacts
size_t numContacts() const
number of contacts found
Definition: collision_data.h:342
shape_shape_func.h
hpp::fcl::GEOM_OCTREE
Definition: collision_object.h:84
hpp::fcl::BV_RSS
Definition: collision_object.h:69
hpp::fcl::CollisionRequest::isSatisfied
bool isSatisfied(const CollisionResult &result) const
Definition: collision_data.cpp:43
hpp::fcl::BV_AABB
Definition: collision_object.h:67
hpp::fcl::HeightField
Data structure depicting a height field given by the base grid dimensions and the elevation along the...
Definition: hfield.h:182
hpp::fcl::HF_AABB
Definition: collision_object.h:86
hpp::fcl::OcTree
Octree is one type of collision geometry which can encode uncertainty information in the sensor data...
Definition: octree.h:53
hpp::fcl::GEOM_HALFSPACE
Definition: collision_object.h:82
hpp::fcl::BVHCollide
std::size_t BVHCollide(const CollisionGeometry *o1, const Transform3f &tf1, const CollisionGeometry *o2, const Transform3f &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:214
hpp::fcl::CollisionRequest
request to the collision algorithm
Definition: collision_data.h:235
hpp::fcl::BV_KDOP16
Definition: collision_object.h:72
hpp::fcl::Box
Center at zero point, axis aligned box.
Definition: shape/geometric_shapes.h:125
hpp::fcl::HF_OBBRSS
Definition: collision_object.h:87
hpp::fcl::HeightFieldShapeCollider::collide
static std::size_t collide(const CollisionGeometry *o1, const Transform3f &tf1, const CollisionGeometry *o2, const Transform3f &tf2, const GJKSolver *nsolver, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:172
hpp::fcl::BVHShapeCollider::collide
static std::size_t collide(const CollisionGeometry *o1, const Transform3f &tf1, const CollisionGeometry *o2, const Transform3f &tf2, const GJKSolver *nsolver, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:103
hpp::fcl::BVHModel
A class describing the bounding hierarchy of a mesh model or a point cloud model (which is viewed as ...
Definition: BVH/BVH_model.h:273
hpp::fcl::Cone
Cone The base of the cone is at and the top is at .
Definition: shape/geometric_shapes.h:414
hpp::fcl::BV_kIOS
Definition: collision_object.h:70
hpp::fcl::BVHCollide< OBB >
std::size_t BVHCollide< OBB >(const CollisionGeometry *o1, const Transform3f &tf1, const CollisionGeometry *o2, const Transform3f &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:238
hpp::fcl::Sphere
Center at zero point sphere.
Definition: shape/geometric_shapes.h:196
hpp::fcl::Capsule
Capsule It is where is the distance between the point x and the capsule segment AB...
Definition: shape/geometric_shapes.h:333
hpp::fcl::BV_KDOP18
Definition: collision_object.h:73
hpp::fcl::GEOM_SPHERE
Definition: collision_object.h:76
hpp::fcl::details::bvh_shape_traits
Definition: collision_func_matrix.cpp:81
hpp::fcl::ConvexBase
Base for convex polytope.
Definition: shape/geometric_shapes.h:581
hpp::fcl::GEOM_ELLIPSOID
Definition: collision_object.h:85
hpp::fcl::details::orientedMeshCollide
std::size_t orientedMeshCollide(const CollisionGeometry *o1, const Transform3f &tf1, const CollisionGeometry *o2, const Transform3f &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:193
hpp::fcl::collide
HPP_FCL_DLLAPI std::size_t collide(const CollisionObject *o1, const CollisionObject *o2, const CollisionRequest &request, CollisionResult &result)
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.
Definition: src/collision.cpp:63
hpp::fcl::GEOM_CYLINDER
Definition: collision_object.h:79
geometric_shapes_traits.h
hpp::fcl::NODE_COUNT
Definition: collision_object.h:88
hpp::fcl::BVHShapeCollider::oriented
static std::size_t oriented(const CollisionGeometry *o1, const Transform3f &tf1, const CollisionGeometry *o2, const Transform3f &tf2, const GJKSolver *nsolver, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:145
hpp::fcl::GJKSolver
collision and distance solver based on GJK algorithm implemented in fcl (rewritten the code from the ...
Definition: narrowphase.h:54
hpp::fcl::BV_OBB
Definition: collision_object.h:68
hpp::fcl::BVHCollide< OBBRSS >
std::size_t BVHCollide< OBBRSS >(const CollisionGeometry *o1, const Transform3f &tf1, const CollisionGeometry *o2, const Transform3f &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:247
hpp::fcl::CollisionGeometry
The geometry for the object for collision or distance computation.
Definition: collision_object.h:95
hpp::fcl::HeightFieldShapeCollider
Collider functor for HeightField data structure.
Definition: collision_func_matrix.cpp:169
hpp::fcl::GEOM_PLANE
Definition: collision_object.h:81
hpp::fcl::GEOM_CONVEX
Definition: collision_object.h:80
hpp::fcl::GEOM_CAPSULE
Definition: collision_object.h:77
gjk.tf1
tuple tf1
Definition: test/scripts/gjk.py:28
HPP_FCL_THROW_PRETTY
#define HPP_FCL_THROW_PRETTY(message, exception)
Definition: include/hpp/fcl/fwd.hh:57
hpp::fcl::CollisionRequest::security_margin
FCL_REAL security_margin
Distance below which objects are considered in collision. See Collision.
Definition: collision_data.h:251
hpp::fcl::BV_KDOP24
Definition: collision_object.h:74
hpp::fcl::details::bvh_shape_traits::Options
Definition: collision_func_matrix.cpp:82

hpp-fcl
Author(s):
autogenerated on Fri Jun 2 2023 02:39:00