Equalization.h

#ifndef Equalization_h
#define Equalization_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#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