E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeProjection.h

Go to the documentation of this file.

/************************************************************************************
TerraLib - a library for developing GIS applications.
Copyright  2001-2007 INPE and Tecgraf/PUC-Rio.

This code is part of the TerraLib library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

You should have received a copy of the GNU Lesser General Public
License along with this library.

The authors reassure the license terms regarding the warranties.
They specifically disclaim any warranties, including, but not limited to,
the implied warranties of merchantability and fitness for a particular purpose.
The library provided hereunder is on an "as is" basis, and the authors have no
obligation to provide maintenance, support, updates, enhancements, or modifications.
In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
indirect, special, incidental, or consequential damages arising out of the use
of this library and its documentation.
*************************************************************************************/
#ifndef  __TERRALIB_INTERNAL_PROJECTION_H
#define  __TERRALIB_INTERNAL_PROJECTION_H

#include "TeCoord2D.h"
#include "TeDefines.h"
#include "TeDatum.h"

#include <stdio.h>
#include <map>
#include <string>

using namespace std;

enum TeHemisphere
{ TeNORTH_HEM, TeSOUTH_HEM };

const int NUM_PROJ = 13;

struct TL_DLL TeProjInfo 
{
           int hasUnits;
           int hasLon0;
           int hasLat0;
           int hasStlat1;
           int hasStlat2;
           int hasScale;
           int hasOffx;
           int hasOffy;
};

typedef map<string,TeProjInfo> TeProjInfoMap;

TL_DLL TeProjInfo TeProjectionInfo ( const string& projName  );

TL_DLL const char** TeGetProjInfo();

// ============ PROJECTION PARAMETERS ===============

class TeProjection;

//FAMI Added Satellite parameters
struct TL_DLL TeProjectionParams
{
           string     name;           
           TeDatum datum;       
        double        lon0;           
           double  lat0;              
           double     offx;           
           double     offy;           
           double     stlat1;         
           double  stlat2;      
           string  units;       
           double  scale;       
           TeHemisphere hemisphere; 
           double  pri;         
           double  prj;         
           double  pis;         
           double  pjs;         
           double  prs;         
           double  pscn;        
           double  pyaw;        

  TeProjectionParams()
  {
             name="";      
    lon0=0.;               
             lat0=0.;        
             offx=0.;      
             offy=0.;      
             stlat1=0.;               
             stlat2=0.;      
             units="";       
             scale=0.;       
             pri=0.;         
             prj=0.;         
             pis=0.;         
             pjs=0.;         
             prs=0.;         
             pscn=0.;        
             pyaw=0.;        
  }
};

//========== PROJECTION FACTORY
class TL_DLL TeProjectionFactory 
{
public:
  static TeProjection* make( const TeProjectionParams& );
  static TeProjection* make(int epsgCode);
};


class TL_DLL TeProjection 
{
protected:
           string     GPname;                 // projection name
           TeDatum GPdatum;             // spheroid
           double     GPlon0;                 // Longitude of origin (rad)
           double  GPlat0;                    // Latitude of origin (rad)  
           double     GPoffx;                 // X (projection coordinate) offset (m)
           double     GPoffy;                 // Y (projection coordinate) offset (m)
           double     GPstlat1;            // First standard parallel (rad)
           double  GPstlat2;            // Second standard parallel (rad)
           string  GPunits;             // units
           double  GPscale;             // scale (used for UTM)
           TeHemisphere  GPhemisphere;  // Hemisphere
           TeProjection* GPdestination; // destination projection
           int              GPid;          // id
    int               GPepsgCode;                      //the epsg code associated to the given projection
           TeUnits               GPunitsEnum; //an enum to store the units and used for performance porpouses


           void       ChangeLL (double &x, double &y); 

public:


           TeProjection ( const string& name, const TeDatum& datum,
                      double lon0 = 0., double lat0=0., double offx = 0., double offy = 0.,
                      double stlat1 = 0., double stlat2 = 0., 
                      const string units = "Meters",
                      double scale = 1., TeHemisphere hem = TeSOUTH_HEM, int epsgcode = -1):
                      GPname   ( name ),
                      GPdatum  ( datum ),
               GPlon0   ( lon0 ),
               GPlat0   ( lat0  ),
               GPoffx   ( offx  ),
               GPoffy   ( offy ),
               GPstlat1 ( stlat1 ),
               GPstlat2 ( stlat2 ),
               GPunits  ( units ),
               GPscale  ( scale ),
               GPhemisphere ( hem ),
                      GPdestination (0),
                      GPid(0),
        GPepsgCode(epsgcode)
                      {
                                 GPunitsEnum = TeGetUnit(units);
                      }

