HiCalUtil.h

#ifndef HiCalUtil_h
#define HiCalUtil_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <cmath>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>
 
#include "HiCalTypes.h"
#include "DbProfile.h"
#include "IString.h"
#include "Statistics.h"
#include "PvlKeyword.h"
#include "NumericalApproximation.h"
#include "FileName.h"
#include "Pvl.h"
#include "IException.h"
 
namespace Isis {
 
 template <typename T> inline T MIN(const T &A, const T &B) {
   if ( A < B ) { return (A); }
   else         { return (B); }
 }
 
 template <typename T> inline T MAX(const T &A, const T &B) {
   if ( A > B ) { return (A); }
   else         { return (B); }
 }
 
inline int ValidCount(const HiVector &v) {
  int n = 0;
  for (int i = 0 ; i < v.dim() ; i++) {
    if (!IsSpecial(v[i])) n++;
  }
  return (n);
}
 
inline int InValidCount(const HiVector &v) {
  int n = 0;
  for (int i = 0 ; i < v.dim() ; i++) {
    if (IsSpecial(v[i])) n++;
  }
  return (n);
}
 
inline int CpmmToCcd(int cpmm) {
  const int cpmm2ccd[] = {0,1,2,3,12,4,10,11,5,13,6,7,8,9};
  if ( (cpmm < 0) || (cpmm >= (int)(sizeof(cpmm2ccd)/sizeof(int))) ) {
    QString mess = "CpmmToCdd: Bad CpmmNumber (" + toString(cpmm) + ")";
    throw IException(IException::User, mess, _FILEINFO_);
  }
  return (cpmm2ccd[cpmm]);
}
 
 
inline QString CcdToFilter(int ccd) {
  if ( (ccd < 0) || (ccd > 13) ) {
    QString mess = "CcdToFilter: Bad Ccd Number (" + toString(ccd) + ")";
    throw IException(IException::User, mess, _FILEINFO_);
  }
 
  QString filter;
  if ( ccd <= 9 )     { filter = "RED"; }
  else if (ccd <= 11) { filter = "IR";  }
  else                { filter = "BG";  }
  return (filter);
}
 
inline HiMatrix cropLines(const HiMatrix &m, int sline, int eline) {
  int nlines(eline-sline+1);
  HiMatrix mcrop(nlines, m.dim2());
  for (int l =  0 ; l < nlines ; l++) {
    for (int s = 0 ; s < m.dim2() ; s++) {
      mcrop[l][s] = m[l+sline][s];
    }
  }
  return (mcrop);
}
 
inline HiMatrix cropSamples(const HiMatrix &m, int ssamp, int esamp) {
  int nsamps(esamp-ssamp+1);
  HiMatrix mcrop(m.dim1(), nsamps);
  for (int l =  0 ; l < m.dim1() ; l++) {
    for (int s = 0 ; s < nsamps ; s++) {
      mcrop[l][s] = m[l][s+ssamp];
    }
  }
  return (mcrop);
}
 
inline HiVector averageLines(const HiMatrix &m, int sline = 0, int eline = -1) {
  eline = (eline == -1) ? m.dim1() - 1 : eline;
  HiVector v(m.dim2());
  for (int s =  0 ; s < m.dim2() ; s++) {
    Statistics stats;
    for (int l = sline ; l <= eline ; l++) {
      stats.AddData(&m[l][s], 1);
    }
    v[s] = stats.Average();
  }
  return (v);
}
 
inline HiVector averageSamples(const HiMatrix &m, int ssamp = 0,
                               int esamp = -1) {
  esamp = (esamp == -1) ? m.dim2() - 1 : esamp;
  HiVector v(m.dim1());
  for (int l =  0 ; l < m.dim1() ; l++) {
    Statistics stats;
    for (int s = ssamp ; s <= esamp ; s++) {
      stats.AddData(&m[l][s], 1);
    }
    v[l] = stats.Average();
  }
  return (v);
}
 
template <typename T>
  T ConfKey(const DbProfile &conf, const QString &keyname, const T &defval,
            int index = 0) {
  if (!conf.exists(keyname)) { return (defval); }
  if (conf.count(keyname) < index) { return (defval); }
  QString iValue(conf.value(keyname, index));
  T value = iValue;  // This makes it work with a string?
  return (value);
}
 
template <typename T> int ToInteger(const T &value) {
    return toInt(QString(value).trimmed());
}
 
template <typename T> double ToDouble(const T &value) {
    return toDouble(QString(value).trimmed());
}
 
template <typename T> QString ToString(const T &value) {
    return (toString(value).trimmed());
}
 
inline bool IsEqual(const QString &v1, const QString &v2 = "TRUE") {
    return (v1.toUpper() == v2.toUpper());
}
 
inline bool IsTrueValue(const DbProfile &prof, const QString &key,
                   const QString &value = "TRUE") {
  if ( prof.exists(key) ) {
    return (IsEqual(prof(key), value));
  }
  return (false);
}
 
inline bool SkipModule(const DbProfile &prof) {
  return (IsTrueValue(prof, "Debug::SkipModule", "TRUE"));
}
 
 
inline HiMatrix appendLines(const HiMatrix &top, const HiMatrix &bottom) {
  //  Ensure same number samples
  if (top.dim2() != bottom.dim2()) {
       std::ostringstream mess;
        mess << "Top buffer samples (" << top.dim2()
             << ") do not match bottom buffer samples (" << bottom.dim2()
             << ")";
        throw IException(IException::User, mess.str(), _FILEINFO_);
  }
 
  int nlines(top.dim1()+bottom.dim1());
  HiMatrix mat(nlines, top.dim2());
  for (int lt = 0 ; lt < top.dim1() ; lt++) {
    for (int s = 0 ; s < top.dim2() ; s++) {
      mat[lt][s] = top[lt][s];
    }
  }
 
  int topl = top.dim1();
  for (int lb = 0 ; lb < bottom.dim1() ; lb++) {
    for (int s = 0 ; s < top.dim2() ; s++) {
      mat[topl+lb][s] = bottom[lb][s];
    }
  }
  return (mat);
}
 
inline HiMatrix appendSamples(const HiMatrix &left, const HiMatrix &right) {
  //  Ensure same number samples
  if (right.dim1() != right.dim1()) {
       std::ostringstream mess;
        mess << "Left buffer lines (" << left.dim1()
             << ") do not match right buffer lines (" << right.dim1()
             << ")";
        throw IException(IException::User, mess.str(), _FILEINFO_);
  }
 
  int nsamps(left.dim2()+right.dim2());
  HiMatrix mat(left.dim1(), nsamps);
  for (int ll = 0 ; ll < left.dim1() ; ll++) {
    for (int s = 0 ; s < left.dim2() ; s++) {
      mat[ll][s] = left[ll][s];
    }
  }
 
  int lefts = left.dim2();
  for (int lr = 0 ; lr < right.dim1() ; lr++) {
    for (int s = 0 ; s < right.dim2() ; s++) {
      mat[lr][lefts+s] = right[lr][s];
    }
  }
  return (mat);
}
 
class HiLineTimeEqn {
  public:
    HiLineTimeEqn() : _bin(1), _ltime(1.0) { }
    HiLineTimeEqn(int bin, double ltime) : _bin(bin), _ltime(ltime) { }
    virtual ~HiLineTimeEqn() { }
 
