Transformation.cc

Go to the documentation of this file.

#include <utl/config.h>
#include <utl/Transformation.h>
#include <CLHEP/Geometry/Transform3D.h>
#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/AxialVector.h>

using namespace utl;


TransformationPolicy::TransformationPolicy()
  : fTransformation(),
    fCoordinateSystem(CoordinateSystem::GetRootCoordinateSystem())
{
}


TransformationPolicy::TransformationPolicy(const TransformationMatrix& theMatrix,
                                           const CoordinateSystemPtr& theCoordinateSystem)
  : fTransformation(theMatrix),
    fCoordinateSystem(theCoordinateSystem)
{
}


TransformationPolicy::type
TransformationPolicy::FromTransformation(const TransformationMatrix& theTrafo,
                                         const CoordinateSystemPtr& theCS)
{
  return Transformation(theTrafo, theCS);
}


void
TransformationPolicy::UncheckedTransformTo(const CoordinateSystemPtr& newCoordinateSystem)
  const
{
  HepGeom::Transform3D t(fCoordinateSystem->GetTransformationTo(newCoordinateSystem).fTransform);
  HepGeom::Transform3D tInv(fCoordinateSystem->GetInverseTransformationTo(newCoordinateSystem).fTransform);

  fTransformation = t * fTransformation * tInv;
  fCoordinateSystem = newCoordinateSystem;
}


double
TransformationPolicy::Distance(const TransformationPolicy& theTransformation)
  const
{
  theTransformation.TransformTo(fCoordinateSystem);
  return fTransformation.Distance(theTransformation.fTransformation);
}


template<typename V>
V
TransformationPolicy::operator*(const V& rhs)
  const
{
  rhs.TransformTo(fCoordinateSystem);
  return V(fTransformation.fTransform * rhs.fVector,
           fCoordinateSystem);
}


template
Point
TransformationPolicy::operator*<Point>(const Point&) const;

template
Vector
TransformationPolicy::operator*<Vector>(const Vector&) const;

template
AxialVector
TransformationPolicy::operator*<AxialVector>(const AxialVector&) const;


TransformationPolicy&
TransformationPolicy::operator*=(const TransformationPolicy& rhs)
{
  rhs.TransformTo(fCoordinateSystem);
  fTransformation*=rhs.fTransformation;
  return *this;
}


// Configure (x)emacs for this file ...
// Local Variables:
// mode:c++
// compile-command: "make -C .. -k"
// End: