SampleAveragingInterpolator.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2024.
//
// 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 <map>
#include <span>
#include <string>
#include <vector>
 
#include "MeshKernel/AveragingInterpolation.hpp" //  Only for the enum Method. should move to Definitions.hpp
#include "MeshKernel/AveragingStrategies/AveragingStrategy.hpp"
#include "MeshKernel/AveragingStrategies/AveragingStrategyFactory.hpp"
#include "MeshKernel/Constants.hpp"
#include "MeshKernel/Definitions.hpp"
#include "MeshKernel/Entities.hpp"
#include "MeshKernel/Exceptions.hpp"
#include "MeshKernel/Mesh2D.hpp"
#include "MeshKernel/MeshTriangulation.hpp"
#include "MeshKernel/Operations.hpp"
#include "MeshKernel/Point.hpp"
#include "MeshKernel/SampleInterpolator.hpp"
#include "MeshKernel/Utilities/RTreeFactory.hpp"
 
namespace meshkernel
{
 
    struct InterpolationParameters
    {
        AveragingInterpolation::Method m_method = AveragingInterpolation::Method::SimpleAveraging;
 
        double m_absoluteSearchRadius = 100.0;
 
        double m_relativeSearchRadius = 1.0;
 
        bool m_useClosestIfNoneFound = true;
 
        UInt m_minimumNumberOfSamples = 10;
    };
    struct InterpolationParameters {…};
 
    class SampleAveragingInterpolator : public SampleInterpolator
    {
    public:
        SampleAveragingInterpolator(const std::span<const double> xNodes,
                                    const std::span<const double> yNodes,
                                    const Projection projection,
                                    const InterpolationParameters& interpolationParameters);
 
        SampleAveragingInterpolator(const std::span<const Point> nodes,
                                    const Projection projection,
                                    const InterpolationParameters& interpolationParameters);
 
        UInt Size() const override;
 
        void Interpolate(const int propertyId, const std::span<const Point> iterpolationNodes, std::span<double> result) const override;
 
        void Interpolate(const int propertyId, const Mesh2D& mesh, const Location location, std::span<double> result) const override;
 
        double InterpolateValue(const int propertyId, const Point& evaluationPoint) const override;
 
    private:
        static constexpr UInt MaximumNumberOfEdgesPerNode = 16; 
 
        static std::vector<Point> CombineCoordinates(const std::span<const double> xNodes, const std::span<const double> yNodes);
 
        double InterpolateOnElement(const UInt elementId, const Point& interpolationPoint, const std::vector<double>& sampleValues) const;
 
        double ComputeOnPolygon(const int propertyId,
                                std::vector<Point>& polygon,
                                const Point& interpolationPoint,
                                const Projection projection,
                                std::vector<Sample>& sampleCache) const;
 
        double GetSearchRadiusSquared(const std::vector<Point>& searchPolygon,
                                      const Point& interpolationPoint,
                                      const Projection projection) const;
 
        void GenerateSearchPolygon(const double relativeSearchRadius,
                                   const Point& interpolationPoint,
                                   std::vector<Point>& polygon,
                                   const Projection projection) const;
 
        double GetSampleValueFromRTree(const int propertyId, const UInt index) const;
 
        double ComputeInterpolationResultFromNeighbors(const int propertyId,
                                                       const Point& interpolationPoint,
                                                       const std::vector<Point>& searchPolygon,
                                                       const Projection projection,
                                                       std::vector<Sample>& sampleCache) const;
 
        void InterpolateAtNodes(const int propertyId, const Mesh2D& mesh, std::span<double>& result) const;
 
        void InterpolateAtEdgeCentres(const Mesh2D& mesh,
                                      const std::span<double>& nodeResult,
                                      std::span<double>& result) const;
 
        void InterpolateAtFaces(const int propertyId, const Mesh2D& mesh, std::span<double>& result) const;
 
        std::vector<Point> m_samplePoints;
 
        // Should use the m_projection from the mesh in the interpolate function or
        // needs to be passed to the interpolate function in the no mesh version
        Projection m_projection = Projection::cartesian;
 
        InterpolationParameters m_interpolationParameters;
 
        std::unique_ptr<averaging::AveragingStrategy> m_strategy;
 
        std::map<int, std::vector<double>> m_sampleData;
 
        std::unique_ptr<RTreeBase> m_nodeRTree;
    };
    class SampleAveragingInterpolator : public SampleInterpolator {…};
 
} // namespace meshkernel
 
inline meshkernel::UInt meshkernel::SampleAveragingInterpolator::Size() const
{
    return static_cast<UInt>(m_samplePoints.size());
}
inline meshkernel::UInt meshkernel::SampleAveragingInterpolator::Size() const {…}