Process.h

Go to the documentation of this file.

#ifndef Process_h
#define Process_h

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


      virtual Isis::Cube *SetOutputCube(const QString &parameter);
      virtual Isis::Cube *SetOutputCube(const QString &parameter, const int nsamps,
                                const int nlines, const int nbands = 1);
      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 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