datamodels1d.h

Go to the documentation of this file.

#ifndef CTL_DATAMODELS1D_H
#define CTL_DATAMODELS1D_H

#include "abstractdatamodel.h"
#include <cfloat>

namespace CTL {

class SaturatedLinearModel : public AbstractIntegrableDataModel
{
    CTL_TYPE_ID(10)

    public: float valueAt(float position) const override;
    public: float binIntegral(float position, float binWidth) const override;
    public: AbstractIntegrableDataModel* clone() const override;

public:
    explicit SaturatedLinearModel(float lowerCap = 0.0f, float upperCap = FLT_MAX);

    QVariant parameter() const override;
    void setParameter(const QVariant& parameter) override;

private:
    float _a = 0.0f;    
    float _b = FLT_MAX; 

    void setParFromList(const QVariantList& list);
    void setParFromMap(const QVariantMap& map);
};

class SaturatedSplineModel : public AbstractDataModel
{
    CTL_TYPE_ID(20)

    public: float valueAt(float position) const override;
    public: AbstractDataModel* clone() const override;

public:
    explicit SaturatedSplineModel(float lowerCap = 0.0f, float upperCap = FLT_MAX, float softening = 0.0f);
    SaturatedSplineModel(float lowerCap, float upperCap, float softLower, float softUpper);

    QVariant parameter() const override;
    void setParameter(const QVariant& parameter) override;

private:
    float _a = 0.0f;     
    float _b = FLT_MAX;  
    float _softA = 0.0f; 
    float _softB = 0.0f; 

    void setParFromList(const QVariantList& list);
    void setParFromMap(const QVariantMap& map);

    float spline1(float x) const;
    float spline2(float x) const;
};


// ####################################
// Step functions & other simple models
// ####################################

/*
 * All step functions are implemented with left-closed and right-open intervals,
 * i.e. they are piecewise constant on intervals of the form [a,b).
 * This allows seamless compositions of these models.
 */

class StepFunctionModel : public AbstractIntegrableDataModel
{
    CTL_TYPE_ID(50)

    public: float valueAt(float position) const override;
    public: float binIntegral(float position, float binWidth) const override;
    public: AbstractIntegrableDataModel* clone() const override;

public:
    enum StepDirection{ RightIsZero = 0, Downwards = 0, LeftIsZero = 1, Upwards = 1 };

    explicit StepFunctionModel(float threshold = 0.0f, float amplitude = 1.0f, StepDirection stepDirection = LeftIsZero);

    QVariant parameter() const override;
    void setParameter(const QVariant& parameter) override;

private:
    float _threshold;
    float _amplitude;
    StepDirection _stepDirection;
};

class ConstantModel : public AbstractIntegrableDataModel
{
    CTL_TYPE_ID(51)

    public: float valueAt(float position) const override;
    public: float binIntegral(float position, float binWidth) const override;
    public: AbstractIntegrableDataModel* clone() const override;

public:
    explicit ConstantModel(float amplitude = 1.0f);

    QVariant parameter() const override;
    void setParameter(const QVariant& parameter) override;

private:
    float _amplitude;
};

class RectFunctionModel : public AbstractDataModel
{
    CTL_TYPE_ID(52)

    public: float valueAt(float position) const override;
    public: AbstractDataModel* clone() const override;

public:
    explicit RectFunctionModel(float rectBegin = -0.5f, float rectEnd = 0.5f, float amplitude = 1.0f);

    QVariant parameter() const override;
    void setParameter(const QVariant& parameter) override;

private:
    float _rectBegin;
    float _rectEnd;
    float _amplitude;
};

class IdentityModel : public AbstractIntegrableDataModel
{
    CTL_TYPE_ID(53)

    public: float valueAt(float position) const override;
    public: float binIntegral(float position, float binWidth) const override;
    public: AbstractIntegrableDataModel* clone() const override;

public:
    IdentityModel();
};

class GaussianModel1D : public AbstractIntegrableDataModel
{
    CTL_TYPE_ID(54)

    // AbstractDataModel2D interface
    public: float valueAt(float position) const override;
    public: float binIntegral(float position, float binWidth) const override;
    public: AbstractIntegrableDataModel* clone() const override;

public:
    explicit GaussianModel1D(float amplitude = 1.0f, float mean = 0.0f, float std = 1.0f);

    // SerializationInterface interface
    QVariant toVariant() const override;
    QVariant parameter() const override;
    void setParameter(const QVariant& parameter) override;

private:
    float _ampl = 1.0f;
    float _mean = 0.0f;
    float _std = 1.0f;
};

// typedefs
typedef SaturatedLinearModel DetectorSaturationLinearModel;
typedef SaturatedSplineModel DetectorSaturationSplineModel;

} // namespace CTL



#endif // CTL_DATAMODELS1D_H