Feature/gridedit 785 refactor mesh refinement

libs/MeshKernel/include/MeshKernel/AveragingInterpolation.hpp

@@ -109,6 +109,9 @@ namespace meshkernel
         void Compute() override;
 
     private:
+        /// @brief Default size for interpolation points and sample caches.
+        static constexpr UInt DefaultMaximumCacheSize = 100;
+
         /// @brief Compute the averaging results in polygon
         /// @param[in]  polygon            The bounding polygon where the samples are included
         /// @param[in]  interpolationPoint The interpolation point
@@ -151,9 +154,10 @@ namespace meshkernel
         bool m_useClosestSampleIfNoneAvailable = false; ///< Whether to use the closest sample if there is none available
         bool m_transformSamples = false;                ///< Wheher to transform samples
         UInt m_minNumSamples = 1;                       ///< The minimum amount of samples for a valid interpolation. Used in some interpolation algorithms.
+        std::vector<Point> m_interpolationPointCache;   ///< Cache for interpolation points
+        std::vector<double> m_interpolationSampleCache; ///< Cache for interpolation samples
 
-        std::vector<bool> m_visitedSamples; ///< The visited samples
-
-        RTree m_samplesRtree; ///< The samples tree
+        RTree m_samplesRtree;                                     ///< The samples tree
+        std::unique_ptr<averaging::AveragingStrategy> m_strategy; ///< Averaging strategy
     };
 } // namespace meshkernel

libs/MeshKernel/include/MeshKernel/AveragingStrategies/AveragingStrategy.hpp

@@ -36,6 +36,9 @@ namespace meshkernel::averaging
     public:
         virtual ~AveragingStrategy() = default;
 
+        /// @brief Reset the state of the averaging strategy, ready for the next calculation.
+        virtual void Reset(const Point& interpolationPoint) = 0;
+
         /// @brief Adds the specified sample point.
         /// @param[in] samplePoint The sample point to add to this strategy.
         /// @param[in] sampleValue The value associated with the sample point.
@@ -44,5 +47,14 @@ namespace meshkernel::averaging
         /// @brief Calculates the average value based on the values added.
         /// @return The calculated average
         [[nodiscard]] virtual double Calculate() const = 0;
+
+        /// @brief Calculates the average value based on the sample values.
+        /// @param[in] interpolationPoint The point for which the average should be calculated.
+        /// @param[in] samplePoints The sample points to used by this strategy.
+        /// @param[in] sampleValues The sample values  associated with each sample point.
+        /// @return The calculated average
+        virtual double Calculate (const Point& interpolationPoint,
+                                  const std::vector<Point>& samplePoints,
+                                  const std::vector<double>& sampleValues) const = 0;
     };
 } // namespace meshkernel::averaging

libs/MeshKernel/include/MeshKernel/AveragingStrategies/AveragingStrategyFactory.hpp

@@ -38,12 +38,10 @@ namespace meshkernel::averaging
         /// @brief The static method returning the strategy
         /// @param[in] averagingMethod The averaging method enumeration value
         /// @param[in] minNumSamples The minimum a of samples used for certain interpolation algorithms
-        /// @param[in] interpolationPoint The interpolation point
         /// @param[in] projection  The projection to use
         /// @return The interpolation strategy to use
         [[nodiscard]] std::unique_ptr<AveragingStrategy> static GetAveragingStrategy(AveragingInterpolation::Method averagingMethod,
                                                                                      size_t minNumSamples,
-                                                                                     Point const& interpolationPoint,
                                                                                      Projection projection);
     };
 } // namespace meshkernel::averaging

libs/MeshKernel/include/MeshKernel/AveragingStrategies/ClosestAveragingStrategy.hpp

@@ -39,12 +39,23 @@ namespace meshkernel::averaging
         /// @brief Construct a new ClosestAveragingStrategy.
         /// @param[in] interpolationPoint The point for which the average should be calculated.
         /// @param[in] projection         The projection used to calculate distances with.
