|| ||           || Doxygen's  

---

HxHistogram.h

/*
 *  Copyright (c) 1997, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *
 *  Author(s):
 *  Dennis Koelma (koelma@wins.uva.nl)
 *  Edo Poll (poll@wins.uva.nl)
 *  Jeroen Vendrig (vendrig@science.uva.nl)
 *  Leon Todoran (todoran@science.uva.nl)
 *  Jan Baan (baan@science.uva.nl)
 *  Jan-Mark Geusebroek (mark@science.uva.nl)
 *  Andrew D. Bagdanov (andrew@science.uva.nl)
 */
 
 /*
  *  JV 12Feb01, added Jan Baan's chiSquareNorm (bug of unofficial 20Jul00 version corrected).  
  *  JV 12Feb01, added write() for histogram output
  */

/*
 *  JV 12Feb01 (again 27Jun01), added Jan Baan's chiSquareNorm (bug of unofficial 20Jul00 version corrected).
 *  JV 12Feb01 (again 27Jun01), added ascii write() for histogram output
 *  JV/JM 27Jun01, added threshold, countBins
 *  JV/JM 27Jun01, added reduceRange, reduceRangeVal
 *  JV 27Jun01, added to1D
 *  JV 27Jun01, added valueToBin
 *  JV 27Jun01, added setBin for doubles
 *  JMG         added smooth
 *  JMG         changed smooth and normalize to return HxHistogram
 *  JMG         added nrOfBins
 *  JMG         changed "put" into behaviour of ascii "write"
 *  JMG/JV      removed ascii write
 *  JMG/CdeB    changed limits to exactly match the interval
 *  JMG/CdB/ADB changed binToValue, valueToBin
 *  JMG/CdB     changed insertValue etc.
 *  LT 04Sep02  added Isodata and Entropy methods for computing threshold value
 *  JV/CdB 03Mar03  fixed insertVal problem, highBin value now inclusive
 *  JV/CdB 10Mar03,  added clipBin to clip values into histogram. 
 *                   Values outside range are put in low/high bin. Only insertVal.
 *  CdB 10Mar03, moved valueToBin to .h (inline) and added 1D version of valueToBin.
 */

#ifndef HxHistogram_h
#define HxHistogram_h

#include <list>
#include "HxRcPtr.h"
#include "HxString.h"
#include "HxPointInt.h"
#include "HxScalarInt.h"
#include "HxScalarDouble.h"
#include "HxVec2Int.h"
#include "HxVec2Double.h"
#include "HxVec3Int.h"
#include "HxVec3Double.h"
#include "HxHistogramData.h"
#include "HxIo.h"

class HxHistogram {
public:


                        HxHistogram();

                        HxHistogram(const HxHistogram&);

                        HxHistogram(int dimSize);

                        HxHistogram(int dimSize1, int dimSize2);

                        HxHistogram(int dimSize1, int dimSize2, int dimSize3);

                        HxHistogram(HxValueType dataType, int dimensions,
                            int dimSize1, int dimSize2 = 0, int dimSize3 = 0);

                        HxHistogram(HxValueType dataType, int dimensions,
                            double lowBin1, double highBin1, int nBins1,
                            double lowBin2, double highBin2, int nBins2,
                            double lowBin3, double highBin3, int nBins3);

                        HxHistogram(HxString filename);




                        ~HxHistogram();


    HxHistogram&        operator=(const HxHistogram&);

    int                 isNull() const;

                        operator int() const;


    int                 ident() const;

    HxValueType         dataType() const;

    int                 dimensionality() const;

    int                 dimensionSize(int dim) const;

    int                 nrOfBins() const;

    double              lowBin(int dim) const;

    double              highBin(int dim) const;

    double              binWidth(int dim) const;

    double              binToValue(int bin, int dimension) const;

    int                 valueToBin(double value, int dimension) const;  

    int                 valueToBin(double val) const;

