movementFile.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include "vrfutil/vrfutilDefines.h"

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>

#include <vlutil/vlFilename.h>
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>

#include <set>
#include <vector>


class DT_DLL_vrfutil DtScriptedMovementFileConfiguration
{
public:
   struct Column
   {
      int myColumnInFile;
      std::string myColumnType;
      std::string myColumnUnits;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myColumnInFile);
         ar & BOOST_SERIALIZATION_NVP(myColumnType);
         ar & BOOST_SERIALIZATION_NVP(myColumnUnits);
      }
   };

   typedef std::vector<Column> Columns;

   enum TimeConversion
   {
      Milliseconds = 0,
      Seconds,
      Minutes,
      Hours
   };

   enum DistanceConversion
   {
      Uknown = -1,
      Feet = 0,
      Meters,
      Miles,
      Kilometers,
      NauticalMiles,
      Radians,
      Degrees
   };

public:
   DtScriptedMovementFileConfiguration();

   virtual ~DtScriptedMovementFileConfiguration();

   DtScriptedMovementFileConfiguration(const DtScriptedMovementFileConfiguration&);

   DtScriptedMovementFileConfiguration& operator=(const DtScriptedMovementFileConfiguration&);

   virtual void addColumn(const std::string& type, const std::string& units, int columnInFile = -1);
   
   virtual void removeColumn(int);

   virtual const Columns& columns() const;
   virtual void setColumns(const Columns&);

   virtual void setRowStart(int);

   virtual int rowStart() const;

   virtual int timeColumn() const;

   virtual int altitudeColumn() const;
   virtual int altitudeUnits() const;

   virtual int rangeColumn() const;
   virtual int rangeUnits() const;

   virtual int lateralDistanceColumn() const;
   virtual int lateralDistanceUnits() const;

   virtual int headingColumn() const;
   virtual int headingUnits() const;

   virtual int pitchColumn() const;
   virtual int pitchUnits() const;

   virtual int rollColumn() const;
   virtual int rollUnits() const;

   virtual int column(const std::string&) const;
   virtual int units(const std::string&) const;
   virtual double convertValueForColumn(int col, double value) const;

   virtual double convertTimeToSeconds(double time) const;

   virtual void updateCache();

   virtual int mapToInternalValue(const std::string&) const;

   virtual double convertUnitsToNative(double d, int conv) const;

   virtual DtString toString() const;

   virtual void fromString(const DtString&);

   static DtScriptedMovementFileConfiguration defaultBallisticMissileConfiguration();

   static DtScriptedMovementFileConfiguration defaultPrecisionMovementConfiguration();

   virtual bool setColumn(int col, const std::string& type, const std::string& unit, int columnInFile = -1);

   virtual void column(int col, int& columnInFile, std::string& type, std::string& unit) const;

   virtual void setDisplayName(const std::string&);
   virtual const std::string& displayName() const;

   virtual void setUniqueId(const std::string&);
   virtual const std::string& uniqueId() const;

protected:

   friend class boost::serialization::access;

   template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
   {
      ar & BOOST_SERIALIZATION_NVP(myRowStart);
      ar & BOOST_SERIALIZATION_NVP(myColumns);

      if (version >= 2)
      {
         ar & BOOST_SERIALIZATION_NVP(myDisplayName);
         ar & BOOST_SERIALIZATION_NVP(myUniqueId);
      }

      if (Archive::is_loading::value)
      {
         updateCache();
      }
   }

protected:
   int myRowStart;
   Columns myColumns;
   
   struct CacheColumn
   {
      CacheColumn() : csvColumn(-1), conversion(-1) {};
      CacheColumn(int csv, int col) : csvColumn(csv), conversion(col) {};
      CacheColumn(const CacheColumn& orig) : csvColumn(orig.csvColumn), conversion(orig.conversion) {};
      int csvColumn;
      int conversion;
   };

   typedef std::map<std::string, CacheColumn> CachedMap;
   
   CachedMap myCachedColumnsByType;
   CachedMap myCachedColumnsByColumn;

   std::string myUniqueId;
   std::string myDisplayName;
};

typedef std::vector<double> DtMovementFileRow;
typedef std::vector<DtMovementFileRow> DtMovementFileData;

class DT_DLL_vrfutil DtMovementFileLoaderInterface
{
public:
   virtual DtMovementFileData loadMovementFileData(const DtFilename&, const std::string& configuration,
      int loadRows = -1) const = 0;

   virtual DtScriptedMovementFileConfiguration currentFileConfiguration() const = 0;

   virtual DtScriptedMovementFileConfiguration defaultFileConfiguration() const = 0;

   virtual std::vector<std::string> formatsForFile(const DtFilename&) const = 0;
};

class DT_DLL_vrfutil DtMovementFile
{
public:
   typedef boost::function<DtMovementFileLoaderInterface* ()> MovementFileLoaderInterfaceCreator;

   typedef std::vector<DtScriptedMovementFileConfiguration> MovementFileConfigurations;

public:
   DtMovementFile();

   virtual ~DtMovementFile();

   DtMovementFile(const DtMovementFile&);

   DtMovementFile& operator=(const DtMovementFile&);

   virtual double simTime(int) const;

   virtual int numRows() const;

   virtual bool hasOffsetOrientation() const;

   virtual DtVector bodyOffsetVector(int row) const;

   virtual DtTaitBryan orientationOffset(int row) const;

   virtual bool isLoaded() const;

   virtual bool load(const DtFilename& file, const std::string& configuration, int rowsToLoad = -1);

   virtual int movementRow(double) const;

   virtual void reset();

   virtual void setObjectOffsetLocation(int row, const DtVector&);

   virtual void setObjectOffsetOrientation(int row, const DtTaitBryan&);

   virtual void setTimeDelta(int forRow, double timeDelta);

   virtual void removeRow(int);

   virtual void setDefaultTimeScale(double);
   virtual double defaultTimeScale() const;

   static DtScriptedMovementFileConfiguration defaultConfigurationForFile(const DtFilename&);

   static std::vector<std::string> dialogStrings();

   static int addLoadableFileType(std::string extension, std::string displayString, MovementFileLoaderInterfaceCreator);

   static std::vector<std::string> supportedExtensions();

   static void removeLoadableFileType(const DtString& extension);

   static DtMovementFileLoaderInterface* loader(const DtFilename& filename);

   static std::vector<std::string> formatsForFile(const DtFilename&);

   static MovementFileConfigurations loadMovementFileConfigurations(const DtFilename& directory);

   static bool saveMovementFileConfigurations(const MovementFileConfigurations& configs, const DtFilename& file);

protected:
   DtScriptedMovementFileConfiguration myConfiguration;
   double myDefaultTimeScale;
   DtMovementFileData myMovementFileData;

   struct MovementFileLoader
   {
      MovementFileLoaderInterfaceCreator fcn;
      std::string displayString;
   };

   typedef std::map<std::string, MovementFileLoader> MovementFileLoaders;
   static MovementFileLoaders* theMovementFileLoaders;

   boost::shared_ptr<DtMovementFileLoaderInterface> myMovementFileInterface;
};

#define REGISTER_MOVEMENT_FILE_LOADER(extension, displayString, creator) \
   static int autoRegisterMovementFileInt = DtMovementFile::addLoadableFileType(extension, displayString, boost::bind(&creator));

BOOST_CLASS_VERSION(DtScriptedMovementFileConfiguration, 2)