Histogram1D.cpp

#include "Histogram1D.hh"

using namespace BIAS;
using namespace std;

template <class T>
Histogram1D<T>::
Histogram1D()
  : Debug(), Data_(), NumBins_(100), MinValue_(T(0)), MaxValue_(T(0)),
    BinSize_(T(0)), AutoScale_(true)
{}

template <class T>
Histogram1D<T>::
~Histogram1D()
{}


template <class T>
void Histogram1D<T>::
AddData(const std::vector<T>& data)
{ Data_.insert(Data_.end(), data.begin(), data.end()); }

template <class T>
void Histogram1D<T>::
AddData(const T& data)
{ Data_.push_back(data); }

template <class T>
int Histogram1D<T>::
GetHistogram(std::vector<T>& bin_center, std::vector<unsigned>& hist)
{
  if (AutoScale_)
    InitInternalsFromData_();
  else 
    InitInternals_();

  ComputeBinCenters_(bin_center);

  hist.resize(NumBins_, 0u);

  int num = 0;
  register int bin;
  typename std::vector<T>::const_iterator it;
  for (it=Data_.begin(); it!=Data_.end(); it++){
    if (*it<MinValue_ || *it>MaxValue_){
      /// this should not happen when autoscale is true
      BIASASSERT(!AutoScale_);
      continue;
    }
    bin = GetBinNum_(*it);
    // BIASASSERT(bin>=0 && bin<(int)NumBins_);
    if(bin>=0 && bin<(int)NumBins_){
      hist[bin]++;
      num++;
    }
  }

  return num;
}

template <class T>
T Histogram1D<T>::
GetBinCenterWithMaxEntries()
{
    vector<T> center;
    vector<unsigned> histo;
    GetHistogram(center,histo);
    T maxValue=(T)0.0f; unsigned maxHist=0;
    for(unsigned i=0;i<histo.size();i++){
        if(histo[i] > maxHist){
            maxValue=center[i];
            maxHist =histo[i];
        }
    }
    return maxValue;
}

template <class T>
void Histogram1D<T>::
InitInternalsFromData_()
{
  BIASASSERT(AutoScale_);
  if (Data_.empty()) {
    BIASERR("cannot init, no data");
    return;
  }
  MinValue_ = MaxValue_ = Data_[0];
  if (Data_.size()<=1){
    BIASERR("cannot init, not enough data");
    return;
  }
  
  typename std::vector<T>::const_iterator it;
  for (it=Data_.begin(); it!=Data_.end(); it++){
    if (*it < MinValue_) MinValue_ = *it;
    if (*it > MaxValue_) MaxValue_ = *it;
  }
  InitInternals_();
}


template <class T>
void Histogram1D<T>::
InitInternals_()
{
  if (MaxValue_<=MinValue_){
    BIASERR("max value <= min value, histogram computation impossible");
    BinSize_ = (T)0.;
    return;
  }
  BIASASSERT(NumBins_>0);
  BinSize_ = (T)(((double)MaxValue_ - (double)MinValue_) / (double)NumBins_);
}


template <class T>
void Histogram1D<T>::
ComputeBinCenters_(std::vector<T>& center) const
{
  BIASASSERT(BinSize_>(T)0.);
  center.resize(NumBins_);
  double half_bin_size = (double)BinSize_ * 0.5;
  for (unsigned i=0; i<NumBins_; i++)
    center[i] = (T)((double)i * (double)BinSize_ + half_bin_size + (double)MinValue_);
}

#define INSTANCE_Hist1D(type)\
template class BIASMathAlgo_EXPORT Histogram1D<type>;

// create instances
namespace BIAS{
INSTANCE_Hist1D(float)
INSTANCE_Hist1D(double)
INSTANCE_Hist1D(int)
}