Kernels.h

#ifndef __KERNELS_H
#define __KERNELS_H

#include <cmath>

#include <vector>
#include <memory>
#include <functional>

#include "CommonTypes.h"
#include "Config.h"
#include "ModelInfo.h"
#include "Representer.h"
#include "StatisticalModel.h"


namespace statismo {

template<class TPoint>
class ScalarValuedKernel {
  public:

    ScalarValuedKernel() {  }

    virtual ~ScalarValuedKernel() {
    }

    virtual double operator()(const TPoint& x, const TPoint& y) const = 0;

    virtual std::string GetKernelInfo() const = 0;

};


template<class TPoint>
class MatrixValuedKernel {
  public:

    MatrixValuedKernel(unsigned dim) :
        m_dimension(dim) {
    }

    virtual MatrixType operator()(const TPoint& x,
                                  const TPoint& y) const = 0;

    virtual unsigned GetDimension() const {
        return m_dimension;
    }
    ;
    virtual ~MatrixValuedKernel() {
    }

    virtual std::string GetKernelInfo() const = 0;

  protected:
    unsigned m_dimension;

};

template<class T>
class StatisticalModelKernel: public MatrixValuedKernel<typename Representer<T>::PointType > {
  public:

    typedef Representer<T> RepresenterType;
    typedef typename RepresenterType::PointType PointType;
    typedef StatisticalModel<T> StatisticalModelType;

    StatisticalModelKernel(const StatisticalModelType* model) :
        MatrixValuedKernel<PointType>(model->GetRepresenter()->GetDimensions()), m_statisticalModel(model) {
    }

    virtual ~StatisticalModelKernel() {
    }

    inline MatrixType operator()(const PointType& x, const PointType& y) const {
        MatrixType m = m_statisticalModel->GetCovarianceAtPoint(x, y);
        return m;
    }

    std::string GetKernelInfo() const {
        return "StatisticalModelKernel";
    }

  private:
    const StatisticalModelType* m_statisticalModel;
};



} // namespace statismo

#endif // __KERNELS_H