mlBackgroundTaskTileProcessor.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2009, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_BACKGROUND_TASK_TILE_PROCESSOR_H
#define ML_BACKGROUND_TASK_TILE_PROCESSOR_H
 
// Local includes
#include "MLBackgroundTasksSystem.h"
 
#include "mlImagingBackgroundTask.h"
#include "mlTileIterator.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <deque>
#include <ThirdPartyWarningsRestore.h>
 
ML_START_NAMESPACE
 
//-----------------------------------------------------------------------
 
class ModuleBackgroundTask;

class MLBACKGROUNDTASKS_EXPORT BackgroundTaskTileProcessorBase
{
public:
  BackgroundTaskTileProcessorBase();

  virtual ~BackgroundTaskTileProcessorBase(){};
 
  //--------------------------------------------------------------------------------------------
  //
  //
  //--------------------------------------------------------------------------------------------

  virtual SubImageBox getNextTileBox() = 0;

  virtual bool processTile(ManagedSubImage& image) = 0;

  virtual ManagedSubImage* createExternalBuffer(const SubImageBox& box);

 
  //--------------------------------------------------------------------------------------------
  //
  //
  //--------------------------------------------------------------------------------------------

  void setDataType(MLDataType dt) { _dataType = dt; }
  MLDataType getDataType() const { return _dataType; }

  void setInputImageIndex(int index) { _inputImageIndex = index; }
  int  getInputImageIndex() const { return _inputImageIndex; }

  void setAllocationPolicy(TileRequest::AllocationPolicy policy) { _allocationPolicy = policy; }

  void setMaximumQueuedTiles(int size) { _maxQueuedTiles = size; }

 
  //--------------------------------------------------------------------------------------------
  //
  //
  //--------------------------------------------------------------------------------------------

  virtual bool doProcessing(ModuleBackgroundTask& task);

 
protected:
  virtual bool setupProcessing(ModuleBackgroundTask& /*task*/) { return true; }

  virtual bool cleanupProcessing(ModuleBackgroundTask& /*task*/) { return true; }

  void setNumTiles(MLint tiles) { _numTiles = tiles; }
 
private:
  int        _maxQueuedTiles;
  std::deque<ImagingBackgroundTask::AsyncTileRequest > _queue;
 
  int        _inputImageIndex;
  MLDataType _dataType;
  TileRequest::AllocationPolicy _allocationPolicy;
 
  MLint      _numTiles;
};
 
 
//----------------------------------------------------------------------------------------------

class MLBACKGROUNDTASKS_EXPORT BackgroundTaskTileProcessor : public BackgroundTaskTileProcessorBase
{
public:
  BackgroundTaskTileProcessor();
 
  //--------------------------------------------------------------------------------------------
  //
  //
  //--------------------------------------------------------------------------------------------

  void setRegion(const SubImageBox& box) { _box = box; }

  void setTileExtent(const ImageVector& extent) { _tileExtent = extent; }

  void setClipTilesToRegion(bool clip) { _clipTiles = clip; }


  SubImageBox getNextTileBox() override;

  bool setupProcessing(ModuleBackgroundTask& task) override;
 
private:
  TileIterator _iterator;
  SubImageBox  _box;
  ImageVector  _tileExtent;
  bool         _clipTiles;
};
 
ML_END_NAMESPACE
 
#endif