Euclid3D.h

Go to the documentation of this file.

#ifndef OPALX_Euclid3D_HH
#define OPALX_Euclid3D_HH
 
// ------------------------------------------------------------------------
// $RCSfile: Euclid3D.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Euclid3D
//
// ------------------------------------------------------------------------
// Class category: BeamlineGeometry
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:34 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "BeamlineGeometry/Rotation3D.h"
#include "BeamlineGeometry/Vector3D.h"
 
// Class Euclid3D
// ------------------------------------------------------------------------
//  An arbitrary 3-dimension translation and rotation.
//  The translation is a 3-dimensional vector, the rotation is represented
//  as a 3-dimensional orthonormal matrix.
//  {P}
//  If we think of an Euler3D object as an operator  E  which transforms a
//  point in the super-frame  X  to the local frame  X':
//  {P}
//  X' = E(X),
//  {P}
//  then we can define a dot product of two successive operations in the
//  following way: Given two Euclid3D objects (operators)  E1  and  E2,
//  we can define
//  {P}
//  E3 = E2 . E1
//  {P}
//  using
//  {P}
//  X''= E3(X) = E2(E1(X)).
//  {P}
//  The definition of a multiplicative inverse naturally follows as
//  {P}
//  E . inv(E) = I.
//  {P}
//  If  R  represents the 3-d rotation and  X  the vector specified by
//  (x,y,z),  then a transformation of a point  P  in the super-frame by
//  the Euclid3D is given by
//  {P}
//  P -> R . P + X.
//  {P}
//  For the representation of rotations, see Rotation3D.
//  The copy constructor, destructor, and assignment operator generated
//  by the compiler perform the correct operation.  For speed reasons they
//  are not implemented.
//  An alternate representation for the rotation is given by a vector
//  pointing in the direction of the axis of rotation, whose sense is
//  given by the right-hand rule, and whose length is equal to the angle
//  of rotation.
 
class Euclid3D {
public:
    //  Construct identity.
    Euclid3D();
 
    //  Use displacement [b]V[/b] and rotation [b]R[/b].
    Euclid3D(const Vector3D& V, const Rotation3D& R);
 
    //  Use displacement (x,y,z) and rotation (vx,vy,vz).
    Euclid3D(double x, double y, double z, double vx, double vy, double vz);
 
    bool operator==(const Euclid3D&) const;
    bool operator!=(const Euclid3D&) const;
 
    //  Return the displacement in (x,y,z) and the rotation axis in (vx,vy,vz).
    void getAll(double& x, double& y, double& z, double& vx, double& vy, double& vz) const;
 
    //  Return x-component of displacement.
    double getX() const;
 
    //  Return x-component of displacement.
    double getY() const;
 
    //  Return x-component of displacement.
    double getZ() const;
 
    //  Return displacement as a vector.
    const Vector3D& getVector() const;
 
    //  Return rotation as an orthogonal matrix.
    const Rotation3D& getRotation() const;
 
    //  Return the component (row,col) of the rotation matrix.
    double M(int row, int col) const;
 
    //  Assign x-component of displacement.
    void setX(double x);
 
    //  Assign y-component of displacement.
    void setY(double y);
 
    //  Assign z-component of displacement.
    void setZ(double z);
 
    //  Assign displacement as a vector.
    void setDisplacement(const Vector3D& V);
 
    //  Assign rotation as an orthogonal matrix.
    void setRotation(const Rotation3D& R);
 
    //  Return composition of [b]this[/b] with [b]rhs[/b].
    Euclid3D dot(const Euclid3D& rhs) const;
 
    //  Return composition of [b]this[/b] with [b]rhs[/b].
    const Euclid3D& dotBy(const Euclid3D& rhs);
 
    //  Return composition of [b]this[/b] with [b]rhs[/b].
    Euclid3D operator*(const Euclid3D& rhs) const;
 
    const Euclid3D& operator*=(const Euclid3D& rhs);
 
    Euclid3D inverse() const;
 
    bool isIdentity() const;
 
    //  Return true, if [b]this[/b] is a pure translation.
    bool isPureTranslation() 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 Euclid3D identity();
 
    // Use displacement (x,y,z).
    static Euclid3D translation(double x, double y, double z);
 
    //  Construct pure rotation by [b]angle[/b] around the x-axis;
    static Euclid3D XRotation(double angle);
 
    //  Construct pure rotation by [b]angle[/b] around the y-axis;
    static Euclid3D YRotation(double angle);
 
    //  Construct pure rotation by [b]angle[/b] around the z-axis;
    static Euclid3D ZRotation(double angle);
 
private:
    // Implementation.
    Vector3D V;                // The displacement.
    Rotation3D R;              // The rotation.
    mutable bool is_identity;  // True, when [b]this[/b] is identity.
};
 
// Global Function.
// ------------------------------------------------------------------------
 
inline Euclid3D Inverse(const Euclid3D& t) { return t.inverse(); }
 
// Trivial functions are inlined.
// ------------------------------------------------------------------------
 
inline Euclid3D::Euclid3D() : V(), R(), is_identity(true) {}
 
inline double Euclid3D::getX() const { return V.getX(); }
 
inline double Euclid3D::getY() const { return V.getY(); }
 
inline double Euclid3D::getZ() const { return V.getZ(); }
 
inline double Euclid3D::M(int row, int col) const { return R(row, col); }
 
inline bool Euclid3D::isIdentity() const { return is_identity; }
 
#endif  // OPALX_Euclid3D_HH