GCC Code Coverage Report

Directory:	./
File:	include/coal/broadphase/default_broadphase_callbacks.h
Date:	2025-06-03 17:15:40

	Exec	Total	Coverage
Lines:	14	15	93.3%
Functions:	8	9	88.9%
Branches:	0	0	-%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Software License Agreement (BSD License)
    
       *
    
       *  Copyright (c) 2020, Toyota Research Institute
    
       *  Copyright (c) 2022-2023, INRIA
    
       *  All rights reserved.
    
       *
    
       *  Redistribution and use in source and binary forms, with or without
    
       *  modification, are permitted provided that the following conditions
    
       *  are met:
    
       *
    
       *   * Redistributions of source code must retain the above copyright
    
       *     notice, this list of conditions and the following disclaimer.
    
       *   * Redistributions in binary form must reproduce the above
    
       *     copyright notice, this list of conditions and the following
    
       *     disclaimer in the documentation and/or other materials provided
    
       *     with the distribution.
    
       *   * Neither the name of the copyright holder nor the names of its
    
       *     contributors may be used to endorse or promote products derived
    
       *     from this software without specific prior written permission.
    
       *
    
       *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    
       *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    
       *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    
       *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    
       *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    
       *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    
       *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    
       *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    
       *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    
       *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    
       *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    
       *  POSSIBILITY OF SUCH DAMAGE.
    
       */
    
      /** @author Sean Curtis (sean@tri.global) */
    
      /** @author Justin Carpentier (justin.carpentier@inria.fr) */
    
      #ifndef COAL_BROADPHASE_DEFAULT_BROADPHASE_CALLBACKS_H
    
      #define COAL_BROADPHASE_DEFAULT_BROADPHASE_CALLBACKS_H
    
      #include "coal/broadphase/broadphase_callbacks.h"
    
      #include "coal/collision.h"
    
      #include "coal/distance.h"
    
      // #include "coal/narrowphase/continuous_collision.h"
    
      // #include "coal/narrowphase/continuous_collision_request.h"
    
      // #include "coal/narrowphase/continuous_collision_result.h"
    
      // #include "coal/narrowphase/distance_request.h"
    
      // #include "coal/narrowphase/distance_result.h"
    
      namespace coal {
    
      /// @brief Collision data stores the collision request and the result given by
    
      /// collision algorithm.
    
      struct CollisionData {
    
      35655
        CollisionData() { done = false; }
    
        /// @brief Collision request
    
        CollisionRequest request;
    
        /// @brief Collision result
    
        CollisionResult result;
    
        /// @brief Whether the collision iteration can stop
    
        bool done;
    
        /// @brief Clears the CollisionData
    
      31689
        void clear() {
    
      31689
          result.clear();
    
      31689
          done = false;
    
      31689
        }
    
      };
    
      /// @brief Distance data stores the distance request and the result given by
    
      /// distance algorithm.
    
      struct DistanceData {
    
      774
        DistanceData() { done = false; }
    
        /// @brief Distance request
    
        DistanceRequest request;
    
        /// @brief Distance result
    
        DistanceResult result;
    
        /// @brief Whether the distance iteration can stop
    
        bool done;
    
        /// @brief Clears the DistanceData
    
      688
        void clear() {
    
      688
          result.clear();
    
      688
          done = false;
    
      688
        }
    
      };
    
      /// @brief Provides a simple callback for the collision query in the
    
      /// BroadPhaseCollisionManager. It assumes the `data` parameter is non-null and
    
      /// points to an instance of CollisionData. It simply invokes the
    
      /// `collide()` method on the culled pair of geometries and stores the results
    
      /// in the data's CollisionResult instance.
    
      ///
    
      /// This callback will cause the broadphase evaluation to stop if:
    
      ///   - the collision requests _disables_ cost _and_
    
      ///   - the collide() reports a collision for the culled pair, _and_
    
      ///   - we've reported the number of contacts requested in the CollisionRequest.
    
      ///
    
      /// For a given instance of CollisionData, if broadphase evaluation has
    
      /// already terminated (i.e., defaultCollisionFunction() returned `true`),
    
      /// subsequent invocations with the same instance of CollisionData will
    
      /// return immediately, requesting termination of broadphase evaluation (i.e.,
    
      /// return `true`).
    
      ///
    
      /// @param o1   The first object in the culled pair.
    
      /// @param o2   The second object in the culled pair.
    
      /// @param data A non-null pointer to a CollisionData instance.
    
      /// @return `true` if the broadphase evaluation should stop.
    
      /// @tparam S   The scalar type with which the computation will be performed.
    
      bool defaultCollisionFunction(CollisionObject* o1, CollisionObject* o2,
    
                                    void* data);
    
      /// @brief Collision data for use with the DefaultContinuousCollisionFunction.
    
      /// It stores the collision request and the result given by the collision
    
      /// algorithm (and stores the conclusion of whether further evaluation of the
    
      /// broadphase collision manager has been deemed unnecessary).
    
      // struct DefaultContinuousCollisionData {
    
      //   ContinuousCollisionRequest request;
    
      //   ContinuousCollisionResult result;
    
      //
    
      //   /// If `true`, requests that the broadphase evaluation stop.
    
      //   bool done{false};
    
      // };
    
      /// @brief Provides a simple callback for the continuous collision query in the
    
      /// BroadPhaseCollisionManager. It assumes the `data` parameter is non-null and
    
      /// points to an instance of DefaultContinuousCollisionData. It simply invokes
    
      /// the `collide()` method on the culled pair of geometries and stores the
    
      /// results in the data's ContinuousCollisionResult instance.
    
      ///
    
      /// This callback will never cause the broadphase evaluation to terminate early.
    
      /// However, if the `done` member of the DefaultContinuousCollisionData is set
    
      /// to true, this method will simply return without doing any computation.
    
      ///
    
      /// For a given instance of DefaultContinuousCollisionData, if broadphase
    
      /// evaluation has already terminated (i.e.,
    
      /// DefaultContinuousCollisionFunction() returned `true`), subsequent
    
      /// invocations with the same instance of CollisionData will return
    
      /// immediately, requesting termination of broadphase evaluation (i.e., return
    
      /// `true`).
    
      ///
    
      /// @param o1   The first object in the culled pair.
    
      /// @param o2   The second object in the culled pair.
    
      /// @param data A non-null pointer to a CollisionData instance.
    
      /// @return True if the broadphase evaluation should stop.
    
      /// @tparam S   The scalar type with which the computation will be performed.
    
      // bool DefaultContinuousCollisionFunction(ContinuousCollisionObject* o1,
    
      //                                         ContinuousCollisionObject* o2,
    
      //                                         void* data) {
    
      //   assert(data != nullptr);
    
      //   auto* cdata = static_cast<DefaultContinuousCollisionData*>(data);
    
      //
    
      //   if (cdata->done) return true;
    
      //
    
      //   const ContinuousCollisionRequest& request = cdata->request;
    
      //   ContinuousCollisionResult& result = cdata->result;
    
      //   collide(o1, o2, request, result);
    
      //
    
      //   return cdata->done;
    
      // }
    
      /// @brief Provides a simple callback for the distance query in the
    
      /// BroadPhaseCollisionManager. It assumes the `data` parameter is non-null and
    
      /// points to an instance of DistanceData. It simply invokes the
    
      /// `distance()` method on the culled pair of geometries and stores the results
    
      /// in the data's DistanceResult instance.
    
      ///
    
      /// This callback will cause the broadphase evaluation to stop if:
    
      ///   - The distance is less than or equal to zero (i.e., the pair is in
    
      ///     contact).
    
      ///
    
      /// For a given instance of DistanceData, if broadphase evaluation has
    
      /// already terminated (i.e., defaultDistanceFunction() returned `true`),
    
      /// subsequent invocations with the same instance of DistanceData will
    
      /// simply report the previously reported minimum distance and request
    
      /// termination of broadphase evaluation (i.e., return `true`).
    
      ///
    
      /// @param o1     The first object in the culled pair.
    
      /// @param o2     The second object in the culled pair.
    
      /// @param data   A non-null pointer to a DistanceData instance.
    
      /// @param dist   The distance computed by distance().
    
      /// @return `true` if the broadphase evaluation should stop.
    
      /// @tparam S   The scalar type with which the computation will be performed.
    
      bool defaultDistanceFunction(CollisionObject* o1, CollisionObject* o2,
    
                                   void* data, Scalar& dist);
    
      /// @brief Default collision callback to check collision between collision
    
      /// objects.
    
      struct COAL_DLLAPI CollisionCallBackDefault : CollisionCallBackBase {
    
        /// @brief Initialize the callback.
    
        /// Clears the collision result and sets the done boolean to false.
    
      31689
        void init() { data.clear(); }
    
        bool collide(CollisionObject* o1, CollisionObject* o2);
    
        CollisionData data;
    
      71094
        virtual ~CollisionCallBackDefault() {};
    
      };
    
      /// @brief Default distance callback to check collision between collision
    
      /// objects.
    
      struct COAL_DLLAPI DistanceCallBackDefault : DistanceCallBackBase {
    
        /// @brief Initialize the callback.
    
        /// Clears the distance result and sets the done boolean to false.
    
      688
        void init() { data.clear(); }
    
        bool distance(CollisionObject* o1, CollisionObject* o2, Scalar& dist);
    
        DistanceData data;
    
      1548
        virtual ~DistanceCallBackDefault() {};
    
      };
    
      /// @brief Collision callback to collect collision pairs potentially in contacts
    
      struct COAL_DLLAPI CollisionCallBackCollect : CollisionCallBackBase {
    
        typedef std::pair<CollisionObject*, CollisionObject*> CollisionPair;
    
        /// @brief Default constructor.
    
        CollisionCallBackCollect(const size_t max_size);
    
        bool collide(CollisionObject* o1, CollisionObject* o2);
    
        /// @brief Returns the number of registered collision pairs
    
        size_t numCollisionPairs() const;
    
        /// @brief Returns a const reference to the active collision_pairs to check
    
        const std::vector<CollisionPair>& getCollisionPairs() const;
    
        /// @brief Reset the callback
    
        void init();
    
        /// @brief Check whether a collision pair exists
    
        bool exist(const CollisionPair& pair) const;
    
        /// @brief Check whether a collision pair exists
    
        bool exist(CollisionObject* o1, CollisionObject* o2) const;
    
      ✗
        virtual ~CollisionCallBackCollect() {};
    
       protected:
    
        std::vector<CollisionPair> collision_pairs;
    
        size_t max_size;
    
      };
    
      }  // namespace coal
    
      #endif  // COAL_BROADPHASE_DEFAULT_BROADPHASE_CALLBACKS_H

