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));
        }
        
        virtual void GetDependentConsiderations(std::vector<Consideration<ContextType>*>& considerations) override
        {
            childEvaluator->GetDependentConsiderations(considerations);
        }
 
    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