SpecialPixel.h

Go to the documentation of this file.

#ifndef SpecialPixel_h
#define SpecialPixel_h

#include <vector>
#include <cmath>
#include <cfloat>
#include <QString>
#include <QStringList>

#include "IException.h"
#include "IString.h"

namespace Isis {


  //  Set up special kludge for double precision initialization
  typedef union {
    unsigned int i[2];
    double d;
  } DBL_UNION;

#if ISIS_LITTLE_ENDIAN
#  define DBL_INIT(a,b)  {(b), (a)}
#else
#  define DBL_INIT(a,b)  {(a), (b)}
#endif

  // Define 8-byte special pixel values for IEEE floating point
  const DBL_UNION IVALID_MIN8 = { DBL_INIT(0xFFEFFFFF, 0xFFFFFFFA) };
  const double VALID_MIN8          = IVALID_MIN8.d;
  const double ValidMinimum        = IVALID_MIN8.d; 
  const DBL_UNION INULL8 = { DBL_INIT(0xFFEFFFFF, 0xFFFFFFFB) };
  const double NULL8               = INULL8.d;
  const double Null                = INULL8.d;  

  const DBL_UNION ILOW_REPR_SAT8 = { DBL_INIT(0xFFEFFFFF, 0xFFFFFFFC) };
  const double LOW_REPR_SAT8       = ILOW_REPR_SAT8.d;
  const double Lrs                 = ILOW_REPR_SAT8.d;  
  const DBL_UNION ILOW_INSTR_SAT8 = { DBL_INIT(0xFFEFFFFF, 0xFFFFFFFD) };
  const double LOW_INSTR_SAT8      = ILOW_INSTR_SAT8.d;
  const double Lis                 = ILOW_INSTR_SAT8.d;  
  const DBL_UNION IHIGH_INSTR_SAT8 = { DBL_INIT(0xFFEFFFFF, 0xFFFFFFFE) };
  const double HIGH_INSTR_SAT8     = IHIGH_INSTR_SAT8.d;
  const double His                 = IHIGH_INSTR_SAT8.d; 
  const DBL_UNION IHIGH_REPR_SAT8  = { DBL_INIT(0xFFEFFFFF, 0xFFFFFFFF) };
  const double HIGH_REPR_SAT8      = IHIGH_REPR_SAT8.d;
  const double Hrs                 = IHIGH_REPR_SAT8.d;  
  const double VALID_MAX8 = DBL_MAX;
  const double ValidMaximum = DBL_MAX;  
#undef DBL_INIT

  // Define 4-byte special pixel values for IEEE floating point
  const int  IVALID_MIN4      = 0xFF7FFFFA;
  const float VALID_MIN4       = (*((const float *) &IVALID_MIN4));

  const int  INULL4           =         0xFF7FFFFB;
  const float NULL4            = (*((const float *) &INULL4));

  const int  ILOW_REPR_SAT4   =         0xFF7FFFFC;
  const float LOW_REPR_SAT4    = (*((const float *) &ILOW_REPR_SAT4));

  const int  ILOW_INSTR_SAT4  =         0xFF7FFFFD;
  const float LOW_INSTR_SAT4   = (*((const float *) &ILOW_INSTR_SAT4));

  const int  IHIGH_INSTR_SAT4 =         0xFF7FFFFE;
  const float HIGH_INSTR_SAT4  = (*((const float *) &IHIGH_INSTR_SAT4));

  const int  IHIGH_REPR_SAT4  =         0xFF7FFFFF;
  const float HIGH_REPR_SAT4   = (*((const float *) &IHIGH_REPR_SAT4));

  const float VALID_MAX4       = FLT_MAX;

  // 2-byte signed special pixel values
  const short VALID_MIN2     = ((short)(-32752));
  const short NULL2          = ((short)(-32768));
  const short LOW_REPR_SAT2  = ((short)(-32767));
  const short LOW_INSTR_SAT2 = ((short)(-32766));
  const short HIGH_INSTR_SAT2 = ((short)(-32765));
  const short HIGH_REPR_SAT2  = ((short)(-32764));
  const short VALID_MAX2      = ((short)   32767);

  // 2-byte unsigned special pixel values
  const unsigned short VALID_MINU2     = ((unsigned short)       3);
  const unsigned short NULLU2          = ((unsigned short)       0);
  const unsigned short LOW_REPR_SATU2  = ((unsigned short)       1);
  const unsigned short LOW_INSTR_SATU2 = ((unsigned short)       2);
  const unsigned short HIGH_INSTR_SATU2 = ((unsigned short)   65534);
  const unsigned short HIGH_REPR_SATU2  = ((unsigned short)   65535);
  const unsigned short VALID_MAXU2      = ((unsigned short)   65522);

