mitkImagePixelWriteAccessor.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 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);
 
    ~ImagePixelWriteAccessor() override {}
 
  private:
    ImageWriteAccessor m_WriteAccessor;
 
    ImagePixelWriteAccessor &operator=(const ImagePixelWriteAccessor &); // Not implemented on purpose.
    ImagePixelWriteAccessor(const ImagePixelWriteAccessor &);
  };
}
#endif