Curve.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_CURVE_H
#define GRAIL_CURVE_H
 
#include "../Evaluator.hh"
#include "../../libs/vector2/vector2.h"
 
#include <utility>
#include <vector>
 
namespace grail
{
namespace evaluator
{
 template <typename ContextType>
 class Curve : public Evaluator<ContextType>
 {
 public:
 explicit Curve(std::shared_ptr<Evaluator<ContextType>> childEvaluator)
 : childEvaluator{childEvaluator}
 {
 }
 
 Curve(const Curve<ContextType>& other) = default;
 Curve(Curve<ContextType>&& other) = default;
 virtual ~Curve() = default;
 
 virtual float Sample(float argument) const = 0;
 
 virtual float
 Evaluate(const ContextType& context, data::UtilityEvaluatorSnapshot* const snapshot) const override final
 {
 return Sample(childEvaluator->EvaluateContext(context, snapshot));
 }
 
 protected:
 virtual void DebugDump(const std::map<const void*, unsigned int>& nodeMapping,
 data::EvaluationDebugData& debugData) const override final
 {
 debugData.AddChildNode(nodeMapping.at(childEvaluator.get()));
 }
 
 private:
 std::shared_ptr<Evaluator<ContextType>> childEvaluator{};
 };
 
 template <typename ContextType>
 class LowerBound final : public Curve<ContextType>
 {
 public:
 LowerBound(std::shared_ptr<Evaluator<ContextType>> childEvaluator, float lowerBound)
 : Curve<ContextType>(childEvaluator), lowerBound{lowerBound}
 {
 }
 
 virtual float Sample(float argument) const override final
 {
 return std::max(lowerBound, argument);
 }
 
 virtual data::EvaluatorType GetEvaluatorType() const override final { return data::EvaluatorType::CURVE_LOWER_BOUND; }
 
 private:
 float lowerBound = 0.0f;
 };
 
 template <typename ContextType>
 class UpperBound final : public Curve<ContextType>
 {
 public:
 UpperBound(std::shared_ptr<Evaluator<ContextType>> childEvaluator, float upperBound)
 : Curve<ContextType>(childEvaluator), upperBound{upperBound}
 {
 }
 
 virtual float Sample(float argument) const override final
 {
 return std::min(upperBound, argument);
 }
 
 virtual data::EvaluatorType GetEvaluatorType() const override final { return data::EvaluatorType::CURVE_UPPER_BOUND; }
 
 private:
 float upperBound = 0.0f;
 };
 
 template <typename ContextType>
 class DoubleSidedBound final : public Curve<ContextType>
 {
 public:
 DoubleSidedBound(std::shared_ptr<Evaluator<ContextType>> childEvaluator,
 float lowerBound,
 float upperBound)
 : Curve<ContextType>{childEvaluator}, lowerBound{lowerBound}, upperBound{upperBound}
 {
 }
 
 virtual float Sample(float argument) const override final
 {
 return std::min(upperBound, std::max(lowerBound, argument));
 }
 
 virtual data::EvaluatorType GetEvaluatorType() const override final
 {
 return data::EvaluatorType::CURVE_DOUBLE_SIDED_BOUND;
 }
 
 private:
 float lowerBound = 0.0f;
 float upperBound = 0.0f;
 };
 
 template <typename ContextType>
 std::vector<Vector2> DiscretizeCurve(const Curve<ContextType>& curve, std::size_t samplesQuantity)
 {
 std::vector<Vector2> controlPoints;
 float increment = 1.0f / (samplesQuantity - 1);
 for(float i = 0; i <= 1; i += increment)
 {
 controlPoints.push_back({i, curve.Sample(i)});
 }
 return controlPoints;
 }
}
}
#endif //GRAIL_CURVE_H