    int                 clipBin(int bin) const;

    double              get(int bin1) const;

    double              get(int bin1, int bin2) const;

    double              get(int bin1, int bin2, int bin3) const;


    void                insertValChecked(int val);

    void                insertValChecked(double val);

    void                insertValChecked(HxScalarInt val);

    void                insertValChecked(HxScalarDouble val);

    void                insertValChecked(HxVec2Int val);

    void                insertValChecked(HxVec2Double val);

    void                insertValChecked(HxVec3Int val);

    void                insertValChecked(HxVec3Double val);

    void                incBinChecked(int bin);

    void                incBinChecked(int bin1, int bin2);

    void                incBinChecked(int bin1, int bin2, int bin3);


    void                insertVal(int val);

    void                insertVal(double val);

    void                insertVal(double val, double sigma);

    void                insertVal(HxScalarInt val);

    void                insertVal(HxScalarDouble val);

    void                insertVal(HxVec2Int val);

    void                insertVal(HxVec2Double val);

    void                insertVal(HxVec3Int val);

    void                insertVal(HxVec3Double val);


    void                incBin(int bin); //inline

    void                incBin(int bin1, int bin2); //inline

    void                incBin(int bin1, int bin2, int bin3); //inline

    void                setBin(int bin1, long val);

    void                setBin(int bin1, int bin2, long val);

    void                setBin(int bin1, int bin2, int bin3, long val);

    void                setBin(int bin1, double val);

    void                setBin(int bin1, int bin2, double val);

    void                setBin(int bin1, int bin2, int bin3, double val);



    HxHistogram         smooth(double sigma = 3.0);

    std::list<HxVec2Double> modes();

    HxHistogram         normalize(double weight = 1.0);

    double              sum() const;

    double              minVal() const;

    double              minVal(int *index) const;

    double              maxVal() const;

    double              maxVal(int *index) const;

    double              intersection(const HxHistogram&) const;

    double              chiSquare(const HxHistogram&) const;

    double              chiSquareNorm(const HxHistogram&) const;



    int                 computeIsodataThreshold(void);
    int                 computeEntropyThreshold(void);



    HxHistogram         convert(HxValueType dataType);

    void                getTheData(double *x, double* y);

    void                getTheData2(double *x1, double *x2, double* y);

    void                getTheData3(double *x1, double *x2, double *x3,
                                double* y);

    void                getDataDouble(double* data);

    void                getDataInt(int* data);

    void                render3d(int* data, int dataWidth, int dataHeight,
                            double elevation, double alpha, double threshold);

    STD_OSTREAM&        put(STD_OSTREAM&, HxString delimit = " ") const;

    int                 write(HxString filename);



    HxHistogram         threshold(double valThreshold);
    
    int                 countBins(double valThreshold=0.0);

    HxHistogram         reduceRange(int binMin1, int binMax1=-1,
                                    int binMin2=0, int binMax2=-1,
                                    int binMin3=0, int binMax3=-1);

    HxHistogram         reduceRangeVal(double binValMin1, double binValMax1,
                                     double binValMin2=0, double binValMax2=0,
                                     double binValMin3=0, double binValMax3=0);

    HxHistogram         to1D(int dim=1);

private:

                        HxHistogram(const HxHistogramData*);

    int                 isEqualSize(const HxHistogram&) const;

    HxRcPtr<HxHistogramData>    _data;

};

inline STD_OSTREAM&
operator<<(STD_OSTREAM& os, const HxHistogram& his)
{ 
    return his.put(os);
}

inline HxString
makeString(const HxHistogram& his)
{
    return HxString("HxHistogram") + makeString(his.ident());
}

inline double
HxHistogram::get(int bin1) const
{
    return _data ? _data->getBin(bin1) : 0;
}

inline double
HxHistogram::get(int bin1, int bin2) const
{
    return _data ? _data->getBin(bin2 * _data->_dimSize1 + bin1) : 0;
}

