gls_map_util.h

Go to the documentation of this file.

/*! \file
  \brief  Utility classes for GL Studio Map toolkit.

  \par Copyright Information

  Copyright (c) 2016 The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.

*/
#ifndef INCLUDED_GLS_MAP_UTIL_H
#define INCLUDED_GLS_MAP_UTIL_H

#include "vertex.h"

#include <cfloat>
#include <iostream>

//////////////////// Provides support for creating DLLs ////////////////////////
#if( defined( GLSGEN_EXPORT_GLSMAPUTIL ) || defined( GLSGEN_IMPORT_GLSMAPUTIL ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSMAPUTIL ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GLSMAPUTIL_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GLSMAPUTIL_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GLSMAPUTIL_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////

namespace disti
{
/** The GeoCoord class encapsulates a location relative to the earth.
  * It is possible to get and set the value in a number of different
  * coordinate systems.
  */
class GeoCoord
{
public:
    /** The EllipsoidParams class is used to store data about
      * the reference ellipsoid used for geodetic coordinate conversions.
      * The GeoCoord methods use the WGS84 reference ellipsoid by default.
      */
    class EllipsoidParams
    {
    public:
        EllipsoidParams( double radius, double flattening );
        void SetEllipsoid( double radius, double flattening );

        double Radius() const { return _a; }
        double Flattening() const { return _f; }

        // The derived parameters are calculated in advance
        // to speedup conversions.
        double a() const { return _a; }
        double f() const { return _f; }
        double a_sq() const { return _a_sq; }
        double b() const { return _b; }
        double b_sq() const { return _b_sq; }
        double a_sq_over_b() const { return _a_sq_over_b; }
        double e() const { return _e; }
        double c1() const { return _c1; }
        double a_b() const { return _a_b; }
        double a_sq_sq() const { return _a_sq_sq; }
        double b_sq_sq() const { return _b_sq_sq; }
        double two_over_a() const { return _two_over_a; }
        double two_over_b() const { return _two_over_b; }
        double two_over_a_sq() const { return _two_over_a_sq; }
        double two_over_b_sq() const { return _two_over_b_sq; }

        double e_sq() const { return _e_sq; }
        double ep_sq() const { return _ep_sq; }
        double ef() const { return _ef; }
        double e_sq_to_3() const { return _e_sq_to_3; }
        double ef_to_3() const { return _ef_to_3; }
        double ef_to4() const { return _ef_to_4; }

        double poly1_a() const { return _poly1_a; }
        double poly2_a() const { return _poly2_a; }
        double poly3_a() const { return _poly3_a; }
        double poly4_a() const { return _poly4_a; }
        double poly5_a() const { return _poly5_a; }
        double poly1_b() const { return _poly1_b; }
        double poly2_b() const { return _poly2_b; }
        double poly3_b() const { return _poly3_b; }
        double poly4_b() const { return _poly4_b; }

    protected:
        // Primary parameters
        double _a; ///< equatorial radius
        double _f; ///< flattening (a-b)/a

        // Derived parameters
        double _a_sq;          ///< radius squared
        double _b;             ///< polar semi-diameter
        double _b_sq;          ///< polar semi-diameter squared
        double _a_sq_over_b;   ///< a*a/b
        double _e;             ///< ellipticity 2f-f*f
        double _c1;            ///< (1-f)*(1-f)
        double _a_b;           ///< (a * b)
        double _a_sq_sq;       ///< (a * a * a * a)
        double _b_sq_sq;       ///< (b * b * b * b)
        double _two_over_a;    ///< (2/a)
        double _two_over_b;    ///< (2/b)
        double _two_over_a_sq; ///< 2/(a * a)
        double _two_over_b_sq; ///< 2/(b * b)

        double _e_sq;      ///< eccentricity squared
        double _ep_sq;     ///< e-prime squared
        double _ef;        ///< e-factor
        double _e_sq_to_3; ///< pow(e_sq,3.0)
        double _ef_to_3;   ///< pow(ef,3.0)
        double _ef_to_4;   ///< pow(ef,4.0)

