Statistics.cpp

Go to the documentation of this file.

#include <float.h>
#include <string>
#include "Statistics.h"
#include "IException.h"
#include "IString.h"

using namespace std;
namespace Isis {
  Statistics::Statistics() {
    SetValidRange();
    Reset();
  }

  void Statistics::Reset() {
    p_sum = 0.0;
    p_sumsum = 0.0;
    p_minimum = DBL_MAX;
    p_maximum = -DBL_MAX;
    p_totalPixels = 0;
    p_validPixels = 00;
    p_nullPixels = 0;
    p_lisPixels = 0;
    p_lrsPixels = 0;
    p_hrsPixels = 0;
    p_hisPixels = 0;
    p_overRangePixels = 0;
    p_underRangePixels = 0;
    p_removedData = false;
  }

  Statistics::~Statistics() {};

  void Statistics::AddData(const double *data, const unsigned int count) {
    for(unsigned int i = 0; i < count; i++) {
      double value = data[i];
      //Calls the inline AddData method  --see .h file.
      AddData(value);
    }
  }


  void Statistics::RemoveData(const double *data, const unsigned int count) {
    p_removedData = true;

    for(unsigned int i = 0; i < count; i++) {
      p_totalPixels--;

      if(Isis::IsValidPixel(data[i]) && InRange(data[i])) {
        p_sum -= data[i];
        p_sumsum -= data[i] * data[i];
        p_validPixels--;
      }
      else if(Isis::IsNullPixel(data[i])) {
        p_nullPixels--;
      }
      else if(Isis::IsHisPixel(data[i])) {
        p_hisPixels--;
      }
      else if(Isis::IsHrsPixel(data[i])) {
        p_hrsPixels--;
      }
      else if(Isis::IsLisPixel(data[i])) {
        p_lisPixels--;
      }
      else if(Isis::IsLrsPixel(data[i])) {
        p_lrsPixels--;
      }
      else if(AboveRange(data[i])) {
        p_overRangePixels--;
      }
      else {
        p_underRangePixels--;
      }
    }

    if(p_totalPixels < 0) {
      string m = "You are removing non-existant data in [Statistics::RemoveData]";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
  }

  void Statistics::RemoveData(const double data) {
    RemoveData(&data, 1);
  }

  void Statistics::SetValidRange(const double minimum, const double maximum) {
    p_validMinimum = minimum;
    p_validMaximum = maximum;

    if(p_validMaximum < p_validMinimum) {
      // get the min and max DN values in the chosen range
      IString sMin(minimum);
      IString sMax(maximum);
      std::string m = "Invalid Range: Minimum [" + sMin + "] must be less than the Maximum [" + sMax + "]";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
  }
  double Statistics::Average() const {
    if(p_validPixels < 1) return Isis::NULL8;
    return p_sum / p_validPixels;
  }

  double Statistics::StandardDeviation() const {
    if(p_validPixels <= 1) return Isis::NULL8;
    return sqrt(Variance());
  }

  double Statistics::Variance() const {
    if(p_validPixels <= 1) return Isis::NULL8;
    double temp = p_validPixels * p_sumsum - p_sum * p_sum;
    if(temp < 0.0) temp = 0.0;  // This should happen unless roundoff occurs
    return temp / ((p_validPixels - 1.0) * p_validPixels);
  }

  double Statistics::Rms() const {
    if(p_validPixels < 1) return Isis::NULL8;
    double temp = p_sumsum / p_validPixels;
    if(temp < 0.0) temp = 0.0;
    return sqrt(temp);
  }

  double Statistics::Minimum() const {
    if(p_removedData) {
      string m = "Minimum is invalid since you removed data";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    if(p_validPixels < 1) return Isis::NULL8;
    return p_minimum;
  }

  double Statistics::Maximum() const {
    if(p_removedData) {
      string m = "Maximum is invalid since you removed data";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    if(p_validPixels < 1) return Isis::NULL8;
    return p_maximum;
  }

  BigInt Statistics::TotalPixels() const {
    return p_totalPixels;
  }

  BigInt Statistics::ValidPixels() const {
    return p_validPixels;
  }

  BigInt Statistics::OverRangePixels() const {
    return p_overRangePixels;
  }

  BigInt Statistics::UnderRangePixels() const {
    return p_underRangePixels;
  }

  BigInt Statistics::NullPixels() const {
    return p_nullPixels;
  }

  BigInt Statistics::LisPixels() const {
    return p_lisPixels;
  }

  BigInt Statistics::LrsPixels() const {
    return p_lrsPixels;
  }

  BigInt Statistics::HisPixels() const {
    return p_hisPixels;
  }

  BigInt Statistics::HrsPixels() const {
    return p_hrsPixels;
  }

  BigInt Statistics::OutOfRangePixels() const {
    return p_overRangePixels + p_underRangePixels;
  }

  double Statistics::ChebyshevMinimum(const double percent) const {
    if((percent <= 0.0) || (percent >= 100.0)) {
      string m = "Invalid value for percent";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    if(p_validPixels < 1) return Isis::NULL8;
    double k = sqrt(1.0 / (1.0 - percent / 100.0));
    return Average() - k * StandardDeviation();
  }

  double Statistics::ChebyshevMaximum(const double percent) const {
    if((percent <= 0.0) || (percent >= 100.0)) {
      string m = "Invalid value for percent";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    if(p_validPixels < 1) return Isis::NULL8;
    double k = sqrt(1.0 / (1.0 - percent / 100.0));
    return Average() + k * StandardDeviation();
  }

  double Statistics::BestMinimum(const double percent) const {
    if(p_validPixels < 1) return Isis::NULL8;
    double min = ChebyshevMinimum(percent);
    if(Minimum() > min) min = Minimum();
    return min;
  }

  double Statistics::BestMaximum(const double percent) const {
    if(p_validPixels < 1) return Isis::NULL8;
    double max = ChebyshevMaximum(percent);
    if(Maximum() < max) max = Maximum();
    return max;
  }

  double Statistics::ZScore(const double value) const {
    if(StandardDeviation() == 0) {
      if(value == Maximum()) return 0;
      else {
        string m = "Undefined Z-score. Standard deviation is zero and";
        m += " the input value[" + Isis::IString(value) + "] is out of range [" + Isis::IString(Maximum()) + "].";
        throw IException(IException::Programmer, m, _FILEINFO_);
      }
    }
    return (value - Average()) / StandardDeviation();
  }

} // end namespace isis