coordinates-definitions.h

Go to the documentation of this file.

/* WOSS - World Ocean Simulation System -
 * 
 * Copyright (C) 2009 Federico Guerra
 * and regents of the SIGNET lab, University of Padova
 *
 * Author: Federico Guerra - federico@guerra-tlc.com
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */ 
 
/*
 * This software has been developed by Federico Guerra and SIGNET lab,
 * University of Padova, in collaboration with the NATO Centre for 
 * Maritime Research and Experimentation (http://www.cmre.nato.int ; 
 * E-mail: pao@cmre.nato.int), whose support is gratefully acknowledged.
 */
 
 
#ifndef WOSS_COORDINATES_DEFINITIONS_H
#define WOSS_COORDINATES_DEFINITIONS_H
 
 
#include <vector>
#include <utility>
#include <iostream>
 
 
namespace woss {
    
    
  class Coord;
  class CoordZ;
  
  typedef char UtmZoneChar;
 
  typedef ::std::vector< CoordZ > CoordZVector;
 
  typedef int Marsden;
 
  typedef ::std::pair< int, int > MarsdenCoord; 
  
  typedef ::std::vector< Coord > CoordVector;
 
  typedef ::std::vector< Marsden > MarsdenVector;
 
  typedef ::std::vector< MarsdenCoord > MarsdenCoordVector;
 
 
  #define COORD_NOT_SET_VALUE (-2000)
 
 
  class Coord {
 
    public:
 
    static const double COORD_MIN_LATITUDE; 
 
    static const double COORD_MAX_LATITUDE; 
 
    static const double COORD_MIN_LONGITUDE; 
 
    static const double COORD_MAX_LONGITUDE; 
 
    static const double EARTH_RADIUS; 
 
    static const double EARTH_SEMIMAJOR_AXIS;
 
    static const double EARTH_GRS80_POLAR_RADIUS;
 
    static const double EARTH_WGS84_POLAR_RADIUS; 
 
    static const double EARTH_GRS80_ECCENTRICITY;
 
    static const double EARTH_WGS84_ECCENTRICITY;
 
    Coord( double lat = COORD_NOT_SET_VALUE, double lon = COORD_NOT_SET_VALUE );
 
    Coord( const Coord& copy );
 
    virtual ~Coord() { }
 
    void setLatitude( double lat ) { latitude = lat; updateMarsdenCoord(); }
 
    void setLongitude( double lon ) { longitude = lon; updateMarsdenCoord(); }
 
 
    virtual bool isValid() const { return( latitude >= COORD_MIN_LATITUDE && latitude <= COORD_MAX_LATITUDE
                                        && longitude >= COORD_MIN_LONGITUDE && longitude <= COORD_MAX_LONGITUDE ); }
 
    double getLatitude() const { return latitude; }
 
    double getLongitude() const { return longitude; } 
  
    int getMarsdenSquare() const { return marsden_square; }
 
    int getMarsdenOneDegreeSquare() const { return marsden_one_degree; }
 
    MarsdenCoord getMarsdenCoord() const { return( ::std::make_pair( marsden_square, marsden_one_degree) ); }
 
 
    double getInitialBearing( const Coord& destination ) const ;
 
    double getFinalBearing( const Coord& destination ) const ;
 
    double getGreatCircleDistance( const Coord& destination, double depth = 0 ) const ;
 
    
    static const Coord getCoordFromBearing( const Coord& start_coord, double bearing, double distance, double depth = 0.0 ); 
    
    static const Coord getCoordAlongGreatCircle( const Coord& start_coord, const Coord& end_coord, double distance, double depth = 0.0 ); 
    
    static const Coord getCoordFromUtmWgs84( double easting, double northing, double utm_zone_number, UtmZoneChar utm_zone_char );
    
    
    Coord& operator=( const Coord& copy );
 
 
    friend const Coord operator+( const Coord& left , const Coord& right ) ;
 
    friend const Coord operator-( const Coord& left , const Coord& right ) ;
 
 
    friend Coord& operator+=( Coord& left, const Coord& right );
    
    friend Coord& operator-=( Coord& left, const Coord& right );
    
 
    friend bool operator==( const Coord& left , const Coord& right ) ;
    
