TSplineGridFunctionBase.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// ACF includes
#include <istd/TArray.h>
#include <imath/TVector.h>
#include <imath/TFulcrumGridFunctionBase.h>
#include <imath/CSplineSegmentFunction.h>
 
 
namespace imath
{
 
 
template <class Argument, class Result, class Fulcrums, class Degree>
class TSplineGridFunctionBase: public TFulcrumGridFunctionBase<Argument, Result, Fulcrums>
{
public:
       typedef TFulcrumGridFunctionBase<Argument, Result, Fulcrums> BaseClass;
 
       typedef Degree DerivativeDegreeType;
 
       // reimplemented (imath::TIMathFunction<Argument, Result>)
       virtual bool GetValueAt(const Argument& argument, Result& result) const override;
       virtual Result GetValueAt(const Argument& argument) const override;
 
protected:
       void CumulateRecursiveValueAt(
                            const Argument& argument,
                            int dimension,
                            const typename BaseClass::FulcrumSizes& sizes,
                            typename BaseClass::FulcrumIndex& index,
                            DerivativeDegreeType& degree,
                            double cumulationFactor,
                            Result& result) const;
 
       // abstract methods
       virtual const typename BaseClass::ResultType& GetFulcrumDerivativeAtIndex(
                            const typename BaseClass::FulcrumIndex& index,
                            const DerivativeDegreeType& degree) const = 0;
 
       virtual bool IsDerivativeDegreeSupported(const DerivativeDegreeType& degree) const = 0;
};
 
 
// public methods
 
// reimplemented (imath::TIMathFunction<Argument, Result>)
 
template <class Argument, class Result, class Fulcrums, class Degree>
bool TSplineGridFunctionBase<Argument, Result, Fulcrums, Degree>::GetValueAt(const Argument& argument, Result& result) const
{
       result.Clear();
 
       if (BaseClass::EnsureCacheValid()){
              typename BaseClass::FulcrumIndex index = this->FindIndices(argument);
 
              typename BaseClass::FulcrumSizes gridSize = BaseClass::GetGridSize();
 
              if (index.IsInside(gridSize)){
                     int dimensionsCount = BaseClass::GetDimensionsCount();
                     Degree degree;
                     degree.SetDimensionsCount(dimensionsCount);
 
                     CumulateRecursiveValueAt(argument, dimensionsCount - 1, gridSize, index, degree, 1.0, result);
 
                     return true;
              }
       }
 
       return false;
}
 
 
template <class Argument, class Result, class Fulcrums, class Degree>
Result TSplineGridFunctionBase<Argument, Result, Fulcrums, Degree>::GetValueAt(const Argument& argument) const
{
       typename BaseClass::ResultType retVal;
 
       GetValueAt(argument, retVal);
 
       return retVal;
}
 
 
// protected methods
 
template <class Argument, class Result, class Fulcrums, class Degree>
void TSplineGridFunctionBase<Argument, Result, Fulcrums, Degree>::CumulateRecursiveValueAt(
                     const Argument& argument,
                     int dimension,
                     const typename BaseClass::FulcrumSizes& sizes,
                     typename BaseClass::FulcrumIndex& index,
                     DerivativeDegreeType& derivativeDegree,
                     double cumulationFactor,
                     Result& result) const
{
       Q_ASSERT(dimension < BaseClass::GetDimensionsCount());
       Q_ASSERT(sizes.GetDimensionsCount() == BaseClass::GetDimensionsCount());
       Q_ASSERT(index.GetDimensionsCount() == BaseClass::GetDimensionsCount());
 
       if (dimension < 0){
              result.ScaledCumulate(GetFulcrumDerivativeAtIndex(index, derivativeDegree), cumulationFactor);
 
              return;
       }
 
       int& indexElement = index[dimension];
 
       if (indexElement >= 0){
              if (indexElement < sizes[dimension] - 1){
                     double firstPosition = BaseClass::GetLayerPosition(dimension, indexElement);
                     double secondPosition = BaseClass::GetLayerPosition(dimension, indexElement + 1);
                     double layersDistance = secondPosition - firstPosition;
                     Q_ASSERT(layersDistance >= 0);
                     Q_ASSERT(argument[dimension] >= firstPosition);
                     Q_ASSERT(argument[dimension] <= secondPosition);
                     Q_ASSERT(derivativeDegree[dimension] == 0);
 
                     bool useDerivative = false;
                     if (derivativeDegree.IncreaseAt(dimension)){
                            useDerivative = IsDerivativeDegreeSupported(derivativeDegree);
                            derivativeDegree.DecreaseAt(dimension);
                     }
 
                     double alpha = (argument[dimension] - firstPosition) / layersDistance;
 
                     double firstValueFactor = useDerivative? CSplineSegmentFunction::GetValueKernelAt(alpha): (1 - alpha);   // use linear interpolation if no derivative is available
                     if (firstValueFactor > I_BIG_EPSILON){
                            CumulateRecursiveValueAt(
                                                 argument,
                                                 dimension - 1,
                                                 sizes,
                                                 index,
                                                 derivativeDegree,
                                                 cumulationFactor * firstValueFactor,
                                                 result);
                     }
 
                     double secondValueFactor = useDerivative? CSplineSegmentFunction::GetValueKernelAt(1.0 - alpha): alpha;  // use linear interpolation if no derivative is available
 
                     if (secondValueFactor > I_BIG_EPSILON){
                            ++indexElement;
                            CumulateRecursiveValueAt(
                                                 argument,
                                                 dimension - 1,
                                                 sizes,
                                                 index,
                                                 derivativeDegree,
                                                 cumulationFactor * secondValueFactor,
                                                 result);
                            --indexElement;
                     }
 
                     if (useDerivative){
                            derivativeDegree.IncreaseAt(dimension);
 
                            double firstDerivativeFactor = CSplineSegmentFunction::GetDerivativeKernelAt(alpha) * layersDistance;
                            if (firstDerivativeFactor > I_BIG_EPSILON){
                                   CumulateRecursiveValueAt(
                                                        argument,
                                                        dimension - 1,
                                                        sizes,
                                                        index,
                                                        derivativeDegree,
                                                        cumulationFactor * firstDerivativeFactor,
                                                        result);
                            }
 
                            ++indexElement;
 
                            double secondDerivativeFactor = -CSplineSegmentFunction::GetDerivativeKernelAt(1.0 - alpha) * layersDistance;
                            if (secondDerivativeFactor < -I_BIG_EPSILON){
                                   CumulateRecursiveValueAt(
                                                        argument,
                                                        dimension - 1,
                                                        sizes,
                                                        index,
                                                        derivativeDegree,
                                                        cumulationFactor * secondDerivativeFactor,
                                                        result);
                            }
 
                            --indexElement;
 
                            derivativeDegree.DecreaseAt(dimension);
                     }
              }
              else{
                     // element out of boundaries at this dimension
                     Q_ASSERT(indexElement == sizes[dimension] - 1);
 
                     CumulateRecursiveValueAt(
                                          argument,
                                          dimension - 1,
                                          sizes,
                                          index,
                                          derivativeDegree,
                                          cumulationFactor,
                                          result);
              }
       }
       else{
              // element out of boundaries at this dimension
              Q_ASSERT(indexElement == -1);
 
              ++indexElement;
              CumulateRecursiveValueAt(
                                   argument,
                                   dimension - 1,
                                   sizes,
                                   index,
                                   derivativeDegree,
                                   cumulationFactor,
                                   result);
              --indexElement;
       }
}
 
 
} // namespace imath