AveragingInterpolation.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 "MeshKernel/AveragingStrategies/AveragingStrategy.hpp"
#include "MeshKernel/Definitions.hpp"
#include "MeshKernel/Mesh2D.hpp"
#include "MeshKernel/MeshInterpolation.hpp"
#include "MeshKernel/Utilities/RTreeBase.hpp"
 
namespace meshkernel
{
    // Forward declarations
    class Mesh;
    class Sample;
 
    class AveragingInterpolation : public MeshInterpolation
    {
    public:
        enum class Method
        {
            SimpleAveraging = 1,         
            Closest = 2,                 
            Max = 3,                     
            Min = 4,                     
            InverseWeightedDistance = 5, 
            MinAbsValue = 6              
        };
        enum class Method {…};
 
        AveragingInterpolation(Mesh2D& mesh,
                               std::vector<Sample>& samples,
                               Method method,
                               Location locationType,
                               double relativeSearchRadius,
                               bool useClosestSampleIfNoneAvailable,
                               bool subtractSampleValues,
                               UInt minNumSamples);
 
        void Compute() override;
 
    private:
        static constexpr UInt DefaultMaximumCacheSize = 100;
 
        double ComputeOnPolygon(const std::vector<Point>& polygon,
                                const Point& interpolationPoint);
 
        void DecreaseValueOfSamples();
 
        [[nodiscard]] std::vector<Point> GetSearchPolygon(std::vector<Point> const& polygon, Point const& interpolationPoint) const;
 
        [[nodiscard]] double ComputeInterpolationResultFromNeighbors(const Point& interpolationPoint, std::vector<Point> const& searchPolygon);
 
        [[nodiscard]] double GetSampleValueFromRTree(UInt index);
 
        [[nodiscard]] double GetSearchRadiusSquared(std::vector<Point> const& searchPolygon,
                                                    Point const& interpolationPoint) const;
 
        Mesh2D& m_mesh;                                 
        std::vector<Sample>& m_samples;                 
        Location m_interpolationLocation;               
        double m_relativeSearchRadius;                  
        bool m_useClosestSampleIfNoneAvailable = false; 
        bool m_transformSamples = false;                
        std::vector<Sample> m_interpolationSampleCache; 
 
        std::unique_ptr<RTreeBase> m_samplesRtree;                
        std::unique_ptr<averaging::AveragingStrategy> m_strategy; 
    };
    class AveragingInterpolation : public MeshInterpolation {…};
} // namespace meshkernel
namespace meshkernel {…}