coordinate_converter.cpp

Go to the documentation of this file.

#include "coordinate_converter/coordinate_converter.h"
 
namespace CoordinateConverter
{
 
    // ResetOrigin will manage that rest of the function always work with the
    // same origin. The size parameter represent the size of the coordinate
    // system.
    void
    CoordConv::ResetOrigin(Core::GeographicalCoordinate geoCoord, int size)
    {
        auto& instance = GetInstance();
        instance.m_Size = size;
        instance.m_OriginGeographical = { geoCoord.Latitude,
                                          geoCoord.Longitude };
        instance.m_Origin.Reset(geoCoord.Latitude, geoCoord.Longitude, 0);
    }
 
    // This function convert a geographical coordinate to a cartesian
    // coordinate.
    Core::CartesianCoordinate
    CoordConv::GeographicalToCartesian(Core::GeographicalCoordinate geoCoord)
    {
        auto& instance = GetInstance();
        double x, y, z;
        instance.m_Origin.Forward(geoCoord.Latitude, geoCoord.Longitude, 0, x,
                                  y, z);
        return { x, y, z };
    }
 
    // This function convert a cartesian coordinate to a geographical coordinate
    Core::GeographicalCoordinate
    CoordConv::CartesianToGeographical(Core::CartesianCoordinate cartCoord)
    {
        auto& instance = GetInstance();
        double lat, lon, alt;
        instance.m_Origin.Reverse(cartCoord.X, cartCoord.Y, cartCoord.Z, lat,
                                  lon, alt);
        return { lat, lon };
    }
 
    // This function return the origin to hivemind.
    Core::GeographicalCoordinate
    CoordConv::GetOrigin()
    {
        auto& instance = GetInstance();
        return instance.m_OriginGeographical;
    }
 
    // This function convert from a symmetric coordinate system to an
    // asynmmetric coordinate system. The size parameter represent the size of
    // the coordinate system.
    Core::CartesianCoordinate
    CoordConv::SymmetricToAsymmetric(Core::CartesianCoordinate symmetric)
    {
        auto& instance = GetInstance();
        symmetric.X = symmetric.X + (instance.m_Size / 2);
        symmetric.Y = -symmetric.Y + (instance.m_Size / 2);
        return symmetric;
    }
 
    // This function convert from an asymmetric coordinate system to a
    // synmmetric coordinate system. The size parameter represent the size of
    // the coordinate system.
    Core::CartesianCoordinate
    CoordConv::AsymmetricToSymmetric(Core::CartesianCoordinate asymmetric)
    {
        auto& instance = GetInstance();
        asymmetric.X = asymmetric.X - (instance.m_Size / 2);
        asymmetric.Y = -asymmetric.Y + (instance.m_Size / 2);
        return asymmetric;
    }
 
    // Hivemind are using UTM33N and therefore are this hardcoded in the call to
    // geographiclib. For scalability and easier maintenance this should be able
    // to configured.
    Core::UTMCoordinate
    CoordConv::GeographicToUTM(Core::GeographicalCoordinate GeoCoord)
    {
        Core::UTMCoordinate utmCoord;
        GeographicLib::UTMUPS::Forward(GeoCoord.Latitude, GeoCoord.Longitude,
                                       utmCoord.Zone,
                                       utmCoord.IsNorthHemisphere,
                                       utmCoord.Easting, utmCoord.Northing, 33);
        return utmCoord;
    }
 
    // This function convert from UTM coordinates to geographical coordinates.
    Core::GeographicalCoordinate
    CoordConv::UTMToGeographic(Core::UTMCoordinate UTMCoord)
    {
        Core::GeographicalCoordinate geoCoord(0, 0);
        GeographicLib::UTMUPS::Reverse(
            UTMCoord.Zone, UTMCoord.IsNorthHemisphere, UTMCoord.Easting,
            UTMCoord.Northing, geoCoord.Latitude, geoCoord.Longitude);
        return geoCoord;
    }
 
} // namespace CoordinateConverter