LinearlyInterpolatedCurve.hh

// Copyright QED Software 2023.
 
#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 evaluator
{
 template <typename ContextType>
 class LinearlyInterpolatedCurve final : public Curve<ContextType>
 {
 public:
 LinearlyInterpolatedCurve(std::shared_ptr<Evaluator<ContextType>> childEvaluator,
 const std::vector<Vector2>& points)
 : Curve<ContextType>{childEvaluator}, points(points)
 {
 }
 
 LinearlyInterpolatedCurve(std::shared_ptr<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 data::EvaluatorType GetEvaluatorType() const override final
 {
 return data::EvaluatorType::CURVE_LINEAR_INTERPOLATED;
 }
 
 private:
 std::vector<Vector2> points{};
 };
}
}
 
#endif // GRAIL_LINEARLY_INTERPOLATED_CURVE_H