CubeAttribute.h

Go to the documentation of this file.

#ifndef CubeAttribute_h
#define CubeAttribute_h

#include <string>

#include "Cube.h"
#include "Endian.h"
#include "iException.h"
#include "iString.h"
#include "PixelType.h"
#include "Pvl.h"

namespace Isis {

  enum RangeType {
    PropagateRange, 
    RangeSet,       
  };


  inline std::string RangeTypeName(RangeType rangeType) {
    if(rangeType == PropagateRange) return "Propagate";
    if(rangeType == RangeSet) return "Set";

    std::string msg = "Invalid output range type [" + Isis::iString(rangeType) + "]";
    throw Isis::iException::Message(Isis::iException::Parse, msg, _FILEINFO_);
  }


  inline RangeType RangeTypeEnumeration(const std::string &rangeType) {
    Isis::iString temp(rangeType);
    temp = temp.UpCase();
    if(temp == "PROPAGATE") return PropagateRange;
    if(temp == "SET") return RangeSet;

    std::string msg = "Invalid output range type string [" + rangeType + "]";
    throw Isis::iException::Message(Isis::iException::Parse, msg, _FILEINFO_);
  }


  enum LabelAttachment {
    AttachedLabel,  
    DetachedLabel   
  };


  inline std::string LabelAttachmentName(LabelAttachment labelType) {
    if(labelType == AttachedLabel) return "Attached";
    if(labelType == DetachedLabel) return "Detached";

    std::string msg = "Invalid label attachment type [" + Isis::iString(labelType) + "]";
    throw Isis::iException::Message(Isis::iException::Parse, msg, _FILEINFO_);
  }


  inline LabelAttachment LabelAttachmentEnumeration(const std::string &labelType) {
    Isis::iString temp(labelType);
    temp = temp.UpCase();
    if(temp == "ATTACHED") return AttachedLabel;
    if(temp == "DETACHED") return DetachedLabel;

    std::string msg = "Invalid label attachment type string [" + labelType + "]";
    throw Isis::iException::Message(Isis::iException::Parse, msg, _FILEINFO_);
  }



  class CubeAttribute {
    public:

      CubeAttribute();


      CubeAttribute(const Isis::iString &att);


      virtual ~CubeAttribute();


      virtual void Write(std::ostream &ostr) const;


      virtual void Write(std::string &str) const;


      virtual void Write(Isis::Pvl &pvl) const;

    protected:
      Isis::iString p_attribute; 
  };


  class CubeAttributeInput : public CubeAttribute {

    public:

      CubeAttributeInput();


      CubeAttributeInput(const Isis::iString &att);


      ~CubeAttributeInput();


      void Set(const std::string &att);


      void Reset();


      std::vector<std::string> Bands() const;

      std::string BandsStr() const;

      void Bands(const std::vector<std::string> &bands);

      void Bands(const std::string &bands);

      void Write(std::ostream &ostr) const;

      void Write(std::string &str) const;

      void Write(Isis::Pvl &pvl) const;

    private:
      std::vector<std::string> p_bands; 

      void Parse(const std::string &att);
  };


  class CubeAttributeOutput : public CubeAttribute {
    public:

      CubeAttributeOutput();

      CubeAttributeOutput(const Isis::iString &att);


      ~CubeAttributeOutput();


      inline bool PropagatePixelType() const {
        if(p_pixelTypeDef == "PROPAGATE") {
          return true;
        }
        return false;
      };

      inline bool PropagateMinimumMaximum() const {
        if(p_rangeType == Isis::PropagateRange) {
          return true;
        }
        return false;
      };

      void Set(const std::string &att);

      void Reset();

      std::string FileFormatStr() const;

      Cube::Format FileFormat() const;

      void Format(const Cube::Format &fmt);

      std::string ByteOrderStr() const;

      Isis::ByteOrder ByteOrder() const;

      void Order(const Isis::ByteOrder order);

      double Minimum() const;

      double Maximum() const;

      void Minimum(const double min);

      void Maximum(const double max);

      Isis::PixelType PixelType() const;

      void Label(Isis::LabelAttachment attachment) {
        p_labelAttachment = attachment;
      };

      bool AttachedLabel() const {
        return p_labelAttachment == Isis::AttachedLabel;
      };

      bool DetachedLabel() const {
        return p_labelAttachment == Isis::DetachedLabel;
      };

      void PixelType(const Isis::PixelType type);

      void Write(std::ostream &ostr) const;

      void Write(std::string &str) const;

      void Write(Isis::Pvl &pvl) const;


    private:
      Isis::PixelType p_pixelType; 

      std::string p_pixelTypeDef;
      Isis::RangeType p_rangeType;

      double p_minimum; 
      double p_maximum; 
      Cube::Format p_format; 
      Isis::ByteOrder p_order; 
      Isis::LabelAttachment p_labelAttachment; 

      void Parse(const std::string &att);

      void Initialize();

  };
};

#endif