mitkImageAccessorBase.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkImageAccessorBase_h
#define mitkImageAccessorBase_h
 
#include <itkImageRegion.h>
#include <itkIndex.h>
#include <itkSmartPointer.h>
 
#include "mitkImageDataItem.h"
 
#include <mutex>
 
namespace mitk
{
  //##Documentation
  //## @brief The ImageAccessorBase class provides a lock mechanism for all inheriting image accessors.
  //##
  //## @ingroup Data
 
  class Image;
 
  struct ImageAccessorWaitLock
  {
    unsigned int m_WaiterCount;
 
    std::mutex m_Mutex;
  };
 
// Defs to assure dead lock prevention only in case of possible thread handling.
#if defined(ITK_USE_SPROC) || defined(ITK_USE_PTHREADS) || defined(ITK_USE_WIN32_THREADS)
#define MITK_USE_RECURSIVE_MUTEX_PREVENTION
#endif
 
  class MITKCORE_EXPORT ImageAccessorBase
  {
    friend class Image;
 
    friend class ImageReadAccessor;
    friend class ImageWriteAccessor;
 
    template <class TPixel, unsigned int VDimension>
    friend class ImagePixelReadAccessor;
 
    template <class TPixel, unsigned int VDimension>
    friend class ImagePixelWriteAccessor;
 
  public:
    typedef itk::SmartPointer<const mitk::Image> ImageConstPointer;
 
    enum Options
    {
      DefaultBehavior = 0,
      ExceptionIfLocked = 1,
      ForceCoherentMemory = 2,
      IgnoreLock = 4
    };
 
    virtual ~ImageAccessorBase();
 
    inline const void *GetData() const { return m_AddressBegin; }
  protected:
// Define type of thread id
#ifdef ITK_USE_SPROC
    typedef int ThreadIDType;
#endif
 
#ifdef ITK_USE_WIN32_THREADS
    typedef DWORD ThreadIDType;
#endif
 
#ifdef ITK_USE_PTHREADS
    typedef pthread_t ThreadIDType;
#endif
 
    ImageAccessorBase(ImageConstPointer iP, const ImageDataItem *iDI = nullptr, int OptionFlags = DefaultBehavior);
 
    // ImagePointer m_Image;
 
    itk::ImageRegion<4> *m_SubRegion;
 
    void *m_AddressBegin;
 
    void *m_AddressEnd;
 
    int m_Options;
 
    bool m_CoherentMemory;
 
    ImageAccessorWaitLock *m_WaitLock;
 
    inline void Increment() { m_WaitLock->m_WaiterCount += 1; }
    bool Overlap(const ImageAccessorBase *iAB);
 
    void WaitForReleaseOf(ImageAccessorWaitLock *wL);
 
    ThreadIDType m_Thread;
 
    void PreventRecursiveMutexLock(ImageAccessorBase *iAB);
 
    virtual const Image *GetImage() const = 0;
 
  private:
    ThreadIDType CurrentThreadHandle();
    inline bool CompareThreadHandles(ThreadIDType, ThreadIDType);
  };
 
  class MemoryIsLockedException : public Exception
  {
  public:
    mitkExceptionClassMacro(MemoryIsLockedException, Exception)
  };
}
 
#endif