        double _poly1_a; ///< 1.0 - _e_sq / 4.0 - 3.0 * _e_sq * _e_sq / 64.0 - 5.0 * _e_sq_to_3 / 256.0
        double _poly2_a; ///< 3.0 * _ef / 2.0 - 27.0 * _ef_to_3 / 32.0
        double _poly3_a; ///< 21.0 * _ef * _ef / 16.0 - 55.0 * _ef_to_4 / 32.0
        double _poly4_a; ///< 151.0 * _ef_to_3 / 96.0
        double _poly5_a; ///< 1097.0 * _ef_to_4 / 512.0
        double _poly1_b; ///< 1.0 - (_e_sq / 4.0) - (3.0 * _e_sq * _e_sq) / 64.0 - 5.0 * _e_sq_to_3 / 256.0
        double _poly2_b; ///< 3.0 * _e_sq / 8.0 + (3.0 * _e_sq * _e_sq) / 32.0 + 45.0 * _e_sq_to_3 / 1024.0
        double _poly3_b; ///< 15.0 * _e_sq * _e_sq / 256.0 + 45.0 * _e_sq_to_3 / 1024.0
        double _poly4_b; ///< 35.0 * _e_sq_to_3 / 3072.0
    };

    /** Set GeoCoord value in geodetic coordinates
      * \param lonLatAlt Vector where x = longitude, y = latitude, z = altitude
      * \param ellipsoid Ellipsoid type
      */
    void SetGeodetic( const Vector& lonLatAlt, const EllipsoidParams& ellipsoid = GeoCoord::WGS84 )
    {
        SetGeodetic( lonLatAlt.x, lonLatAlt.y, lonLatAlt.z, ellipsoid );
    }

    /** Set GeoCoord value in geodetic coordinates
      * \param longitude Longitude in degrees
      * \param latitude Latitude in degrees
      * \param altitude Altitude in meters 
      * \param ellipsoid Ellipsoid type
      */
    void SetGeodetic( double longitude, double latitude, double altitude, const EllipsoidParams& ellipsoid = GeoCoord::WGS84 )
    {
        if( &ellipsoid == &WGS84 )
        {
            _lon         = longitude;
            _lat         = latitude;
            _alt         = altitude;
            _validValues = VAL_GEODETIC_WGS84;
        }
        else
        {
            SetGeodeticNonWGS84( longitude, latitude, altitude, ellipsoid );
        }
    }

    /** Get GeoCoord value in geodetic coordinates
      * \param lonLatAlt pointer to a vector to receive the value ( x = longitude, y = latitude, z = altitude ) 
      * \param ellipsoid Ellipsoid type
      */
    void GetGeodetic( Vector* lonLatAlt, const EllipsoidParams& ellipsoid = GeoCoord::WGS84 ) const
    {
        double lon, lat, alt;
        GetGeodetic( &lon, &lat, &alt, ellipsoid );
        lonLatAlt->x = float( lon );
        lonLatAlt->y = float( lat );
        lonLatAlt->z = float( alt );
    }

    /** Get GeoCoord value in geodetic coordinates
      * \param longitude pointer to a double to receive the longitude in degrees
      * \param latitude pointer to a double to receive the latitude in degrees
      * \param altitude pointer to a double to receive the altitude in meters
      * \param ellipsoid Ellipsoid type
      */
    void GetGeodetic( double* longitude, double* latitude, double* altitude, const EllipsoidParams& ellipsoid = GeoCoord::WGS84 ) const
    {
        if( &ellipsoid == &WGS84 )
        {
            if( !( _validValues & VAL_GEODETIC_WGS84 ) )
            {
                UpdateGeodeticWGS84Value();
            }

            *longitude = _lon;
            *latitude  = _lat;
            *altitude  = _alt;
        }
        else
        {
            GetGeodeticNonWGS84( longitude, latitude, altitude, ellipsoid );
        }
    }

    /** Set GeoCoord value in geocentric coordinates
      * \param value Vector containing new geocentric coordinate in meters */
    void SetGeocentric( const Vector& value )
    {
        SetGeocentric( value.x, value.y, value.z );
    }

