Cube.h

#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 "Endian.h"
#include "PixelType.h"
#include "PvlKeyword.h"
 
class QFile;
class QMutex;
class QString;
 
namespace Isis {
  class Blob;
  class Buffer;
  class Camera;
  class CubeAttributeOutput;
  class CubeCachingAlgorithm;
  class CubeIoHandler;
  class CubeStretch;
  class FileName;
  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
      };
 
      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;
      bool labelsAttached() const;
 
      void attachSpiceFromIsd(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 open(const QString &cfile, QString access = "r");
      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(bool attached);
      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");
      bool storesDnData() const;
 
      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);
 
 
    private:
      void applyVirtualBandsToLabel();
      void cleanUp(bool remove);
 
      void construct();
      QFile *dataFile() const;
      FileName realDataFileName() const;
 
      void initialize();
      void initCoreFromLabel(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;
 
      CubeIoHandler *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;
 
      bool m_attached;
 
      bool m_storesDnData;
 
      Pvl *m_label;
 
      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