/vol/vipdata/irtk/image++/include/irtkDensity.h

/*=========================================================================

  Library   : Image Registration Toolkit (IRTK)
  Module    : $Id: irtkDensity.h 2 2008-12-23 12:40:14Z dr $
  Copyright : Imperial College, Department of Computing
              Visual Information Processing (VIP), 2008 onwards
  Date      : $Date: 2008-12-23 12:40:14 +0000 (Tue, 23 Dec 2008) $
  Version   : $Revision: 2 $
  Changes   : $Author: dr $

=========================================================================*/

#ifndef _IRTKDENSITY_H

#define _IRTKDENSITY_H

class irtkDensity : public irtkObject
{

  int _nbins;

  double _norm;

  double _min;

  double _max;

  double _width;

  double *_bins;

public:

//  irtkHistogram_1D(const irtkHistogram_1D &);

  irtkDensity(int nbins = 256);

  irtkDensity(double min, double max, double width);

  //irtkHistogram_1D(char *);

  ~irtkDensity(void);

  void Reset();

  int  GetNumberOfBins() const;

  void PutNumberOfBins(int);

  double GetMin() const;

  void   PutMin(double);

  double GetMax() const;

  void   PutMax(double);

  double GetWidth() const;

  void   PutWidth(double);

  double Norm() const;

  double operator()(int) const;

  void Add(int, double = 1);

  void Delete(int, double = 1);

  void AddSample(double, double = 1);

  void DelSample(double, double = 1);

  int    ValToBin(double val);

  double BinToVal(int    bin);

  double BinToPDF(int bin);

  double ValToPDF(double val);

//  double BinToCDF(int bin);

//  double ValToCDF(double val);

//  double CDFToBin(double p);

//  double CDFToVal(double p);

  double Mean();

  double Variance();

  double StandardDeviation();

  double Entropy();

//  void Read (char *filename);

//  void Write(char *filename);

  void Print();

  void WriteToImage(char *image_name);
};

inline int irtkDensity::GetNumberOfBins() const
{
  return _nbins;
}

inline double irtkDensity::GetMin() const
{
  return _min;
}

inline double irtkDensity::GetMax() const
{
  return _max;
}

inline double irtkDensity::GetWidth() const
{
  return _width;
}

inline double irtkDensity::Norm() const
{
  return _norm;
}

inline double irtkDensity::operator()(int i) const
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins)) {
    cerr << "irtkDensity::operator(): No such bin" << endl;
    exit(1);
  }
#endif
  return _bins[i];
}

inline void irtkDensity::Add(int i, double value)
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins)) {
    cerr << "irtkDensity::Add: No such bin" << endl;
    exit(1);
  }
#endif
  _bins[i] += value;
  _norm   += value;
}

inline void irtkDensity::Delete(int i, double value)
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins)) {
    cerr << "irtkDensity::Delete: No such bin" << endl;
    exit(1);
  }
#endif
  _bins[i] -= value;
  _norm   -= value;

}

inline void irtkDensity::AddSample(double x, double value)
{
  if (x < _min) return;
  if (x > _max) return;
  double bin = (x - _min) / (_max - _min) *_nbins -0.5;
  /*double bin = (x - _min) / (_max - _min) *(_nbins-1) ;*/
  int index1 = (int)floor(bin);
  int index2 = (int)ceil(bin);
  if (index2 == 0) _bins[0]+=value;
  if (index1 == _nbins-1) _bins[_nbins-1]+=value;
  if ((index1>=0)&&(index2<=_nbins-1)) {
    if (index1 ==index2) _bins[index1]+=value;
    else {
      _bins[index1]+=(index2-bin)*value;
      _bins[index2]+=(bin-index1)*value;
    }
  }
  _norm += value;
}

inline void irtkDensity::DelSample(double x, double value)
{
  int index;

  if (x < _min) return;
  if (x > _max) return;
  index = ValToBin(x);
  _bins[index] -= value;
  _norm -= value;
}

inline int irtkDensity::ValToBin(double val)
{
  int index;

#ifndef NO_BOUNDS
  if ((val < _min) || (val > _max)) {
    cerr << "irtkDensity::ValToBin: Must be between " << _min << " and "
         << _max << endl;
    exit(1);
  }
#endif
  index = round((val - _min) / (_max - _min) * _nbins -0.5);
  if (index < 0) index = 0;
  if (index > _nbins-1) index = _nbins - 1;
  return index;
}

inline double irtkDensity::BinToVal(int i)
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins)) {
    cerr << "irtkDensity::BinToVal: Must be between 0 and " << _nbins << endl;
    exit(1);
  }
#endif
  return (_min + (i + 0.5)*(_max - _min)/_nbins);
}

inline double irtkDensity::BinToPDF(int i)
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins)) {
    cerr << "irtkDensity::BinToPDF: No such bin" << endl;
    exit(1);
  }
#endif
  if (_norm == 0) return 0;
  return _bins[i] / _norm;
}

inline double irtkDensity::ValToPDF(double value)
{
  int i = ValToBin(value);
  if (_norm == 0) return 0;
  return _bins[i] / _norm;
}

#endif

Generated on Mon Mar 23 16:55:52 2009 for IRTK by Doxygen 1.5.4