    /** Set GeoCoord value in geocentric coordinates
      * \param x New x coordinate value in meters
      * \param y New y coordinate value in meters
      * \param z New z coordinate value in meters */
    void SetGeocentric( double x, double y, double z )
    {
        _x           = x;
        _y           = y;
        _z           = z;
        _validValues = VAL_GEOCENTRIC;
    }

    /** Get GeoCoord value in geocentric coordinates
      * \param value pointer to a vector to receive the value */
    void GetGeocentric( Vector* value ) const
    {
        double x, y, z;
        GetGeocentric( &x, &y, &z );
        value->x = float( x );
        value->y = float( y );
        value->z = float( z );
    }

    /** Get GeoCoord value in geocentric coordinates
      * \param x pointer to a double to receive the x coordinate value
      * \param y pointer to a double to receive the y coordinate value
      * \param z pointer to a double to receive the z coordinate value */
    void GetGeocentric( double* x, double* y, double* z ) const
    {
        if( !( _validValues & VAL_GEOCENTRIC ) )
        {
            UpdateGeocentricValue();
        }

        *x = _x;
        *y = _y;
        *z = _z;
    }

    /** Determine if two GeoCoords have equivalent values
      * \param other The GeoCoord to compare to */
    bool operator==( const GeoCoord& other ) const
    {
        if( this->_validValues & VAL_GEODETIC_WGS84 && other._validValues & VAL_GEODETIC_WGS84 )
        {
            // Compare Geodetic coords
            return closeValues( this->_lon, other._lon ) && closeValues( this->_lat, other._lat ) && closeValues( this->_alt, other._alt );
        }
        else
        {
            // Compare geocentric coords

            if( !( _validValues & VAL_GEOCENTRIC ) )
            {
                UpdateGeocentricValue();
            }

            if( !( other._validValues & VAL_GEOCENTRIC ) )
            {
                other.UpdateGeocentricValue();
            }

            return closeValues( this->_x, other._x ) && closeValues( this->_y, other._y ) && closeValues( this->_z, other._z );
        }
    }

    /** Determine if two GeoCoords do not have equivalent values
      * \param other The GeoCoord to compare to */
    bool operator!=( const GeoCoord& other ) const
    {
        return !( *this == other );
    }

    /** Utility method to convert from geocentric to geodetic coordinates */
    static void GeocentricToGeodetic( double xp, double yp, double zp,
        double* lon, double* lat, double* alt,
        const EllipsoidParams& ellipsoid = GeoCoord::WGS84 );

    /** Utility method to convert from geodetic to geocentric coordinates */
    static void GeodeticToGeocentric( double lon, double lat, double alt,
        double* xp, double* yp, double* zp,
        const EllipsoidParams& ellipsoid = GeoCoord::WGS84 );

    static void UTMToGeodetic( const double northing, const double easting,
        double& lat_degrees, double& lon_degrees );

    static void UTMToGeodetic( const double northing, const double easting, const int zone, const int latZoneIndex,
        double& lat_degrees, double& lon_degrees );

    static void GeodeticToUTM( const double lat_degrees, const double lon_degrees,
        double& northing, double& easting );

    static int CalcZone( double lon_radians );
    static int CalcZoneDeg( double longitude_degrees );

    static char CalcLatZoneDeg( double lat_degrees );
    static int  CalcLatZoneDegIndex( double lat_degrees );

    /** Calculate the 'great circle' distance and initial bearing between two points
      * along the surface of a sphere using the Haversine formula.
      *
      * \param coord1 First point
      * \param coord2 Second point
      * \param distance Pointer to a double to receive the distance in meters
      * \param bearing Pointer to a double to receive the initial bearing from coord1 to coord2 in degrees from true north
      * \param radius (optional) Radius of the sphere.  Default value is the average radius of the earth (6372795.477598 meters)
      */
    static void GetSphericalDistanceAndBearing( const GeoCoord& coord1, const GeoCoord& coord2,
        double* distance, double* bearing,
        const double radius = 6372795.477598 );

