ProcessByLine.cpp

Go to the documentation of this file.

#include "ProcessByLine.h"

#include "Buffer.h"
#include "Cube.h"
#include "IException.h"
#include "Process.h"
#include "ProcessByBrick.h"


using namespace std;
namespace Isis {
  Isis::Cube *ProcessByLine::SetInputCube(const QString &parameter,
                                          const int requirements) {
    int allRequirements = Isis::SpatialMatch | Isis::BandMatchOrOne;
    allRequirements |= requirements;
    return Process::SetInputCube(parameter, allRequirements);
  }

  Isis::Cube *ProcessByLine::SetInputCube(const QString &file,
                                          Isis::CubeAttributeInput &att,
                                          const int requirements) {
    int allRequirements = Isis::SpatialMatch | Isis::BandMatchOrOne;
    allRequirements |= requirements;
    return Process::SetInputCube(file, att, allRequirements);
  }


  void ProcessByLine::SetInputCube(Isis::Cube *inCube)
  {
    Process::SetInputCube(inCube);
  }

  void ProcessByLine::VerifyCubeInPlace(void){
     // Error checks
     if((InputCubes.size() + OutputCubes.size()) > 1) {
       string m = "You can only specify exactly one input or output cube";
       throw IException(IException::Programmer, m, _FILEINFO_);
     }
     else if((InputCubes.size() + OutputCubes.size()) == 0) {
       string m = "You haven't specified an input or output cube";
       throw IException(IException::Programmer, m, _FILEINFO_);
     }

     // Determine if we have an input or output
     if(InputCubes.size() == 1) {
       SetBrickSize(InputCubes[0]->sampleCount(), 1, 1);
     }
     else {
       SetBrickSize(OutputCubes[0]->sampleCount(), 1, 1);
     }
   }

  void ProcessByLine::StartProcess(void funct(Isis::Buffer &inout)) {
    // Error checks
    VerifyCubeInPlace();
    ProcessByBrick::StartProcess(funct);
  }

  void ProcessByLine::VerifyCubeIO(void)
  {
    // Error checks ... there must be one input and output
    if(InputCubes.size() != 1) {
      string m = "You must specify exactly one input cube";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
    else if(OutputCubes.size() != 1) {
      string m = "You must specify exactly one output cube";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    // The lines in the input and output must match
    if(InputCubes[0]->lineCount() != OutputCubes[0]->lineCount()) {
      string m = "The number of lines in the input and output cubes ";
      m += "must match";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    // The bands in the input and output must match
    if(InputCubes[0]->bandCount() != OutputCubes[0]->bandCount()) {
      string m = "The number of bands in the input and output cubes ";
      m += "must match";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    SetInputBrickSize(InputCubes[0]->sampleCount(), 1, 1);
    SetOutputBrickSize(OutputCubes[0]->sampleCount(), 1, 1);
  }

  void ProcessByLine::StartProcess(void
                                   funct(Isis::Buffer &in, Isis::Buffer &out)) {

    VerifyCubeIO();
    ProcessByBrick::StartProcess(funct);
  }

  void ProcessByLine::VerifyCubeIOList(void)
  {
    // Make sure we had an image
    if(InputCubes.size() + OutputCubes.size() < 1) {
      string m = "You have not specified any input or output cubes";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }

    // Make sure all the output images have the same number of bands as
    // the first input/output cube
    for(unsigned int i = 0; i < OutputCubes.size(); i++) {
      if(OutputCubes[i]->lineCount() != OutputCubes[0]->lineCount()) {
        string m = "All output cubes must have the same number of lines ";
        m += "as the first input cube or output cube";
        throw IException(IException::Programmer, m, _FILEINFO_);
      }
      if(OutputCubes[i]->bandCount() != OutputCubes[0]->bandCount()) {
        string m = "All output cubes must have the same number of bands ";
        m += "as the first input cube or output cube";
        throw IException(IException::Programmer, m, _FILEINFO_);
      }
    }

    for(unsigned int i = 0; i < InputCubes.size(); i++) {
      SetInputBrickSize(InputCubes[i]->sampleCount(), 1, 1, i + 1);
    }
    for(unsigned int i = 0; i < OutputCubes.size(); i++) {
      SetOutputBrickSize(OutputCubes[i]->sampleCount(), 1, 1, i + 1);
    }
  }
  void ProcessByLine::StartProcess(
       void funct(std::vector<Isis::Buffer *> &in,
                  std::vector<Isis::Buffer *> &out)) {

    VerifyCubeIOList();
    ProcessByBrick::StartProcess(funct);
  }
}