Commit ce3a2e1a authored by Jordan Lack's avatar Jordan Lack

Merge branch 'feature/RDL-92' into 'develop'

Feature/rdl 92

See merge request !61
parents 26491894 8840ee4b
Pipeline #60832363 (#938) passed with stages
in 50 minutes and 57 seconds
......@@ -42,4 +42,9 @@ Removed a bunch of deprecated functions
Reworked FrameOrientation inheritance so it inherits from Quaternion instead of having a Quaternion
--- 04-07-2019 ---
Added Model::mass variable where you can get the mass of the model
\ No newline at end of file
Added Model::mass variable where you can get the mass of the model
--- 05-11-2019 ---
Remove the use of raw pointers and replace them with typedef'd std::shared_ptr's
Remove ReferenceFrameHolder
Minor rework to ReferenceFrame internal functionality to improve efficiency
\ No newline at end of file
<?xml version="1.0"?>
<package format="2">
<name>rdl</name>
<version>2.0.0</version>
<version>3.0.0</version>
<description>The rdl meta-package</description>
<maintainer email="jlack1987@gmail.com">jordan</maintainer>
......
<?xml version="1.0"?>
<package format="2">
<name>rdl_benchmark</name>
<version>2.0.1</version>
<version>3.0.0</version>
<description>The rdl_benchmark package</description>
<maintainer email="jlack1987@gmail.com">jordan</maintainer>
......
......@@ -23,8 +23,7 @@ SET ( RDL_SOURCES
src/SpatialAcceleration.cpp
src/MotionVector.cpp
src/FrameObject.cpp
src/RigidBodyInertia.cpp
)
src/RigidBodyInertia.cpp)
include_directories( ${INCLUDES_DIR} ${EIGEN3_INCLUDE_DIR})
......
......@@ -15,8 +15,8 @@
* is important.
*/
#include "rdl_dynamics/ReferenceFrame.hpp"
#include "rdl_dynamics/rdl_eigenmath.h"
#include "rdl_dynamics/ReferenceFrameHolder.hpp"
namespace RobotDynamics
{
......@@ -25,14 +25,10 @@ namespace RobotDynamics
* @ingroup reference_frame
* @brief An interface that objects with a ReferenceFrame extend to inherit the FrameObject::changeFrame method
*/
class FrameObject : public ReferenceFrameHolder
class FrameObject
{
public:
explicit FrameObject(ReferenceFrame* referenceFrame) : referenceFrame(referenceFrame)
{
}
explicit FrameObject(ReferenceFramePtr referenceFrame) : referenceFrame(referenceFrame.get())
explicit FrameObject(ReferenceFramePtr referenceFrame) : referenceFrame(referenceFrame)
{
}
......@@ -47,22 +43,13 @@ class FrameObject : public ReferenceFrameHolder
* @brief Change the ReferenceFrame this FrameObject is expressed in.
* @param desiredFrame A pointer to the ReferenceFrame this FrameObject is to be transformed to
*/
virtual void changeFrame(ReferenceFrame* desiredFrame);
/**
* @brief Change the ReferenceFrame this FrameObject is expressed in
* @param desiredFrame A shared pointer to the ReferenceFrame this FrameObject is to be transformed to
*/
inline void changeFrame(ReferenceFramePtr desiredFrame)
{
this->changeFrame(desiredFrame.get());
}
virtual void changeFrame(ReferenceFramePtr desiredFrame);
/**
* @brief Get a pointer to the reference frame this FrameObject is expressed in
* @return Pointer to the ReferenceFrame this FrameObject is expressed in
*/
inline ReferenceFrame* getReferenceFrame() const
inline ReferenceFramePtr getReferenceFrame() const
{
return referenceFrame;
}
......@@ -71,22 +58,27 @@ class FrameObject : public ReferenceFrameHolder
* @brief Set frame objects internal reference frame
* @param frame Pointer to new frame
*/
inline void setReferenceFrame(ReferenceFrame* frame)
inline void setReferenceFrame(ReferenceFramePtr frame)
{
referenceFrame = frame;
}
/**
* @brief Set frame objects internal reference frame
* @param frame Pointer to new frame
* @brief Check if two ReferenceFrameHolders hold the same ReferenceFrame
* @param referenceFrameHolder
*/
inline void setReferenceFrame(ReferenceFramePtr frame)
void checkReferenceFramesMatch(const FrameObject* frameObject) const
{
getReferenceFrame()->checkReferenceFramesMatch(frameObject->getReferenceFrame());
}
void checkReferenceFramesMatch(FrameObject* frameObject) const
{
referenceFrame = frame.get();
getReferenceFrame()->checkReferenceFramesMatch(frameObject->getReferenceFrame());
}
protected:
ReferenceFrame* referenceFrame /**< Pointer to a ReferenceFrame*/;
ReferenceFramePtr referenceFrame /**< Pointer to a ReferenceFrame*/;
/**
* @brief Pure virtual method that FrameObjects are required to implement so the FrameObject::changeFrame method is able
......
......@@ -34,11 +34,11 @@ class FrameOrientation : public FrameObject, public Quaternion
{
}
explicit FrameOrientation(ReferenceFrame* referenceFrame) : FrameObject(referenceFrame), Quaternion(0., 0., 0., 1.)
explicit FrameOrientation(ReferenceFramePtr referenceFrame) : FrameObject(referenceFrame), Quaternion(0., 0., 0., 1.)
{
}
FrameOrientation(ReferenceFrame* referenceFrame, Quaternion quat) : FrameObject(referenceFrame), Quaternion(quat)
FrameOrientation(ReferenceFramePtr referenceFrame, Quaternion quat) : FrameObject(referenceFrame), Quaternion(quat)
{
}
......@@ -46,10 +46,6 @@ class FrameOrientation : public FrameObject, public Quaternion
{
}
FrameOrientation(ReferenceFrame* referenceFrame, double x, double y, double z, double w) : FrameObject(referenceFrame), Quaternion(x, y, z, w)
{
}
/**
*
* @param referenceFrame
......@@ -57,7 +53,7 @@ class FrameOrientation : public FrameObject, public Quaternion
*
* @note assumes rotation is a valid, orthogonal rotation matrix
*/
FrameOrientation(ReferenceFrame* referenceFrame, const Matrix3d& E) : FrameObject(referenceFrame), Quaternion(E)
FrameOrientation(ReferenceFramePtr referenceFrame, const Matrix3d& E) : FrameObject(referenceFrame), Quaternion(E)
{
}
......@@ -66,34 +62,18 @@ class FrameOrientation : public FrameObject, public Quaternion
return this;
}
void setIncludingFrame(const Quaternion& q, ReferenceFrame* referenceFrame)
void setIncludingFrame(const Quaternion& q, ReferenceFramePtr referenceFrame)
{
this->referenceFrame = referenceFrame;
set(q);
}
FrameOrientation changeFrameAndCopy(ReferenceFrame* referenceFrame) const
FrameOrientation changeFrameAndCopy(ReferenceFramePtr referenceFrame) const
{
FrameOrientation ret = *this;
ret.changeFrame(referenceFrame);
return ret;
}
void changeFrameAndCopy(ReferenceFrame* referenceFrame, FrameOrientation& frameOrientation) const
{
frameOrientation = *this;
frameOrientation.changeFrame(referenceFrame);
}
FrameOrientation changeFrameAndCopy(std::shared_ptr<ReferenceFrame> referenceFrame) const
{
return changeFrameAndCopy(referenceFrame.get());
}
void changeFrameAndCopy(std::shared_ptr<ReferenceFrame> referenceFrame, FrameOrientation& frameOrientation) const
{
changeFrameAndCopy(referenceFrame.get(), frameOrientation);
}
};
} // namespace Math
} // namespace RobotDynamics
......
......@@ -36,7 +36,7 @@ namespace Math
* implementation are an adaptation of FramePoint.java by <a href="http://robots.ihmc.us/">Jerry Pratt and the IHMC
**Robotics Group</a>.
*/
class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
class FramePoint : public FrameObject, public Math::Point3d
{
public:
/**
......@@ -46,7 +46,7 @@ class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
* @param y The y-component of the point
* @param z The z-component of the point
*/
FramePoint(ReferenceFrame* referenceFrame, const double x, const double y, const double z) : FrameObject(referenceFrame), Math::Point3d(x, y, z)
FramePoint(ReferenceFramePtr referenceFrame, const double x, const double y, const double z) : FrameObject(referenceFrame), Math::Point3d(x, y, z)
{
}
......@@ -55,7 +55,7 @@ class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
* @param referenceFrame A pointer to the ReferenceFrame the point will be expressed in
* @param v A Vector3d that will be used to set the components of this FramePoint
*/
FramePoint(ReferenceFrame* referenceFrame, Math::Vector3d v) : FrameObject(referenceFrame), Math::Point3d(v[0], v[1], v[2])
FramePoint(ReferenceFramePtr referenceFrame, Math::Vector3d v) : FrameObject(referenceFrame), Math::Point3d(v[0], v[1], v[2])
{
}
......@@ -64,7 +64,7 @@ class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
* @param referenceFrame A pointer to the ReferenceFrame the point will be expressed in
* @param point A Math::Point3 that will be used to set the components of this FramePoint
*/
FramePoint(ReferenceFrame* referenceFrame, const Math::Point3d& point) : FrameObject(referenceFrame), Math::Point3d(point)
FramePoint(ReferenceFramePtr referenceFrame, const Math::Point3d& point) : FrameObject(referenceFrame), Math::Point3d(point)
{
}
......@@ -80,7 +80,7 @@ class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
* @brief Constructor that initializes to (x,y,z) = (0,0,0)
* @param referenceFrame A pointer to the ReferenceFrame the point will be expressed in
*/
explicit FramePoint(ReferenceFrame* referenceFrame) : FrameObject(referenceFrame), Math::Point3d()
explicit FramePoint(ReferenceFramePtr referenceFrame) : FrameObject(referenceFrame), Math::Point3d()
{
}
......@@ -122,52 +122,19 @@ class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
* @param referenceFrame
* @return
*/
FramePoint changeFrameAndCopy(ReferenceFrame* referenceFrame) const
FramePoint changeFrameAndCopy(ReferenceFramePtr referenceFrame) const
{
FramePoint p = *this;
p.changeFrame(referenceFrame);
return p;
}
/**
* @brief copy into new frame point and change the frame of that
* @param referenceFrame
* @return
*/
FramePoint changeFrameAndCopy(std::shared_ptr<ReferenceFrame> referenceFrame) const
{
return changeFrameAndCopy(referenceFrame.get());
}
/**
* @brief Copy *this into p and change its frame
* @param referenceFrame
* @param p Modified
* @return
*/
void changeFrameAndCopy(ReferenceFrame* referenceFrame, FramePoint& p) const
{
p = *this;
p.changeFrame(referenceFrame);
}
/**
* @brief Copy *this into p and change its frame
* @param referenceFrame
* @param p Modified
* @return
*/
void changeFrameAndCopy(std::shared_ptr<ReferenceFrame> referenceFrame, FramePoint& p) const
{
changeFrameAndCopy(referenceFrame.get(), p);
}
/**
* @brief Set both the ReferenceFrame this object is expressed in as well as the (x,y,z) coordinates of the point
* @param v Vector3d that this point will be set to
* @param referenceFrame Pointer to the ReferenceFrame this object will be expressed in
*/
EIGEN_STRONG_INLINE void setIncludingFrame(const Math::Vector3d& v, ReferenceFrame* referenceFrame)
EIGEN_STRONG_INLINE void setIncludingFrame(const Math::Vector3d& v, ReferenceFramePtr referenceFrame)
{
setIncludingFrame(v(0), v(1), v(2), referenceFrame);
}
......@@ -179,7 +146,7 @@ class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
* @param z The z coordinate
* @param referenceFrame The ReferenceFrame this point is to be expressed in
*/
void setIncludingFrame(const double x, const double y, const double z, ReferenceFrame* referenceFrame)
void setIncludingFrame(const double x, const double y, const double z, ReferenceFramePtr referenceFrame)
{
if (!referenceFrame)
{
......@@ -195,7 +162,7 @@ class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
* @param point Math::Point3d to set this point to
* @param referenceFrame Pointer to ReferenceFrame this point will be expressed in
*/
void setIncludingFrame(const Math::Point3d& point, ReferenceFrame* referenceFrame)
void setIncludingFrame(const Math::Point3d& point, ReferenceFramePtr referenceFrame)
{
if (!referenceFrame)
{
......@@ -269,32 +236,6 @@ class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
return tmp > fabs(dz) ? tmp : fabs(dz);
}
/**
* @brief Perform addition of FramePoint argument
* @param point The FramePoint to be added
* @throws ReferenceFrameException If both points are not expressed in the same ReferenceFrame
*/
void add(const FramePoint& point)
{
checkReferenceFramesMatch(&point);
this->x() += point.x();
this->y() += point.y();
this->z() += point.z();
}
/**
* @brief Perform subtraction of FramePoint argument
* @param point The FramePoint to be subtracted
* @throws ReferenceFrameException If both points are not expressed in the same ReferenceFrame
*/
void subtract(const FramePoint& point)
{
checkReferenceFramesMatch(&point);
this->x() -= point.x();
this->y() -= point.y();
this->z() -= point.z();
}
/**
* @brief Return true FramePoint argument is within epsilon of this, false otherwise
* @param point The FramePoint to be compared
......@@ -395,7 +336,7 @@ class RDL_DLLAPI FramePoint : public FrameObject, public Math::Point3d
*/
inline bool operator==(const FramePoint& lhs, const FramePoint& rhs)
{
lhs.checkReferenceFramesMatch(rhs.getReferenceFrame());
lhs.checkReferenceFramesMatch(&rhs);
if (lhs.x() != rhs.x())
{
......@@ -459,12 +400,6 @@ inline std::ostream& operator<<(std::ostream& output, const FramePoint& framePoi
output << "x = " << framePoint.x() << " y = " << framePoint.y() << " z = " << framePoint.z() << std::endl;
return output;
}
/**
* @typedef FramePoint<double> FramePointd
* @brief A type definition for a FramePoint<double>
*/
typedef FramePoint FramePointd;
} // namespace Math
} // namespace RobotDynamics
#endif // ifndef __RDL_FRAME_POINT_HPP__
......@@ -40,14 +40,6 @@ class FrameVector : public FrameObject, public Math::Vector3d
{
}
/**
* @brief Constructor
* @param referenceFrame A pointer to a ReferenceFrame
*/
explicit FrameVector(ReferenceFrame* referenceFrame) : FrameObject(referenceFrame), Math::Vector3d()
{
}
/**
* @brief Constructor
* @param referenceFrame A pointer to a ReferenceFrame
......@@ -63,18 +55,7 @@ class FrameVector : public FrameObject, public Math::Vector3d
* @param y Value of the y-coordinate
* @param z Value of the z-coordinate
*/
FrameVector(ReferenceFrame* referenceFrame, const double& x, const double& y, const double& z) : FrameObject(referenceFrame), Math::Vector3d(x, y, z)
{
}
/**
* @brief Constructor
* @param referenceFrame A pointer to a ReferenceFrame
* @param x Value of the x-coordinate
* @param y Value of the y-coordinate
* @param z Value of the z-coordinate
*/
FrameVector(ReferenceFramePtr referenceFrame, const double& x, const double& y, const double& z) : FrameObject(referenceFrame.get()), Math::Vector3d(x, y, z)
FrameVector(ReferenceFramePtr referenceFrame, const double& x, const double& y, const double& z) : FrameObject(referenceFrame), Math::Vector3d(x, y, z)
{
}
......@@ -83,16 +64,7 @@ class FrameVector : public FrameObject, public Math::Vector3d
* @param referenceFrame Pointer to a ReferenceFrame
* @param vector A Vector3d used to set the x,y, and z coordinates
*/
FrameVector(ReferenceFrame* referenceFrame, const Eigen::Vector3d& vector) : FrameObject(referenceFrame), Math::Vector3d(vector[0], vector[1], vector[2])
{
}
/**
* @brief Constructor
* @param referenceFrame Pointer to a ReferenceFrame
* @param vector A Vector3d used to set the x,y, and z coordinates
*/
FrameVector(ReferenceFramePtr referenceFrame, const Eigen::Vector3d& vector) : FrameObject(referenceFrame.get()), Math::Vector3d(vector[0], vector[1], vector[2])
FrameVector(ReferenceFramePtr referenceFrame, const Eigen::Vector3d& vector) : FrameObject(referenceFrame), Math::Vector3d(vector[0], vector[1], vector[2])
{
}
......@@ -118,46 +90,13 @@ class FrameVector : public FrameObject, public Math::Vector3d
* @param referenceFrame
* @return
*/
FrameVector changeFrameAndCopy(ReferenceFrame* referenceFrame) const
FrameVector changeFrameAndCopy(ReferenceFramePtr referenceFrame) const
{
FrameVector p = *this;
p.changeFrame(referenceFrame);
return p;
}
/**
* @brief copy into new frame vector and change the frame of that
* @param referenceFrame
* @return
*/
FrameVector changeFrameAndCopy(std::shared_ptr<ReferenceFrame> referenceFrame) const
{
return changeFrameAndCopy(referenceFrame.get());
}
/**
* @brief Copy *this into p and change its frame
* @param referenceFrame
* @param p Modified
* @return
*/
void changeFrameAndCopy(ReferenceFrame* referenceFrame, FrameVector& p) const
{
p = *this;
p.changeFrame(referenceFrame);
}
/**
* @brief Copy *this into p and change its frame
* @param referenceFrame
* @param p Modified
* @return
*/
void changeFrameAndCopy(std::shared_ptr<ReferenceFrame> referenceFrame, FrameVector& p) const
{
changeFrameAndCopy(referenceFrame.get(), p);
}
/**
* @brief Set x, y, and z components to 0
*/
......@@ -174,7 +113,7 @@ class FrameVector : public FrameObject, public Math::Vector3d
* @throws ReferenceFrameException If *referenceFrame=nullptr
* @param referenceFrame Pointer to a ReferenceFrame this point is expressed in
*/
inline void setIncludingFrame(const double x, const double y, const double z, ReferenceFrame* referenceFrame)
inline void setIncludingFrame(const double x, const double y, const double z, ReferenceFramePtr referenceFrame)
{
if (!referenceFrame)
{
......@@ -185,23 +124,6 @@ class FrameVector : public FrameObject, public Math::Vector3d
this->referenceFrame = referenceFrame;
}
/**
* @brief Set the x, y, and z components and the ReferenceFrame these components are expressed in
* @param vector Used to set the x,y, and z components of this point
* @throws ReferenceFrameException If *referenceFrame=nullptr
* @param referenceFrame Pointer to a ReferenceFrame this point is expressed in
*/
inline void setIncludingFrame(const Eigen::Vector3d& vector, ReferenceFrame* referenceFrame)
{
if (!referenceFrame)
{
throw ReferenceFrameException("Reference frame cannot be nullptr!");
}
set(vector[0], vector[1], vector[2]);
this->referenceFrame = referenceFrame;
}
/**
* @brief Set the x, y, and z components and the ReferenceFrame these components are expressed in
* @param vector Used to set the x,y, and z components of this point
......@@ -216,7 +138,7 @@ class FrameVector : public FrameObject, public Math::Vector3d
}
set(vector[0], vector[1], vector[2]);
this->referenceFrame = referenceFrame.get();
this->referenceFrame = referenceFrame;
}
/**
......@@ -324,6 +246,8 @@ class FrameVector : public FrameObject, public Math::Vector3d
}
};
typedef std::shared_ptr<FrameVector> FrameVectorPtr;
inline FrameVector operator+(FrameVector v1, const Vector3d v2)
{
v1 += v2;
......
......@@ -58,14 +58,6 @@ class FrameVectorPair
{
}
/*
* @brief constructor
* @param referenceFrame pointer to a reference frame
*/
explicit FrameVectorPair(ReferenceFrame* referenceFrame) : lin(referenceFrame), ang(referenceFrame)
{
}
/**
* @brief Constructor
* @param v Spatial motion
......@@ -76,16 +68,6 @@ class FrameVectorPair
ang.setIncludingFrame(v.getAngularPart(), v.getReferenceFrame());
}
/**
* @brief Constructor
* @param referenceFrame A pointer to a ReferenceFrame
* @param linear linear component
* @param angular angular component
*/
FrameVectorPair(ReferenceFrame* referenceFrame, const Vector3d& linear, const Vector3d& angular) : lin(referenceFrame, linear), ang(referenceFrame, angular)
{
}
/**
* @brief Constructor
* @param referenceFrame A pointer to a ReferenceFrame
......@@ -105,15 +87,6 @@ class FrameVectorPair
{
}
/**
* @brief Constructor
* @param referenceFrame
* @param v
*/
FrameVectorPair(ReferenceFrame* referenceFrame, const SpatialVector& v) : lin(referenceFrame, v.getLinearPart()), ang(referenceFrame, v.getAngularPart())
{
}
/**
* @brief Destructor
*/
......@@ -143,71 +116,18 @@ class FrameVectorPair
ang.changeFrame(referenceFrame);
}
/**
* @brief Change the frame of the two 3d vectors. Equivalent to the following math expression
* \f[
* \begin{bmatrix}
* E & 0 \\
* 0 & E
* \end{bmatrix}
* \begin{bmatrix}
* angular \\
* linear
* \end{bmatrix}
* \f]
*
* @param referenceFrame
*/
void changeFrame(ReferenceFrame* referenceFrame)
{
assert(referenceFrame);
lin.changeFrame(referenceFrame);
ang.changeFrame(referenceFrame);
}
/**
* @brief copy into new frame vector and change the frame of that
* @param referenceFrame
* @return Copy of frame vector pair expressed in new frame
*/
FrameVectorPair changeFrameAndCopy(ReferenceFrame* referenceFrame) const
FrameVectorPair changeFrameAndCopy(ReferenceFramePtr referenceFrame) const
{
FrameVectorPair p = *this;
p.changeFrame(referenceFrame);
return p;
}
/**
* @brief copy into new frame vector and change the frame of that
* @param referenceFrame
* @return Copy of frame vector pair expressed in new frame
*/
FrameVectorPair changeFrameAndCopy(ReferenceFramePtr referenceFrame) const
{
return changeFrameAndCopy(referenceFrame.get());
}
/**
* @brief Copy *this into p and change its frame
* @param referenceFrame
* @param p Modified
*/
void changeFrameAndCopy(ReferenceFrame* referenceFrame, FrameVectorPair& p) const
{
p = *this;
p.changeFrame(referenceFrame);
}
/**
* @brief Copy *this into p and change its frame
* @param referenceFrame
* @param p Modified
*/
void changeFrameAndCopy(std::shared_ptr<ReferenceFrame> referenceFrame, FrameVectorPair& p) const
{
changeFrameAndCopy(referenceFrame.get(), p);
}
/**
* @brief Set x, y, and z components of linear and angular to 0
*/
......@@ -227,23 +147,13 @@ class FrameVectorPair
ang.setReferenceFrame(referenceFrame);
}
/**
* @brief Set the reference frame
* @param referenceFrame
*/
void setReferenceFrame(ReferenceFrame* referenceFrame)
{
lin.setReferenceFrame(referenceFrame);
ang.setReferenceFrame(referenceFrame);
}
/**
* @brief Set the components and the ReferenceFrame these components are expressed in
* @param linear Linear component
* @param angular Angular component
* @param referenceFrame Pointer to a ReferenceFrame this point is expressed in
*/
inline void setIncludingFrame(ReferenceFrame* referenceFrame, const Vector3d& linear, const Vector3d& angular)
inline void setIncludingFrame(ReferenceFramePtr referenceFrame, const Vector3d& linear, const Vector3d& angular)
{
assert(referenceFrame);
......@@ -251,19 +161,6 @@ class FrameVectorPair
ang.setIncludingFrame(angular, referenceFrame);
}
/**
* @brief Set the components and the ReferenceFrame these components are expressed in
* @param v spatial vector
* @param referenceFrame Pointer to a ReferenceFrame this point is expressed in
*/
inline void setIncludingFrame(ReferenceFrame* referenceFrame, const SpatialVector& v)
{
assert(referenceFrame);
lin.setIncludingFrame(v.getLinearPart(), referenceFrame);
ang.setIncludingFrame(v.getAngularPart(), referenceFrame);
}
/**
* @brief Set the components and the ReferenceFrame these components are expressed in
* @param v spatial vector
......@@ -282,19 +179,6 @@ class FrameVectorPair
* @param v Motion vector
* @param referenceFrame pointer to a reference frame
*/
inline void setIncludingFrame(ReferenceFrame* referenceFrame, const MotionVector& v)
{
assert(referenceFrame);
lin.setIncludingFrame(v.getLinearPart(), referenceFrame);
ang.setIncludingFrame(v.getAngularPart(), referenceFrame);
}
/**
* @brief Set the components and the ReferenceFrame these components are expressed in
* @param referenceFrame Pointer to a reference frame
* @param v Motion vector
*/
inline void setIncludingFrame(ReferenceFramePtr referenceFrame, const MotionVector& v)
{
assert(referenceFrame);
......@@ -313,20 +197,6 @@ class FrameVectorPair
ang.setIncludingFrame(v.getAngularPart(), v.getReferenceFrame());
}