ProcessByBrick.h

Go to the documentation of this file.

#ifndef ProcessByBrick_h
#define ProcessByBrick_h
/* SPDX-License-Identifier: CC0-1.0 */
#include <functional>
#include <QtConcurrentMap>
#include <QTime>
 
#include "Brick.h"
#include "Buffer.h"
#include "Cube.h"
#include "Process.h"
#include "Progress.h"
 
namespace Isis {
  class ProcessByBrick : public Process {
    public:
      ProcessByBrick();
 
      virtual ~ProcessByBrick();
 
      enum IOCubes{InPlace,
                   InputOutput,
                   InputOutputList};
 
      enum ProcessingDirection {
        LinesFirst,
        BandsFirst
      };
 
      using Process::SetInputCube;
      Cube *SetInputCube(const QString &parameter,
                         int requirements = 0);
 
      Cube *SetInputCube(const QString &fname,
                         const CubeAttributeInput &att,
                         int requirements = 0);
 
      virtual void SetBricks(IOCubes cn);
      void VerifyCubes(IOCubes cn);
 
      void SetBrickSize(int ns, int nl, int nb);
 
      void SetInputBrickSize(int ns, int nl, int nb);
      void SetInputBrickSize(int ns, int nl, int nb, int cube);
 
      void SetOutputBrickSize(int ns, int nl, int nb);
      void SetOutputBrickSize(int ns, int nl, int nb, int cube);
 
      // Overload the SetOutputCube() method to allow the user to pass in the
      // file name and attributes without the lines and samples.
      // Any other calls to this method will use the prototypes found in the
      //process class due to the using statement below.
      using Isis::Process::SetOutputCube;
      virtual Cube *SetOutputCube(const QString &fname,
                                  const CubeAttributeOutput &att);
 
      void SetProcessingDirection(ProcessingDirection direction);
      ProcessingDirection GetProcessingDirection();
 
      void SetOutputRequirements(int outputRequirements);
      void SetWrap(bool wrap);
      bool Wraps();
 
