dartpy 7.0.0.dev0__cp313-cp313-manylinux_2_39_x86_64.whl

include/dart/dynamics/EndEffector.hpp

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * 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 DART_DYNAMICS_ENDEFFECTOR_HPP_
+#define DART_DYNAMICS_ENDEFFECTOR_HPP_
+
+#include <dart/dynamics/CompositeNode.hpp>
+#include <dart/dynamics/FixedJacobianNode.hpp>
+#include <dart/dynamics/detail/EndEffectorAspect.hpp>
+
+#include <dart/common/Aspect.hpp>
+#include <dart/common/AspectWithVersion.hpp>
+#include <dart/common/SpecializedForAspect.hpp>
+
+namespace dart {
+namespace dynamics {
+
+class BodyNode;
+class Skeleton;
+class EndEffector;
+
+//==============================================================================
+class Support final : public common::AspectWithStateAndVersionedProperties<
+                          Support,
+                          detail::SupportStateData,
+                          detail::SupportPropertiesData,
+                          EndEffector,
+                          &detail::SupportUpdate>
+{
+public:
+  DART_COMMON_ASPECT_STATE_PROPERTY_CONSTRUCTORS(Support)
+
+  /// Set/Get the support geometry for this EndEffector. The SupportGeometry
+  /// represents points in the EndEffector frame that can be used for contact
+  /// when solving balancing or manipulation constraints.
+  DART_COMMON_SET_GET_ASPECT_PROPERTY(math::SupportGeometry, Geometry)
+  // void setGeometry(const math::SupportGeometry&);
+  // const math::SupportGeometry& getGeometry() const;
+
+  /// Pass in true if this EndEffector should be used to support the robot, like
+  /// a foot
+  void setActive(bool _supporting = true);
+
+  /// Get whether this EndEffector is currently being used for support
+  bool isActive() const;
+};
+
+//==============================================================================
+class EndEffector final : public common::EmbedPropertiesOnTopOf<
+                              EndEffector,
+                              detail::EndEffectorProperties,
+                              detail::EndEffectorCompositeBase>
+{
+public:
+  friend class Skeleton;
+  friend class BodyNode;
+
+  using UniqueProperties = detail::EndEffectorProperties;
+
+  using BasicProperties
+      = common::Composite::MakeProperties<NameAspect, FixedFrame, EndEffector>;
+
+  using Properties = common::Composite::Properties;
+
+  /// Destructor
+  virtual ~EndEffector() = default;
+
+  //----------------------------------------------------------------------------
+  /// \{ \name Structural Properties
+  //----------------------------------------------------------------------------
+
+  /// Set the Properties of this EndEffector. If _useNow is true, the current
+  /// Transform will be set to the new default transform.
+  void setProperties(const BasicProperties& _properties);
+
+  /// Set the Properties of this EndEffector. If _useNow is true, the current
+  /// Transform will be set to the new default transform.
+  void setProperties(const UniqueProperties& properties, bool useNow = false);
+
+  /// Set the AspectProperties of this EndEffector
+  void setAspectProperties(const AspectProperties& properties);
+
+  /// Get the Properties of this EndEffector
+  Properties getEndEffectorProperties() const;
+
+  /// Copy the State and Properties of another EndEffector
+  void copy(const EndEffector& _otherEndEffector);
+
+  /// Copy the State and Properties of another EndEffector
+  void copy(const EndEffector* _otherEndEffector);
+
+  /// Copy the State and Properties of another EndEffector
+  EndEffector& operator=(const EndEffector& _otherEndEffector);
+
+  /// Set the default relative transform of this EndEffector. The relative
+  /// transform of this EndEffector will be set to _newDefaultTf the next time
+  /// resetRelativeTransform() is called. If _useNow is set to true, then
+  /// resetRelativeTransform() will be called at the end of this function.
+  void setDefaultRelativeTransform(
+      const Eigen::Isometry3d& _newDefaultTf, bool _useNow = false);
+
+  /// Set the current relative transform of this EndEffector to the default
+  /// relative transform of this EndEffector. The default relative transform can
+  /// be set with setDefaultRelativeTransform()
+  void resetRelativeTransform();
+
+  DART_BAKE_SPECIALIZED_ASPECT(Support)
+
+  //----------------------------------------------------------------------------
+  /// \{ \name Notifications
+  //----------------------------------------------------------------------------
+
+  // Documentation inherited
+  void dirtyTransform() override;
+
+  /// \}
+
+protected:
+  /// Constructor used by the Skeleton class
+  explicit EndEffector(BodyNode* parent, const BasicProperties& properties);
+
+  // Documentation inherited
+  Node* cloneNode(BodyNode* _parent) const override;
+};
+
+} // namespace dynamics
+} // namespace dart
+
+#endif // DART_DYNAMICS_ENDEFFECTOR_HPP_