  // 1-byte special pixel values
  const unsigned char VALID_MIN1  = ((unsigned char) 1);
  const unsigned char NULL1       = ((unsigned char) 0);
  const unsigned char LOW_REPR_SAT1 = ((unsigned char) 0);
  const unsigned char LOW_INSTR_SAT1 = ((unsigned char) 0);
  const unsigned char HIGH_INSTR_SAT1 = ((unsigned char) 255);
  const unsigned char HIGH_REPR_SAT1 = ((unsigned char) 255);
  const unsigned char VALID_MAX1    = ((unsigned char) 254);

  inline bool IsSpecial(const double d) {
    return (d < VALID_MIN8);
  }

  inline bool IsSpecial(const float f) {
    return (f < VALID_MIN4);
  }

  inline bool IsValidPixel(const double d) {
    return (d >= VALID_MIN8);
  }

  inline bool IsNullPixel(const double d) {
    return (d == NULL8);
  }

  inline bool IsHighPixel(const double d) {
    return (d == HIGH_REPR_SAT8) || (d == HIGH_INSTR_SAT8);
  }

  inline bool IsLowPixel(const double d) {
    return (d == LOW_REPR_SAT8) || (d == LOW_INSTR_SAT8);
  }

  inline bool IsHrsPixel(const double d) {
    return (d == HIGH_REPR_SAT8);
  }

  inline bool IsHisPixel(const double d) {
    return (d == HIGH_INSTR_SAT8);
  }

  inline bool IsLisPixel(const double d) {
    return (d == LOW_INSTR_SAT8);
  }

  inline bool IsLrsPixel(const double d) {
    return (d == LOW_REPR_SAT8);
  }

  inline double TestPixel(const float t) {
    if(t < VALID_MIN4) {
      if(t == NULL4) return (NULL8);
      if(t == LOW_REPR_SAT4) return (LOW_REPR_SAT8);
      if(t == LOW_INSTR_SAT4) return (LOW_INSTR_SAT8);
      if(t == HIGH_REPR_SAT4) return (HIGH_REPR_SAT8);
      if(t == HIGH_INSTR_SAT4) return (HIGH_INSTR_SAT8);
      return (LOW_REPR_SAT8);
    }
    else if(t > VALID_MAX4) {
      return (HIGH_REPR_SAT8);
    }
    else {
      return ((double) t);
    }
  }

  inline float TestPixel(const double t) {
    if(t < (double) VALID_MIN4) {
      if(t == NULL8) return (NULL4);
      if(t == LOW_REPR_SAT8) return (LOW_REPR_SAT4);
      if(t == LOW_INSTR_SAT8) return (LOW_INSTR_SAT4);
      if(t == HIGH_INSTR_SAT8) return (HIGH_INSTR_SAT4);
      if(t == HIGH_REPR_SAT8) return (HIGH_REPR_SAT4);
      return (LOW_REPR_SAT4);
    }
    else if(t > (double) VALID_MAX4) {
      return (HIGH_REPR_SAT8);
    }
    else {
      return ((float) t);
    }
  }

  inline QString PixelToString(double d) {
    if(Isis::IsSpecial(d)) {
      if(Isis::IsNullPixel(d)) return "Null";
      if(Isis::IsLrsPixel(d)) return "Lrs";
      if(Isis::IsHrsPixel(d)) return "Hrs";
      if(Isis::IsHisPixel(d)) return "His";
      if(Isis::IsLisPixel(d)) return "Lis";
      return "Invalid";
    }

    QString result;
    return result.setNum(d, 'g', 8);
  }
  inline double StringToPixel(const QString &str) {

    QString s = str.toUpper();

    QStringList legal;
    legal.push_back("NULL");
    legal.push_back("HRS");
    legal.push_back("LRS");
    legal.push_back("HIS");
    legal.push_back("LIS");
    int matches = 0;
    for(int i = 0; i < (int) legal.size(); i++) {
      if(legal[i].mid(0, s.size()) == s) {
        matches++;
      }
    }
    if(matches > 1) {
      QString msg = "Input [" + str + "] is not a unique abbreviation. Use " + s + "I or " + s + "R.";
      throw IException(IException::User, msg, _FILEINFO_);
    }
    if(matches == 0) {
      try {
        return toDouble(s);
      }
      catch(IException &e) {
        QString msg = "Input [" + str + "] does not appear to be a legal special pixel abbreviation or double value.";
        throw IException(e, IException::User, msg, _FILEINFO_);
      }
    }
    if(s[0] == 'N') return Null;
    if(s.mid(0, 2) == "HR") return Hrs;
    if(s.mid(0, 2) == "LR") return Lrs;
    if(s.mid(0, 2) == "HI") return His;
    else  return Lis;//(s.substr(0,2) == "LI")

  }
}

#endif