                      TeProjection ():
                      GPname   ( "NoProjection" ),
               GPlon0   ( 0. ),
               GPlat0   ( 0. ),
               GPoffx   ( 0. ),
               GPoffy   ( 0. ),
               GPstlat1 ( 0. ),
               GPstlat2 ( 0. ),
               GPunits  ( "Units" ),
               GPscale  ( 1 ),
               GPhemisphere ( TeSOUTH_HEM ),
                      GPdestination (0),
                      GPid(0),
                      GPepsgCode(99999),
                      GPunitsEnum(TeUndefinedUnit)
           {}

           TeProjection(const TeProjection&);

           TeProjection& operator=(const TeProjection&);

           virtual ~TeProjection (){}

           inline string& name() { return GPname; }
           
  inline const string& name() const { return GPname; } 

           TeDatum datum()
           { return GPdatum; }
           
  inline const TeDatum& datum() const { return GPdatum; }         

           void setDatum(const TeDatum& datum)
           {          GPdatum = datum; }

           string& units()
           { return GPunits; }

           double     lon0() { return GPlon0;          }
           
           double  lat0() { return GPlat0;  }            

           double     offX() { return GPoffx; }         
    
           double     offY() { return GPoffy;           }
    
           double     stLat1() { return GPstlat1; }
           
           double  stLat2() { return GPstlat2; }
           
           double  scale()  { return GPscale;   }
           
           int epsgCode() { return GPepsgCode; }

           void epsgCode(int code) { GPepsgCode = code; }

           inline const TeHemisphere& hemisphere() const {        return GPhemisphere; }
                      
           // Returns a the parameters of this projection
           virtual TeProjectionParams params () const; //FAMI

           bool operator== (const TeProjection& proj);


           virtual    TeCoord2D LL2PC (const TeCoord2D& p) = 0;
           virtual    void         LL2PC (ostream&) const {} //FAMI


           virtual    TeCoord2D  PC2LL (const TeCoord2D& p) = 0;

           virtual    void LL2PC (double, double, double&, double&) const {printf("\nWRONG"); return;} //FAMI
           virtual    void PC2LL (double, double, double&, double&) {printf("\nWRONG"); return;} //FAMI

           void setDestinationProjection (TeProjection* proj)
           { GPdestination = proj; }
           
           void print ( FILE* file_ );

           string describe ();

           int        id() { return GPid;}

           void id(int i) { GPid = i;}
};



class TL_DLL TeUtm : public TeProjection
{
public:


           TeUtm ( const TeDatum& datum, double long0, double lat0 = 0., 
                           double offx = 500000., double offy = 10000000., 
                                  const string& units = "Meters",
                                  double scale = 0.9996, TeHemisphere hemisphere = TeSOUTH_HEM );
           ~TeUtm () {}


           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           /*         Projection transforms UTM into geodetic coordinates.
                      \param p:  UTM coordinates (m).
                      \return p: Geodetic coordinates (rad).
                      \note
                      X and Y UTM coordinates must be both valid, within
                      their typical range. Conventional UTM offsets are
                      handled in this method, and therefore must not be 
                      previously subtracted.
           */
           virtual TeCoord2D PC2LL(const TeCoord2D& p);
};


class TL_DLL TeLambertConformal : public TeProjection
{
public :

           TeLambertConformal ( const TeDatum& datum, 
                                       double long0,
                                              double lat0, 
                                                                   double offx, 
                                                                   double offy,
                                                                   double stlat1, 
                                                                   double stlat2, 
                                                                   const string& units = "Meters" ):
           TeProjection ( "LambertConformal", datum, long0, lat0, offx, offy, stlat1, stlat2, units, 1., TeSOUTH_HEM, 9802)
           {}

           ~TeLambertConformal () {}


           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual    TeCoord2D PC2LL(const TeCoord2D& p);
};