include/dart/dynamics/Entity.hpp

@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * 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 DART_DYNAMICS_ENTITY_HPP_
+#define DART_DYNAMICS_ENTITY_HPP_
+
+#include <dart/dynamics/Shape.hpp>
+#include <dart/dynamics/SmartPointer.hpp>
+
+#include <dart/common/Composite.hpp>
+#include <dart/common/Signal.hpp>
+#include <dart/common/Subject.hpp>
+
+#include <Eigen/Core>
+
+#include <string>
+#include <vector>
+
+namespace dart {
+namespace dynamics {
+
+class Frame;
+
+/// Entity class is a base class for any objects that exist in the kinematic
+/// tree structure of DART.
+///
+/// Entities all share the following properties: they exist within a reference
+/// frame, have a name, and are visualizable. However, different Entity types
+/// may have different policies about how/if their reference frame or name
+/// can be changed. Use the Detachable class to create an Entity whose reference
+/// Frame can be changed arbitrarily.
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
+class Entity : public virtual common::Subject
+{
+public:
+  friend class Frame;
+
+  using EntitySignal = common::Signal<void(const Entity*)>;
+  using FrameChangedSignal = common::Signal<void(
+      const Entity*, const Frame* _oldFrame, const Frame* _newFrame)>;
+  using NameChangedSignal = common::Signal<void(
+      const Entity*, const std::string& _oldName, const std::string& _newName)>;
+
+  /// Constructor for typical usage
+  explicit Entity(Frame* _refFrame, bool _quiet);
+
+  /// Default constructor, delegates to Entity(ConstructAbstract_t)
+  Entity();
+
+  Entity(const Entity&) = delete;
+
+  /// Destructor
+  virtual ~Entity();
+
+  /// Set name. Some implementations of Entity may make alterations to the name
+  /// that gets passed in. The final name that this entity will use gets passed
+  /// back in the return of this function.
+  virtual const std::string& setName(const std::string& _name) = 0;
+
+  /// Return the name of this Entity
+  virtual const std::string& getName() const = 0;
+
+  /// Get the parent (reference) frame of this Entity
+  Frame* getParentFrame();
+
+  /// Get the parent (reference) frame of this Entity
+  const Frame* getParentFrame() const;
+
+  /// Returns true if and only if this Entity is itself (i.e. this ==
+  /// _someFrame) or depends on (i.e. kinematically descends from) _someFrame.
+  ///
+  /// If _someFrame is nullptr, this returns true in order to accommodate
+  /// BodyNodes which always have a nullptr BodyNode as the parent of a root
+  /// BodyNode.
+  bool descendsFrom(const Frame* _someFrame) const;
+
+  /// True iff this Entity is also a Frame.
+  bool isFrame() const;
+
+  /// Returns true if this Entity is set to be quiet.
+  ///
+  /// A quiet entity is unknown to its parent Frame. It will not be tracked by
+  /// its parent; it will not receive notifications from its parent, and it will
+  /// not be rendered. The advantage to a quiet Entity is that it has less
+  /// overhead when constructing and deconstructing, which makes it more
+  /// suitable for temporary objects.
+  bool isQuiet() const;
+
+  /// Notify the transformation update of this Entity that its parent Frame's
+  /// pose is needed
+  DART_DEPRECATED(6.2)
+  virtual void notifyTransformUpdate();
+
+  /// Notify the transformation update of this Entity that its parent Frame's
+  /// pose is needed
+  virtual void dirtyTransform();
+
+  /// Returns true iff a transform update is needed for this Entity
+  bool needsTransformUpdate() const;
+
+  /// Notify the velocity update of this Entity that its parent Frame's velocity
+  /// is needed
+  DART_DEPRECATED(6.2)
+  virtual void notifyVelocityUpdate();
+
+  /// Notify the velocity update of this Entity that its parent Frame's velocity
+  /// is needed
+  virtual void dirtyVelocity();
+
+  /// Returns true iff a velocity update is needed for this Entity
+  bool needsVelocityUpdate() const;
+
+  /// Notify the acceleration of this Entity that its parent Frame's
+  /// acceleration is needed
+  DART_DEPRECATED(6.2)
+  virtual void notifyAccelerationUpdate();
+
+  /// Notify the acceleration of this Entity that its parent Frame's
+  /// acceleration is needed
+  virtual void dirtyAcceleration();
+
+  /// Returns true iff an acceleration update is needed for this Entity
+  bool needsAccelerationUpdate() const;
+
+protected:
+  /// Used when constructing a Frame class, because the Frame constructor will
+  /// take care of setting up the parameters you pass into it
+  enum ConstructFrameTag
+  {
+    ConstructFrame
+  };
+
+  explicit Entity(ConstructFrameTag);
+
+  /// Used when constructing a pure abstract class, because calling the Entity
+  /// constructor is just a formality
+  enum ConstructAbstractTag
+  {
+    ConstructAbstract
+  };
+
+  explicit Entity(ConstructAbstractTag);
+
+  /// Used by derived classes to change their parent frames
+  virtual void changeParentFrame(Frame* _newParentFrame);
+
+protected:
+  /// Parent frame of this Entity
+  Frame* mParentFrame;
+
+  /// Does this Entity need a Transform update
+  mutable bool mNeedTransformUpdate;
+  // TODO(JS): Rename this to mIsTransformDirty in DART 7
+
+  /// Does this Entity need a Velocity update
+  mutable bool mNeedVelocityUpdate;
+  // TODO(JS): Rename this to mIsVelocityDirty in DART 7
+
+  /// Does this Entity need an Acceleration update
+  mutable bool mNeedAccelerationUpdate;
+  // TODO(JS): Rename this to mIsAccelerationDirty in DART 7
+
+  /// Frame changed signal
+  FrameChangedSignal mFrameChangedSignal;
+
+  /// Name changed signal
+  NameChangedSignal mNameChangedSignal;
+
+  /// Transform changed signal
+  EntitySignal mTransformUpdatedSignal;
+
+  /// Velocity changed signal
+  EntitySignal mVelocityChangedSignal;
+
+  /// Acceleration changed signal
+  EntitySignal mAccelerationChangedSignal;
+
+public:
+  //----------------------------------------------------------------------------
+  /// \{ \name Slot registers
+  //----------------------------------------------------------------------------
+
+  /// Slot register for frame changed signal
+  common::SlotRegister<FrameChangedSignal> onFrameChanged;
+
+  /// Slot register for name changed signal
+  common::SlotRegister<NameChangedSignal> onNameChanged;
+
+  /// Slot register for transform updated signal
+  common::SlotRegister<EntitySignal> onTransformUpdated;
+
+  /// Slot register for velocity updated signal
+  common::SlotRegister<EntitySignal> onVelocityChanged;
+
+  /// Slot register for acceleration updated signal
+  common::SlotRegister<EntitySignal> onAccelerationChanged;
+
+private:
+  /// Whether or not this Entity is set to be quiet
+  const bool mAmQuiet;
+
+  /// Whether or not this Entity is a Frame
+  bool mAmFrame;
+};
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
+
+/// The Detachable class is a special case of the Entity base class. Detachable
+/// allows the Entity's reference Frame to be changed arbitrarily by the user.
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
+class Detachable : public virtual Entity
+{
+public:
+  /// Constructor
+  explicit Detachable(Frame* _refFrame, bool _quiet);
+
+  /// Allows the user to change the parent Frame of this Entity
+  virtual void setParentFrame(Frame* _newParentFrame);
+
+protected:
+  /// Constructor for inheriting classes, so they do not need to fill in the
+  /// arguments
+  Detachable();
+};
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
+
+} // namespace dynamics
+} // namespace dart
+
+#endif // DART_DYNAMICS_ENTITY_HPP_

