Cartesian3DPoint.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2025.
//
// 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/Point.hpp"
 
namespace meshkernel
{
 
    struct Cartesian3DPoint
    {
        double x; 
        double y; 
        double z; 
    };
    struct Cartesian3DPoint {…};
 
    double separationDistance(const Cartesian3DPoint& p1, const Cartesian3DPoint& p2);
 
    std::tuple<double, double, double> ComputeSphericalCoordinatesFromLatitudeAndLongitude(const Point& point);
 
    [[nodiscard]] Cartesian3DPoint VectorProduct(const Cartesian3DPoint& a, const Cartesian3DPoint& b);
 
    [[nodiscard]] double InnerProduct(const Cartesian3DPoint& a, const Cartesian3DPoint& b);
 
    Cartesian3DPoint operator*(const Cartesian3DPoint& p, const double value);
 
    Cartesian3DPoint operator*(const double value, const Cartesian3DPoint& p);
 
    Cartesian3DPoint operator/(const Cartesian3DPoint& p, const double value);
 
    Cartesian3DPoint operator+(const Cartesian3DPoint& p1, const Cartesian3DPoint& p2);
 
    Cartesian3DPoint operator-(const Cartesian3DPoint& p1, const Cartesian3DPoint& p2);
 
    [[nodiscard]] Cartesian3DPoint SphericalToCartesian3D(const Point& sphericalPoint);
 
    [[nodiscard]] Point Cartesian3DToSpherical(const Cartesian3DPoint& cartesianPoint, double referenceLongitude);
 
} // end namespace meshkernel
 
inline meshkernel::Cartesian3DPoint meshkernel::operator+(const Cartesian3DPoint& p1, const Cartesian3DPoint& p2)
{
    return {p1.x + p2.x, p1.y + p2.y, p1.z + p2.z};
}
inline meshkernel::Cartesian3DPoint meshkernel::operator+(const Cartesian3DPoint& p1, const Cartesian3DPoint& p2) {…}
 
inline meshkernel::Cartesian3DPoint meshkernel::operator-(const Cartesian3DPoint& p1, const Cartesian3DPoint& p2)
{
    return {p1.x - p2.x, p1.y - p2.y, p1.z - p2.z};
}
inline meshkernel::Cartesian3DPoint meshkernel::operator-(const Cartesian3DPoint& p1, const Cartesian3DPoint& p2) {…}
 
inline meshkernel::Cartesian3DPoint meshkernel::operator/(const Cartesian3DPoint& p, const double value)
{
    return {p.x / value, p.y / value, p.z / value};
}
inline meshkernel::Cartesian3DPoint meshkernel::operator/(const Cartesian3DPoint& p, const double value) {…}
 
inline meshkernel::Cartesian3DPoint meshkernel::operator*(const double value, const Cartesian3DPoint& p)
{
    return {value * p.x, value * p.y, value * p.z};
}
inline meshkernel::Cartesian3DPoint meshkernel::operator*(const double value, const Cartesian3DPoint& p) {…}
 
inline meshkernel::Cartesian3DPoint meshkernel::operator*(const Cartesian3DPoint& p, const double value)
{
    return value * p;
}
inline meshkernel::Cartesian3DPoint meshkernel::operator*(const Cartesian3DPoint& p, const double value) {…}
 
inline double meshkernel::InnerProduct(const Cartesian3DPoint& a, const Cartesian3DPoint& b)
{
    return a.x * b.x + a.y * b.y + a.z * b.z;
}
inline double meshkernel::InnerProduct(const Cartesian3DPoint& a, const Cartesian3DPoint& b) {…}
 
inline double meshkernel::separationDistance(const Cartesian3DPoint& p1, const Cartesian3DPoint& p2)
{
    double dx = p1.x - p2.x;
    double dy = p1.y - p2.y;
    double dz = p1.z - p2.z;
    return std::sqrt(dx * dx + dy * dy + dz * dz);
}
inline double meshkernel::separationDistance(const Cartesian3DPoint& p1, const Cartesian3DPoint& p2) {…}