Polygon.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 <vector>
 
#include "MeshKernel/BoundingBox.hpp"
#include "MeshKernel/Definitions.hpp"
#include "MeshKernel/Point.hpp"
 
namespace meshkernel
{
 
    class LandBoundary;
 
    class Polygon
    {
    public:
        Polygon() = default;
 
        Polygon(const Polygon& copy) = default;
 
        Polygon(Polygon&& copy) = default;
 
        Polygon(const std::vector<Point>& points,
                Projection projection);
 
        Polygon(std::vector<Point>&& points,
                Projection projection);
 
        void Reset(const std::vector<Point>& points,
                   Projection projection);
 
        Polygon& operator=(const Polygon& copy);
 
        Polygon& operator=(Polygon&& copy);
 
        UInt Size() const;
 
        const std::vector<Point>& Nodes() const;
 
        Point& Node(const size_t i);
 
        const Point& Node(const size_t i) const;
 
        const BoundingBox& GetBoundingBox() const;
 
        bool Contains(const Point& point) const;
 
        void SnapToLandBoundary(const size_t startIndex, const size_t endIndex, const LandBoundary& boundary);
 
        std::vector<Point> Refine(UInt startIndex, UInt endIndex, double refinementDistance) const;
 
        std::vector<Point> LinearRefine(UInt startIndex, UInt endIndex) const;
 
        std::tuple<double, Point, TraversalDirection> FaceAreaAndCenterOfMass() const;
 
        static std::tuple<double, Point, TraversalDirection> FaceAreaAndCenterOfMass(const std::vector<Point>& polygon, const Projection projection);
 
        static std::tuple<double, Point, TraversalDirection> FaceAreaAndCenterOfMass(const std::vector<Point>& nodes,
                                                                                     const std::vector<UInt>& nodeIndices,
                                                                                     const Projection projection,
                                                                                     bool isClosed);
 
        double PerimeterLength() const;
 
        std::vector<double> EdgeLengths() const;
 
        std::vector<Point> ComputeOffset(double displacement, const bool innerAndOuter) const;
 
        Projection GetProjection() const;
 
    private:
        static void RefineSegment(std::vector<meshkernel::Point>& refinedPolygon,
                                  const std::vector<meshkernel::Point>::const_iterator& nodeIterator,
                                  const double refinementDistance,
                                  const meshkernel::Projection projection);
 
        static void computeAverageLengths(const std::vector<double>& cumulativeDistances, std::vector<double>& averageDistances);
 
        static void smoothCumulativeDistance(const std::vector<double>& averageDistances, std::vector<double>& cumulativeDistances);
 
        static void smoothAverageLengths(const std::vector<double>& cumulativeDistances,
                                         const double firstDistance,
                                         const double lastDistance,
                                         std::vector<double>& averageLengths);
 
        void GetPolygonNodes(const UInt startIndex,
                             const UInt endIndex,
                             std::vector<Point>& polygonNodes) const;
 
        std::vector<double> ComputeCumulativeDistances(const std::vector<meshkernel::Point>& polygonNodes) const;
 
        std::tuple<meshkernel::UInt, meshkernel::UInt>
        FindMinMaxRatioIndex(const std::vector<double>& averageLengths,
                             const std::vector<double>& actualAverageLengths) const;
 
        static meshkernel::Point interpolatePointOnPolyline(const std::vector<meshkernel::Point>& points,
                                                            const std::vector<double>& cumulativeDistances,
                                                            const double pointDistance);
 
        void Initialise();
 
        bool ContainsCartesian(const Point& point) const;
 
        bool ContainsSphericalAccurate(const Point& point) const;
 
        std::vector<Point> m_nodes;
 
        Projection m_projection = Projection::cartesian;
 
        BoundingBox m_boundingBox;
    };
 
} // namespace meshkernel
 
inline meshkernel::UInt meshkernel::Polygon::Size() const
{
    return static_cast<UInt>(m_nodes.size());
}
 
inline const std::vector<meshkernel::Point>& meshkernel::Polygon::Nodes() const
{
    return m_nodes;
}
 
inline meshkernel::Point& meshkernel::Polygon::Node(const size_t i)
{
    return m_nodes[i];
}
 
inline const meshkernel::Point& meshkernel::Polygon::Node(const size_t i) const
{
    return m_nodes[i];
}
 
inline const meshkernel::BoundingBox& meshkernel::Polygon::GetBoundingBox() const
{
    return m_boundingBox;
}
 
inline meshkernel::Projection meshkernel::Polygon::GetProjection() const
{
    return m_projection;
}