CodeSmoother.hpp

Go to the documentation of this file.

#pragma ident "$Id: CodeSmoother.hpp 1316 2008-07-25 21:13:58Z ckiesch $"

#ifndef CODESMOOTHER_HPP
#define CODESMOOTHER_HPP

//============================================================================
//
//  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  Dagoberto Salazar - gAGE ( http://www.gage.es ). 2007, 2008
//
//============================================================================



#include "ProcessingClass.hpp"


namespace gpstk
{



   class CodeSmoother : public ProcessingClass
   {
   public:

      CodeSmoother() : codeType(TypeID::C1), phaseType(TypeID::L1),
         resultType(TypeID::C1), maxWindowSize(100), csFlag(TypeID::CSL1) 
      { setIndex(); };


      CodeSmoother( const TypeID& codeT,
                    const int& mwSize = 100 );


      virtual satTypeValueMap& Process(satTypeValueMap& gData)
         throw(ProcessingException);


      virtual gnssSatTypeValue& Process(gnssSatTypeValue& gData)
         throw(ProcessingException)
      { Process(gData.body); return gData; };


      virtual gnssRinex& Process(gnssRinex& gData)
         throw(ProcessingException)
      { Process(gData.body); return gData; };


      virtual TypeID getCodeType() const
      { return codeType; };


      virtual CodeSmoother& setCodeType(const TypeID& codeT)
      { codeType = codeT; return (*this); };


      virtual TypeID getPhaseType() const
      { return phaseType; };


      virtual CodeSmoother& setPhaseType(const TypeID& phaseT)
      { phaseType = phaseT; return (*this); };


      virtual TypeID getCSFlag() const
      { return csFlag; };


      virtual CodeSmoother& setCSFlag(const TypeID& csT)
      { csFlag = csT; return (*this); };


      virtual TypeID getResultType() const
      { return resultType; };


      virtual CodeSmoother& setResultType(const TypeID& resultT)
      { resultType = resultT; return (*this); };


      virtual int getMaxWindowSize() const
      { return maxWindowSize; };


      virtual CodeSmoother& setMaxWindowSize(const int& maxSize);


      virtual int getIndex(void) const;


      virtual std::string getClassName(void) const;


      virtual ~CodeSmoother() {};


   private:

      TypeID codeType;


      TypeID phaseType;


      TypeID resultType;


      int maxWindowSize;


      TypeID csFlag;


      struct filterData
      {
            // Default constructor initializing the data in the structure
         filterData() : windowSize(1), previousCode(0.0), previousPhase(0.0) {};

         int windowSize;       
         double previousCode;  
         double previousPhase; 
      };


      std::map<SatID, filterData> SmoothingData;


      virtual double getSmoothing( const SatID& sat,
                                   const double& code,
                                   const double& phase,
                                   const double& flag );


      static int classIndex;

      int index;

      void setIndex(void)
      { (*this).index = classIndex++; };


   }; // End of class 'CodeSmoother'


}
#endif   // CODESMOOTHER_HPP

---