The SaturatedSplineModel is a data model to map values according to a dependency composed of a linear central segment and a fade in/out from/to a constant level by quadratic splines. More...

#include <datamodels1d.h>

Inheritance diagram for CTL::SaturatedSplineModel:

[legend]

Collaboration diagram for CTL::SaturatedSplineModel:

[legend]

Public Types
enum	{ Type = 20 }

Public Types inherited from CTL::AbstractDataModel
enum	{ Type = 0 }

Public Types inherited from CTL::SerializationInterface
enum	{ Type = -1, UserType = 65536 }

Public Member Functions
int	type () const override

float	valueAt (float position) const override

AbstractDataModel *	clone () const override

	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

Public Member Functions inherited from CTL::AbstractDataModel
void	fromVariant (const QVariant &variant) override

QVariant	toVariant () const override

bool	isIntegrable () const

void	setName (const QString &name)

const QString &	name () const

Public Member Functions inherited from CTL::SerializationInterface
virtual	~SerializationInterface ()=default

Private Member Functions
void	setParFromList (const QVariantList &list)

void	setParFromMap (const QVariantMap &map)

float	spline1 (float x) const

float	spline2 (float x) const

Private Attributes
float	_a = 0.0f
	lower saturation level

float	_b = FLT_MAX
	upper saturation level

float	_softA = 0.0f
	softening margin of lower saturation

float	_softB = 0.0f
	softening margin of upper saturation

Friends
template<class >
struct	SerializationHelper::RegisterWithSerializationHelper

Related Functions
(Note that these are not member functions.)

	DetectorSaturationSplineModel
	Alias for SaturatedSplineModel used here to map true (or expected) values to actually measured values.

Related Functions inherited from CTL::AbstractDataModel
	DataModelPtr
	Template alias name for CopyableUniquePtr<ModelType> to a suitable ModelType.

	AbstractDataModelPtr
	Alias name for DataModelPtr<AbstractDataModel>. More...

std::unique_ptr< ModelType >	makeDataModel (ConstructorArguments &&... arguments)

using DataModelPtr	CopyableUniquePtr
	Alias name for CopyableUniquePtr<ModelType> to a suitable ModelType.

Additional Inherited Members
Protected Member Functions inherited from CTL::AbstractDataModel
	AbstractDataModel (const AbstractDataModel &)=default

	AbstractDataModel (AbstractDataModel &&)=default

AbstractDataModel &	operator= (const AbstractDataModel &)=default

AbstractDataModel &	operator= (AbstractDataModel &&)=default

Protected Member Functions inherited from CTL::SerializationInterface
	SerializationInterface ()=default

	SerializationInterface (const SerializationInterface &)=default

	SerializationInterface (SerializationInterface &&)=default

SerializationInterface &	operator= (const SerializationInterface &)=default

SerializationInterface &	operator= (SerializationInterface &&)=default

Detailed Description

The SaturatedSplineModel is a data model to map values according to a dependency composed of a linear central segment and a fade in/out from/to a constant level by quadratic splines.

The model is defined by four parameters:

lower saturation level \( a \)
upper saturation level \( b \)
softness of lower transition \( s_a \)
softness of upper transition \( s_b \)

This is illustrated in the following figure.

Illustration of a SaturatedSplineModel with parameters (2, 8, 0.5, 2)

See also: DetectorSaturationSplineModel

Constructor & Destructor Documentation

◆ SaturatedSplineModel() [1/2]

CTL::SaturatedSplineModel::SaturatedSplineModel	(	float	lowerCap = `0.0f`,
		float	upperCap = `FLT_MAX`,
		float	softening = `0.0f`
	)

explicit

Constructs a SaturatedSplineModel with (lower/upper) saturation levels at lowerCap and upperCap and equally sized softening margins \( s_{a}=s_{b}=softening \).

◆ SaturatedSplineModel() [2/2]

CTL::SaturatedSplineModel::SaturatedSplineModel	(	float	lowerCap,
		float	upperCap,
		float	softLower,
		float	softUpper
	)

Constructs a SaturatedSplineModel with (lower/upper) saturation levels at lowerCap and upperCap. Softening margins around the saturation levels are set to softLower and softUpper, respectively.

