include/terrainCS/coordSystem.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1996-2005 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: coordSystem.h,v $ $Revision: 1.30 $ $State: Exp $
*********************************************************************/
#ifndef coordSystem_H_
#define coordSystem_H_

//
// \file coordSystem.h Contains the base (Geocentric, aka DIS) coordinate system class declaration.
// 

#include "terrainCS/terrainCSDefines.h"
#include <matrix/vlMath.h>
#include <matrix/utmCoord.h>
#include <vl/utmView.h>
#include "geometry/tdbextent.h"
#include <memory>
#include <vlutil/vlMutex.h>
#include <vlutil/vlScopedLock.h>

#define GETLAT(dms)     ((dms).lat())
#define GETLON(dms)     ((dms).lon())
#define GETALT(dms)     ((dms).alt())
#define SETLAT(dms,l)   ((dms).setLat((l)))
#define SETLON(dms,l)   ((dms).setLon((l)))
#define SETALT(dms,a)   ((dms).setAlt((a)))

#define DtSQR(x)    ((x)*(x))

namespace MAKVRinTerra { class DtProj; }

enum CS_Type {
   CS_NONE,
   CS_LCC, 
   CS_UTM, 
   CS_GEOD,
   CS_DIS, 
   CS_TCC,
   CS_FLATEARTH, // Add future CS_Types after this one.
   CS_BCI210=50331650 // this is a specific coordinate system for BCI
};

// Coordinate_System is the base class for converting between DIS
// (geocentric) and local (DB) coordinates.  Coordinates are WGS84
// geocentric Cartesian coordinate (GCC) systems.  Rotations are
// defined as right-handed rotations about Z, then Y, then X and DIS
// body coordinates are defined as X front, Y right, Z down.
// Rotations transform between DIS body and DIS world.
//
// All derived classes convert between their own system and the DIS system
class DT_DLL_terrainCS Coordinate_System
{
public:
   class ProjData;

   // Constructor
   Coordinate_System(bool setUseDynamicSceneOrigin = false, 
                     double dynamicSceneOriginDeadband = 0.0);

   // Copy constructor
   Coordinate_System(const Coordinate_System& orig);

   // Destructor
   virtual ~Coordinate_System();

   // Assignment operator
   Coordinate_System& operator=(const Coordinate_System& orig);

   // Clone operator
   virtual Coordinate_System* clone() const;

   virtual void dis2local(const DtVector& in, DtVector&  out) const;

   virtual void dis2local(const DtDcm& in, DtDcm& out) const;

   virtual void dis2local(const DtVector& vIn, const DtDcm& dIn,
      DtVector&  vOut, DtDcm& dOut) const;

   virtual void disBody2localBody(const DtVector& in, DtVector&  out) const;

   virtual void disBody2localBody(const DtDcm& in, DtDcm& out) const;

   virtual void local2dis(const DtVector& in, DtVector&  out) const;

   virtual void local2dis(const DtDcm& in, DtDcm& out) const;

   virtual void local2dis(const DtVector& vIn, const DtDcm& dIn,
      DtVector&  vOut, DtDcm& dOut) const;

   virtual void localBody2disBody(const DtVector& in, DtVector&  out) const;

   virtual void localBody2disBody(const DtDcm& in, DtDcm& out) const;

   // Returns the geodetic coordinate for a given local position.
   virtual void localToGeodetic(const DtVector& localPosition,
      DtGeodeticCoord& geodeticPosition) const;
   virtual void localToGeodetic(const DtVector& localPosition,
      DtVector& geodeticPosition) const;

   // Returns the local coordinate for a given geodetic position.
   virtual void geodeticToLocal(const DtGeodeticCoord& geodeticPosition,
      DtVector& localPosition) const;
   
   virtual void geodeticToLocal(const DtVector& geodeticPosition,
      DtVector& localPosition) const;

   // \return A rotation matrices for going between topo and local coordinates, 
   // at a given local position.  It is up to the caller to ensure that 
   // topoToLocal and localToTopo are valid pointers.
   virtual void topoToLocal(const DtVector& localPosition, DtDcm& topoToLocal) const;
   virtual void localToTopo(const DtVector& localPosition, DtDcm& localToTopo) const;

   // \return The unit vector pointing down (along the direction
   // of gravity) at a given local position.
   virtual DtVector down(const DtVector& localPosition) const;

   virtual DtDegMinSec latitudeOrigin() const;

   virtual DtDegMinSec longitudeOrigin() const;

   virtual CS_Type getCS_Type() const;

   virtual bool isSameCS(const Coordinate_System* CSystem) const;

   // Reset the origin of the scene
   virtual void updateDynamicSceneOrigin(const DtVector& New_Origin);

   // Convert the CIG value to scene value by compensating for the
   // scene origin offset.
   virtual void Cig2Scene(const DtVector& Cig, DtVector&  Scene) const;

   // Convert the scene value to CIG value by compensating for the
   // scene origin offset.
   virtual void Scene2Cig(const DtVector& Scene, DtVector&  Cig) const;

   // Returns true if the scene origin was updated during this frame,
   // false otherwise.  If the scene origin was updated, previous
   // local coordinate values will have to be updated.
   virtual bool sceneOriginUpdatedThisFrame();

   // Returns the current scene origin in Cig coordinates.
   virtual void sceneOrigin(DtVector& origin) const;

   // @return True if dynamic scene origin is in affect.
   virtual bool useDynamicSceneOrigin();

   virtual void localToGeodetic(const DtExtent& extent, DtExtent& destExtent) const;
   virtual void geodeticToLocal(const DtExtent& extent, DtExtent& destExtent) const;

   virtual void local2dis(const DtExtent& extent, DtExtent& destExtent) const;
   virtual void dis2local(const DtExtent& extent, DtExtent& destExtent) const;

   // Returns name of coordinate system
   virtual DtString coordinateSystemName() const;

   // Sets the new lat/lon for the origin of the coordinate system
   virtual void setOrigin(const DtGeodeticCoord&);
   virtual DtGeodeticCoord origin() const;

   // This class allows VRIT to attach proj data to this CS so we don't have to
   // add new code to MTTK which is a pain to test and update.
   class DT_DLL_terrainCS ProjData {
   public:
      virtual const MAKVRinTerra::DtProj* proj() const = 0;
      virtual std::auto_ptr<ProjData> clone() const = 0;
      virtual ~ProjData();
   };

   // Allows thread-safe access to internal ProjData object.
   class DT_DLL_terrainCS ProjAccess {
   public:
      explicit ProjAccess(Coordinate_System* cs)
         : myCS(cs), myLock(cs->myProjMutex) { }

      const MAKVRinTerra::DtProj* get() const {
         return myCS->myProjData.get() ? myCS->myProjData->proj() : 0;
      }

      void set(std::auto_ptr<ProjData> p) {
         myCS->myProjData = p;
      }

   private:
      Coordinate_System* myCS;
      DtScopedLock myLock;
   };

protected:
   DtDegMinSec myLatitudeOrigin;
   DtDegMinSec myLongitudeOrigin;
   CS_Type myCoordinateSystemType;
   bool myDynamicSceneOriginInAffect;
   bool myDynamicSceneOriginUpdatedThisFrame;
   bool myInitialized;
   DtVector myScenePosition;
   double myDynamicSceneOriginDeadbandRegion;

   // access controled by ProjAccess
   friend class ProjAccess;
   mutable DtMutex myProjMutex;
   std::auto_ptr<ProjData> myProjData;
};

#endif