timeconvert.cpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
#include "NewNavInc.h"
#include <gnsstk/BasicFramework.hpp>
 
#include <gnsstk/TimeString.hpp>
#include <gnsstk/TimeConstants.hpp>
 
#include <gnsstk/ANSITime.hpp>
#include <gnsstk/CivilTime.hpp>
#include <gnsstk/GPSWeekSecond.hpp>
#include <gnsstk/GPSWeekZcount.hpp>
#include <gnsstk/JulianDate.hpp>
#include <gnsstk/MJD.hpp>
#include <gnsstk/UnixTime.hpp>
#include <gnsstk/YDSTime.hpp>
#include <gnsstk/SystemTime.hpp>
 
#include <gnsstk/CommandOptionWithCommonTimeArg.hpp>
#include <gnsstk/EnumIterator.hpp>
#include <gnsstk/BasicTimeSystemConverter.hpp>
#include <gnsstk/NavTimeSystemConverter.hpp>
#include <gnsstk/MultiFormatNavDataFactory.hpp>
 
using namespace std;
using namespace gnsstk;
 
class CommandOptionHelpTimeSystem : public gnsstk::CommandOptionHelp
{
public:
   CommandOptionHelpTimeSystem(const char shOpt,
                               const std::string& loOpt,
                               const std::string& desc)
         : CommandOptionHelp(gnsstk::CommandOption::noArgument, shOpt, loOpt,
                             desc)
   {
   }
 
   void printHelp(std::ostream& out, bool pretty = true) override
   {
      out << "Available Time Systems:" << endl;
      for (gnsstk::TimeSystem e : TimeSystemIterator())
      {
         cout << "  " << gnsstk::StringUtils::asString(e) << endl;
      }
   }
};
 
 
class TimCvt : public BasicFramework
{
public:
   TimCvt(char* arg0);
 
protected:
   virtual void process();
 
private:
   CommandOptionWithCommonTimeArg ANSITimeOption;
   CommandOptionWithCommonTimeArg CivilTimeOption;
   CommandOptionWithCommonTimeArg RinexFileTimeOption;
   CommandOptionWithCommonTimeArg GPSEWSOption;
   CommandOptionWithCommonTimeArg GPSWSOption;
   CommandOptionWithCommonTimeArg GPSWZOption;
   CommandOptionWithCommonTimeArg GPSZ29Option;
   CommandOptionWithCommonTimeArg GPSZ32Option;
   CommandOptionWithCommonTimeArg JDOption;
   CommandOptionWithCommonTimeArg MJDOption;
   CommandOptionWithCommonTimeArg UnixTimeOption;
   CommandOptionWithCommonTimeArg YDSTimeOption;
   CommandOptionHelpTimeSystem timeSystemHelpOption;
   CommandOptionWithAnyArg srcTSOption; 
   CommandOptionWithAnyArg tgtTSOption; 
   CommandOptionWithAnyArg navOption;   
 
   CommandOptionWithAnyArg inputFormatOption;
   CommandOptionWithAnyArg inputTimeOption;
   CommandOptionAllOf inputFormatAndTimeOption;
 
   CommandOptionNoArg offsOnlyOption;
   CommandOptionWithAnyArg formatOption;
   CommandOptionMutex offsetOrFormatOption;
   CommandOptionDependent offsetTgtTSOption;
   CommandOptionWithNumberArg addOption;
   CommandOptionWithNumberArg subOption;
   CommandOptionMutex mutexOption;
 