Member Function Documentation

◆ clone()

AbstractDataModel * CTL::SaturatedSplineModel::clone ( ) const

overridevirtual

Creates a copy of this instance and returns a base class pointer to the new object.

Implements CTL::AbstractDataModel.

◆ parameter()

QVariant CTL::SaturatedSplineModel::parameter ( ) const

overridevirtual

Returns the parameters of this instance as QVariant.

This returns a QVariantMap with four key-value-pairs: ("a", a), ("b", b), ("softA", \( s_a \)), ("softB", \( s_b \)). Here, a and b denote the lower and upper saturation level, respectively, and \( s_a \) and \( s_b \) are the softening margins of the transitions to/from the linear regime.

Reimplemented from CTL::AbstractDataModel.

◆ setParameter()

void CTL::SaturatedSplineModel::setParameter ( const QVariant & parameter )

overridevirtual

Sets the parameters of this instance based on the passed QVariant parameter.

Parameters can be passed by either of the following two options:

As a QVariantMap with four key-value-pairs: ("a", a), ("b", b), ("softA", \( s_a \)), ("softB", \( s_b \)). In this case, a and b denote the lower and upper saturation level and \( s_a \) and \( s_b \) specify the softening margins of the transitions to/from the linear regime.
As a QVariantList: In this case, the list must contain four floating point values sorted in the following order: a, b, \( s_a \), \( s_b \).

Example:

SaturatedSplineModel splineModel;
// option 1
QVariantMap parameterMap;
parameterMap.insert("a", 1.0f);
parameterMap.insert("b", 5.0f);
parameterMap.insert("softA", 0.2f);
parameterMap.insert("softB", 0.5f);
splineModel.setParameter(parameterMap);
// option 1 - alternative way
splineModel.setParameter(QVariantMap{ {"a", 1.0f},
                                      {"b", 5.0f},
                                      {"softA", 0.2f},
                                      {"softB", 0.5f} });
// option 2
splineModel.setParameter(QVariantList{1.0f, 5.0f, 0.2f, 0.5f});

Reimplemented from CTL::AbstractDataModel.

◆ setParFromList()

void CTL::SaturatedSplineModel::setParFromList ( const QVariantList & list )

private

Helper method for setParameter().

◆ setParFromMap()

void CTL::SaturatedSplineModel::setParFromMap ( const QVariantMap & map )

private

Helper method for setParameter().

◆ spline1()

float CTL::SaturatedSplineModel::spline1 ( float x ) const

private

Helper method for valueAt().

◆ spline2()

float CTL::SaturatedSplineModel::spline2 ( float x ) const

private

Helper method for valueAt().

◆ type()

int CTL::SaturatedSplineModel::type ( ) const

inlineoverridevirtual

Returns the type id of this instance.

Reimplemented from CTL::AbstractDataModel.

◆ valueAt()

float CTL::SaturatedSplineModel::valueAt ( float position ) const

overridevirtual

Returns the value from the model at position.

\( f(x)=\begin{cases} a & x<a-s_{a}\\ S_{1}(x) & a-s_{a}\leq x<a+s_{a}\\ x & a+s_{a}\leq x<b-s_{b}\\ S_{2}(x) & b-s_{b}\leq x<b+s_{b}\\ b & x\geq b \end{cases} \)

With: \( \begin{align*} S_{1}(x) & =\frac{1}{4s_{a}}x^{2}-\frac{a-s_{a}}{2s_{a}}x+\frac{(a+s_{a})^{2}}{4s_{a}}\\ S_{2}(x) & =-\frac{1}{4s_{b}}x^{2}+\frac{b+s_{b}}{2s_{b}}x+\frac{(b-s_{b})^{2}}{4s_{b}} \end{align*} \)

Implements CTL::AbstractDataModel.

The documentation for this class was generated from the following files:

modules/src/models/datamodels1d.h
modules/src/models/datamodels1d.cpp

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Friends

Related Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SaturatedSplineModel() [1/2]

◆ SaturatedSplineModel() [2/2]

Member Function Documentation

◆ clone()

◆ parameter()

◆ setParameter()

◆ setParFromList()

◆ setParFromMap()

◆ spline1()

◆ spline2()

◆ type()

◆ valueAt()