HelmertTransform.hpp

Go to the documentation of this file.

#pragma ident "$Id: HelmertTransform.hpp 3140 2012-06-18 15:03:02Z susancummins $"

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//  
//  Copyright 2009, The University of Texas at Austin
//
//============================================================================

#ifndef GPSTK_HELMERT_TRANSFORM_HPP
#define GPSTK_HELMERT_TRANSFORM_HPP

#include <map>
#include <string>

#include "Exception.hpp"
#include "Matrix.hpp"
#include "MatrixOperators.hpp"
#include "Position.hpp"
#include "ReferenceFrame.hpp"
#include "Vector.hpp"
#include "Xvt.hpp"

namespace gpstk
{
   class HelmertTransform
   {

   public:

      //Forward declarations so the structs don't have to be moved.
      struct Transform;
      struct TransformParameters;

      typedef std::map<ReferenceFrame, Transform> TransformMap;

      typedef std::map<ReferenceFrame, TransformMap> LookupMap;

      static const double MAS;
      static const double PPB;

      static HelmertTransform& instance();

      void dump();


      void defineTransform(const TransformParameters& tp,
                           const ReferenceFrame& to,
                           const ReferenceFrame& from    )
         throw(InvalidParameter);

      Transform& getTransform(const ReferenceFrame& from,
                              const ReferenceFrame& to   )
         throw(InvalidParameter);


      Position transform(const ReferenceFrame& to,
                         const Position& pos      )
         throw(InvalidParameter);

      Xvt transform(const ReferenceFrame& to,
                    const Xvt& pos           )
         throw(InvalidParameter);

      Triple posTransform(const ReferenceFrame& from,
                          const ReferenceFrame& to,
                          const Triple& pos          )
         throw(InvalidParameter);

      Triple velTransform(const ReferenceFrame& from,
                          const ReferenceFrame& to,
                          const Triple& vel          )
         throw(InvalidParameter);

      Vector<double> posTransform(const ReferenceFrame& from,
                                  const ReferenceFrame& to,
                                  const Vector<double>& pos  )
         throw(InvalidParameter);

      Vector<double> velTransform(const ReferenceFrame& from,
                                  const ReferenceFrame& to,
                                  const Vector<double>& vel  )
         throw(InvalidParameter);

         // The struct that gets passed to this class.
         // Holds basic information about the transformation, including
         // its rotation parameters, scale factor and translation values.
         // In addition, there is a string for a brief description of the
         // publication from which these parameters were taken, or other
         // information deemed neccessary.
      struct TransformParameters
      {
         double r1;   
         double r2;   
         double r3;   
         double t1;   
         double t2;   
         double t3;   
         double scale;   

         // Used for publication info.
         std::string description;

      }; //struct TransformParameters

         // The stored struct, takes the params struct and builds the matrices.
      struct Transform
      {
         TransformParameters params;     

         Matrix<double> rotation;        
         Matrix<double> inverseRotation; 
         Vector<double> translation;     


      }; //struct Transform


   protected:

         // This function does the work for the other functions.
      Vector<double> helperTransform(const ReferenceFrame& from,
                                     const ReferenceFrame& to,
                                     const Vector<double>& vec,
                                     bool translate             )
         throw(InvalidParameter);

      //Initializer
      void populateTransformMaps();

      Transform buildTransform(const TransformParameters& tp)
         throw();

      LookupMap fromMap;


      // Constructors. Because we want this class to be a singleton,
      // these need to be private or protected.
      HelmertTransform()
         throw();

      HelmertTransform(const HelmertTransform& ht)
         throw()
      {}

      HelmertTransform& operator=(const HelmertTransform& ht)
         throw();

   }; //class HelmertTransform

} //namespace gpstk

#endif

---