    void setLineTime(double ltime) { _ltime = ltime; }
    void setBin(int bin) { _bin = bin; }
    double Time(const double line) const {
      return (line * (_bin * _ltime * 1.0E-6));
    }
    double operator()(const double line) const { return (Time(line)); }
 
  private:
    double _bin;
    double _ltime;
};
 
inline double HiTempEqn(const double temperature, const double napcm2 = 2.0,
                        const double px = 12.0) {
  double temp = temperature + 273.0;
  double eg   = 1.1557 - (7.021E-4 * temp * temp) / (1108.0 + temp);
  const double K = 1.38E-23;
  const double Q = 1.6E-19;
  return (napcm2*(px*px)*2.55E7*std::pow(temp,1.5)*std::exp(-eg*Q/2.0/K/temp));
}
 
inline HiVector rebin(const HiVector &v, int n) {
  if ( n == v.dim() ) { return (v); }
  NumericalApproximation nterp(NumericalApproximation::CubicNatural);
  double mag((double) v.dim()/ (double) n);
 
  for ( int i = 0 ; i < v.dim() ; i++ ) {
    double x((double) i);
    if ( !IsSpecial(v[i]) ) {
      nterp.AddData(x,v[i]);
    }
  }
 
  // Compute the spline and fill the output vector
  HiVector vout(n);
  for ( int j = 0 ; j < n ; j++ ) {
    double x = (double) j * mag;
    vout[j] = nterp.Evaluate(x, NumericalApproximation::NearestEndpoint);
  }
  return (vout);
}
 
inline void RemoveHiBlobs(Pvl &label) {
  for ( int blob = 0 ; blob < label.objects() ; blob++ ) {
    if ( label.object(blob).isNamed("Table") ) {
      QString name = label.object(blob)["Name"][0];
      if ( name.toLower() == "hirise calibration ancillary" ||
           name.toLower() == "hirise calibration images" ||
           name.toLower() == "hirise ancillary") {
        label.deleteObject(blob);
        blob--;
      }
    }
  }
  return;
}
 
inline double GainLineStat(std::vector<double> &data) {
 
  //  Check for special conditions
  if (data.size() == 0)  return (Null);
  if (data.size() == 1) return (data[0]);
 
#if defined(USE_AVERAGE)
  Statistics stats;
  stats.AddData(&data[0], data.size());
  return (stat.Average());
#else
  std::sort(data.begin(), data.end());
  int meanIndex = data.size()/2;
  if ((data.size() % 2) == 1)  return data[meanIndex];
  return ((data[meanIndex-1]+data[meanIndex])/2.0);
#endif
}
 
};     // namespace Isis
#endif