class TL_DLL TeMercator : public TeProjection
{

public:

           TeMercator ( const TeDatum& datum,  
                               double long0, 
                                             double lat0 = 0.,
                                             double offx = 0., 
                                             double offy = 0.,
                                             double stlat1 = 0.,
                                             const string& units = "Meters"): 
           TeProjection ( "Mercator", datum, long0, lat0, offx, offy, stlat1, 0., units,1., TeSOUTH_HEM, 9805)
           {}

           ~TeMercator () {}

           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual TeCoord2D PC2LL(const TeCoord2D& p);

};




class TL_DLL TePolyconic : public TeProjection
{
public:

           TePolyconic (const TeDatum& datum,  
                               double long0, 
                                             double lat0 = 0.,
                                             double offx = 0., 
                                             double offy = 0.,
                                             const string& units = "Meters");
           
           ~TePolyconic () {}


           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual TeCoord2D PC2LL(const TeCoord2D& p);
};

class TL_DLL TeLatLong : public TeProjection
{

public :

           TeLatLong( const TeDatum& datum, const string& units = "DecimalDegrees" );

           ~TeLatLong () {}

           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual TeCoord2D PC2LL(const TeCoord2D& p);

           virtual void LL2PC(double xi, double yi, double& xo, double& yo) const; //FAMI
           virtual void PC2LL(double xi, double yi, double& xo, double& yo); //FAMI

};

/*
  Specifies methods that are necessary to establish the relation between
  geodetic and Albers Conic coordinates. Albers Conic is an equal-area
  projection system. 
*/
class TL_DLL TeAlbers : public TeProjection
{
public:

           TeAlbers( const TeDatum& datum, 
                            double lon0,
                                   double lat0, 
                                   double offx, 
                                   double offy,
                                   double stlat1, 
                                   double stlat2, 
                                   const string& units = "Meters" ):
                      TeProjection ( "Albers", datum, lon0, lat0, offx, offy, stlat1, stlat2, units, 1, TeSOUTH_HEM, 9822 )
           {} 

           ~TeAlbers () { }

           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual TeCoord2D PC2LL(const TeCoord2D& p);
};


class TL_DLL TeMiller : public TeProjection 
{
public:

           TeMiller ( const TeDatum& datum,  
                               double long0, 
                                             double offx = 0., 
                                             double offy = 0.,
                                             const string& units = "Meters"): 
           TeProjection ( "Miller", datum, long0, 0., offx, offy, 0., 0., units )
           {}

           ~TeMiller () {}

           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual TeCoord2D PC2LL(const TeCoord2D& p);

};


class TL_DLL TeSinusoidal : public TeProjection        
{
public:


           TeSinusoidal (const TeDatum& datum,  
                               double long0, 
                                             double offx = 0., 
                                             double offy = 0.,
                                             const string& units = "Meters"): 
           TeProjection ( "Sinusoidal", datum, long0, 0., offx, offy, 0., 0., units )
           {}

           ~TeSinusoidal () {}

           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual TeCoord2D PC2LL(const TeCoord2D& p);
};

class TL_DLL TeCylindricalEquidistant : public TeProjection
{
public:


           TeCylindricalEquidistant (const TeDatum& datum,  
                               double lon0, 
                                             double offx = 0., 
                                             double offy = 0.,
                                             double stlat1 = 0.,
                                             const string& units = "Meters");
           ~TeCylindricalEquidistant () {}

           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual TeCoord2D PC2LL(const TeCoord2D& p);
};

class TL_DLL TePolarStereographic : public TeProjection
{
public:

           TePolarStereographic ( const TeDatum& datum,  
                               double lon0,  
                                             double offx = 0., 
                                             double offy = 0.,
                                             const string& units = "Meters",
                                             const TeHemisphere hem = TeSOUTH_HEM );

           ~TePolarStereographic () {}

           virtual TeCoord2D LL2PC(const TeCoord2D& p);
           virtual    void       LL2PC (ostream&) const; //FAMI
           virtual TeCoord2D PC2LL(const TeCoord2D& p);

           virtual void LL2PC(double xi, double yi, double& xo, double& yo) const; //FAMI
};

