handle.hh

Go to the documentation of this file.

// This file is part of hpp-manipulation.
// hpp-manipulation 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-manipulation 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-manipulation. If not, see
// <http://www.gnu.org/licenses/>.

#ifndef HPP_MANIPULATION_HANDLE_HH
# define HPP_MANIPULATION_HANDLE_HH

# include <pinocchio/spatial/se3.hpp>

# include <hpp/manipulation/fwd.hh>
# include <hpp/manipulation/config.hh>

namespace hpp {
  namespace manipulation {
    typedef constraints::ImplicitPtr_t ImplicitPtr_t;
    class HPP_MANIPULATION_DLLAPI Handle
    {
    public:
      static std::string className;
      virtual ~Handle () {};

      static HandlePtr_t create (const std::string& name,
                 const Transform3f& localPosition,
                 const DeviceWkPtr_t& robot,
                 const JointPtr_t& joint)
      {
    Handle* ptr = new Handle (name, localPosition, robot, joint);
    HandlePtr_t shPtr (ptr);
    ptr->init (shPtr);
    return shPtr;
      }
      virtual HandlePtr_t clone () const;


      const std::string& name () const
      {
    return name_;
      }
      void name (const std::string& n)
      {
    name_ = n;
      }


      const JointPtr_t& joint () const
      {
    return joint_;
      }
      void joint (const JointPtr_t& joint)
      {
    joint_ = joint;
      }

      DevicePtr_t robot () const
      {
        return robot_.lock();
      }

      const Transform3f& localPosition () const
      {
    return localPosition_;
      }

      void mask (const std::vector<bool>& mask);

      const std::vector<bool>& mask () const
      { return mask_; }

      virtual ImplicitPtr_t createGrasp
      (const GripperPtr_t& gripper, std::string name) const;

      virtual ImplicitPtr_t createGraspComplement
      (const GripperPtr_t& gripper, std::string name) const;

      virtual ImplicitPtr_t createGraspAndComplement
      (const GripperPtr_t& gripper, std::string name) const;

      virtual ImplicitPtr_t createPreGrasp
      (const GripperPtr_t& gripper, const value_type& shift, std::string name) const;

      value_type clearance () const
      {
        return clearance_;
      }

      void clearance (const value_type& clearance)
      {
        clearance_ = clearance;
      }

    protected:
      Handle (const std::string& name, const Transform3f& localPosition,
              const DeviceWkPtr_t& robot, const JointPtr_t& joint) :
        name_ (name), localPosition_ (localPosition), joint_ (joint),
        robot_ (robot), clearance_ (0), mask_ (6, true), weakPtr_ ()
      {
      }
      void init (HandleWkPtr_t weakPtr)
      {
    weakPtr_ = weakPtr;
      }

      virtual std::ostream& print (std::ostream& os) const;

    private:
      std::string name_;
      Transform3f localPosition_;
      JointPtr_t joint_;
      DeviceWkPtr_t robot_;
      value_type clearance_;
      std::vector<bool> mask_;
      HandleWkPtr_t weakPtr_;

      friend std::ostream& operator<< (std::ostream&, const Handle&);
    }; // class Handle

    std::ostream& operator<< (std::ostream& os, const Handle& handle);
  } // namespace manipulation
} // namespace hpp

#endif // HPP_MANIPULATION_HANDLE_HH