problem.hh

Go to the documentation of this file.

 
//
// Copyright (c) 2005, 2006, 2007, 2008, 2009, 2010, 2011 CNRS
// Authors: Florent Lamiraux
//
 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. 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.
//
// 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
// HOLDER 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.
 
#ifndef HPP_CORE_PROBLEM_HH
#define HPP_CORE_PROBLEM_HH
 
#include <hpp/core/config.hh>
#include <hpp/core/container.hh>
#include <hpp/core/parameter.hh>
#include <hpp/core/steering-method.hh>
#include <hpp/pinocchio/device.hh>
#include <hpp/util/pointer.hh>
#include <stdexcept>
 
namespace hpp {
namespace core {
 
class HPP_CORE_DLLAPI Problem {
 public:
  static ProblemPtr_t create(DevicePtr_t robot);
 
  static ProblemPtr_t createCopy(const ProblemConstPtr_t& other);
 
  Problem();
 
  virtual ~Problem();
 
 
  const DevicePtr_t& robot() const { return robot_; }
 
  const Configuration_t& initConfig() const { return initConf_; }
  void initConfig(ConfigurationIn_t inConfig);
  void target(const ProblemTargetPtr_t& target) { target_ = target; }
  const ProblemTargetPtr_t& target() const { return target_; }
  const Configurations_t goalConfigs() const;
  void addGoalConfig(ConfigurationIn_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 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();
 
  void setSecurityMargins(const matrix_t& securityMatrix);
 
  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);
  Problem(const Problem& other) = default;
 
  void init(ProblemWkPtr_t wkPtr);
 
 private:
  ProblemWkPtr_t wkPtr_;
  DevicePtr_t robot_;
  DistancePtr_t distance_;
  Configuration_t initConf_;
  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