Process.h

#ifndef Process_h
#define Process_h
/* SPDX-License-Identifier: CC0-1.0 */
#include "Preference.h"
 
#include "Cube.h"
#include "Progress.h"
#include "CubeAttribute.h"
#include "Statistics.h"
 
template <typename T> class QSet;
template <typename T> class QList;
 
namespace Isis {
  const int SizeMatch = 1;
  const int SpatialMatch = 2;
  const int OneBand = 16;
  const int BandMatchOrOne = 32;
  const int ReadWrite = 64;
  const int AllMatchOrOne = 128;
};
 
namespace Isis {
  class UserInterface;
 
  class Process {
    protected:
      Isis::Progress *p_progress;  
      bool p_propagateLabels;
      bool p_propagateTables;
      bool p_propagatePolygons;
      bool p_propagateHistory;
      bool p_propagateOriginalLabel;
 
      std::vector< std::vector< Isis::Statistics * > > p_bandStats;
 
      std::vector< Isis::Statistics * > p_cubeStats;
 
      std::vector<Isis::Cube *> InputCubes;
 
      std::vector<Isis::Cube *> OutputCubes;
 
      QSet<Isis::Cube *> *m_ownedCubes;
 
    public:
      Process();
      virtual ~Process();
 
      virtual void StartProcess(void funct()) {
        funct();
      };
      virtual void EndProcess();
      virtual void Finalize();
 
      virtual Isis::Cube *SetInputCube(const QString &parameter,
                               const int requirements = 0);
      virtual Isis::Cube *SetInputCube(const QString &fname,
                               const Isis::CubeAttributeInput &att,
                               int requirements = 0);
      virtual void SetInputCube(Isis::Cube *inCube, int requirements = 0);
 
      virtual Isis::Cube *SetOutputCube(const QString &parameter);
      virtual Isis::Cube *SetOutputCubeStretch(const QString &parameter, UserInterface *ui=nullptr);
      virtual Isis::Cube *SetOutputCube(const QString &parameter, const int nsamps,
                                const int nlines, const int nbands = 1);
      virtual Isis::Cube *SetOutputCubeStretch(const QString &parameter, const int nsamps,
                                const int nlines, const int nbands = 1, UserInterface *ui=nullptr);
      virtual Isis::Cube *SetOutputCube(const QString &fname,
                                const Isis::CubeAttributeOutput &att,
                                const int nsamps, const int nlines,
                                const int nbands = 1);
 
      void AddInputCube(Cube *cube, bool owned = true);
      void AddOutputCube(Cube *cube, bool owned = true);
 
      void CheckRequirements(const Cube *cube, const int requirements);
 
      void ClearCubes();
      void ClearInputCubes();
      void ClearOutputCubes();
 
      void PropagateLabels(const bool prop);
      void PropagateLabels(const QString &cube);
      void PropagateTables(const bool prop);
      void PropagateTables(const QString &fromName, const QList<QString>& tableNames = QList<QString>());
      void PropagatePolygons(const bool prop);
      void PropagateHistory(const bool prop);
      void PropagateOriginalLabel(const bool prop);
 
      Isis::Progress *Progress() {
        return p_progress;
      };
 
      QString MissionData(const QString &mission, const QString &file,
                              bool highestVersion = false);
 
      void WriteHistory(Cube &cube);
 
      void CalculateStatistics();
 
      inline std::vector<Isis::Statistics *> BandStatistics(
        const unsigned index) {
        return p_bandStats[index];
      }
 
      inline Isis::Statistics *CubeStatistics(
        const unsigned index) {
        return p_cubeStats[index];
      }
  };
}
 
#endif