gaussian.hh

Go to the documentation of this file.

//
// Copyright (c) 2018 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_CONFIGURATION_SHOOTER_GAUSSIAN_HH
# define HPP_CORE_CONFIGURATION_SHOOTER_GAUSSIAN_HH

# include <sstream>

# include <hpp/pinocchio/device.hh>

# include <hpp/core/configuration-shooter.hh>

namespace hpp {
  namespace core {
    namespace configurationShooter {

      class HPP_CORE_DLLAPI Gaussian :
        public ConfigurationShooter
      {
        public:
          static GaussianPtr_t create (const DevicePtr_t& robot)
          {
            Gaussian* ptr = new Gaussian (robot);
            GaussianPtr_t shPtr (ptr);
            ptr->init (shPtr);
            return shPtr;
          }

          void center (ConfigurationIn_t c)
          {
            center_ = c;
          }
          const Configuration_t& center () const
          {
            return center_;
          }

          void sigma (const value_type& factor);

          void sigmas (vectorIn_t s)
          {
            assert (s.size() == robot_->numberDof());
            sigmas_ = s;
          }
          const vector_t& sigmas () const
          {
            return sigmas_;
          }

        protected:
          Gaussian (const DevicePtr_t& robot)
            : robot_ (robot)
            , center_ (robot->currentConfiguration())
            , sigmas_ (robot->numberDof())
          {
            sigma(1./4.);
          }
          void init (const GaussianPtr_t& self)
          {
            ConfigurationShooter::init (self);
            weak_ = self;
          }

          virtual void impl_shoot (Configuration_t& q) const;
        private:
          const DevicePtr_t& robot_;
          Configuration_t center_;
          vector_t sigmas_;

          GaussianWkPtr_t weak_;
      }; // class Gaussian
    } //   namespace configurationShooter
  } //   namespace core
} // namespace hpp

#endif // HPP_CORE_CONFIGURATION_SHOOTER_GAUSSIAN_HH