GeoCoordinate.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "LatLonAlt.hpp"
#include "AstMath/Vector.hpp"
#include "AstUtil/Math.hpp"
#include <cmath>
 
AST_NAMESPACE_BEGIN
 
class GeocentricPoint;
class GeodeticPoint;
 
 
 
class GeoCoordinate
{
public:
    GeoCoordinate() noexcept {};
 
    constexpr GeoCoordinate(double lat, double lon, double alt = 0.0) noexcept
        : latLonAlt_{lat, lon, alt} {}
    
    constexpr explicit GeoCoordinate(const LatLonAlt& latLonAlt) noexcept
        : latLonAlt_{latLonAlt} {}
 
public: // get and set methods
 
    constexpr const LatLonAlt& latLonAlt() const noexcept { return latLonAlt_; }
    void setLatLonAlt(const LatLonAlt& latLonAlt) noexcept{ latLonAlt_ = latLonAlt; }
 
    double latitude() const { return latLonAlt_.latitude(); }
    double longitude() const { return latLonAlt_.longitude(); }
    double altitude() const { return latLonAlt_.altitude(); }
    double& latitude() { return latLonAlt_.latitude(); }
    double& longitude() { return latLonAlt_.longitude(); }
    double& altitude() { return latLonAlt_.altitude(); }
    void setLatitude(double lat) { latLonAlt_.setLatitude(lat); }
    void setLongitude(double lon) { latLonAlt_.setLongitude(lon); }
    void setAltitude(double alt) { latLonAlt_.setAltitude(alt); }
 
public: // as methods
 
    GeocentricPoint& asGeocentricPoint() { return (GeocentricPoint&)*this; }
    GeodeticPoint& asGeodeticPoint() { return (GeodeticPoint&)*this; }
public:
    Vector3d getZenith() const;
    Vector3d getNadir() const;
    Vector3d getEast() const;
    Vector3d getWest() const;
    Vector3d getNorth() const;
    Vector3d getSouth() const;
 
public:
    LatLonAlt latLonAlt_;  
};
 
inline Vector3d GeoCoordinate::getZenith() const
{
    double lat = latitude();
    double lon = longitude();
    double sLat, cLat, sLon, cLon;
    sincos(lat, &sLat, &cLat);
    sincos(lon, &sLon, &cLon);
    return {cLon * cLat, sLon * cLat, sLat};    
}
 
inline Vector3d GeoCoordinate::getNadir() const
{
    return -getZenith();
}
            
inline Vector3d GeoCoordinate::getEast() const
{
    double sLon, cLon;
    sincos(longitude(), &sLon, &cLon);
    return {-sLon, cLon, 0};
}
 
inline Vector3d GeoCoordinate::getWest() const
{
    return -getEast();
}
 
inline Vector3d GeoCoordinate::getNorth() const
{
    double lat = latitude();
    double lon = longitude();
    double sLat, cLat, sLon, cLon;
    sincos(lat, &sLat, &cLat);
    sincos(lon, &sLon, &cLon);
    return {-cLon * sLat, -sLon * sLat, cLat};
}
 
inline Vector3d GeoCoordinate::getSouth() const
{
    return -getNorth();
}
 
AST_CORE_CAPI void aSurfaceCentricToDetic(const GeocentricPoint& centric, double flatFact, GeodeticPoint& detic);
 
 
AST_CORE_CAPI void aSurfaceDeticToCentric(const GeodeticPoint& detic, double flatFact, GeocentricPoint& centric);
 
 
 
AST_CORE_CAPI double aSurfaceCentricToDeticLat(double centricLat, double flatFact);
 
 
A_ALWAYS_INLINE double aSurfaceCentricToDetic(double centricLat, double flatFact)
{
    return aSurfaceCentricToDeticLat(centricLat, flatFact);
}
 
AST_CORE_CAPI double aSurfaceDeticToCentricLat(double deticLat, double flatFact);
 
 
A_ALWAYS_INLINE double aSurfaceDeticToCentric(double deticLat, double flatFact)
{
    return aSurfaceDeticToCentricLat(deticLat, flatFact);
}
 
 
AST_NAMESPACE_END