    /** Calculate a new point given the distance and initial bearing from a known origin.
      * The new point is located on the 'great circle' arc defined by the parameters.
      *
      * \param origin The starting point
      * \param distance Distance to the destination in meters
      * \param bearing Initial bearing from the origin in degrees from true north
      * \param destination Pointer to a GeoCoord to receive the destination point
      * \param radius (optional) Radius of the sphere.  Default value is the average radius of the earth (6372795.477598 meters)
      */
    static void GetPointAtDistanceAndBearingSpherical( const GeoCoord& origin, double distance,
        double bearing, GeoCoord* destination,
        const double radius = 6372795.477598 );

protected:
    static bool closeValues( double lv, double rv )
    {
        const double PRECISION( 1e-7 );
        return ( lv - PRECISION ) <= rv && rv <= ( lv + PRECISION );
    }

    void GetGeodeticNonWGS84( double* longitude, double* latitude, double* altitude, const EllipsoidParams& ellipsoid = GeoCoord::WGS84 ) const;
    void SetGeodeticNonWGS84( double longitude, double latitude, double altitude, const EllipsoidParams& ellipsoid = GeoCoord::WGS84 );
    void UpdateGeodeticWGS84Value() const;
    void UpdateGeocentricValue() const;

    static void CalcFalseNorthEast( double lat_radians );
    static void CalcLambda0();

    enum ValueFlags
    {
        VAL_GEODETIC_WGS84 = 1,
        VAL_GEOCENTRIC     = 2
    };

    mutable unsigned char _validValues;

    // Geodetic WGS84
    mutable double _lon;
    mutable double _lat;
    mutable double _alt;

    // Geocentric
    mutable double _x;
    mutable double _y;
    mutable double _z;

    static double     _False_Northing;
    static double     _False_Easting;
    static double     _Zone;
    static double     _Lambda0;
    static const char _LatZone[ 20 ];

public:
    // Standard ellipsoid parameters
    static const EllipsoidParams WGS84;
};

/** GeoCoord stream operator
  * Accepts the following types of input:
  * - `<longitude_degrees> <latitude_degrees> <altitude_meters>` (e.g. "-75.0 35.0 1000.0")
  * - `WGS84 <longitude_degrees> <latitude_degrees> <altitude_meters>` (e.g. "WGS84 -75.0 35.0 1000.0")
  * - `ECEF <x> <y> <z>` (e.g. "ECEF -5316120.34302 -2236496.88192 -2714391.58968")
  */
GLSGEN_GLSMAPUTIL_EXPORT std::istream& operator>>( std::istream& instr, GeoCoord& coord );

/** GeoCoord stream operator 
  * Outputs WGS84 geodetic coordinates:
  * `<longitude_degrees> <latitude_degrees> <altitude_meters>` (e.g. -75 35 1000)
  */
GLSGEN_GLSMAPUTIL_EXPORT std::ostream& operator<<( std::ostream& outstr, const GeoCoord& coord );

/** The GeoRect class represents a lon/lat aligned region on the surface of the earth. */
class GeoRect
{
public:
    /** ctor - sets the GeoRect to contain nothing */
    GeoRect()
    {
        SetToNull();
    }

    GeoRect( double minLongitude, double minLatitude, double maxLongitude, double maxLatitude )
    {
        SetRect( minLongitude, minLatitude, maxLongitude, maxLatitude );
    }

    /** Set the GeoRect value */
    void SetRect( double minLongitude, double minLatitude, double maxLongitude, double maxLatitude )
    {
        _minLon = minLongitude;
        _minLat = minLatitude;
        _maxLon = maxLongitude;
        _maxLat = maxLatitude;
    }

    void MinLongitude( double value ) { _minLon = value; }
    void MinLatitude( double value ) { _minLat = value; }
    void MaxLongitude( double value ) { _maxLon = value; }
    void MaxLatitude( double value ) { _maxLat = value; }

    double MinLongitude() const { return _minLon; }
    double MinLatitude() const { return _minLat; }
    double MaxLongitude() const { return _maxLon; }
    double MaxLatitude() const { return _maxLat; }

