SpecialPixel.h

Go to the documentation of this file.

#ifndef SpecialPixel_h
#define SpecialPixel_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#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;
  const int IVALID_MAX4  = (*((const int *) &VALID_MAX4));
 
  // 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);
 
  // 4-byte unsigned special pixel values
  const unsigned int VALID_MINUI4      = ((unsigned int)       3);
  const unsigned int NULLUI4           = ((unsigned int)       0);
  const unsigned int LOW_REPR_SATUI4   = ((unsigned int)       1);
  const unsigned int LOW_INSTR_SATUI4  = ((unsigned int)       2);
  const unsigned int HIGH_INSTR_SATUI4 = ((unsigned int)   4294967294);
  const unsigned int HIGH_REPR_SATUI4  = ((unsigned int)   4294967295);
  const unsigned int VALID_MAXUI4      = ((unsigned int)   4294967282);
 
 
  // 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