AugerCoordinateSystem.cc

Go to the documentation of this file.

#include <utl/AugerCoordinateSystem.h>
#include <utl/ReferenceEllipsoid.h>
#include <utl/CoordinateSystem.h>
#include <utl/Point.h>
#include <utl/UTMPoint.h>

#include <boost/tuple/tuple_io.hpp>

using namespace utl;


template<typename Policy>
typename Policy::type
AugerCoordinateSystemConstructor<Policy>::Create(const Point& theOrigin,
                                                 const ReferenceEllipsoid& theEllipsoid,
                                                 const CoordinateSystemPtr& theReferenceCS)
{
  TransformationMatrix trans;
  TransformationMatrix rot;
  boost::tie(trans, rot) = theEllipsoid.TransformECEFToLocalSystem(theOrigin);

  const CoordinateSystemPtr ecef = theEllipsoid.GetECEF();

  const CoordinateSystemPtr baseCSToUse = theReferenceCS->GetReferenceSystem();
  const TransformationMatrix ecefToReferenceCS = ecef->GetTransformationTo(baseCSToUse);

  // NB the order of the transformation and rotation has to be the
  // oposite of the natural order to account for the way the
  // transformations have to be reversed when going from active to
  // passive transformations. This is related to the appearance of
  // contra-gredient transformations in usual linear algebra. For the
  // same reaseon, we have to put the inverse transformation from the
  // reference CS to the ECEF in front.
  return Policy::FromTransformation(ecefToReferenceCS * trans * rot, baseCSToUse);
}


template<typename Policy>
typename Policy::type
AugerCoordinateSystemConstructor<Policy>::Create(const Point& theOrigin,
                                                 const ReferenceEllipsoid::EllipsoidID& theEllipsoidID,
                                                 const CoordinateSystemPtr& theReferenceCS)
{
  return Create(theOrigin, ReferenceEllipsoid::Get(theEllipsoidID), theReferenceCS);
}


template<typename Policy>
typename Policy::type
AugerCoordinateSystemConstructor<Policy>::Create(const UTMPoint& theOrigin,
                                                 const CoordinateSystemPtr& theReferenceCS)
{
  const ReferenceEllipsoid& e = theOrigin.GetEllipsoid();
  const Point p(theOrigin.GetPoint());

  return Create(p, e, theReferenceCS);
}


// instantiations
namespace utl {
  template class AugerCoordinateSystemConstructor<utl::DerivedCSPolicy>;
  template class AugerCoordinateSystemConstructor<utl::BaseCSPolicy>;
}