mitkImagePixelWriteAccessor.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 MITKIMAGEPIXELWRITEACCESSOR_H
#define MITKIMAGEPIXELWRITEACCESSOR_H

#include "mitkImagePixelAccessor.h"
#include "mitkImageWriteAccessor.h"

namespace mitk
{
  template <class TPixel, unsigned int VDimension = 3>
  class ImagePixelWriteAccessor : public ImagePixelAccessor<TPixel, VDimension>
  {
    friend class Image;

  public:
    typedef ImagePixelAccessor<TPixel, VDimension> ImagePixelAccessorType;
    typedef itk::SmartPointer<mitk::Image> ImagePointer;

    ImagePixelWriteAccessor(ImagePointer iP,
                            const ImageDataItem *iDI = nullptr,
                            int OptionFlags = ImageAccessorBase::DefaultBehavior)
      : ImagePixelAccessor<TPixel, VDimension>(iP.GetPointer(), iDI), m_WriteAccessor(iP, iDI, OptionFlags)
    {
    }

    virtual inline TPixel *GetData() const { return static_cast<TPixel *>(m_WriteAccessor.m_AddressBegin); }
    void SetPixelByIndex(const itk::Index<VDimension> &idx, const TPixel &value)
    {
      unsigned int offset = ImagePixelAccessor<TPixel, VDimension>::GetOffset(idx);

      *(((TPixel *)m_WriteAccessor.m_AddressBegin) + offset) = value;
    }

    void SetPixelByIndexSafe(const itk::Index<VDimension> &idx, const TPixel &value)
    {
      unsigned int offset = ImagePixelAccessorType::GetOffset(idx);

      TPixel *targetAddress = ((TPixel *)m_WriteAccessor.m_AddressBegin) + offset;

      if (targetAddress >= m_WriteAccessor.m_AddressBegin && targetAddress < m_WriteAccessor.m_AddressEnd)
      {
        *targetAddress = value;
      }
      else
      {
        // printf("image dimensions = %d, %d, %d\n", imageDims[0], imageDims[1], imageDims[2]);
        // printf("m_AddressBegin: %p, m_AddressEnd: %p, offset: %u\n", m_WriteAccessor.m_AddressBegin,
        // m_WriteAccessor.m_AddressEnd, offset);
        mitkThrow() << "ImageAccessor Overflow: image access exceeds the requested image area at " << idx << ".";
      }
    }

    const TPixel &GetPixelByIndex(const itk::Index<VDimension> &idx) const
    {
      unsigned int offset = ImagePixelAccessorType::GetOffset(idx);

      return *(((TPixel *)m_WriteAccessor.m_AddressBegin) + offset);
    }

    const TPixel &GetPixelByIndexSafe(const itk::Index<VDimension> &idx) const
    {
      unsigned int offset = ImagePixelAccessorType::GetOffset(idx);

      TPixel *targetAddress = ((TPixel *)m_WriteAccessor.m_AddressBegin) + offset;

      if (!(targetAddress >= m_WriteAccessor.m_AddressBegin && targetAddress < m_WriteAccessor.m_AddressEnd))
      {
        mitkThrow() << "ImageAccessor Overflow: image access exceeds the requested image area at " << idx << ".";
      }

      return *targetAddress;
    }

    const TPixel &GetPixelByWorldCoordinates(mitk::Point3D position)
    {
      itk::Index<3> itkIndex;
      m_WriteAccessor.GetImage()->GetGeometry()->WorldToIndex(position, itkIndex);

      return GetPixelByIndex(itkIndex);
    }

    void SetPixelByWorldCoordinates(const mitk::Point3D &, const TPixel &value, unsigned int timestep = 0);

    virtual ~ImagePixelWriteAccessor() {}
  private:
    ImageWriteAccessor m_WriteAccessor;

    ImagePixelWriteAccessor &operator=(const ImagePixelWriteAccessor &); // Not implemented on purpose.
    ImagePixelWriteAccessor(const ImagePixelWriteAccessor &);
  };
}
#endif // MITKIMAGEWRITEACCESSOR_H