    /** Determine if a point is in the GeoRect */
    bool ContainsPoint( const GeoCoord& point ) const
    {
        double lon, lat, alt;
        point.GetGeodetic( &lon, &lat, &alt );
        return ContainsPoint( lon, lat );
    }

    /** Determine if a point is in the GeoRect */
    bool ContainsPoint( double lon, double lat ) const
    {
        return ( lon <= _maxLon && lon >= _minLon && lat <= _maxLat && lat >= _minLat );
    }

    /** Set the GeoRect to contain nothing. */
    void SetToNull()
    {
        _minLat = _minLon = DBL_MAX;
        _maxLat = _maxLon = -DBL_MAX;
    }

    /** determine if the GeoRect to contains nothing
      * \return true if contains nothing else false
      */
    bool IsNull() const
    {
        return ( ( ( DBL_MAX == _minLat ) && ( DBL_MAX == _minLon ) && ( -DBL_MAX == _maxLat ) && ( -DBL_MAX == _maxLon ) ) || ( ( _minLat > _maxLat ) || ( _minLon > _maxLon ) ) );
    }

    /** Set the GeoRect to contain a single point */
    void SetToPoint( const GeoCoord& point )
    {
        double alt;
        point.GetGeodetic( &_maxLon, &_maxLat, &alt );
        _minLon = _maxLon;
        _minLat = _maxLat;
    }

    /** Set the GeoRect to contain a single point */
    void SetToPoint( double lon, double lat )
    {
        _minLon = _maxLon = lon;
        _minLat = _maxLat = lat;
    }

    /**  Increase the area of the GeoRect as needed to include the given point */
    void GrowToContainPoint( const GeoCoord& point )
    {
        double lon, lat, alt;
        point.GetGeodetic( &lon, &lat, &alt );
        GrowToContainPoint( lon, lat );
    }

    /**  Increase the area of the GeoRect as needed to include the given point */
    void GrowToContainPoint( double lon, double lat )
    {
        if( lon < _minLon )
        {
            _minLon = lon;
        }
        if( lon > _maxLon )
        {
            _maxLon = lon;
        }
        if( lat < _minLat )
        {
            _minLat = lat;
        }
        if( lat > _maxLat )
        {
            _maxLat = lat;
        }
    }

    /** Determine if this GeoRect intersects with another GeoRect */
    bool Intersects( const GeoRect& other ) const
    {
        if( ( _minLat > other._maxLat ) || ( _maxLat < other._minLat ) || ( _minLon > other._maxLon ) || ( _maxLon < other._minLon ) )
        {
            return false;
        }
        else
        {
            // Make sure neither rect is null
            if( _maxLat < _minLat || _maxLon < _minLon || other._maxLat < other._minLat || other._maxLon < other._minLon )
            {
                return false;
            }
            else
            {
                return true;
            }
        }
    }

    /** Set this GeoRect to the intersection of the two given GeoRect */
    void SetToIntersection( const GeoRect& rect1, const GeoRect& rect2 )
    {
        _minLon = ( rect1._minLon > rect2._minLon ) ? rect1._minLon : rect2._minLon;
        _minLat = ( rect1._minLat > rect2._minLat ) ? rect1._minLat : rect2._minLat;
        _maxLon = ( rect1._maxLon < rect2._maxLon ) ? rect1._maxLon : rect2._maxLon;
        _maxLat = ( rect1._maxLat < rect2._maxLat ) ? rect1._maxLat : rect2._maxLat;
    }

    /** Scale the region by moving the edges
      * inward or outward from the center. */
    void Scale( const double scaleFactor )
    {
        double centerLon = ( _minLon + _maxLon ) / 2.0;
        double centerLat = ( _minLat + _maxLat ) / 2.0;

        _minLon = ( _minLon - centerLon ) * scaleFactor + centerLon;
        _maxLon = ( _maxLon - centerLon ) * scaleFactor + centerLon;
        _minLat = ( _minLat - centerLat ) * scaleFactor + centerLat;
        _maxLat = ( _maxLat - centerLat ) * scaleFactor + centerLat;
    }