-        ClosestAveragingStrategy(Point const& interpolationPoint,
-                                 Projection projection);
+        ClosestAveragingStrategy(Projection projection);
+
+        /// @brief Reset the state of the closest averaging strategy.
+        void Reset(const Point& interpolationPoint) override;
 
         void Add(Point const& samplePoint, double sampleValue) override;
         [[nodiscard]] double Calculate() const override;
 
+        /// @brief Calculates the average value based on the sample values.
+        /// @param[in] interpolationPoint The point for which the average should be calculated.
+        /// @param[in] samplePoints The sample points to used by this strategy.
+        /// @param[in] sampleValues The sample values  associated with each sample point.
+        /// @return The calculated average
+        double Calculate (const Point& interpolationPoint,
+                          const std::vector<Point>& samplePoints,
+                          const std::vector<double>& sampleValues) const override;
+
     private:
         /// @brief The result used to calculate the final value in Calculate.
         double m_result = constants::missing::doubleValue;
@@ -53,7 +64,7 @@ namespace meshkernel::averaging
         double m_closestSquaredValue = std::numeric_limits<double>::max();
 
         /// @brief The interpolation point from which the closest value is calculated.
-        Point const& m_interpolationPoint;
+        Point m_interpolationPoint{constants::missing::doubleValue, constants::missing::doubleValue};
 
         /// @brief The projection used to calculate the squared distance.
         Projection const m_projection;

libs/MeshKernel/include/MeshKernel/AveragingStrategies/InverseWeightedAveragingStrategy.hpp

