ClusteringUtils.h

Go to the documentation of this file.

// ClusteringUtils.h:
// ------------------
//

#ifndef __IPSDKMATH_CLUSTERINGUTILS_H__
#define __IPSDKMATH_CLUSTERINGUTILS_H__

#include <IPSDKMath/IPSDKMathExports.h>
#include <IPSDKMath/Clustering/ClusteringTypes.h>
#include <iostream>

namespace ipsdk {
namespace math {
namespace clustering {

template <typename KernelType>
class KernelKMeansCentroid;


IPSDKMATH_API ipReal64
computeCompactness(const VectorColl& clustersCentersColl,
                   const VectorColl& dataColl,
                   const UInt32Vector& indexColl);

template <typename KernelType>
IPSDKMATH_API ipReal64
computeKernelCompactness(const std::vector<KernelKMeansCentroid<KernelType> >& clustersCentroids,
                         const VectorColl& dataColl,
                         const UInt32Vector& indexColl);

IPSDKMATH_API ipReal64
computeValidityIndex(const VectorColl& clustersCentersColl,
                     const VectorColl& dataColl,
                     const UInt32Vector& indexColl,
                     const eValidityIndexType& validityIndexType);

IPSDKMATH_API void
generateKMeansPPInit(const ipUInt32 nbClusters,
                     const VectorColl& inputDataColl,
                     VectorColl& initClustersCenters);

template <typename KernelType>
IPSDKMATH_API void
generateKernelKMeansPPInit(const KernelType& kernel,
                           const ipUInt32 nbClusters,
                           const VectorColl& inputDataColl,
                           VectorColl& initClustersCenters);

IPSDKMATH_API ipUInt32
computeAssignment(const VectorColl& clustersCentersColl,
                  const Vector& data);

IPSDKMATH_API ipUInt32
computeKMeansAttempt(const VectorColl& inputDataColl,
                     const ipUInt32 nbMaxIteration,
                     VectorColl& inOutClustersCenters,
                     UInt32Vector& assignments);

template <typename KernelType>
IPSDKMATH_API ipUInt32
computeKernelAssignment(const std::vector<KernelKMeansCentroid<KernelType> >& clustersCentroids,
                        const Vector& data);

template <typename KernelType>
IPSDKMATH_API ipUInt32
computeKernelKMeansAttempt(const KernelType& kernel,
                           const VectorColl& inputDataColl,
                           const ipUInt32 nbMaxIteration,
                           const ipReal64 minChangeRatio,
                           std::vector<KernelKMeansCentroid<KernelType> >& inOutClustersCentroids,
                           UInt32Vector& assignments);

IPSDKMATH_API void
computeClustersCenters(const ipUInt32 nbClusters,
                      const VectorColl& inputDataColl,
                      const UInt32Vector& indexColl,
                      VectorColl& clustersCentersColl);

IPSDKMATH_API ipUInt32
computeClusterPopulation(const ipUInt32 clusterIdx,
                         const UInt32Vector& indexColl);

IPSDKMATH_API Vector
computeClusterCenter(const ipUInt32 clusterIdx,
                     const VectorColl& inputDataColl,
                     const UInt32Vector& indexColl);

IPSDKMATH_API ipReal64
computeClusterStdDev(const ipUInt32 clusterIdx,
                     const VectorColl& inputDataColl,
                     const UInt32Vector& indexColl,
                     const Vector& clusterCenter);

IPSDKMATH_API ipReal64
radialBasisKernelSigmaFromDynamic(const VectorColl& inputDataColl,
                                  const ipReal64 ratio = 0.2);

IPSDKMATH_API std::ostream&
operator<< (std::ostream& os,
            const KMeansClustering& clustering);

template <typename KernelType>
IPSDKMATH_API std::ostream&
operator<< (std::ostream& os,
            const KernelKMeansClustering<KernelType>& clustering);

template <typename KernelType>
IPSDKMATH_API std::ostream&
operator<< (std::ostream& os,
            const SpectralClustering<KernelType>& clustering);


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

#endif // __IPSDKMATH_CLUSTERINGUTILS_H__