ProcessByBrick.h

Go to the documentation of this file.

#ifndef ProcessByBrick_h
#define ProcessByBrick_h

#include "Brick.h"
#include "Buffer.h"
#include "Cube.h"
#include "Process.h"

using namespace std;

namespace Isis {
  class ProcessByBrick : public Isis::Process {
    
    private:
      bool p_wrapOption;    
      bool p_inputBrickSizeSet;  
      bool p_outputBrickSizeSet; 
      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;   
    private:
      std::vector<int> CalculateMaxDimensions(std::vector<Cube *> cubes) const;

    public:
      ProcessByBrick();

      ~ProcessByBrick() {};

      Isis::Cube *SetInputCube(const std::string &parameter,
                               const int requirements = 0);

      Isis::Cube *SetInputCube(const std::string &fname,
                               const Isis::CubeAttributeInput &att,
                               const int requirements = 0);

      void SetBrickSize(const int ns, const int nl, const int nb);

      void SetInputBrickSize(const int ns, const int nl, const int nb);
      void SetInputBrickSize(const int ns, const int nl, const int nb, 
                             const int tile);

      void SetOutputBrickSize(const int ns, const int nl, const int nb);
      void SetOutputBrickSize(const int ns, const int nl, const int nb, 
                              const int tile);

      void SetWrap(bool wrap) {
        p_wrapOption = wrap;
      };

      bool Wraps() {
        return p_wrapOption;
      };

      void StartProcess(void funct(Isis::Buffer &in));
      void StartProcess(void funct(Isis::Buffer &in, Isis::Buffer &out));
      void StartProcess(void funct(std::vector<Isis::Buffer *> &in,
                                   std::vector<Isis::Buffer *> &out));
      void EndProcess();
      
      bool ProcessInPlace(Isis::Cube **cube, Isis::Brick **bricks);
      
      template <typename Functor> 
      void StartProcessInPlace(Functor & funct) {
        Isis::Cube *cube=NULL;
        Isis::Brick *bricks=NULL;
        
        bool haveInput = ProcessInPlace(&cube, &bricks);
        
        p_progress->SetMaximumSteps(bricks->Bricks());
        p_progress->CheckStatus();

        // Loop and let the app programmer work with the bricks
        for(bricks->begin(); !bricks->end(); (*bricks)++) {
          if(haveInput) {
            cube->read(*bricks);  // input only
          }
          funct(*bricks);
          if((!haveInput) || (cube->isReadWrite())){
            cube->write(*bricks);  // output only or input/output
          }
          p_progress->CheckStatus();

          }
        delete bricks;
      }
      
      int ProcessIO(Isis::Brick **ibrick, Isis::Brick **obrick);
      
      template <typename FunctorIO>
      void StartProcessIO(FunctorIO & funct) {

        Isis::Brick *ibrick=NULL, *obrick=NULL;
    
        int numBricks = ProcessIO(&ibrick, &obrick);
    
        // Loop and let the app programmer work with the bricks
        p_progress->SetMaximumSteps(numBricks);
        p_progress->CheckStatus();

        ibrick->begin();
        obrick->begin();
        for(int i = 0; i < numBricks; i++) {
          InputCubes[0]->read(*ibrick);
          funct(*ibrick, *obrick);
          OutputCubes[0]->write(*obrick);
          p_progress->CheckStatus();
          (*ibrick)++;
          (*obrick)++;
        }
        delete ibrick;
        delete obrick;
      }
      
      int ProcessIOList(std::vector<Isis::Buffer *> & ibufs, 
                        std::vector<Isis::Buffer *> & obufs,
                        std::vector<Isis::Brick *> & imgrs,  
                        std::vector<Isis::Brick *> & omgrs);
      
      template <typename FunctorIOList>
      void StartProcessIOList(FunctorIOList & funct) {
        // Construct two vectors of brick buffer managers
        // The input buffer managers
        vector<Isis::Brick *> imgrs;
        vector<Isis::Buffer *> ibufs;
    
        // And the output buffer managers
        vector<Isis::Brick *> omgrs;
        vector<Isis::Buffer *> obufs;
    
        int numBricks = ProcessIOList (ibufs, obufs, imgrs, omgrs);
    
        // Loop and let the app programmer process the bricks
        p_progress->SetMaximumSteps(numBricks);
        p_progress->CheckStatus();

        for(int t = 0; t < numBricks; t++) {
          // Read the input buffers
          for(unsigned int i = 0; i < InputCubes.size(); i++) {
            InputCubes[i]->read(*ibufs[i]);
          }

          // Pass them to the application function
          funct(ibufs, obufs);

          // And copy them into the output cubes
          for(unsigned int i = 0; i < OutputCubes.size(); i++) {
            OutputCubes[i]->write(*obufs[i]);
            omgrs[i]->next();
          }

          for(unsigned int i = 0; i < InputCubes.size(); i++) {
            imgrs[i]->next();
            // if the manager has reached the end and the
            // wrap option is on, wrap around to the beginning
            if(Wraps() && imgrs[i]->end()) imgrs[i]->begin();

            // Enforce same band
            if(imgrs[i]->Band() != imgrs[0]->Band() &&
               InputCubes[i]->getBandCount() != 1) {
              imgrs[i]->SetBaseBand(imgrs[0]->Band());
            }
          }
          p_progress->CheckStatus();
        }
  
        for(unsigned int i = 0; i < ibufs.size(); i++) {
          delete ibufs[i];
        }
        ibufs.clear();
        imgrs.clear();

        for(unsigned int i = 0; i < obufs.size(); i++) {
          delete obufs[i];
        }
        obufs.clear();
        omgrs.clear();
      }
  };
};

#endif