    friend bool operator!=( const Coord& left , const Coord& right ) ;
    
    
    friend bool operator>( const Coord& left , const Coord& right ) ;
 
    friend bool operator<( const Coord& left , const Coord& right ) ;
 
    friend bool operator>=( const Coord& left , const Coord& right ) ;
 
    friend bool operator<=( const Coord& left , const Coord& right ) ;
 
    
    friend ::std::ostream& operator<<( ::std::ostream& os, const Coord& instance );
    
 
    protected:
 
    double latitude;
 
    double longitude;
 
    
    int marsden_square;
 
    int marsden_one_degree;
 
 
    void updateMarsdenCoord();
 
    static bool isValidUtmZoneChar( UtmZoneChar utm_zone_char );
 
  };
 
 
  class CoordZ : public Coord {
 
    
    public:
 
    static const double COORDZ_MIN_DEPTH; 
 
    enum CoordZSpheroidType
    {
      COORDZ_SPHERE = 0,
      COORDZ_GRS80,
      COORDZ_WGS84
    };
 
    class CartCoords {
      public:
 
      CartCoords();
 
      CartCoords(double in_x, double in_y, double in_z, CoordZSpheroidType in_type);
 
      double getX() const { return x; }
 
      double getY() const { return y; }
 
      double getZ() const { return z; }
 
      CoordZSpheroidType getType() const { return type; }
 
      friend ::std::ostream& operator<<( ::std::ostream& os, const CartCoords& instance );
 
      protected:
 
      double x; 
      
      double y; 
      
      double z; 
      
      CoordZSpheroidType type; 
      
    };
 
    CoordZ( double lat = COORD_NOT_SET_VALUE, double lon = COORD_NOT_SET_VALUE, double z = COORD_NOT_SET_VALUE );
 
    explicit CoordZ( const Coord& coords, double depth = COORD_NOT_SET_VALUE );
    
    CoordZ( const CoordZ& copy );
 
    virtual ~CoordZ() { }
 
 
    void setDepth( double d ) { depth = d; }
 
 
    double getDepth() const { return depth; }
 
    CartCoords getCartCoords(CoordZSpheroidType type = COORDZ_SPHERE) const;
 
    double getCartX(CoordZSpheroidType type = COORDZ_SPHERE) const;
    
    double getCartY(CoordZSpheroidType type = COORDZ_SPHERE) const;
    
    double getCartZ(CoordZSpheroidType type = COORDZ_SPHERE) const;
    
    double getSphericalRho() const;
    
    double getSphericalTheta() const;
    
    double getSphericalPhi() const;
    
    
    double getCartDistance( const CoordZ& coords, CoordZSpheroidType type = COORDZ_SPHERE ) const;
    
    double getCartRelZenith( const CoordZ& coords ) const;
    
    double getCartRelAzimuth( const CoordZ& coords ) const;
   
   
    static const CoordZ getCoordZAlongCartLine( const CoordZ& start, const CoordZ& end, double distance );
 
    static const CoordZ getCoordZAlongGreatCircle( const CoordZ& start, const CoordZ& end, double distance );
    
    static const CoordZ getCoordZFromCartesianCoords( double x, double y, double z, CoordZSpheroidType type = COORDZ_SPHERE);
 
    static const CoordZ getCoordZFromCartesianCoords( const CartCoords& cart_coords );
                
    static const CoordZ getCoordZFromSphericalCoords( double rho, double theta, double phi);
    
    virtual bool isValid() const { return( Coord::isValid() && depth >= COORDZ_MIN_DEPTH ); }
 
 
    CoordZ& operator=( const CoordZ& coordz );
 
    
    friend const CoordZ operator+( const CoordZ& left , const CoordZ& right );
 
    friend const CoordZ operator-( const CoordZ& left , const CoordZ& right );
 
 
    friend CoordZ& operator+=( CoordZ& left, const CoordZ& right );
    
    friend CoordZ& operator-=( CoordZ& left, const CoordZ& right );
    
 
    friend bool operator==( const CoordZ& left , const CoordZ& right ) ;
    
    friend bool operator!=( const CoordZ& left , const CoordZ& right ) ;
    
    
    friend bool operator>( const CoordZ& left , const CoordZ& right ) ;
 
