Object/Developer/_process_import_8h_source.html

#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