GLIMSView Source Code Documentation

histogram.h

Go to the documentation of this file.

#ifndef HISTOGRAM_H
#define HISTOGRAM_H

#include <vector>

using namespace std;

class Hash {
public:
  double  mVal;       
  int     mCnt;       

public:

  Hash( double val ) {
    mVal = val;
    mCnt = 1;
  }


  void    incCnt( ) {
    mCnt++;
  }


  double  getVal( ) {
    return mVal;
  }


  int     getCnt( ) {
    return mCnt;
  }
};

class Histogram {
private:
  int       mLen;           // LENGTH OF THE DATASET
  int       mMaxCnt;        // MAX COUNT OF ALL VALUES
  double    mMin;           // MIN DATA VALUE
  double    mMax;           // MAX DATA VALUE

  vector<Hash>    mHist;      // THE HISTOGRAM

  void insert( double val ) {
    Hash hash( val );
    mHist.insert( (vector<Hash>::iterator)findGt( val ), hash );
  }

  Hash* find( double val ) {
    int l;  // LEFT POS IN ARRAY
    int r;  // RIGHT POS IN ARRAY
    int m;  // MID POS BETWEEN LEFT & RIGHT

    // ----------------------------------------------------------------
    // INITIALIZE POSITIONS
    l = 0;
    r = mHist.size() -1;

    // NOTHING TO SEARCH?
    if ( r == -1 )
      return NULL;

    m = r / 2;
    // ----------------------------------------------------------------

    // ----------------------------------------------------------------
    // FIND THE POSITION OF THE Hash WITH val
    while ( l < r-1 ) {
      if ( val > mHist[m].mVal )
        l = m;
      else if ( val < mHist[m].mVal )
        r = m;
      else
        return &mHist[m];

      m = ((r - l) / 2) + l;
    }

    if ( val == mHist[l].mVal )
      return &mHist[l];

    if ( val == mHist[r].mVal )
      return &mHist[r];
    // ----------------------------------------------------------------

    // THERE'S NO Hash WITH val
    return NULL;
  }

  Hash* findGt( double val ) {
    int l;  // LEFT POS IN ARRAY
    int r;  // RIGHT POS IN ARRAY
    int m;  // MID POS BETWEEN LEFT & RIGHT

    // ----------------------------------------------------------------
    // INITIALIZE POSITIONS
    l = 0;
    r = mHist.size() -1;

    // NOTHING TO SEARCH?
    if ( r == -1 )
      return NULL;

    m = r / 2;
    // ----------------------------------------------------------------

    // ----------------------------------------------------------------
    // FIND THE POSITION OF THE Hash WITH val
    while ( l < r-1 ) {
      if ( val > mHist[m].getVal() )
        l = m;
      else
        r = m;

      m = ((r - l) / 2) + l;
    }

    if ( val <= mHist[l].getVal() )
      return &mHist[l];

    if ( val <= mHist[r].getVal() )
      return &mHist[r];
    // ----------------------------------------------------------------

    // ***************************************************
    // This seems wrong.  If r==0 and it gets here it should
    // crash. FIX!
    // ***************************************************
    return &mHist[r+1];
  }

public:

  Histogram( ) {
    mLen = 0;
    mMaxCnt = 0;
    mMin = 0;
    mMax = 255;
  }
  template<class DType>
  void calcHist( DType *data, int len  ) {
    Hash    *hash = NULL;   // THE RESULTING HISTOGRAM
    int     iVal = 0;       // ARRAY INDEX

    mLen = len;

    // ----------------------------------------------------------------
    // LOOP THROUGH DATASET & CALC HISTOGRAM
    for ( ; iVal < mLen; iVal++ ) {
      hash = find( (double)data[iVal] );

      if ( hash )
        hash->incCnt();
      else
        insert( (double)data[iVal] );
    }
    // ----------------------------------------------------------------

    // ----------------------------------------------------------------
    // DETERMINE THE HASH WITH THE GREATEST COUNT
    mMaxCnt = -1;
    for ( unsigned int i=0; i < mHist.size(); i++ )
      if ( mHist[i].mCnt > mMaxCnt )
        mMaxCnt = mHist[i].mCnt;
      // ----------------------------------------------------------------

      // SINCE THIS IS AN ORDERED SET, THE MIN & MAX ARE ON THE ENDS
    mMin = mHist[0].mVal;
    mMax = mHist[mHist.size()-1].mVal;

  }

  vector<Hash> getHist( ) {
    return mHist;
  }


  double getMin( ) {
    return mMin;
  }


  double getMax( ) {
    return mMax;
  }


  int    getLen( ) {
    return mLen;
  }


  int    getMaxCnt( ) {
    return mMaxCnt;
  }
};
#endif

---

Home | Search | Disclaimers & Privacy | Contact Us GLIMSView Maintainer: dsoltesz@usgs.gov