ProcessExport.cpp

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <QCryptographicHash>
#include <QString>

#include "ProcessExport.h"
#include "Preference.h"
#include "IException.h"
#include "LineManager.h"
#include "BandManager.h"
#include "SpecialPixel.h"
#include "Histogram.h"
#include "Stretch.h"
#include "Application.h"
#include "EndianSwapper.h"
#include "Projection.h"

using namespace std;
namespace Isis {

  ProcessExport::ProcessExport() : Isis::Process() {

    p_outputMinimum = 0.0;
    p_outputMiddle = 0.5;
    p_outputMaximum = 1.0;

    p_inputMinimum.clear();
    p_inputMiddle.clear();
    p_inputMaximum.clear();

    p_endianSwap = NULL;

    setFormat(BSQ);
    SetOutputEndian(Isis::IsLsb() ? Isis::Lsb : Isis::Msb);
    SetOutputType(Isis::Real);

    p_Null_Set = false;
    p_Lis_Set = false;
    p_Lrs_Set = false;
    p_His_Set = false;
    p_Hrs_Set = false;

    m_cryptographicHash = new QCryptographicHash(QCryptographicHash::Md5);
    m_canGenerateChecksum = false;

    p_progress->SetText("Exporting");
  }


  ProcessExport::~ProcessExport() {
    if (p_endianSwap != NULL) {
      delete p_endianSwap;
    }
    for (unsigned int i = 0; i < p_str.size(); i++) {
      delete p_str[i];
    }
    p_str.clear();

    delete m_cryptographicHash;
  }


  void ProcessExport::SetInputRange(const double minimum, const double maximum) {
    double middle = (minimum + maximum) / 2.0;
    SetInputRange(minimum, middle, maximum);
  }

  void ProcessExport::SetInputRange(const double minimum, const double maximum, const int index) {
    double middle = (minimum + maximum) / 2.0;
    SetInputRange(minimum, middle, maximum, index);
  }

