ProcessMosaic.h

Go to the documentation of this file.

#ifndef ProcessMosaic_h
#define ProcessMosaic_h

#include "Process.h"
#include "Buffer.h"
#include "Portal.h"
enum BandCriteria {
  Lesser, Greater
};
enum FileType {
  inFile, outFile
};

namespace Isis {

#define SRC_IMAGE_TBL  "InputImages"
#define FLOAT_MAX      16777216       
#define FLOAT_MIN      -16777215      


  class ProcessMosaic : public Isis::Process {

    public:

      typedef struct {
        bool bTrack;   
        bool bCreate;  
        int  iBandNum; 
        std::string  sKeyName;  
        std::string  sKeyValue; 
        BandCriteria eCriteria; 
        int  iInBand;  
        int  iOutBand; 
      }MosaicOptions;

      enum MosaicPriority {
        input,  
        mosaic, 
        band,   
        average 
      };

      ProcessMosaic();

      ~ProcessMosaic();

      void StartProcess(const int &piOutSample, const int &piOutLine, const int &piOutBand);

      Isis::Cube *SetInputCube(const std::string &parameter,
                               const int ss = 1, const int sl = 1,
                               const int sb = 1,
                               const int ns = 0, const int nl = 0,
                               const int nb = 0);

      Isis::Cube *SetInputCube(const std::string &fname,
                               Isis::CubeAttributeInput &att,
                               const int ss = 1, const int sl = 1,
                               const int sb = 1,
                               const int ns = 0, const int nl = 0,
                               const int nb = 0);

      Isis::Cube *SetOutputCube(const std::string &psParameter);

      void SetBandBinMatch(bool pbFlag) {
        mbBandbinMatch = pbFlag;
      };

      void SetMosaicOrigin(int &piIndex);

      int GetIndexOffsetByPixelType(void);

      void ResetOriginBand(void);

      void BandComparison(int piIndex, int piIns, int piInl, int piIss, 
                          int piIsl, int piOss, int piOsl);

      int GetOriginDefaultByPixelType(void);

      int GetBandIndex(const FileType &peFileType);

      bool GetTrackStatus(void);

      MosaicPriority GetPriority(void){
        return mePriority;
      };
      
      void AddBandBinGroup(int piIsb, int piOsb);

      void AddDefaultBandBinGroup(void);

      void MatchBandBinGroup(const int piIsb, const int piOsb, int &piInb);
      
      bool ProcessAveragePriority(int piPixel, Portal& pInPortal, Portal& pOutPortal, Portal& pOrigPortal);

      void ResetCountBands(void);
       void SetHighSaturationFlag(bool pbFlag) {
         mbHighSat = pbFlag;
       } ;
       
       void SetLowSaturationFlag(bool pbFlag) {
         mbLowSat  = pbFlag;
       } ;
       
       void SetNullFlag(bool pbFlag) {
         mbNull    = pbFlag;
       } ;
       
       bool GetHighSaturationFlag(void) {
         return mbHighSat;
       } ;

       bool GetLowSaturationFlag(void) {
         return mbLowSat;
       };
       
       bool GetNullFlag(void) {
         return mbNull;
       };

      void SetPriority(MosaicPriority pePriority) {
        mePriority = pePriority;
      };

      void SetMatchDEM(bool pbMatchDEM) {
        mbMatchDEM = pbMatchDEM;
      }
      
      void MatchDEMShapeModel(void);
      
      void SetTrackFlag(bool pbFlag) {
        mMosaicOptions.bTrack = pbFlag;
      };
      
      bool GetTrackFlag(void) {
        return mMosaicOptions.bTrack;
      };

      void SetCreateFlag(bool pbFlag) {
        mMosaicOptions.bCreate  = pbFlag;
      };

      void SetBandNumber(int piBandNum) {
        mMosaicOptions.iBandNum = piBandNum;
      };

      void SetBandKeyWord(std::string psKeyName, std::string psKeyValue) {
        mMosaicOptions.sKeyName = psKeyName;
        mMosaicOptions.sKeyValue = psKeyValue;
      };

      void SetBandCriteria(BandCriteria peCriteria) {
        mMosaicOptions.eCriteria = peCriteria;
      };

      void Test(void);

      int GetInputStartLineInMosaic(void) {
        return miOsl;
      };
      
      int GetInputStartSampleInMosaic(void) {
        return miOss;
      };
      
      int GetInputStartBandInMosaic(void) {
        return miOsb;
      };

    private:
      int p_iss; 
      int p_isl; 
      int p_isb; 
      int p_ins; 
      int p_inl; 
      int p_inb; 

      int miOss; 
      int miOsl; 
      int miOsb; 

      bool mbBandbinMatch;

      bool mbMatchDEM;
      
      MosaicPriority mePriority;

      bool mbHighSat; 
      bool mbLowSat;  
      bool mbNull;    

      MosaicOptions mMosaicOptions; 
  };
};

#endif