Cube.h

Go to the documentation of this file.

#ifndef Cube_h
#define Cube_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <vector>
 
// This is needed for the QVariant macro
#include <QMetaType>
#include <QList>
#include <QMap>
 
#include <nlohmann/json.hpp>
 
#include "Blob.h"
#include "IEndian.h"
#include "PixelType.h"
#include "PvlKeyword.h"
 
class QFile;
class QMutex;
class QString;
 
namespace Isis {
  class Buffer;
  class Camera;
  class CubeAttributeOutput;
  class CubeCachingAlgorithm;
  class CubeStretch;
  class FileName;
  class ImageIoHandler;
  class Projection;
  class Pvl;
  class PvlGroup;
  class Statistics;
  class Table;
  class Histogram;
  class History;
  class OriginalLabel;
  class OriginalXmlLabel;
  class ImagePolygon;
 

  class Cube {
    public:
      Cube();
      Cube(const FileName &fileName, QString access = "r");
 
      virtual ~Cube();

      enum Format {
        Bsq,
        Tile,
        GTiff
      };

      enum LabelAttachment {
        AttachedLabel,  
        DetachedLabel,  
        ExternalLabel,
        GdalLabel
      };
 
      void fromIsd(const FileName &fileName, Pvl &label, nlohmann::json &isd, QString access);
      void fromIsd(const FileName &fileName, FileName &labelFile, FileName &isdFile, QString access);
 
      void fromLabel(const FileName &fileName, Pvl &label, QString access);
 
      bool isOpen() const;
      bool isProjected() const;
      bool isReadOnly() const;
      bool isReadWrite() const;
      LabelAttachment labelsAttached() const;
 
      void attachSpiceFromIsd(nlohmann::json Isd);
      void attachLineScanTableFromIsd(nlohmann::json isd);
 
      void close(bool remove = false);
      Cube *copy(FileName newFile, const CubeAttributeOutput &newFileAttributes);
      void create(const QString &cfile);
      void create(const QString &cfile, const CubeAttributeOutput &att);
      void createGdal(QString &dataFileName, QString &, char **papszOptions);
      void checkAccess(QString access);
      void open(const QString &cfile, QString access = "r");
      void openCube(const QString &cubeFileName, QString access);
      void openGdal(const QString &cubeFileName, QString access);
      void reopen(QString access = "r");
 
      void read(Blob &blob,
                const std::vector<PvlKeyword> keywords = std::vector<PvlKeyword>()) const;
      void read(Buffer &rbuf) const;
      OriginalLabel readOriginalLabel(const QString &name="IsisCube") const;
      CubeStretch readCubeStretch(QString name="CubeStretch",
                                  const std::vector<PvlKeyword> keywords = std::vector<PvlKeyword>()) const;
      OriginalXmlLabel readOriginalXmlLabel() const;
      History readHistory(const QString &name = "IsisCube") const;
      ImagePolygon readFootprint() const;
      Table readTable(const QString &name);
      void write(Blob &blob, bool overwrite=true);
      void write(const Table &table);
      void write(const CubeStretch &cubeStretch);
      void write(OriginalLabel &lab);
      void write(const OriginalXmlLabel &lab);
      void write(History &history, const QString &name = "IsisCube");
      void write(const ImagePolygon &polygon);
      void write(Buffer &wbuf);
 
      void setBaseMultiplier(double base, double mult);
      void setMinMax(double min, double max);
      void setByteOrder(ByteOrder byteOrder);
      void setDimensions(int ns, int nl, int nb);
      void setExternalDnData(FileName cubeFileWithDnData);
      void setFormat(Format format);
      void setLabelsAttached(LabelAttachment attached);
      // void setLabelsExternal(bool external);
      void setLabelSize(int labelBytes);
      void setPixelType(PixelType pixelType);
      void setVirtualBands(const QList<QString> &vbands);
      void setVirtualBands(const std::vector<QString> &vbands);
 
      void relocateDnData(FileName dnDataFile);
//       static void relocateDnData(FileName externalLabelFile, FileName dnDataFile);
 
      virtual int bandCount() const;
      double base() const;
      ByteOrder byteOrder() const;
      Camera *camera();
      FileName externalCubeFileName() const;
      virtual QString fileName() const;
      Format format() const;
      virtual Histogram *histogram(const int &band = 1,
                                        QString msg = "Gathering histogram");
      virtual Histogram *histogram(const int &band, const double &validMin,
                                        const double &validMax,
                                        QString msg = "Gathering histogram");
      Pvl *label() const;
      int labelSize(bool actual = false) const;
      int lineCount() const;
      double multiplier() const;
      PixelType pixelType() const;
      virtual int physicalBand(const int &virtualBand) const;
      Projection *projection();
      int sampleCount() const;
      Statistics *statistics(const int &band = 1,
                             QString msg = "Gathering statistics");
      Statistics *statistics(const int &band, const double &validMin,
                             const double &validMax,
                             QString msg = "Gathering statistics");
 
      void addCachingAlgorithm(CubeCachingAlgorithm *);
      void clearIoCache();
      bool deleteBlob(QString BlobName, QString BlobType);
      void deleteGroup(const QString &group);
      PvlGroup &group(const QString &group) const;
      bool hasGroup(const QString &group) const;
      bool hasTable(const QString &name);
      bool hasBlob(const QString &name, const QString &type);
      void putGroup(const PvlGroup &group);
      void latLonRange(double &minLatitude, double &maxLatitude, double &minLongitude,
                       double &maxLongitude);
      FileName realDataFileName() const;
 
    private:
      void applyVirtualBandsToLabel();
      void cleanUp(bool remove);
 
      void construct();
      QFile *dataFile() const;
      GDALDataset *gdalDataset() const;
 
      void initialize();
      void initCoreFromLabel(const Pvl &label);
      void initCoreFromGdal(const QString &labelFile);
      void initLabelState(const Pvl &label);
      void initLabelFromFile(FileName labelFileName, bool readWrite);
      void openCheck();
      Pvl realDataFileLabel() const;
      void reformatOldIsisLabel(const QString &oldCube);
      void writeLabels();
 
    private:
      QFile *m_labelFile;

      QFile *m_dataFile;

      GDALDataset *m_geodataSet = nullptr;

      ImageIoHandler *m_ioHandler;

      ByteOrder m_byteOrder;

      Format m_format;

      PixelType m_pixelType;

      QMutex *m_mutex;

      Camera *m_camera;

      Projection *m_projection;

      FileName *m_labelFileName;

      FileName *m_dataFileName;

      FileName *m_tempCube;

      FileName *m_formatTemplateFile;

      LabelAttachment m_attached;

      Pvl *m_label;

      QMap<QString, Blob> m_blobMap;
      QList<QString> m_blobQueue;

      int m_labelBytes;

      int m_samples;

      int m_lines;

      int m_bands;

      double m_base;

      double m_multiplier;

      QList<int> *m_virtualBandList;
  };
}

Q_DECLARE_METATYPE(Isis::Cube *);
 
#endif