KernelKMeansCentroid.h

// KernelKMeansCentroid.h:
// -----------------------
//

#ifndef __IPSDKMATH_KERNELKMEANSCENTROID_H__
#define __IPSDKMATH_KERNELKMEANSCENTROID_H__

// suppression warnings
// warning C4251: 'ipsdk::math::KernelKMeansCentroid<KernelType>::_weights': class 'boost::numeric::ublas::vector<ipsdk::ipReal64,boost::numeric::ublas::unbounded_array<ipsdk::ipReal64,std::allocator<_Ty>>>' needs to have dll-interface to be used by clients of class 'ipsdk::math::KernelKMeansCentroid<KernelType>'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKMath/IPSDKMathExports.h>
#include <IPSDKUtil/Tools/ForceInline.h>
#include <IPSDKMath/Constants.h>
#include <IPSDKMath/Clustering/ClusteringTypes.h>
#include <IPSDKMath/Clustering/KernelKMeansClusteringConfig.h>

namespace ipsdk {
namespace math {
namespace clustering {


template <typename KernelType>
class IPSDKMATH_API KernelKMeansCentroid
{
public:
    KernelKMeansCentroid(const KernelType& kernel);
    ~KernelKMeansCentroid();

// methods
public:
    // ---------------------------
    // ---------------------------

    const KernelType&           getKernel() const;

    static ipReal64             getDefaultAccuracyThreshold()
    {
        return KernelKMeansClusteringConfig::getDefaultAccuracyThreshold();
    }

    void                        setAccuracyThreshold(const ipReal64 accuracyThreshold);

    ipReal64                    getAccuracyThreshold() const;

    static ipUInt32             getDefaultMaxDictionarySize()
    {
        return KernelKMeansClusteringConfig::getDefaultMaxDictionarySize();
    }

    void                        setMaxDictionarySize(const ipUInt32 maxDictionarySize);

    ipUInt32                    getMaxDictionarySize() const;

    ipUInt64                    getNbSamples() const;

    ipUInt32                    getDictionarySize() const;

    void                        addSample(const Vector& sample);

    IPSDK_FORCEINLINE ipReal64  comparable_distance(const Vector& sample) const
    {
        // compute sample term
        const ipReal64 sampleTerm = _kernel.value(sample);

        // compute mixed term
        ipReal64 mixedTerm = 0;
        typename VectorColl::const_iterator iterDict = _dictionary.begin();
        typename Real64Vector::const_iterator iterWeight = _weights.begin();
        while (iterDict != _dictionary.end()) {

            // retrieve current point and associated weight
            const Vector& curPoint = *iterDict;
            const ipReal64 curWeight = *iterWeight;

            // compute associated contribution
            mixedTerm += curWeight * _kernel.value(curPoint, sample);

            ++iterDict;
            ++iterWeight;
        }

        // update cluster term if needed
        updateClusterTerm();

        // compute comparable distance
        return sampleTerm + _clusterTermInfo.first - 2*mixedTerm;
    }

    IPSDK_FORCEINLINE ipReal64  distance(const Vector& sample) const
    {
        // compute comparable distance
        const ipReal64 comparableDistance = comparable_distance(sample);

        // compute associated distance
        if (comparableDistance > 0)
            return std::sqrt(comparableDistance);
        else
            return 0;
    }

    ipReal64                    getClusterTerm() const;
    
    const VectorColl&           getDictionary() const;

    const Real64Vector&         getWeights() const;

    void                        clear();

protected:
    void                        updateClusterTerm() const;

    void                        updateMinStrength();

// attributes
protected:
    KernelType                          _kernel;

    ipReal64                            _accuracyThreshold;

    ipUInt32                            _maxDictionarySize;

    VectorColl                          _dictionary;

    Real64Vector                        _weights;

    ipUInt64                            _nbSamples;

    mutable std::pair<ipReal64, bool>   _clusterTermInfo;

    Matrix                              _matK;

    Matrix                              _invMatK;

    std::pair<ipReal64, ipUInt32>       _minStrengthInfo;

    Matrix                              _wkMat;
    Vector                              _wkVec;
    Vector                              _wkVecA;
    Vector                              _wkVecMixedTerms;
};


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

#pragma warning (pop)

#endif // __IPSDKMATH_KERNELKMEANSCENTROID_H__