DtCoordinateSystem.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2018 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/


#pragma once
#include <vrvUtil/vrvUtil.h>
#include <makArchives/DtDisplayUnitsSettingsRecord.h>
#include <matrix/vlVector.h>
#include <boost/unordered_map.hpp>

class DtMapDatum;
class DtTaitBryan;
class DtDcm;
class DtReferenceEllipsoid;

namespace makVrv
{

   class DtNoOpCoordinateConverter;
   class DtFlatEarthCoordinateConverter;
   class DtGeocentricCoordinateConverter;
   class DtUtmCoordinateConverter;
   class DtCartesianCoordinateConverter;
   class DtLambertCoordinateConverter;
   class DtCoordinateConverterFactory;
   class DtCoordinateConverter;

   class DtCoordinateDisplay;
   class DtCoordinateDisplayCollection;
   class DtUnitConverterCollection;
   class DtUnicode;

   class DT_DLL_VRVUTIL DtCoordinateSystem
   {
   public:

      typedef DtCoordinateSystem* (*CoordinateSystemCreatorFn)();
      typedef DtCoordinateSystem* (*CoordinateSystemCloneFn)(const DtCoordinateSystem&);
      typedef void (*TypeChangedFn)(DtCoordinateSystem*, void*);

      static DtCoordinateSystem* create();

      DtCoordinateSystem* clone() const;

      virtual ~DtCoordinateSystem();

      const std::string& type() const;

      bool isGeocentric() const;

      const std::string& parameters() const;

      bool set(const std::string& type, const std::string& origin);

      bool addConverter(const std::string& t, DtCoordinateConverter* converter);

      DtCoordinateConverter* converter() const;

      DtCoordinateConverter* converter(const std::string& type) const;

      virtual DtCoordinateDisplay* display(
         makArchives::DtDisplayUnitsSettingsRecord::CoordSys system ) const;

      virtual DtCoordinateDisplay* display(
         const DtUnicode& coordSysName ) const;

      virtual DtCoordinateDisplayCollection& displays();
      virtual const DtCoordinateDisplayCollection& displays() const;

      virtual DtUnitConverterCollection& units();
      virtual const DtUnitConverterCollection& units() const;

      DtNoOpCoordinateConverter* noopConverter();
      const DtNoOpCoordinateConverter* noopConverter() const;

      DtUtmCoordinateConverter* utmConverter() ;
      const DtUtmCoordinateConverter* utmConverter() const;

      DtLambertCoordinateConverter* lambertConverter() ;
      const DtLambertCoordinateConverter* lambertConverter() const;
 
      DtCartesianCoordinateConverter* cartesianConverter() ;
      const DtCartesianCoordinateConverter* cartesianConverter() const;

      DtGeocentricCoordinateConverter* geocentricConverter() ;
      const DtGeocentricCoordinateConverter* geocentricConverter() const;

      DtFlatEarthCoordinateConverter* flatEarthConverter() ;
      const DtFlatEarthCoordinateConverter* flatEarthConverter() const;

      void setUseTopoForFlatEarthVectorConversion( bool flag );
      bool useTopoForFlatEarthVectorConversion() const;

      const DtMapDatum& datum() const;

      void setDatum(const DtMapDatum& datum);

      void netToLocalPos(const DtVector& netpos, DtVector& localpos) const;
      void netToLocalVec(const DtVector& localpos, const DtVector& netvec, DtVector& localvec) const;
      void netToLocalVec(const DtVector& localpos, const DtVector32& netvec, DtVector32& localvec) const;
      void netToLocalOri(const DtVector& localpos, const DtTaitBryan& netori, DtTaitBryan& localori) const;
      void netToLocalHpr(const DtVector& localpos, const DtTaitBryan& netori, DtTaitBryan& localhpr) const;  
      void netBodyToLocalBody(const DtVector& localpos, const DtDcm& netdcm, DtDcm& localdcm) const;


      /* FIXME: This function does not work
      inline void netToLocalPos(const double netpos[3], double localpos[3]) const
      {
         DtVector localpos_v;
         DtVector netpos_v;         
         memcpy(&netpos_v,netpos,sizeof(netpos));
         netToLocalPos( netpos_v, localpos_v);
         memcpy(localpos,&localpos_v,sizeof(localpos));      
      }*/

      void netToLocalOri(const double localpos[3], const double netori[3], double localori[3]) const;

      void localToNetPos( const DtVector& localpos, DtVector& netpos) const;    
      void localToNetOri(const DtVector& localpos, const DtTaitBryan& localori, DtTaitBryan& netori) const;
      void localToNetVec(const DtVector& localpos, const DtVector& localvec, DtVector& netvec) const;
      void localToNetVec(const DtVector& localpos, const DtVector32& localvec, DtVector32& netvec) const;

      inline void localToNetPos( const double (&localpos)[3], double (&netpos)[3]) const
      {  
         DtVector localpos_v;
         memcpy(&localpos_v,localpos,sizeof(localpos));
         DtVector netpos_v;         
         localToNetPos( localpos_v, netpos_v);
         memcpy(netpos,&netpos_v,sizeof(netpos));
      }

      void localToNetOri(const double localpos[3], const double localori[3], double netori[3]) const;

   public:

      static DtCoordinateConverterFactory& converterFactory();

      static void setCreator(CoordinateSystemCreatorFn fn);

      static const DtReferenceEllipsoid* referenceEllipsoid();


   protected:

      DtCoordinateSystem();

      DtCoordinateSystem(const DtCoordinateSystem&);

   private:

      DtCoordinateSystem& operator=(const DtCoordinateSystem&);

   protected:

      typedef boost::unordered_map<std::string, DtCoordinateConverter*> ConverterMap;
      
      ConverterMap myConverters;
      DtCoordinateConverter* myCurrentConverter;
      std::string myCoordinateSystemParameters;

      DtCoordinateDisplayCollection* myDisplays;
      DtUnitConverterCollection* myUnits;
      bool myUseTopoForFlatEarthVectorConversion;

   protected:   

      static CoordinateSystemCreatorFn theCreatorFn;
      static CoordinateSystemCloneFn theCloneFn;
      static DtCoordinateConverterFactory theCoordConverterFactory;
      static DtReferenceEllipsoid* theReferenceEllipsoidPtr;

      

   };

}