   string stringToParse;
   string timeSpec;
   gnsstk::NavDataFactoryPtr ndfp;
};
 
 
TimCvt::TimCvt(char* arg0)
      : BasicFramework(arg0, "Converts from a given input time specification"
                       " to other time formats.  Include the quotation marks."
                       "  All year values are four digit years.\n\nWhen"
                       " converting between time systems, GPS is the default"
                       " source time system when a time is specified, while UTC"
                       " is the default source time system when a time is not"
                       " specified."),
        ANSITimeOption('A', "ansi", "%K", "\"ANSI-Second\""),
        CivilTimeOption('c', "civil", "%m %d %Y %H:%M:%f",
                        "\"Month(numeric) DayOfMonth Year"
                        " Hour:Minute:Second\""),
        RinexFileTimeOption('R', "rinex-file", "%y %m %d %H %M %S",
                            "\"Year(2-digit) Month(numeric) DayOfMonth Hour"
                            " Minute Second\""),
        GPSEWSOption('o', "ews", "%E %G %g", 
                     "\"GPSEpoch 10bitGPSweek SecondOfWeek\""),
        GPSWSOption('f', "ws", "%F %g", "\"FullGPSWeek SecondOfWeek\""),
        GPSWZOption('w', "wz", "%F %Z", "\"FullGPSWeek Zcount\""),
        GPSZ29Option(0, "z29", "%E %c", "\"29bitZcount\""),
        GPSZ32Option('Z', "z32", "%C", "\"32bitZcount\""),
        JDOption('j', "julian", "%J", "\"JulianDate\""),
        MJDOption('m', "mjd", "%Q", "\"ModifiedJulianDate\""),
        UnixTimeOption('u',"unixtime", "%U %u",
                       "\"UnixSeconds UnixMicroseconds\""),
        YDSTimeOption('y', "doy", "%Y %j %s",
                      "\"Year DayOfYear SecondsOfDay\""),
        inputFormatOption(0, "input-format", "Time format to use on input"),
        inputTimeOption(0, "input-time",
                        "Time to be parsed by \"input-format\" option"),
        formatOption('F', "format", "Time format to use on output"),
        addOption('a', "add-offset", "Add NUM seconds to specified time"),
        subOption('s', "sub-offset",
                  "Subtract NUM seconds from specified time"),
        timeSystemHelpOption(0, "systems", "List available time systems"),
        srcTSOption(0, "src-sys", "Source time system when converting between"
                    " systems"),
        tgtTSOption(0, "tgt-sys", "Target time system when converting between"
                    " systems"),
        navOption(0, "nav", "if you see this, we failed"),
        offsOnlyOption(0, "offset", "Only display the offset at the reference"
                       " time"),
        offsetTgtTSOption(&tgtTSOption, &offsOnlyOption)
{
      // Initialize these two items in here rather than in the
      // initializer list to guarantee execution order and avoid seg
      // faults.
   ndfp = std::make_shared<gnsstk::MultiFormatNavDataFactory>();
      // process only time offset messages
   ndfp->setTypeFilter({NavMessageType::TimeOffset});
   navOption.setDescription("Where to get the navigation data. Can be " +
                            ndfp->getFactoryFormats() + ".");
   ANSITimeOption.setMaxCount(1);
   CivilTimeOption.setMaxCount(1);
   RinexFileTimeOption.setMaxCount(1);
   GPSEWSOption.setMaxCount(1);
   GPSWSOption.setMaxCount(1);
   GPSWZOption.setMaxCount(1);
   GPSZ29Option.setMaxCount(1);
   GPSZ32Option.setMaxCount(1);
   JDOption.setMaxCount(1);
   MJDOption.setMaxCount(1);
   UnixTimeOption.setMaxCount(1);
   YDSTimeOption.setMaxCount(1);
   formatOption.setMaxCount(1);
   srcTSOption.setMaxCount(1);
   tgtTSOption.setMaxCount(1);
 
   inputFormatOption.setMaxCount(1);
   inputTimeOption.setMaxCount(1);
   inputFormatAndTimeOption.addOption(&inputFormatOption);
   inputFormatAndTimeOption.addOption(&inputTimeOption);
 
   mutexOption.addOption(&ANSITimeOption);
   mutexOption.addOption(&CivilTimeOption);
   mutexOption.addOption(&RinexFileTimeOption);
   mutexOption.addOption(&GPSEWSOption);
   mutexOption.addOption(&GPSWSOption);
   mutexOption.addOption(&GPSWZOption);
   mutexOption.addOption(&GPSZ29Option);
   mutexOption.addOption(&GPSZ32Option);
   mutexOption.addOption(&JDOption);
   mutexOption.addOption(&MJDOption);
   mutexOption.addOption(&UnixTimeOption);
   mutexOption.addOption(&YDSTimeOption);
   mutexOption.addOption(&inputFormatAndTimeOption);
 
   offsetOrFormatOption.addOption(&offsOnlyOption);
   offsetOrFormatOption.addOption(&formatOption);
}
 
 
void TimCvt::process()
{
   CommonTime ct;
   ct.setTimeSystem(TimeSystem::GPS);
   CommandOption *whichOpt = mutexOption.whichOne();
 
   if (navOption.getCount())
   {
         // create our time system converter
      CommonTime::tsConv = make_shared<NavTimeSystemConverter>();
      NavTimeSystemConverter *ntsc = dynamic_cast<NavTimeSystemConverter*>(
         CommonTime::tsConv.get());
         // create our NavLibrary and associate it with the
         // NavTimeSystemConverter
      ntsc->navLib = make_shared<NavLibrary>();
         // Set the NavLibrary to use the MultiFormatNavDataFactory
      ntsc->navLib->addFactory(ndfp);
         // load the data files.
      std::vector<string> values(navOption.getValue());
      for (size_t i=0; i<values.size(); i++)
      {
         if (!ndfp->addDataSource(values[i]))
         {
            cerr << "Unable to load \"" << values[i] << "\"" << endl;
               // this could be a missing or invalid file either one.
            exitCode = BasicFramework::EXIST_ERROR;
               // We continue because it's possible that the user
               // specified a valid file in addition to this invalid
               // one.  But we still want to indicate the error with
               // the message and exit code.
         }
      }
      switch (debugLevel)
      {
         case 0:
            break;
         case 1:
            ndfp->dump(std::cerr, gnsstk::DumpDetail::OneLine);
            break;
         case 2:
            ndfp->dump(std::cerr, gnsstk::DumpDetail::Brief);
            break;
         default:
            ndfp->dump(std::cerr, gnsstk::DumpDetail::Full);
            break;
      }
   }
   else
   {
      CommonTime::tsConv = make_shared<BasicTimeSystemConverter>();
   }
 
   if (whichOpt)
   {
      CommandOptionWithCommonTimeArg *cta =
         dynamic_cast<CommandOptionWithCommonTimeArg *>(whichOpt);
      if (cta)
      {
         ct = cta->getTime().front();
         if (srcTSOption.getCount())
         {
            ct.setTimeSystem(gnsstk::StringUtils::asTimeSystem(
                                srcTSOption.getValue()[0]));
         }
         else
         {
            ct.setTimeSystem(TimeSystem::GPS);
         }
      }
      else // whichOpt == &inputFormatAndTimeOption
      {
         mixedScanTime( ct,
                        inputTimeOption.getValue().front(),
                        inputFormatOption.getValue().front() );
         if (srcTSOption.getCount())
         {
            ct.setTimeSystem(gnsstk::StringUtils::asTimeSystem(
                                srcTSOption.getValue()[0]));
         }
         else
         {
            ct.setTimeSystem(TimeSystem::GPS);
         }
      }
   }
   else
   {
      ct = SystemTime();
      ct.setTimeSystem(TimeSystem::UTC); 
   }
 
   int i;
   int addOptions = addOption.getCount();
   int subOptions = subOption.getCount();
   for (i = 0; i < addOptions; i++)
      ct += StringUtils::asDouble(addOption.getValue()[i]);
   for (i = 0; i < subOptions; i++)
      ct -= StringUtils::asDouble(subOption.getValue()[i]);
 
   if (tgtTSOption.getCount())
   {
      gnsstk::TimeSystem ts = gnsstk::StringUtils::asTimeSystem(
         tgtTSOption.getValue()[0]);
      if (offsOnlyOption)
      {
         double offset;
         if (!CommonTime::tsConv->getOffset(ct.getTimeSystem(), ts, ct, offset))
         {
            cerr << "Unable to change time systems" << endl;
            exitCode = 1;
         }
         else
         {
            cout << setprecision(20) << offset << endl;
         }
         return;
      }
      else
      {
         if (!ct.changeTimeSystem(ts))
         {
            cerr << "Unable to change time systems" << endl;
            exitCode = 1;
            return;
         }
      }
   }
 
   if (formatOption.getCount())
   {
      cout << printTime(ct, formatOption.getValue()[0]) << endl;
   }
   else
   {
      using StringUtils::leftJustify;
      string eight(8, ' '); // eight spaces
 
      GPSWeekZcount wz(ct);
      CivilTime civ(ct);
 
      cout << endl
           << eight << leftJustify("Month/Day/Year H:M:S", 32)
           << CivilTime(ct).printf("%02m/%02d/%04Y %02H:%02M:%02S") << endl
 
           << eight << leftJustify("Modified Julian Date", 32)
           << setprecision(15) << MJD(ct).printf("%15.9Q") << endl
 
           << eight << leftJustify("GPSweek DayOfWeek SecOfWeek", 32)
           << GPSWeekSecond(ct).printf("%G %w % 13.6g") << endl
 
           << eight << leftJustify("FullGPSweek Zcount", 32)
           << wz.printf("%F % 6z") << endl
 
           << eight << leftJustify("Year DayOfYear SecondOfDay", 32)
           << YDSTime(ct).printf("%Y %03j % 12.6s") << endl
 
           << eight << leftJustify("Unix: Second Microsecond", 32)
           << UnixTime(ct).printf("%U % 6u") << endl
 
           << eight << leftJustify("Zcount: 29-bit (32-bit)", 32)
           << wz.printf("%c (%C)") << endl
 
           << endl << endl;
   }
 
   return;
}
 
 
int main(int argc, char* argv[])
{
#include "NewNavInit.h"
   try
   {
      TimCvt m(argv[0]);
      if (!m.initialize(argc, argv))
         return m.exitCode;
      m.run();
      return m.exitCode;
   }
   catch(Exception& e)
   {
      cout << e << endl;
   }
   catch(std::exception& e)
   {
      cout << e.what() << endl;
   }
   catch(...)
   {
      cout << "unknown error" << endl;
   }
      // only reach this point if an exception was caught
   return BasicFramework::EXCEPTION_ERROR;
}