ProcessImportPds.h

#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