ProcessImport.h

Go to the documentation of this file.

#ifndef ProcessImport_h
#define ProcessImport_h

#include <string>

#include "Buffer.h"
#include "CubeAttribute.h"
#include "EndianSwapper.h"
#include "JP2Decoder.h"
#include "PixelType.h"
#include "Process.h"
#include "PvlTranslationManager.h"
#include "SpecialPixel.h"

namespace Isis {
  class ProcessImport : public Isis::Process {
    public:
      ProcessImport();
      ~ProcessImport();
      void StartProcess();
      void StartProcess(void funct(Isis::Buffer &out));
      void SetInputFile(const QString &file);
      Isis::Cube *SetOutputCube(const QString &parameter);
      Isis::Cube *SetOutputCube(const QString &parameter,
                                Isis::CubeAttributeOutput &att);
      void SetPixelType(const Isis::PixelType type);
      Isis::PixelType PixelType() {
        return p_pixelType;
      }
      void SetDimensions(const int ns, const int nl, const int nb);

      int Samples() {
        return p_ns;
      }

      int Lines() {
        return p_nl;
      }

      int Bands() {
        return p_nb;
      }

      void SetByteOrder(const Isis::ByteOrder order);

      Isis::ByteOrder ByteOrder() {
        return p_byteOrder;
      }

      void SetFileHeaderBytes(const int bytes);
      void SetFileTrailerBytes(const int bytes);
      void SetDataHeaderBytes(const int bytes);
      void SetDataTrailerBytes(const int bytes);
      void SetDataPrefixBytes(const int bytes);
      void SetDataSuffixBytes(const int bytes);
      void SaveFileHeader();
      void SaveFileTrailer();
      void SaveDataHeader();
      void SaveDataTrailer();
      void SaveDataPrefix();
      void SaveDataSuffix();
      char *FileHeader();
      char *FileTrailer();
      std::vector<char *> DataHeader();
      std::vector<char *> DataTrailer();
      std::vector<std::vector<char *> > DataPrefix();
      std::vector<std::vector<char *> > DataSuffix();

      enum Interleave {
        InterleaveUndefined, 
        JP2,                 
        BSQ,                
        BIL,                 
        BIP                  
      };
      void SetOrganization(const ProcessImport::Interleave org);

      void SetBase(const double base);
      void SetMultiplier(const double mult);
      void SetBase(const std::vector<double> base);
      void SetMultiplier(const std::vector<double> mult);

      void SetSpecialValues(const double null, const double lrs,
                            const double lis, const double hrs,
                            const double his);
      void SetNull(const double null_min, const double null_max);
      void SetLRS(const double lrs_min, const double lrs_max);
      void SetLIS(const double lis_min, const double lis_max);
      void SetHRS(const double hrs_min, const double hrs_max);
      void SetHIS(const double his_min, const double his_max);

      double TestPixel(const double pixel);

#if 0
      void AddImportLabel(Isis::Pvl &importLab);
      void AddLabel(Isis::Pvl &label);
#endif


    private:
      QString p_inFile;        
      Isis::PixelType p_pixelType; 
      int p_ns;                    
      int p_nl;                    
      int p_nb;                    
      Isis::ByteOrder p_byteOrder; 
      int p_fileHeaderBytes;       
      int p_fileTrailerBytes;      
      int p_dataHeaderBytes;       
      int p_dataTrailerBytes;      
      int p_dataPreBytes;          
      int p_dataPostBytes;         
      bool p_saveFileHeader;       
      bool p_saveDataHeader;       
      bool p_saveDataTrailer;      
      bool p_saveDataPre;          
      bool p_saveDataPost;         
      bool p_saveFileTrailer;      
      char *p_fileHeader;                          
      std::vector<char *>p_dataHeader;             
      std::vector<char *>p_dataTrailer;            
      std::vector<std::vector<char *> >p_dataPre;  
      std::vector<std::vector<char *> >p_dataPost; 
      char *p_fileTrailer;                         

      ProcessImport::Interleave p_organization; 
      std::vector<double> p_base; 
      std::vector<double> p_mult; 
      double p_null_min;     
      double p_null_max;     
      double p_hrs_min;     
      double p_hrs_max;     
      double p_his_min;     
      double p_his_max;     
      double p_lrs_min;     
      double p_lrs_max;     
      double p_lis_min;     
      double p_lis_max;     
      void ProcessBsq(void funct(Isis::Buffer &out) = NULL);
      void ProcessBil(void funct(Isis::Buffer &out) = NULL);
      void ProcessBip(void funct(Isis::Buffer &out) = NULL);
      void ProcessJp2(void funct(Isis::Buffer &out) = NULL);

      void CheckPixelRange(QString pixelName, double min, double max);
  };
};
#endif