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 "coal/collision_func_matrix.h"
39 
40 #include "coal/internal/traversal_node_setup.h"
41 #include <../src/collision_node.h>
42 #include "coal/narrowphase/narrowphase.h"
43 #include "coal/internal/shape_shape_func.h"
44 #include "coal/shape/geometric_shapes_traits.h"
45 #include <../src/traits_traversal.h>
46 
47 namespace coal {
48 
49 #ifdef COAL_HAS_OCTOMAP
50 
51 template <typename TypeA, typename TypeB>
52 std::size_t OctreeCollide(const CollisionGeometry* o1, const Transform3s& tf1,
53  const CollisionGeometry* o2, const Transform3s& tf2,
54  const GJKSolver* nsolver,
55  const CollisionRequest& request,
56  CollisionResult& result) {
57  if (request.isSatisfied(result)) return result.numContacts();
58 
59  if (request.security_margin < 0)
60  COAL_THROW_PRETTY("Negative security margin are not handled yet for Octree",
61  std::invalid_argument);
62 
63  typename TraversalTraitsCollision<TypeA, TypeB>::CollisionTraversal_t node(
64  request);
65  const TypeA* obj1 = dynamic_cast<const TypeA*>(o1);
66  const TypeB* obj2 = dynamic_cast<const TypeB*>(o2);
67  OcTreeSolver otsolver(nsolver);
68 
69  initialize(node, *obj1, tf1, *obj2, tf2, &otsolver, result);
70  collide(&node, request, result);
71 
72  return result.numContacts();
73 }
74 
75 #endif
76 
77 namespace details {
78 template <typename T_BVH, typename T_SH>
79 struct bvh_shape_traits {
80  enum { Options = RelativeTransformationIsIdentity };
81 };
82 #define BVH_SHAPE_DEFAULT_TO_ORIENTED(bv) \
83  template <typename T_SH> \
84  struct bvh_shape_traits<bv, T_SH> { \
85  enum { Options = 0 }; \
86  }
87 BVH_SHAPE_DEFAULT_TO_ORIENTED(OBB);
88 BVH_SHAPE_DEFAULT_TO_ORIENTED(RSS);
89 BVH_SHAPE_DEFAULT_TO_ORIENTED(kIOS);
90 BVH_SHAPE_DEFAULT_TO_ORIENTED(OBBRSS);
91 #undef BVH_SHAPE_DEFAULT_TO_ORIENTED
92 } // namespace details
93 
98 template <typename T_BVH, typename T_SH,
99  int _Options = details::bvh_shape_traits<T_BVH, T_SH>::Options>
100 struct COAL_LOCAL BVHShapeCollider{static std::size_t collide(
101  const CollisionGeometry* o1, const Transform3s& tf1,
102  const CollisionGeometry* o2, const Transform3s& tf2,
103  const GJKSolver* nsolver, const CollisionRequest& request,
104  CollisionResult& result){
105  if (request.isSatisfied(result)) return result.numContacts();
106 
107 if (request.security_margin < 0)
108  COAL_THROW_PRETTY("Negative security margin are not handled yet for BVHModel",
109  std::invalid_argument);
110 
111 if (_Options & RelativeTransformationIsIdentity)
112  return aligned(o1, tf1, o2, tf2, nsolver, request, result);
113 else
114  return oriented(o1, tf1, o2, tf2, nsolver, request, result);
115 } // namespace coal
116 
117 static std::size_t aligned(const CollisionGeometry* o1, const Transform3s& tf1,
118  const CollisionGeometry* o2, const Transform3s& tf2,
119  const GJKSolver* nsolver,
120  const CollisionRequest& request,
121  CollisionResult& result) {
122  if (request.isSatisfied(result)) return result.numContacts();
123 
124  MeshShapeCollisionTraversalNode<T_BVH, T_SH, RelativeTransformationIsIdentity>
125  node(request);
126  const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
127  BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
128  Transform3s tf1_tmp = tf1;
129  const T_SH* obj2 = static_cast<const T_SH*>(o2);
130 
131  initialize(node, *obj1_tmp, tf1_tmp, *obj2, tf2, nsolver, result);
132  coal::collide(&node, request, result);
133 
134  delete obj1_tmp;
135  return result.numContacts();
136 }
137 
138 static std::size_t oriented(const CollisionGeometry* o1, const Transform3s& tf1,
139  const CollisionGeometry* o2, const Transform3s& tf2,
140  const GJKSolver* nsolver,
141  const CollisionRequest& request,
142  CollisionResult& result) {
143  if (request.isSatisfied(result)) return result.numContacts();
144 
145  MeshShapeCollisionTraversalNode<T_BVH, T_SH, 0> node(request);
146  const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
147  const T_SH* obj2 = static_cast<const T_SH*>(o2);
148 
149  initialize(node, *obj1, tf1, *obj2, tf2, nsolver, result);
150  coal::collide(&node, request, result);
151  return result.numContacts();
152 }
153 }
154 ;
155 
161 template <typename BV, typename Shape>
162 struct COAL_LOCAL HeightFieldShapeCollider {
163  typedef HeightField<BV> HF;
164 
165  static std::size_t collide(const CollisionGeometry* o1,
166  const Transform3s& tf1,
167  const CollisionGeometry* o2,
168  const Transform3s& tf2, const GJKSolver* nsolver,
169  const CollisionRequest& request,
170  CollisionResult& result) {
171  if (request.isSatisfied(result)) return result.numContacts();
172 
173  const HF& height_field = static_cast<const HF&>(*o1);
174  const Shape& shape = static_cast<const Shape&>(*o2);
175 
176  HeightFieldShapeCollisionTraversalNode<BV, Shape, 0> node(request);
177 
178  initialize(node, height_field, tf1, shape, tf2, nsolver, result);
179  coal::collide(&node, request, result);
180  return result.numContacts();
181  }
182 };
183 
184 namespace details {
185 template <typename OrientedMeshCollisionTraversalNode, typename T_BVH>
186 std::size_t orientedMeshCollide(const CollisionGeometry* o1,
187  const Transform3s& tf1,
188  const CollisionGeometry* o2,
189  const Transform3s& tf2,
190  const CollisionRequest& request,
191  CollisionResult& result) {
192  if (request.isSatisfied(result)) return result.numContacts();
193 
194  OrientedMeshCollisionTraversalNode node(request);
195  const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
196  const BVHModel<T_BVH>* obj2 = static_cast<const BVHModel<T_BVH>*>(o2);
197 
198  initialize(node, *obj1, tf1, *obj2, tf2, result);
199  collide(&node, request, result);
200 
201  return result.numContacts();
202 }
203 
204 } // namespace details
205 
206 template <typename T_BVH>
207 std::size_t BVHCollide(const CollisionGeometry* o1, const Transform3s& tf1,
208  const CollisionGeometry* o2, const Transform3s& tf2,
209  const CollisionRequest& request,
210  CollisionResult& result) {
211  if (request.isSatisfied(result)) return result.numContacts();
212 
213  // TODO(louis): each time we call collide on BVH-BVH, we:
214  // - Allocate 2 new BVHs
215  // - Copy and transform the vertices in both BVHs so that they are in the
216  // same frame
217  // - Recompute BVs of the BVH structure
218  // -> all that just to avoid doing (a few) rotations/translations of AABBs.
219  // Is it really worth it?
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  Transform3s tf1_tmp = tf1;
225  BVHModel<T_BVH>* obj2_tmp = new BVHModel<T_BVH>(*obj2);
226  Transform3s tf2_tmp = tf2;
227 
228  initialize(node, *obj1_tmp, tf1_tmp, *obj2_tmp, tf2_tmp, result);
229  coal::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 Transform3s& tf1,
239  const CollisionGeometry* o2, const Transform3s& 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 Transform3s& tf1,
249  const CollisionGeometry* o2,
250  const Transform3s& 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 Transform3s& tf1,
260  const CollisionGeometry* o2,
261  const Transform3s& 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 Transform3s& tf1,
270  const CollisionGeometry* o2, const Transform3s& 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  collision_matrix[GEOM_BOX][GEOM_TRIANGLE] =
294  &ShapeShapeCollide<Box, TriangleP>;
295 
296  collision_matrix[GEOM_SPHERE][GEOM_BOX] = &ShapeShapeCollide<Sphere, Box>;
297  collision_matrix[GEOM_SPHERE][GEOM_SPHERE] =
298  &ShapeShapeCollide<Sphere, Sphere>;
299  collision_matrix[GEOM_SPHERE][GEOM_CAPSULE] =
300  &ShapeShapeCollide<Sphere, Capsule>;
301  collision_matrix[GEOM_SPHERE][GEOM_CONE] = &ShapeShapeCollide<Sphere, Cone>;
302  collision_matrix[GEOM_SPHERE][GEOM_CYLINDER] =
303  &ShapeShapeCollide<Sphere, Cylinder>;
304  collision_matrix[GEOM_SPHERE][GEOM_CONVEX] =
305  &ShapeShapeCollide<Sphere, ConvexBase>;
306  collision_matrix[GEOM_SPHERE][GEOM_PLANE] = &ShapeShapeCollide<Sphere, Plane>;
307  collision_matrix[GEOM_SPHERE][GEOM_HALFSPACE] =
308  &ShapeShapeCollide<Sphere, Halfspace>;
309  collision_matrix[GEOM_SPHERE][GEOM_ELLIPSOID] =
310  &ShapeShapeCollide<Sphere, Ellipsoid>;
311  collision_matrix[GEOM_SPHERE][GEOM_TRIANGLE] =
312  &ShapeShapeCollide<Sphere, TriangleP>;
313 
314  collision_matrix[GEOM_ELLIPSOID][GEOM_BOX] =
315  &ShapeShapeCollide<Ellipsoid, Box>;
316  collision_matrix[GEOM_ELLIPSOID][GEOM_SPHERE] =
317  &ShapeShapeCollide<Ellipsoid, Sphere>;
318  collision_matrix[GEOM_ELLIPSOID][GEOM_CAPSULE] =
319  &ShapeShapeCollide<Ellipsoid, Capsule>;
320  collision_matrix[GEOM_ELLIPSOID][GEOM_CONE] =
321  &ShapeShapeCollide<Ellipsoid, Cone>;
322  collision_matrix[GEOM_ELLIPSOID][GEOM_CYLINDER] =
323  &ShapeShapeCollide<Ellipsoid, Cylinder>;
324  collision_matrix[GEOM_ELLIPSOID][GEOM_CONVEX] =
325  &ShapeShapeCollide<Ellipsoid, ConvexBase>;
326  collision_matrix[GEOM_ELLIPSOID][GEOM_PLANE] =
327  &ShapeShapeCollide<Ellipsoid, Plane>;
328  collision_matrix[GEOM_ELLIPSOID][GEOM_HALFSPACE] =
329  &ShapeShapeCollide<Ellipsoid, Halfspace>;
330  collision_matrix[GEOM_ELLIPSOID][GEOM_ELLIPSOID] =
331  &ShapeShapeCollide<Ellipsoid, Ellipsoid>;
332  collision_matrix[GEOM_ELLIPSOID][GEOM_TRIANGLE] =
333  &ShapeShapeCollide<Ellipsoid, TriangleP>;
334 
335  collision_matrix[GEOM_CAPSULE][GEOM_BOX] = &ShapeShapeCollide<Capsule, Box>;
336  collision_matrix[GEOM_CAPSULE][GEOM_SPHERE] =
337  &ShapeShapeCollide<Capsule, Sphere>;
338  collision_matrix[GEOM_CAPSULE][GEOM_CAPSULE] =
339  &ShapeShapeCollide<Capsule, Capsule>;
340  collision_matrix[GEOM_CAPSULE][GEOM_CONE] = &ShapeShapeCollide<Capsule, Cone>;
341  collision_matrix[GEOM_CAPSULE][GEOM_CYLINDER] =
342  &ShapeShapeCollide<Capsule, Cylinder>;
343  collision_matrix[GEOM_CAPSULE][GEOM_CONVEX] =
344  &ShapeShapeCollide<Capsule, ConvexBase>;
345  collision_matrix[GEOM_CAPSULE][GEOM_PLANE] =
346  &ShapeShapeCollide<Capsule, Plane>;
347  collision_matrix[GEOM_CAPSULE][GEOM_HALFSPACE] =
348  &ShapeShapeCollide<Capsule, Halfspace>;
349  collision_matrix[GEOM_CAPSULE][GEOM_ELLIPSOID] =
350  &ShapeShapeCollide<Capsule, Ellipsoid>;
351  collision_matrix[GEOM_CAPSULE][GEOM_TRIANGLE] =
352  &ShapeShapeCollide<Capsule, TriangleP>;
353 
354  collision_matrix[GEOM_CONE][GEOM_BOX] = &ShapeShapeCollide<Cone, Box>;
355  collision_matrix[GEOM_CONE][GEOM_SPHERE] = &ShapeShapeCollide<Cone, Sphere>;
356  collision_matrix[GEOM_CONE][GEOM_CAPSULE] = &ShapeShapeCollide<Cone, Capsule>;
357  collision_matrix[GEOM_CONE][GEOM_CONE] = &ShapeShapeCollide<Cone, Cone>;
358  collision_matrix[GEOM_CONE][GEOM_CYLINDER] =
359  &ShapeShapeCollide<Cone, Cylinder>;
360  collision_matrix[GEOM_CONE][GEOM_CONVEX] =
361  &ShapeShapeCollide<Cone, ConvexBase>;
362  collision_matrix[GEOM_CONE][GEOM_PLANE] = &ShapeShapeCollide<Cone, Plane>;
363  collision_matrix[GEOM_CONE][GEOM_HALFSPACE] =
364  &ShapeShapeCollide<Cone, Halfspace>;
365  collision_matrix[GEOM_CONE][GEOM_ELLIPSOID] =
366  &ShapeShapeCollide<Cone, Ellipsoid>;
367  collision_matrix[GEOM_CONE][GEOM_TRIANGLE] =
368  &ShapeShapeCollide<Cone, TriangleP>;
369 
370  collision_matrix[GEOM_CYLINDER][GEOM_BOX] = &ShapeShapeCollide<Cylinder, Box>;
371  collision_matrix[GEOM_CYLINDER][GEOM_SPHERE] =
372  &ShapeShapeCollide<Cylinder, Sphere>;
373  collision_matrix[GEOM_CYLINDER][GEOM_CAPSULE] =
374  &ShapeShapeCollide<Cylinder, Capsule>;
375  collision_matrix[GEOM_CYLINDER][GEOM_CONE] =
376  &ShapeShapeCollide<Cylinder, Cone>;
377  collision_matrix[GEOM_CYLINDER][GEOM_CYLINDER] =
378  &ShapeShapeCollide<Cylinder, Cylinder>;
379  collision_matrix[GEOM_CYLINDER][GEOM_CONVEX] =
380  &ShapeShapeCollide<Cylinder, ConvexBase>;
381  collision_matrix[GEOM_CYLINDER][GEOM_PLANE] =
382  &ShapeShapeCollide<Cylinder, Plane>;
383  collision_matrix[GEOM_CYLINDER][GEOM_HALFSPACE] =
384  &ShapeShapeCollide<Cylinder, Halfspace>;
385  collision_matrix[GEOM_CYLINDER][GEOM_ELLIPSOID] =
386  &ShapeShapeCollide<Cylinder, Ellipsoid>;
387  collision_matrix[GEOM_CYLINDER][GEOM_TRIANGLE] =
388  &ShapeShapeCollide<Cylinder, TriangleP>;
389 
390  collision_matrix[GEOM_CONVEX][GEOM_BOX] = &ShapeShapeCollide<ConvexBase, Box>;
391  collision_matrix[GEOM_CONVEX][GEOM_SPHERE] =
392  &ShapeShapeCollide<ConvexBase, Sphere>;
393  collision_matrix[GEOM_CONVEX][GEOM_CAPSULE] =
394  &ShapeShapeCollide<ConvexBase, Capsule>;
395  collision_matrix[GEOM_CONVEX][GEOM_CONE] =
396  &ShapeShapeCollide<ConvexBase, Cone>;
397  collision_matrix[GEOM_CONVEX][GEOM_CYLINDER] =
398  &ShapeShapeCollide<ConvexBase, Cylinder>;
399  collision_matrix[GEOM_CONVEX][GEOM_CONVEX] =
400  &ShapeShapeCollide<ConvexBase, ConvexBase>;
401  collision_matrix[GEOM_CONVEX][GEOM_PLANE] =
402  &ShapeShapeCollide<ConvexBase, Plane>;
403  collision_matrix[GEOM_CONVEX][GEOM_HALFSPACE] =
404  &ShapeShapeCollide<ConvexBase, Halfspace>;
405  collision_matrix[GEOM_CONVEX][GEOM_ELLIPSOID] =
406  &ShapeShapeCollide<ConvexBase, Ellipsoid>;
407  collision_matrix[GEOM_CONVEX][GEOM_TRIANGLE] =
408  &ShapeShapeCollide<ConvexBase, TriangleP>;
409 
410  collision_matrix[GEOM_PLANE][GEOM_BOX] = &ShapeShapeCollide<Plane, Box>;
411  collision_matrix[GEOM_PLANE][GEOM_SPHERE] = &ShapeShapeCollide<Plane, Sphere>;
412  collision_matrix[GEOM_PLANE][GEOM_CAPSULE] =
413  &ShapeShapeCollide<Plane, Capsule>;
414  collision_matrix[GEOM_PLANE][GEOM_CONE] = &ShapeShapeCollide<Plane, Cone>;
415  collision_matrix[GEOM_PLANE][GEOM_CYLINDER] =
416  &ShapeShapeCollide<Plane, Cylinder>;
417  collision_matrix[GEOM_PLANE][GEOM_CONVEX] =
418  &ShapeShapeCollide<Plane, ConvexBase>;
419  collision_matrix[GEOM_PLANE][GEOM_PLANE] = &ShapeShapeCollide<Plane, Plane>;
420  collision_matrix[GEOM_PLANE][GEOM_HALFSPACE] =
421  &ShapeShapeCollide<Plane, Halfspace>;
422  collision_matrix[GEOM_PLANE][GEOM_ELLIPSOID] =
423  &ShapeShapeCollide<Plane, Ellipsoid>;
424  collision_matrix[GEOM_PLANE][GEOM_TRIANGLE] =
425  &ShapeShapeCollide<Plane, TriangleP>;
426 
427  collision_matrix[GEOM_HALFSPACE][GEOM_BOX] =
428  &ShapeShapeCollide<Halfspace, Box>;
429  collision_matrix[GEOM_HALFSPACE][GEOM_SPHERE] =
430  &ShapeShapeCollide<Halfspace, Sphere>;
431  collision_matrix[GEOM_HALFSPACE][GEOM_CAPSULE] =
432  &ShapeShapeCollide<Halfspace, Capsule>;
433  collision_matrix[GEOM_HALFSPACE][GEOM_CONE] =
434  &ShapeShapeCollide<Halfspace, Cone>;
435  collision_matrix[GEOM_HALFSPACE][GEOM_CYLINDER] =
436  &ShapeShapeCollide<Halfspace, Cylinder>;
437  collision_matrix[GEOM_HALFSPACE][GEOM_CONVEX] =
438  &ShapeShapeCollide<Halfspace, ConvexBase>;
439  collision_matrix[GEOM_HALFSPACE][GEOM_PLANE] =
440  &ShapeShapeCollide<Halfspace, Plane>;
441  collision_matrix[GEOM_HALFSPACE][GEOM_HALFSPACE] =
442  &ShapeShapeCollide<Halfspace, Halfspace>;
443  collision_matrix[GEOM_HALFSPACE][GEOM_ELLIPSOID] =
444  &ShapeShapeCollide<Halfspace, Ellipsoid>;
445  collision_matrix[GEOM_HALFSPACE][GEOM_TRIANGLE] =
446  &ShapeShapeCollide<Halfspace, TriangleP>;
447 
448  collision_matrix[GEOM_TRIANGLE][GEOM_BOX] =
449  &ShapeShapeCollide<TriangleP, Box>;
450  collision_matrix[GEOM_TRIANGLE][GEOM_SPHERE] =
451  &ShapeShapeCollide<TriangleP, Sphere>;
452  collision_matrix[GEOM_TRIANGLE][GEOM_CAPSULE] =
453  &ShapeShapeCollide<TriangleP, Capsule>;
454  collision_matrix[GEOM_TRIANGLE][GEOM_CONE] =
455  &ShapeShapeCollide<TriangleP, Cone>;
456  collision_matrix[GEOM_TRIANGLE][GEOM_CYLINDER] =
457  &ShapeShapeCollide<TriangleP, Cylinder>;
458  collision_matrix[GEOM_TRIANGLE][GEOM_CONVEX] =
459  &ShapeShapeCollide<TriangleP, ConvexBase>;
460  collision_matrix[GEOM_TRIANGLE][GEOM_PLANE] =
461  &ShapeShapeCollide<TriangleP, Plane>;
462  collision_matrix[GEOM_TRIANGLE][GEOM_HALFSPACE] =
463  &ShapeShapeCollide<TriangleP, Halfspace>;
464  collision_matrix[GEOM_TRIANGLE][GEOM_ELLIPSOID] =
465  &ShapeShapeCollide<TriangleP, Ellipsoid>;
466  collision_matrix[GEOM_TRIANGLE][GEOM_TRIANGLE] =
467  &ShapeShapeCollide<TriangleP, TriangleP>;
468 
469  collision_matrix[BV_AABB][GEOM_BOX] = &BVHShapeCollider<AABB, Box>::collide;
470  collision_matrix[BV_AABB][GEOM_SPHERE] =
471  &BVHShapeCollider<AABB, Sphere>::collide;
472  collision_matrix[BV_AABB][GEOM_CAPSULE] =
473  &BVHShapeCollider<AABB, Capsule>::collide;
474  collision_matrix[BV_AABB][GEOM_CONE] = &BVHShapeCollider<AABB, Cone>::collide;
475  collision_matrix[BV_AABB][GEOM_CYLINDER] =
476  &BVHShapeCollider<AABB, Cylinder>::collide;
477  collision_matrix[BV_AABB][GEOM_CONVEX] =
478  &BVHShapeCollider<AABB, ConvexBase>::collide;
479  collision_matrix[BV_AABB][GEOM_PLANE] =
480  &BVHShapeCollider<AABB, Plane>::collide;
481  collision_matrix[BV_AABB][GEOM_HALFSPACE] =
482  &BVHShapeCollider<AABB, Halfspace>::collide;
483  collision_matrix[BV_AABB][GEOM_ELLIPSOID] =
484  &BVHShapeCollider<AABB, Ellipsoid>::collide;
485 
486  collision_matrix[BV_OBB][GEOM_BOX] = &BVHShapeCollider<OBB, Box>::collide;
487  collision_matrix[BV_OBB][GEOM_SPHERE] =
488  &BVHShapeCollider<OBB, Sphere>::collide;
489  collision_matrix[BV_OBB][GEOM_CAPSULE] =
490  &BVHShapeCollider<OBB, Capsule>::collide;
491  collision_matrix[BV_OBB][GEOM_CONE] = &BVHShapeCollider<OBB, Cone>::collide;
492  collision_matrix[BV_OBB][GEOM_CYLINDER] =
493  &BVHShapeCollider<OBB, Cylinder>::collide;
494  collision_matrix[BV_OBB][GEOM_CONVEX] =
495  &BVHShapeCollider<OBB, ConvexBase>::collide;
496  collision_matrix[BV_OBB][GEOM_PLANE] = &BVHShapeCollider<OBB, Plane>::collide;
497  collision_matrix[BV_OBB][GEOM_HALFSPACE] =
498  &BVHShapeCollider<OBB, Halfspace>::collide;
499  collision_matrix[BV_OBB][GEOM_ELLIPSOID] =
500  &BVHShapeCollider<OBB, Ellipsoid>::collide;
501 
502  collision_matrix[BV_RSS][GEOM_BOX] = &BVHShapeCollider<RSS, Box>::collide;
503  collision_matrix[BV_RSS][GEOM_SPHERE] =
504  &BVHShapeCollider<RSS, Sphere>::collide;
505  collision_matrix[BV_RSS][GEOM_CAPSULE] =
506  &BVHShapeCollider<RSS, Capsule>::collide;
507  collision_matrix[BV_RSS][GEOM_CONE] = &BVHShapeCollider<RSS, Cone>::collide;
508  collision_matrix[BV_RSS][GEOM_CYLINDER] =
509  &BVHShapeCollider<RSS, Cylinder>::collide;
510  collision_matrix[BV_RSS][GEOM_CONVEX] =
511  &BVHShapeCollider<RSS, ConvexBase>::collide;
512  collision_matrix[BV_RSS][GEOM_PLANE] = &BVHShapeCollider<RSS, Plane>::collide;
513  collision_matrix[BV_RSS][GEOM_HALFSPACE] =
514  &BVHShapeCollider<RSS, Halfspace>::collide;
515  collision_matrix[BV_RSS][GEOM_ELLIPSOID] =
516  &BVHShapeCollider<RSS, Ellipsoid>::collide;
517 
518  collision_matrix[BV_KDOP16][GEOM_BOX] =
519  &BVHShapeCollider<KDOP<16>, Box>::collide;
520  collision_matrix[BV_KDOP16][GEOM_SPHERE] =
521  &BVHShapeCollider<KDOP<16>, Sphere>::collide;
522  collision_matrix[BV_KDOP16][GEOM_CAPSULE] =
523  &BVHShapeCollider<KDOP<16>, Capsule>::collide;
524  collision_matrix[BV_KDOP16][GEOM_CONE] =
525  &BVHShapeCollider<KDOP<16>, Cone>::collide;
526  collision_matrix[BV_KDOP16][GEOM_CYLINDER] =
527  &BVHShapeCollider<KDOP<16>, Cylinder>::collide;
528  collision_matrix[BV_KDOP16][GEOM_CONVEX] =
529  &BVHShapeCollider<KDOP<16>, ConvexBase>::collide;
530  collision_matrix[BV_KDOP16][GEOM_PLANE] =
531  &BVHShapeCollider<KDOP<16>, Plane>::collide;
532  collision_matrix[BV_KDOP16][GEOM_HALFSPACE] =
533  &BVHShapeCollider<KDOP<16>, Halfspace>::collide;
534  collision_matrix[BV_KDOP16][GEOM_ELLIPSOID] =
535  &BVHShapeCollider<KDOP<16>, Ellipsoid>::collide;
536 
537  collision_matrix[BV_KDOP18][GEOM_BOX] =
538  &BVHShapeCollider<KDOP<18>, Box>::collide;
539  collision_matrix[BV_KDOP18][GEOM_SPHERE] =
540  &BVHShapeCollider<KDOP<18>, Sphere>::collide;
541  collision_matrix[BV_KDOP18][GEOM_CAPSULE] =
542  &BVHShapeCollider<KDOP<18>, Capsule>::collide;
543  collision_matrix[BV_KDOP18][GEOM_CONE] =
544  &BVHShapeCollider<KDOP<18>, Cone>::collide;
545  collision_matrix[BV_KDOP18][GEOM_CYLINDER] =
546  &BVHShapeCollider<KDOP<18>, Cylinder>::collide;
547  collision_matrix[BV_KDOP18][GEOM_CONVEX] =
548  &BVHShapeCollider<KDOP<18>, ConvexBase>::collide;
549  collision_matrix[BV_KDOP18][GEOM_PLANE] =
550  &BVHShapeCollider<KDOP<18>, Plane>::collide;
551  collision_matrix[BV_KDOP18][GEOM_HALFSPACE] =
552  &BVHShapeCollider<KDOP<18>, Halfspace>::collide;
553  collision_matrix[BV_KDOP18][GEOM_ELLIPSOID] =
554  &BVHShapeCollider<KDOP<18>, Ellipsoid>::collide;
555 
556  collision_matrix[BV_KDOP24][GEOM_BOX] =
557  &BVHShapeCollider<KDOP<24>, Box>::collide;
558  collision_matrix[BV_KDOP24][GEOM_SPHERE] =
559  &BVHShapeCollider<KDOP<24>, Sphere>::collide;
560  collision_matrix[BV_KDOP24][GEOM_CAPSULE] =
561  &BVHShapeCollider<KDOP<24>, Capsule>::collide;
562  collision_matrix[BV_KDOP24][GEOM_CONE] =
563  &BVHShapeCollider<KDOP<24>, Cone>::collide;
564  collision_matrix[BV_KDOP24][GEOM_CYLINDER] =
565  &BVHShapeCollider<KDOP<24>, Cylinder>::collide;
566  collision_matrix[BV_KDOP24][GEOM_CONVEX] =
567  &BVHShapeCollider<KDOP<24>, ConvexBase>::collide;
568  collision_matrix[BV_KDOP24][GEOM_PLANE] =
569  &BVHShapeCollider<KDOP<24>, Plane>::collide;
570  collision_matrix[BV_KDOP24][GEOM_HALFSPACE] =
571  &BVHShapeCollider<KDOP<24>, Halfspace>::collide;
572  collision_matrix[BV_KDOP24][GEOM_ELLIPSOID] =
573  &BVHShapeCollider<KDOP<24>, Ellipsoid>::collide;
574 
575  collision_matrix[BV_kIOS][GEOM_BOX] = &BVHShapeCollider<kIOS, Box>::collide;
576  collision_matrix[BV_kIOS][GEOM_SPHERE] =
577  &BVHShapeCollider<kIOS, Sphere>::collide;
578  collision_matrix[BV_kIOS][GEOM_CAPSULE] =
579  &BVHShapeCollider<kIOS, Capsule>::collide;
580  collision_matrix[BV_kIOS][GEOM_CONE] = &BVHShapeCollider<kIOS, Cone>::collide;
581  collision_matrix[BV_kIOS][GEOM_CYLINDER] =
582  &BVHShapeCollider<kIOS, Cylinder>::collide;
583  collision_matrix[BV_kIOS][GEOM_CONVEX] =
584  &BVHShapeCollider<kIOS, ConvexBase>::collide;
585  collision_matrix[BV_kIOS][GEOM_PLANE] =
586  &BVHShapeCollider<kIOS, Plane>::collide;
587  collision_matrix[BV_kIOS][GEOM_HALFSPACE] =
588  &BVHShapeCollider<kIOS, Halfspace>::collide;
589  collision_matrix[BV_kIOS][GEOM_ELLIPSOID] =
590  &BVHShapeCollider<kIOS, Ellipsoid>::collide;
591 
592  collision_matrix[BV_OBBRSS][GEOM_BOX] =
593  &BVHShapeCollider<OBBRSS, Box>::collide;
594  collision_matrix[BV_OBBRSS][GEOM_SPHERE] =
595  &BVHShapeCollider<OBBRSS, Sphere>::collide;
596  collision_matrix[BV_OBBRSS][GEOM_CAPSULE] =
597  &BVHShapeCollider<OBBRSS, Capsule>::collide;
598  collision_matrix[BV_OBBRSS][GEOM_CONE] =
599  &BVHShapeCollider<OBBRSS, Cone>::collide;
600  collision_matrix[BV_OBBRSS][GEOM_CYLINDER] =
601  &BVHShapeCollider<OBBRSS, Cylinder>::collide;
602  collision_matrix[BV_OBBRSS][GEOM_CONVEX] =
603  &BVHShapeCollider<OBBRSS, ConvexBase>::collide;
604  collision_matrix[BV_OBBRSS][GEOM_PLANE] =
605  &BVHShapeCollider<OBBRSS, Plane>::collide;
606  collision_matrix[BV_OBBRSS][GEOM_HALFSPACE] =
607  &BVHShapeCollider<OBBRSS, Halfspace>::collide;
608  collision_matrix[BV_OBBRSS][GEOM_ELLIPSOID] =
609  &BVHShapeCollider<OBBRSS, Ellipsoid>::collide;
610 
611  collision_matrix[HF_AABB][GEOM_BOX] =
612  &HeightFieldShapeCollider<AABB, Box>::collide;
613  collision_matrix[HF_AABB][GEOM_SPHERE] =
614  &HeightFieldShapeCollider<AABB, Sphere>::collide;
615  collision_matrix[HF_AABB][GEOM_CAPSULE] =
616  &HeightFieldShapeCollider<AABB, Capsule>::collide;
617  collision_matrix[HF_AABB][GEOM_CONE] =
618  &HeightFieldShapeCollider<AABB, Cone>::collide;
619  collision_matrix[HF_AABB][GEOM_CYLINDER] =
620  &HeightFieldShapeCollider<AABB, Cylinder>::collide;
621  collision_matrix[HF_AABB][GEOM_CONVEX] =
622  &HeightFieldShapeCollider<AABB, ConvexBase>::collide;
623  collision_matrix[HF_AABB][GEOM_PLANE] =
624  &HeightFieldShapeCollider<AABB, Plane>::collide;
625  collision_matrix[HF_AABB][GEOM_HALFSPACE] =
626  &HeightFieldShapeCollider<AABB, Halfspace>::collide;
627  collision_matrix[HF_AABB][GEOM_ELLIPSOID] =
628  &HeightFieldShapeCollider<AABB, Ellipsoid>::collide;
629 
630  collision_matrix[HF_OBBRSS][GEOM_BOX] =
631  &HeightFieldShapeCollider<OBBRSS, Box>::collide;
632  collision_matrix[HF_OBBRSS][GEOM_SPHERE] =
633  &HeightFieldShapeCollider<OBBRSS, Sphere>::collide;
634  collision_matrix[HF_OBBRSS][GEOM_CAPSULE] =
635  &HeightFieldShapeCollider<OBBRSS, Capsule>::collide;
636  collision_matrix[HF_OBBRSS][GEOM_CONE] =
637  &HeightFieldShapeCollider<OBBRSS, Cone>::collide;
638  collision_matrix[HF_OBBRSS][GEOM_CYLINDER] =
639  &HeightFieldShapeCollider<OBBRSS, Cylinder>::collide;
640  collision_matrix[HF_OBBRSS][GEOM_CONVEX] =
641  &HeightFieldShapeCollider<OBBRSS, ConvexBase>::collide;
642  collision_matrix[HF_OBBRSS][GEOM_PLANE] =
643  &HeightFieldShapeCollider<OBBRSS, Plane>::collide;
644  collision_matrix[HF_OBBRSS][GEOM_HALFSPACE] =
645  &HeightFieldShapeCollider<OBBRSS, Halfspace>::collide;
646  collision_matrix[HF_OBBRSS][GEOM_ELLIPSOID] =
647  &HeightFieldShapeCollider<OBBRSS, Ellipsoid>::collide;
648 
649  collision_matrix[BV_AABB][BV_AABB] = &BVHCollide<AABB>;
650  collision_matrix[BV_OBB][BV_OBB] = &BVHCollide<OBB>;
651  collision_matrix[BV_RSS][BV_RSS] = &BVHCollide<RSS>;
652  collision_matrix[BV_KDOP16][BV_KDOP16] = &BVHCollide<KDOP<16> >;
653  collision_matrix[BV_KDOP18][BV_KDOP18] = &BVHCollide<KDOP<18> >;
654  collision_matrix[BV_KDOP24][BV_KDOP24] = &BVHCollide<KDOP<24> >;
655  collision_matrix[BV_kIOS][BV_kIOS] = &BVHCollide<kIOS>;
656  collision_matrix[BV_OBBRSS][BV_OBBRSS] = &BVHCollide<OBBRSS>;
657 
658 #ifdef COAL_HAS_OCTOMAP
659  collision_matrix[GEOM_OCTREE][GEOM_BOX] = &OctreeCollide<OcTree, Box>;
660  collision_matrix[GEOM_OCTREE][GEOM_SPHERE] = &OctreeCollide<OcTree, Sphere>;
661  collision_matrix[GEOM_OCTREE][GEOM_CAPSULE] = &OctreeCollide<OcTree, Capsule>;
662  collision_matrix[GEOM_OCTREE][GEOM_CONE] = &OctreeCollide<OcTree, Cone>;
663  collision_matrix[GEOM_OCTREE][GEOM_CYLINDER] =
664  &OctreeCollide<OcTree, Cylinder>;
665  collision_matrix[GEOM_OCTREE][GEOM_CONVEX] =
666  &OctreeCollide<OcTree, ConvexBase>;
667  collision_matrix[GEOM_OCTREE][GEOM_PLANE] = &OctreeCollide<OcTree, Plane>;
668  collision_matrix[GEOM_OCTREE][GEOM_HALFSPACE] =
669  &OctreeCollide<OcTree, Halfspace>;
670  collision_matrix[GEOM_OCTREE][GEOM_ELLIPSOID] =
671  &OctreeCollide<OcTree, Ellipsoid>;
672 
673  collision_matrix[GEOM_BOX][GEOM_OCTREE] = &OctreeCollide<Box, OcTree>;
674  collision_matrix[GEOM_SPHERE][GEOM_OCTREE] = &OctreeCollide<Sphere, OcTree>;
675  collision_matrix[GEOM_CAPSULE][GEOM_OCTREE] = &OctreeCollide<Capsule, OcTree>;
676  collision_matrix[GEOM_CONE][GEOM_OCTREE] = &OctreeCollide<Cone, OcTree>;
677  collision_matrix[GEOM_CYLINDER][GEOM_OCTREE] =
678  &OctreeCollide<Cylinder, OcTree>;
679  collision_matrix[GEOM_CONVEX][GEOM_OCTREE] =
680  &OctreeCollide<ConvexBase, OcTree>;
681  collision_matrix[GEOM_PLANE][GEOM_OCTREE] = &OctreeCollide<Plane, OcTree>;
682  collision_matrix[GEOM_HALFSPACE][GEOM_OCTREE] =
683  &OctreeCollide<Halfspace, OcTree>;
684 
685  collision_matrix[GEOM_OCTREE][GEOM_OCTREE] = &OctreeCollide<OcTree, OcTree>;
686 
687  collision_matrix[GEOM_OCTREE][BV_AABB] =
688  &OctreeCollide<OcTree, BVHModel<AABB> >;
689  collision_matrix[GEOM_OCTREE][BV_OBB] =
690  &OctreeCollide<OcTree, BVHModel<OBB> >;
691  collision_matrix[GEOM_OCTREE][BV_RSS] =
692  &OctreeCollide<OcTree, BVHModel<RSS> >;
693  collision_matrix[GEOM_OCTREE][BV_OBBRSS] =
694  &OctreeCollide<OcTree, BVHModel<OBBRSS> >;
695  collision_matrix[GEOM_OCTREE][BV_kIOS] =
696  &OctreeCollide<OcTree, BVHModel<kIOS> >;
697  collision_matrix[GEOM_OCTREE][BV_KDOP16] =
698  &OctreeCollide<OcTree, BVHModel<KDOP<16> > >;
699  collision_matrix[GEOM_OCTREE][BV_KDOP18] =
700  &OctreeCollide<OcTree, BVHModel<KDOP<18> > >;
701  collision_matrix[GEOM_OCTREE][BV_KDOP24] =
702  &OctreeCollide<OcTree, BVHModel<KDOP<24> > >;
703  collision_matrix[GEOM_OCTREE][HF_AABB] =
704  &OctreeCollide<OcTree, HeightField<AABB> >;
705  collision_matrix[GEOM_OCTREE][HF_OBBRSS] =
706  &OctreeCollide<OcTree, HeightField<OBBRSS> >;
707 
708  collision_matrix[BV_AABB][GEOM_OCTREE] =
709  &OctreeCollide<BVHModel<AABB>, OcTree>;
710  collision_matrix[BV_OBB][GEOM_OCTREE] = &OctreeCollide<BVHModel<OBB>, OcTree>;
711  collision_matrix[BV_RSS][GEOM_OCTREE] = &OctreeCollide<BVHModel<RSS>, OcTree>;
712  collision_matrix[BV_OBBRSS][GEOM_OCTREE] =
713  &OctreeCollide<BVHModel<OBBRSS>, OcTree>;
714  collision_matrix[BV_kIOS][GEOM_OCTREE] =
715  &OctreeCollide<BVHModel<kIOS>, OcTree>;
716  collision_matrix[BV_KDOP16][GEOM_OCTREE] =
717  &OctreeCollide<BVHModel<KDOP<16> >, OcTree>;
718  collision_matrix[BV_KDOP18][GEOM_OCTREE] =
719  &OctreeCollide<BVHModel<KDOP<18> >, OcTree>;
720  collision_matrix[BV_KDOP24][GEOM_OCTREE] =
721  &OctreeCollide<BVHModel<KDOP<24> >, OcTree>;
722  collision_matrix[HF_AABB][GEOM_OCTREE] =
723  &OctreeCollide<HeightField<AABB>, OcTree>;
724  collision_matrix[HF_OBBRSS][GEOM_OCTREE] =
725  &OctreeCollide<HeightField<OBBRSS>, OcTree>;
726 #endif
727 }
728 // template struct CollisionFunctionMatrix;
729 } // namespace coal
coal::details::orientedMeshCollide
std::size_t orientedMeshCollide(const CollisionGeometry *o1, const Transform3s &tf1, const CollisionGeometry *o2, const Transform3s &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:186
coal::BVHShapeCollider::aligned
static std::size_t aligned(const CollisionGeometry *o1, const Transform3s &tf1, const CollisionGeometry *o2, const Transform3s &tf2, const GJKSolver *nsolver, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:117
coal::CollisionFunctionMatrix::CollisionFunctionMatrix
CollisionFunctionMatrix()
Definition: collision_func_matrix.cpp:277
coal::BV_AABB
@ BV_AABB
Definition: coal/collision_object.h:66
coal::details::bvh_shape_traits
Definition: collision_func_matrix.cpp:79
coal::BV_KDOP24
@ BV_KDOP24
Definition: coal/collision_object.h:73
coal::NODE_COUNT
@ NODE_COUNT
Definition: coal/collision_object.h:87
coal::BV_kIOS
@ BV_kIOS
Definition: coal/collision_object.h:69
coal::BV_OBBRSS
@ BV_OBBRSS
Definition: coal/collision_object.h:70
coal::GEOM_CONE
@ GEOM_CONE
Definition: coal/collision_object.h:77
coal::Halfspace
Half Space: this is equivalent to the Plane in ODE. A Half space has a priviledged direction: the dir...
Definition: coal/shape/geometric_shapes.h:892
coal::GEOM_CONVEX
@ GEOM_CONVEX
Definition: coal/collision_object.h:79
gjk.tf1
tuple tf1
Definition: test/scripts/gjk.py:27
coal::CollisionRequest::security_margin
CoalScalar security_margin
Distance below which objects are considered in collision. See Collision.
Definition: coal/collision_data.h:328
coal::Capsule
Capsule It is where is the distance between the point x and the capsule segment AB,...
Definition: coal/shape/geometric_shapes.h:383
coal::BV_RSS
@ BV_RSS
Definition: coal/collision_object.h:68
coal::HeightFieldShapeCollider::collide
static std::size_t collide(const CollisionGeometry *o1, const Transform3s &tf1, const CollisionGeometry *o2, const Transform3s &tf2, const GJKSolver *nsolver, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:165
coal::details::bvh_shape_traits::Options
@ Options
Definition: collision_func_matrix.cpp:80
coal
Main namespace.
Definition: coal/broadphase/broadphase_bruteforce.h:44
narrowphase.h
coal::BVHCollide< OBB >
std::size_t BVHCollide< OBB >(const CollisionGeometry *o1, const Transform3s &tf1, const CollisionGeometry *o2, const Transform3s &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:238
coal::BVHCollide
std::size_t BVHCollide(const CollisionGeometry *o1, const Transform3s &tf1, const CollisionGeometry *o2, const Transform3s &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:207
coal::GEOM_CAPSULE
@ GEOM_CAPSULE
Definition: coal/collision_object.h:76
coal::HeightFieldShapeCollider
Collider functor for HeightField data structure.
Definition: collision_func_matrix.cpp:162
coal::GJKSolver
collision and distance solver based on the GJK and EPA algorithms. Originally, GJK and EPA were imple...
Definition: coal/narrowphase/narrowphase.h:57
coal::BV_KDOP18
@ BV_KDOP18
Definition: coal/collision_object.h:72
coal::Ellipsoid
Ellipsoid centered at point zero.
Definition: coal/shape/geometric_shapes.h:305
coal::GEOM_SPHERE
@ GEOM_SPHERE
Definition: coal/collision_object.h:75
coal::CollisionGeometry
The geometry for the object for collision or distance computation.
Definition: coal/collision_object.h:94
coal::Plane
Infinite plane. A plane can be viewed as two half spaces; it has no priviledged direction....
Definition: coal/shape/geometric_shapes.h:983
coal::Box
Center at zero point, axis aligned box.
Definition: coal/shape/geometric_shapes.h:166
coal::Sphere
Center at zero point sphere.
Definition: coal/shape/geometric_shapes.h:240
traversal_node_setup.h
coal::Transform3s
Simple transform class used locally by InterpMotion.
Definition: coal/math/transform.h:55
coal::HF_AABB
@ HF_AABB
Definition: coal/collision_object.h:85
shape_shape_func.h
coal::GEOM_PLANE
@ GEOM_PLANE
Definition: coal/collision_object.h:80
coal::GEOM_ELLIPSOID
@ GEOM_ELLIPSOID
Definition: coal/collision_object.h:84
coal::GEOM_HALFSPACE
@ GEOM_HALFSPACE
Definition: coal/collision_object.h:81
COAL_THROW_PRETTY
#define COAL_THROW_PRETTY(message, exception)
Definition: include/coal/fwd.hh:64
coal::CollisionFunctionMatrix::collision_matrix
CollisionFunc collision_matrix[NODE_COUNT][NODE_COUNT]
each item in the collision matrix is a function to handle collision between objects of type1 and type...
Definition: coal/collision_func_matrix.h:70
coal::CollisionRequest::isSatisfied
COAL_COMPILER_DIAGNOSTIC_POP bool isSatisfied(const CollisionResult &result) const
Definition: collision_data.cpp:43
coal::CollisionResult
collision result
Definition: coal/collision_data.h:390
coal::BVHShapeCollider::oriented
static std::size_t oriented(const CollisionGeometry *o1, const Transform3s &tf1, const CollisionGeometry *o2, const Transform3s &tf2, const GJKSolver *nsolver, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:138
geometric_shapes_traits.h
coal::BVHShapeCollider
Definition: collision_func_matrix.cpp:100
coal::GEOM_TRIANGLE
@ GEOM_TRIANGLE
Definition: coal/collision_object.h:82
coal::CollisionRequest
request to the collision algorithm
Definition: coal/collision_data.h:311
gjk.tf2
tuple tf2
Definition: test/scripts/gjk.py:36
coal::Cylinder
Cylinder along Z axis. The cylinder is defined at its centroid.
Definition: coal/shape/geometric_shapes.h:560
coal::BVHShapeCollider::collide
static std::size_t collide(const CollisionGeometry *o1, const Transform3s &tf1, const CollisionGeometry *o2, const Transform3s &tf2, const GJKSolver *nsolver, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:100
coal::HeightField
Data structure depicting a height field given by the base grid dimensions and the elevation along the...
Definition: coal/hfield.h:202
collision_func_matrix.h
coal::details::BVH_SHAPE_DEFAULT_TO_ORIENTED
BVH_SHAPE_DEFAULT_TO_ORIENTED(OBB)
coal::GEOM_CYLINDER
@ GEOM_CYLINDER
Definition: coal/collision_object.h:78
coal::Cone
Cone The base of the cone is at and the top is at .
Definition: coal/shape/geometric_shapes.h:467
coal::GEOM_OCTREE
@ GEOM_OCTREE
Definition: coal/collision_object.h:83
coal::BVHModel
A class describing the bounding hierarchy of a mesh model or a point cloud model (which is viewed as ...
Definition: coal/BVH/BVH_model.h:314
coal::OcTree
Octree is one type of collision geometry which can encode uncertainty information in the sensor data.
Definition: coal/octree.h:53
coal::BVHCollide< kIOS >
std::size_t BVHCollide< kIOS >(const CollisionGeometry *o1, const Transform3s &tf1, const CollisionGeometry *o2, const Transform3s &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:258
coal::HeightFieldShapeCollider::HF
HeightField< BV > HF
Definition: collision_func_matrix.cpp:163
coal::collide
COAL_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,...
Definition: src/collision.cpp:61
coal::BV_OBB
@ BV_OBB
Definition: coal/collision_object.h:67
coal::GEOM_BOX
@ GEOM_BOX
Definition: coal/collision_object.h:74
coal::HF_OBBRSS
@ HF_OBBRSS
Definition: coal/collision_object.h:86
coal::BVHCollide< OBBRSS >
std::size_t BVHCollide< OBBRSS >(const CollisionGeometry *o1, const Transform3s &tf1, const CollisionGeometry *o2, const Transform3s &tf2, const CollisionRequest &request, CollisionResult &result)
Definition: collision_func_matrix.cpp:247
initialize
bool initialize(MeshCollisionTraversalNode< BV, RelativeTransformationIsIdentity > &node, BVHModel< BV > &model1, Transform3s &tf1, BVHModel< BV > &model2, Transform3s &tf2, CollisionResult &result, bool use_refit=false, bool refit_bottomup=false)
Initialize traversal node for collision between two meshes, given the current transforms.
Definition: coal/internal/traversal_node_setup.h:467
coal::BV_KDOP16
@ BV_KDOP16
Definition: coal/collision_object.h:71
coal::ConvexBase
Base for convex polytope.
Definition: coal/shape/geometric_shapes.h:645
coal::CollisionResult::numContacts
size_t numContacts() const
number of contacts found
Definition: coal/collision_data.h:446

hpp-fcl
Author(s):
autogenerated on Sat Nov 23 2024 03:44:57