Merge remote-tracking branch 'jmirabel/devel' into devel

CMakeLists.txt

@@ -46,8 +46,8 @@ FIND_PACKAGE(Boost REQUIRED COMPONENTS unit_test_framework)
 
 # Declare Headers
 SET(${PROJECT_NAME}_HEADERS
-  include/hpp/core/basic-configuration-shooter.hh # DEPRECATED
   include/hpp/core/bi-rrt-planner.hh
+  include/hpp/core/collision-pair.hh
   include/hpp/core/collision-path-validation-report.hh
   include/hpp/core/collision-validation.hh
   include/hpp/core/relative-motion.hh
@@ -75,17 +75,13 @@ SET(${PROJECT_NAME}_HEADERS
   include/hpp/core/distance-between-objects.hh
   include/hpp/core/dubins-path.hh
   include/hpp/core/edge.hh
-  include/hpp/core/explicit-numerical-constraint.hh
-  include/hpp/core/explicit-relative-transformation.hh
   include/hpp/core/fwd.hh
   include/hpp/core/joint-bound-validation.hh
-  include/hpp/core/equation.hh
   include/hpp/core/obstacle-user.hh
   include/hpp/core/path-validations.hh
   include/hpp/core/path-validation/discretized.hh
   include/hpp/core/path-validation/discretized-collision-checking.hh
   include/hpp/core/path-validation/discretized-joint-bound.hh
-  include/hpp/core/numerical-constraint.hh
   include/hpp/core/node.hh
   include/hpp/core/parameter.hh
   include/hpp/core/path.hh

include/hpp/core/basic-configuration-shooter.hh

-//
-// Copyright (c) 2014 CNRS
-// Authors: Florent Lamiraux
-//
-// This file is part of hpp-core
-// hpp-core is free software: you can redistribute it
-// and/or modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation, either version
-// 3 of the License, or (at your option) any later version.
-//
-// hpp-core is distributed in the hope that it will be
-// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Lesser Public License for more details.  You should have
-// received a copy of the GNU Lesser General Public License along with
-// hpp-core  If not, see
-// <http://www.gnu.org/licenses/>.
-
-#ifndef HPP_CORE_BASIC_CONFIGURATION_SHOOTER_HH
-# define HPP_CORE_BASIC_CONFIGURATION_SHOOTER_HH
-
-# warning "This file is deprecated. You should only include hpp/core/configuration-shooter/uniform.hh"
-
-# include <hpp/core/configuration-shooter/uniform.hh>
-
-namespace hpp {
-  namespace core {
-    /// \addtogroup configuration_sampling
-    /// \{
-    typedef configurationShooter::Uniform      BasicConfigurationShooter;
-    typedef configurationShooter::UniformPtr_t BasicConfigurationShooterPtr_t;
-    /// \}
-  } //   namespace core
-} // namespace hpp
-
-#endif // HPP_CORE_BASIC_CONFIGURATION_SHOOTER_HH

include/hpp/core/collision-pair.hh

+//
+// Copyright (c) 2021 CNRS
+// Authors: Joseph Mirabel
+//
+// This file is part of hpp-core
+// hpp-core is free software: you can redistribute it
+// and/or modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation, either version
+// 3 of the License, or (at your option) any later version.
+//
+// hpp-core is distributed in the hope that it will be
+// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Lesser Public License for more details.  You should have
+// received a copy of the GNU Lesser General Public License along with
+// hpp-core  If not, see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef HPP_CORE_COLLISION_PAIR_HH
+# define HPP_CORE_COLLISION_PAIR_HH
+
+#include <hpp/fcl/collision.h>
+#include <pinocchio/spatial/fcl-pinocchio-conversions.hpp>
+
+#include <hpp/pinocchio/device-data.hh>
+#include <hpp/pinocchio/collision-object.hh>
+#include <hpp/core/fwd.hh>
+
+namespace hpp {
+namespace core {
+
+struct CollisionPair {
+  CollisionObjectConstPtr_t first;
+  CollisionObjectConstPtr_t second;
+  fcl::ComputeCollision computeCollision;
+
+  inline CollisionPair (CollisionObjectConstPtr_t f, CollisionObjectConstPtr_t s)
+    : first(f), second(s), computeCollision(f->geometry().get(), s->geometry().get())
+  {}
+
+  inline auto collide(fcl::CollisionRequest& request, fcl::CollisionResult& result) const
+    //decltype(computeCollision(tf1,tf2,request,result))
+  {
+    assert(!first ->getTransform(d).translation().hasNaN());
+    assert(!first ->getTransform(d).rotation   ().hasNaN());
+    assert(!second->getTransform(d).translation().hasNaN());
+    assert(!second->getTransform(d).rotation   ().hasNaN());
+    return computeCollision(
+        first ->getFclTransform(),
+        second->getFclTransform(),
+        request,result);
+  }
+
+  inline auto collide(const pinocchio::DeviceData& d,
+      fcl::CollisionRequest& request, fcl::CollisionResult& result) const
+    //decltype(computeCollision(tf1,tf2,request,result))
+  {
+    using ::pinocchio::toFclTransform3f;
+    assert(!first ->getTransform(d).translation().hasNaN());
+    assert(!first ->getTransform(d).rotation   ().hasNaN());
+    assert(!second->getTransform(d).translation().hasNaN());
+    assert(!second->getTransform(d).rotation   ().hasNaN());
+    return computeCollision(
+        toFclTransform3f(first ->getTransform (d)),
+        toFclTransform3f(second->getTransform (d)),
+        request,result);
+  }
+};
+
+} // namespace core
+} // namespace hpp
+#endif // HPP_CORE_COLLISION_PAIR_HH

include/hpp/core/collision-validation-report.hh

@@ -24,6 +24,7 @@
 # include <hpp/pinocchio/collision-object.hh>
 # include <hpp/core/validation-report.hh>
 # include <hpp/fcl/collision_data.h>
+# include <hpp/core/collision-pair.hh>
 
 namespace hpp {
   namespace core {

include/hpp/core/config-projector.hh

@@ -92,13 +92,6 @@ namespace hpp {
       bool contains (const constraints::ImplicitPtr_t& numericalConstraint)
         const;
 
-      /// \copydoc ConfigProjector::add(const constraints::ImplicitPtr_t&, const std::size_t)
-      /// \param passiveDofs column indices of the jacobian vector that will be
-      ///        set to zero when solving.
-      bool add (const constraints::ImplicitPtr_t& numericalConstraint,
-		const segments_t& passiveDofs = segments_t (0),
-		const std::size_t priority = 0);
-
       /// Add a numerical constraint
       ///
       /// \note The intervals are interpreted as a list of couple
@@ -109,10 +102,7 @@ namespace hpp {
       ///        optional.
       /// \return false if numerical constraint had already been inserted.
       bool add (const constraints::ImplicitPtr_t& numericalConstraint,
-		const std::size_t priority)
-      {
-        return add (numericalConstraint, segments_t(0), priority);
-      }
+		const std::size_t priority = 0);
 
       void lastIsOptional (bool optional);
 
@@ -169,12 +159,6 @@ namespace hpp {
 				    vectorOut_t value,
 				    matrixOut_t reducedJacobian);
 
-      /// Execute one iteration of the projection algorithm
-      /// \return true if the constraints are satisfied
-      /// \deprecated use solver().oneStep is needed
-      bool oneStep (ConfigurationOut_t config, vectorOut_t dq,
-          const value_type& alpha) HPP_CORE_DEPRECATED;
-
       /// \name Compression of locked degrees of freedom
       ///
       /// Degrees of freedom related to locked joint are not taken into
@@ -186,10 +170,6 @@ namespace hpp {
       /// Return the number of free variables
       size_type numberFreeVariables () const;
 
-      /// Get number of non-locked degrees of freedom
-      /// \deprecated Call numberFreeVariables instead
-      size_type numberNonLockedDof () const HPP_CORE_DEPRECATED;
-
       /// Get constraint dimension
       size_type dimension () const;
 

include/hpp/core/config-validation.hh

@@ -45,12 +45,10 @@ namespace hpp {
       virtual bool validate (const Configuration_t& config,
 			     ValidationReportPtr_t& validationReport) = 0;
 
-      virtual ~ConfigValidation () {};
+      virtual ~ConfigValidation () = default;
 
     protected:
-      ConfigValidation ()
-      {
-      }
+      ConfigValidation () = default;
     }; // class ConfigValidation
     /// \}
   } // namespace core

include/hpp/core/config-validations.hh

@@ -52,7 +52,10 @@ namespace hpp {
       size_type numberConfigValidations() const;
 
     protected:
-      ConfigValidations ();
+      ConfigValidations () = default;
+      ConfigValidations(std::initializer_list<ConfigValidationPtr_t> validations) :
+        ObstacleUserVector (validations)
+      {};
     }; // class ConfigValidation
     /// \}
   } // namespace core

include/hpp/core/container.hh

@@ -18,30 +18,21 @@
 # define HPP_CORE_CONTAINER_HH
 
 # include <map>
-# include <list>
 # include <stdexcept>
+# include <type_traits>
 
-# include <boost/smart_ptr/shared_ptr.hpp>
-
-# include <boost/mpl/inherit_linearly.hpp>
-# include <boost/mpl/fold.hpp>
-# include <boost/mpl/inherit.hpp>
-# include <boost/mpl/vector.hpp>
-# include <boost/mpl/for_each.hpp>
-# include <boost/type_traits/is_pointer.hpp>
-# include <boost/type_traits/remove_pointer.hpp>
-
+# include <hpp/util/pointer.hh>
 # include <hpp/core/config.hh>
 
 namespace hpp {
   namespace core {
     /// @cond INTERNAL
     namespace internal {
-      template <typename T> struct is_pointer : boost::is_pointer<T> {};
-      template <typename T> struct is_pointer<boost::shared_ptr<T> > : boost::true_type {};
-      template <typename T> struct remove_pointer : boost::remove_pointer<T> {};
-      template <typename T> struct remove_pointer<boost::shared_ptr<T> > { typedef T type; };
-      template <typename T> struct remove_pointer<const boost::shared_ptr<T> > { typedef T type; };
+      template <typename T> struct is_pointer : std::is_pointer<T> {};
+      template <typename T> struct is_pointer<shared_ptr<T> > : std::true_type {};
+      template <typename T> struct remove_pointer : std::remove_pointer<T> {};
+      template <typename T> struct remove_pointer<shared_ptr<T> > { typedef T type; };
+      template <typename T> struct remove_pointer<const shared_ptr<T> > { typedef T type; };
 
       template <bool deref_ptr> struct deref {
         template <typename T> static inline T get (T t) { return t; }

include/hpp/core/continuous-validation/body-pair-collision.hh

@@ -24,6 +24,7 @@
 
 # include <hpp/fcl/collision_data.h>
 
+# include <hpp/core/collision-pair.hh>
 # include <hpp/core/collision-validation-report.hh>
 # include <hpp/core/continuous-validation/interval-validation.hh>
 
@@ -51,9 +52,6 @@ namespace hpp {
       class BodyPairCollision : public IntervalValidation
       {
       public:
-        typedef std::pair<CollisionObjectConstPtr_t, CollisionObjectConstPtr_t> CollisionPair_t;
-        typedef std::vector<CollisionPair_t> CollisionPairs_t;
-
         /// Validate interval centered on a path parameter
         /// \param t parameter value in the path interval of definition
         /// \param[in,out] interval as input, interval over which
@@ -143,7 +141,7 @@ namespace hpp {
         struct Model {
           CollisionPairs_t pairs;
         };
-        boost::shared_ptr<Model> m_;
+        shared_ptr<Model> m_;
         fcl::CollisionRequest collisionRequest_;
 
         mutable vector_t Vb_;

include/hpp/core/continuous-validation/solid-solid-collision.hh

@@ -150,7 +150,7 @@ namespace hpp {
           JointIndices_t computeSequenceOfJoints () const;
           void computeCoefficients (const JointIndices_t& joints);
         };
-        boost::shared_ptr<Model> m_;
+        shared_ptr<Model> m_;
         SolidSolidCollisionWkPtr_t weak_;
       }; // class SolidSolidCollision
     } // namespace continuousValidation

include/hpp/core/distance/reeds-shepp.hh

@@ -43,6 +43,11 @@ namespace hpp {
 				       std::vector <JointPtr_t> wheels);
 
 	static ReedsSheppPtr_t createCopy (const ReedsSheppPtr_t& distance);
+
+        void turningRadius(const value_type& rho);
+
+        inline value_type turningRadius() const { return rho_; }
+
       protected:
 	ReedsShepp (const ProblemConstPtr_t& problem);
 	ReedsShepp (const ProblemConstPtr_t& problem,
@@ -58,6 +63,7 @@ namespace hpp {
       private:
 	WeighedDistancePtr_t weighedDistance_;
 	DeviceWkPtr_t device_;
+        /// Turning radius
 	value_type rho_;
 	JointPtr_t xy_, rz_;
 	size_type xyId_, rzId_;

include/hpp/core/equation.hh

-// Copyright (c) 2015, LAAS-CNRS
-// Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
-//
-// This file is part of hpp-core.
-// hpp-core is free software: you can redistribute it
-// and/or modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation, either version
-// 3 of the License, or (at your option) any later version.
-//
-// hpp-core is distributed in the hope that it will be
-// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Lesser Public License for more details.  You should have
-// received a copy of the GNU Lesser General Public License along with
-// hpp-core. If not, see <http://www.gnu.org/licenses/>.
-
-
-#ifndef HPP_CORE_EQUATION_HH
-# define HPP_CORE_EQUATION_HH
-
-# warning "This file is deprecated. Include <hpp/constraints/implicit.hh> instead."
-# include <hpp/constraints/implicit.hh>
-# include <hpp/core/fwd.hh>
-
-namespace hpp {
-  namespace core {
-  } // namespace core
-} // namespace hpp
-
-#endif // HPP_CORE_EQUATION_HH

include/hpp/core/explicit-numerical-constraint.hh

-// Copyright (c) 2015, LAAS-CNRS
-// Authors: Florent Lamiraux
-//
-// This file is part of hpp-core.
-// hpp-core is free software: you can redistribute it
-// and/or modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation, either version
-// 3 of the License, or (at your option) any later version.
-//
-// hpp-core is distributed in the hope that it will be
-// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Lesser Public License for more details.  You should have
-// received a copy of the GNU Lesser General Public License along with
-// hpp-core. If not, see <http://www.gnu.org/licenses/>.
-
-#ifndef HPP_CORE_EXPLICIT_NUMERICAL_CONSTRAINT_HH
-# define HPP_CORE_EXPLICIT_NUMERICAL_CONSTRAINT_HH
-
-# warning "This file is deprecated. Include <hpp/constraints/explicit.hh> instead."
-# include <hpp/constraints/explicit.hh>
-# include <hpp/core/fwd.hh>
-# include <hpp/core/config.hh>
-
-namespace hpp {
-  namespace core {
-  } // namespace core
-} // namespace core
-
-#endif // HPP_CORE_EXPLICIT_NUMERICAL_CONSTRAINT_HH

include/hpp/core/explicit-relative-transformation.hh

-// Copyright (c) 2015, LAAS-CNRS
-// Authors: Florent Lamiraux
-//
-// This file is part of hpp-core.
-// hpp-core is free software: you can redistribute it
-// and/or modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation, either version
-// 3 of the License, or (at your option) any later version.
-//
-// hpp-core is distributed in the hope that it will be
-// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// General Lesser Public License for more details.  You should have
-// received a copy of the GNU Lesser General Public License along with
-// hpp-core. If not, see <http://www.gnu.org/licenses/>.
-
-#ifndef HPP_CORE_EXPLICIT_RELATIVE_TRANSFORM_HH
-# define HPP_CORE_EXPLICIT_RELATIVE_TRANSFORM_HH
-
-# include <hpp/constraints/explicit/relative-pose.hh>
-# warning "This file is deprecated. Include <hpp/constraints/explicit/relative-pose.hh> instead."
-#endif

include/hpp/core/fwd.hh

@@ -78,20 +78,20 @@ namespace hpp {
     typedef constraints::ComparisonTypes_t ComparisonTypes_t;
     typedef constraints::ComparisonType ComparisonType;
 
-    typedef boost::shared_ptr <BiRRTPlanner> BiRRTPlannerPtr_t;
+    typedef shared_ptr <BiRRTPlanner> BiRRTPlannerPtr_t;
     typedef hpp::pinocchio::Body Body;
     typedef hpp::pinocchio::BodyPtr_t BodyPtr_t;
-    typedef boost::shared_ptr <CollisionValidation> CollisionValidationPtr_t;
-    typedef boost::shared_ptr <CollisionValidationReport>
+    typedef shared_ptr <CollisionValidation> CollisionValidationPtr_t;
+    typedef shared_ptr <CollisionValidationReport>
     CollisionValidationReportPtr_t;
-    typedef boost::shared_ptr <AllCollisionsValidationReport>
+    typedef shared_ptr <AllCollisionsValidationReport>
     AllCollisionsValidationReportPtr_t;
     typedef pinocchio::CollisionObjectPtr_t CollisionObjectPtr_t;
     typedef pinocchio::CollisionObjectConstPtr_t CollisionObjectConstPtr_t;
     typedef pinocchio::FclCollisionObject FclCollisionObject;
     typedef FclCollisionObject * FclCollisionObjectPtr_t;
     typedef const FclCollisionObject * FclConstCollisionObjectPtr_t;
-    typedef boost::shared_ptr <FclCollisionObject> FclCollisionObjectSharePtr_t;
+    typedef shared_ptr <FclCollisionObject> FclCollisionObjectSharePtr_t;
 
     typedef pinocchio::Configuration_t Configuration_t;
     typedef pinocchio::ConfigurationIn_t ConfigurationIn_t;
@@ -100,15 +100,15 @@ namespace hpp {
     typedef std::vector <ConfigurationPtr_t> Configurations_t;
     typedef Configurations_t::iterator ConfigIterator_t;
     typedef Configurations_t::const_iterator ConfigConstIterator_t;
-    typedef boost::shared_ptr <ConfigurationShooter> ConfigurationShooterPtr_t;
-    typedef boost::shared_ptr <ConfigProjector> ConfigProjectorPtr_t;
-    typedef boost::shared_ptr <ConfigValidation> ConfigValidationPtr_t;
-    typedef boost::shared_ptr <ConfigValidations> ConfigValidationsPtr_t;
-    typedef boost::shared_ptr <ConnectedComponent> ConnectedComponentPtr_t;
+    typedef shared_ptr <ConfigurationShooter> ConfigurationShooterPtr_t;
+    typedef shared_ptr <ConfigProjector> ConfigProjectorPtr_t;
+    typedef shared_ptr <ConfigValidation> ConfigValidationPtr_t;
+    typedef shared_ptr <ConfigValidations> ConfigValidationsPtr_t;
+    typedef shared_ptr <ConnectedComponent> ConnectedComponentPtr_t;
     typedef std::set <ConnectedComponentPtr_t> ConnectedComponents_t;
-    typedef boost::shared_ptr <Constraint> ConstraintPtr_t;
-    typedef boost::shared_ptr <ConstraintSet> ConstraintSetPtr_t;
-    typedef boost::shared_ptr <const ConstraintSet> ConstraintSetConstPtr_t;
+    typedef shared_ptr <Constraint> ConstraintPtr_t;
+    typedef shared_ptr <ConstraintSet> ConstraintSetPtr_t;
+    typedef shared_ptr <const ConstraintSet> ConstraintSetConstPtr_t;
     typedef std::vector<ConstraintPtr_t> Constraints_t;
     typedef pinocchio::Device Device_t;
     typedef pinocchio::DevicePtr_t DevicePtr_t;
@@ -118,22 +118,22 @@ namespace hpp {
     typedef constraints::DifferentiableFunction DifferentiableFunction;
     typedef constraints::DifferentiableFunctionPtr_t
     DifferentiableFunctionPtr_t;
-    typedef boost::shared_ptr <DiffusingPlanner> DiffusingPlannerPtr_t;
-    typedef boost::shared_ptr <Distance> DistancePtr_t;
-    typedef boost::shared_ptr <DistanceBetweenObjects>
+    typedef shared_ptr <DiffusingPlanner> DiffusingPlannerPtr_t;
+    typedef shared_ptr <Distance> DistancePtr_t;
+    typedef shared_ptr <DistanceBetweenObjects>
     DistanceBetweenObjectsPtr_t;
     typedef pinocchio::DistanceResults_t DistanceResults_t;
     typedef Edge* EdgePtr_t;
     typedef std::list <Edge*> Edges_t;
-    typedef boost::shared_ptr <ExtractedPath> ExtractedPathPtr_t;
-    typedef boost::shared_ptr <SubchainPath> SubchainPathPtr_t;
+    typedef shared_ptr <ExtractedPath> ExtractedPathPtr_t;
+    typedef shared_ptr <SubchainPath> SubchainPathPtr_t;
     typedef pinocchio::JointJacobian_t JointJacobian_t;
     typedef pinocchio::Joint Joint;
     typedef pinocchio::JointConstPtr_t JointConstPtr_t;
     typedef pinocchio::JointPtr_t JointPtr_t;
     typedef pinocchio::JointConstPtr_t JointConstPtr_t;
-    typedef boost::shared_ptr <JointBoundValidation> JointBoundValidationPtr_t;
-    typedef boost::shared_ptr <JointBoundValidationReport>
+    typedef shared_ptr <JointBoundValidation> JointBoundValidationPtr_t;
+    typedef shared_ptr <JointBoundValidationReport>
     JointBoundValidationReportPtr_t;
     typedef pinocchio::HalfJointJacobian_t HalfJointJacobian_t;
     typedef pinocchio::JointVector_t JointVector_t;
@@ -167,32 +167,32 @@ namespace hpp {
     typedef std::vector<CollisionObjectPtr_t> ObjectStdVector_t;
     typedef std::vector<CollisionObjectConstPtr_t> ConstObjectStdVector_t;
 
-    typedef boost::shared_ptr <Path> PathPtr_t;
-    typedef boost::shared_ptr <const Path> PathConstPtr_t;
-    typedef boost::shared_ptr <TimeParameterization> TimeParameterizationPtr_t;
-    typedef boost::shared_ptr <PathOptimizer> PathOptimizerPtr_t;
-    typedef boost::shared_ptr <PathPlanner> PathPlannerPtr_t;
-    typedef boost::shared_ptr <ProblemTarget> ProblemTargetPtr_t;
-    typedef boost::shared_ptr <PathVector> PathVectorPtr_t;
-    typedef boost::shared_ptr <const PathVector> PathVectorConstPtr_t;
-    typedef boost::shared_ptr <PlanAndOptimize> PlanAndOptimizePtr_t;
-    typedef boost::shared_ptr <Problem> ProblemPtr_t;
-    typedef boost::shared_ptr <const Problem> ProblemConstPtr_t;
+    typedef shared_ptr <Path> PathPtr_t;
+    typedef shared_ptr <const Path> PathConstPtr_t;
+    typedef shared_ptr <TimeParameterization> TimeParameterizationPtr_t;
+    typedef shared_ptr <PathOptimizer> PathOptimizerPtr_t;
+    typedef shared_ptr <PathPlanner> PathPlannerPtr_t;
+    typedef shared_ptr <ProblemTarget> ProblemTargetPtr_t;
+    typedef shared_ptr <PathVector> PathVectorPtr_t;
+    typedef shared_ptr <const PathVector> PathVectorConstPtr_t;
+    typedef shared_ptr <PlanAndOptimize> PlanAndOptimizePtr_t;
+    typedef shared_ptr <Problem> ProblemPtr_t;
+    typedef shared_ptr <const Problem> ProblemConstPtr_t;
     typedef ProblemSolver* ProblemSolverPtr_t;
-    typedef boost::shared_ptr <Roadmap> RoadmapPtr_t;
-    typedef boost::shared_ptr <StraightPath> StraightPathPtr_t;
-    typedef boost::shared_ptr <const StraightPath> StraightPathConstPtr_t;
-    typedef boost::shared_ptr <ReedsSheppPath> ReedsSheppPathPtr_t;
-    typedef boost::shared_ptr <const ReedsSheppPath> ReedsSheppPathConstPtr_t;
-    typedef boost::shared_ptr <DubinsPath> DubinsPathPtr_t;
-    typedef boost::shared_ptr <const DubinsPath> DubinsPathConstPtr_t;
-    typedef boost::shared_ptr <KinodynamicPath> KinodynamicPathPtr_t;
-    typedef boost::shared_ptr <const KinodynamicPath> KinodynamicPathConstPtr_t;
-    typedef boost::shared_ptr <KinodynamicOrientedPath> KinodynamicOrientedPathPtr_t;
-    typedef boost::shared_ptr <const KinodynamicOrientedPath> KinodynamicOrientedPathConstPtr_t;
-    typedef boost::shared_ptr <InterpolatedPath> InterpolatedPathPtr_t;
-    typedef boost::shared_ptr <const InterpolatedPath> InterpolatedPathConstPtr_t;
-    typedef boost::shared_ptr <SteeringMethod> SteeringMethodPtr_t;
+    typedef shared_ptr <Roadmap> RoadmapPtr_t;
+    typedef shared_ptr <StraightPath> StraightPathPtr_t;
+    typedef shared_ptr <const StraightPath> StraightPathConstPtr_t;
+    typedef shared_ptr <ReedsSheppPath> ReedsSheppPathPtr_t;
+    typedef shared_ptr <const ReedsSheppPath> ReedsSheppPathConstPtr_t;
+    typedef shared_ptr <DubinsPath> DubinsPathPtr_t;
+    typedef shared_ptr <const DubinsPath> DubinsPathConstPtr_t;
+    typedef shared_ptr <KinodynamicPath> KinodynamicPathPtr_t;
+    typedef shared_ptr <const KinodynamicPath> KinodynamicPathConstPtr_t;
+    typedef shared_ptr <KinodynamicOrientedPath> KinodynamicOrientedPathPtr_t;
+    typedef shared_ptr <const KinodynamicOrientedPath> KinodynamicOrientedPathConstPtr_t;
+    typedef shared_ptr <InterpolatedPath> InterpolatedPathPtr_t;
+    typedef shared_ptr <const InterpolatedPath> InterpolatedPathConstPtr_t;
+    typedef shared_ptr <SteeringMethod> SteeringMethodPtr_t;
     typedef std::vector <PathPtr_t> Paths_t;
     typedef std::vector <PathVectorPtr_t> PathVectors_t;
     typedef std::vector <PathVectorPtr_t> PathVectors_t;
@@ -203,10 +203,10 @@ namespace hpp {
     typedef pinocchio::vectorIn_t vectorIn_t;
     typedef pinocchio::vectorOut_t vectorOut_t;
     typedef Eigen::Matrix<value_type, 1, Eigen::Dynamic> rowvector_t;
-    typedef boost::shared_ptr <VisibilityPrmPlanner> VisibilityPrmPlannerPtr_t;
-    typedef boost::shared_ptr <ValidationReport> ValidationReportPtr_t;
-    typedef boost::shared_ptr <WeighedDistance> WeighedDistancePtr_t;
-    typedef boost::shared_ptr <KinodynamicDistance> KinodynamicDistancePtr_t;
+    typedef shared_ptr <VisibilityPrmPlanner> VisibilityPrmPlannerPtr_t;
+    typedef shared_ptr <ValidationReport> ValidationReportPtr_t;
+    typedef shared_ptr <WeighedDistance> WeighedDistancePtr_t;
+    typedef shared_ptr <KinodynamicDistance> KinodynamicDistancePtr_t;
     typedef std::map <std::string, constraints::ImplicitPtr_t>
     NumericalConstraintMap_t;
     typedef std::map <std::string, ComparisonTypes_t> ComparisonTypeMap_t;
@@ -216,40 +216,40 @@ namespace hpp {
     CenterOfMassComputationMap_t;
 
     // Collision pairs
-    typedef std::pair <CollisionObjectConstPtr_t, CollisionObjectConstPtr_t>
-    CollisionPair_t;
+    struct CollisionPair;
+    typedef CollisionPair CollisionPair_t; // For backward compatibility.
     typedef std::vector <CollisionPair_t> CollisionPairs_t;
 
     class ExtractedPath;
     namespace path {
       template <int _PolynomeBasis, int _Order> class Spline;
       HPP_PREDEF_CLASS (Hermite);
-      typedef boost::shared_ptr <Hermite> HermitePtr_t;
-      typedef boost::shared_ptr <const Hermite> HermiteConstPtr_t;
+      typedef shared_ptr <Hermite> HermitePtr_t;
+      typedef shared_ptr <const Hermite> HermiteConstPtr_t;
     } // namespace path
 
     HPP_PREDEF_CLASS (ContinuousValidation);
-    typedef boost::shared_ptr <ContinuousValidation>
+    typedef shared_ptr <ContinuousValidation>
     ContinuousValidationPtr_t;
     namespace continuousValidation {
       HPP_PREDEF_CLASS (Dichotomy);
-      typedef boost::shared_ptr <Dichotomy> DichotomyPtr_t;
+      typedef shared_ptr <Dichotomy> DichotomyPtr_t;
       HPP_PREDEF_CLASS (Progressive);
-      typedef boost::shared_ptr <Progressive> ProgressivePtr_t;
+      typedef shared_ptr <Progressive> ProgressivePtr_t;
       HPP_PREDEF_CLASS (BodyPairCollision);
-      typedef boost::shared_ptr <BodyPairCollision> BodyPairCollisionPtr_t;
+      typedef shared_ptr <BodyPairCollision> BodyPairCollisionPtr_t;
       typedef std::vector <BodyPairCollisionPtr_t> BodyPairCollisions_t;
       HPP_PREDEF_CLASS (IntervalValidation);
-      typedef boost::shared_ptr <IntervalValidation> IntervalValidationPtr_t;
+      typedef shared_ptr <IntervalValidation> IntervalValidationPtr_t;
       typedef std::vector <IntervalValidationPtr_t> IntervalValidations_t;