  void ProcessExport::SetInputRange(const double minimum, const double middle,
                                    const double maximum) {
    if (minimum >= middle) {
      string message =
        "minimum must be less than the middle [ProcessExport::SetInputRange]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
    if (middle >= maximum) {
      string message =
        "middle must be less than the maximum [ProcessExport::SetInputRange]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
    p_inputMinimum.clear();
    p_inputMinimum.resize(InputCubes.size(), minimum);
    p_inputMiddle.clear();
    p_inputMiddle.resize(InputCubes.size(), middle);
    p_inputMaximum.clear();
    p_inputMaximum.resize(InputCubes.size(), maximum);
  }

  void ProcessExport::SetInputRange(const double minimum, const double middle,
                                    const double maximum, const int index) {
    if (minimum >= middle) {
      string message =
        "minimum must be less than the middle [ProcessExport::SetInputRange]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
    if (middle >= maximum) {
      string message =
        "middle must be less than the maximum [ProcessExport::SetInputRange]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
    if (index >= (int)InputCubes.size() || index < 0) {
      string message =
        "index out of bounds";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }

    p_inputMinimum.resize(index + 1, minimum);
    p_inputMiddle.resize(index + 1, middle);
    p_inputMaximum.resize(index + 1, maximum);
    p_inputMinimum[index] = minimum;
    p_inputMiddle[index] = middle;
    p_inputMaximum[index] = maximum;
  }

  void ProcessExport::SetInputRange() {
    p_inputMinimum.clear();
    p_inputMiddle.clear();
    p_inputMaximum.clear();

    for (unsigned int i = 0; i < InputCubes.size(); i++) {
      // Get the manual stretch parameters if needed
      QString strType = Application::GetUserInterface().GetString("STRETCH");
      if (strType == "MANUAL") {
        p_inputMinimum.push_back(Application::GetUserInterface().GetDouble("MINIMUM"));
        p_inputMaximum.push_back(Application::GetUserInterface().GetDouble("MAXIMUM"));

        p_inputMiddle.push_back(Isis::NULL8);
      }

      // Or get the automatic parameters
      else if (strType != "NONE") {
        Isis::Histogram *hist = InputCubes[i]->histogram(0);
        p_inputMinimum.push_back(hist->Percent(
                                   Application::GetUserInterface().GetDouble("MINPERCENT")));
        p_inputMaximum.push_back(hist->Percent(
                                   Application::GetUserInterface().GetDouble("MAXPERCENT")));
        p_inputMiddle.push_back(Isis::NULL8);
        Application::GetUserInterface().Clear("MINIMUM");
        Application::GetUserInterface().Clear("MAXIMUM");
        Application::GetUserInterface().PutDouble("MINIMUM", p_inputMinimum[i]);
        Application::GetUserInterface().PutDouble("MAXIMUM", p_inputMaximum[i]);

        if (strType == "PIECEWISE") {
          p_inputMiddle[i] = hist->Median();

          // If the median is the min or max, back off to linear
          if (p_inputMiddle[i] == p_inputMinimum[i] ||
              p_inputMiddle[i] == p_inputMaximum[i]) {
            p_inputMiddle[i] = Isis::NULL8;
          }
        }

        // Make sure the image isn't constant
        if (p_inputMinimum[i] == p_inputMaximum[i]) {
          p_inputMaximum[i] = p_inputMinimum[i] + 1.0;
          if (strType == "PIECEWISE") p_inputMiddle[i] = p_inputMinimum[i] + 0.5;
        }
      }
    }
  }


   bool ProcessExport::HasInputRange() const {
     return p_inputMinimum.size() > 0;
   }


   double ProcessExport::GetInputMinimum(unsigned int n) const {
     if (n >= p_inputMinimum.size())
       throw IException(IException::Programmer,
           "There is no input minimum for channel " + IString((int) n),
           _FILEINFO_);

     return p_inputMinimum[n];
   }


   double ProcessExport::GetInputMaximum(unsigned int n) const {
     if (n >= p_inputMaximum.size())
       throw IException(IException::Programmer,
           "There is no input maximum for channel " + IString((int) n),
           _FILEINFO_);

     return p_inputMaximum[n];
   }


  void ProcessExport::SetOutputRange(const double minimum, const double maximum) {
    if (minimum >= maximum) {
      string message =
        "minimum must be less than the maximum [ProcessExport::SetOutputRange]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }

    p_outputMinimum = minimum;
    p_outputMaximum = maximum;
    p_outputMiddle = (p_outputMinimum + p_outputMaximum) / 2.0;
  }


  void ProcessExport::SetOutputNull(const double value) {
    p_Null = value;
    p_Null_Set = true;
  }


  void ProcessExport::SetOutputLis(const double value) {
    p_Lis = value;
    p_Lis_Set = true;
  }


  void ProcessExport::SetOutputLrs(const double value) {
    p_Lrs = value;
    p_Lrs_Set = true;
  }


  void ProcessExport::SetOutputHis(const double value) {
    p_His = value;
    p_His_Set = true;
  }


  void ProcessExport::SetOutputHrs(const double value) {
    p_Hrs = value;
    p_Hrs_Set = true;
  }


  double ProcessExport::OutputNull() {
    return p_Null_Set ? p_Null : p_outputMinimum;
  }


  double ProcessExport::OutputLis() {
    return p_Lis_Set ? p_Lis : p_outputMinimum;
  }


  double ProcessExport::OutputLrs() {
    return p_Lrs_Set ? p_Lrs : p_outputMinimum;
  }


  double ProcessExport::OutputHis() {
    return p_His_Set ? p_His : p_outputMaximum;
  }


  double ProcessExport::OutputHrs() {
    return p_Hrs_Set ? p_Hrs : p_outputMaximum;
  }


  void ProcessExport::SetOutputType(Isis::PixelType pixelIn) {
    p_pixelType = pixelIn;

    if (p_format < 0 || p_format > 3) {
      string message =
        "Format of the output file must be set prior to calling this method [ProcessExport::SetOutputType]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
    if (pixelIn == Isis::UnsignedByte)
      SetOutputRange((double)VALID_MIN1, (double)VALID_MAX1);
    else if (pixelIn == Isis::UnsignedWord)
      SetOutputRange((double)VALID_MINU2, (double)VALID_MAXU2);
    else if (pixelIn == Isis::SignedWord)
      SetOutputRange((double)VALID_MIN2, (double)VALID_MAX2);
    else if (pixelIn == Isis::Real)
      if (p_format == JP2) {
        string message =
          "Unsupported bit type for JP2 formatted files [ProcessExport::SetOutputType]";
        throw IException(IException::Programmer, message, _FILEINFO_);
      }
      else {
        SetOutputRange(-DBL_MAX, DBL_MAX);
      }
    else {
      string message =
        "Unsupported bit type [ProcessExport::SetOutputType]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
  }


  void ProcessExport::SetOutputEndian(enum ByteOrder byteOrderIn) {
    if (p_endianSwap != NULL) {
      delete p_endianSwap;
    }
    p_endianType = byteOrderIn;
    if (byteOrderIn == Isis::NoByteOrder) {
      p_endianSwap = new EndianSwapper("NoByteOrder");
    }
    else if (byteOrderIn == Isis::Lsb) {
      p_endianSwap = new EndianSwapper("LSB");
    }
    else if (byteOrderIn == Isis::Msb) {
      p_endianSwap = new EndianSwapper("MSB");
    }
  }


  void ProcessExport::setCanGenerateChecksum(bool flag) {
    m_canGenerateChecksum = flag;
  }


  bool ProcessExport::canGenerateChecksum() {
    return m_canGenerateChecksum;
  }


  QString ProcessExport::checksum() {

    QString checksum;

    if (!m_canGenerateChecksum) {
      QString msg = "Cannot generate a checksum. Call setGenerateChecksum(true) before startProcess";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    else {
      if (m_cryptographicHash == NULL) {
        QString msg = "Unable to generate a checksum. Did you call startProcess?";
        throw IException(IException::Programmer, msg, _FILEINFO_);
        return checksum;
      }

      checksum = m_cryptographicHash->result().toHex();
    }

    return checksum;
  }


  void ProcessExport::InitProcess() {
    if (InputCubes.size() < 1) {
      string m = "You have not specified any input cubes";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    // TODO this really belongs here, but causes problems because of its
    // coupling with an application User Interface that contains a STRETCH
    // parameter
    //if (!HasInputRange()) SetInputRange();

    // Construct a line buffer manager
    if (p_format == BIP) {
      p_progress->SetMaximumSteps((InputCubes[0]->sampleCount()) * (InputCubes[0]->lineCount()));
    }
    else {
      p_progress->SetMaximumSteps((InputCubes[0]->lineCount()) * (InputCubes[0]->bandCount()));
    }


    // Setup a stretch object
    p_str.clear();
    for (unsigned int i = 0; i < InputCubes.size(); i++) {
      p_str.push_back(new Stretch());
      if (p_inputMinimum.size() > 0) {
        if (Isis::IsValidPixel(p_inputMinimum[i])) {
          p_str[i]->AddPair(p_inputMinimum[i], p_outputMinimum);
          if (Isis::IsValidPixel(p_inputMiddle[i])) {
            p_str[i]->AddPair(p_inputMiddle[i], p_outputMiddle);
          }
          p_str[i]->AddPair(p_inputMaximum[i], p_outputMaximum);
        }
      }

      p_str[i]->SetNull(OutputNull());
      p_str[i]->SetLis(OutputLis());
      p_str[i]->SetLrs(OutputLrs());
      p_str[i]->SetHis(OutputHis());
      p_str[i]->SetHrs(OutputHrs());
    }

    p_progress->CheckStatus();
    return;
  }


  void ProcessExport::StartProcess(void funct(Isis::Buffer &in)) {
    InitProcess();

    Isis::BufferManager *buff;
    if (p_format == BSQ) {
      buff = new Isis::LineManager(*InputCubes[0]);
    }
    else if (p_format == BIL || p_format == JP2) {
      buff = new Isis::LineManager(*InputCubes[0], true);
    }
    else if (p_format == BIP) {
      buff = new Isis::BandManager(*InputCubes[0]);
    }
    else {
      string m = "Invalid storage order.";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    // Loop and let the app programmer fiddle with the buffers
    for (buff->begin(); !buff->end(); buff->next()) {
      // Read a line of data
      InputCubes[0]->read(*buff);
      // Stretch the pixels into the desired range
      for (int i = 0; i < buff->size(); i++) {
        (*buff)[i] = p_str[0]->Map((*buff)[i]);
      }
      // Invoke the user function
      funct(*buff);
      p_progress->CheckStatus();
    }
  }


  void ProcessExport::StartProcess(void funct(vector<Buffer *> &in)) {
    int length = (p_format == BIP) ?
      InputCubes[0]->bandCount() : InputCubes[0]->lineCount();

    // Loop and let the app programmer fiddle with the lines
    vector<BufferManager *> imgrs = GetBuffers();
    for (int k = 1; k <= length; k++) {
      vector<Buffer *> ibufs;

      for (unsigned int j = 0; j < InputCubes.size(); j++) {
        // Read a line of data
        InputCubes[j]->read(*imgrs[j]);

        // Stretch the pixels into the desired range
        for (int i = 0; i < InputCubes[0]->sampleCount(); i++)
          (*imgrs[j])[i] = p_str[j]->Map((*imgrs[j])[i]);

        ibufs.push_back(imgrs[j]);
      }

      // Invoke the user function
      funct(ibufs);

      for (unsigned int i = 0; i < imgrs.size(); i++) imgrs[i]->next();
      p_progress->CheckStatus();
    }
  }


  vector<BufferManager *> ProcessExport::GetBuffers() {
    InitProcess();
    vector<BufferManager *> imgrs;
    if (p_format == BSQ) {
      imgrs = GetBuffersBSQ();
    }
    else if (p_format == BIL || p_format == JP2) {
      imgrs = GetBuffersBIL();
    }
    else if (p_format == BIP) {
      imgrs = GetBuffersBIP();
    }
    else {
      string m = "Invalid storage order.";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
    return imgrs;
  }


  vector<BufferManager *> ProcessExport::GetBuffersBSQ() {
    int samples = InputCubes[0]->sampleCount();
    int lines = InputCubes[0]->lineCount();

    vector<BufferManager *> imgrs;
    for (unsigned int i = 0; i < InputCubes.size(); i++) {
      if ((InputCubes[i]->sampleCount() == samples) &&
          (InputCubes[i]->lineCount() == lines)) {

        Isis::LineManager *iline = new Isis::LineManager(*InputCubes[i]);
        iline->begin();
        imgrs.push_back(iline);
      }
      else {
        string m = "All input cubes must have the same dimensions";
        throw IException(IException::Programmer, m, _FILEINFO_);
      }
    }

    return imgrs;
  }


  vector<BufferManager *> ProcessExport::GetBuffersBIL() {
    int samples = InputCubes[0]->sampleCount();
    int lines = InputCubes[0]->lineCount();

    vector<BufferManager *> imgrs;
    for (unsigned int i = 0; i < InputCubes.size(); i++) {
      if ((InputCubes[i]->sampleCount() == samples) &&
          (InputCubes[i]->lineCount() == lines)) {

        Isis::LineManager *iline = new Isis::LineManager(*InputCubes[i], true);
        iline->begin();
        imgrs.push_back(iline);
      }
      else {
        string m = "All input cubes must have the same dimensions";
        throw IException(IException::Programmer, m, _FILEINFO_);
      }
    }

    return imgrs;
  }

  vector<BufferManager *> ProcessExport::GetBuffersBIP() {
    int bands = InputCubes[0]->bandCount();
    int samples = InputCubes[0]->sampleCount();

    vector<BufferManager *> imgrs;
    for (unsigned int i = 0; i < InputCubes.size(); i++) {
      if ((InputCubes[i]->bandCount() == bands) && (InputCubes[i]->sampleCount() == samples)) {
        Isis::BandManager *iband = new Isis::BandManager(*InputCubes[i]);
        iband->begin();
        imgrs.push_back(iband);
      }
      else {
        string m = "All input cubes must have the same dimensions";
        throw IException(IException::Programmer, m, _FILEINFO_);
      }
    }

    return imgrs;
  }




  void ProcessExport::StartProcess(std::ofstream &fout) {
    InitProcess();

    Isis::BufferManager *buff;
    if (p_format == BSQ) {
      buff = new Isis::LineManager(*InputCubes[0]);
    }
    else if (p_format == BIL) {
      buff = new Isis::LineManager(*InputCubes[0], true);
    }
    else if (p_format == BIP) {
      buff = new Isis::BandManager(*InputCubes[0]);
    }
    else {
      string m = "Output stream cannot be generated for requested storage order type.";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    //This if is the changed one
    if (m_canGenerateChecksum) {
      // Loop for each line of data
      for (buff->begin(); !buff->end(); buff->next()) {
        // Read a line of data
        InputCubes[0]->read(*buff);
        QByteArray byteArray;
        // Stretch the pixels into the desired range
        for (int i = 0; i < buff->size(); i++) {
          (*buff)[i] = p_str[0]->Map((*buff)[i]);
          byteArray.append((*buff)[i]);
        }
        if (p_pixelType == Isis::UnsignedByte)
          isisOut8(*buff, fout);
        else if (p_pixelType == Isis::UnsignedWord)
          isisOut16u(*buff, fout);
        else if (p_pixelType == Isis::SignedWord)
          isisOut16s(*buff, fout);
        else if (p_pixelType == Isis::Real)
          isisOut32(*buff, fout);
        p_progress->CheckStatus();
        m_cryptographicHash->addData(byteArray);
      }
    }
    else {
      for (buff->begin(); !buff->end(); buff->next()) {
        // Read a line of data
        InputCubes[0]->read(*buff);
        // Stretch the pixels into the desired range
        for (int i = 0; i < buff->size(); i++) {
          (*buff)[i] = p_str[0]->Map((*buff)[i]);
        }
        if (p_pixelType == Isis::UnsignedByte)
          isisOut8(*buff, fout);
        else if (p_pixelType == Isis::UnsignedWord)
          isisOut16u(*buff, fout);
        else if (p_pixelType == Isis::SignedWord)
          isisOut16s(*buff, fout);
        else if (p_pixelType == Isis::Real)
          isisOut32(*buff, fout);
        p_progress->CheckStatus();
      }
    }
    delete buff;
    return;
  }


  void ProcessExport::isisOut8(Buffer &in, std::ofstream &fout) {
    char *out8 = new char[in.size()];
    for (int samp = 0; samp < in.size(); samp++) {
      double pixel = in[samp];
      if (pixel <= 0.0) {
        out8[samp] = 0;
      }
      else if (pixel >= 255.0) {
        out8[samp] = (char)255;
      }
      else {
        out8[samp] = (char)(in[samp] + 0.5);  //Rounds
      }
    }
    fout.write(out8, in.size());
    delete[] out8;
    return;
  }


  void ProcessExport::isisOut16s(Buffer &in, std::ofstream &fout) {
    short *out16s = new short[in.size()];
    for (int samp = 0; samp < in.size(); samp++) {
      double pixel = in[samp];
      short tempShort;
      if (pixel <= -32768.0) {
        tempShort = (short)32768;
        tempShort = -1 * tempShort;
      }
      else if (pixel >= 32767.0) {
        tempShort = (short)32767;
      }
      else {
        //Rounds
        if (in[samp] < 0.0) {
          tempShort = (short)(in[samp] - 0.5);
        }
        else {
          tempShort = (short)(in[samp] + 0.5);
        }
      }
      void *p_swap = &tempShort;
      out16s[samp] = p_endianSwap->ShortInt(p_swap);
    }
    fout.write((char *)out16s, in.size() * 2);
    delete[] out16s;
    return;
  }


  void ProcessExport::isisOut16u(Buffer &in, std::ofstream &fout) {
    unsigned short *out16u = new unsigned short[in.size()];
    for (int samp = 0; samp < in.size(); samp++) {
      double pixel = in[samp];
      unsigned short tempShort;
      if (pixel <= 0.0) {
        tempShort = 0;
      }
      else if (pixel >= 65535.0) {
        tempShort = 65535;
      }
      else {
        tempShort = (unsigned short)(in[samp] + 0.5); //Rounds
      }
      unsigned short *p_swap = &tempShort;
      out16u[samp] = p_endianSwap->UnsignedShortInt(p_swap);
    }

    fout.write((char *)out16u, in.size() * 2);
    delete[] out16u;
    return;
  }


  void ProcessExport::isisOut32(Buffer &in, std::ofstream &fout) {
    int *out32 = new int[in.size()];
    for (int samp = 0; samp < in.size(); samp++) {
      double pixel = in[samp];
      float tempFloat;
      if (pixel <= -((double)FLT_MAX)) {
        tempFloat = -((double)FLT_MAX);
      }
      else if (pixel >= (double)FLT_MAX) {
        tempFloat = (double)FLT_MAX;
      }
      else {
        tempFloat = (double)in[samp];
      }
      void *p_swap = &tempFloat;
      out32[samp] = p_endianSwap->ExportFloat(p_swap);
    }
    fout.write((char *)out32, in.size() * 4);
    delete[] out32;
    return;
  }

  void ProcessExport::CreateWorldFile(const QString &worldFile) {
    try {
      Projection *proj = InputCubes[0]->projection();
      proj->SetWorld(1.0, 1.0);
      ofstream os;
      os.open(worldFile.toLatin1().data(), ios::out);

      // X resolution
      os << std::fixed << setprecision(15)
         << proj->Resolution() << endl;
      // scale and rotation
      os << 0.0 << endl;
      os << 0.0 << endl;

      // Y resolution
      os << std::fixed << setprecision(15)
         << -proj->Resolution() << endl;

      // Upper left x at pixel middle
      os << std::fixed << setprecision(15)
         << proj->XCoord() << endl;

      // Upper left y at pixel middle
      os << std::fixed << setprecision(15)
         << proj->YCoord() << endl;

      os.close();
    }
    catch(IException &e) {
    }
  }
}