covariance.h

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

#include <math.h>
#include <vector>
#include "Object.h"
#include "ObjectParser.h"
#include "misc.h"
#include "Vector.h"
#include "mean.h"
#include <fstream>

namespace FD {

class GMM; 

class Covariance : public Object
{
protected:
   enum Mode {accum, real, rotated, inverted};
   
   int   dimension;
   
   mutable double determinant;
   
   mutable bool  determinant_is_valid;
   
   int mode;

   int accum_count;
public:
   Covariance(int dim) : dimension(dim) , determinant(-10000) , determinant_is_valid(false), mode(accum)
   {
      
   }
   Covariance(const Covariance &cov) 
      : dimension(cov.dimension) 
      , determinant(0)
      , determinant_is_valid(false)
      , mode (cov.mode)
      , accum_count(0)
   {}
   virtual ~Covariance() {}
   
   virtual void accumFrame(const float *v)=0;

   virtual void accumFrame(const std::vector<float> &v)=0;
  
   unsigned int   size() const { return dimension; }

   double getDeterminant() const 
   { 
      if (!determinant_is_valid) compute_determinant(); 
      return determinant; 
   }

   virtual void compute_determinant() const =0;

   virtual void printOn(std::ostream &out=std::cout) const = 0;
   
   virtual double mahalanobisDistance(const float *x1, const double *x2) const =0;

   virtual double&      operator[](int )=0;

   virtual double&      operator()(int,int)=0;

   virtual void reset()=0;
   
   virtual Covariance * copy()=0;

   virtual void invert()=0;

   virtual void processMean(RCPtr<Mean> mean)=0;

   friend class GMM;
};


class DiagonalCovariance : public Covariance  {
   std::vector<double> data;
public:
   DiagonalCovariance(std::istream &in)
      : Covariance(0)
   {in >> *this;}
   
   DiagonalCovariance() 
      : Covariance(0)
      , data(std::vector<double>(0,0.0))
   {}

   DiagonalCovariance(int dim) 
      : Covariance(dim) 
      , data(std::vector<double>(dim,0.0)) 
   {}

   DiagonalCovariance (const DiagonalCovariance &cov) 
      : Covariance(cov)
      , data(cov.data)
   {}

   double mahalanobisDistance(const float *x1, const double *x2) const;

   double&      operator[](int i) {return data[i];}

   double&      operator()(int i) {return data[i];}

   double&      operator()(int i,int) {return data[i];}

   void compute_determinant() const;

   
   void accumFrame(const float *v)
   {
      for (int i=0;i<dimension;i++)
         data[i] += v[i]*v[i];
      accum_count++;
   }

   void accumFrame(const std::vector<float> &v)
   {
      for (int i=0;i<dimension;i++)
         data[i] += v[i]*v[i];
      accum_count++;
   }

   void reset();

   Covariance *copy () {  return new DiagonalCovariance (*this); }

   void invert();

   void processMean(RCPtr<Mean> mean);

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

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

   friend std::istream &operator >> (std::istream &in, DiagonalCovariance &cov);
   friend class GMM;
}
;

inline Covariance *NewDiagonalCovariance(int dim) {return new DiagonalCovariance (dim);}

std::istream &operator >> (std::istream &in, DiagonalCovariance &cov);
}//namespace FD

#endif

---