Object/Developer/_process_import_pds_8h_source.html

#ifndef ProcessImportPds_h

#define ProcessImportPds_h


/* SPDX-License-Identifier: CC0-1.0 */

#include "ProcessImport.h"


#include <vector>


#include "Pvl.h"

#include "PvlGroup.h"

#include <QString>


namespace Isis {

  class PvlToPvlTranslationManager;

  class Table;

  class ProcessImportPds : public ProcessImport {


    public:

      enum PdsFileType {

        Image = 1,

        Qube = 2,

        SpectralQube = 4,

        L0 = 8,

        Rdn = 16,

        Loc = 32,

        Obs = 64,

        CombinedSpectrum = 128,

        All = Image | Qube | SpectralQube | L0 | Rdn | Loc | Obs | CombinedSpectrum

      };

      ProcessImportPds();

      virtual ~ProcessImportPds();

      bool GetProjectionOffsetChange();

      PvlGroup GetProjectionOffsetGroup();

      void SetPdsFile(const QString &pdsLabelFile, const QString &pdsDataFile,

                      Pvl &pdsLabel, PdsFileType allowedTypes = All);

      void SetPdsFile(const Pvl &pdsLabelPvl, const QString &pdsDataFile,

                      PdsFileType allowedTypes = All);

      void ProcessLabel(const QString &pdsDataFile, PdsFileType allowedTypes);


      void TranslatePdsProjection(Pvl &lab);

      void TranslateIsis2Labels(Pvl &lab);

      void TranslatePdsLabels(Pvl &lab);


      bool IsIsis2();


      void OmitOriginalLabel();


      Table &ImportTable(QString pdsTableName);

      // since we are overriding StartProcess(), we must specify for other

      // overloaded calls to StartProcess(), the ProcessImport class method

      // definitions should be used.

      using ProcessImport::StartProcess;

      void StartProcess();

      void StartProcess(void funct(Isis::Buffer &out));

      void EndProcess();

      void Finalize();

    private:


      enum Source {

        NOSOURCE,

        PDS,

        ISIS2

      };


      enum EncodingType {

        NONE,

        JP2

      };


      void ProcessDataFilePointer(PvlToPvlTranslationManager & pdsXlater,

                                  const bool & calcOffsetOnly);

      void ProcessPixelBitandType(PvlToPvlTranslationManager & pdsXlater);

      void ProcessSpecialPixels(PvlToPvlTranslationManager & pdsXlater, const bool & isQube);


      void ProcessPdsImageLabel(const QString &pdsDataFile);

      void ProcessPdsQubeLabel(const QString &pdsDataFile, const QString &transFile);

      void ProcessPdsM3Label(const QString &pdsDataFile, PdsFileType fileType);

      void ProcessPdsCombinedSpectrumLabel(const QString &pdsDataFile);


      void ExtractPdsProjection(PvlToPvlTranslationManager &pdsXlater);

      void GetProjectionOffsetMults(double &xoff, double &yoff,

                                    double &xmult, double &ymult);


      void IdentifySource(Pvl &lab);


      void TranslateIsis2BandBin(Pvl &lab);

      void TranslateIsis2Instrument(Pvl &lab);

      void TranslatePdsBandBin(Pvl &lab);

      void TranslatePdsArchive(Pvl &lab);


      Pvl p_pdsLabel;

      QString p_labelFile;


      QString p_transDir;


      // Encoding info

      EncodingType p_encodingType;

      QString p_jp2File;

      // Projection info

      QString p_projection;

      bool p_projectionOffsetChange;

      PvlGroup p_projectionOffsetGroup;

      QString p_targetName;

      double p_equatorialRadius;

      double p_polarRadius;

      QString p_longitudeDirection;

      int p_longitudeDomain;

      QString p_latitudeType;

      double p_minimumLatitude;

      double p_maximumLatitude;

      double p_minimumLongitude;

      double p_maximumLongitude;

      double p_pixelResolution;

      double p_scaleFactor;

      double p_rotation;

      double p_sampleProjectionOffset;

      double p_lineProjectionOffset;

      double p_upperLeftX;

      double p_upperLeftY;


      bool p_keepOriginalLabel;

      std::vector<Table> p_tables;

      Source p_source;

  };

};


#endif