#ifndef __JEULERANGLE3D__ #define __JEULERANGLE3D__ #include #include #include "JIO/JSerialisable.hh" #include "JLang/JManip.hh" #include "JMath/JMath.hh" #include "JMath/JConstants.hh" #include "JGeometry3D/JAngle3D.hh" #include "JGeometry3D/JVersor3D.hh" /** * \author mdejong */ namespace JGEOMETRY3D {} namespace JPP { using namespace JGEOMETRY3D; } namespace JGEOMETRY3D { using JMATH::PI; using JMATH::JMath; using JIO::JReader; using JIO::JWriter; /** * Data structure for Euler angles in three dimensions. * * This class implements the JMATH::JMath interface. */ class JEulerAngle3D : public JMath { public: /** * Default constructor. */ JEulerAngle3D() : __alpha(0.0), __beta (0.0), __gamma(0.0) {} /** * Constructor. * * \param alpha alpha angle [rad] * \param beta beta angle [rad] * \param gamma gamma angle [rad] */ JEulerAngle3D(const double alpha, const double beta, const double gamma) : __alpha(alpha), __beta (beta), __gamma(gamma) {} /** * Constructor. * * \param angle angle */ JEulerAngle3D(const JAngle3D& angle) : __alpha(PI/2), __beta (angle.getTheta()), __gamma(angle.getPhi() + PI/2) {} /** * Constructor. * * \param versor versor */ JEulerAngle3D(const JVersor3D& versor) : __alpha(PI/2), __beta (versor.getTheta()), __gamma(versor.getPhi() + PI/2) {} /** * Get Euler angle. * * \return this angle */ const JEulerAngle3D& getEulerAngle() const { return static_cast(*this); } /** * Set Euler angle. * * \param angle Euler angle */ void setEulerAngle(const JEulerAngle3D& angle) { static_cast(*this) = angle; } /** * Negate angle. * * \return this angle */ JEulerAngle3D& negate() { __alpha = -__alpha; __beta = -__beta; __gamma = -__gamma; return *this; } /** * Add angle. * * \param angle angle * \return this angle */ JEulerAngle3D& add(const JEulerAngle3D& angle) { __alpha += angle.getAlpha(); __beta += angle.getBeta(); __gamma += angle.getGamma(); return *this; } /** * Subtract angle. * * \param angle angle * \return this angle */ JEulerAngle3D& sub(const JEulerAngle3D& angle) { __alpha -= angle.getAlpha(); __beta -= angle.getBeta(); __gamma -= angle.getGamma(); return *this; } /** * Scale angle. * * \param factor multiplication factor * \return this angle */ JEulerAngle3D& mul(const double factor) { __alpha *= factor; __beta *= factor; __gamma *= factor; return *this; } /** * Scale angle. * * \param factor division factor * \return this angle */ JEulerAngle3D& div(const double factor) { __alpha /= factor; __beta /= factor; __gamma /= factor; return *this; } /** * Get alpha angle. * * \return alpha angle */ double getAlpha() const { return __alpha; } /** * Get beta angle. * * \return beta angle */ double getBeta() const { return __beta; } /** * Get gamma angle. * * \return gamma angle */ double getGamma() const { return __gamma; } /** * Read Euler angles from input. * * \param in input stream * \param angle Euler angles * \return input stream */ friend inline std::istream& operator>>(std::istream& in, JEulerAngle3D& angle) { in >> angle.__alpha >> angle.__beta >> angle.__gamma; return in; } /** * Write Euler angles to output. * * \param out output stream * \param angle Euler angle * \return output stream */ friend inline std::ostream& operator<<(std::ostream& out, const JEulerAngle3D& angle) { const JFormat format(out, getFormat(JFormat_t(9, 5, std::ios::fixed | std::ios::showpos))); out << format << angle.getAlpha() << ' ' << format << angle.getBeta() << ' ' << format << angle.getGamma(); return out; } /** * Read Euler angles from input. * * \param in reader * \param angle Euler angles * \return reader */ friend inline JReader& operator>>(JReader& in, JEulerAngle3D& angle) { in >> angle.__alpha; in >> angle.__beta; in >> angle.__gamma; return in; } /** * Write Euler angles to output. * * \param out writer * \param angle Euler angles * \return writer */ friend inline JWriter& operator<<(JWriter& out, const JEulerAngle3D& angle) { out << angle.__alpha; out << angle.__beta; out << angle.__gamma; return out; } protected: double __alpha; double __beta; double __gamma; }; } #endif