Rotation3D.h

Go to the documentation of this file.

#ifndef OPALX_Rotation3D_HH
#define OPALX_Rotation3D_HH
 
// ------------------------------------------------------------------------
// $RCSfile: Rotation3D.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Rotation3D
//
// ------------------------------------------------------------------------
// Class category: BeamlineGeometry
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:34 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "BeamlineGeometry/Matrix3D.h"
#include "BeamlineGeometry/Vector3D.h"
 
// Class Rotation3D
// -----------------------------------------------------------------------
//  There are two possible external representations:
//  [DL]
//  [DT]Matrix3D R[DD]
//  The matrix R is an element of SO(3). Its column vectors define the
//  unit vectors of the rotated coordinate system, expressed in the
//  original system. This representation is used internally and can only
//  be read from a Rotation3D object. To build such an object, use the
//  other representation.
//  [DT]Vector3D V[DD]
//  The direction of V defines the axis of rotation, and its length the
//  sine of half the rotation angle. A zero vector represents the identity.
//  [/DL]
//  The copy constructor, destructor, and assignment operator generated
//  by the compiler perform the correct operation.  For speed reasons they
//  are not implemented.
 
class Rotation3D {
public:
    //  Constructs identity.
    Rotation3D();
 
    //  Use axis vector (vx,vy,vz).
    Rotation3D(double vx, double vy, double vz);
 
    bool operator==(const Rotation3D&) const;
    bool operator!=(const Rotation3D&) const;
 
    Rotation3D& operator*=(const Rotation3D& rhs);
 
    Rotation3D operator*(const Rotation3D& rhs) const;
 
    //  Return vector [b]rhs[/b] rotated by the rotation [b]this[/b].
    Vector3D operator*(const Vector3D& rhs) const;
 
    //  Return element (i,k) of the orthogonal matrix.
    double operator()(int i, int k) const;
 
    //  Return the axis vector.
    Vector3D getAxis() const;
 
    //  Return the axis vector in (vx,vy,vz).
    void getAxis(double& vx, double& vy, double& vz) const;
 
    Rotation3D inverse() const;
 
    bool isIdentity() const;
 
    //  Return true, if [b]this[/b] is a pure x-rotation.
    bool isPureXRotation() const;
 
    //  Return true, if [b]this[/b] is a pure y-rotation.
    bool isPureYRotation() const;
 
    //  Return true, if [b]this[/b] is a pure z-rotation.
    bool isPureZRotation() const;
 
    static Rotation3D Identity();
 
    //  Construct pure rotation around x-axis.
    static Rotation3D XRotation(double angle);
 
    //  Construct pure rotation around y-axis.
    static Rotation3D YRotation(double angle);
 
    //  Construct pure rotation around z-axis.
    static Rotation3D ZRotation(double angle);
 
private:
    // Representation.
    Matrix3D R;
};
 
// Inline functions.
// ------------------------------------------------------------------------
 
inline Rotation3D::Rotation3D() : R() {}
 
inline bool Rotation3D::operator==(const Rotation3D& rhs) const { return (R == rhs.R); }
 
inline bool Rotation3D::operator!=(const Rotation3D& rhs) const { return (R != rhs.R); }
 
inline double Rotation3D::operator()(int row, int col) const { return R(row, col); }
 
inline Rotation3D& Rotation3D::operator*=(const Rotation3D& rhs) {
    R *= rhs.R;
    return *this;
}
 
inline Rotation3D Rotation3D::operator*(const Rotation3D& rhs) const {
    Rotation3D result(*this);
    return result *= rhs;
}
 
inline Vector3D Rotation3D::operator*(const Vector3D& rhs) const { return R * rhs; }
 
inline bool Rotation3D::isIdentity() const { return R.isIdentity(); }
 
#endif  // OPALX_Rotation3D_HH