utmCS.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1996 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: utmCoordSys.h,v $ $Revision: 1.35 $ $State: Exp $
*********************************************************************/
#ifndef utmCS_H_
#define utmCS_H_

//
// \file utmCoordSys.h Contains the declaration of the UTM coordinate system class.
//
#include "terrainCS/terrainCSDefines.h"
#include "terrainCS/coordSystem.h"
#include <matrix/utmCoord.h>
#include <vl/utmView.h>
#include <matrix/utmReferencePoint.h>

// DtUtmCS 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 ate defined as Y front, X 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 DtUtmCS : public Coordinate_System
{
public:

   DtUtmCS(const DtDegMinSec &refLatitude,
                         const DtDegMinSec &refLongitude, 
                         int standardOffsets,
                         long zone = 0,
                         bool setUseDynamicSceneOrigin = false,
                         double dynamicSceneOriginDeadband = 0.0,
                         double scaleFactor = 0.9996);
   
   DtUtmCS(double refLatitude,  // in Radians
                         double refLongitude, // in Radians
                         int standardOffsets,
                         long zone = 0,
                         bool setUseDynamicSceneOrigin = false,
                         double dynamicSceneOriginDeadband = 0.0,
                         double scaleFactor = 0.9996);

   //
   // \note These parameters are available from ModSAF CTDBs. 
   DtUtmCS(int zone,
                         double northing,
                         double easting,
                         double scaleFactor = 0.9996);

   DtUtmCS(const DtUtmCS& orig);

   // Destructor
   virtual ~DtUtmCS();

   // Assignment operator
   DtUtmCS& operator=(const DtUtmCS& 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;

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

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

   // \return A coordinate transformation object for going between 
   // topo and local coordinates, at a given location.  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 Unit vector pointing down (along the direction of gravity) 
   // at the specified location.
   virtual DtVector down(const DtVector& location) const;

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

   // Given a latitude & longitude, returns the UTM zone number in which
   // that coordinates resides.  With the exception of a couple anomalies,
   // the world is broken up into 6 degree wide slices.
   static DtU16 latlonToUtmZone(double lat_deg, double lon_deg);

   // \return The UTM zone of utmReferencePoint
   virtual long zone() const;

   // \return Zone of myZone member.
   long userSetZone() const;
   void setUserSetZone(long);

   // Reinitializes coordinate system from newly specified zone
   virtual void initFromZone(long zone);

   // Call this to reset the lat/lon and zone from new values.  Will only
   // set the coordinate system.  Will not reset the coordinates of the
   // database
   virtual void initFromLatLonZone(double radLat, double radLon, int zone = 0, double scaleFactor = 0.9996);

   int zoneOrigin() const;

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

   double projectionScale() const;
   virtual void setOrigin(const DtGeodeticCoord& c);

   virtual bool isSameCS(const Coordinate_System* CSystem) const;

   // Returns transform matricies that use grid declination to be able to translate
   // between coordiate systems
   virtual DtDcm geocToUtmMatrix(const DtVector& geocLoc) const;
   virtual DtDcm utmToGeocMatrix(const DtVector& geocLoc) const;
   virtual DtDcm utmToTopoMatrix(const DtVector& geocLoc) const;
   virtual DtDcm topoToUtmMatrix(const DtVector& geocLoc) const;

   virtual void setStandardFalseEasting(double);
   virtual void setStandardFalseNorthing(double);

   virtual double standardFalseEasting() const;
   virtual double standardFalseNorthing() const;

   const DtUtmReferencePoint* utmReferencePoint() const;

private:
   // This class only partially overrides these functions, so hide them explicitly.
   using Coordinate_System::dis2local;
   using Coordinate_System::local2dis;
   using Coordinate_System::localToGeodetic;
   using Coordinate_System::geodeticToLocal;

public:
   static double UTM_Projection_Scale;

protected:

   // Used by derived classes
   DtUtmCS();

   void initRefLatLon(const DtDegMinSec &refLatitude, const DtDegMinSec &refLongitude,
      int standardOffsets, long zone = 0, bool setUseDynamicSceneOrigin = false,
      double dynamicSceneOriginDeadband = 0.0, double scaleFactor = 0.9996);

   DtDcm myOriginDis2Utm;
   DtDcm myOriginUtm2Dis;

   // These are saved so that we can serialize and un-serialize the CS. 
   DtDegMinSec myRefLatitude;
   DtDegMinSec myRefLongitude;
   long        myZone;
   int         myStandardOffsets;
   int         myUseDynamicSceneOrigin;
   double      myDynamicSceneOriginDeadband;
   double      myScaleFactor;
   DtUtmReferencePoint myUtmReferencePoint;
};

inline const DtUtmReferencePoint* DtUtmCS::utmReferencePoint() const
{
   return &myUtmReferencePoint;
}

inline int DtUtmCS::zoneOrigin() const
{
   return myUtmReferencePoint.zoneOrigin();
}

inline double DtUtmCS::projectionScale() const
{
   return myScaleFactor;
}

inline long DtUtmCS::userSetZone() const
{
   return myZone;
}

inline void DtUtmCS::setUserSetZone(long c)
{
   myZone = c;
}

#endif