include/dart/dynamics/EntityNode.hpp

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * 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 DART_DYNAMICS_ENTITYNODE_HPP_
+#define DART_DYNAMICS_ENTITYNODE_HPP_
+
+#include <dart/dynamics/detail/EntityNodeAspect.hpp>
+
+namespace dart {
+namespace dynamics {
+
+//==============================================================================
+template <class Base>
+class EntityNode
+  : public detail::
+        EntityNodeBase<Base, std::is_base_of<common::Composite, Base>::value>
+{
+public:
+  using NameAspect = typename detail::EntityNodeAspectBase<Base>::Aspect;
+
+  /// Forwarding constructor
+  template <typename... Args>
+  EntityNode(Args&&... args)
+    : detail::
+          EntityNodeBase<Base, std::is_base_of<common::Composite, Base>::value>(
+              std::forward<Args>(args)...)
+  {
+    this->template createAspect<NameAspect>();
+  }
+
+  virtual ~EntityNode() = default;
+
+  /// Set the AspectProperties of this EntityNode
+  void setAspectProperties(const typename NameAspect::Properties& properties);
+
+  // Documentation inherited from Node
+  const std::string& setName(const std::string& newName) override;
+
+  // Documentation inherited from Node
+  const std::string& getName() const override;
+};
+
+} // namespace dynamics
+} // namespace dart
+
+#include <dart/dynamics/detail/EntityNode.hpp>
+
+#endif // DART_DYNAMICS_ENTITYNODE_HPP_

