GCC Code Coverage Report


Directory: ./
File: include/hpp/core/steering-method/snibud.hh
Date: 2024-12-13 16:14:03
Exec Total Coverage
Lines: 0 14 0.0%
Branches: 0 6 0.0%

Line Branch Exec Source
1 //
2 // Copyright (c) 2017 CNRS
3 // Authors: Florent Lamiraux
4 //
5
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
8 // met:
9 //
10 // 1. Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 //
13 // 2. Redistributions in binary form must reproduce the above copyright
14 // notice, this list of conditions and the following disclaimer in the
15 // documentation and/or other materials provided with the distribution.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
28 // DAMAGE.
29
30 #ifndef HPP_CORE_STEERING_METHOD_SNIBUD_HH
31 #define HPP_CORE_STEERING_METHOD_SNIBUD_HH
32
33 #include <hpp/core/config.hh>
34 #include <hpp/core/fwd.hh>
35 #include <hpp/core/steering-method/car-like.hh>
36 #include <hpp/util/debug.hh>
37 #include <hpp/util/pointer.hh>
38
39 namespace hpp {
40 namespace core {
41 namespace steeringMethod {
42 /// \addtogroup steering_method
43 /// \{
44
45 /// Steering method that creates backward Dubins paths
46 ///
47 class HPP_CORE_DLLAPI Snibud : public CarLike {
48 public:
49 /// Create an instance
50 ///
51 /// This constructor assumes that:
52 /// - the 2 parameters of the configurations corresponds to the XY
53 /// translation joint,
54 /// - the 2 following parameters corresponds to the RZ unbounded
55 /// rotation joint.
56 /// Use CarLike::setWheelJoints to set the wheel joints.
57 static SnibudPtr_t createWithGuess(const ProblemConstPtr_t& problem) {
58 Snibud* ptr = new Snibud(problem);
59 SnibudPtr_t shPtr(ptr);
60 ptr->init(shPtr);
61 return shPtr;
62 }
63
64 /// Create an instance
65 ///
66 /// This constructor does no assumption.
67 static SnibudPtr_t create(
68 const ProblemConstPtr_t& problem, const value_type turningRadius,
69 JointPtr_t xyJoint, JointPtr_t rzJoint,
70 std::vector<JointPtr_t> wheels = std::vector<JointPtr_t>()) {
71 Snibud* ptr = new Snibud(problem, turningRadius, xyJoint, rzJoint, wheels);
72 SnibudPtr_t shPtr(ptr);
73 ptr->init(shPtr);
74 return shPtr;
75 }
76
77 /// Copy instance and return shared pointer
78 static SnibudPtr_t createCopy(const SnibudPtr_t& other) {
79 Snibud* ptr = new Snibud(*other);
80 SnibudPtr_t shPtr(ptr);
81 ptr->init(shPtr);
82 return shPtr;
83 }
84
85 /// Copy instance and return shared pointer
86 virtual SteeringMethodPtr_t copy() const { return createCopy(weak_.lock()); }
87
88 /// create a path between two configurations
89 virtual PathPtr_t impl_compute(ConfigurationIn_t q1,
90 ConfigurationIn_t q2) const;
91
92 protected:
93 /// Constructor
94 Snibud(const ProblemConstPtr_t& problem);
95
96 /// Constructor
97 Snibud(const ProblemConstPtr_t& problem, const value_type turningRadius,
98 JointPtr_t xyJoint, JointPtr_t rzJoint,
99 std::vector<JointPtr_t> wheels);
100
101 /// Copy constructor
102 Snibud(const Snibud& other);
103
104 /// Store weak pointer to itself
105 void init(SnibudWkPtr_t weak) {
106 CarLike::init(weak);
107 weak_ = weak;
108 }
109
110 private:
111 SnibudWkPtr_t weak_;
112 }; // Snibud
113 /// \}
114 } // namespace steeringMethod
115 } // namespace core
116 } // namespace hpp
117 #endif // HPP_CORE_STEERING_METHOD_SNIBUD_HH
118