mlImagingBackgroundTask.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_IMAGING_BACKGROUND_TASK_H
#define ML_IMAGING_BACKGROUND_TASK_H
 
// Local includes
#include "MLBackgroundTasksSystem.h"
 
#include "mlMessagingBackgroundTask.h"
#include "mlManagedSubImage.h"
#include <mlTimeCounter.h>
#include <host/mlTileRequest.h>
#include <mlModuleIncludes.h>
 
ML_START_NAMESPACE
 
//-----------------------------------------------------------------------

typedef MLuint32 BackgroundRequestId;
 
class MLBACKGROUNDTASKS_EXPORT ImagingBackgroundTask : public MessagingBackgroundTask
{
  ML_DISALLOW_COPY_AND_ASSIGN(ImagingBackgroundTask)
 
public:
 
  ImagingBackgroundTask(void* owner);
  ~ImagingBackgroundTask() override;

  enum TileRequestFlags {
    UseMemoryManager = TileRequest::UseMemoryManager,  //<! This will allocate the memory using the MemoryManager.
    UseMLAlloc       = TileRequest::UseMLAlloc,        //<! This will allocate the memory using MLAlloc.
    NoAllocation     = TileRequest::NoAllocation,      //<! This can be used if no data should be allocated at all (e.g., for processAllPages).
    ExternalBuffer   = TileRequest::ExternalBuffer,    //<! This can be used to provide the data by the user.
    AllocationPolicyMask = 0xf,                        //<! Mask to get a AsyncTileRequest ::AllocationPolicy enum from the flags value.
 
    RequestReadOnlyPage     = 16,                      //<! Request the data of the AsyncTileRequest  as read-only page data, this requires that the given box
                                                       //<! matches a page's box and data type, and that scale/shift has the default value. This overrides the
                                                       //<! allocation policy above.
    ReceiveProgressMessages = 32                       //<! Receive progress messages for the AsyncTileRequest.
  };

  class AsyncTileRequest  {
  public:
    AsyncTileRequest ():_tileId(0),_task(nullptr) {};
    AsyncTileRequest (BackgroundRequestId tileId, ImagingBackgroundTask* task)
      : _tileId(tileId), _task(task)
    {}

    ManagedSubImage* getTile() {
      bool found;
      return _task->getFinishedRequest(_tileId, found);
    };
 
  private:
    BackgroundRequestId   _tileId;
    ImagingBackgroundTask* _task;
  };
 

  class ProcessAllPagesRequest {
  public:
    ProcessAllPagesRequest():_id(0),_task(nullptr) {};
    ProcessAllPagesRequest(BackgroundRequestId tileId, ImagingBackgroundTask* task)
      : _id(tileId), _task(task)
    {}

    bool waitUntilFinished() {
      return _task->waitForProcessAllPages(_id);
    }
 
  private:
    BackgroundRequestId _id;
    ImagingBackgroundTask* _task;
  };
 
protected:
  BackgroundRequestId generateBackgroundRequestId() {
    return _nextTileRequestId++;
  }
 
private:
  friend class  BackgroundTaskMLGetTileResultMessage;
  friend class  BackgroundTaskMLProcessAllPagesResultMessage;
  friend class  AsyncTileRequest ;
  friend class  ProcessAllPagesRequest;

  struct RequestResult
  {
    RequestResult(BackgroundRequestId idArg, ProcessAllPagesHandler* handlerArg) {
      this->id = idArg;
      this->handler = handlerArg;
      this->image = nullptr;
    }
 
    RequestResult(BackgroundRequestId idArg, ManagedSubImage* imageArg) {
      this->id = idArg;
      this->image = imageArg;
      this->handler = nullptr;
    }
 
    void free() {
      delete image;
      image = nullptr;
      delete handler;
      handler = nullptr;
    }
 
    // Public access to variables
    BackgroundRequestId     id;
    ProcessAllPagesHandler* handler;
    ManagedSubImage*        image;
  };

  ManagedSubImage* takeRequestIfAvailable(BackgroundRequestId tileId, bool& found);

  ManagedSubImage* getFinishedRequest(BackgroundRequestId tileId, bool& found);

  bool             waitForProcessAllPages(BackgroundRequestId id);

  void addFinishedRequest(BackgroundRequestId tileId, ManagedSubImage* image);

  void addFinishedRequest(BackgroundRequestId tileId, ProcessAllPagesHandler* handler);

  std::deque<RequestResult> _availableTiles;
  BackgroundRequestId _nextTileRequestId;
 
};
 
 
ML_END_NAMESPACE
 
#endif