      using Isis::Process::StartProcess;  // make parents virtual function visable
      virtual void StartProcess(void funct(Buffer &in));
      virtual void StartProcess(std::function<void(Buffer &in)> funct );
      virtual void StartProcess(void funct(Buffer &in, Buffer &out));
      virtual void StartProcess(std::function<void(Buffer &in, Buffer &out)> funct);
      virtual void StartProcess(void funct(std::vector<Buffer *> &in,
                                           std::vector<Buffer *> &out));
      virtual void StartProcess(std::function<void(std::vector<Buffer *> &in,
                                                   std::vector<Buffer *> &out)> funct);
      void EndProcess();// Depricated. Please use Finalize
      void Finalize();
 
 
      template <typename Functor> void ProcessCubeInPlace(
          const Functor & functor, bool threaded = true) {
        Cube *cube = NULL;
        Brick *brick = NULL;
 
        bool haveInput = PrepProcessCubeInPlace(&cube, &brick);
        bool writeOutput = (!haveInput) || (cube->isReadWrite());
 
        ProcessCubeInPlaceFunctor<Functor> wrapperFunctor(
            cube, brick, haveInput, writeOutput, functor);
 
        RunProcess(wrapperFunctor, brick->Bricks(), threaded);
 
        delete brick;
      }
 
 
      template <typename Functor> void ProcessCube(const Functor & functor,
                                                   bool threaded = true) {
        Brick *inputCubeData = NULL;
        Brick *outputCubeData = NULL;
 
        int numBricks = PrepProcessCube(&inputCubeData, &outputCubeData);
 
        ProcessCubeFunctor<Functor> wrapperFunctor(InputCubes[0], inputCubeData,
            OutputCubes[0], outputCubeData, functor);
 
        RunProcess(wrapperFunctor, numBricks, threaded);
 
        delete inputCubeData;
        delete outputCubeData;
      }
 
 
      template <typename Functor> void ProcessCubes(const Functor & functor,
                                                    bool threaded = true) {
        std::vector<Brick *> inputCubeData;
        std::vector<Brick *> outputCubeData;
 
        std::vector<Buffer *> inputCubeDataParents;
        std::vector<Buffer *> outputCubeDataParents;
 
        int numBricks = PrepProcessCubes(
            inputCubeDataParents, outputCubeDataParents,
            inputCubeData, outputCubeData);
 
        ProcessCubesFunctor<Functor> wrapperFunctor(InputCubes, inputCubeData,
              OutputCubes, outputCubeData, Wraps(), functor);
 
        RunProcess(wrapperFunctor, numBricks, threaded);
 
        for(unsigned int i = 0; i < inputCubeData.size(); i++) {
          delete inputCubeData[i];
        }
 
        for(unsigned int i = 0; i < outputCubeData.size(); i++) {
          delete outputCubeData[i];
        }
      }
 
 
    private:
      template <typename Functor>
      void RunProcess(const Functor &wrapperFunctor,
                      int numSteps, bool threaded) {
        ProcessIterator begin(0);
        ProcessIterator end(numSteps);
 
        p_progress->SetMaximumSteps(numSteps);
        p_progress->CheckStatus();
 
        int threadCount = QThreadPool::globalInstance()->maxThreadCount();
        if (threaded && threadCount > 1) {
          QFuture<void> result = QtConcurrent::mapped(begin, end,
              wrapperFunctor);
          BlockingReportProgress(result);
        }
        else {
          while (begin != end) {
            wrapperFunctor(*begin);
            ++begin;
           p_progress->CheckStatus();
          }
        }
      }
 
 
      template <typename T>
      class ProcessCubeInPlaceFunctor :
          public std::function<void*(int)> {
        public:
          ProcessCubeInPlaceFunctor(Cube *cube,
                                    const Brick *templateBrick,
                                    bool readInput, bool writeOutput,
                                    const T &processingFunctor) :
              m_cube(cube),
              m_templateBrick(templateBrick),
              m_readInput(readInput),
              m_writeOutput(writeOutput),
              m_processingFunctor(processingFunctor) {
          }
 
 
          ProcessCubeInPlaceFunctor(const ProcessCubeInPlaceFunctor &other) :
              m_cube(other.m_cube),
              m_templateBrick(other.m_templateBrick),
              m_readInput(other.m_readInput),
              m_writeOutput(other.m_writeOutput),
              m_processingFunctor(other.m_processingFunctor) {
          }
 
 
          virtual ~ProcessCubeInPlaceFunctor() {
            m_cube = NULL;
            m_templateBrick = NULL;
          }
 
 
          void *operator()(const int &brickPosition) const {
            Brick cubeData(*m_templateBrick);
            cubeData.setpos(brickPosition);
 
            if (m_readInput)
              m_cube->read(cubeData);
 
            m_processingFunctor(cubeData);
 
            if (m_writeOutput)
              m_cube->write(cubeData);
 
            return NULL;
          }
 
 
          ProcessCubeInPlaceFunctor &operator=(
              const ProcessCubeInPlaceFunctor &rhs) {
            m_cube = rhs.m_cube;
            m_templateBrick = rhs.m_templateBrick;
 
            m_readInput = rhs.m_readInput;
            m_writeOutput = rhs.m_writeOutput;
 
            m_processingFunctor = rhs.m_processingFunctor;
 
            return *this;
          }
 
        private:
          Cube *m_cube;
          const Brick *m_templateBrick;
          bool m_readInput;
          bool m_writeOutput;
 
          const T &m_processingFunctor;
       };
 
 
      template <typename T>
      class ProcessCubeFunctor :
          public std::function<void *(const int &)> {
        public:
          ProcessCubeFunctor(Cube *inputCube,
                             const Brick *inputTemplateBrick,
                             Cube *outputCube,
                             const Brick *outputTemplateBrick,
                             const T &processingFunctor) :
              m_inputCube(inputCube),
              m_inputTemplateBrick(inputTemplateBrick),
              m_outputCube(outputCube),
              m_outputTemplateBrick(outputTemplateBrick),
              m_processingFunctor(processingFunctor) {
          }
 
 
          ProcessCubeFunctor(const ProcessCubeFunctor &other) :
              m_inputCube(other.m_inputCube),
              m_inputTemplateBrick(other.m_inputTemplateBrick),
              m_outputCube(other.m_outputCube),
              m_outputTemplateBrick(other.m_outputTemplateBrick),
              m_processingFunctor(other.m_processingFunctor) {
          }
 
 
          virtual ~ProcessCubeFunctor() {
            m_inputTemplateBrick = NULL;
            m_outputTemplateBrick = NULL;
          }
 
 
          void *operator()(const int &brickPosition) const {
            Brick inputCubeData(*m_inputTemplateBrick);
            Brick outputCubeData(*m_outputTemplateBrick);
 
            inputCubeData.setpos(brickPosition);
            outputCubeData.setpos(brickPosition);
 
            m_inputCube->read(inputCubeData);
 
            m_processingFunctor(inputCubeData, outputCubeData);
 
            m_outputCube->write(outputCubeData);
 
            return NULL;
          }
 
 
          ProcessCubeFunctor &operator=(const ProcessCubeFunctor &rhs) {
            m_inputCube = rhs.m_inputCube;
            m_inputTemplateBrick = rhs.m_inputTemplateBrick;
 
            m_outputCube = rhs.m_outputCube;
            m_outputTemplateBrick = rhs.m_outputTemplateBrick;
 
            m_processingFunctor = rhs.m_processingFunctor;
 
            return *this;
          }
 
        private:
          Cube *m_inputCube;
          const Brick *m_inputTemplateBrick;
 
          Cube *m_outputCube;
          const Brick *m_outputTemplateBrick;
 
          const T &m_processingFunctor;
       };
 
 
      template <typename T>
      class ProcessCubesFunctor :
          public std::function<void *(const int &)> {
        public:
          ProcessCubesFunctor(std::vector<Cube *> &inputCubes,
                              std::vector<Brick *> &inputTemplateBricks,
                              std::vector<Cube *> &outputCubes,
                              std::vector<Brick *> &outputTemplateBricks,
                              bool wraps,
                              const T &processingFunctor) :
              m_inputCubes(inputCubes),
              m_inputTemplateBricks(inputTemplateBricks),
              m_outputCubes(outputCubes),
              m_outputTemplateBricks(outputTemplateBricks),
              m_wraps(wraps),
              m_processingFunctor(processingFunctor) {
          }
 
 
          ProcessCubesFunctor(const ProcessCubesFunctor &other)  :
              m_inputCubes(other.m_inputCubes),
              m_inputTemplateBricks(other.m_inputTemplateBricks),
              m_outputCubes(other.m_outputCubes),
              m_outputTemplateBricks(other.m_outputTemplateBricks),
              m_wraps(other.m_wraps),
              m_processingFunctor(other.m_processingFunctor) {
          }
 
 
          virtual ~ProcessCubesFunctor() {
          }
 
 
          void *operator()(const int &brickPosition) const {
            QPair< std::vector<Buffer *>, std::vector<Buffer *> > functorBricks;
 
            for (int i = 0; i < (int)m_inputTemplateBricks.size(); i++) {
              Brick *inputBrick = new Brick(*m_inputTemplateBricks[i]);
              functorBricks.first.push_back(inputBrick);
 
              if (m_wraps) {
                inputBrick->setpos(brickPosition % inputBrick->Bricks());
              }
              else {
                inputBrick->setpos(brickPosition);
              }
 
              if (i != 0 &&
                  functorBricks.first.size() &&
                  inputBrick->Band() != functorBricks.first[0]->Band() &&
                  m_inputCubes[i]->bandCount() != 1) {
                inputBrick->SetBaseBand(functorBricks.first[0]->Band());
              }
 
              m_inputCubes[i]->read(*inputBrick);
            }
 
            for (int i = 0; i < (int)m_outputTemplateBricks.size(); i++) {
              Brick *outputBrick = new Brick(*m_outputTemplateBricks[i]);
              functorBricks.second.push_back(outputBrick);
              outputBrick->setpos(brickPosition);
            }
 
            // Pass them to the application function
            m_processingFunctor(functorBricks.first, functorBricks.second);
 
            // And copy them into the output cubes
            for (int i = 0; i < (int)functorBricks.second.size(); i++) {
              m_outputCubes[i]->write(*functorBricks.second[i]);
              delete functorBricks.second[i];
            }
 
            for (int i = 0; i < (int)functorBricks.first.size(); i++) {
              delete functorBricks.first[i];
            }
 
            return NULL;
          }
 
 
          ProcessCubesFunctor &operator=(const ProcessCubesFunctor &rhs) {
            m_inputCubes = rhs.m_inputCubes;
            m_inputTemplateBricks = rhs.m_inputTemplateBricks;
 
            m_outputCubes = rhs.m_outputCubes;
            m_outputTemplateBricks = rhs.m_outputTemplateBricks;
 
            m_wraps = rhs.m_wraps;
 
            m_processingFunctor = rhs.m_processingFunctor;
 
            return *this;
          }
 
        private:
          std::vector<Cube *> m_inputCubes;
          std::vector<Brick *> &m_inputTemplateBricks;
 
          std::vector<Cube *> m_outputCubes;
          std::vector<Brick *> &m_outputTemplateBricks;
 
          bool m_wraps;
 
          const T &m_processingFunctor;
       };
 
 
      void BlockingReportProgress(QFuture<void> &future);
      std::vector<int> CalculateMaxDimensions(std::vector<Cube *> cubes) const;
      bool PrepProcessCubeInPlace(Cube **cube, Brick **bricks);
      int PrepProcessCube(Brick **ibrick, Brick **obrick);
      int PrepProcessCubes(std::vector<Buffer *> & ibufs,
                           std::vector<Buffer *> & obufs,
                           std::vector<Brick *> & imgrs,
                           std::vector<Brick *> & omgrs);
 
 
      class ProcessIterator {
        public:
          ProcessIterator(int position);
          ProcessIterator(const ProcessIterator &other);
          virtual ~ProcessIterator();
 
