OverlapNormalization.h

#ifndef OverlapNormalization_h
#define OverlapNormalization_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Statistics.h"
#include "LeastSquares.h"
 
namespace Isis {
  class BasisFunction;
 
  class OverlapNormalization {
    public:
 
      OverlapNormalization(std::vector<Statistics *> statsList);
 
      virtual ~OverlapNormalization();
 
      enum AddStatus {
 
        Success,
 
        NoOverlap,
 
        NoContrast
      };
 
      AddStatus AddOverlap(const Statistics &area1, const unsigned index1,
                           const Statistics &area2, const unsigned index2,
                           double weight = 1.0);
 
      inline void AddHold(unsigned holdIndex) {
        m_idHoldList.push_back(holdIndex);
      };
 
      enum SolutionType {
 
        Gains,
 
        Offsets,
 
        Both,
 
         GainsWithoutNormalization
      };
 
      void Solve(SolutionType type = Both,
                 LeastSquares::SolveMethod method=LeastSquares::QRD);
 
      double Average(const unsigned index) const;
      double Gain(const unsigned index) const;
      double Offset(const unsigned index) const;
 
      double Evaluate(double dn, unsigned index) const;
 
    private:
 
      std::vector<Statistics *> m_statsList;
 
      std::vector<int> m_idHoldList;
 
      class Overlap {
        public:
 
          Statistics area1;
 
          Statistics area2;
 
          int index1;
 
          int index2;
      };
 
      std::vector<Overlap> m_overlapList;
 
      std::vector<double> m_deltas;
 
      std::vector<double> m_weights;
 
 
      bool m_solved;
 
      SolutionType m_solutionType;
 
      std::vector<double> m_gains;
 
      std::vector<double> m_offsets;
 
 
      BasisFunction *m_gainFunction;
 
      BasisFunction *m_offsetFunction;
 
      LeastSquares *m_gainLsq;
 
      LeastSquares *m_offsetLsq;
 
      OverlapNormalization &operator=(const OverlapNormalization &);
 
      OverlapNormalization(const OverlapNormalization &);
  };
};
 
#endif