Euclid3D.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: Euclid3D.cpp,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Euclid3D
//   Euclid3D represents an arbitrary 3-dimension translation and
//   rotation.
//
// ------------------------------------------------------------------------
// Class category: BeamlineGeometry
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:34 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "BeamlineGeometry/Euclid3D.h"
#include <cmath>
 
// Class Euclid3D
// ------------------------------------------------------------------------
// The present implementation contains a Vector3D representing the
// displacement, and a Matrix3D representing the rotation.
 
Euclid3D::Euclid3D(double x, double y, double z, double vx, double vy, double vz)
    : V(x, y, z), R(vx, vy, vz), is_identity(false) {}
 
Euclid3D::Euclid3D(const Vector3D& vec, const Rotation3D& rot)
    : V(vec), R(rot), is_identity(false) {}
 
bool Euclid3D::operator==(const Euclid3D& rhs) const { return (V == rhs.V) && (R == rhs.R); }
 
bool Euclid3D::operator!=(const Euclid3D& rhs) const { return (V != rhs.V) || (R != rhs.R); }
 
void Euclid3D::getAll(double& x, double& y, double& z, double& vx, double& vy, double& vz) const {
    V.getComponents(x, y, z);
    R.getAxis(vx, vy, vz);
}
 
const Vector3D& Euclid3D::getVector() const { return V; }
 
const Rotation3D& Euclid3D::getRotation() const { return R; }
 
void Euclid3D::setX(double x) { V.setX(x); }
 
void Euclid3D::setY(double y) { V.setY(y); }
 
void Euclid3D::setZ(double z) { V.setZ(z); }
 
void Euclid3D::setDisplacement(const Vector3D& v) {
    if (!v.isZero()) is_identity = false;
    V = v;
}
 
void Euclid3D::setRotation(const Rotation3D& rot) {
    if (!rot.isIdentity()) is_identity = false;
    R = rot;
}
 
Euclid3D Euclid3D::dot(const Euclid3D& rhs) const {
    Euclid3D result(*this);
    return result.dotBy(rhs);
}
 
const Euclid3D& Euclid3D::dotBy(const Euclid3D& rhs) {
    V += R * rhs.V;
    R *= rhs.R;
    if (!rhs.is_identity) is_identity = false;
    return *this;
}
 
Euclid3D Euclid3D::operator*(const Euclid3D& rhs) const {
    Euclid3D result(*this);
    return result.dotBy(rhs);
}
 
const Euclid3D& Euclid3D::operator*=(const Euclid3D& rhs) { return dotBy(rhs); }
 
Euclid3D Euclid3D::inverse() const {
    Rotation3D rot = R.inverse();
    return Euclid3D(rot * (-V), rot);
}
 
bool Euclid3D::isPureTranslation() const { return R.isIdentity(); }
 
bool Euclid3D::isPureXRotation() const { return V.isZero() && R.isPureXRotation(); }
 
bool Euclid3D::isPureYRotation() const { return V.isZero() && R.isPureYRotation(); }
 
bool Euclid3D::isPureZRotation() const { return V.isZero() && R.isPureZRotation(); }
 
Euclid3D Euclid3D::identity() { return Euclid3D(); }
 
Euclid3D Euclid3D::translation(double x, double y, double z) {
    return Euclid3D(Vector3D(x, y, z), Rotation3D::Identity());
}
 
Euclid3D Euclid3D::XRotation(double angle) {
    Euclid3D result    = Euclid3D(Vector3D(), Rotation3D::XRotation(angle));
    result.is_identity = angle == 0.0;
    return result;
}
 
Euclid3D Euclid3D::YRotation(double angle) {
    Euclid3D result    = Euclid3D(Vector3D(), Rotation3D::YRotation(angle));
    result.is_identity = angle == 0.0;
    return result;
}
 
Euclid3D Euclid3D::ZRotation(double angle) {
    Euclid3D result    = Euclid3D(Vector3D(), Rotation3D::ZRotation(angle));
    result.is_identity = angle == 0.0;
    return result;
}