          using value_type = int;
          using iterator_category = std::forward_iterator_tag;
          using difference_type = std::ptrdiff_t;
          using pointer = int*;
          using reference = int&;
 
          ProcessIterator &operator++();
 
          bool operator==(const ProcessIterator &rhs) {
            return (m_currentPosition == rhs.m_currentPosition);
          }
 
          bool operator!=(const ProcessIterator &rhs) {
            return !(*this == rhs);
          }
 
 
          void swap(ProcessIterator &other) {
            std::swap(m_currentPosition, other.m_currentPosition);
          }
 
 
          ProcessIterator &operator=(const ProcessIterator &rhs) {
            ProcessIterator copy(rhs);
            swap(copy);
            return *this;
          }
 
 
          int operator*() const {
            return m_currentPosition;
          }
 
        private:
          int m_currentPosition;
      };
 
    private:
      bool p_reverse; 
      bool p_wrapOption;    
      bool p_inputBrickSizeSet;  
      bool p_outputBrickSizeSet; 
      int p_outputRequirements;
 
 
      std::vector<int> p_inputBrickSamples;  
      std::vector<int> p_inputBrickLines;    
      std::vector<int> p_inputBrickBands;    
      std::vector<int> p_outputBrickSamples; 
      std::vector<int> p_outputBrickLines;   
      std::vector<int> p_outputBrickBands;   
  };
 
};
 
#endif