AAX_CRangeTaperDelegate.h

Go to the documentation of this file.

/*================================================================================================*/
/*
 *
 *  Copyright 2013 by 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_CRANGETAPERDELEGATE_H
#define AAX_CRANGETAPERDELEGATE_H

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

#include <cmath>    //for floor()
#include <vector>


template <typename T, int32_t RealPrecision=1000>
class AAX_CRangeTaperDelegate : public AAX_ITaperDelegate<T>
{
public: 
    AAX_CRangeTaperDelegate(T* range, double* rangesSteps, long numRanges, bool useSmartRounding = true);
    AAX_CRangeTaperDelegate( const AAX_CRangeTaperDelegate& rhs);
    AAX_CRangeTaperDelegate& operator=( AAX_CRangeTaperDelegate& rhs );

    //Virtual Overrides
    AAX_CRangeTaperDelegate<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;
    T   SmartRound(double value) const;     

private:
    T       mMinValue;
    T       mMaxValue;
    long    mNumRanges;
    std::vector<T> mRanges;
    std::vector<double> mRangesSteps;       
    std::vector<double> mRangesPercents;    
    std::vector<double> mRangesStepsCount;  
    bool    mUseSmartRounding;
};

template <typename T, int32_t RealPrecision>
AAX_CRangeTaperDelegate<T, RealPrecision>::AAX_CRangeTaperDelegate(T* ranges, double* rangesSteps, long numRanges, bool useSmartRounding) :
    AAX_ITaperDelegate<T>(),
    mMinValue(*ranges), 
    mMaxValue(*(ranges + numRanges)),
    mNumRanges(numRanges),
    mRanges( ranges, ranges + numRanges + 1),
    mRangesSteps( rangesSteps, rangesSteps + numRanges),
    mUseSmartRounding( useSmartRounding )
{
    mRangesStepsCount.reserve(numRanges);
    mRangesPercents.reserve(numRanges);
    int i = 0;
    for (; i < mNumRanges; i++)
    {
        mRangesStepsCount.push_back( (mRanges.at(i + 1) - mRanges.at(i)) / mRangesSteps.at(i));
    }
    double numSteps = 0;
    for (i = 0; i < mNumRanges; i++)
    {
        numSteps += mRangesStepsCount.at(i);
    }
    for (i = 0; i < mNumRanges; i++)
    {
        mRangesPercents.push_back( mRangesStepsCount.at(i) / numSteps );
    }
}

template <typename T, int32_t RealPrecision>
AAX_CRangeTaperDelegate<T, RealPrecision>::AAX_CRangeTaperDelegate( const AAX_CRangeTaperDelegate<T, RealPrecision>& rhs) :
    mMinValue(rhs.mMinValue),
    mMaxValue(rhs.mMaxValue),
    mNumRanges(rhs.mNumRanges),
    mRanges( rhs.mRanges.begin(), rhs.mRanges.end()),
    mRangesSteps( rhs.mRangesSteps.begin(), rhs.mRangesSteps.end()),
    mRangesPercents( rhs.mRangesPercents.begin(), rhs.mRangesPercents.end()),
    mRangesStepsCount( rhs.mRangesStepsCount.begin(), rhs.mRangesStepsCount.end()),
    mUseSmartRounding( rhs.mUseSmartRounding )
{
}

template <typename T, int32_t RealPrecision>
AAX_CRangeTaperDelegate<T, RealPrecision>& AAX_CRangeTaperDelegate<T, RealPrecision>::operator=( AAX_CRangeTaperDelegate<T, RealPrecision>& rhs)
{
    if (this == &rhs)
        return *this;

    this->mMinValue = rhs.mMinValue;
    this->mMaxValue = rhs.mMaxValue;
    this->mNumRanges = rhs.mNumRanges;
    this->mRanges.assign( rhs.mRanges.begin(), rhs.mRanges.end());
    this->mRangesSteps.assign( rhs.mRangesSteps.begin(), rhs.mRangesSteps.end());
    this->mRangesPercents.assign( rhs.mRangesPercents.begin(), rhs.mRangesPercents.end());
    this->mRangesStepsCount.assign( rhs.mRangesStepsCount.begin(), rhs.mRangesStepsCount.end());

    return *this;
}

template <typename T, int32_t RealPrecision>
T   AAX_CRangeTaperDelegate<T, RealPrecision>::Round(double iValue) const
{
    return ((0 >= RealPrecision) ?  static_cast<T>(iValue) :
            (0 <= iValue) ?         floor( iValue*RealPrecision + 0.5f ) / RealPrecision :
                                    ceil( iValue*RealPrecision - 0.5f ) / RealPrecision
            );
}

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

template <typename T, int32_t RealPrecision>
T       AAX_CRangeTaperDelegate<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_CRangeTaperDelegate<T, RealPrecision>::NormalizedToReal(double normalizedValue)     const
{
    double percentTotal = normalizedValue;

    double percent = 0.0;
    long i = 0;
    for (; i < mNumRanges; i++)
    {
        if ((percentTotal >= percent) && (percentTotal < (percent + mRangesPercents.at( i ) )))
            break;
        percent += mRangesPercents.at( i );
    }

    double extValue;
    if (i == mNumRanges)
        extValue = mMaxValue;   // our control is 100% of maximum
    else
        extValue = mRanges.at(i) + ((mRanges.at(i+1) - mRanges.at(i))*(percentTotal - percent)) / (mRangesPercents.at(i));

    T realValue = T(extValue);
    if ( mUseSmartRounding )
        realValue = SmartRound(extValue);       //reduce the precision to get proper rounding behavior with integers.

    return ConstrainRealValue(realValue);
}

template <typename T, int32_t RealPrecision>
double  AAX_CRangeTaperDelegate<T, RealPrecision>::RealToNormalized(T realValue)    const
{
    realValue = ConstrainRealValue(realValue);

    double percentTotal = 0.0;
    long i = 0;
    for (; i < mNumRanges; i++)
    {
        if ((realValue >= mRanges[i]) && (realValue < mRanges[i+1]))
            break;
        percentTotal += mRangesPercents[i];
    }

    if (i == mNumRanges)
        percentTotal = 1.0;     // our control is 100% of maximum
    else
        percentTotal += (realValue - mRanges.at(i))/(mRanges.at(i + 1) - mRanges.at(i)) * mRangesPercents.at(i);

    double normalizedValue = percentTotal;
    return normalizedValue;
}

template <typename T, int32_t RealPrecision>
T   AAX_CRangeTaperDelegate<T, RealPrecision>::SmartRound(double value) const
{
    int32_t i = 0;
    for (; i < mNumRanges; i++)
    {
        if ((value >= mRanges.at(i)) && (value < mRanges.at(i + 1) ))
            break;
        if ( i == mNumRanges - 1 )
            break;
    }

    int32_t longVal = 0;
    if (value >= 0)
        longVal = int32_t(floor(value / mRangesSteps.at(i) + 0.5));
    else
        longVal = int32_t(ceil(value / mRangesSteps.at(i) - 0.5));

    return static_cast<double>(longVal) * mRangesSteps.at(i);
}


#endif AAX_CRANGETAPERDELEGATE_H