Process.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include <sstream>
#include <fstream>
 
#include <QSet>
 
#include "SessionLog.h"
#include "Process.h"
#include "FileName.h"
#include "Message.h"
#include "IException.h"
#include "IString.h"
#include "Preference.h"
#include "Application.h"
#include "History.h"
#include "OriginalLabel.h"
#include "LineManager.h"
 
using namespace std;
namespace Isis {
 

  Process::Process() {
    m_ownedCubes = NULL;
 
    p_progress = new Isis::Progress();
    p_progress->SetText("Working");
    p_propagateLabels = true;
    p_propagateTables = true;
    p_propagatePolygons = true;
    p_propagateHistory = true;
    p_propagateOriginalLabel = true;
 
    m_ownedCubes = new QSet<Cube *>;
  }
  Process::Process() {…}

  Process::~Process() {
    EndProcess();
    delete p_progress;
 
    delete m_ownedCubes;
    m_ownedCubes = NULL;
  }
  Process::~Process() {…}
 

  Isis::Cube *Process::SetInputCube(const QString &fname,
                                    const Isis::CubeAttributeInput &att,
                                    int requirements) {
    Isis::Cube *cube = new Isis::Cube;
    if(att.bands().size() != 0) {
      vector<QString> lame = att.bands();
      cube->setVirtualBands(lame);
    }
 
    try {
      if(requirements & Isis::ReadWrite) {
        cube->open(fname, "rw");
      }
      else {
        // Make sure attributes don't get processed twice
        cube->open(FileName(fname).expanded());
      }
    }
    catch(IException &e) {
      delete cube;
      throw;
    }
 
    CheckRequirements(cube, requirements);
 
    // Everything is good so save the cube on the stack
    AddInputCube(cube);
    return cube;
  }
  Isis::Cube *Process::SetInputCube(const QString &fname, {…}
 

   * Set the InputCube vector to an opened Cube which was dynamically allocated.
   * This is used if there already exists a valid opened cube
   *
   * @author Sharmila Prasad (5/7/2011)
   *
   * @param inCube - Pointer to input Cube
   *
   * @param requirements Requirements to check that the input cube meets.
   *                     See CheckRequirements().
   */
  void Process::SetInputCube(Isis::Cube *inCube, const int requirements)
  {
    if(inCube != NULL && inCube->isOpen()) {
      CheckRequirements(inCube, requirements);
      AddInputCube(inCube, false);
    }
    else {
      QString message = "Input cube does not exist";
      throw IException(IException::User, message, _FILEINFO_);
    }
  }
  void Process::SetInputCube(Isis::Cube *inCube, const int requirements) {…}
   * Set the InputCube vector to an opened Cube which was dynamically allocated. {…}
 

  Isis::Cube *Process::SetInputCube(const QString &parameter,
                                    const int requirements) {
    QString fname = Application::GetUserInterface().GetCubeName(parameter);
    Isis::CubeAttributeInput &att = Application::GetUserInterface().GetInputAttribute(parameter);
    return SetInputCube(FileName(fname).expanded(), att, requirements);
  }
  Isis::Cube *Process::SetInputCube(const QString &parameter, {…}
 

  Isis::Cube *Process::SetOutputCube(const QString &parameter) {
    // Make sure we have an input cube to get a default size from
    if(InputCubes.size() == 0) {
      QString message = "No input images have been selected ... therefore";
      message += "the output image size can not be determined";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    int nl = InputCubes[0]->lineCount();
    int ns = InputCubes[0]->sampleCount();
    int nb = InputCubes[0]->bandCount();
    return SetOutputCube(parameter, ns, nl, nb);
  }
  Isis::Cube *Process::SetOutputCube(const QString &parameter) {…}
 

  Isis::Cube *Process::SetOutputCubeStretch(const QString &parameter, UserInterface *ui) {
    // Make sure we have an input cube to get a default size from
    if(InputCubes.size() == 0) {
      QString message = "No input images have been selected ... therefore";
      message += "the output image size can not be determined";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    int nl = InputCubes[0]->lineCount();
    int ns = InputCubes[0]->sampleCount();
    int nb = InputCubes[0]->bandCount();
    return SetOutputCubeStretch(parameter, ns, nl, nb, ui);
  }
  Isis::Cube *Process::SetOutputCubeStretch(const QString &parameter, UserInterface *ui) {…}
 

   *                  this routine would allocate the file output.cub with size
   *                  specified by the first opened input cube. The output pixel
   *                  type will be propagated from the first loaded input cube or
   *                  will use the value in the application XML file for
   *                  pixelType.
   *
   * @param ns Number of samples to allocate
   *
   * @param nl Number of lines to allocate
   *
   * @param nb Number of bands to allocate
   *
   * @throws Isis::iException::Message
   */
  Isis::Cube *Process::SetOutputCube(const QString &parameter, const int ns,
                                     const int nl, const int nb) {
    // Make sure we have good dimensions
    if((ns <= 0) || (nl <= 0) || (nb <= 0)) {
      ostringstream message;
      message << "Invalid cube size specifications [ns=" << ns << ",nl=" << nl
              << ",nb=" << nb << "]";
      throw IException(IException::Programmer, message.str().c_str(), _FILEINFO_);
    }
    QString fname;
    Isis::CubeAttributeOutput atts;
    fname = Application::GetUserInterface().GetCubeName(parameter);
    atts = Application::GetUserInterface().GetOutputAttribute(parameter);
    return SetOutputCube(fname, atts, ns, nl, nb);
}
  Isis::Cube *Process::SetOutputCube(const QString &parameter, const int ns, {…}
 

Isis::Cube *Process::SetOutputCubeStretch(const QString &parameter, const int ns,
                                   const int nl, const int nb, UserInterface *ui) {
  // Make sure we have good dimensions
  if((ns <= 0) || (nl <= 0) || (nb <= 0)) {
    ostringstream message;
    message << "Invalid cube size specifications [ns=" << ns << ",nl=" << nl
            << ",nb=" << nb << "]";
    throw IException(IException::Programmer, message.str().c_str(), _FILEINFO_);
  }
  QString fname;
  Isis::CubeAttributeOutput atts;
  if(ui==nullptr){
    fname = Application::GetUserInterface().GetCubeName(parameter);
    atts = Application::GetUserInterface().GetOutputAttribute(parameter);
  }
  else{
    fname = ui->GetCubeName(parameter);
    atts = ui->GetOutputAttribute(parameter);
  }
  return SetOutputCube(fname, atts, ns, nl, nb);
}
Isis::Cube *Process::SetOutputCubeStretch(const QString &parameter, const int ns, {…}
 

  Isis::Cube *Process::SetOutputCube(const QString &fname,
                                     const Isis::CubeAttributeOutput &att,
                                     const int ns, const int nl,
                                     const int nb) {
    // Make sure we have good dimensions
    if ((ns <= 0) || (nl <= 0) || (nb <= 0)) {
      ostringstream message;
      message << "Invalid cube size specifications [ns=" << ns << ",nl=" << nl
              << ",nb=" << nb << "]";
      throw IException(IException::Programmer, message.str().c_str(), _FILEINFO_);
    }
 
    // Setup the cube
    Isis::Cube *cube = new Isis::Cube;
    try {
      cube->setDimensions(ns, nl, nb);
      cube->setByteOrder(att.byteOrder());
      cube->setFormat(att.fileFormat());
      cube->setLabelsAttached(att.labelAttachment() == AttachedLabel);
      if(att.propagatePixelType()) {
        if(InputCubes.size() > 0) {
          cube->setPixelType(InputCubes[0]->pixelType());
        }
        else {
          QString msg = "You told me to propagate PixelType from input to output";
          msg += " cube but there are no input cubes loaded";
          throw IException(IException::Programmer, msg, _FILEINFO_);
        }
      }
      else {
        cube->setPixelType(att.pixelType());
      }
 
      if(att.propagateMinimumMaximum()) {
        if(cube->pixelType() == Isis::Real) {
          cube->setBaseMultiplier(0.0, 1.0);
        }
        else if(InputCubes.size() == 0) {
          QString msg = "You told me to propagate base/multiplier from input to output";
          msg += " cube but there are no input cubes loaded";
          throw IException(IException::Programmer, msg, _FILEINFO_);
        }
        else if(cube->pixelType() >= InputCubes[0]->pixelType()) {
          double base = InputCubes[0]->base();
          double mult = InputCubes[0]->multiplier();
          cube->setBaseMultiplier(base, mult);
        }
        else if((cube->pixelType() != Isis::Real) &&
                (cube->pixelType() != Isis::UnsignedByte) &&
                (cube->pixelType() != Isis::UnsignedWord) &&
                (cube->pixelType() != Isis::SignedWord) &&
                (cube->pixelType() != Isis::UnsignedInteger) &&
                (cube->pixelType() != Isis::SignedInteger)) {
          QString msg = "Looks like your refactoring to add different pixel types";
          msg += " you'll need to make changes here";
          throw IException(IException::Programmer, msg, _FILEINFO_);
        }
        else {
          QString msg = "You've chosen to reduce your output PixelType for [" +
                       fname + "] you must specify the output pixel range too";
          throw IException(IException::User, msg, _FILEINFO_);
        }
      }
      else {
        // Not propagating so either the user entered or the programmer did
        cube->setMinMax(att.minimum(), att.maximum());
      }
 
      if(InputCubes.size() > 0) {
        int needLabBytes = InputCubes[0]->labelSize(true) + (1024 * 6);
        if(needLabBytes > cube->labelSize()) {
          cube->setLabelSize(needLabBytes);
        }
      }
 
      // Allocate the cube
      cube->create(fname);
 
      // Transfer labels from the first input cube
      if((p_propagateLabels) && (InputCubes.size() > 0)) {
        Isis::PvlObject &incube =
            InputCubes[0]->label()->findObject("IsisCube");
        Isis::PvlObject &outcube = cube->label()->findObject("IsisCube");
        for(int i = 0; i < incube.groups(); i++) {
          outcube.addGroup(incube.group(i));
        }
 
        if (InputCubes[0]->label()->hasObject("NaifKeywords")) {
          cube->label()->addObject(
              InputCubes[0]->label()->findObject("NaifKeywords"));
        }
      }
 
      // Transfer tables from the first input cube
      if((p_propagateTables) && (InputCubes.size() > 0)) {
        Isis::Pvl &inlab = *InputCubes[0]->label();
        for(int i = 0; i < inlab.objects(); i++) {
          if(inlab.object(i).isNamed("Table")) {
            Isis::Blob t((QString)inlab.object(i)["Name"], inlab.object(i).name());
            InputCubes[0]->read(t);
            cube->write(t);
          }
        }
      }
 
      // Transfer blobs from the first input cube
      if((p_propagatePolygons) && (InputCubes.size() > 0)) {
        Isis::Pvl &inlab = *InputCubes[0]->label();
        for(int i = 0; i < inlab.objects(); i++) {
          if(inlab.object(i).isNamed("Polygon")) {
            Isis::Blob t((QString)inlab.object(i)["Name"], inlab.object(i).name());
            InputCubes[0]->read(t);
            cube->write(t);
          }
        }
      }
 
      // Transfer tables from the first input cube
      if((p_propagateOriginalLabel) && (InputCubes.size() > 0)) {
        Isis::Pvl &inlab = *InputCubes[0]->label();
        for(int i = 0; i < inlab.objects(); i++) {
          if(inlab.object(i).isNamed("OriginalLabel")) {
            Isis::OriginalLabel ol = InputCubes[0]->readOriginalLabel(inlab.object(i)["Name"]);
            cube->write(ol);
          }
        }
      }
 
      // Transfer history from the first input cube
      WriteHistory(*cube);
    }
    catch (IException &e) {
      delete cube;
      throw;
    }
    // Everything is fine so save the cube on the stack
    AddOutputCube(cube);
    return cube;
  }
  Isis::Cube *Process::SetOutputCube(const QString &fname, {…}
   */ {…}
 

  void Process::EndProcess() {
    Process::Finalize();
  }
  void Process::EndProcess() {…}
 

  void Process::Finalize() {
    ClearCubes();
  }
  void Process::Finalize() {…}
 
 
  void Process::AddInputCube(Cube *cube, bool owned) {
    InputCubes.push_back(cube);
    if (owned) m_ownedCubes->insert(cube);
  }
 
 
  void Process::AddOutputCube(Cube *cube, bool owned) {
    OutputCubes.push_back(cube);
    if (owned) m_ownedCubes->insert(cube);
  }
 

  void Process::CheckRequirements(const Cube *cube, int requirements) {
    // Test for same size or one in all dimensions
    if(requirements & Isis::AllMatchOrOne) {
      if(InputCubes.size() > 0) {
        if(cube->lineCount() != 1) {
          if(cube->lineCount() != InputCubes[0]->lineCount()) {
            QString message = "The number of lines in the secondary input cubes must match";
            message += " the primary input cube or be exactly one";
            throw IException(IException::User, message, _FILEINFO_);
          }
        }
 
        if(cube->sampleCount() != 1) {
          if(cube->sampleCount() != InputCubes[0]->sampleCount()) {
            QString message = "The number of samples in the secondary input cubes must match";
            message += " the primary input cube or be exactly one";
            throw IException(IException::User, message, _FILEINFO_);
          }
        }
        if(cube->bandCount() != 1) {
          if(cube->bandCount() != InputCubes[0]->bandCount()) {
            QString message = "The number of bands in the secondary input cubes must match";
            message += " the primary input cube or be exactly one";
            throw IException(IException::User, message, _FILEINFO_);
          }
        }
 
        // Do not do a spatial match if this flag was set
        requirements = requirements & !Isis::SpatialMatch;
      }
    }
 
    // Test for size match if requested
    if(requirements & Isis::SizeMatch) {
      if(InputCubes.size() > 0) {
        if(cube->lineCount() != InputCubes[0]->lineCount()) {
          QString message = "The number of lines in the input cubes must match";
          throw IException(IException::User, message, _FILEINFO_);
        }
        if(cube->sampleCount() != InputCubes[0]->sampleCount()) {
          QString message = "The number of samples in the input cubes must match";
          throw IException(IException::User, message, _FILEINFO_);
        }
        if(cube->bandCount() != InputCubes[0]->bandCount()) {
          QString message = "The number of bands in the input cubes must match";
          throw IException(IException::User, message, _FILEINFO_);
        }
      }
    }
 
    // Test for spatial match if requested
    if(requirements & Isis::SpatialMatch) {
      if(InputCubes.size() > 0) {
        if(cube->lineCount() != InputCubes[0]->lineCount()) {
          QString message = "The number of lines in the input cubes must match";
          throw IException(IException::User, message, _FILEINFO_);
        }
        if(cube->sampleCount() != InputCubes[0]->sampleCount()) {
          QString message = "The number of samples in the input cubes must match";
          throw IException(IException::User, message, _FILEINFO_);
        }
      }
    }
 
    // Test for one band
    if(requirements & Isis::OneBand) {
      if(cube->bandCount() != 1) {
        QString message = "Input cube [" + cube->fileName() + "] must have one band";
        throw IException(IException::User, message, _FILEINFO_);
      }
    }
 
    // Test for same bands or one band
    if(requirements & Isis::BandMatchOrOne) {
      if(cube->bandCount() != 1) {
        if(InputCubes.size() > 0) {
          if(cube->bandCount() != InputCubes[0]->bandCount()) {
            QString message = "The number of bands in the secondary input cubes must match";
            message += " the primary input cube or be exactly one";
            throw IException(IException::User, message, _FILEINFO_);
          }
        }
      }
    }
  }
  void Process::CheckRequirements(const Cube *cube, int requirements) {…}
 

  void Process::ClearCubes() {
    // Close the cubes
    ClearInputCubes();
    ClearOutputCubes();
    m_ownedCubes->clear();
  }
  void Process::ClearCubes() {…}
 

  void Process::ClearInputCubes() {
    // Close the cubes
    for (unsigned int i = 0; i < InputCubes.size(); i++) {
      if (m_ownedCubes->contains(InputCubes[i])) {
        InputCubes[i]->close();
        delete InputCubes[i];
      }
    }
    InputCubes.clear();
  }
  void Process::ClearInputCubes() {…}
 

  void Process::ClearOutputCubes() {
    // Close the cubes
    for (unsigned int i = 0; i < OutputCubes.size(); i++) {
      if (m_ownedCubes->contains(OutputCubes[i])) {
        OutputCubes[i]->close();
        delete OutputCubes[i];
      }
    }
    OutputCubes.clear();
  }
  void Process::ClearOutputCubes() {…}
 

  void Process::PropagateLabels(const bool prop) {
    p_propagateLabels = prop;
  }
  void Process::PropagateLabels(const bool prop) {…}
 

  void Process::PropagateLabels(const QString &cube) {
    // Open the Pvl file
    Isis::Pvl inLabels(cube);
 
    // Loop for each output cube
    for(int i = 0; i < (int)OutputCubes.size(); i++) {
      Isis::PvlObject &inCubeLabels = inLabels.findObject("IsisCube");
 
      Isis::Pvl &outLabels(*OutputCubes[i]->label());
      Isis::PvlObject &outCubeLabels = outLabels.findObject("IsisCube");
 
      for(int g = 0; g < inCubeLabels.groups(); g++) {
        outCubeLabels.addGroup(inCubeLabels.group(g));
      }
 
      if (inLabels.hasObject("NaifKeywords")) {
        outLabels.addObject(inLabels.findObject("NaifKeywords"));
      }
    }
  }
  void Process::PropagateLabels(const QString &cube) {…}
 

  void Process::PropagateTables(const bool prop) {
    p_propagateTables = prop;
  }
  void Process::PropagateTables(const bool prop) {…}
 

  void Process::PropagateTables(const QString &fromName, const QList<QString> &tableNames) {
    Cube *fromCube = new Isis::Cube;
    fromCube->open(fromName);
    const Pvl *fromLabels = fromCube->label();
 
    for (unsigned int i = 0; i < OutputCubes.size(); i++) {
      for (int j = 0; j < fromLabels->objects(); j++) {
        const PvlObject &object = fromLabels->object(j);
 
        if (object.isNamed("Table")) {
          if (tableNames.isEmpty() || tableNames.contains(object["Name"])) {
            Blob table((QString) object["Name"], object.name());
            fromCube->read(table);
            OutputCubes[i]->write(table);
          }
        }
      }
    }
    fromCube->close();
    delete fromCube;
  }
  void Process::PropagateTables(const QString &fromName, const QList<QString> &tableNames) {…}
 

  void Process::PropagatePolygons(const bool prop) {
    p_propagatePolygons = prop;
  }
  void Process::PropagatePolygons(const bool prop) {…}
 

  void Process::PropagateHistory(const bool prop) {
    p_propagateHistory = prop;
  }
  void Process::PropagateHistory(const bool prop) {…}
 

  void Process::PropagateOriginalLabel(const bool prop) {
    p_propagateOriginalLabel = prop;
  }
  void Process::PropagateOriginalLabel(const bool prop) {…}
 

  QString Process::MissionData(const QString &mission, const QString &file,
                              bool highestVersion) {
    Isis::PvlGroup &dataDir = Isis::Preference::Preferences().findGroup("DataDirectory");
    QString dir = dataDir[mission];
 
    // See if the data directory is installed
    Isis::FileName installed(dir);
    if(!installed.fileExists()) {
      QString message = "Data directory for mission [" + mission + "] " +
                       "is not installed at your site";
      throw IException(IException::Io, message, _FILEINFO_);
    }
 
    Isis::FileName expanded(dir + "/" + file);
    // Highest version checks if the file exists, if we
    // do not ask for the highest version, then we need to check
    // if the file exists
    if (highestVersion) {
      expanded = expanded.highestVersion();
    }
    else {
      if (!expanded.fileExists()) {
        QString message = "The file [" + expanded.original() + "] " +
                          "cannot be found under [" + mission + "]";
        throw IException(IException::Io, message, _FILEINFO_);
      }
    }
    return expanded.expanded();
  }
  QString Process::MissionData(const QString &mission, const QString &file, {…}
 

  void Process::WriteHistory(Cube &cube) {
    if(p_propagateHistory) {
      bool addedHist = false;
      if(InputCubes.size() > 0) {
        Isis::Pvl & inlab = *InputCubes[0]->label();
        for(int i = 0; i < inlab.objects(); i++) {
          if(inlab.object(i).isNamed("History") && Isis::iApp != NULL) {
            QString histBlobName = (QString)inlab.object(i)["Name"];
            History h = InputCubes[0]->readHistory(histBlobName);
            h.AddEntry();
            cube.write(h, histBlobName);
            addedHist = true;
          }
        }
      }
 
      if(!addedHist && Isis::iApp != NULL) {
        Isis::History h = cube.readHistory();
        h.AddEntry();
 
        cube.write(h);
      }
    }
  }
  void Process::WriteHistory(Cube &cube) {…}
 

  void Process::CalculateStatistics() {
    for(unsigned cubeNum = 0; cubeNum < InputCubes.size(); cubeNum++) {
      Cube *cube = InputCubes[cubeNum];
 
      // Construct a line buffer manager and a statistics object
      Isis::LineManager line(*cube);
      Isis::Statistics *cubeStats = new Isis::Statistics();
 
      int bandStart = 1;
      int bandStop = cube->bandCount();
      int maxSteps = cube->lineCount() * cube->bandCount();
 
      QString cubeNumStr = toString(cubeNum + 1);
      QString totalCubes = toString((int)InputCubes.size());
      QString msg = "Calculating statistics for cube " + cubeNumStr + " of " + totalCubes;
 
      Isis::Progress progress;
      progress.SetText(msg);
      progress.SetMaximumSteps(maxSteps);
      progress.CheckStatus();
 
      // Loop and get the statistics for a good minimum/maximum
      vector<Statistics *> allBandStats;
      for(int useBand = bandStart; useBand <= bandStop; useBand++) {
        Isis::Statistics *bandStats = new Isis::Statistics();
 
        for(int i = 1; i <= cube->lineCount(); i++) {
          line.SetLine(i, useBand);
          cube->read(line);
          bandStats->AddData(line.DoubleBuffer(), line.size());
          cubeStats->AddData(line.DoubleBuffer(), line.size());
          progress.CheckStatus();
        }
 
        allBandStats.push_back(bandStats);
      }
 
      p_bandStats.push_back(allBandStats);
      p_cubeStats.push_back(cubeStats);
    }
  }
  void Process::CalculateStatistics() {…}
 
} // end namespace isis
   * {…}
   * {…}
   * {…}
   *                  type will be propagated from the first loaded input cube or {…}
   *                  this routine would allocate the file output.cub with size {…}