inline double
HxHistogram::get(int bin1, int bin2, int bin3) const
{
    return _data ? _data->getBin((bin3 * _data->_dimSize2 + bin2) *
                                _data->_dimSize1 + bin1) : 0;
}

inline void
HxHistogram::incBin(int bin)
{
    if ((bin >= 0) && (bin < _data->_dimSize1))
        _data->incBin(bin);
}

inline void
HxHistogram::incBin(int bin1, int bin2)
{
    if ((bin1 >= 0) && (bin1 < _data->_dimSize1) &&
            (bin2 >= 0) && (bin2 < _data->_dimSize2))
        _data->incBin(bin2 * _data->_dimSize1 + bin1);
}

inline void
HxHistogram::incBin(int bin1, int bin2, int bin3)
{
    if ((bin1 >= 0) && (bin1 < _data->_dimSize1) &&
            (bin2 >= 0) && (bin2 < _data->_dimSize2) &&
            (bin3 >= 0) && (bin3 < _data->_dimSize3))
        _data->incBin((bin3 * _data->_dimSize2 + bin2) *
                     _data->_dimSize1 + bin1);
}

inline void
HxHistogram::setBin(int bin1, long val)
{
    if ((bin1 >= 0) && (bin1 < _data->_dimSize1))           
        _data->setBin(bin1, val);
}

inline void
HxHistogram::setBin(int bin1, int bin2, long val)
{
    if ((bin1 >= 0) && (bin1 < _data->_dimSize1) &&
            (bin2 >= 0) && (bin2 < _data->_dimSize2))
        _data->setBin(bin2 * _data->_dimSize1 + bin1, val);
}

inline void
HxHistogram::setBin(int bin1, int bin2, int bin3, long val)
{
    if ((bin1 >= 0) && (bin1 < _data->_dimSize1) &&
            (bin2 >= 0) && (bin2 < _data->_dimSize2) &&
            (bin3 >= 0) && (bin3 < _data->_dimSize3))
        _data->setBin((bin3 * _data->_dimSize2 + bin2) *
                     _data->_dimSize1 + bin1, val);
}

inline void
HxHistogram::setBin(int bin1, double val)
{
    if ((bin1 >= 0) && (bin1 < _data->_dimSize1))           
        _data->setBin(bin1, val);
}

inline void
HxHistogram::setBin(int bin1, int bin2, double val)
{
    if ((bin1 >= 0) && (bin1 < _data->_dimSize1) &&
            (bin2 >= 0) && (bin2 < _data->_dimSize2))
        _data->setBin(bin2 * _data->_dimSize1 + bin1, val);
}

inline void
HxHistogram::setBin(int bin1, int bin2, int bin3, double val)
{
    if ((bin1 >= 0) && (bin1 < _data->_dimSize1) &&
            (bin2 >= 0) && (bin2 < _data->_dimSize2) &&
            (bin3 >= 0) && (bin3 < _data->_dimSize3))
        _data->setBin((bin3 * _data->_dimSize2 + bin2) *
                     _data->_dimSize1 + bin1, val);
}

inline int
HxHistogram::valueToBin(double val, int dimension) const
{
    if (!_data)
        return -1;
    switch (dimension) {
    case 1: return (int) ((val - _data->_lowRange1) * _data->_binFac1);
    case 2: return (int) ((val - _data->_lowRange2) * _data->_binFac2);
    case 3: return (int) ((val - _data->_lowRange3) * _data->_binFac3);
    }
    return -1;
}

inline int
HxHistogram::valueToBin(double val) const
{
    if (!_data)
        return -1;
    return (int) ((val - _data->_lowRange1) * _data->_binFac1);
}

inline int
HxHistogram::clipBin(int bin) const
{

    return (bin < 0) ? 0 : (bin > (nrOfBins()-1)) ? nrOfBins()-1 : bin;
}

