AAX_CPieceWiseLinearTaperDelegate.h

Go to the documentation of this file.

/*================================================================================================*/
/*
 *
 *  Copyright (c) 2009 Avid Technology, Inc. 
 *  All rights reserved.
 *  
 *  CONFIDENTIAL: This document contains confidential information.  Do not 
 *  read or examine this document unless you are an Avid Technology employee
 *  or have signed a non-disclosure agreement with Avid Technology which protects
 *  the confidentiality of this document.  DO NOT DISCLOSE ANY INFORMATION 
 *  CONTAINED IN THIS DOCUMENT TO ANY THIRD-PARTY WITHOUT THE PRIOR WRITTEN CONSENT 
 *  OF Avid Technolgy, INC.
 *
 */

/*================================================================================================*/


#ifndef AAX_CPIECEWISELINEARTAPERDELEGATE_H
#define AAX_CPIECEWISELINEARTAPERDELEGATE_H

#include "AAX_ITaperDelegate.h"
#include "AAX.h"    //for types

#include <cmath>    //for floor()


template <typename T, int32_t RealPrecision=100>
class AAX_CPieceWiseLinearTaperDelegate : public AAX_ITaperDelegate<T>
{
public: 
    AAX_CPieceWiseLinearTaperDelegate(const double* normalizedValues, const T* realValues, int32_t numValues);
    
    AAX_CPieceWiseLinearTaperDelegate(const AAX_CPieceWiseLinearTaperDelegate& other);  //Explicit copy constructor because there are internal arrays.
    ~AAX_CPieceWiseLinearTaperDelegate();
    
    //Virtual AAX_ITaperDelegate Overrides
    AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>*    Clone() const;
    T       GetMinimumValue()   const                       { return mMinValue; }
    T       GetMaximumValue()   const                       { return mMaxValue; }
    T       ConstrainRealValue(T value) const;
    T       NormalizedToReal(double normalizedValue) const;
    double  RealToNormalized(T realValue) const;
    
protected:
    T   Round(double iValue) const;
    
private:
    double*     mNormalizedValues;
    T*          mRealValues;
    int32_t     mNumValues;
    T           mMinValue;      //Really just an optimization
    T           mMaxValue;      //Really just an optimization
};

template <typename T, int32_t RealPrecision>
T   AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>::Round(double iValue) const
{
    if (RealPrecision > 0)
        return static_cast<T>(floor(iValue * RealPrecision + 0.5) / RealPrecision);
    else
        return static_cast<T>(iValue);
}

template <typename T, int32_t RealPrecision>
AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>::AAX_CPieceWiseLinearTaperDelegate(const double* normalizedValues, const T* realValues, int32_t numValues)  :  AAX_ITaperDelegate<T>(),
    mNormalizedValues(0),
    mRealValues(0),
    mNumValues(0),
    mMinValue(0),
    mMaxValue(0)
{
    mNormalizedValues = new double[numValues];
    mRealValues = new T[numValues];
    mNumValues = numValues;

    if (numValues > 0)
    {
        mMaxValue = realValues[0];
        mMinValue = realValues[0];
    }
    for (int32_t i=0; i< numValues; i++)
    {
        mNormalizedValues[i] = normalizedValues[i];
        mRealValues[i] = realValues[i];
        if (mRealValues[i] > mMaxValue)
            mMaxValue = mRealValues[i];
        if (mRealValues[i] < mMinValue)
            mMinValue = mRealValues[i];
    }
}

template <typename T, int32_t RealPrecision>
AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>::AAX_CPieceWiseLinearTaperDelegate(const AAX_CPieceWiseLinearTaperDelegate& other)  :  AAX_ITaperDelegate<T>(),
    mNormalizedValues(0),
    mRealValues(0),
    mNumValues(0),
    mMinValue(0),
    mMaxValue(0)
{
    mNormalizedValues = new double[other.mNumValues];
    mRealValues = new T[other.mNumValues];
    mNumValues = other.mNumValues;
    mMaxValue = other.mMaxValue;
    mMinValue = other.mMinValue;
    for (int32_t i=0; i< mNumValues; i++)
    {
        mNormalizedValues[i] = other.mNormalizedValues[i];
        mRealValues[i] = other.mRealValues[i];
    }   
}

template <typename T, int32_t RealPrecision>
AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>::~AAX_CPieceWiseLinearTaperDelegate() 
{
    mNumValues = 0;
    delete [] mNormalizedValues; 
    delete [] mRealValues;
}


template <typename T, int32_t RealPrecision>
AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>*        AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>::Clone() const
{
    return new AAX_CPieceWiseLinearTaperDelegate(*this);
}

template <typename T, int32_t RealPrecision>
T       AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>::ConstrainRealValue(T value)    const
{
    if (RealPrecision)
        value = Round(value);       //reduce the precision to get proper rounding behavior with integers.
    
    if (value > mMaxValue)
        return mMaxValue;
    if (value < mMinValue)
        return mMinValue;
    return value;       
}

template <typename T, int32_t RealPrecision>
T       AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>::NormalizedToReal(double normalizedValue) const
{

    // Clip to normalized range.
    if (normalizedValue > 1.0)
        normalizedValue = 1.0;
    if (normalizedValue < 0.0)
        normalizedValue = 0.0;
    
    // This is basically linear interpolation so let's first find the bounding normalized points from our specified array.
    int32_t mLowerIndex = 0;
    int32_t mUpperIndex = 0;
    for (int32_t i=1;i<mNumValues;i++)
    {
        mUpperIndex++;
        if (mNormalizedValues[i] >= normalizedValue)
            break;
        mLowerIndex++;
    }
    
    // Do the interpolation.
    double delta = normalizedValue - mNormalizedValues[mLowerIndex];
    double slope = double(mRealValues[mUpperIndex] - mRealValues[mLowerIndex]) / (mNormalizedValues[mUpperIndex] - mNormalizedValues[mLowerIndex]);
    double interpolatedValue = mRealValues[mLowerIndex] + (delta * slope);                                                                                                                          
    return ConstrainRealValue(static_cast<T>(interpolatedValue));
}

template <typename T, int32_t RealPrecision>
double  AAX_CPieceWiseLinearTaperDelegate<T, RealPrecision>::RealToNormalized(T realValue) const
{
    realValue = ConstrainRealValue(realValue);
    
    // This is basically linear interpolation so let's first find the bounding normalized points from our specified array.
    int32_t mLowerIndex = 0;
    int32_t mUpperIndex = 0;
    if (mRealValues[0] < mRealValues[mNumValues-1])
    {
        //Increasing real values (positive slope)
        for (int32_t i=1;i<mNumValues;i++)
        {
            mUpperIndex++;
            if (mRealValues[i] >= realValue)
                break;
            mLowerIndex++;
        }
    }
    else 
    {
        //Decreasing real values (negative slope)
        for (int32_t i=1;i<mNumValues;i++)
        {
            mUpperIndex++;
            if (mRealValues[i] <= realValue)
                break;
            mLowerIndex++;
        }       
    }
    
    // Do the interpolation.
    double delta = realValue - mRealValues[mLowerIndex];
    double slope = double(mNormalizedValues[mUpperIndex] - mNormalizedValues[mLowerIndex]) / (mRealValues[mUpperIndex] - mRealValues[mLowerIndex]);
    double interpolatedValue = mNormalizedValues[mLowerIndex] + (delta * slope);                                                                                                                            
    return static_cast<T>(interpolatedValue);
}




#endif //AAX_CPIECEWISELINEARTAPERDELEGATE_H