Euler Class Reference

#include <euler.h>

Collaboration diagram for Euler:

Public Types
enum	eulerOrder {   XYZ = 0x0101, XZY = 0x0001, YZX = 0x1101, YXZ = 0x1001,   ZXY = 0x2101, ZYX = 0x2001, XZX = 0x0011, XYX = 0x0111,   YXY = 0x1011, YZY = 0x1111, ZYZ = 0x2011, ZXZ = 0x2111,   XYZr = 0x2000, XZYr = 0x2100, YZXr = 0x1000, YXZr = 0x1100,   ZXYr = 0x0000, ZYXr = 0x0100, XZXr = 0x2110, XYXr = 0x2010,   YXYr = 0x1110, YZYr = 0x1010, ZYZr = 0x0110, ZXZr = 0x0010,   Legal, eulerDefault = ZYZ }
enum	Axis { axisX = 0, axisY = 1, axisZ = 2 }
enum	InputLayout { XYZLayout, IJKLayout }

Public Member Functions
	Euler ()
void	init (void)
	Euler (const Euler &)
	Euler (eulerOrder p)
	Euler (const Matrix1D< double > &v, eulerOrder o=eulerDefault, InputLayout l=IJKLayout)
	Euler (double i, double j, double k, eulerOrder o=eulerDefault, InputLayout l=IJKLayout)
	Euler (const Euler &euler, eulerOrder newp)
	Euler (const Matrix2D< double > &, eulerOrder o=eulerDefault)
const Euler &	operator= (const Euler &)
const Euler &	operator= (const Matrix1D< double > &)
void	setXYZVector (const Matrix1D< double > &)
eulerOrder	order () const
void	setOrder (eulerOrder)
void	set (Axis initial, bool relative, bool parityEven, bool firstRepeats)
void	extract (const Matrix2D< double > &)
void	toMatrix (Matrix2D< double > &M) const
void	toXYZVector (Matrix1D< double > &v) const
void	angleOrder (int &i, int &j, int &k) const
void	angleMapping (int &i, int &j, int &k) const
void	makeNear (const Euler &target)
bool	frameStatic () const
bool	initialRepeated () const
bool	parityEven () const
Axis	initialAxis () const
void	eulerRotate (Matrix2D< double > &M, const Matrix1D< double > &r)

Static Public Member Functions
static bool	legal (eulerOrder)
static double	angleMod (double angle)
static void	simpleXYZRotation (Matrix1D< double > &xyzRot, const Matrix1D< double > &targetXyzRot)
static void	nearestRotation (Matrix1D< double > &xyzRot, const Matrix1D< double > &targetXyzRot, eulerOrder order=XYZ)

Public Attributes
Matrix1D< double >	vec3
double	x
double	y
double	z

Protected Attributes
bool	_frameStatic: 1
bool	_initialRepeated: 1
bool	_parityEven: 1
Axis	_initialAxis: 2

Detailed Description

Routines for computing Euler angles following different approaches

Definition at line 39 of file euler.h.

Member Enumeration Documentation

Axis

enum Euler::Axis

Enumerator
axisX
axisY
axisZ

Definition at line 95 of file euler.h.

{ axisX = 0, axisY = 1, axisZ = 2 };

eulerOrder

enum Euler::eulerOrder

Enumerator
XYZ
XZY
YZX
YXZ
ZXY
ZYX
XZX
XYX
YXY
YZY
ZYZ
ZXZ
XYZr
XZYr
YZXr
YXZr
ZXYr
ZYXr
XZXr
XYXr
YXYr
YZYr
ZYZr
ZXZr
Legal
eulerDefault

Definition at line 43 of file euler.h.

    {
        //
        //  All 24 possible orderings
        //

        XYZ = 0x0101, // "usual" orderings
        XZY = 0x0001,
        YZX = 0x1101,
        YXZ = 0x1001,
        ZXY = 0x2101,
        ZYX = 0x2001,

        XZX = 0x0011, // first axis repeated
        XYX = 0x0111,
        YXY = 0x1011,
        YZY = 0x1111,
        ZYZ = 0x2011,
        ZXZ = 0x2111,

        XYZr = 0x2000, // relative orderings -- not common
        XZYr = 0x2100,
        YZXr = 0x1000,
        YXZr = 0x1100,
        ZXYr = 0x0000,
        ZYXr = 0x0100,

        XZXr = 0x2110, // relative first axis repeated
        XYXr = 0x2010,
        YXYr = 0x1110,
        YZYr = 0x1010,
        ZYZr = 0x0110,
        ZXZr = 0x0010,
        //       ||||
        //       VVVV
        //Legend:ABCD
        //  A -> Initial Axis (0==x, 1==y, 2==z)
        //  B -> Parity Even (1==true)
        //  C -> Initial Repeated (1==true)
        //  D -> Frame Static (1==true)
        //

        Legal =   XYZ | XZY | YZX | YXZ | ZXY | ZYX |
                  XZX | XYX | YXY | YZY | ZYZ | ZXZ |
                  XYZr| XZYr| YZXr| YXZr| ZXYr| ZYXr|
                  XZXr| XYXr| YXYr| YZYr| ZYZr| ZXZr,

        //        Min = 0x0000,
        //        Max = 0x2111,
        eulerDefault = ZYZ
    } eulerOrder;

