LinearlyInterpolatedCurve.hh

#ifndef GRAIL_LINEARLY_INTERPOLATED_CURVE_H
#define GRAIL_LINEARLY_INTERPOLATED_CURVE_H
 
#include "Curve.hh"
#include "../../libs/vector2/vector2.h"
 
#include <algorithm>
#include <cassert>
 
namespace grail
{
    namespace curves
    {
        template <typename ContextType>
        class LinearlyInterpolatedCurve final : public Curve<ContextType>
        {
        public:
            LinearlyInterpolatedCurve(std::shared_ptr<utility::Evaluator<ContextType>> childEvaluator,
                                      const std::vector<Vector2>& points)
                : Curve<ContextType>{childEvaluator}, points(points)
            {
            }
 
            LinearlyInterpolatedCurve(std::shared_ptr<utility::Evaluator<ContextType>> childEvaluator,
                                      std::vector<Vector2>&& points)
                : Curve<ContextType>{childEvaluator}, points(std::move(points))
            {
            }
 
            virtual float Sample(float argument) const override final
            {
                assert(points.size() > 1);
 
                if(argument < points.front().x)
                {
                    return points.front().y;
                }
                else if(argument > points.back().x)
                {
                    return points.back().y;
                }
 
                auto iter = std::find_if(points.begin(),
                                         points.end(),
                                         [argument](const Vector2& point) { return point.x > argument; });
                size_t secondPointIndex = std::distance(points.begin(), iter);
                Vector2 firstPoint = points[secondPointIndex - 1];
                Vector2 secondPoint = points[secondPointIndex];
 
                float deltaY = secondPoint.y - firstPoint.y;
                float deltaX = secondPoint.x - firstPoint.x;
                return firstPoint.y + deltaY * (argument - firstPoint.x) / deltaX;
            }
 
            void SetPointY(std::size_t pointIndex, float y) { points[pointIndex].y = y; }
 
            std::vector<Vector2>& GetPoints() { return points; }
            const std::vector<Vector2>& GetPoints() const { return points; }
 
            virtual EvaluatorType GetEvaluatorType() const override final
            {
                return EvaluatorType::CURVE_LINEAR_INTERPOLATED;
            }
 
        private:
            std::vector<Vector2> points{};
        };
    }
}
 
#endif // GRAIL_LINEARLY_INTERPOLATED_CURVE_H