@@ -37,16 +37,26 @@ namespace meshkernel::averaging
     {
     public:
         /// @brief Construct a new InverseWeightedAveragingStrategy.
-        /// @param[in] interpolationPoint The point for which the average should be calculated.
         /// @param[in] minNumSamples      The minimum amount of samples for a valid interpolation.
         /// @param[in] projection         The projection used in calculating the distance.
-        InverseWeightedAveragingStrategy(Point const& interpolationPoint,
-                                         size_t minNumSamples,
+        InverseWeightedAveragingStrategy(size_t minNumSamples,
                                          Projection projection);
 
+        /// @brief Reset the state of the inverse weighted averaging strategy.
+        void Reset(const Point& interpolationPoint) override;
+
         void Add(Point const& samplePoint, double sampleValue) override;
         [[nodiscard]] double Calculate() const override;
 
+        /// @brief Calculates the average value based on the sample values.
+        /// @param[in] interpolationPoint The point for which the average should be calculated.
+        /// @param[in] samplePoints The sample points to used by this strategy.
+        /// @param[in] sampleValues The sample values  associated with each sample point.
+        /// @return The calculated average
+        double Calculate (const Point& interpolationPoint,
+                          const std::vector<Point>& samplePoints,
+                          const std::vector<double>& sampleValues) const override;
+
     private:
         /// @brief The current result used in Calculate to calculate the final value.
         double m_result = 0.0;
@@ -55,10 +65,10 @@ namespace meshkernel::averaging
         double m_wall = 0.0;
 
         /// @brief The interpolation point from which the inverse weight is calculated.
-        Point const& m_interpolationPoint;
+        Point m_interpolationPoint{constants::missing::doubleValue, constants::missing::doubleValue};
 
         /// @brief The minimum number of samples for a valid interpolation.
-        size_t m_minNumSamples;
+        const size_t m_minNumSamples;
 
         /// @brief The projection used to calculate the distance.
         Projection const m_projection;

libs/MeshKernel/include/MeshKernel/AveragingStrategies/MaxAveragingStrategy.hpp

@@ -36,10 +36,22 @@ namespace meshkernel::averaging
     class MaxAveragingStrategy final : public AveragingStrategy
     {
     public:
+        /// @brief Reset the state of the max averaging strategy.
+        void Reset(const Point& interpolationPoint) override;
+
         void Add(Point const& samplePoint, double sampleValue) override;
 
         [[nodiscard]] double Calculate() const override;
 
+        /// @brief Calculates the average value based on the sample values.
+        /// @param[in] interpolationPoint The point for which the average should be calculated.
+        /// @param[in] samplePoints The sample points to used by this strategy.
+        /// @param[in] sampleValues The sample values  associated with each sample point.
+        /// @return The calculated average
+        double Calculate (const Point& interpolationPoint,
+                          const std::vector<Point>& samplePoints,
+                          const std::vector<double>& sampleValues) const override;
+
     private:
         /// @brief The current result returned in Calculate.
         double m_result = std::numeric_limits<double>::lowest();

libs/MeshKernel/include/MeshKernel/AveragingStrategies/MinAbsAveragingStrategy.hpp

@@ -36,10 +36,22 @@ namespace meshkernel::averaging
     class MinAbsAveragingStrategy final : public AveragingStrategy
     {
     public:
+        /// @brief Reset the state of the absolute-value-of-the-mininimum averaging-strategy.
+        void Reset(const Point& interpolationPoint) override;
+
         void Add(Point const& samplePoint, double sampleValue) override;
 
         [[nodiscard]] double Calculate() const override;
 
+        /// @brief Calculates the average value based on the sample values.
+        /// @param[in] interpolationPoint The point for which the average should be calculated.
+        /// @param[in] samplePoints The sample points to used by this strategy.
+        /// @param[in] sampleValues The sample values  associated with each sample point.
+        /// @return The calculated average
+        double Calculate (const Point& interpolationPoint,
+                          const std::vector<Point>& samplePoints,
+                          const std::vector<double>& sampleValues) const override;
+
     private:
         /// @brief The current result returned in Calculate
         double m_result = std::numeric_limits<double>::max();

libs/MeshKernel/include/MeshKernel/AveragingStrategies/MinAveragingStrategy.hpp

@@ -35,10 +35,22 @@ namespace meshkernel::averaging
     class MinAveragingStrategy final : public AveragingStrategy
     {
     public:
+        /// @brief Reset the state of the minimum value averaging-strategy.
+        void Reset(const Point& interpolationPoint) override;
+
         void Add(Point const& samplePoint, double sampleValue) override;
 
         [[nodiscard]] double Calculate() const override;
 
+        /// @brief Calculates the average value based on the sample values.
+        /// @param[in] interpolationPoint The point for which the average should be calculated.
+        /// @param[in] samplePoints The sample points to used by this strategy.
+        /// @param[in] sampleValues The sample values  associated with each sample point.
+        /// @return The calculated average
+        double Calculate (const Point& interpolationPoint,
+                          const std::vector<Point>& samplePoints,
+                          const std::vector<double>& sampleValues) const override;
+
     private:
         /// @brief The current result returned in Calculate
         double m_result = std::numeric_limits<double>::max();

libs/MeshKernel/include/MeshKernel/AveragingStrategies/SimpleAveragingStrategy.hpp

@@ -13,12 +13,24 @@ namespace meshkernel::averaging
         /// @param minNumSamples[in] The minimum amount of samples for a valid interpolation
         SimpleAveragingStrategy(size_t minNumSamples);
 
+        /// @brief Reset the state of the simple averaging-strategy.
+        void Reset(const Point& interpolationPoint) override;
+
         void Add(Point const& samplePoint, double sampleValue) override;
         [[nodiscard]] double Calculate() const override;
 
+        /// @brief Calculates the average value based on the sample values.
+        /// @param[in] interpolationPoint The point for which the average should be calculated.
+        /// @param[in] samplePoints The sample points to used by this strategy.
+        /// @param[in] sampleValues The sample values  associated with each sample point.
+        /// @return The calculated average
+        double Calculate (const Point& interpolationPoint,
+                          const std::vector<Point>& samplePoints,
+                          const std::vector<double>& sampleValues) const override;
+
     private:
         /// @brief The minimum number of points for a valid interpolation.
-        size_t m_minNumPoints;
+        const size_t m_minNumPoints;
 
         /// @brief The current result from which Calculate calculates the final value.
         double m_result = 0.0;