//FAMI
class TL_DLL TeSatelliteProjection : public TeProjection
{

private:
           
           double     SPri,      // Sensor angle resolution along y axis in radians
                      SPrj,      // Sensor angle resolution along x axis in radians
                      SPis,      // Y-coordinate of sub-satellite point 
                      SPjs,      // X-coordinate of sub-satellite point
                   SPrs,   // Radius of satellite orbit in meters
                      SPscn,     // Scanning mode: 0-WE/NS, 1-SN/EW
                      SPyaw;  // Grid orientation, i.e., angle in radians between
                                 // the increasing y axis and the meridian of the
                                 // sub-satellite point along the direction of
                                 // increasing latitude.
public:

           /*
                      \param datum:         planimetric datum
                      \param offx:          x offset
                      \param offy:          y offset
                      \param Pri:     Sensor angle resolution along y axis in radians
                      \param Prj:           Sensor angle resolution along x axis in radians
                      \param Pis:     Y-coordinate of sub-satellite point 
                      \param Pjs:           X-coordinate of sub-satellite point
                      \param Pla0:          Latitude of sub-satellite point in radians
                      \param Plo0:          Longitude of sub-satellite point in radians
                      \param Prs:           Radius of satellite orbit in meters
                      \param Pscn:          Scanning mode: 0-WE/NS, 1-SN/EW
                      \param Pyaw:          Grid orientation, i.e., angle in radians between
                                            the increasing y axis and the meridian of the
                                            sub-satellite point along the direction of
                                            increasing latitude.
                      */
           TeSatelliteProjection(const TeDatum& datum, double offx, double offy,  
                                       double Pri, double Prj, double Pis, double Pjs, double Pla0, double Plon0, 
                                       double Prs,double Pscn, double Pyaw):
                                 TeProjection("Satellite", datum, Plon0, Pla0, offx, offy, 0., 0.,"Meters",1.,TeSOUTH_HEM),
                                 SPri(Pri),
                                 SPrj(Prj),
                                 SPis(Pis),
                                 SPjs(Pjs),            
                                 SPrs(Prs),
                                 SPscn(Pscn),
                                 SPyaw(Pyaw)           {}

           ~TeSatelliteProjection() {}

           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual    TeCoord2D PC2LL(const TeCoord2D& p);

           // Returns a the parameters of this projection
           virtual TeProjectionParams params () const;
};

class TL_DLL TeNoProjection : public TeProjection
{
public:
           TeNoProjection(const TeDatum& datum = TeDatum(), const string& units = "Units"):
                      TeProjection ( "NoProjection", datum, 0., 0., 0., 0., 0, 0, units, 1, TeSOUTH_HEM )

           {          GPname = "NoProjection", GPunits = units; }

                      ~TeNoProjection () {}

                      virtual TeCoord2D LL2PC(const TeCoord2D& p) { return p; }

                      virtual TeCoord2D PC2LL(const TeCoord2D& p) {return p;};
};


class TL_DLL TeVirtualEarthMercator : public TeProjection
{

public:

           TeVirtualEarthMercator ( const TeDatum& datum,  
                               double long0, 
                                             double lat0 = 0.,
                                             double offx = 0., 
                                             double offy = 0.,
                                             double stlat1 = 0.,
                                             const string& units = "Meters"): 
           TeProjection ( "VirtualEarthMercator", datum, long0, lat0, offx, offy, stlat1, 0., units )
           {}

           ~TeVirtualEarthMercator () {}

           virtual TeCoord2D LL2PC(const TeCoord2D& p);

           virtual TeCoord2D PC2LL(const TeCoord2D& p);
};

bool TL_DLL decodifyDescription(const string& projDescription, TeProjectionParams& pars);

/*
           \note This function works only for sproj descriptionsgenerated by TerraLib
*/
TL_DLL TeProjection* TeGetTeProjectionFromSProj(const string& sproj4desc);

TL_DLL string TeGetSProjFromTeProjection(TeProjection* teproj);

TL_DLL string TeGetWKTFromTeProjection(TeProjection* proj);

/*
           \note This function works only for sproj descriptions generated by TerraLib
*/
TL_DLL TeProjection* TeGetTeProjectionFromWKT(const string& wkt);

#endif