Domain.h

#ifndef _WINC_DOMAIN
#define _WINC_DOMAIN
 
#include <WXP/Const.h>
#include <WXP/DomainVal.h>
#include <WXP/EarthPoint.h>
#include <WXP/EarthPoints.h>
#include <WXP/GridPoint.h>
#include <WXP/GridPoints.h>
#include <WXP/Point.h>
#include <WXP/Points.h>
#include <WXP/Rect.h>
#include <WXP/String.h>
 
namespace WXP {
   /*
      Structure for domain location
   */
   class Domain : private DomainVal {
      Rect limits;
      Rect view;
   
      double sat_rad;
      double sat_rad2;
      double sat_rad4;
      double sat2_earth2;
      double earth_sat_ratio;
      double earth_ratio;
      double earth_ratio2;
      float tlat1;
      float tlat2;
      float cx, cy;
      double xfactor;
      double mult;
      double yfactor;
      double scale;
 
      public:
      static double earth_rad;  
      static double earth_maj;  
      static double earth_min;  
      Domain();
      Domain( const char *str );
      int init();
      int set( DomainVal &val );
      int set( const char *str );
      int set( EarthPoint &ul, EarthPoint &lr, int rnx, int rny );
      int set( int rnx, int rny );
      DomainVal get();
      inline bool isSet(){ return proj != Const::MISS? true: false; };
      int setParam();
      int setLimits();
      int getLimits( Rect &rect );
      Rect getLimits();
      int setView( Rect &rect );
      inline int getProj(){ return proj; };
      inline float getPLat(){ return plat; };
      inline float getPLon(){ return plon; };
      inline float getCLat(){ return clat; };
      inline float getCLon(){ return clon; };
      inline int getNx(){ return nx; };
      inline int getNy(){ return ny; };
      inline float getDx(){ return dx; };
      inline float getDy(){ return dy; };
      inline float getParam( int i ){ return i >= 0 && i < 5 ? param[i]: Const::MISS; };
      int tranCenter( Point &pt );
      float getAspect();
      int tran( EarthPoint &ept, Point &pt );
      int tran( Point &pt, EarthPoint &ept );
      int tran( GridPoint &gpt, Point &pt );
      int tran( Point &pt, GridPoint &gpt );
      int tran( EarthPoint &ept, GridPoint &gpt );
      int tran( GridPoint &gpt, EarthPoint &ept );
      int tran( EarthPoints &epts, Points &pts );
      int tran( EarthPoints &epts, GridPoints &gpts );
 
      enum TranLocate { 
         UL, 
         UR,     
         LL,     
         LR,     
         CENTER  
      };
      int tran( int w, EarthPoint &ept );
      int tran( int w, GridPoint &gpt );
      int tran( int w, Point &pt );
 
      bool within( Point &pt );
      bool within( EarthPoint &ept );
      bool withinExt( Point &pt, int ext );
      bool withinExt( EarthPoint &ept, int ext );
      int where( Point &pt );
      int where( EarthPoint &ept );
      int scaleSize( int width, int height );
      int scaleGrid( float scale );
      int zoom( Point &pt, float zfac );
      int pan( Point &pt );
      int adjust( Point &pt );
      int adjust( Points &pts );
      float adjustDir( float dir, Point &pt );
      float adjustDir( float dir, EarthPoint &ept );
      float unadjustDir( float dir, Point &pt );
      float unadjustDir( float dir, EarthPoint &ept );
      int offset( Point &pt, float dir, float rad, Point &opt );
      float direct( Point &pt1, Point &pt2 );
      float getVert();
      float getMapFactor( EarthPoint &ept );
      int wrapLine( Point &pt1, Point &pt2 );
      int wrapLine( Points &pts );
      int offsetLine( Point &pt1, Point &pt2, int flag );
      int offsetLine( Points &pts, int flag );
      int toString( String &string );
      int print();
      int printLimits();
   
      inline int isProj( int p ){ return p == proj; };
      inline int isMap(){ return isMap( proj ); };
      inline int isTherm(){ return isTherm( proj ); };
      inline int isCoord(){ return isCoord( proj ); };
      inline int isPolar(){ return isPolar( proj ); };
 
      static int getProj( const char *proj );
      static bool compare( Domain &dom1, Domain &dom2 );
      static bool compareProj( Domain &dom1, Domain &dom2 );
      static int translate( Domain &dom1, Domain &dom2, Point &pt1, Point &pt2 );
      static int translate( Domain &dom1, Domain &dom2, GridPoint &gpt1, GridPoint &gpt2 );
      static float calcEarthDist( EarthPoint &ept1, EarthPoint &ept2 );
      static int offsetLatLon( EarthPoint &ept, float dir, float rad, EarthPoint &opt );
 
      static const int PSTEREO = DomainVal::PSTEREO;
      static const int LATLON  = DomainVal::LATLON;
      static const int MERC    = DomainVal::MERC;  
      static const int LAMB    = DomainVal::LAMB;  
      static const int ORTHO   = DomainVal::ORTHO; 
      static const int GNOM    = DomainVal::GNOM;  
      static const int MOLL    = DomainVal::MOLL;  
      static const int LAMBAZ  = DomainVal::LAMBAZ;
      static const int ALBERS  = DomainVal::ALBERS;
      static const int SAT     = DomainVal::SAT;   
      static const int RADIAL  = DomainVal::RADIAL;
      static const int PIXEL  = DomainVal::PIXEL;  
      static const int XY     = DomainVal::XY;     
      static const int XZ     = DomainVal::XZ;     
      static const int XP     = DomainVal::XP;     
      static const int XLOGP  = DomainVal::XLOGP;  
      static const int POLAR  = DomainVal::POLAR;  
      static const int CAT    = DomainVal::CAT;    
      static const int SKEWT  = DomainVal::SKEWT;  
      static const int STUVE  = DomainVal::STUVE;  
      static const int EMA    = DomainVal::EMA;    
      static const int TEPH   = DomainVal::TEPH;   
      static const int RTEPH  = DomainVal::RTEPH;  
      static const int ZOOM   = DomainVal::ZOOM;   
      static const int SIZE   = DomainVal::SIZE;   
      static inline bool isMap( int a ){ return (a >= PSTEREO && a <= SAT);}
      static inline bool isTherm( int a ){ return (a >= SKEWT && a <= RTEPH);}
      static inline bool isCoord( int a ){ return (a >= PIXEL && a <= CAT);}
      static inline bool isPolar( int a ){ return (a == POLAR);}
 
      static float OFFSET_LL;   
      static float OFFSET_MERC; 
   };
}
#endif