InputLayout

enum Euler::InputLayout

Enumerator
XYZLayout
IJKLayout

Definition at line 97 of file euler.h.

{ XYZLayout, IJKLayout };

Constructor & Destructor Documentation

Euler() [1/7]

Euler::Euler

(

)

Definition at line 80 of file euler.cpp.

             :
        _frameStatic(true),
        _initialRepeated(false),
        _parityEven(true),
        _initialAxis(axisX)
{
    init();
}

Euler() [2/7]

Euler::Euler

(

const Euler &

euler

)

Definition at line 115 of file euler.cpp.

{
    init();
    operator=(euler);
}

Euler() [3/7]

Euler::Euler

(

Euler::eulerOrder

p

)

Definition at line 89 of file euler.cpp.

                              :
        _frameStatic(true),
        _initialRepeated(false),
        _parityEven(true),
        _initialAxis(axisX)
{
    init();
    setOrder(p);
}

Euler() [4/7]

Euler::Euler	(	const Matrix1D< double > &	v,
		Euler::eulerOrder	p = eulerDefault,
		Euler::InputLayout	l = IJKLayout
	)

Definition at line 99 of file euler.cpp.

{
    init();
    setOrder(p);
    if ( l == XYZLayout )
        setXYZVector(v);
    else
    {
        x = XX(v);
        y = YY(v);
        z = ZZ(v);
    }
}

Euler() [5/7]

Euler::Euler	(	double	i,
		double	j,
		double	k,
		Euler::eulerOrder	p = eulerDefault,
		Euler::InputLayout	l = IJKLayout
	)

Definition at line 132 of file euler.cpp.

{
    setOrder(p);
    if ( l == XYZLayout )
    {
        setXYZVector(vectorR3(xi,yi,zi));
    }

    else
    {
        x = xi;
        y = yi;
        z = zi;
    }
}

Euler() [6/7]

Euler::Euler	(	const Euler &	euler,
		eulerOrder	newp
	)

Definition at line 122 of file euler.cpp.

{
    init();
    setOrder(p);
    Matrix2D<double> M(3,3);
    euler.toMatrix(M);
    extract(M);
}

Euler() [7/7]

Euler::Euler	(	const Matrix2D< double > &	M,
		Euler::eulerOrder	p = eulerDefault
	)

Definition at line 150 of file euler.cpp.

{
    setOrder(p);
    extract(M);
}

Member Function Documentation

angleMapping()

void Euler::angleMapping	(	int &	i,
		int &	j,
		int &	k
	)		const

Definition at line 36 of file euler.cpp.

{
    int m[3];

    m[_initialAxis] = 0;
    m[(_initialAxis+1) % 3] = _parityEven ? 1 : 2;
    m[(_initialAxis+2) % 3] = _parityEven ? 2 : 1;
    i = m[0];
    j = m[1];
    k = m[2];
}

angleMod()

double Euler::angleMod ( double  angle )

static

Definition at line 396 of file euler.cpp.

{
    angle = fmod(angle,  (2. * M_PI));

    if (angle < -M_PI)
        angle += 2 * M_PI;
    if (angle > +M_PI)
        angle -= 2 * M_PI;

    return angle;
}

angleOrder()

void Euler::angleOrder	(	int &	i,
		int &	j,
		int &	k
	)		const

Definition at line 28 of file euler.cpp.

{
    i = _initialAxis;
    j = _parityEven ? (i+1)%3 : (i > 0 ? i-1 : 2);
    k = _parityEven ? (i > 0 ? i-1 : 2) : (i+1)%3;
}

eulerRotate()

void Euler::eulerRotate	(	Matrix2D< double > &	M,
		const Matrix1D< double > &	r
	)

Definition at line 464 of file euler.cpp.

