Pixel.h

#ifndef Pixel_h
#define Pixel_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include "SpecialPixel.h"
 
namespace Isis {
  class Pixel {
    public:
      Pixel();
      Pixel(int sample, int line, int band, double DN);
      Pixel(const Pixel& pixel);
      virtual ~Pixel();
 
 
      Pixel &operator=(const Pixel& other);
 
      int line() const;
      int sample() const;
      int band() const;
      double DN() const;
 
      static unsigned char To8Bit(const double d);
      unsigned char To8Bit();
      static short int To16Bit(const double d);
      short int To16Bit();
      static short unsigned int To16UBit(const double d);
      short unsigned int To16Ubit();
      static float To32Bit(const double d);
      float To32Bit();
 
      static double ToDouble(const unsigned char t);
      static double ToDouble(const short int t);
      static double ToDouble(const short unsigned int t);
      static double ToDouble(const float t);
      double ToDouble();
 
      static float ToFloat(const unsigned char d);
      static float ToFloat(const short int d);
      static float ToFloat(const short unsigned int d);
      static float ToFloat(const double d);
      float ToFloat();
 
      static std::string ToString(double d);
      std::string ToString();
 
      static inline bool IsSpecial(const double d) {
        return(d < VALID_MIN8);
      }
 
      bool IsSpecial() {
        return IsSpecial(m_DN);
      }
 
      static inline bool IsSpecial(const float f) {
        return(f < VALID_MIN4);
      }
 
      static inline bool IsValid(const double d) {
        return(d >= VALID_MIN8);
      }
 
      bool IsValid() {
        return IsValid(m_DN);
      }
 
      static inline bool IsNull(const double d) {
        return(d == NULL8);
      }
 
      bool IsNull() {
        return IsNull(m_DN);
      }
 
      static inline bool IsHigh(const double d) {
        return(d == HIGH_REPR_SAT8) || (d == HIGH_INSTR_SAT8);
      }
 
      bool IsHigh() {
        return IsHigh(m_DN);
      }
 
      static inline bool IsLow(const double d) {
        return(d == LOW_REPR_SAT8) || (d == LOW_INSTR_SAT8);
      }
 
      bool IsLow() {
        return IsLow(m_DN);
      }
 
      static inline bool IsHrs(const double d) {
        return(d == HIGH_REPR_SAT8);
      }
 
      bool IsHrs() {
        return IsHrs(m_DN);
      }
 
      static inline bool IsHis(const double d) {
        return(d == HIGH_INSTR_SAT8);
      }
 
      bool IsHis() {
        return IsHis(m_DN);
      }
 
      static inline bool IsLis(const double d) {
        return(d == LOW_INSTR_SAT8);
      }
 
      bool IsLis() {
        return IsLis(m_DN);
      }
 
      static inline bool IsLrs(const double d) {
        return(d == LOW_REPR_SAT8);
      }
 
      bool IsLrs() {
        return IsLrs(m_DN);
      }
 
  private:
    int m_line;
 
    int m_sample;
 
    int m_band;
 
    double m_DN;
 
  }; // end of pixel class
}
#endif