    friend bool operator<( const CoordZ& left , const CoordZ& right ) ;
 
    friend bool operator>=( const CoordZ& left , const CoordZ& right ) ;
 
    friend bool operator<=( const CoordZ& left , const CoordZ& right ) ;
 
    
    friend ::std::ostream& operator<<( ::std::ostream& os, const CoordZ& instance );
    
 
    protected:
 
      
    double depth;
  };
 
   class UtmWgs84 {
    
    public:
      
    UtmWgs84(int utmZone = COORD_NOT_SET_VALUE, double east = COORD_NOT_SET_VALUE, double north = COORD_NOT_SET_VALUE);
 
    ~UtmWgs84() { }
 
 
    int getZone() const;
 
    double getEasting() const;
 
    double getNorthing() const;
 
    bool isValid() const;
 
    static const UtmWgs84 getUtmWgs84FromCoord(const Coord& coords);
 
    friend ::std::ostream& operator<<( ::std::ostream& os, const UtmWgs84& instance );
 
    protected:
 
    int zone; 
    double easting; 
    double northing; 
  };
 
  
  
  template < class CompUser, class T = Coord >
  class CoordComparator {
  
    
    public:
        
    
    bool operator()( const T& x, const T& y ) const {    
//       ::std::cout << "CoordComparator::operator() x " <<  x << "; y " << y << "; dist " << x.getCartDistance(y)
//                   << "; space samp " << CompUser::getSpaceSampling() << ::std::endl;     
                  
      if ( CompUser::getSpaceSampling() <= 0.0 ) return operator<(x,y);
      if ( x.getGreatCircleDistance(y) <= CompUser::getSpaceSampling() ) return false;
      return operator<(x,y);
    }
 
  };
  
  
  template < class CompUser >
  class CoordComparator< CompUser, CoordZ > {
 
    public:
        
    
    bool operator()( const CoordZ& x, const CoordZ& y ) const {    
//       ::std::cout << "CoordComparator::operator() x " <<  x << "; y " << y << "; dist " << x.getCartDistance(y)
//                   << "; space samp " << CompUser::getSpaceSampling() << ::std::endl;     
                  
      if ( CompUser::getSpaceSampling() <= 0.0 ) return operator<(x,y);
      if ( x.getCartDistance(y) <= CompUser::getSpaceSampling() ) return false;
      return operator<(x,y);
    }
 
  };
  
  //non-inline operator declarations
  Coord& operator+=( Coord& left, const Coord& right );
 
  Coord& operator-=( Coord& left, const Coord& right );
 
  CoordZ& operator+=( CoordZ& left, const CoordZ& right );
 
