ProjectionConversions.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2023.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation version 3.
//
// 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, see <http://www.gnu.org/licenses/>.
//
// contact: delft3d.support@deltares.nl
// Stichting Deltares
// P.O. Box 177
// 2600 MH Delft, The Netherlands
//
// All indications and logos of, and references to, "Delft3D" and "Deltares"
// are registered trademarks of Stichting Deltares, and remain the property of
// Stichting Deltares. All rights reserved.
//
//------------------------------------------------------------------------------
 
#pragma once
 
#include <string>
 
#if defined(__linux__) || defined(__APPLE__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
 
#define BOOST_ALLOW_DEPRECATED_HEADERS
#include <boost/geometry.hpp>
#include <boost/geometry/srs/epsg.hpp>
#undef BOOST_ALLOW_DEPRECATED_HEADERS
 
#if defined(__linux__) || defined(__APPLE__)
#pragma GCC diagnostic pop
#endif
 
namespace meshkernel
{
 
    namespace bg = boost::geometry;
 
    template <typename ProjectionConversion>
    class ConvertSphericalToCartesianBase
    {
    public:
        using LongLat = bg::model::d2::point_xy<double, bg::cs::geographic<bg::degree>>;
 
        using UTM = bg::model::d2::point_xy<double, Projection>;
 
        explicit ConvertSphericalToCartesianBase(const ProjectionConversion& proj) : m_projection(proj) {}
 
        virtual ~ConvertSphericalToCartesianBase() = default;
 
        Projection SourceProjection() const
        {
            return Projection::spherical;
        }
 
        Projection TargetProjection() const
        {
            return Projection::cartesian;
        }
 
        Point operator()(const Point& pnt) const
        {
            LongLat longLat(pnt.x, pnt.y);
            UTM utm{0.0, 0.0};
            m_projection.forward(longLat, utm);
 
            Point result(utm.x(), utm.y());
            return result;
        }
 
    private:
        ProjectionConversion m_projection;
    };
 
    template <const int EpsgCode>
    class ConvertSphericalToCartesianEPSG : public ConvertSphericalToCartesianBase<bg::srs::projection<bg::srs::static_epsg<EpsgCode>>>
    {
    public:
        using EpsgProjection = bg::srs::projection<bg::srs::static_epsg<EpsgCode>>;
 
        ConvertSphericalToCartesianEPSG() : ConvertSphericalToCartesianBase<bg::srs::projection<bg::srs::static_epsg<EpsgCode>>>(EpsgProjection()) {}
    };
 
    class ConvertSphericalToCartesian : public ConvertSphericalToCartesianBase<bg::srs::projection<>>
    {
    public:
        explicit ConvertSphericalToCartesian(const std::string& zone) : ConvertSphericalToCartesianBase<bg::srs::projection<>>(bg::srs::proj4(zone)) {}
    };
 
    //--------------------------------
 
    template <typename ProjectionConversion>
    class ConvertCartesianToSphericalBase
    {
    public:
        using LongLat = bg::model::d2::point_xy<double, bg::cs::geographic<bg::degree>>;
 
        using UTM = bg::model::d2::point_xy<double>;
 
        explicit ConvertCartesianToSphericalBase(const ProjectionConversion& proj) : m_projection(proj) {}
 
        virtual ~ConvertCartesianToSphericalBase() = default;
 
        Projection SourceProjection() const
        {
            return Projection::cartesian;
        }
 
        Projection TargetProjection() const
        {
            return Projection::spherical;
        }
 
        Point operator()(const Point& pnt) const
        {
            UTM utm{pnt.x, pnt.y};
            LongLat longLat{0.0, 0.0};
            m_projection.inverse(utm, longLat);
 
            Point result(longLat.x(), longLat.y());
            return result;
        }
 
    private:
        ProjectionConversion m_projection;
    };
 
    template <const int EpsgCode>
    class ConvertCartesianToSphericalEPSG : public ConvertCartesianToSphericalBase<boost::geometry::srs::projection<boost::geometry::srs::static_epsg<EpsgCode>>>
    {
    public:
        using EpsgProjection = boost::geometry::srs::projection<boost::geometry::srs::static_epsg<EpsgCode>>;
 
        ConvertCartesianToSphericalEPSG() : ConvertCartesianToSphericalBase<boost::geometry::srs::projection<boost::geometry::srs::static_epsg<EpsgCode>>>(EpsgProjection()) {}
    };
 
    class ConvertCartesianToSpherical : public ConvertCartesianToSphericalBase<bg::srs::projection<>>
    {
    public:
        explicit ConvertCartesianToSpherical(const std::string& zone) : ConvertCartesianToSphericalBase<bg::srs::projection<>>(bg::srs::proj4(zone)) {}
    };
 
} // namespace meshkernel