Smoothers.cpp

Go to the documentation of this file.

#include "Smoothers.h"
 
template <typename T>
int TSmoother<T>::getSmootherType()
{
  if (std::is_same<T, float>::value)
    return SMOOTHER_TYPE_FLOAT;
  else if (std::is_same<T, Vector2>::value)
    return SMOOTHER_TYPE_VEC2;
  else if (std::is_same<T, Vector3>::value)
    return SMOOTHER_TYPE_VEC3;
  return SMOOTHER_TYPE_UNDEFINED;
}
 
// Linear Smoothing
// Constructor
template <typename T>
LinearSmoother<T>::LinearSmoother(float factor)
{
  mFactor = factor;
  initialized = false;
  value = T();
}
 
template <typename T>
void LinearSmoother<T>::setSmoothingFactor(float factor)
{
  mFactor = factor;
}
 
// Extrapolate
template <typename T>
T LinearSmoother<T>::getExtrapolatedValue()
{
  return value;
}
 
// Smooth
template <typename T>
T LinearSmoother<T>::getSmoothedValue()
{
  return value;
}
 
// Internal compute
template <typename T>
void LinearSmoother<T>::pushValue(T val)
{
  if (!initialized)
  {
    value = val;
    initialized = true;
    return;
  }
 
  T lastValue = value;
  value = mFactor * val + (1.0f - mFactor) * lastValue;
}
 
// Smoother method SMOOTHER_METHOD_LINEAR
template <typename T>
int LinearSmoother<T>::getSmootherMethod()
{
  return SMOOTHER_METHOD_LINEAR;
}
 
template <typename T>
void LinearSmoother<T>::clearValues()
{
  initialized = false;
}
 
// Double Exponential Smoothing
// Constructor
template <typename T>
DoubleExponentialSmoother<T>::DoubleExponentialSmoother(float alpha, float beta)
{
  mAlpha = alpha;
  mBeta = beta;
  value = T();
  slope = T();
  init = false;
}
 
template <typename T>
void DoubleExponentialSmoother<T>::setSmoothingFactor(float alpha, float beta)
{
  mAlpha = alpha;
  mBeta = beta;
}
 
// Extrapolate
template <typename T>
T DoubleExponentialSmoother<T>::getExtrapolatedValue()
{
  return value + slope;
}
 
// Smooth
template <typename T>
T DoubleExponentialSmoother<T>::getSmoothedValue()
{
  return value;
}
 
// Internal compute
template <typename T>
void DoubleExponentialSmoother<T>::pushValue(T val)
{
  if (!init)
  {
    slope = T();
    value = val;
    init = true;
    return;
  }
 
  T lastValue = value;
  value = (mAlpha * val) + ((1.0f - mAlpha) * (value + slope));
  slope = (mBeta * (value - lastValue)) + ((1.0f - mBeta) * slope);
}
 
// Smoother method SMOOTHER_METHOD_DOUBLEEXP
template <typename T>
int DoubleExponentialSmoother<T>::getSmootherMethod()
{
  return SMOOTHER_METHOD_DOUBLEEXP;
}
 
template <typename T>
void DoubleExponentialSmoother<T>::clearValues()
{
  init = false;
}
 
// Force compile for float, Vector2, Vector3
template class DoubleExponentialSmoother < float > ;
template class DoubleExponentialSmoother < Vector2 >;
template class DoubleExponentialSmoother < Vector3 >;
 
template class LinearSmoother < float >;
template class LinearSmoother < Vector2 >;
template class LinearSmoother < Vector3 >;