mitkImageAccessorBase.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef MITKIMAGEACCESSORBASE_H
#define MITKIMAGEACCESSORBASE_H

#include <itkImageRegion.h>
#include <itkIndex.h>
#include <itkMultiThreader.h>
#include <itkSimpleFastMutexLock.h>
#include <itkSmartPointer.h>

#include "mitkImageDataItem.h"

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;

    itk::SimpleFastMutexLock 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