Stretch.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include <iostream>
 
#include <QDebug>
#include <QRegularExpression>
 
#include "Stretch.h"
#include "Histogram.h"
#include "IString.h"
#include "SpecialPixel.h"
#include "IException.h"
#include "Pvl.h"
 
using namespace std;
namespace Isis {

  Stretch::Stretch() {
    p_null = Isis::NULL8;
    p_lis = Isis::LOW_INSTR_SAT8;
    p_lrs = Isis::LOW_REPR_SAT8;
    p_his = Isis::HIGH_INSTR_SAT8;
    p_hrs = Isis::HIGH_REPR_SAT8;
    p_minimum = p_lrs;
    p_maximum = p_hrs;
    p_pairs = 0;
  }
 

  void Stretch::AddPair(const double input, const double output) {
    if(p_pairs > 0) {
      if(input <= p_input[p_pairs-1]) {
        string msg = "Input pairs must be in ascending order";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
    }
 
    p_input.push_back(input);
    p_output.push_back(output);
    p_pairs++;
  }

  double Stretch::Map(const double value) const {
    // Check special pixels first
    if(!Isis::IsValidPixel(value)) {
      if(Isis::IsNullPixel(value)) return p_null;
      if(Isis::IsHisPixel(value)) return p_his;
      if(Isis::IsHrsPixel(value)) return p_hrs;
      if(Isis::IsLisPixel(value)) return p_lis;
      return p_lrs;
    }
 
    // Check to see if we have any pairs
    if(p_input.size() == 0) return value;
 
    // Check to see if outside the minimum and maximum next
    if(value < p_input[0]) {
      if(!Isis::IsValidPixel(p_minimum)) {
        if(Isis::IsNullPixel(p_minimum)) return p_null;
        if(Isis::IsHisPixel(p_minimum)) return p_his;
        if(Isis::IsHrsPixel(p_minimum)) return p_hrs;
        if(Isis::IsLisPixel(p_minimum)) return p_lis;
        return p_lrs;
      }
      return p_minimum;
    }
 
    if(value > p_input[p_pairs-1]) {
      if(!Isis::IsValidPixel(p_maximum)) {
        if(Isis::IsNullPixel(p_maximum)) return p_null;
        if(Isis::IsHisPixel(p_maximum)) return p_his;
        if(Isis::IsHrsPixel(p_maximum)) return p_hrs;
        if(Isis::IsLisPixel(p_maximum)) return p_lis;
        return p_lrs;
      }
      return p_maximum;
    }
 
    // Check the end points
    if(value == p_input[0]) return p_output[0];
    if(value == p_input[p_pairs-1]) return p_output[p_pairs-1];
 
    // Ok find the surrounding pairs with a binary search
    int start = 0;
    int end = p_pairs - 1;
    while(start != end) {
      int middle = (start + end) / 2;
 
      if(middle == start) {
        end = middle;
      }
      else if(value < p_input[middle]) {
        end = middle;
      }
      else {
        start = middle;
      }
    }
 
    end = start + 1;
 
    // Apply the stretch
    double slope = (p_output[end] - p_output[start]) / (p_input[end] - p_input[start]);
    return slope * (value - p_input[end]) + p_output[end];
  }

  std::pair<double, double> Stretch::NextPair(QString &pairs) {
    std::pair<double, double> io;
    io.first = Null;
    io.second = Null;
 
    pairs = pairs.simplified().trimmed();
 
    if (pairs.contains(":")) {
      QStringList pairList = pairs.split(" ");
 
      QString firstPair = pairList.takeFirst();
 
      QStringList firstPairValues = firstPair.split(":");
 
      if (firstPairValues.count() == 2) {
        io.first = toDouble(firstPairValues.first());
        io.second = toDouble(firstPairValues.last());
 
        pairs = pairList.join(" ");
      }
    }
 
    return io;
  }

  void Stretch::Parse(const QString &pairs) {
    // Zero out the stretch arrays
    p_input.clear();
    p_output.clear();
    p_pairs = 0;
 
    std::pair<double, double> pear;
 
    QString p = pairs.simplified().trimmed();
    p.replace(QRegularExpression("[\\s]*:"), ":");
    p.replace(QRegularExpression(":[\\s]*"), ":");
    QStringList pairList = p.split(" ", Qt::SkipEmptyParts);
 
    try {
      foreach(QString singlePair, pairList) {
        pear = Stretch::NextPair(singlePair);
        Stretch::AddPair(pear.first, pear.second);
      }
    }
    catch(IException &e) {
      throw IException(e, IException::User, "Invalid stretch pairs [" + pairs + "]", _FILEINFO_);
    }
  }

  void Stretch::Parse(const QString &pairs, const Isis::Histogram *hist) {
    // Zero out the stretch arrays
    p_input.clear();
    p_output.clear();
    p_pairs = 0;
 
    QString p(pairs);
    std::pair<double, double> pear;
 
    // need to save the input dn values in order to
    // to detect collisions
    std::vector<double> converted;
 
    try {
      while(p.size() > 0) {
        pear = Stretch::NextPair(p);
        pear.first = hist->Percent(pear.first);
 
        // test for collision!
        // if collision occurs then ignore this pair and move on
        // to next pair
        bool collision = false;
        unsigned int k = 0;
        while(!collision && k < converted.size()) {
          if(pear.first == converted[k]) {
            collision = true;
          }
          else {
            k++;
          }
        }
        if(!collision) {
          Stretch::AddPair(pear.first, pear.second);
          converted.push_back(pear.first);
        }
      }
    }
 
    catch(IException &e) {
      throw IException(e, IException::User, "Invalid stretch pairs [" +
                       pairs + "]", _FILEINFO_);
    }
  }
 

  QString Stretch::Text() const {
 
    if(p_pairs < 0) return "";
 
    QString p("");
    for(int i = 0; i < p_pairs; i++) {
      p += toString(p_input[i]) + ":" + toString(p_output[i]) + " ";
    }
    return p.trimmed();
  }

  double Stretch::Input(int index) const {
    if(index >= p_pairs || index < 0) {
      return -1;
    }
    return p_input[index];
  }

  double Stretch::Output(int index) const {
    if(index >= p_pairs || index < 0) {
      return -1;
    }
    return p_output[index];
  }

  void Stretch::Load(QString &file, QString &grpName) {
    Pvl pvl(file);
    Load(pvl, grpName);
  }

  void Stretch::Load(Isis::Pvl &pvl, QString &grpName) {
    PvlGroup grp = pvl.findGroup(grpName, Isis::PvlObject::Traverse);
    PvlKeyword inputs = grp.findKeyword("Input");
    PvlKeyword outputs = grp.findKeyword("Output");
 
    if(inputs.size() != outputs.size()) {
      QString msg = "Invalid Pvl file: The number of Input values must equal the number of Output values";
      throw IException(IException::User, msg, _FILEINFO_);
    }
    for(int i = 0; i < inputs.size(); i++) {
      AddPair(toDouble(inputs[i]), toDouble(outputs[i]));
    }
  }
 

  void Stretch::Save(QString &file, QString &grpName) {
    Pvl p;
    Save(p, grpName);
    p.write(file);
  }
 
  void Stretch::Save(Isis::Pvl &pvl, QString &grpName) {
    PvlGroup *grp = new PvlGroup(grpName);
    PvlKeyword inputs("Input");
    PvlKeyword outputs("Output");
    for(int i = 0; i < Pairs(); i++) {
      inputs.addValue(toString(Input(i)));
      outputs.addValue(toString(Output(i)));
    }
    grp->addKeyword(inputs);
    grp->addKeyword(outputs);
    pvl.addGroup(*grp);
  }

  void Stretch::CopyPairs(const Stretch &other) {
    this->p_pairs = other.p_pairs;
    this->p_input = other.p_input;
    this->p_output = other.p_output;
  }
} // end namespace isis