Point.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 <cmath>
 
#include "MeshKernel/Constants.hpp"
#include "MeshKernel/Utilities/NumericFunctions.hpp"
#include "MeshKernel/Vector.hpp"
 
namespace meshkernel
{
 
    class Point
    {
    public:
        double x; 
        double y; 
 
        Point()
            : x(constants::missing::doubleValue),
              y(constants::missing::doubleValue)
        {
        }
 
        Point(double x, double y)
            : x(x),
              y(y)
        {
        }
 
        void SetInvalid();
 
        Point& operator+=(const Point& p);
 
        Point& operator-=(const Point& p);
 
        Point& operator+=(const Vector& vec);
 
        Point& operator-=(const Vector& vec);
 
        Point& operator/=(const Point& p);
 
        Point& operator*=(const Point& p);
 
        Point& operator+=(const double p);
 
        Point& operator-=(const double p);
 
        Point& operator/=(const double p);
 
        Point& operator*=(const double p);
 
        [[nodiscard]] Point operator*(int const& rhs) const { return Point(x * rhs, y * rhs); }
 
        void TransformSphericalToCartesian(double referenceLatitude)
        {
            static double constexpr m_trans_factor =
                constants::conversion::degToRad *
                constants::geometric::earth_radius; 
 
            x = x * m_trans_factor * std::cos(constants::conversion::degToRad * referenceLatitude);
            y = y * m_trans_factor;
        }
 
        [[nodiscard]] bool IsValid(const double missingValue = constants::missing::doubleValue) const
        {
            bool isInvalid = IsEqual(x, missingValue) ||
                             IsEqual(y, missingValue);
 
            return !isInvalid;
        }
    };
 
    double lengthSquared(const Point& p1);
 
    double dot(const Point& p1, const Point& p2);
 
    double dot(const Point& p, const Vector& v);
 
    double dot(const Vector& v, const Point& p);
 
    double cross(const Point& p1, const Point& p2);
 
    Point operator-(const Point& pnt);
 
    Point operator+(const Point& p1, const Point& p2);
 
    Point operator+(const Point& pnt, const Vector& vec);
 
    Point operator+(const Point& p, const double x);
 
    Point operator+(const double x, const Point& p);
 
    Point operator-(const Point& p1, const Point& p2);
 
    Point operator-(const Point& pnt, const Vector& vec);
 
    Point operator-(const Point& p, const double x);
 
    Point operator-(const double x, const Point& p);
 
    Point operator*(const Point& p1, const Point& p2);
 
    Point operator*(const double x, const Point& p);
 
    Point operator*(const Point& p, const double x);
 
    Point operator/(const Point& p1, const Point& p2);
 
    Point operator/(const Point& p, const double x);
 
    bool operator==(const Point& p1, const Point& p2);
 
    bool operator!=(const Point& p1, const Point& p2);
 
    bool IsEqual(const Point& p1, const Point& p2, const double epsilon);
 
    Point PointAlongLine(const Point& startPoint, const Point& endPoint, const double lambda);
 
    static Point Rotate(const Point& point, const double angle, const Point& reference)
    {
        const auto translatedPoint = point - reference;
 
        const auto angleInRad = angle * constants::conversion::degToRad;
        const auto cosineAngle = std::cos(angleInRad);
        const auto sinAngle = std::sin(angleInRad);
        Point result(translatedPoint.x * cosineAngle - translatedPoint.y * sinAngle,
                     translatedPoint.x * sinAngle + translatedPoint.y * cosineAngle);
 
        return result + reference;
    }
 
    double GetDeltaXCartesian(const Point& p1, const Point& p2);
 
    double GetDeltaYCartesian(const Point& p1, const Point& p2);
 
    Vector GetDeltaCartesian(const Point& p1, const Point& p2);
 
} // namespace meshkernel
 
inline void meshkernel::Point::SetInvalid()
{
    x = constants::missing::doubleValue;
    y = constants::missing::doubleValue;
}
 
inline meshkernel::Point& meshkernel::Point::operator+=(const Point& p)
{
    x += p.x;
    y += p.y;
    return *this;
}
 
inline meshkernel::Point& meshkernel::Point::operator-=(const Point& p)
{
    x -= p.x;
    y -= p.y;
    return *this;
}
 
inline meshkernel::Point& meshkernel::Point::operator+=(const Vector& vec)
{
    x += vec.x();
    y += vec.y();
    return *this;
}
 
inline meshkernel::Point& meshkernel::Point::operator-=(const Vector& vec)
{
    x -= vec.x();
    y -= vec.y();
    return *this;
}
 
inline meshkernel::Point& meshkernel::Point::operator/=(const Point& p)
{
    x /= p.x;
    y /= p.y;
    return *this;
}
 
