Commit ae4c84dc authored by Florent Lamiraux's avatar Florent Lamiraux
Browse files

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

parents 43e02c0d afe3dedc
Pipeline #12933 failed with stage
in 58 seconds
......@@ -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
......
//
// 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
//
// 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
......@@ -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 {
......
......@@ -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;
......
......@@ -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
......
......@@ -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
......
......@@ -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; }
......
......@@ -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_;
......
......@@ -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
......
......@@ -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_;
......
// 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
// 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
// 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
......@@ -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;