ExtremaUtils.h

Go to the documentation of this file.

// ExtremaUtils.h:
// ---------------
//

#ifndef __IPSDKMATH_EXTREMAUTILS_H__
#define __IPSDKMATH_EXTREMAUTILS_H__

#include <IPSDKMath/IPSDKMathExports.h>
#include <IPSDKMath/Statistics/ExtremaTypes.h>
#include <boost/bind.hpp>
#include <boost/function.hpp>

namespace ipsdk {
namespace math {


template <typename T,
          typename IndexType>
IPSDKMATH_API void
findLocalStrictExtrema(const std::vector<T>& inputColl,
                       const eExtremaBorderPolicy& extremaBorderPolicy,
                       const eExtremaType& extremaType,
                       std::vector<IndexType>& extremaIdxColl);

template <typename T,
          typename IndexType>
void
findLocalStrictMinima(const std::vector<T>& inputColl,
                      const eExtremaBorderPolicy& extremaBorderPolicy,
                      std::vector<IndexType>& extremaIdxColl)
{
    findLocalStrictExtrema(inputColl, extremaBorderPolicy,
                           eExtremaType::eET_Minima,
                           extremaIdxColl);
}

template <typename T,
          typename IndexType>
void
findLocalStrictMaxima(const std::vector<T>& inputColl,
                      const eExtremaBorderPolicy& extremaBorderPolicy,
                      std::vector<IndexType>& extremaIdxColl)
{
    findLocalStrictExtrema(inputColl, extremaBorderPolicy,
                           eExtremaType::eET_Maxima,
                           extremaIdxColl);
}


template <typename T>
IPSDKMATH_API void
findLocalDilatedExtrema(const std::vector<T>& inputColl,
                        const eExtremaBorderPolicy& extremaBorderPolicy,
                        const eExtremaType& extremaType,
                        const T& dilateFactor,
                        ExtremaRangeColl& extremaRangeColl);


template <typename T,
          typename IndexType>
IPSDKMATH_API void
findLocalExtrema(const std::vector<T>& inputColl,
                 const eExtremaBorderPolicy& extremaBorderPolicy,
                 const eExtremaType& extremaType,
                 std::vector<IndexType>& extremaIdxColl);

template <typename T,
          typename IndexType>
void
findLocalMinima(const std::vector<T>& inputColl,
                const eExtremaBorderPolicy& extremaBorderPolicy,
                std::vector<IndexType>& extremaIdxColl)
{
    findLocalExtrema(inputColl, extremaBorderPolicy, eExtremaType::eET_Minima, extremaIdxColl);
}

template <typename T,
          typename IndexType>
void
findLocalMaxima(const std::vector<T>& inputColl,
                const eExtremaBorderPolicy& extremaBorderPolicy,
                std::vector<IndexType>& extremaIdxColl)
{
    findLocalExtrema(inputColl, extremaBorderPolicy, eExtremaType::eET_Maxima, extremaIdxColl);
}


template <typename ExtremaInfo,
          typename T>
IPSDKMATH_API void
filterExtrema(const eExtremaType& extremaType,
              const ipReal64 minDistance,
              const T extremaThresholdValue,
              boost::function<void (const ExtremaInfo&, ipReal64&, T&)> extractExtremaCoordsWrapper,
              std::vector<ExtremaInfo>& extremaInfoColl);

template <typename T,
          typename IndexType>
void
extractBasicExtremaCoords(const std::vector<T>& inputColl,
                          const IndexType& dataIdx,
                          ipReal64& extremaLocation,
                          T& extremaValue)
{
    extremaLocation = static_cast<ipReal64>(dataIdx);
    extremaValue = inputColl[dataIdx];
}

template <typename T>
IPSDKMATH_API void
extractBasicExtremaCoords(const std::vector<T>& inputColl,
                          const ExtremaRange& extremaRange,
                          ipReal64& extremaLocation,
                          T& extremaValue);

template <typename T,
          typename IndexType>
void
filterMinima(const std::vector<T>& inputColl,
             const ipReal64 minDistance,
             std::vector<IndexType>& extremaInfoColl)
{
    const T extremaThresholdValue = NumericLimits<T>::max();
    typedef void (*ExtractExtremaCoordsFun) (const std::vector<T>&, const IndexType&, ipReal64&, T&);
    typedef boost::function<void (const IndexType&, ipReal64&, T&)> ExtractExtremaCoordsWrapper;
    ExtractExtremaCoordsWrapper extractExtremaCoordsWrapper = boost::bind(static_cast<ExtractExtremaCoordsFun>(extractBasicExtremaCoords<T>), boost::cref(inputColl), _1, _2, _3);
    filterExtrema(eExtremaType::eET_Minima, minDistance, extremaThresholdValue,
                  extractExtremaCoordsWrapper, extremaInfoColl);
}

template <typename T,
          typename IndexType>
void
filterMinima(const std::vector<T>& inputColl,
             const ipReal64 minDistance,
             const T extremaThresholdValue,
             std::vector<IndexType>& extremaInfoColl)
{
    typedef void (*ExtractExtremaCoordsFun) (const std::vector<T>&, const IndexType&, ipReal64&, T&);
    typedef boost::function<void (const IndexType&, ipReal64&, T&)> ExtractExtremaCoordsWrapper;
    ExtractExtremaCoordsWrapper extractExtremaCoordsWrapper = boost::bind(static_cast<ExtractExtremaCoordsFun>(extractBasicExtremaCoords<T>), boost::cref(inputColl), _1, _2, _3);
    filterExtrema(eExtremaType::eET_Minima, minDistance, extremaThresholdValue,
                  extractExtremaCoordsWrapper, extremaInfoColl);
}

template <typename T,
          typename IndexType>
void
filterMaxima(const std::vector<T>& inputColl,
             const ipReal64 minDistance,
             std::vector<IndexType>& extremaInfoColl)
{
    const T extremaThresholdValue = NumericLimits<T>::min();
    typedef void (*ExtractExtremaCoordsFun) (const std::vector<T>&, const IndexType&, ipReal64&, T&);
    typedef boost::function<void (const IndexType&, ipReal64&, T&)> ExtractExtremaCoordsWrapper;
    ExtractExtremaCoordsWrapper extractExtremaCoordsWrapper = boost::bind(static_cast<ExtractExtremaCoordsFun>(extractBasicExtremaCoords<T>), boost::cref(inputColl), _1, _2, _3);
    filterExtrema(eExtremaType::eET_Maxima, minDistance, extremaThresholdValue,
                  extractExtremaCoordsWrapper, extremaInfoColl);
}

template <typename T,
          typename IndexType>
void
filterMaxima(const std::vector<T>& inputColl,
             const ipReal64 minDistance,
             const T extremaThresholdValue,
             std::vector<IndexType>& extremaInfoColl)
{
    typedef void (*ExtractExtremaCoordsFun) (const std::vector<T>&, const IndexType&, ipReal64&, T&);
    typedef boost::function<void (const IndexType&, ipReal64&, T&)> ExtractExtremaCoordsWrapper;
    ExtractExtremaCoordsWrapper extractExtremaCoordsWrapper = boost::bind(static_cast<ExtractExtremaCoordsFun>(extractBasicExtremaCoords<T>), boost::cref(inputColl), _1, _2, _3);
    filterExtrema(eExtremaType::eET_Maxima, minDistance, extremaThresholdValue,
                  extractExtremaCoordsWrapper, extremaInfoColl);
}


} // end of namespace math
} // end of namespace ipsdk

#endif // __IPSDKMATH_EXTREMAUTILS_H__