problem.hh

Go to the documentation of this file.

//
// Copyright (c) 2005, 2006, 2007, 2008, 2009, 2010, 2011 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_PROBLEM_HH
# define HPP_CORE_PROBLEM_HH

# include <stdexcept>

# include <hpp/pinocchio/device.hh>
# include <hpp/util/pointer.hh>

# include <hpp/core/config.hh>
# include <hpp/core/steering-method.hh>
# include <hpp/core/container.hh>
# include <hpp/core/parameter.hh>

namespace hpp {
  namespace core {

    class HPP_CORE_DLLAPI Problem
    {
    public:
      static ProblemPtr_t create (DevicePtr_t robot);

      Problem ();

      virtual ~Problem ();


      const DevicePtr_t& robot () const {
    return robot_;
      }

      const ConfigurationPtr_t& initConfig () const
      {
    return initConf_;
      }
      void initConfig (const ConfigurationPtr_t& inConfig);
      void target (const ProblemTargetPtr_t& target)
      {
        target_ = target;
      }
      const ProblemTargetPtr_t& target () const
      {
        return target_;
      }
      const Configurations_t& goalConfigs () const;
      void addGoalConfig (const ConfigurationPtr_t& config);
      void resetGoalConfigs ();



      void steeringMethod (const SteeringMethodPtr_t& sm) {
    steeringMethod_ = sm;
    if (constraints_) steeringMethod_->constraints (constraints_);
      }

      SteeringMethodPtr_t steeringMethod () const {
    return steeringMethod_;
      }

      void distance (const DistancePtr_t& distance)
      {
    distance_ = distance;
      }
      const DistancePtr_t& distance () const
      {
    return distance_;
      }


      void configValidation (const ConfigValidationsPtr_t& configValidations)
      {
    configValidations_ = configValidations;
      }
      const ConfigValidationsPtr_t& configValidations () const
      {
    return configValidations_;
      }

      void resetConfigValidations ();

      void clearConfigValidations ();

      void addConfigValidation (const ConfigValidationPtr_t& configValidation);

      virtual void pathValidation (const PathValidationPtr_t& pathValidation);

      PathValidationPtr_t pathValidation () const
      {
    return pathValidation_;
      }


      void configurationShooter (const ConfigurationShooterPtr_t& configurationShooter);

      ConfigurationShooterPtr_t configurationShooter () const
      {
    return configurationShooter_;
      }

      void pathProjector (const PathProjectorPtr_t& pathProjector)
      {
        pathProjector_ = pathProjector;
      }

      PathProjectorPtr_t pathProjector () const
      {
    return pathProjector_;
      }


      void constraints (const ConstraintSetPtr_t& constraints)
      {
    constraints_ = constraints;
    if (steeringMethod_) steeringMethod_->constraints (constraints);
      }

      const ConstraintSetPtr_t& constraints () const
      {
    return constraints_;
      }

      virtual void checkProblem () const;


      void addObstacle (const CollisionObjectPtr_t &object);
      void removeObstacleFromJoint (const JointPtr_t& joint,
                    const CollisionObjectConstPtr_t& obstacle);

      void filterCollisionPairs ();

      const ObjectStdVector_t &collisionObstacles() const;
      void collisionObstacles (const ObjectStdVector_t &collisionObstacles);

      const Parameter& getParameter (const std::string& name) const
      {
        if (parameters.has(name))
          return parameters.get(name);
        else
          return parameterDescription(name).defaultValue();
      }

      void setParameter (const std::string& name, const Parameter& value);

      static void declareParameter (const ParameterDescription& desc);

      static const Container<ParameterDescription>& parameterDescriptions ();

      static const ParameterDescription& parameterDescription (const std::string& name);

      Container < Parameter > parameters;

    protected:
      Problem (DevicePtr_t robot);

      void init (ProblemWkPtr_t wkPtr);

    private :
      ProblemWkPtr_t wkPtr_;
      DevicePtr_t robot_;
      DistancePtr_t distance_;
      ConfigurationPtr_t initConf_;
      Configurations_t goalConfigurations_;
      ProblemTargetPtr_t target_;
      SteeringMethodPtr_t steeringMethod_;
      ConfigValidationsPtr_t configValidations_;
      PathValidationPtr_t pathValidation_;
      PathProjectorPtr_t pathProjector_;
      ObjectStdVector_t collisionObstacles_;
      ConstraintSetPtr_t constraints_;
      ConfigurationShooterPtr_t configurationShooter_;
    }; // class Problem
  } // namespace core
} // namespace hpp

#define HPP_START_PARAMETER_DECLARATION(name)                                  \
  struct HPP_CORE_DLLAPI __InitializerClass_##name {                           \
    __InitializerClass_##name () {

#define HPP_END_PARAMETER_DECLARATION(name)                                    \
    }                                                                          \
  };                                                                           \
  extern "C" {                                                                 \
    __InitializerClass_##name __instance_##name;                               \
  }

#endif // HPP_CORE_PROBLEM_HH