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

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

  Library   : Image Registration Toolkit (IRTK)
  Module    : $Id: irtkHistogram_2D.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 _IRTKHISTOGRAM_2D_H

#define _IRTKHISTOGRAM_2D_H

class irtkHistogram_2D : public irtkObject
{

  int _nbins_x;

  int _nbins_y;

  int _nsamp;

  double _min_x;

  double _min_y;

  double _max_x;

  double _max_y;

  double _width_x;

  double _width_y;

  int **_bins;

public:

  irtkHistogram_2D(const irtkHistogram_2D &);

  irtkHistogram_2D(int nbins_x = 256, int nbins_y = 256);

  irtkHistogram_2D(double min_x, double max_x, double width_x,
                   double min_y, double max_y, double width_y);

  ~irtkHistogram_2D(void);

  void Reset();

  void Reset(const irtkHistogram_2D &);

  int  GetNumberOfBinsX() const;

  void PutNumberOfBinsX(int);

  int  GetNumberOfBinsY() const;

  void PutNumberOfBinsY(int);

  void GetNumberOfBins(int *, int *) const;

  void PutNumberOfBins(int, int);

  void   GetMin(double *, double *) const;

  void   PutMin(double, double);

  void   GetMax(double *, double *) const;

  void   PutMax(double, double);

  void   GetWidth(double *, double *) const;

  void   PutWidth(double, double);

  int NumberOfSamples() const;

  int operator()(int, int) const;

  void Add(int, int, int = 1);

  void Delete(int, int, int = 1);

  void AddSample(double, double);

  void DelSample(double, double);

  int  ValToBinX(double val);

  double BinToValX(int    bin);

  int  ValToBinY(double val);

  double BinToValY(int    bin);

  void HistogramX(irtkHistogram_1D &);

  void HistogramY(irtkHistogram_1D &);

  double JointProbability(int, int);

  double MarginalProbabilityX(int);

  double MarginalProbabilityY(int);

  double ConditionalProbabilityXY(int, int);

  double ConditionalProbabilityYX(int, int);

  double MeanX();

  double MeanY();

  double ConditionalMeanXY(int);

  double ConditionalMeanYX(int);

  double VarianceX();

  double VarianceY();

  double ConditionalVarianceXY(int);

  double ConditionalVarianceYX(int);

  double Covariance();

  double StandardDeviationX();

  double StandardDeviationY();

  double EntropyX();

  double EntropyY();

  double JointEntropy();

  double MutualInformation();

  double NormalizedMutualInformation();

  double CrossCorrelation();

  double CorrelationRatioXY();

  double CorrelationRatioYX();

  double SumsOfSquaredDifferences();

  double LabelConsistency();

  double Kappa();

  void Read (char *filename);

  void Write(char *filename);

  void Print();
};

inline int irtkHistogram_2D::GetNumberOfBinsX() const
{
  return _nbins_x;
}

inline int irtkHistogram_2D::GetNumberOfBinsY() const
{
  return _nbins_y;
}

inline int irtkHistogram_2D::NumberOfSamples() const
{
  return _nsamp;
}

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

inline void irtkHistogram_2D::Add(int i, int j, int n)
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins_x) || (j < 0) || (j >= _nbins_y)) {
    cerr << "irtkHistogram_2D::Add: No such bin " << i << " " << j << endl;
    exit(1);
  }
#endif
  _bins[j][i] += n;
  _nsamp      += n;
}

inline void irtkHistogram_2D::Delete(int i, int j, int n)
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins_x) || (j < 0) || (j >= _nbins_y)) {
    cerr << "irtkHistogram_2D::Delete: No such bin " << i << " " << j << endl;
    exit(1);
  }
#endif
  _bins[j][i] -= n;
  _nsamp      -= n;
}

inline int irtkHistogram_2D::ValToBinX(double val)
{
  int index;

#ifndef NO_BOUNDS
  if ((val < _min_x) || (val > _max_x)) {
    cerr << "irtkHistogram_2D::ValToBinX: Must be between " << _min_x << " and "
         << _max_x << endl;
    exit(1);
  }
#endif
  index = round(_nbins_x * (val - _min_x - 0.5*_width_x) / (_max_x - _min_x));
  if (index < 0) index = 0;
  if (index > _nbins_x-1) index = _nbins_x - 1;
  return index;
}

inline int irtkHistogram_2D::ValToBinY(double val)
{
  int index;

#ifndef NO_BOUNDS
  if ((val < _min_y) || (val > _max_y)) {
    cerr << "irtkHistogram_2D::ValToBinY: Must be between " << _min_y << " and "
         << _max_y << endl;
    exit(1);
  }
#endif
  index = round(_nbins_y * (val - _min_y - 0.5*_width_y) / (_max_y - _min_y));
  if (index < 0) index = 0;
  if (index > _nbins_y-1) index = _nbins_y - 1;
  return index;
}

inline double irtkHistogram_2D::BinToValX(int i)
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins_x)) {
    cerr << "irtkHistogram_1D::BinToValX: Must be between 0 and " << _nbins_x << endl;
    exit(1);
  }
#endif
  return (i*(_max_x - _min_x)/_nbins_x + _min_x) + _width_x/2.0;
}

inline double irtkHistogram_2D::BinToValY(int i)
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins_y)) {
    cerr << "irtkHistogram_1D::BinToValY: Must be between 0 and " << _nbins_y << endl;
    exit(1);
  }
#endif
  return (i*(_max_y - _min_y)/_nbins_y + _min_y) + _width_y/2.0;
}

inline double irtkHistogram_2D::JointProbability(int i, int j)
{
#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins_x) || (j < 0) || (j >= _nbins_y)) {
    cerr << "irtkHistogram_1D::JointProbability: No such bin " << i << " ";
    cerr << j << endl;
    exit(1);
  }
#endif
  return _bins[j][i] / (double) _nsamp;
}

inline double irtkHistogram_2D::MarginalProbabilityX(int i)
{
  int j, n;

#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins_x)) {
    cerr << "irtkHistogram_1D::MarginalProbabilityX: No such bin " << i << endl;
    exit(1);
  }
#endif
  n = 0;
  for (j = 0; j < _nbins_y; j++) {
    n += _bins[j][i];
  }
  return n / (double) _nsamp;
}

inline double irtkHistogram_2D::MarginalProbabilityY(int i)
{
  int j, n;

#ifndef NO_BOUNDS
  if ((i < 0) || (i >= _nbins_y)) {
    cerr << "irtkHistogram_1D::MarginalProbabilityY: No such bin " << i << endl;
    exit(1);
  }
#endif
  n = 0;
  for (j = 0; j < _nbins_x; j++) {
    n += _bins[i][j];
  }
  return n / (double) _nsamp;
}

inline double irtkHistogram_2D::ConditionalProbabilityXY(int i, int j)
{
  double p;

  p = this->MarginalProbabilityY(j);
  if (p > 0) {
    return this->JointProbability(i, j) / p;
  } else {
    return 0;
  }
}

inline double irtkHistogram_2D::ConditionalProbabilityYX(int i, int j)
{
  double p;

  p = this->MarginalProbabilityX(j);
  if (p > 0) {
    return this->JointProbability(j, i) / p;
  } else {
    return 0;
  }
}

#endif

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