{
    double cos_rz;
    double sin_rz;
    double cos_ry;
    double sin_ry;
    double cos_rx;
    double sin_rx;
    double m00;
    double m01;
    double m02;
    double m10;
    double m11;
    double m12;
    double m20;
    double m21;
    double m22;

    cos_rz = cos (ZZ(r));
    cos_ry = cos (YY(r));
    cos_rx = cos (XX(r));
    sin_rz = sin (ZZ(r));
    sin_ry = sin (YY(r));
    sin_rx = sin (XX(r));

    m00 =  cos_rz *  cos_ry;
    m01 =  sin_rz *  cos_ry;
    m02 = -sin_ry;
    m10 = -sin_rz *  cos_rx + cos_rz * sin_ry * sin_rx;
    m11 =  cos_rz *  cos_rx + sin_rz * sin_ry * sin_rx;
    m12 =  cos_ry *  sin_rx;
    m20 = -sin_rz * -sin_rx + cos_rz * sin_ry * cos_rx;
    m21 =  cos_rz * -sin_rx + sin_rz * sin_ry * cos_rx;
    m22 =  cos_ry *  cos_rx;


    Matrix2D<double> P (M);

    dMij(M,0,0) = dMij(P,0,0) * m00 + dMij(P,1,0) * m01 + dMij(P,2,0) * m02;
    dMij(M,0,1) = dMij(P,0,1) * m00 + dMij(P,1,1) * m01 + dMij(P,2,1) * m02;
    dMij(M,0,2) = dMij(P,0,2) * m00 + dMij(P,1,2) * m01 + dMij(P,2,2) * m02;
    dMij(M,0,3) = dMij(P,0,3) * m00 + dMij(P,1,3) * m01 + dMij(P,2,3) * m02;

    dMij(M,1,0) = dMij(P,0,0) * m10 + dMij(P,1,0) * m11 + dMij(P,2,0) * m12;
    dMij(M,1,1) = dMij(P,0,1) * m10 + dMij(P,1,1) * m11 + dMij(P,2,1) * m12;
    dMij(M,1,2) = dMij(P,0,2) * m10 + dMij(P,1,2) * m11 + dMij(P,2,2) * m12;
    dMij(M,1,3) = dMij(P,0,3) * m10 + dMij(P,1,3) * m11 + dMij(P,2,3) * m12;

    dMij(M,2,0) = dMij(P,0,0) * m20 + dMij(P,1,0) * m21 + dMij(P,2,0) * m22;
    dMij(M,2,1) = dMij(P,0,1) * m20 + dMij(P,1,1) * m21 + dMij(P,2,1) * m22;
    dMij(M,2,2) = dMij(P,0,2) * m20 + dMij(P,1,2) * m21 + dMij(P,2,2) * m22;
    dMij(M,2,3) = dMij(P,0,3) * m20 + dMij(P,1,3) * m21 + dMij(P,2,3) * m22;
}

extract()

void Euler::extract

(

const Matrix2D< double > &

M

)

Definition at line 156 of file euler.cpp.

{
    int i;
    int j;
    int k;
    angleOrder(i,j,k);
    if (_initialRepeated)
    {
        // Extract the first angle, x.
        //

        //x = Math::atan2(M[j][i], M[k][i]);
        x = atan2(dMij(M,j,i), dMij(M,k,i));

        //
        // Remove the x rotation from M, so that the remaining
        // rotation, N, is only around two axes, and gimbal lock
        // cannot occur.
        //

        //Vec3<T> r (0, 0, 0);
        Matrix1D <double> r;
        r.initZeros(3);
        VEC_ELEM(r,i) = (_parityEven? -x: x);

        Matrix2D<double> N(4,4);
        N.initIdentity();
        eulerRotate(N,r);
        N = N * M;

        //
        // Extract the other two angles, y and z, from N.
        //

        double sy = sqrt (dMij(N,j,i)*dMij(N,j,i) +
                          dMij(N,k,i)*dMij(N,k,i) );
        y = atan2 (sy, dMij(N,i,i));
        z = atan2 (dMij(N,j,k),dMij(N,j,j));
    }
    else
    {
        //
        // Extract the first angle, x.
        //
        //        x = Math<T>::atan2 (M[j][k], M[k][k]);
        x = atan2 (dMij(M,j,k),dMij(M,k,k));
        //
        // Remove the x rotation from M, so that the remaining
        // rotation, N, is only around two axes, and gimbal lock
        // cannot occur.
        //

        Matrix1D <double> r;
        r.initZeros(3);
        VEC_ELEM(r,i) = (_parityEven? -x: x);
        //std::cerr << "DEBUG_ROB, r:" << r << std::endl;
        Matrix2D<double> N(4,4);
        N.initIdentity();
        eulerRotate(N,r);
        //std::cerr << "DEBUG_ROB, N:" << N << std::endl;
        N = N * M;
        //std::cerr << "DEBUG_ROB, NN:" << N << std::endl;

        //
        // Extract the other two angles, y and z, from N.
        //
        //        T cy = Math<T>::sqrt (N[i][i]*N[i][i] + N[i][j]*N[i][j]);
        double cy = sqrt (dMij(N,i,i)*dMij(N,i,i) +
                          dMij(N,i,j)*dMij(N,i,j) );
        //        y = Math<T>::atan2 (-N[i][k], cy);
        //        z = Math<T>::atan2 (-N[j][i], N[j][j]);
        y = atan2 (-dMij(N,i,k),cy);
        z = atan2 (-dMij(N,j,i),dMij(N,j,j));

    }

    if (!_parityEven)
        //*this *= -1;
    {
        vec3 *= -1;
        x *=-1;
        y *=-1;
        z *=-1;
    }

    if (!_frameStatic)
    {
        double t = x;
        x = z;
        z = t;
    }

}

