|| || || || || || || ||

---

Histogram2dTem.h

Go to the documentation of this file.

#ifndef Impala_Core_Histogram_Histogram2dTem_h
#define Impala_Core_Histogram_Histogram2dTem_h

#include <iostream>
#include "Core/Array/Array2dTem.h"
#include "Core/Array/SetVal.h"
#include "Core/Array/PixSum.h"

namespace Impala
{
namespace Core
{
namespace Histogram
{


template <class ElemT>
class Histogram2dTem : public Array::Array2dTem<ElemT, 1, ElemT>
{
public:

    Histogram2dTem(ElemT lowX, ElemT highX, int binCountX, ElemT lowY, ElemT highY, int binCountY)
        : Array::Array2dTem<ElemT, 1, ElemT>(binCountX, binCountY, 0, 0)
    {
        mBinCountX = binCountX;
        mBinCountY = binCountY;
        SetRange(lowX, highX, lowY, highY);
        Clear();
    }

    virtual ~Histogram2dTem()
    {
    }

    ElemT GetLowX() 
    {
        return mLowX;
    }

    ElemT GetLowY()
    {
        return mLowY;
    }

    ElemT GetHighX()
    {
        return mHighX;
    }

    ElemT GetHighY()
    {
        return mHighY;
    }

    int GetBinCountX()
    {
        return mBinCountX;
    }

    int GetBinCountY()
    {
        return mBinCountY;
    }
    
    void GetBinRangeX(int bin, ElemT& low, ElemT& high)
    {
        low = mLowX + bin*mBinWidthX;
        high = mLowX + (bin+1)*mBinWidthX;
    }

    void GetBinRangeY(int bin, ElemT& low, ElemT& high)
    {
        low = mLowY + bin*mBinWidthY;
        high = mLowY + (bin+1)*mBinWidthY;
    }

    void SetRange(ElemT lowX, ElemT highX, ElemT lowY, ElemT highY)
    {
        mLowX = lowX;
        mLowY = lowY;
        mHighX = highX;
        mHighY = highY;
        mBinWidthX = (highX-lowX) / ((ElemT) mBinCountX);
        mBinWidthY = (highY-lowY) / ((ElemT) mBinCountY);
    }

    void Clear()
    {
        SetVal(this, static_cast<ElemT>(0));
    }

    void AddWeight(ElemT valueX, ElemT valueY, double weight = 1.)
    {
        *this->CPB(ValueToBinX(valueX), ValueToBinY(valueY)) += weight;
    }

    void AddWeightSafe(ElemT valueX, ElemT valueY, double weight = 1.)
    {
        int indexX = ValueToBinX(valueX);
        int indexY = ValueToBinY(valueY);
        if (indexX<0 || indexX>=this->CW() || indexY<0 || indexY>=this->CH())
        {
            mOutliers += weight;
        }
        else
            *this->CPB(indexX, indexY) += weight;
    }

    ElemT GetWeight(ElemT valueX, ElemT valueY)
    {
        return this->Elem(ValueToBinX(valueX), ValueToBinY(valueY));
    }

    ElemT TotalWeight()
    {
        return PixSum(this);
    }

    void Normalize()
    {
        ElemT tot = TotalWeight();
        DivVal(this, tot);
    }

    int ValueToBinX(ElemT value)
    {
        return (int)((value-mLowX) / mBinWidthX);
    }

    int ValueToBinY(ElemT value)
    {
        return (int)((value-mLowY) / mBinWidthY);
    }

    Real64 OutlierPercentage()
    {
        ElemT sum = TotalWeight() + mOutliers;
        return ((Real64) mOutliers) / ((Real64) sum) * 100;
    }

    void Dump(bool doData)
    {
        std::cout << "hist range x [" << mLowX << "," << mHighX << "] with "
                  << mBinCountX << "range y [" << mLowY << "," << mHighY << "] with "
                  << mBinCountY << " bins. Values: " << std::endl;
        if (doData)
            this->WriteTo(std::cout);
        std::cout << "Total weight: " << TotalWeight() << ", outlier %: "
                  << OutlierPercentage() << std::endl;
        std::cout << std::endl;
    }

private:

    ElemT  mLowX;
    ElemT  mHighX;
    ElemT  mBinWidthX;
    int    mBinCountX;
    ElemT  mLowY;
    ElemT  mHighY;
    ElemT  mBinWidthY;
    int    mBinCountY;
    ElemT  mOutliers;

};

} // namespace Histogram
} // namespace Core
} // namespace Impala

#endif

---