Joint.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
 
#ifndef GZ_PHYSICS_JOINT_HH_
#define GZ_PHYSICS_JOINT_HH_
 
#include <gz/physics/FeatureList.hh>
#include <gz/physics/FrameSemantics.hh>
#include <gz/physics/Geometry.hh>
 
#include <string>
 
namespace gz
{
  namespace physics
  {
    class GZ_PHYSICS_VISIBLE GetBasicJointState : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
        public: using Pose = typename FromPolicy<PolicyT>::template Use<Pose>;
 
        public: Scalar GetPosition(const std::size_t _dof) const;
 
        public: Scalar GetVelocity(const std::size_t _dof) const;
 
        public: Scalar GetAcceleration(const std::size_t _dof) const;
 
        public: Scalar GetForce(const std::size_t _dof) const;
 
        public: Pose GetTransform() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
        public: using Pose = typename FromPolicy<PolicyT>::template Use<Pose>;
 
        // see Joint::GetPosition above
        public: virtual Scalar GetJointPosition(
            const Identity &_id, std::size_t _dof) const = 0;
 
        // see Joint::GetVelocity above
        public: virtual Scalar GetJointVelocity(
            const Identity &_id, std::size_t _dof) const = 0;
 
        // see Joint::GetAcceleration above
        public: virtual Scalar GetJointAcceleration(
            const Identity &_id, std::size_t _dof) const = 0;
 
        // see Joint::GetForce above
        public: virtual Scalar GetJointForce(
            const Identity &_id, std::size_t _dof) const = 0;
 
        // see Joint::GetTransform above
        public: virtual Pose GetJointTransform(const Identity &_id) const = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetBasicJointState : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: void SetPosition(const std::size_t _dof, const Scalar _value);
 
        public: void SetVelocity(const std::size_t _dof, const Scalar _value);
 
        public: void SetAcceleration(
            const std::size_t _dof, const Scalar _value);
 
        public: void SetForce(const std::size_t _dof, const Scalar _value);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        // see Joint::SetPosition above
        public: virtual void SetJointPosition(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
 
        // See Joint::SetVelocity above
        public: virtual void SetJointVelocity(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
 
        // See Joint::SetAcceleration above
        public: virtual void SetJointAcceleration(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
 
        // See Joint::SetForce above
        public: virtual void SetJointForce(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE GetBasicJointProperties
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Pose = typename FromPolicy<PolicyT>::template Use<Pose>;
 
        public: std::size_t GetDegreesOfFreedom() const;
 
        public: Pose GetTransformFromParent() const;
 
        public: Pose GetTransformToChild() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Pose = typename FromPolicy<PolicyT>::template Use<Pose>;
 
        public: virtual std::size_t GetJointDegreesOfFreedom(
            const Identity &_id) const = 0;
 
        public: virtual Pose GetJointTransformFromParent(
            const Identity &_id) const = 0;
 
        public: virtual Pose GetJointTransformToChild(
            const Identity &_id) const = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetJointTransformFromParentFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Pose = typename FromPolicy<PolicyT>::template Use<Pose>;
 
        public: void SetTransformFromParent(const Pose &_pose);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Pose = typename FromPolicy<PolicyT>::template Use<Pose>;
 
        // see Joint::SetTransformFromParent above
        public: virtual void SetJointTransformFromParent(
            const Identity &_id, const Pose &_pose) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetJointTransformToChildFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Pose = typename FromPolicy<PolicyT>::template Use<Pose>;
 
        public: void SetTransformToChild(const Pose &_pose);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Pose = typename FromPolicy<PolicyT>::template Use<Pose>;
 
        // see Joint::SetTransformToChild above
        public: virtual void SetJointTransformToChild(
            const Identity &_id, const Pose &_pose) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetJointVelocityCommandFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: void SetVelocityCommand(
            const std::size_t _dof, const Scalar _value);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        // See Joint::SetVelocityCommand above
        public: virtual void SetJointVelocityCommand(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetJointPositionLimitsFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: void SetMinPosition(
            const std::size_t _dof, const Scalar _value);
 
        public: void SetMaxPosition(
            const std::size_t _dof, const Scalar _value);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        // See Joint::SetMinPositionCommand above
        public: virtual void SetJointMinPosition(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
 
        // See Joint::SetMaxPositionCommand above
        public: virtual void SetJointMaxPosition(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetJointVelocityLimitsFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: void SetMinVelocity(
            const std::size_t _dof, const Scalar _value);
 
        public: void SetMaxVelocity(
            const std::size_t _dof, const Scalar _value);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        // See Joint::SetMinVelocityCommand above
        public: virtual void SetJointMinVelocity(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
 
        // See Joint::SetMaxVelocityCommand above
        public: virtual void SetJointMaxVelocity(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetJointEffortLimitsFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: void SetMinEffort(const std::size_t _dof, const Scalar _value);
 
        public: void SetMaxEffort(const std::size_t _dof, const Scalar _value);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        // See Joint::SetMinEffortCommand above
        public: virtual void SetJointMinEffort(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
 
        // See Joint::SetMaxEffortCommand above
        public: virtual void SetJointMaxEffort(
            const Identity &_id, std::size_t _dof, Scalar _value) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE DetachJointFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: void Detach();
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual void DetachJoint(const Identity &_jointID) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE GetJointTransmittedWrench
        : public virtual FeatureWithRequirements<JointFrameSemantics>
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint
          : public virtual JointFrameSemantics::Joint<PolicyT, FeaturesT>
      {
        public: using Wrench = typename FromPolicy<
                    PolicyT>::template Use<Wrench>;
 
        public: Wrench GetTransmittedWrench() const;
 
        public: Wrench GetTransmittedWrench(
                    const FrameID &_relativeTo,
                    const FrameID &_inCoordinatesOf) const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Wrench = typename FromPolicy<
                    PolicyT>::template Use<Wrench>;
        public: virtual Wrench GetJointTransmittedWrenchInJointFrame(
                    const Identity &_jointID) const = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetMimicConstraintFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Joint : public virtual Feature::Joint<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: bool SetMimicConstraint(
                    std::size_t _dof,
                    const BaseJointPtr<PolicyT> &_leaderJoint,
                    std::size_t _leaderAxisDof,
                    Scalar _multiplier,
                    Scalar _offset,
                    Scalar _reference);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        // See Joint::MimicConstraint above
        public: virtual bool SetJointMimicConstraint(
            const Identity &_id,
            std::size_t _dof,
            const BaseJointPtr<PolicyT> &_leaderJoint,
            std::size_t _leaderAxisDof,
            Scalar _multiplier,
            Scalar _offset,
            Scalar _reference) = 0;
      };
    };
  }
}
 
#include <gz/physics/detail/Joint.hh>
 
#endif