frameStatic()

bool Euler::frameStatic ( ) const

inline

Definition at line 204 of file euler.h.

    {
        return _frameStatic;
    }

init()

void Euler::init

(

void

)

Definition at line 72 of file euler.cpp.

{
    x=0.;
    y=0.;
    z=0.;
    vec3.initZeros(3);
}

initialAxis()

Axis Euler::initialAxis ( ) const

inline

Definition at line 216 of file euler.h.

    {
        return _initialAxis;
    }

initialRepeated()

bool Euler::initialRepeated ( ) const

inline

Definition at line 208 of file euler.h.

    {
        return _initialRepeated;
    }

legal()

bool Euler::legal ( Euler::eulerOrder  order )

static

Definition at line 315 of file euler.cpp.

{
    return (order & ~Legal) ? false : true;
}

makeNear()

void Euler::makeNear

(

const Euler &

target

)

Definition at line 450 of file euler.cpp.

{
    Matrix1D<double> xyzRot ;
    toXYZVector(xyzRot);
    auto targetSameOrder = Euler(target, order());
    Matrix1D<double> targetXyz;
    targetSameOrder.toXYZVector(targetXyz);

    nearestRotation(xyzRot, targetXyz, order());

    setXYZVector(xyzRot);
}

nearestRotation()

void Euler::nearestRotation ( Matrix1D< double > &  xyzRot, const Matrix1D< double > &  targetXyzRot, eulerOrder  order = XYZ  )

static

Definition at line 419 of file euler.cpp.

{
    int i;
    int j;
    int k;
    Euler e (0,0,0, order);
    e.angleOrder(i,j,k);

    simpleXYZRotation(xyzRot, targetXyzRot);

    Matrix1D<double> otherXyzRot;
    XX(otherXyzRot) = M_PI+XX(xyzRot);
    YY(otherXyzRot) = M_PI-YY(xyzRot);
    ZZ(otherXyzRot) = M_PI+ZZ(xyzRot);

    simpleXYZRotation(otherXyzRot, targetXyzRot);

    Matrix1D<double> d  = xyzRot - targetXyzRot;
    Matrix1D<double> od = otherXyzRot - targetXyzRot;
    double dMag     = d.dotProduct(d);
    double odMag    = od.dotProduct(od);

    if (odMag < dMag)
    {
        xyzRot = otherXyzRot;
    }
}

operator=() [1/2]

const Euler & Euler::operator=

(

const Euler &

euler

)

Definition at line 355 of file euler.cpp.

{
    x = euler.x;
    y = euler.y;
    z = euler.z;
    _initialAxis = euler._initialAxis;
    _frameStatic = euler._frameStatic;
    _parityEven  = euler._parityEven;
    _initialRepeated = euler._initialRepeated;
    return *this;
}

operator=() [2/2]

const Euler & Euler::operator=

(

const Matrix1D< double > &

v

)

Definition at line 367 of file euler.cpp.

{
    x = XX(v);
    y = YY(v);
    z = ZZ(v);
    return *this;
}

order()

Euler::eulerOrder Euler::order

(

)

const

Definition at line 320 of file euler.cpp.

{
    int foo = (_initialAxis == axisZ ?
               0x2000 : (_initialAxis == axisY ? 0x1000 : 0));

    if (_parityEven)
        foo |= 0x0100;
    if (_initialRepeated)
        foo |= 0x0010;
    if (_frameStatic)
        foo++;

    return (eulerOrder)foo;
}

parityEven()

bool Euler::parityEven ( ) const

inline

Definition at line 212 of file euler.h.

    {
        return _parityEven;
    }

set()

