GCC Code Coverage Report

Directory: ./
File: src/collision.cpp
Date: 2025-04-13 14:25:19
Exec Total Coverage
Lines: 62 82 75.6%
Branches: 44 254 17.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/collision.h"
39 #include "coal/collision_utility.h"
40 #include "coal/collision_func_matrix.h"
41 #include "coal/narrowphase/narrowphase.h"
42
43 #include "coal/tracy.hh"
44
45 namespace coal {
46
47 1247941 CollisionFunctionMatrix& getCollisionFunctionLookTable() {
48
4/8
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 1247919 times.
✓ Branch 3 taken 22 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 22 times.
✗ Branch 7 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
 1247941 static CollisionFunctionMatrix table;
49 1247941 return table;
50 }
51
52 // reorder collision results in the order the call has been made.
53 20 void CollisionResult::swapObjects() {
54 20 for (std::vector<Contact>::iterator it = contacts.begin();
55
1/2
✗ Branch 2 not taken.
✓ Branch 3 taken 20 times.
 20 it != contacts.end(); ++it) {
56 ✗ std::swap(it->o1, it->o2);
57 ✗ std::swap(it->b1, it->b2);
58 ✗ it->nearest_points[0].swap(it->nearest_points[1]);
59 ✗ it->normal *= -1;
60 }
61 20 }
62
63 1230588 std::size_t collide(const CollisionObject* o1, const CollisionObject* o2,
64 const CollisionRequest& request, CollisionResult& result) {
65 1230588 return collide(o1->collisionGeometryPtr(), o1->getTransform(),
66 o2->collisionGeometryPtr(), o2->getTransform(), request,
67 1230588 result);
68 }
69
70 1247938 std::size_t collide(const CollisionGeometry* o1, const Transform3s& tf1,
71 const CollisionGeometry* o2, const Transform3s& tf2,
72 const CollisionRequest& request, CollisionResult& result) {
73 COAL_TRACY_ZONE_SCOPED_N("coal::collide");
74 // If security margin is set to -infinity, return that there is no collision
75
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1247938 times.
 1247938 if (request.security_margin == -std::numeric_limits<Scalar>::infinity()) {
76 ✗ result.clear();
77 ✗ return false;
78 }
79
80
1/2
✓ Branch 1 taken 1247938 times.
✗ Branch 2 not taken.
 1247938 GJKSolver solver(request);
81
82
1/2
✓ Branch 1 taken 1247938 times.
✗ Branch 2 not taken.
 1247938 const CollisionFunctionMatrix& looktable = getCollisionFunctionLookTable();
83 std::size_t res;
84
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1247938 times.
 1247938 if (request.num_max_contacts == 0) {
85 ✗ COAL_THROW_PRETTY("Invalid number of max contacts (current value is 0).",
86 std::invalid_argument);
87 res = 0;
88 } else {
89
1/2
✓ Branch 1 taken 1247938 times.
✗ Branch 2 not taken.
 1247938 OBJECT_TYPE object_type1 = o1->getObjectType();
90
1/2
✓ Branch 1 taken 1247938 times.
✗ Branch 2 not taken.
 1247938 OBJECT_TYPE object_type2 = o2->getObjectType();
91
1/2
✓ Branch 1 taken 1247938 times.
✗ Branch 2 not taken.
 1247938 NODE_TYPE node_type1 = o1->getNodeType();
92
1/2
✓ Branch 1 taken 1247938 times.
✗ Branch 2 not taken.
 1247938 NODE_TYPE node_type2 = o2->getNodeType();
93
94
4/4
✓ Branch 0 taken 1234497 times.
✓ Branch 1 taken 13441 times.
✓ Branch 2 taken 1234477 times.
✓ Branch 3 taken 20 times.
 1247938 if (object_type1 == OT_GEOM &&
95
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1234477 times.
 1234477 (object_type2 == OT_BVH || object_type2 == OT_HFIELD)) {
96
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.
 20 if (!looktable.collision_matrix[node_type2][node_type1]) {
97 ✗ COAL_THROW_PRETTY("Collision function between node type "
98 << std::string(get_node_type_name(node_type1))
99 << " and node type "
100 << std::string(get_node_type_name(node_type2))
101 << " is not yet supported.",
102 std::invalid_argument);
103 res = 0;
104 } else {
105
1/2
✓ Branch 1 taken 20 times.
✗ Branch 2 not taken.
 20 res = looktable.collision_matrix[node_type2][node_type1](
106 o2, tf2, o1, tf1, &solver, request, result);
107
1/2
✓ Branch 1 taken 20 times.
✗ Branch 2 not taken.
 20 result.swapObjects();
108
1/2
✓ Branch 3 taken 20 times.
✗ Branch 4 not taken.
 20 result.nearest_points[0].swap(result.nearest_points[1]);
109
1/2
✓ Branch 1 taken 20 times.
✗ Branch 2 not taken.
 20 result.normal *= -1;
110 }
111 20 } else {
112
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1247918 times.
 1247918 if (!looktable.collision_matrix[node_type1][node_type2]) {
113 ✗ COAL_THROW_PRETTY("Collision function between node type "
114 << std::string(get_node_type_name(node_type1))
115 << " and node type "
116 << std::string(get_node_type_name(node_type2))
117 << " is not yet supported.",
118 std::invalid_argument);
119 res = 0;
120 } else
121
1/2
✓ Branch 1 taken 1247918 times.
✗ Branch 2 not taken.
 1247918 res = looktable.collision_matrix[node_type1][node_type2](
122 o1, tf1, o2, tf2, &solver, request, result);
123 }
124 }
125 // Cache narrow phase solver result. If the option in the request is selected,
126 // also store the solver result in the request for the next call.
127
1/2
✓ Branch 1 taken 1247938 times.
✗ Branch 2 not taken.
 1247938 result.cached_gjk_guess = solver.cached_guess;
128
1/2
✓ Branch 1 taken 1247938 times.
✗ Branch 2 not taken.
 1247938 result.cached_support_func_guess = solver.support_func_cached_guess;
129
1/2
✓ Branch 1 taken 1247938 times.
✗ Branch 2 not taken.
 1247938 request.updateGuess(result);
130
131 1247938 return res;
132 1247938 }
133
134 3 ComputeCollision::ComputeCollision(const CollisionGeometry* o1,
135 3 const CollisionGeometry* o2)
136 3 : o1(o1), o2(o2) {
137
1/2
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 3 const CollisionFunctionMatrix& looktable = getCollisionFunctionLookTable();
138
139
1/2
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 3 OBJECT_TYPE object_type1 = o1->getObjectType();
140
1/2
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 3 NODE_TYPE node_type1 = o1->getNodeType();
141
1/2
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 3 OBJECT_TYPE object_type2 = o2->getObjectType();
142
1/2
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 3 NODE_TYPE node_type2 = o2->getNodeType();
143
144
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 4 swap_geoms = object_type1 == OT_GEOM &&
145
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 (object_type2 == OT_BVH || object_type2 == OT_HFIELD);
146
147
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 3 if ((swap_geoms && !looktable.collision_matrix[node_type2][node_type1]) ||
148
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
 3 (!swap_geoms && !looktable.collision_matrix[node_type1][node_type2])) {
149 ✗ COAL_THROW_PRETTY("Collision function between node type "
150 << std::string(get_node_type_name(node_type1))
151 << " and node type "
152 << std::string(get_node_type_name(node_type2))
153 << " is not yet supported.",
154 std::invalid_argument);
155 }
156
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (swap_geoms)
157 ✗ func = looktable.collision_matrix[node_type2][node_type1];
158 else
159 3 func = looktable.collision_matrix[node_type1][node_type2];
160 3 }
161
162 482 std::size_t ComputeCollision::run(const Transform3s& tf1,
163 const Transform3s& tf2,
164 const CollisionRequest& request,
165 CollisionResult& result) const {
166 COAL_TRACY_ZONE_SCOPED_N("coal::ComputeCollision::run");
167 // If security margin is set to -infinity, return that there is no collision
168
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 482 times.
 482 if (request.security_margin == -std::numeric_limits<Scalar>::infinity()) {
169 ✗ result.clear();
170 ✗ return false;
171 }
172 std::size_t res;
173
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 482 times.
 482 if (swap_geoms) {
174 ✗ res = func(o2, tf2, o1, tf1, &solver, request, result);
175 ✗ result.swapObjects();
176 ✗ result.nearest_points[0].swap(result.nearest_points[1]);
177 ✗ result.normal *= -1;
178 } else {
179 482 res = func(o1, tf1, o2, tf2, &solver, request, result);
180 }
181 // Cache narrow phase solver result. If the option in the request is selected,
182 // also store the solver result in the request for the next call.
183 482 result.cached_gjk_guess = solver.cached_guess;
184 482 result.cached_support_func_guess = solver.support_func_cached_guess;
185 482 request.updateGuess(result);
186
187 482 return res;
188 }
189
190 482 std::size_t ComputeCollision::operator()(const Transform3s& tf1,
191 const Transform3s& tf2,
192 const CollisionRequest& request,
193 CollisionResult& result) const
194
195 {
196 482 solver.set(request);
197
198 std::size_t res;
199
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 482 times.
 482 if (request.enable_timings) {
200 ✗ Timer timer;
201 ✗ res = run(tf1, tf2, request, result);
202 ✗ result.timings = timer.elapsed();
203 } else
204 482 res = run(tf1, tf2, request, result);
205
206 482 return res;
207 }
208
209 } // namespace coal
210