Line	Exec	Source
1		/*
2		* Software License Agreement (BSD License)
3		*
4		* Copyright (c) 2020, Toyota Research Institute
5		* Copyright (c) 2022-2023, INRIA
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 the copyright holder 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 Sean Curtis (sean@tri.global) */
37		/** @author Justin Carpentier (justin.carpentier@inria.fr) */
38
39		#ifndef COAL_BROADPHASE_DEFAULT_BROADPHASE_CALLBACKS_H
40		#define COAL_BROADPHASE_DEFAULT_BROADPHASE_CALLBACKS_H
41
42		#include "coal/broadphase/broadphase_callbacks.h"
43		#include "coal/collision.h"
44		#include "coal/distance.h"
45		// #include "coal/narrowphase/continuous_collision.h"
46		// #include "coal/narrowphase/continuous_collision_request.h"
47		// #include "coal/narrowphase/continuous_collision_result.h"
48		// #include "coal/narrowphase/distance_request.h"
49		// #include "coal/narrowphase/distance_result.h"
50
51		namespace coal {
52
53		/// @brief Collision data stores the collision request and the result given by
54		/// collision algorithm.
55		struct CollisionData {
56	35655	CollisionData() { done = false; }
57
58		/// @brief Collision request
59		CollisionRequest request;
60
61		/// @brief Collision result
62		CollisionResult result;
63
64		/// @brief Whether the collision iteration can stop
65		bool done;
66
67		/// @brief Clears the CollisionData
68	31689	void clear() {
69	31689	result.clear();
70	31689	done = false;
71	31689	}
72		};
73
74		/// @brief Distance data stores the distance request and the result given by
75		/// distance algorithm.
76		struct DistanceData {
77	774	DistanceData() { done = false; }
78
79		/// @brief Distance request
80		DistanceRequest request;
81
82		/// @brief Distance result
83		DistanceResult result;
84
85		/// @brief Whether the distance iteration can stop
86		bool done;
87
88		/// @brief Clears the DistanceData
89	688	void clear() {
90	688	result.clear();
91	688	done = false;
92	688	}
93		};
94
95		/// @brief Provides a simple callback for the collision query in the
96		/// BroadPhaseCollisionManager. It assumes the `data` parameter is non-null and
97		/// points to an instance of CollisionData. It simply invokes the
98		/// `collide()` method on the culled pair of geometries and stores the results
99		/// in the data's CollisionResult instance.
100		///
101		/// This callback will cause the broadphase evaluation to stop if:
102		/// - the collision requests _disables_ cost _and_
103		/// - the collide() reports a collision for the culled pair, _and_
104		/// - we've reported the number of contacts requested in the CollisionRequest.
105		///
106		/// For a given instance of CollisionData, if broadphase evaluation has
107		/// already terminated (i.e., defaultCollisionFunction() returned `true`),
108		/// subsequent invocations with the same instance of CollisionData will
109		/// return immediately, requesting termination of broadphase evaluation (i.e.,
110		/// return `true`).
111		///
112		/// @param o1 The first object in the culled pair.
113		/// @param o2 The second object in the culled pair.
114		/// @param data A non-null pointer to a CollisionData instance.
115		/// @return `true` if the broadphase evaluation should stop.
116		/// @tparam S The scalar type with which the computation will be performed.
117		bool defaultCollisionFunction(CollisionObject* o1, CollisionObject* o2,
118		void* data);
119
120		/// @brief Collision data for use with the DefaultContinuousCollisionFunction.
121		/// It stores the collision request and the result given by the collision
122		/// algorithm (and stores the conclusion of whether further evaluation of the
123		/// broadphase collision manager has been deemed unnecessary).
124		// struct DefaultContinuousCollisionData {
125		// ContinuousCollisionRequest request;
126		// ContinuousCollisionResult result;
127		//
128		// /// If `true`, requests that the broadphase evaluation stop.
129		// bool done{false};
130		// };
131
132		/// @brief Provides a simple callback for the continuous collision query in the
133		/// BroadPhaseCollisionManager. It assumes the `data` parameter is non-null and
134		/// points to an instance of DefaultContinuousCollisionData. It simply invokes
135		/// the `collide()` method on the culled pair of geometries and stores the
136		/// results in the data's ContinuousCollisionResult instance.
137		///
138		/// This callback will never cause the broadphase evaluation to terminate early.
139		/// However, if the `done` member of the DefaultContinuousCollisionData is set
140		/// to true, this method will simply return without doing any computation.
141		///
142		/// For a given instance of DefaultContinuousCollisionData, if broadphase
143		/// evaluation has already terminated (i.e.,
144		/// DefaultContinuousCollisionFunction() returned `true`), subsequent
145		/// invocations with the same instance of CollisionData will return
146		/// immediately, requesting termination of broadphase evaluation (i.e., return
147		/// `true`).
148		///
149		/// @param o1 The first object in the culled pair.
150		/// @param o2 The second object in the culled pair.
151		/// @param data A non-null pointer to a CollisionData instance.
152		/// @return True if the broadphase evaluation should stop.
153		/// @tparam S The scalar type with which the computation will be performed.
154		// bool DefaultContinuousCollisionFunction(ContinuousCollisionObject* o1,
155		// ContinuousCollisionObject* o2,
156		// void* data) {
157		// assert(data != nullptr);
158		// auto* cdata = static_cast<DefaultContinuousCollisionData*>(data);
159		//
160		// if (cdata->done) return true;
161		//
162		// const ContinuousCollisionRequest& request = cdata->request;
163		// ContinuousCollisionResult& result = cdata->result;
164		// collide(o1, o2, request, result);
165		//
166		// return cdata->done;
167		// }
168
169		/// @brief Provides a simple callback for the distance query in the
170		/// BroadPhaseCollisionManager. It assumes the `data` parameter is non-null and
171		/// points to an instance of DistanceData. It simply invokes the
172		/// `distance()` method on the culled pair of geometries and stores the results
173		/// in the data's DistanceResult instance.
174		///
175		/// This callback will cause the broadphase evaluation to stop if:
176		/// - The distance is less than or equal to zero (i.e., the pair is in
177		/// contact).
178		///
179		/// For a given instance of DistanceData, if broadphase evaluation has
180		/// already terminated (i.e., defaultDistanceFunction() returned `true`),
181		/// subsequent invocations with the same instance of DistanceData will
182		/// simply report the previously reported minimum distance and request
183		/// termination of broadphase evaluation (i.e., return `true`).
184		///
185		/// @param o1 The first object in the culled pair.
186		/// @param o2 The second object in the culled pair.
187		/// @param data A non-null pointer to a DistanceData instance.
188		/// @param dist The distance computed by distance().
189		/// @return `true` if the broadphase evaluation should stop.
190		/// @tparam S The scalar type with which the computation will be performed.
191		bool defaultDistanceFunction(CollisionObject* o1, CollisionObject* o2,
192		void* data, Scalar& dist);
193
194		/// @brief Default collision callback to check collision between collision
195		/// objects.
196		struct COAL_DLLAPI CollisionCallBackDefault : CollisionCallBackBase {
197		/// @brief Initialize the callback.
198		/// Clears the collision result and sets the done boolean to false.
199	31689	void init() { data.clear(); }
200
201		bool collide(CollisionObject* o1, CollisionObject* o2);
202
203		CollisionData data;
204
205	71094	virtual ~CollisionCallBackDefault() {};
206		};
207
208		/// @brief Default distance callback to check collision between collision
209		/// objects.
210		struct COAL_DLLAPI DistanceCallBackDefault : DistanceCallBackBase {
211		/// @brief Initialize the callback.
212		/// Clears the distance result and sets the done boolean to false.
213	688	void init() { data.clear(); }
214
215		bool distance(CollisionObject* o1, CollisionObject* o2, Scalar& dist);
216
217		DistanceData data;
218
219	1548	virtual ~DistanceCallBackDefault() {};
220		};
221
222		/// @brief Collision callback to collect collision pairs potentially in contacts
223		struct COAL_DLLAPI CollisionCallBackCollect : CollisionCallBackBase {
224		typedef std::pair<CollisionObject, CollisionObject> CollisionPair;
225
226		/// @brief Default constructor.
227		CollisionCallBackCollect(const size_t max_size);
228
229		bool collide(CollisionObject* o1, CollisionObject* o2);
230
231		/// @brief Returns the number of registered collision pairs
232		size_t numCollisionPairs() const;
233
234		/// @brief Returns a const reference to the active collision_pairs to check
235		const std::vector<CollisionPair>& getCollisionPairs() const;
236
237		/// @brief Reset the callback
238		void init();
239
240		/// @brief Check whether a collision pair exists
241		bool exist(const CollisionPair& pair) const;
242
243		/// @brief Check whether a collision pair exists
244		bool exist(CollisionObject* o1, CollisionObject* o2) const;
245
246	✗	virtual ~CollisionCallBackCollect() {};
247
248		protected:
249		std::vector<CollisionPair> collision_pairs;
250		size_t max_size;
251		};
252
253		} // namespace coal
254
255		#endif // COAL_BROADPHASE_DEFAULT_BROADPHASE_CALLBACKS_H
256

Function (Line)	Call count	Block coverage
coal::CollisionCallBackCollect::~CollisionCallBackCollect() (line 246)	not called	0.0%
coal::CollisionCallBackDefault::init() (line 199)	called 31689 times, returned 31689 times	100.0%
coal::CollisionCallBackDefault::~CollisionCallBackDefault() (line 205)	called 35547 times, returned 35547 times	100.0%
coal::CollisionData::CollisionData() (line 56)	called 35655 times, returned 35655 times	100.0%
coal::CollisionData::clear() (line 68)	called 31689 times, returned 31689 times	100.0%
coal::DistanceCallBackDefault::init() (line 213)	called 688 times, returned 688 times	100.0%
coal::DistanceCallBackDefault::~DistanceCallBackDefault() (line 219)	called 774 times, returned 774 times	100.0%
coal::DistanceData::DistanceData() (line 77)	called 774 times, returned 774 times	100.0%
coal::DistanceData::clear() (line 89)	called 688 times, returned 688 times	100.0%