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