ProcessImport.h

#ifndef ProcessImport_h
#define ProcessImport_h
/* SPDX-License-Identifier: CC0-1.0 */
#include <string>
 
#include "Buffer.h"
#include "CubeAttribute.h"
#include "EndianSwapper.h"
#include "JP2Decoder.h"
#include "PixelType.h"
#include "Process.h"
#include "PvlToPvlTranslationManager.h"
#include "SpecialPixel.h"
#include "UserInterface.h"
 
namespace Isis {
  class ProcessImport : public Isis::Process {
    public:
      enum VAXDataType {
        VAX_REAL,
        VAX_INT
      };
 
 
      enum VAXSpecialPixel {
        VAX_MIN4,
        VAX_NULL4,
        VAX_LRS4,
        VAX_LIS4,
        VAX_HIS4,
        VAX_HRS4
      };
 
      ProcessImport();
      virtual ~ProcessImport();
 
      using Isis::Process::StartProcess;  // make parent functions visable
      virtual void StartProcess();
      virtual void StartProcess(void funct(Isis::Buffer &out));
      void SetInputFile(const QString &file);
      QString InputFile();
 
      // SetOutputCube() is not virtual in the Process class, so the following
      // definitions for this method are the only ones that are allowed for
      // ProcessImport objects and child objects
 
      using Isis::Process::SetOutputCube;  // make parent functions visable
      Isis::Cube *SetOutputCube(const QString &parameter);
      Isis::Cube *SetOutputCube(const QString &parameter, UserInterface &ui);
      virtual Isis::Cube *SetOutputCube(const QString &fname,
                                Isis::CubeAttributeOutput &att);
 
      void SetAttributes(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;
      }
 
      bool IsVAXSpecial(unsigned int *vax, VAXSpecialPixel pix);
      double VAXConversion(void *ibuf);
      void SetSuffixOffset(int samples,int lines, int coreBands, int itemBytes);
      void SetSuffixPixelType(const Isis::PixelType type);
      void SetVAXConvert(const bool vax_convert);
 
      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();
 
      int FileHeaderBytes() const;
      int FileTrailerBytes() const;
      int DataHeaderBytes() const;
      int DataTrailerBytes() const;
      int DataPrefixBytes() const;
      int DataSuffixBytes() const;
 
      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);
      Interleave Organization() const;
 
      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);
 
      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);
 
#if 0
      void AddImportLabel(Isis::Pvl &importLab);
      void AddLabel(Isis::Pvl &label);
#endif
 
 
    private:
      QString p_inFile;            
      Isis::PixelType p_pixelType; 
 
      Isis::PixelType p_suffixPixelType; 
      int p_ns;                    
      int p_nl;                    
      int p_nb;                    
      Isis::ByteOrder p_byteOrder; 
 
      int p_suffixData;             
      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;                         
 
      bool p_vax_convert;
 
      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;     
  };
};
#endif