inline void
HxHistogram::insertVal(int val)
{
    incBin(clipBin(valueToBin((double) val)));
}

inline void
HxHistogram::insertVal(double val)
{
    incBin(clipBin(valueToBin(val)));
}

inline void
HxHistogram::insertVal(HxScalarInt val)
{
    insertVal(val.x());
    return;
}

inline void
HxHistogram::insertVal(HxScalarDouble val)
{
    insertVal(val.x());
    return;
}

inline void
HxHistogram::insertVal(HxVec2Int val)
{
    int bin1 = (int) ((val.x() - _data->_lowRange1) * _data->_binFac1);
    if (bin1 >= _data->_dimSize1)
    {
        if (val.x()==_data->_highBin1)
            bin1=_data->_dimSize1-1;
        else
            return; // out of range, don't do anything
    }
    int bin2 = (int) ((val.y() - _data->_lowRange2) * _data->_binFac2);
    if (bin2 >= _data->_dimSize2)
    {
        if (val.y()==_data->_highBin2)
            bin2=_data->_dimSize2-1;
        else
            return; // out of range, don't do anything
    }
    incBin(bin1,bin2);      
}

inline void
HxHistogram::insertVal(HxVec2Double val)
{
    int bin1 = (int) ((val.x() - _data->_lowRange1) * _data->_binFac1);
    if (bin1 >= _data->_dimSize1)
    {
        if (val.x()==_data->_highBin1)
            bin1=_data->_dimSize1-1;
        else
            return; // out of range, don't do anything
    }
    int bin2 = (int) ((val.y() - _data->_lowRange2) * _data->_binFac2);
    if (bin2 >= _data->_dimSize2)
    {
        if (val.y()==_data->_highBin2)
            bin2=_data->_dimSize2-1;
        else
            return; // out of range, don't do anything
    }
    incBin(bin1,bin2);
}

inline void
HxHistogram::insertVal(HxVec3Int val)
{
    int bin1 = (int) ((val.x() - _data->_lowRange1) * _data->_binFac1);
    if (bin1 >= _data->_dimSize1)
    {
        if (val.x()==_data->_highBin1)
            bin1=_data->_dimSize1-1;
        else
            return; // out of range, don't do anything
    }
    int bin2 = (int) ((val.y() - _data->_lowRange2) * _data->_binFac2);
    if (bin2 >= _data->_dimSize2)
    {
        if (val.y()==_data->_highBin2)
            bin2=_data->_dimSize2-1;
        else
            return; // out of range, don't do anything
    }
    int bin3 = (int) ((val.z() - _data->_lowRange3) * _data->_binFac3);
    if (bin3 >= _data->_dimSize3)
    {
        if (val.z()==_data->_highBin3)
            bin3=_data->_dimSize3-1;
        else
            return; // out of range, don't do anything
    }
    incBin(bin1,bin2,bin3);
}

inline void
HxHistogram::insertVal(HxVec3Double val)
{
    int bin1 = (int) ((val.x() - _data->_lowRange1) * _data->_binFac1);
    if (bin1 >= _data->_dimSize1)
    {
        if (val.x()==_data->_highBin1)
            bin1=_data->_dimSize1-1;
        else
            return; // out of range, don't do anything
    }
    int bin2 = (int) ((val.y() - _data->_lowRange2) * _data->_binFac2);
    if (bin2 >= _data->_dimSize2)
    {
        if (val.y()==_data->_highBin2)
            bin2=_data->_dimSize2-1;
        else
            return; // out of range, don't do anything
    }
    int bin3 = (int) ((val.z() - _data->_lowRange3) * _data->_binFac3);
    if (bin3 >= _data->_dimSize3)
    {
        if (val.z()==_data->_highBin3)
            bin3=_data->_dimSize3-1;
        else
            return; // out of range, don't do anything
    }
    incBin(bin1,bin2,bin3);
}

#endif

---