GCC Code Coverage Report


Directory: ./
File: src/distance_func_matrix.cpp
Date: 2025-04-13 14:25:19
Exec Total Coverage
Lines: 206 259 79.5%
Branches: 14 150 9.3%

Line Branch Exec Source
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
36 /** \author Jia Pan */
37
38 #include "coal/distance_func_matrix.h"
39
40 #include <../src/collision_node.h>
41 #include "coal/internal/shape_shape_func.h"
42 #include "coal/internal/traversal_node_setup.h"
43 #include "coal/internal/shape_shape_func.h"
44 #include <../src/traits_traversal.h>
45
46 namespace coal {
47
48 #ifdef COAL_HAS_OCTOMAP
49
50 template <typename TypeA, typename TypeB>
51 Scalar Distance(const CollisionGeometry* o1, const Transform3s& tf1,
52 const CollisionGeometry* o2, const Transform3s& tf2,
53 const GJKSolver* nsolver, const DistanceRequest& request,
54 DistanceResult& result) {
55 if (request.isSatisfied(result)) return result.min_distance;
56 typename TraversalTraitsDistance<TypeA, TypeB>::CollisionTraversal_t node;
57 const TypeA* obj1 = static_cast<const TypeA*>(o1);
58 const TypeB* obj2 = static_cast<const TypeB*>(o2);
59 OcTreeSolver otsolver(nsolver);
60
61 initialize(node, *obj1, tf1, *obj2, tf2, &otsolver, request, result);
62 distance(&node);
63
64 return result.min_distance;
65 }
66
67 #endif
68
69 COAL_LOCAL Scalar distance_function_not_implemented(
70 const CollisionGeometry* o1, const Transform3s& /*tf1*/,
71 const CollisionGeometry* o2, const Transform3s& /*tf2*/,
72 const GJKSolver* /*nsolver*/, const DistanceRequest& /*request*/,
73 DistanceResult& /*result*/) {
74 NODE_TYPE node_type1 = o1->getNodeType();
75 NODE_TYPE node_type2 = o2->getNodeType();
76
77 COAL_THROW_PRETTY("Distance function between node type "
78 << std::string(get_node_type_name(node_type1))
79 << " and node type "
80 << std::string(get_node_type_name(node_type2))
81 << " is not yet supported.",
82 std::invalid_argument);
83 }
84
85 template <typename T_BVH, typename T_SH>
86 struct COAL_LOCAL BVHShapeDistancer {
87 static Scalar distance(const CollisionGeometry* o1, const Transform3s& tf1,
88 const CollisionGeometry* o2, const Transform3s& tf2,
89 const GJKSolver* nsolver,
90 const DistanceRequest& request,
91 DistanceResult& result) {
92 if (request.isSatisfied(result)) return result.min_distance;
93 MeshShapeDistanceTraversalNode<T_BVH, T_SH> node;
94 const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
95 BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
96 Transform3s tf1_tmp = tf1;
97 const T_SH* obj2 = static_cast<const T_SH*>(o2);
98
99 initialize(node, *obj1_tmp, tf1_tmp, *obj2, tf2, nsolver, request, result);
100 ::coal::distance(&node);
101
102 delete obj1_tmp;
103 return result.min_distance;
104 } // namespace coal
105 };
106
107 namespace details {
108
109 template <typename OrientedMeshShapeDistanceTraversalNode, typename T_BVH,
110 typename T_SH>
111 204 Scalar orientedBVHShapeDistance(const CollisionGeometry* o1,
112 const Transform3s& tf1,
113 const CollisionGeometry* o2,
114 const Transform3s& tf2,
115 const GJKSolver* nsolver,
116 const DistanceRequest& request,
117 DistanceResult& result) {
118
2/4
✓ Branch 1 taken 102 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 102 times.
204 if (request.isSatisfied(result)) return result.min_distance;
119
1/2
✓ Branch 1 taken 102 times.
✗ Branch 2 not taken.
204 OrientedMeshShapeDistanceTraversalNode node;
120 204 const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
121 204 const T_SH* obj2 = static_cast<const T_SH*>(o2);
122
123
1/2
✓ Branch 1 taken 102 times.
✗ Branch 2 not taken.
204 initialize(node, *obj1, tf1, *obj2, tf2, nsolver, request, result);
124
1/2
✓ Branch 1 taken 102 times.
✗ Branch 2 not taken.
204 ::coal::distance(&node);
125
126 204 return result.min_distance;
127 }
128
129 } // namespace details
130
131 template <typename T_SH>
132 struct COAL_LOCAL BVHShapeDistancer<RSS, T_SH> {
133 static Scalar distance(const CollisionGeometry* o1, const Transform3s& tf1,
134 const CollisionGeometry* o2, const Transform3s& tf2,
135 const GJKSolver* nsolver,
136 const DistanceRequest& request,
137 DistanceResult& result) {
138 return details::orientedBVHShapeDistance<
139 MeshShapeDistanceTraversalNodeRSS<T_SH>, RSS, T_SH>(
140 o1, tf1, o2, tf2, nsolver, request, result);
141 }
142 };
143
144 template <typename T_SH>
145 struct COAL_LOCAL BVHShapeDistancer<kIOS, T_SH> {
146 static Scalar distance(const CollisionGeometry* o1, const Transform3s& tf1,
147 const CollisionGeometry* o2, const Transform3s& tf2,
148 const GJKSolver* nsolver,
149 const DistanceRequest& request,
150 DistanceResult& result) {
151 return details::orientedBVHShapeDistance<
152 MeshShapeDistanceTraversalNodekIOS<T_SH>, kIOS, T_SH>(
153 o1, tf1, o2, tf2, nsolver, request, result);
154 }
155 };
156
157 template <typename T_SH>
158 struct COAL_LOCAL BVHShapeDistancer<OBBRSS, T_SH> {
159 204 static Scalar distance(const CollisionGeometry* o1, const Transform3s& tf1,
160 const CollisionGeometry* o2, const Transform3s& tf2,
161 const GJKSolver* nsolver,
162 const DistanceRequest& request,
163 DistanceResult& result) {
164 return details::orientedBVHShapeDistance<
165 204 MeshShapeDistanceTraversalNodeOBBRSS<T_SH>, OBBRSS, T_SH>(
166 204 o1, tf1, o2, tf2, nsolver, request, result);
167 }
168 };
169
170 template <typename T_HF, typename T_SH>
171 struct COAL_LOCAL HeightFieldShapeDistancer {
172 static Scalar distance(const CollisionGeometry* o1, const Transform3s& tf1,
173 const CollisionGeometry* o2, const Transform3s& tf2,
174 const GJKSolver* nsolver,
175 const DistanceRequest& request,
176 DistanceResult& result) {
177 COAL_UNUSED_VARIABLE(o1);
178 COAL_UNUSED_VARIABLE(tf1);
179 COAL_UNUSED_VARIABLE(o2);
180 COAL_UNUSED_VARIABLE(tf2);
181 COAL_UNUSED_VARIABLE(nsolver);
182 COAL_UNUSED_VARIABLE(request);
183 // TODO(jcarpent)
184 COAL_THROW_PRETTY(
185 "Distance between a height field and a shape is not implemented",
186 std::invalid_argument);
187 // if(request.isSatisfied(result)) return result.min_distance;
188 // HeightFieldShapeDistanceTraversalNode<T_HF, T_SH> node;
189 //
190 // const HeightField<T_HF>* obj1 = static_cast<const HeightField<T_HF>*
191 // >(o1); const T_SH* obj2 = static_cast<const T_SH*>(o2);
192 //
193 // initialize(node, *obj1, tf1, *obj2, tf2, nsolver, request, result);
194 // fcl::distance(&node);
195
196 return result.min_distance;
197 }
198 };
199
200 template <typename T_BVH>
201 Scalar BVHDistance(const CollisionGeometry* o1, const Transform3s& tf1,
202 const CollisionGeometry* o2, const Transform3s& tf2,
203 const DistanceRequest& request, DistanceResult& result) {
204 if (request.isSatisfied(result)) return result.min_distance;
205 MeshDistanceTraversalNode<T_BVH> node;
206 const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
207 const BVHModel<T_BVH>* obj2 = static_cast<const BVHModel<T_BVH>*>(o2);
208 BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
209 Transform3s tf1_tmp = tf1;
210 BVHModel<T_BVH>* obj2_tmp = new BVHModel<T_BVH>(*obj2);
211 Transform3s tf2_tmp = tf2;
212
213 initialize(node, *obj1_tmp, tf1_tmp, *obj2_tmp, tf2_tmp, request, result);
214 distance(&node);
215 delete obj1_tmp;
216 delete obj2_tmp;
217
218 return result.min_distance;
219 }
220
221 namespace details {
222 template <typename OrientedMeshDistanceTraversalNode, typename T_BVH>
223 14282 Scalar orientedMeshDistance(const CollisionGeometry* o1, const Transform3s& tf1,
224 const CollisionGeometry* o2, const Transform3s& tf2,
225 const DistanceRequest& request,
226 DistanceResult& result) {
227
2/4
✓ Branch 1 taken 7141 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 7141 times.
14282 if (request.isSatisfied(result)) return result.min_distance;
228
1/2
✓ Branch 1 taken 7141 times.
✗ Branch 2 not taken.
14282 OrientedMeshDistanceTraversalNode node;
229 14282 const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
230 14282 const BVHModel<T_BVH>* obj2 = static_cast<const BVHModel<T_BVH>*>(o2);
231
232
1/2
✓ Branch 1 taken 7141 times.
✗ Branch 2 not taken.
14282 initialize(node, *obj1, tf1, *obj2, tf2, request, result);
233
1/2
✓ Branch 1 taken 7141 times.
✗ Branch 2 not taken.
14282 distance(&node);
234
235 14282 return result.min_distance;
236 }
237
238 } // namespace details
239
240 template <>
241 Scalar BVHDistance<RSS>(const CollisionGeometry* o1, const Transform3s& tf1,
242 const CollisionGeometry* o2, const Transform3s& tf2,
243 const DistanceRequest& request,
244 DistanceResult& result) {
245 return details::orientedMeshDistance<MeshDistanceTraversalNodeRSS, RSS>(
246 o1, tf1, o2, tf2, request, result);
247 }
248
249 template <>
250 Scalar BVHDistance<kIOS>(const CollisionGeometry* o1, const Transform3s& tf1,
251 const CollisionGeometry* o2, const Transform3s& tf2,
252 const DistanceRequest& request,
253 DistanceResult& result) {
254 return details::orientedMeshDistance<MeshDistanceTraversalNodekIOS, kIOS>(
255 o1, tf1, o2, tf2, request, result);
256 }
257
258 template <>
259 7141 Scalar BVHDistance<OBBRSS>(const CollisionGeometry* o1, const Transform3s& tf1,
260 const CollisionGeometry* o2, const Transform3s& tf2,
261 const DistanceRequest& request,
262 DistanceResult& result) {
263 7141 return details::orientedMeshDistance<MeshDistanceTraversalNodeOBBRSS, OBBRSS>(
264 7141 o1, tf1, o2, tf2, request, result);
265 }
266
267 template <typename T_BVH>
268 14282 Scalar BVHDistance(const CollisionGeometry* o1, const Transform3s& tf1,
269 const CollisionGeometry* o2, const Transform3s& tf2,
270 const GJKSolver* /*nsolver*/, const DistanceRequest& request,
271 DistanceResult& result) {
272 14282 return BVHDistance<T_BVH>(o1, tf1, o2, tf2, request, result);
273 }
274
275 10 DistanceFunctionMatrix::DistanceFunctionMatrix() {
276
2/2
✓ Branch 0 taken 220 times.
✓ Branch 1 taken 10 times.
230 for (int i = 0; i < NODE_COUNT; ++i) {
277
2/2
✓ Branch 0 taken 4840 times.
✓ Branch 1 taken 220 times.
5060 for (int j = 0; j < NODE_COUNT; ++j) distance_matrix[i][j] = NULL;
278 }
279
280 10 distance_matrix[GEOM_BOX][GEOM_BOX] = &ShapeShapeDistance<Box, Box>;
281 10 distance_matrix[GEOM_BOX][GEOM_SPHERE] = &ShapeShapeDistance<Box, Sphere>;
282 10 distance_matrix[GEOM_BOX][GEOM_CAPSULE] = &ShapeShapeDistance<Box, Capsule>;
283 10 distance_matrix[GEOM_BOX][GEOM_CONE] = &ShapeShapeDistance<Box, Cone>;
284 10 distance_matrix[GEOM_BOX][GEOM_CYLINDER] = &ShapeShapeDistance<Box, Cylinder>;
285 10 distance_matrix[GEOM_BOX][GEOM_CONVEX] = &ShapeShapeDistance<Box, ConvexBase>;
286 10 distance_matrix[GEOM_BOX][GEOM_PLANE] = &ShapeShapeDistance<Box, Plane>;
287 10 distance_matrix[GEOM_BOX][GEOM_HALFSPACE] =
288 &ShapeShapeDistance<Box, Halfspace>;
289 10 distance_matrix[GEOM_BOX][GEOM_ELLIPSOID] =
290 &ShapeShapeDistance<Box, Ellipsoid>;
291
292 10 distance_matrix[GEOM_SPHERE][GEOM_BOX] = &ShapeShapeDistance<Sphere, Box>;
293 10 distance_matrix[GEOM_SPHERE][GEOM_SPHERE] =
294 &ShapeShapeDistance<Sphere, Sphere>;
295 10 distance_matrix[GEOM_SPHERE][GEOM_CAPSULE] =
296 &ShapeShapeDistance<Sphere, Capsule>;
297 10 distance_matrix[GEOM_SPHERE][GEOM_CONE] = &ShapeShapeDistance<Sphere, Cone>;
298 10 distance_matrix[GEOM_SPHERE][GEOM_CYLINDER] =
299 &ShapeShapeDistance<Sphere, Cylinder>;
300 10 distance_matrix[GEOM_SPHERE][GEOM_CONVEX] =
301 &ShapeShapeDistance<Sphere, ConvexBase>;
302 10 distance_matrix[GEOM_SPHERE][GEOM_PLANE] = &ShapeShapeDistance<Sphere, Plane>;
303 10 distance_matrix[GEOM_SPHERE][GEOM_HALFSPACE] =
304 &ShapeShapeDistance<Sphere, Halfspace>;
305 10 distance_matrix[GEOM_SPHERE][GEOM_ELLIPSOID] =
306 &ShapeShapeDistance<Sphere, Ellipsoid>;
307
308 10 distance_matrix[GEOM_ELLIPSOID][GEOM_BOX] =
309 &ShapeShapeDistance<Ellipsoid, Box>;
310 10 distance_matrix[GEOM_ELLIPSOID][GEOM_SPHERE] =
311 &ShapeShapeDistance<Ellipsoid, Sphere>;
312 10 distance_matrix[GEOM_ELLIPSOID][GEOM_CAPSULE] =
313 &ShapeShapeDistance<Ellipsoid, Capsule>;
314 10 distance_matrix[GEOM_ELLIPSOID][GEOM_CONE] =
315 &ShapeShapeDistance<Ellipsoid, Cone>;
316 10 distance_matrix[GEOM_ELLIPSOID][GEOM_CYLINDER] =
317 &ShapeShapeDistance<Ellipsoid, Cylinder>;
318 10 distance_matrix[GEOM_ELLIPSOID][GEOM_CONVEX] =
319 &ShapeShapeDistance<Ellipsoid, ConvexBase>;
320 10 distance_matrix[GEOM_ELLIPSOID][GEOM_PLANE] =
321 &ShapeShapeDistance<Ellipsoid, Plane>;
322 10 distance_matrix[GEOM_ELLIPSOID][GEOM_HALFSPACE] =
323 &ShapeShapeDistance<Ellipsoid, Halfspace>;
324 10 distance_matrix[GEOM_ELLIPSOID][GEOM_ELLIPSOID] =
325 &ShapeShapeDistance<Ellipsoid, Ellipsoid>;
326
327 10 distance_matrix[GEOM_CAPSULE][GEOM_BOX] = &ShapeShapeDistance<Capsule, Box>;
328 10 distance_matrix[GEOM_CAPSULE][GEOM_SPHERE] =
329 &ShapeShapeDistance<Capsule, Sphere>;
330 10 distance_matrix[GEOM_CAPSULE][GEOM_CAPSULE] =
331 &ShapeShapeDistance<Capsule, Capsule>;
332 10 distance_matrix[GEOM_CAPSULE][GEOM_CONE] = &ShapeShapeDistance<Capsule, Cone>;
333 10 distance_matrix[GEOM_CAPSULE][GEOM_CYLINDER] =
334 &ShapeShapeDistance<Capsule, Cylinder>;
335 10 distance_matrix[GEOM_CAPSULE][GEOM_CONVEX] =
336 &ShapeShapeDistance<Capsule, ConvexBase>;
337 10 distance_matrix[GEOM_CAPSULE][GEOM_PLANE] =
338 &ShapeShapeDistance<Capsule, Plane>;
339 10 distance_matrix[GEOM_CAPSULE][GEOM_HALFSPACE] =
340 &ShapeShapeDistance<Capsule, Halfspace>;
341 10 distance_matrix[GEOM_CAPSULE][GEOM_ELLIPSOID] =
342 &ShapeShapeDistance<Capsule, Ellipsoid>;
343
344 10 distance_matrix[GEOM_CONE][GEOM_BOX] = &ShapeShapeDistance<Cone, Box>;
345 10 distance_matrix[GEOM_CONE][GEOM_SPHERE] = &ShapeShapeDistance<Cone, Sphere>;
346 10 distance_matrix[GEOM_CONE][GEOM_CAPSULE] = &ShapeShapeDistance<Cone, Capsule>;
347 10 distance_matrix[GEOM_CONE][GEOM_CONE] = &ShapeShapeDistance<Cone, Cone>;
348 10 distance_matrix[GEOM_CONE][GEOM_CYLINDER] =
349 &ShapeShapeDistance<Cone, Cylinder>;
350 10 distance_matrix[GEOM_CONE][GEOM_CONVEX] =
351 &ShapeShapeDistance<Cone, ConvexBase>;
352 10 distance_matrix[GEOM_CONE][GEOM_PLANE] = &ShapeShapeDistance<Cone, Plane>;
353 10 distance_matrix[GEOM_CONE][GEOM_HALFSPACE] =
354 &ShapeShapeDistance<Cone, Halfspace>;
355 10 distance_matrix[GEOM_CONE][GEOM_ELLIPSOID] =
356 &ShapeShapeDistance<Cone, Ellipsoid>;
357
358 10 distance_matrix[GEOM_CYLINDER][GEOM_BOX] = &ShapeShapeDistance<Cylinder, Box>;
359 10 distance_matrix[GEOM_CYLINDER][GEOM_SPHERE] =
360 &ShapeShapeDistance<Cylinder, Sphere>;
361 10 distance_matrix[GEOM_CYLINDER][GEOM_CAPSULE] =
362 &ShapeShapeDistance<Cylinder, Capsule>;
363 10 distance_matrix[GEOM_CYLINDER][GEOM_CONE] =
364 &ShapeShapeDistance<Cylinder, Cone>;
365 10 distance_matrix[GEOM_CYLINDER][GEOM_CYLINDER] =
366 &ShapeShapeDistance<Cylinder, Cylinder>;
367 10 distance_matrix[GEOM_CYLINDER][GEOM_CONVEX] =
368 &ShapeShapeDistance<Cylinder, ConvexBase>;
369 10 distance_matrix[GEOM_CYLINDER][GEOM_PLANE] =
370 &ShapeShapeDistance<Cylinder, Plane>;
371 10 distance_matrix[GEOM_CYLINDER][GEOM_HALFSPACE] =
372 &ShapeShapeDistance<Cylinder, Halfspace>;
373 10 distance_matrix[GEOM_CYLINDER][GEOM_ELLIPSOID] =
374 &ShapeShapeDistance<Cylinder, Ellipsoid>;
375
376 10 distance_matrix[GEOM_CONVEX][GEOM_BOX] = &ShapeShapeDistance<ConvexBase, Box>;
377 10 distance_matrix[GEOM_CONVEX][GEOM_SPHERE] =
378 &ShapeShapeDistance<ConvexBase, Sphere>;
379 10 distance_matrix[GEOM_CONVEX][GEOM_CAPSULE] =
380 &ShapeShapeDistance<ConvexBase, Capsule>;
381 10 distance_matrix[GEOM_CONVEX][GEOM_CONE] =
382 &ShapeShapeDistance<ConvexBase, Cone>;
383 10 distance_matrix[GEOM_CONVEX][GEOM_CYLINDER] =
384 &ShapeShapeDistance<ConvexBase, Cylinder>;
385 10 distance_matrix[GEOM_CONVEX][GEOM_CONVEX] =
386 &ShapeShapeDistance<ConvexBase, ConvexBase>;
387 10 distance_matrix[GEOM_CONVEX][GEOM_PLANE] =
388 &ShapeShapeDistance<ConvexBase, Plane>;
389 10 distance_matrix[GEOM_CONVEX][GEOM_HALFSPACE] =
390 &ShapeShapeDistance<ConvexBase, Halfspace>;
391 10 distance_matrix[GEOM_CONVEX][GEOM_ELLIPSOID] =
392 &ShapeShapeDistance<ConvexBase, Ellipsoid>;
393
394 10 distance_matrix[GEOM_PLANE][GEOM_BOX] = &ShapeShapeDistance<Plane, Box>;
395 10 distance_matrix[GEOM_PLANE][GEOM_SPHERE] = &ShapeShapeDistance<Plane, Sphere>;
396 10 distance_matrix[GEOM_PLANE][GEOM_CAPSULE] =
397 &ShapeShapeDistance<Plane, Capsule>;
398 10 distance_matrix[GEOM_PLANE][GEOM_CONE] = &ShapeShapeDistance<Plane, Cone>;
399 10 distance_matrix[GEOM_PLANE][GEOM_CYLINDER] =
400 &ShapeShapeDistance<Plane, Cylinder>;
401 10 distance_matrix[GEOM_PLANE][GEOM_CONVEX] =
402 &ShapeShapeDistance<Plane, ConvexBase>;
403 10 distance_matrix[GEOM_PLANE][GEOM_PLANE] = &ShapeShapeDistance<Plane, Plane>;
404 10 distance_matrix[GEOM_PLANE][GEOM_HALFSPACE] =
405 &ShapeShapeDistance<Plane, Halfspace>;
406 10 distance_matrix[GEOM_PLANE][GEOM_ELLIPSOID] =
407 &ShapeShapeDistance<Plane, Ellipsoid>;
408
409 10 distance_matrix[GEOM_HALFSPACE][GEOM_BOX] =
410 &ShapeShapeDistance<Halfspace, Box>;
411 10 distance_matrix[GEOM_HALFSPACE][GEOM_SPHERE] =
412 &ShapeShapeDistance<Halfspace, Sphere>;
413 10 distance_matrix[GEOM_HALFSPACE][GEOM_CAPSULE] =
414 &ShapeShapeDistance<Halfspace, Capsule>;
415 10 distance_matrix[GEOM_HALFSPACE][GEOM_CONE] =
416 &ShapeShapeDistance<Halfspace, Cone>;
417 10 distance_matrix[GEOM_HALFSPACE][GEOM_CYLINDER] =
418 &ShapeShapeDistance<Halfspace, Cylinder>;
419 10 distance_matrix[GEOM_HALFSPACE][GEOM_CONVEX] =
420 &ShapeShapeDistance<Halfspace, ConvexBase>;
421 10 distance_matrix[GEOM_HALFSPACE][GEOM_PLANE] =
422 &ShapeShapeDistance<Halfspace, Plane>;
423 10 distance_matrix[GEOM_HALFSPACE][GEOM_HALFSPACE] =
424 &ShapeShapeDistance<Halfspace, Halfspace>;
425 10 distance_matrix[GEOM_HALFSPACE][GEOM_ELLIPSOID] =
426 &ShapeShapeDistance<Halfspace, Ellipsoid>;
427
428 /* AABB distance not implemented */
429 /*
430 distance_matrix[BV_AABB][GEOM_BOX] = &BVHShapeDistancer<AABB, Box>::distance;
431 distance_matrix[BV_AABB][GEOM_SPHERE] = &BVHShapeDistancer<AABB,
432 Sphere>::distance; distance_matrix[BV_AABB][GEOM_CAPSULE] =
433 &BVHShapeDistancer<AABB, Capsule>::distance;
434 distance_matrix[BV_AABB][GEOM_CONE] = &BVHShapeDistancer<AABB,
435 Cone>::distance; distance_matrix[BV_AABB][GEOM_CYLINDER] =
436 &BVHShapeDistancer<AABB, Cylinder>::distance;
437 distance_matrix[BV_AABB][GEOM_CONVEX] = &BVHShapeDistancer<AABB,
438 ConvexBase>::distance; distance_matrix[BV_AABB][GEOM_PLANE] =
439 &BVHShapeDistancer<AABB, Plane>::distance;
440 distance_matrix[BV_AABB][GEOM_HALFSPACE] = &BVHShapeDistancer<AABB,
441 Halfspace>::distance;
442 */
443
444 10 distance_matrix[BV_OBB][GEOM_BOX] = &BVHShapeDistancer<OBB, Box>::distance;
445 10 distance_matrix[BV_OBB][GEOM_SPHERE] =
446 &BVHShapeDistancer<OBB, Sphere>::distance;
447 10 distance_matrix[BV_OBB][GEOM_CAPSULE] =
448 &BVHShapeDistancer<OBB, Capsule>::distance;
449 10 distance_matrix[BV_OBB][GEOM_CONE] = &BVHShapeDistancer<OBB, Cone>::distance;
450 10 distance_matrix[BV_OBB][GEOM_CYLINDER] =
451 &BVHShapeDistancer<OBB, Cylinder>::distance;
452 10 distance_matrix[BV_OBB][GEOM_CONVEX] =
453 &BVHShapeDistancer<OBB, ConvexBase>::distance;
454 10 distance_matrix[BV_OBB][GEOM_PLANE] =
455 &BVHShapeDistancer<OBB, Plane>::distance;
456 10 distance_matrix[BV_OBB][GEOM_HALFSPACE] =
457 &BVHShapeDistancer<OBB, Halfspace>::distance;
458 10 distance_matrix[BV_OBB][GEOM_ELLIPSOID] =
459 &BVHShapeDistancer<OBB, Ellipsoid>::distance;
460
461 10 distance_matrix[BV_RSS][GEOM_BOX] = &BVHShapeDistancer<RSS, Box>::distance;
462 10 distance_matrix[BV_RSS][GEOM_SPHERE] =
463 &BVHShapeDistancer<RSS, Sphere>::distance;
464 10 distance_matrix[BV_RSS][GEOM_CAPSULE] =
465 &BVHShapeDistancer<RSS, Capsule>::distance;
466 10 distance_matrix[BV_RSS][GEOM_CONE] = &BVHShapeDistancer<RSS, Cone>::distance;
467 10 distance_matrix[BV_RSS][GEOM_CYLINDER] =
468 &BVHShapeDistancer<RSS, Cylinder>::distance;
469 10 distance_matrix[BV_RSS][GEOM_CONVEX] =
470 &BVHShapeDistancer<RSS, ConvexBase>::distance;
471 10 distance_matrix[BV_RSS][GEOM_PLANE] =
472 &BVHShapeDistancer<RSS, Plane>::distance;
473 10 distance_matrix[BV_RSS][GEOM_HALFSPACE] =
474 &BVHShapeDistancer<RSS, Halfspace>::distance;
475 10 distance_matrix[BV_RSS][GEOM_ELLIPSOID] =
476 &BVHShapeDistancer<RSS, Ellipsoid>::distance;
477
478 /* KDOP distance not implemented */
479 /*
480 distance_matrix[BV_KDOP16][GEOM_BOX] = &BVHShapeDistancer<KDOP<16>,
481 Box>::distance; distance_matrix[BV_KDOP16][GEOM_SPHERE] =
482 &BVHShapeDistancer<KDOP<16>, Sphere>::distance;
483 distance_matrix[BV_KDOP16][GEOM_CAPSULE] = &BVHShapeDistancer<KDOP<16>,
484 Capsule>::distance; distance_matrix[BV_KDOP16][GEOM_CONE] =
485 &BVHShapeDistancer<KDOP<16>, Cone>::distance;
486 distance_matrix[BV_KDOP16][GEOM_CYLINDER] = &BVHShapeDistancer<KDOP<16>,
487 Cylinder>::distance; distance_matrix[BV_KDOP16][GEOM_CONVEX] =
488 &BVHShapeDistancer<KDOP<16>, ConvexBase>::distance;
489 distance_matrix[BV_KDOP16][GEOM_PLANE] = &BVHShapeDistancer<KDOP<16>,
490 Plane>::distance; distance_matrix[BV_KDOP16][GEOM_HALFSPACE] =
491 &BVHShapeDistancer<KDOP<16>, Halfspace>::distance;
492
493 distance_matrix[BV_KDOP18][GEOM_BOX] = &BVHShapeDistancer<KDOP<18>,
494 Box>::distance; distance_matrix[BV_KDOP18][GEOM_SPHERE] =
495 &BVHShapeDistancer<KDOP<18>, Sphere>::distance;
496 distance_matrix[BV_KDOP18][GEOM_CAPSULE] = &BVHShapeDistancer<KDOP<18>,
497 Capsule>::distance; distance_matrix[BV_KDOP18][GEOM_CONE] =
498 &BVHShapeDistancer<KDOP<18>, Cone>::distance;
499 distance_matrix[BV_KDOP18][GEOM_CYLINDER] = &BVHShapeDistancer<KDOP<18>,
500 Cylinder>::distance; distance_matrix[BV_KDOP18][GEOM_CONVEX] =
501 &BVHShapeDistancer<KDOP<18>, ConvexBase>::distance;
502 distance_matrix[BV_KDOP18][GEOM_PLANE] = &BVHShapeDistancer<KDOP<18>,
503 Plane>::distance; distance_matrix[BV_KDOP18][GEOM_HALFSPACE] =
504 &BVHShapeDistancer<KDOP<18>, Halfspace>::distance;
505
506 distance_matrix[BV_KDOP24][GEOM_BOX] = &BVHShapeDistancer<KDOP<24>,
507 Box>::distance; distance_matrix[BV_KDOP24][GEOM_SPHERE] =
508 &BVHShapeDistancer<KDOP<24>, Sphere>::distance;
509 distance_matrix[BV_KDOP24][GEOM_CAPSULE] = &BVHShapeDistancer<KDOP<24>,
510 Capsule>::distance; distance_matrix[BV_KDOP24][GEOM_CONE] =
511 &BVHShapeDistancer<KDOP<24>, Cone>::distance;
512 distance_matrix[BV_KDOP24][GEOM_CYLINDER] = &BVHShapeDistancer<KDOP<24>,
513 Cylinder>::distance; distance_matrix[BV_KDOP24][GEOM_CONVEX] =
514 &BVHShapeDistancer<KDOP<24>, ConvexBase>::distance;
515 distance_matrix[BV_KDOP24][GEOM_PLANE] = &BVHShapeDistancer<KDOP<24>,
516 Plane>::distance; distance_matrix[BV_KDOP24][GEOM_HALFSPACE] =
517 &BVHShapeDistancer<KDOP<24>, Halfspace>::distance;
518 */
519
520 10 distance_matrix[BV_kIOS][GEOM_BOX] = &BVHShapeDistancer<kIOS, Box>::distance;
521 10 distance_matrix[BV_kIOS][GEOM_SPHERE] =
522 &BVHShapeDistancer<kIOS, Sphere>::distance;
523 10 distance_matrix[BV_kIOS][GEOM_CAPSULE] =
524 &BVHShapeDistancer<kIOS, Capsule>::distance;
525 10 distance_matrix[BV_kIOS][GEOM_CONE] =
526 &BVHShapeDistancer<kIOS, Cone>::distance;
527 10 distance_matrix[BV_kIOS][GEOM_CYLINDER] =
528 &BVHShapeDistancer<kIOS, Cylinder>::distance;
529 10 distance_matrix[BV_kIOS][GEOM_CONVEX] =
530 &BVHShapeDistancer<kIOS, ConvexBase>::distance;
531 10 distance_matrix[BV_kIOS][GEOM_PLANE] =
532 &BVHShapeDistancer<kIOS, Plane>::distance;
533 10 distance_matrix[BV_kIOS][GEOM_HALFSPACE] =
534 &BVHShapeDistancer<kIOS, Halfspace>::distance;
535 10 distance_matrix[BV_kIOS][GEOM_ELLIPSOID] =
536 &BVHShapeDistancer<kIOS, Ellipsoid>::distance;
537
538 10 distance_matrix[BV_OBBRSS][GEOM_BOX] =
539 &BVHShapeDistancer<OBBRSS, Box>::distance;
540 10 distance_matrix[BV_OBBRSS][GEOM_SPHERE] =
541 &BVHShapeDistancer<OBBRSS, Sphere>::distance;
542 10 distance_matrix[BV_OBBRSS][GEOM_CAPSULE] =
543 &BVHShapeDistancer<OBBRSS, Capsule>::distance;
544 10 distance_matrix[BV_OBBRSS][GEOM_CONE] =
545 &BVHShapeDistancer<OBBRSS, Cone>::distance;
546 10 distance_matrix[BV_OBBRSS][GEOM_CYLINDER] =
547 &BVHShapeDistancer<OBBRSS, Cylinder>::distance;
548 10 distance_matrix[BV_OBBRSS][GEOM_CONVEX] =
549 &BVHShapeDistancer<OBBRSS, ConvexBase>::distance;
550 10 distance_matrix[BV_OBBRSS][GEOM_PLANE] =
551 &BVHShapeDistancer<OBBRSS, Plane>::distance;
552 10 distance_matrix[BV_OBBRSS][GEOM_HALFSPACE] =
553 &BVHShapeDistancer<OBBRSS, Halfspace>::distance;
554 10 distance_matrix[BV_OBBRSS][GEOM_ELLIPSOID] =
555 &BVHShapeDistancer<OBBRSS, Ellipsoid>::distance;
556
557 10 distance_matrix[HF_AABB][GEOM_BOX] =
558 &HeightFieldShapeDistancer<AABB, Box>::distance;
559 10 distance_matrix[HF_AABB][GEOM_SPHERE] =
560 &HeightFieldShapeDistancer<AABB, Sphere>::distance;
561 10 distance_matrix[HF_AABB][GEOM_CAPSULE] =
562 &HeightFieldShapeDistancer<AABB, Capsule>::distance;
563 10 distance_matrix[HF_AABB][GEOM_CONE] =
564 &HeightFieldShapeDistancer<AABB, Cone>::distance;
565 10 distance_matrix[HF_AABB][GEOM_CYLINDER] =
566 &HeightFieldShapeDistancer<AABB, Cylinder>::distance;
567 10 distance_matrix[HF_AABB][GEOM_CONVEX] =
568 &HeightFieldShapeDistancer<AABB, ConvexBase>::distance;
569 10 distance_matrix[HF_AABB][GEOM_PLANE] =
570 &HeightFieldShapeDistancer<AABB, Plane>::distance;
571 10 distance_matrix[HF_AABB][GEOM_HALFSPACE] =
572 &HeightFieldShapeDistancer<AABB, Halfspace>::distance;
573 10 distance_matrix[HF_AABB][GEOM_ELLIPSOID] =
574 &HeightFieldShapeDistancer<AABB, Ellipsoid>::distance;
575
576 10 distance_matrix[HF_OBBRSS][GEOM_BOX] =
577 &HeightFieldShapeDistancer<OBBRSS, Box>::distance;
578 10 distance_matrix[HF_OBBRSS][GEOM_SPHERE] =
579 &HeightFieldShapeDistancer<OBBRSS, Sphere>::distance;
580 10 distance_matrix[HF_OBBRSS][GEOM_CAPSULE] =
581 &HeightFieldShapeDistancer<OBBRSS, Capsule>::distance;
582 10 distance_matrix[HF_OBBRSS][GEOM_CONE] =
583 &HeightFieldShapeDistancer<OBBRSS, Cone>::distance;
584 10 distance_matrix[HF_OBBRSS][GEOM_CYLINDER] =
585 &HeightFieldShapeDistancer<OBBRSS, Cylinder>::distance;
586 10 distance_matrix[HF_OBBRSS][GEOM_CONVEX] =
587 &HeightFieldShapeDistancer<OBBRSS, ConvexBase>::distance;
588 10 distance_matrix[HF_OBBRSS][GEOM_PLANE] =
589 &HeightFieldShapeDistancer<OBBRSS, Plane>::distance;
590 10 distance_matrix[HF_OBBRSS][GEOM_HALFSPACE] =
591 &HeightFieldShapeDistancer<OBBRSS, Halfspace>::distance;
592 10 distance_matrix[HF_OBBRSS][GEOM_ELLIPSOID] =
593 &HeightFieldShapeDistancer<OBBRSS, Ellipsoid>::distance;
594
595 10 distance_matrix[BV_AABB][BV_AABB] = &BVHDistance<AABB>;
596 10 distance_matrix[BV_OBB][BV_OBB] = &BVHDistance<OBB>;
597 10 distance_matrix[BV_RSS][BV_RSS] = &BVHDistance<RSS>;
598 10 distance_matrix[BV_kIOS][BV_kIOS] = &BVHDistance<kIOS>;
599 10 distance_matrix[BV_OBBRSS][BV_OBBRSS] = &BVHDistance<OBBRSS>;
600
601 #ifdef COAL_HAS_OCTOMAP
602 10 distance_matrix[GEOM_OCTREE][GEOM_BOX] = &Distance<OcTree, Box>;
603 10 distance_matrix[GEOM_OCTREE][GEOM_SPHERE] = &Distance<OcTree, Sphere>;
604 10 distance_matrix[GEOM_OCTREE][GEOM_CAPSULE] = &Distance<OcTree, Capsule>;
605 10 distance_matrix[GEOM_OCTREE][GEOM_CONE] = &Distance<OcTree, Cone>;
606 10 distance_matrix[GEOM_OCTREE][GEOM_CYLINDER] = &Distance<OcTree, Cylinder>;
607 10 distance_matrix[GEOM_OCTREE][GEOM_CONVEX] = &Distance<OcTree, ConvexBase>;
608 10 distance_matrix[GEOM_OCTREE][GEOM_PLANE] = &Distance<OcTree, Plane>;
609 10 distance_matrix[GEOM_OCTREE][GEOM_HALFSPACE] = &Distance<OcTree, Halfspace>;
610 10 distance_matrix[GEOM_OCTREE][GEOM_ELLIPSOID] = &Distance<OcTree, Ellipsoid>;
611
612 10 distance_matrix[GEOM_BOX][GEOM_OCTREE] = &Distance<Box, OcTree>;
613 10 distance_matrix[GEOM_SPHERE][GEOM_OCTREE] = &Distance<Sphere, OcTree>;
614 10 distance_matrix[GEOM_CAPSULE][GEOM_OCTREE] = &Distance<Capsule, OcTree>;
615 10 distance_matrix[GEOM_CONE][GEOM_OCTREE] = &Distance<Cone, OcTree>;
616 10 distance_matrix[GEOM_CYLINDER][GEOM_OCTREE] = &Distance<Cylinder, OcTree>;
617 10 distance_matrix[GEOM_CONVEX][GEOM_OCTREE] = &Distance<ConvexBase, OcTree>;
618 10 distance_matrix[GEOM_PLANE][GEOM_OCTREE] = &Distance<Plane, OcTree>;
619 10 distance_matrix[GEOM_HALFSPACE][GEOM_OCTREE] = &Distance<Halfspace, OcTree>;
620
621 10 distance_matrix[GEOM_OCTREE][GEOM_OCTREE] = &Distance<OcTree, OcTree>;
622
623 10 distance_matrix[GEOM_OCTREE][BV_AABB] = &Distance<OcTree, BVHModel<AABB> >;
624 10 distance_matrix[GEOM_OCTREE][BV_OBB] = &Distance<OcTree, BVHModel<OBB> >;
625 10 distance_matrix[GEOM_OCTREE][BV_RSS] = &Distance<OcTree, BVHModel<RSS> >;
626 10 distance_matrix[GEOM_OCTREE][BV_OBBRSS] =
627 &Distance<OcTree, BVHModel<OBBRSS> >;
628 10 distance_matrix[GEOM_OCTREE][BV_kIOS] = &Distance<OcTree, BVHModel<kIOS> >;
629 10 distance_matrix[GEOM_OCTREE][BV_KDOP16] =
630 &Distance<OcTree, BVHModel<KDOP<16> > >;
631 10 distance_matrix[GEOM_OCTREE][BV_KDOP18] =
632 &Distance<OcTree, BVHModel<KDOP<18> > >;
633 10 distance_matrix[GEOM_OCTREE][BV_KDOP24] =
634 &Distance<OcTree, BVHModel<KDOP<24> > >;
635
636 10 distance_matrix[BV_AABB][GEOM_OCTREE] = &Distance<BVHModel<AABB>, OcTree>;
637 10 distance_matrix[BV_OBB][GEOM_OCTREE] = &Distance<BVHModel<OBB>, OcTree>;
638 10 distance_matrix[BV_RSS][GEOM_OCTREE] = &Distance<BVHModel<RSS>, OcTree>;
639 10 distance_matrix[BV_OBBRSS][GEOM_OCTREE] = &Distance<BVHModel<OBBRSS>, OcTree>;
640 10 distance_matrix[BV_kIOS][GEOM_OCTREE] = &Distance<BVHModel<kIOS>, OcTree>;
641 10 distance_matrix[BV_KDOP16][GEOM_OCTREE] =
642 &Distance<BVHModel<KDOP<16> >, OcTree>;
643 10 distance_matrix[BV_KDOP18][GEOM_OCTREE] =
644 &Distance<BVHModel<KDOP<18> >, OcTree>;
645 10 distance_matrix[BV_KDOP24][GEOM_OCTREE] =
646 &Distance<BVHModel<KDOP<24> >, OcTree>;
647 10 distance_matrix[GEOM_OCTREE][HF_AABB] = &distance_function_not_implemented;
648 10 distance_matrix[GEOM_OCTREE][HF_OBBRSS] = &distance_function_not_implemented;
649 10 distance_matrix[HF_AABB][GEOM_OCTREE] = &distance_function_not_implemented;
650 10 distance_matrix[HF_OBBRSS][GEOM_OCTREE] = &distance_function_not_implemented;
651 #endif
652 10 }
653 // template struct DistanceFunctionMatrix;
654 } // namespace coal
655