void Euler::set	(	Euler::Axis	axis,
		bool	relative,
		bool	parityEven,
		bool	firstRepeats
	)

Definition at line 344 of file euler.cpp.

{
    _initialAxis = axis;
    _frameStatic = !relative;
    _parityEven  = parityEven;
    _initialRepeated = firstRepeats;
}

setOrder()

void Euler::setOrder

(

Euler::eulerOrder

p

)

Definition at line 335 of file euler.cpp.

{
    set( p & 0x2000 ? axisZ : (p & 0x1000 ? axisY : axisX), // initial axis
         !(p & 0x1),        // static?
         !!(p & 0x100),    // permutation even?
         !!(p & 0x10));    // initial repeats?
}

setXYZVector()

void Euler::setXYZVector

(

const Matrix1D< double > &

v

)

Definition at line 49 of file euler.cpp.

{
    int i;
    int j;
    int k;
    angleMapping(i,j,k);
    vec3(i) = XX(v);
    vec3(j) = YY(v);
    vec3(k) = ZZ(v);
}

simpleXYZRotation()

void Euler::simpleXYZRotation ( Matrix1D< double > &  xyzRot, const Matrix1D< double > &  targetXyzRot  )

static

Definition at line 409 of file euler.cpp.

{
    Matrix1D<double> d  = xyzRot - targetXyzRot;
    XX(xyzRot)  = XX(targetXyzRot) + angleMod(XX(d));
    YY(xyzRot)  = YY(targetXyzRot) + angleMod(YY(d));
    ZZ(xyzRot)  = ZZ(targetXyzRot) + angleMod(ZZ(d));
}

toMatrix()

void Euler::toMatrix

(

Matrix2D< double > &

M

)

const

Definition at line 250 of file euler.cpp.

{
    int i;
    int j;
    int k;
    angleOrder(i,j,k);

    Matrix1D<double> angles;

    if ( _frameStatic )
        angles = vectorR3(x,y,z);
    else
        angles=vectorR3(z,y,x);

    if ( !_parityEven )
    {
        angles *= -1.0;
    }

    double ci = cos(XX(angles));
    double cj = cos(YY(angles));
    double ch = cos(ZZ(angles));
    double si = sin(XX(angles));
    double sj = sin(YY(angles));
    double sh = sin(ZZ(angles));

    double cc = ci*ch;
    double cs = ci*sh;
    double sc = si*ch;
    double ss = si*sh;

    M.initIdentity(4);

    if ( _initialRepeated )
    {
        dMij(M,i,i) = cj;
        dMij(M,j,i) =  sj*si;
        dMij(M,k,i) =  sj*ci;

        dMij(M,i,j) = sj*sh;
        dMij(M,j,j) = -cj*ss+cc;
        dMij(M,k,j) = -cj*cs-sc;

        dMij(M,i,k) = -sj*ch;
        dMij(M,j,k) =  cj*sc+cs;
        dMij(M,k,k) =  cj*cc-ss;
    }
    else
    {
        dMij(M,i,i) = cj*ch;
        dMij(M,j,i) = sj*sc-cs;
        dMij(M,k,i) = sj*cc+ss;

        dMij(M,i,j) = cj*sh;
        dMij(M,j,j) = sj*ss+cc;
        dMij(M,k,j) = sj*cs-sc;

        dMij(M,i,k) = -sj;
        dMij(M,j,k) = cj*si;
        dMij(M,k,k) = cj*ci;
    }
}

toXYZVector()

void Euler::toXYZVector

(

Matrix1D< double > &

v

)

const

Definition at line 61 of file euler.cpp.

{
    int i;
    int j;
    int k;
    angleMapping(i,j,k);
    VEC_ELEM(v, 0) = vec3(i);
    VEC_ELEM(v, 1) = vec3(j);
    VEC_ELEM(v, 2) = vec3(k);
}

Member Data Documentation

_frameStatic

bool Euler::_frameStatic

protected

Definition at line 231 of file euler.h.

_initialAxis

Axis Euler::_initialAxis

protected

Definition at line 237 of file euler.h.

_initialRepeated

bool Euler::_initialRepeated

protected

Definition at line 233 of file euler.h.

_parityEven

bool Euler::_parityEven

protected

Definition at line 235 of file euler.h.

vec3

Matrix1D<double> Euler::vec3

Definition at line 221 of file euler.h.

x

double Euler::x

Definition at line 222 of file euler.h.

y

double Euler::y

Definition at line 223 of file euler.h.

z

double Euler::z

Definition at line 224 of file euler.h.

---

The documentation for this class was generated from the following files:

• xmipp/libraries/data/euler.h
• xmipp/libraries/data/euler.cpp