Equalization.h

Go to the documentation of this file.

#ifndef Equalization_h
#define Equalization_h

#include <vector>

#include <QString>
#include <QStringList>

#include "FileList.h"
#include "LeastSquares.h"
#include "OverlapNormalization.h"

using namespace std;

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

      void addHolds(QString holdListName);

      void calculateStatistics(double samplingPercent, 
                               int mincnt, 
                               bool wtopt,
                               LeastSquares::SolveMethod methodType);
      void recalculateStatistics(QString inStatsFileName);
      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:
          vector<double> gains;
          vector<double> offsets;
          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;

      // Should these be protected or private? (Recall children, i.e. HiEqual... can't
      // access Equalization's private vars directly)
      void calculateBandStatistics();
      void calculateOverlapStatistics();

      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();

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

      void clearNormalizations();
      void clearOverlapStatistics();

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

      void fromPvl(const PvlObject &inStats);
      void setSolved(bool solved);
      bool isSolved() const;

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

      bool m_normsSolved; 
      bool m_recalculating; 
      bool m_wtopt; 

      FileList m_imageList; //<! List of input image filenames

      double m_samplingPercent; 
      int m_validCnt; 
      int m_invalidCnt; 
      int m_mincnt; 

      int m_maxCube; 
      int m_maxBand; 

      QStringList m_badFiles; 

      vector<ImageAdjustment *> m_adjustments; //<! Corrective factors for equalization
      vector<int> m_holdIndices; 
      vector<bool> m_doesOverlapList; 
      vector<bool> m_alreadyCalculated; 
      vector<OverlapNormalization *> m_overlapNorms; 
      vector<OverlapStatistics *> m_overlapStats; 

      OverlapNormalization::SolutionType m_sType;
      LeastSquares::SolveMethod m_lsqMethod; 

      Pvl *m_results; 
  };
};

#endif