ProcessByTile.h

#ifndef ProcessByTile_h
#define ProcessByTile_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include "ProcessByBrick.h"
#include "Buffer.h"
 
namespace Isis {
  class ProcessByTile : public ProcessByBrick {
 
    private:
      bool p_tileSizeSet;  
      int p_tileSamples;   
      int p_tileLines;     
 
    public:
 
      ProcessByTile() {
        p_tileSizeSet = false;
      };
 
      ~ProcessByTile() {};
 
      void SetTileSize(const int ns, const int nl);
 
      void StartProcess(void funct(Buffer &in));
      void StartProcess(void funct(Buffer &in, Buffer &out));
 
      void StartProcess(void funct(std::vector<Buffer *> &in,
                                   std::vector<Buffer *> &out));
      void EndProcess();
      void Finalize();
 
      template <typename Functor>
      void ProcessCubeInPlace(const Functor & funct, bool threaded = true) {
          VerifyCubes(InPlace);
          SetBricks(InPlace);
        //SetBrickSizesForProcessCubeInPlace();
        ProcessByBrick::ProcessCubeInPlace(funct, threaded);
      }
 
      template <typename Functor>
      void ProcessCube(const Functor & funct, bool threaded = true) {
 
        VerifyCubes(InputOutput)  ;
        SetBricks(InputOutput);
 
        //SetBrickSizesForProcessCube();
        ProcessByBrick::ProcessCube(funct, threaded);
      }
 
      template <typename Functor>
      void ProcessCubes(const Functor & funct, bool threaded = true) {
 
          VerifyCubes(InputOutputList);
          SetBricks(InputOutputList);
        //SetBrickSizesForProcessCubes();
        ProcessByBrick::ProcessCubes(funct, threaded);
      }
 
    private:
      void SetBricks(IOCubes cn);
      void SetBrickSizesForProcessCubeInPlace();
      void SetBrickSizesForProcessCube();
      void SetBrickSizesForProcessCubes();
  };
};
 
#endif