include/dart/dynamics/EulerJoint.hpp

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * 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 DART_DYNAMICS_EULERJOINT_HPP_
+#define DART_DYNAMICS_EULERJOINT_HPP_
+
+#include <dart/dynamics/detail/EulerJointAspect.hpp>
+
+namespace dart {
+namespace dynamics {
+
+/// class EulerJoint
+class EulerJoint : public detail::EulerJointBase
+{
+public:
+  friend class Skeleton;
+  using AxisOrder = detail::AxisOrder;
+  using UniqueProperties = detail::EulerJointUniqueProperties;
+  using Properties = detail::EulerJointProperties;
+  using Base = detail::EulerJointBase;
+
+  DART_BAKE_SPECIALIZED_ASPECT_IRREGULAR(Aspect, EulerJointAspect)
+
+  EulerJoint(const EulerJoint&) = delete;
+
+  /// Destructor
+  virtual ~EulerJoint();
+
+  /// Set the Properties of this EulerJoint
+  void setProperties(const Properties& _properties);
+
+  /// Set the Properties of this EulerJoint
+  void setProperties(const UniqueProperties& _properties);
+
+  /// Set the AspectProperties of this EulerJoint
+  void setAspectProperties(const AspectProperties& properties);
+
+  /// Get the Properties of this EulerJoint
+  Properties getEulerJointProperties() const;
+
+  /// Copy the Properties of another EulerJoint
+  void copy(const EulerJoint& _otherJoint);
+
+  /// Copy the Properties of another EulerJoint
+  void copy(const EulerJoint* _otherJoint);
+
+  /// Same as copy(const EulerJoint&)
+  EulerJoint& operator=(const EulerJoint& _otherJoint);
+
+  // Documentation inherited
+  const std::string& getType() const override;
+
+  /// Get joint type for this class
+  static const std::string& getStaticType();
+
+  // Documentation inherited
+  bool isCyclic(std::size_t _index) const override;
+
+  /// Set the axis order
+  /// \param[in] _order Axis order
+  /// \param[in] _renameDofs If true, the names of dofs in this joint will be
+  /// renmaed according to the axis order.
+  void setAxisOrder(AxisOrder _order, bool _renameDofs = true);
+
+  /// Return the axis order
+  AxisOrder getAxisOrder() const;
+
+  /// Convert a rotation into a 3D vector that can be used to set the positions
+  /// of an EulerJoint with the specified AxisOrder. The positions returned by
+  /// this function will result in a relative transform of
+  /// getTransformFromParentBodyNode() * _rotation *
+  /// getTransformFromChildBodyNode().inverse() between the parent BodyNode and
+  /// the child BodyNode frames when applied to an EulerJoint with the correct
+  /// axis ordering.
+  template <typename RotationType>
+  static Eigen::Vector3d convertToPositions(
+      const RotationType& _rotation, AxisOrder _ordering)
+  {
+    switch (_ordering) {
+      case AxisOrder::XYZ:
+        return math::matrixToEulerXYZ(_rotation);
+      case AxisOrder::ZYX:
+        return math::matrixToEulerZYX(_rotation);
+      default:
+        dtwarn << "[EulerJoint::convertToPositions] Unsupported AxisOrder ("
+               << static_cast<int>(_ordering) << "), returning a zero vector\n";
+        return Eigen::Vector3d::Zero();
+    }
+  }
+
+  /// This is a version of EulerJoint::convertToPositions(const RotationType&,
+  /// AxisOrder) which will use the AxisOrder belonging to the joint instance
+  /// that it gets called on.
+  template <typename RotationType>
+  Eigen::Vector3d convertToPositions(const RotationType& _rotation) const
+  {
+    return convertToPositions(_rotation, getAxisOrder());
+  }
+
+  /// Convert a set of Euler angle positions into a transform
+  static Eigen::Isometry3d convertToTransform(
+      const Eigen::Vector3d& _positions, AxisOrder _ordering);
+
+  /// This is a version of EulerJoint::convertToRotation(const Eigen::Vector3d&,
+  /// AxisOrder) which will use the AxisOrder belonging to the joint instance
+  /// that it gets called on.
+  Eigen::Isometry3d convertToTransform(const Eigen::Vector3d& _positions) const;
+
+  /// Convert a set of Euler angle positions into a rotation matrix
+  static Eigen::Matrix3d convertToRotation(
+      const Eigen::Vector3d& _positions, AxisOrder _ordering);
+
+  Eigen::Matrix3d convertToRotation(const Eigen::Vector3d& _positions) const;
+
+  // Documentation inherited
+  Eigen::Matrix<double, 6, 3> getRelativeJacobianStatic(
+      const Eigen::Vector3d& _positions) const override;
+
+protected:
+  /// Constructor called by Skeleton class
+  EulerJoint(const Properties& properties);
+
+  // Documentation inherited
+  Joint* clone() const override;
+
+  using Base::getRelativeJacobianStatic;
+
+  /// Set the names of this joint's DegreesOfFreedom. Used during construction
+  /// and when axis order is changed.
+  void updateDegreeOfFreedomNames() override;
+
+  // Documentation inherited
+  void updateRelativeTransform() const override;
+
+  // Documentation inherited
+  void updateRelativeJacobian(bool = true) const override;
+
+  // Documentation inherited
+  void updateRelativeJacobianTimeDeriv() const override;
+};
+
+} // namespace dynamics
+} // namespace dart
+
+#endif // DART_DYNAMICS_EULERJOINT_HPP_