Object/Developer/_cube_8h_source.html

#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