  CoordZ& operator-=( CoordZ& left, const CoordZ& right );
 
    
  // inline functions
  inline const Coord operator+( const Coord& left , const Coord& right )  {
    if( !( left.isValid() && right.isValid() ) ) return Coord();
    return( Coord( (left.latitude + right.latitude), (left.longitude + right.longitude) ) );
  }
 
 
  inline const Coord operator-( const Coord& left , const Coord& right )  {
    if( !( left.isValid() && right.isValid() ) ) return Coord();
    return( Coord( (left.latitude - right.latitude), (left.longitude - right.longitude) ) );
  }
 
 
  inline bool operator==( const Coord& left , const Coord& right )  { 
    if ( &left == &right ) return true; 
    return( left.latitude == right.latitude && left.longitude == right.longitude );
  }
 
 
  inline bool operator!=( const Coord& left , const Coord& right )  { 
    if ( &left == &right ) return false; 
    return( left.latitude != right.latitude || left.longitude != right.longitude );
  }
 
 
  inline bool operator>( const Coord& left , const Coord& right )  { 
    if ( &left == &right ) return false; 
    return( ( left.latitude > right.latitude ) || ( ( left.latitude == right.latitude ) && ( left.longitude > right.longitude ) ) );
  }
 
 
  inline bool operator<( const Coord& left , const Coord& right )  { 
    if ( &left == &right ) return false; 
    return( ( left.latitude < right.latitude ) || ( ( left.latitude == right.latitude ) && ( left.longitude < right.longitude ) ) );
  }
 
 
  inline bool operator>=( const Coord& left , const Coord& right )  { 
    if ( left == right ) return true;
    return( left > right );
  }
 
 
  inline bool operator<=( const Coord& left , const Coord& right )  { 
    if ( left == right ) return true;
    return( left < right );
  }
 
 
  inline ::std::ostream& operator<<(::std::ostream& os, const Coord& x) {
    os << "Latitude = " << x.latitude << "; Longitude = " << x.longitude
       << "; Marsden square = " << x.marsden_square
       << "; Marsden One Degree square = " << x.marsden_one_degree;
    return os;
  }
 
 
  inline ::std::ostream& operator<<( ::std::ostream& os, const CoordZ::CartCoords& instance ) {
    os << "X = " << instance.x << "; Y = " << instance.y << "; Z = " << instance.z << "; type = " << instance.type;
    return os;
  }
 
  
  inline bool operator==( const CoordZ& left, const CoordZ& right ) { 
    if ( &left == &right ) return true; 
    return( left.latitude == right.latitude && left.longitude == right.longitude && left.depth == right.depth );
  }
 
 
  inline bool operator!=( const CoordZ& left, const CoordZ& right ) { 
    if ( &left == &right ) return false; 
    return( left.latitude != right.latitude || left.longitude != right.longitude || left.depth != right.depth );
  }
 
 
  inline bool operator>( const CoordZ& left, const CoordZ& right ) { 
    if ( &left == &right ) return false; 
 
    return( ( left.latitude > right.latitude ) || ( ( left.latitude == right.latitude ) && ( left.longitude > right.longitude ) ) 
      || ( ( left.latitude == right.latitude ) && ( left.longitude == right.longitude ) && ( left.depth > right.depth ) ) );
  }
 
 
  inline bool operator<( const CoordZ& left, const CoordZ& right ) { 
    if ( &left == &right ) return false; 
    return ( ( left.latitude < right.latitude ) || ( ( left.latitude == right.latitude ) && ( left.longitude < right.longitude ) ) 
      || ( ( left.latitude == right.latitude ) && ( left.longitude == right.longitude ) && ( left.depth < right.depth ) ) );
  }
 
 
  inline bool operator>=( const CoordZ& left, const CoordZ& right ) { 
    if ( left == right ) return true;
    return( left > right );
  }
 
 
  inline bool operator<=( const CoordZ& left, const CoordZ& right ) { 
    if ( left == right ) return true;
    return( left < right );
  }
 
  
  inline ::std::ostream& operator<<( ::std::ostream& os, const CoordZ& instance ) {
    os << "Latitude = " << instance.latitude << "; Longitude = " << instance.longitude << "; Depth = " << instance.depth
       << "; Marsden square = " << instance.marsden_square
       << "; Marsden One Degree square = " << instance.marsden_one_degree;
    return os;
  }
 
 
  inline const CoordZ operator+( const CoordZ& left , const CoordZ& right ) {
    if( !( left.isValid() && right.isValid() ) ) return CoordZ();
    return( CoordZ( left.latitude + right.latitude, left.longitude + right.longitude, left.depth + right.depth ) );
  }
 
 
  inline const CoordZ operator-( const CoordZ& left , const CoordZ& right ) {
    if( !( left.isValid() && right.isValid() ) ) return CoordZ();
    return( CoordZ( left.latitude - right.latitude, left.longitude - right.longitude, left.depth - right.depth ) );
  }
 
  inline int UtmWgs84::getZone() const {
    return zone;
  }
 
  inline double UtmWgs84::getEasting() const { 
    return easting;
  }
 
  inline double UtmWgs84::getNorthing() const { 
    return northing;
  }
  
  inline bool UtmWgs84::isValid() const { 
    return ((zone != COORD_NOT_SET_VALUE) && (easting != COORD_NOT_SET_VALUE) && (northing != COORD_NOT_SET_VALUE)); 
  }
  
  inline ::std::ostream& operator<<( ::std::ostream& os, const UtmWgs84& instance ) {
    os << "Zone = " << instance.zone << "; Easting = " << instance.easting << "; Northing = " << instance.northing;
    return os;
  }
}
 
#endif /* WOSS_COORDINATES_DEFINITIONS_H */