joint.hh

Go to the documentation of this file.

//
// Copyright (c) 2016 CNRS
// Author: NMansard from Florent Lamiraux
//
//
// This file is part of hpp-pinocchio
// hpp-pinocchio 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-pinocchio 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-pinocchio  If not, see
// <http://www.gnu.org/licenses/>.

#ifndef HPP_PINOCCHIO_JOINT_HH
# define HPP_PINOCCHIO_JOINT_HH

# include <cstddef>
# include <hpp/pinocchio/fwd.hh>
# include <hpp/pinocchio/config.hh>

namespace hpp {
  namespace pinocchio {
    class HPP_PINOCCHIO_DLLAPI Joint {
    public:

      static JointPtr_t create (DeviceWkPtr_t device, JointIndex indexInJointList );

      Joint (DeviceWkPtr_t device, JointIndex indexInJointList );

      ~Joint() {}
      // -----------------------------------------------------------------------

      const std::string& name() const;

      // -----------------------------------------------------------------------

      const Transform3f& currentTransformation () const { return currentTransformation(data()); }

      const Transform3f& currentTransformation (const DeviceData& data) const;

      // -----------------------------------------------------------------------

      size_type numberDof () const;

      size_type configSize () const;

      size_type rankInConfiguration () const;

      size_type rankInVelocity () const;

      // -----------------------------------------------------------------------

      JointPtr_t parentJoint () const;

      std::size_t numberChildJoints () const;

      JointPtr_t childJoint (std::size_t rank) const;

      const Transform3f& positionInParentFrame () const;

      // -----------------------------------------------------------------------

      void isBounded (size_type rank, bool bounded);
      bool isBounded (size_type rank) const;
      value_type lowerBound (size_type rank) const;
      value_type upperBound (size_type rank) const;
      void lowerBound (size_type rank, value_type lowerBound);
      void upperBound (size_type rank, value_type upperBound);
      void lowerBounds (vectorIn_t lowerBounds);
      void upperBounds (vectorIn_t upperBounds);

      value_type upperBoundLinearVelocity () const;

      value_type upperBoundAngularVelocity () const;

      const value_type& maximalDistanceToParent () const { return maximalDistanceToParent_; }

    protected:
      void computeMaximalDistanceToParent ();
    public:
      // -----------------------------------------------------------------------

      JointJacobian_t& jacobian (const bool localFrame=true) const { return jacobian (data(), localFrame); }

      JointJacobian_t& jacobian (DeviceData& data, const bool localFrame=true) const;

      // -----------------------------------------------------------------------

      DeviceConstPtr_t robot () const { return devicePtr.lock();}
      DevicePtr_t robot () { return devicePtr.lock();}


      BodyPtr_t linkedBody () const;


      std::ostream& display (std::ostream& os) const;

      LiegroupSpacePtr_t configurationSpace () const;

      LiegroupSpacePtr_t RnxSOnConfigurationSpace () const;


      const JointIndex& index () const
      {
        return jointIndex;
      }

      const JointModel& jointModel() const;


    protected:
      value_type maximalDistanceToParent_;
      DeviceWkPtr_t devicePtr;
      JointIndex jointIndex;
      std::vector<JointIndex> children;

      void setChildList();
      Model&        model() ;      
      const Model&  model() const ;
      DeviceData& data() const;

      void selfAssert() const;

      friend class Device;
    }; // class Joint

    inline std::ostream& operator<< (std::ostream& os, const Joint& joint) { return joint.display(os); }

  } // namespace pinocchio
} // namespace hpp

#endif // HPP_PINOCCHIO_JOINT_HH