inline meshkernel::Point& meshkernel::Point::operator*=(const Point& p)
{
    x *= p.x;
    y *= p.y;
    return *this;
}
 
inline meshkernel::Point& meshkernel::Point::operator+=(const double p)
{
    x += p;
    y += p;
    return *this;
}
 
inline meshkernel::Point& meshkernel::Point::operator-=(const double p)
{
    x -= p;
    y -= p;
    return *this;
}
 
inline meshkernel::Point& meshkernel::Point::operator/=(const double p)
{
    x /= p;
    y /= p;
    return *this;
}
 
inline meshkernel::Point& meshkernel::Point::operator*=(const double p)
{
    x *= p;
    y *= p;
    return *this;
}
 
inline double meshkernel::lengthSquared(const Point& p)
{
    return p.x * p.x + p.y * p.y;
}
 
inline double meshkernel::dot(const Point& p1, const Point& p2)
{
    return p1.x * p2.x + p1.y * p2.y;
}
 
inline double meshkernel::dot(const Point& p, const Vector& v)
{
    return p.x * v.x() + p.y * v.y();
}
 
inline double meshkernel::dot(const Vector& v, const Point& p)
{
    return dot(p, v);
}
 
inline double meshkernel::cross(const Point& p1, const Point& p2)
{
    return p1.x * p2.y - p1.y * p2.x;
}
 
inline meshkernel::Point meshkernel::operator-(const Point& pnt)
{
    return Point(-pnt.x, -pnt.y);
}
 
inline meshkernel::Point meshkernel::operator+(const Point& p1, const Point& p2)
{
    return Point(p1.x + p2.x, p1.y + p2.y);
}
 
inline meshkernel::Point meshkernel::operator+(const Point& pnt, const Vector& vec)
{
    return Point(pnt.x + vec.x(), pnt.y + vec.y());
}
 
inline meshkernel::Point meshkernel::operator+(const Point& p, const double x)
{
    return Point(p.x + x, p.y + x);
}
 
inline meshkernel::Point meshkernel::operator+(const double x, const Point& p)
{
    return Point(p.x + x, p.y + x);
}
 
inline meshkernel::Point meshkernel::operator-(const Point& p1, const Point& p2)
{
    return Point(p1.x - p2.x, p1.y - p2.y);
}
 
inline meshkernel::Point meshkernel::operator-(const Point& pnt, const Vector& vec)
{
    return Point(pnt.x - vec.x(), pnt.y - vec.y());
}
 
inline meshkernel::Point meshkernel::operator-(const Point& p, const double x)
{
    return Point(p.x - x, p.y - x);
}
 
inline meshkernel::Point meshkernel::operator-(const double x, const Point& p)
{
    return Point(x - p.x, x - p.y);
}
 
inline meshkernel::Point meshkernel::operator*(const Point& p1, const Point& p2)
{
    return Point(p1.x * p2.x, p1.y * p2.y);
}
 
inline meshkernel::Point meshkernel::operator*(const double x, const Point& p)
{
    return Point(x * p.x, x * p.y);
}
 
inline meshkernel::Point meshkernel::operator*(const Point& p, const double x)
{
    return Point(x * p.x, x * p.y);
}
 
inline meshkernel::Point meshkernel::operator/(const Point& p1, const Point& p2)
{
    return Point(p1.x / p2.x, p1.y / p2.y);
}
 
inline meshkernel::Point meshkernel::operator/(const Point& p, const double x)
{
    return Point(p.x / x, p.y / x);
}
 
inline bool meshkernel::operator==(const Point& p1, const Point& p2)
{
    return IsEqual(p1.x, p2.x) && IsEqual(p1.y, p2.y);
}
 
inline bool meshkernel::operator!=(const Point& p1, const Point& p2)
{
    return !(p1 == p2);
}
 
inline bool meshkernel::IsEqual(const Point& p1, const Point& p2, const double epsilon)
{
    return IsEqual(p1.x, p2.x, epsilon) && IsEqual(p1.y, p2.y, epsilon);
}
 
inline double meshkernel::GetDeltaXCartesian(const Point& p1, const Point& p2)
{
    return p2.x - p1.x;
}
 
inline double meshkernel::GetDeltaYCartesian(const Point& p1, const Point& p2)
{
    return p2.y - p1.y;
}
 
inline meshkernel::Vector meshkernel::GetDeltaCartesian(const Point& p1, const Point& p2)
{
    return Vector(GetDeltaXCartesian(p1, p2), GetDeltaYCartesian(p1, p2));
}
 
inline meshkernel::Point meshkernel::PointAlongLine(const Point& startPoint, const Point& endPoint, const double lambda)
{
    return (1.0 - lambda) * startPoint + lambda * endPoint;
}