Equalization.h

Go to the documentation of this file.

#ifndef Equalization_h
#define Equalization_h

#include <vector>

// TODO Don't include
#include "FileList.h"
// The following includes are needed since class enumerations are used as input
// parameters (calculateStatistics)
#include "LeastSquares.h"
#include "OverlapNormalization.h"


namespace Isis {
  class Buffer;
  class Cube;
  class FileList;
  class OverlapStatistics;
  class Pvl;
  class PvlGroup;
  class Statistics;
  class Equalization {
    public:
      Equalization(OverlapNormalization::SolutionType sType, QString fromListName);
      virtual ~Equalization();

      void addHolds(QString holdListName);

      void calculateStatistics(double sampPercent, int mincnt,
          bool wtopt,
          LeastSquares::SolveMethod methodType);
      void importStatistics(QString instatsFileName);
      void applyCorrection(QString toListName);

      PvlGroup getResults();
      void write(QString outstatsFileName);

      double evaluate(double dn, int imageIndex, int bandIndex) const;

    protected:
      class ImageAdjustment {
        public:
          ImageAdjustment(OverlapNormalization::SolutionType sType) { m_sType = sType; }
          ~ImageAdjustment() {}

          void addGain(double gain) {
            gains.push_back(gain);
          }

          void addOffset(double offset) {
            offsets.push_back(offset);
          }

          void addAverage(double average) {
            avgs.push_back(average);
          }

          double getGain(int index) const {
            return gains[index];
          }

          double getOffset(int index) const {
            return offsets[index];
          }

          double getAverage(int index) const {
            return avgs[index];
          }

          double evaluate(double dn, int index) const {
            double result = Null;

            double gain = gains[index];
            if (m_sType != OverlapNormalization::GainsWithoutNormalization) {
              double offset = offsets[index];
              double avg = avgs[index];
              result = (dn - avg) * gain + offset + avg;
            }
            else {
              result = dn * gain;
            }

            return result;
          }

        private:
          std::vector<double> gains;
          std::vector<double> offsets;
          std::vector<double> avgs;

          OverlapNormalization::SolutionType m_sType;
      };

      class CalculateFunctor {
        public:
          CalculateFunctor(Statistics *stats, double percent) {
            m_stats = stats;
            m_linc = (int) (100.0 / percent + 0.5);
          }

          virtual ~CalculateFunctor() {}

          void operator()(Buffer &in) const;

        protected:
          virtual void addStats(Buffer &in) const;

        private:
          Statistics *m_stats;
          int m_linc;
      };

      class ApplyFunctor {
        public:
          ApplyFunctor(const ImageAdjustment *adjustment) {
            m_adjustment = adjustment;
          }

          void operator()(Buffer &in, Buffer &out) const;

        private:
          const ImageAdjustment *m_adjustment;
      };

    protected:
      Equalization();
      void loadInputs(QString fromListName);
      void setInput(int index, QString value);
      const FileList & getInputs() const;

      virtual void fillOutList(FileList &outList, QString toListName);
      virtual void errorCheck(QString fromListName);

      void generateOutputs(FileList &outList);
      void loadOutputs(FileList &outList, QString toListName);
      void loadHolds(OverlapNormalization *oNorm);

      void setResults(std::vector<OverlapStatistics> &overlapStats);
      void setResults();

      void clearAdjustments();
      void addAdjustment(ImageAdjustment *adjustment);

      void addValid(int count);
      void addInvalid(int count);

    private:
      void init();
      std::vector<int> validateInputStatistics(QString instatsFileName);

      FileList m_imageList;
      std::vector<ImageAdjustment *> m_adjustments;
      std::vector<int> m_holdIndices;

      int m_validCnt;
      int m_invalidCnt;

      int m_mincnt;
      bool m_wtopt;

      int m_maxCube;
      int m_maxBand;

      OverlapNormalization::SolutionType m_sType;

      Pvl *m_results;
  };
};

#endif