include/terrainCS/lamConfCrdSys.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2005 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: lamConfCrdSys.h,v $ $Revision: 1.15 $ $State: Exp $
*********************************************************************/
#ifndef lamConfCrdSys_H_
#define lamConfCrdSys_H_

//
// \file lamConfCrdSys.h 
// \brief Contains the lambert conformal coordinate system class declaration.
// 
#include "terrainCS/terrainCSDefines.h"
#include "terrainCS/utmCoordSys.h"

// Derived class for converting between DIS (geocentric) and
// coordinates in a Lambert Conformal projection.
// 
// Before instantiating this class, you must call DtUseMapDatum
// to specify which shape for the earth you want to use.
//
// \note This class does not support dynamic scene origin
class DT_DLL_terrainCS DtLambertConformalCS : public DtUtmCS
{
public:

   // The values passed to the constructor (all in radians) are:
   //  lambda0 - longitude east of Greenwich of the central meridian of the map
   //  phi0 - middle latitude
   //  phi1, phi2 - standard parallels of latitude
   DtLambertConformalCS(double passedLambda0, double passedPhi0,
      double passedPhi1, double passedPhi2);

   // Need this for FILE* based constructor in derived class.
   DtLambertConformalCS();

   DtLambertConformalCS(const DtLambertConformalCS& orig);

   // Destructor
   virtual ~DtLambertConformalCS();

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

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

   // Coordinates in the local (i.e., projected) coordinate system only
   // consist of X and Y, but we use a three element vector to store them so a
   // programmer can use the Z value for height above terrain.
   virtual void dis2local(const DtVector& in, DtVector& out) const;
   virtual void local2dis(const DtVector& in, DtVector& out) const;

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

   double getPhi1() const;
   double getPhi2() const;

   virtual bool isSameCS(const Coordinate_System* CSystem) const;

   // Override as UTM grid declination calculations should not be used for this
   virtual DtDcm topoToUtmMatrix(const DtVector& geocLoc) const;
   virtual DtDcm utmToTopoMatrix(const DtVector& geocLoc) const;

protected:
   // The projection requires:

   // Semi-major axis of the ellipsoid of reference
   double a;

   // Semi-minor axis of the ellipsoid of reference
   double b;

   // Eccentricity of the ellipsoid (1 - b^2/a^2)^ (1/2)
   double e;

   // Middle latitude
   double phi0;

   // Standard parallels of latitude
   double phi1;
   double phi2;

   // Longitude east of Greenwich of the central meridian of the map
   double lambda0;

   // Intermediate parameters that don't rely on phi and lambda
   double n;
   double F;
   double p0;

   // The forward and inverse coordinate transformations share several
   // intermediate variables which are further based on lower level
   // parameters.  The low level and intermediate variables are not based on
   // the lat/lon being transformed.  They only rely on the reference
   // ellipsoid, central meridian, middle and standard parallels. Since they
   // are not dependent on the lat/long being translated, they need only be
   // computed once. Based on Map Projections: A Working Manual by Snyder, the
   // parameters can be divided thusly: low level parameters are m1, m2, t0,
   // t1 and t2.  They are only used to compute the intermediate
   // parameters. intermediate parameters are n, F and p0 are the same for both
   // forward and inverse computations t and p are different for forward and
   // inverse computations. To prevent the repetition of code, a function is
   // provided to compute intermediate parameters.

   void computeIntermediateParameters(double* n,double* F,double* p0);
};

inline double DtLambertConformalCS::getPhi1() const
{
   return phi1;
}

inline double DtLambertConformalCS::getPhi2() const
{
   return phi2;
}

#endif