gaussian.h

// Copyright (C) 1998-1999  Jean-Marc Valin
#ifndef GAUSSIAN_H
#define GAUSSIAN_H

#include <iostream>
#include <string>
#include "covariance.h"
#include "ObjectParser.h"
#include "misc.h"
#include "Vector.h"
#include "covariance_set.h"
#include "mean.h"
#include "mean_set.h"


namespace FD {

class GMM;

class Gaussian : public Object
{
protected:
   RCPtr<Mean> mean;
   //RCPtr<Vector<float> > mean;

   RCPtr<Covariance> covariance;

   int            accum_count;

   int            dimension;

   bool using_meanID;
   
   bool using_covarianceID;
   
   int meanID;

   int covarianceID;

public:
   Gaussian() 
      : dimension(0) 
      , using_meanID(false)
      , using_covarianceID(false)
   {}

   Gaussian(std::istream &in) {in >> *this;}

   Gaussian(int dim, Covariance *(*cov_new)(int))
      : mean(new Mean (dim,0.0))
      //: mean(new Vector<float> (dim,0.0))
      , covariance(cov_new (dim))
      , accum_count(0)
      , dimension(dim)
      , using_meanID(false)
      , using_covarianceID(false)
   {}

   Gaussian(int dim, int _meanID, int _covarianceID)
      : accum_count(0)
      , dimension(dim)
      , using_meanID(true)
      , using_covarianceID(true)
      , meanID(_meanID)
      , covarianceID(_covarianceID)
   {}

   Gaussian(const Gaussian &g) 
      : mean(new Mean (*g.mean))
      //: mean(new Vector<float> (*g.mean))
      , covariance(g.covariance->copy())
      , accum_count (g.accum_count)
      , dimension (g.dimension)
      , using_meanID(false)
      , using_covarianceID(false)
   {}

   ~Gaussian();
      
   int getDimension() const  { return dimension; }

   Mean &getMean() const  { return *mean; }

   Covariance &getCovariance() const { return *covariance; }

   void to_real();

   int get_accum_count() const {return accum_count;} 

   double mahalanobis(const float * fr) const
   {
      return covariance->mahalanobisDistance(fr,&(*mean)[0]);
   }

   double mahalanobis(const float * fr, Covariance *cov) const
   {
      return cov->mahalanobisDistance(fr,&(*mean)[0]);
   }

   double euclidian(const float * fr) const
   {
      double dist=0;
      for (unsigned int i=0;i<dimension;i++)
      {
         dist+=FD::sqr<double>(fr[i]-(*mean)[i]);
      }
      //cerr << "det: " << covariance->getDeterminant() << endl;
      return dist;
   }

   void accum_frame(const float * fr)
   {
      mean->accumFrame(fr);
      covariance->accumFrame(fr);
      accum_count++;
   }

   void reset_to_accum_mode()
   {
      accum_count=0;
      covariance->reset();
      mean->resetToAccum();
   }

   void toIDsUsing (MeanSet &means, CovarianceSet & covariances);

   void toPtrsUsing (const MeanSet &means, const CovarianceSet & covariances);

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

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

   friend std::istream &operator >> (std::istream &in, Gaussian &gauss);
   friend class GMM;
};

std::istream &operator >> (std::istream &in, Gaussian &gauss);

}//namespace FD
#endif

---