    /** Printer */
    friend std::ostream& operator<<( std::ostream& os, const GeoRect& r )
    {
        return os << "{ { " << r._minLat << ", " << r._minLon << " }, { " << r._maxLat << ", " << r._maxLon << "} }";
    }

protected:
    double _minLon;
    double _minLat;
    double _maxLon;
    double _maxLat;
};

/** Fuzzy float equality.
  * \tparam X A floating-point type
  * \tparam Y A floating-point type
  * \tparam Z A floating-point type
  * \param x A floating-point value
  * \param y A floating-point value
  * \param tolerance A floating-point value used to determine how fuzzy equality is.
  * \note Overloads disti::Equal() from the GLS runtime.
  */
template<class X, class Y, class Z>
bool Equal( const X x, const Y y, Z tolerance = Z( 0.001 ) )
{
    return ( ( x - tolerance ) <= y )
           && ( ( x + tolerance ) >= y );
}

/** A fuzzy floating-point comparison for GeoRects
  * \param lhs The left-hand side of the equality comparison
  * \param rhs The right-hand side of the equality comparison
  * \param tolerance The tolerance to use for fuzzy equality. Defaults to 1e-8.
  * \note Overloads disti::Equal() from the GLS runtime.
  */
inline bool Equal( const GeoRect& lhs, const GeoRect& rhs, const double tolerance = 1e-8 )
{
    return Equal( lhs.MinLatitude(), rhs.MinLatitude(), tolerance )
           && Equal( lhs.MaxLatitude(), rhs.MaxLatitude(), tolerance )
           && Equal( lhs.MinLongitude(), rhs.MinLongitude(), tolerance )
           && Equal( lhs.MaxLongitude(), rhs.MaxLongitude(), tolerance );
}

/** Wrap a lon, lat coordinate to be valid.
  * \param lon The longitude value to be wrapped
  * \param lat The latitiude value to be wrapped */
inline void WrapCoords( double& lon, double& lat )
{
    if( lat > 90 )
    {
        lat = -90 + fmod( lat - 90, 180 );
    }
    else if( lat < -90 )
    {
        lat = 90 + fmod( lat + 90, 180 );
    }

    if( lon > 180.0 )
    {
        lon = -180.0 + fmod( lon - 180.0, 360.0 );
    }
    else if( lon < -180.0 )
    {
        lon = 180.0 + fmod( lon + 180.0, 360.0 );
    }
}

/** Wrap for lon, lat coordinates of a GeoRect
  * \param rect The GeoRect to be wrapped */
inline void WrapCoords( GeoRect& rect )
{
    double minLongitude = rect.MinLongitude();
    double minLatitude  = rect.MinLatitude();
    double maxLongitude = rect.MaxLongitude();
    double maxLatitude  = rect.MaxLatitude();

    WrapCoords( minLongitude, minLatitude );
    WrapCoords( maxLongitude, maxLatitude );

    rect.SetRect( minLongitude, minLatitude, maxLongitude, maxLatitude );
}

/** Clamp a lon, lat coordinate to be valid.
  * \param lon The longitude value to be clamped
  * \param lat The latitiude value to be clamped */
inline void ClampCoords( double& lon, double& lat )
{
    if( lat > 90.0 )
    {
        lat = 90.0;
    }
    else if( lat < -90.0 )
    {
        lat = -90.0;
    }

    if( lon > 180.0 )
    {
        lon = 180.0;
    }
    else if( lon < -180.0 )
    {
        lon = -180.0;
    }
}

/** Clamp for lon, lat coordinates of a GeoRect
  * \param rect The GeoRect to be clamped */
inline void ClampCoords( GeoRect& rect )
{
    double minLongitude = rect.MinLongitude();
    double minLatitude  = rect.MinLatitude();
    double maxLongitude = rect.MaxLongitude();
    double maxLatitude  = rect.MaxLatitude();

    ClampCoords( minLongitude, minLatitude );
    ClampCoords( maxLongitude, maxLatitude );

    rect.SetRect( minLongitude, minLatitude, maxLongitude, maxLatitude );
}

/** Initialize the GlsMapToolkit library.
  * Called by generated code.
  */
void GlsMapToolkitInit( const char* );

} // namespace disti

#endif