gmm.h

// Copyright (C) 1999 Jean-Marc Valin
#ifndef GMM_H
#define GMM_H
#include "gaussian.h"
#include "covariance.h"
#include "Object.h"
#include "ObjectParser.h"
#include "gaussian_set.h"
#include "DiagGMM.h"

namespace FD {

class GMM;

class Score {
public:
   float score;

   int gaussian_id;

   float * frame;

   const GMM *gmm;
public:

   friend class GMM;
};

class GMM : public Object{
public:

   typedef enum {real, accum} GMM_Mode;
protected:
   
   //vector<Gaussian *>  gaussians;
   std::vector<RCPtr<Gaussian> >  gaussians;

   std::vector<float>       apriori;

   int                 nb_gaussians;

   int                 mode;

   int                 nb_frames_aligned;

   int dimensions;

   bool using_gaussianIDs;

   std::vector<int>  gaussianIDs;

public:
   GMM(int nb_gauss, int dim, Covariance *(*cov_new)(int)) 
      : gaussians(std::vector<RCPtr<Gaussian> >(nb_gauss))
      //: gaussians(std::vector<Gaussian *>(nb_gauss,(Gaussian *)NULL))
      , apriori (std::vector<float>(nb_gauss,0.0)) 
      , nb_gaussians (nb_gauss)
      , mode(accum)
      , nb_frames_aligned(0)
      , dimensions (dim)
      , using_gaussianIDs(false)
   {
      for (int i=0;i<nb_gauss;i++)
         gaussians[i] = RCPtr<Gaussian> (new Gaussian (dim, cov_new));
   }

   GMM ()
   //: gaussians(std::vector<Gaussian *>(1,(Gaussian *)NULL))
      : gaussians(std::vector<RCPtr<Gaussian> >())
      , nb_gaussians (0)
      , mode(accum)
      , nb_frames_aligned(0)
      , dimensions(1)
      , using_gaussianIDs(false)
   {
      //gaussians[0] = new Gaussian (1, NewDiagonalCovariance);
   }

   void save(std::string file);

   int get_nb_gaussians() const {return nb_gaussians;}

   Gaussian &gaussian (int i) const {return *(gaussians[i]);}

   void accum_to_gaussian(int i, const float * fr)
   {
      gaussians[i]->accum_frame(fr);
      apriori[i]+=1.0;
      nb_frames_aligned++;
   }

   void init(std::vector<float * > frames);

   void kmeans1(std::vector<float * > frames, int nb_iterations = 1);
   
   void split1();

   void kmeans2(std::vector<float * > frames, GMM *gmm);

   void adaptMAP(std::vector<float * > frame, GMM *gmm);

   void to_real();

   void reset_to_accum_mode();

   Score minDistance(float * fr, Covariance *cov) const;

   Score score(float * fr) const;

   void binary_split();

   std::vector<Score> minDistance(std::vector <float *> fr) const;

   std::vector<Score> score(std::vector <float *> fr) const;

   void toIDsUsing (GaussianSet & gauss);

   void toPtrsUsing (const GaussianSet & gauss);

   DiagGMM *createDiagGMM();

   virtual void printOn(std::ostream &out=std::cout) const;

   void readFrom (std::istream &in=std::cin);

   //friend std::ostream &operator << (std::ostream &out, const GMM &gmm);
   friend std::istream &operator >> (std::istream &in, GMM &gmm);
}
;

//ostream &operator << (ostream &out, const GMM &gmm);
std::istream &operator >> (std::istream &in, GMM &gmm);

}//namespace FD

#endif

---