ProcessBySpectra.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "ProcessBySpectra.h"
 
#include "Buffer.h"
#include "Cube.h"
#include "IException.h"
#include "Process.h"
#include "ProcessByBrick.h"
 
using namespace std;
namespace Isis {
 
  Isis::Cube *ProcessBySpectra::SetInputCube(const QString &parameter,
      const int requirements) {
    return ProcessByBrick::SetInputCube(parameter,
                                        Isis::SpatialMatch | requirements);
  }
 
 
  Isis::Cube *ProcessBySpectra::SetInputCube(const QString &file,
      Isis::CubeAttributeInput &att,
      const int requirements) {
    return ProcessByBrick::SetInputCube(file, att,
                                        Isis::SpatialMatch | requirements);
  }
 
 
  void ProcessBySpectra::StartProcess(void funct(Isis::Buffer &in)) {
 
 
    VerifyCubes(InPlace);
    SetBricks(InPlace);
    //SetBrickSizesForProcessCubeInPlace();
    ProcessByBrick::StartProcess(funct);
  }
 
 
  void ProcessBySpectra::StartProcess(void
                                      funct(Isis::Buffer &in,
                                            Isis::Buffer &out)) {
 
      VerifyCubes(InputOutput);
      SetBricks(InputOutput);
    //SetBrickSizesForProcessCube();
    ProcessByBrick::StartProcess(funct);
  }
 
 
  void ProcessBySpectra::StartProcess(void funct(std::vector<Isis::Buffer *> &in,
                                      std::vector<Isis::Buffer *> &out)) {
    //SetBrickSizesForProcessCubes();
      VerifyCubes(InputOutputList);
      SetBricks(InputOutputList);
      ProcessByBrick::StartProcess(funct);
  }
 
 
  void ProcessBySpectra::SetType(const int type) {
    if (type != PerPixel && type != ByLine && type != BySample) {
      string m = "The specified spectra type is invalid";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
    else p_spectraType = type;
  }
 
 
  void ProcessBySpectra::SetBricks(IOCubes cn){
 
 
 
 
      switch(cn){
 
        case InPlace:
            int ns, nl, nb;
            if(InputCubes.size() == 1) {
 
              ns = InputCubes[0]->sampleCount();
              nl = InputCubes[0]->lineCount();
              nb = InputCubes[0]->bandCount();
            }
            else {
              ns = OutputCubes[0]->sampleCount();
              nl = OutputCubes[0]->lineCount();
              nb = OutputCubes[0]->bandCount();
            }
 
            if(Type() == PerPixel) SetBrickSize(1, 1, nb);
 
            else if(Type() == ByLine) SetBrickSize(ns, 1, nb);
 
            else SetBrickSize(1, nl, nb);
 
          break;
 
        case InputOutput:
 
          if(Type() == PerPixel) {
            SetInputBrickSize(1, 1, InputCubes[0]->bandCount());
            SetOutputBrickSize(1, 1, OutputCubes[0]->bandCount());
          }
          else if(Type() == ByLine) {
            SetInputBrickSize(InputCubes[0]->sampleCount(), 1,
                              InputCubes[0]->bandCount());
            SetOutputBrickSize(OutputCubes[0]->sampleCount(), 1,
                               OutputCubes[0]->bandCount());
          }
          else {
            SetInputBrickSize(1, InputCubes[0]->lineCount(),
                              InputCubes[0]->bandCount());
            SetOutputBrickSize(1, OutputCubes[0]->lineCount(),
                               OutputCubes[0]->bandCount());
          }
 
          break;
 
 
        case InputOutputList:
 
          if(Type() == PerPixel) {
            for(unsigned int i = 0; i < InputCubes.size(); i++) {
              SetInputBrickSize(1, 1, InputCubes[i]->bandCount(), i + 1);
            }
            for(unsigned int i = 0; i < OutputCubes.size(); i++) {
              SetOutputBrickSize(1, 1, OutputCubes[i]->bandCount(), i + 1);
            }
          }
          else if(Type() == ByLine) {
            for(unsigned int i = 0; i < InputCubes.size(); i++) {
              SetInputBrickSize(InputCubes[i]->sampleCount(), 1,
                                InputCubes[i]->bandCount(), i + 1);
            }
            for(unsigned int i = 0; i < OutputCubes.size(); i++) {
              SetOutputBrickSize(OutputCubes[i]->sampleCount(), 1,
                                 OutputCubes[i]->bandCount(), i + 1);
            }
          }
          else {
            for(unsigned int i = 0; i < InputCubes.size(); i++) {
              SetInputBrickSize(1, InputCubes[i]->lineCount(),
                                InputCubes[i]->bandCount(), i + 1);
            }
            for(unsigned int i = 0; i < OutputCubes.size(); i++) {
              SetOutputBrickSize(1, OutputCubes[i]->lineCount(),
                                 OutputCubes[i]->bandCount(), i + 1);
            }
          }
 
          break;
 
        }
 
 
  }
 
 
  /*
  void ProcessBySpectra::SetBrickSizesForProcessCubeInPlace() {
    // 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_);
    }
 
    int ns, nl, nb;
    if (InputCubes.size() == 1) {
      ns = InputCubes[0]->sampleCount();
      nl = InputCubes[0]->lineCount();
      nb = InputCubes[0]->bandCount();
    }
    else {
      ns = OutputCubes[0]->sampleCount();
      nl = OutputCubes[0]->lineCount();
      nb = OutputCubes[0]->bandCount();
    }
    if (Type() == PerPixel) SetBrickSize(1, 1, nb);
    else if (Type() == ByLine) SetBrickSize(ns, 1, nb);
    else SetBrickSize(1, nl, nb);
  }
 
*/
  /*
  void ProcessBySpectra::SetBrickSizesForProcessCube() {
    // 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_);
    }
 
    if (Type() == PerPixel) {
      SetInputBrickSize(1, 1, InputCubes[0]->bandCount());
      SetOutputBrickSize(1, 1, OutputCubes[0]->bandCount());
    }
    else if (Type() == ByLine) {
      SetInputBrickSize(InputCubes[0]->sampleCount(), 1,
                        InputCubes[0]->bandCount());
      SetOutputBrickSize(OutputCubes[0]->sampleCount(), 1,
                         OutputCubes[0]->bandCount());
    }
    else {
      SetInputBrickSize(1, InputCubes[0]->lineCount(),
                        InputCubes[0]->bandCount());
      SetOutputBrickSize(1, OutputCubes[0]->lineCount(),
                         OutputCubes[0]->bandCount());
    }
  }
 
*/
  /*
  void ProcessBySpectra::SetBrickSizesForProcessCubes() {
    if (Type() == PerPixel) {
      for (unsigned int i = 0; i < InputCubes.size(); i++) {
        SetInputBrickSize(1, 1, InputCubes[i]->bandCount(), i + 1);
      }
      for (unsigned int i = 0; i < OutputCubes.size(); i++) {
        SetOutputBrickSize(1, 1, OutputCubes[i]->bandCount(), i + 1);
      }
    }
    else if (Type() == ByLine) {
      for (unsigned int i = 0; i < InputCubes.size(); i++) {
        SetInputBrickSize(InputCubes[i]->sampleCount(), 1,
                          InputCubes[i]->bandCount(), i + 1);
      }
      for (unsigned int i = 0; i < OutputCubes.size(); i++) {
        SetOutputBrickSize(OutputCubes[i]->sampleCount(), 1,
                           OutputCubes[i]->bandCount(), i + 1);
      }
    }
    else {
      for (unsigned int i = 0; i < InputCubes.size(); i++) {
        SetInputBrickSize(1, InputCubes[i]->lineCount(),
                          InputCubes[i]->bandCount(), i + 1);
      }
      for (unsigned int i = 0; i < OutputCubes.size(); i++) {
        SetOutputBrickSize(1, OutputCubes[i]->lineCount(),
                           OutputCubes[i]->bandCount(), i + 1);
      }
    }
  }
  */
 
 
}