mitkImagePixelReadAccessor.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 mitkImagePixelReadAccessor_h
#define mitkImagePixelReadAccessor_h
 
#include <mitkImagePixelAccessor.h>
#include <mitkImageReadAccessor.h>
 
namespace mitk
{
  class Image;
 
  template <class TPixel, unsigned int VDimension = 3>
  class ImagePixelReadAccessor : public ImagePixelAccessor<TPixel, VDimension>
  {
    friend class Image;
 
  public:
    typedef ImagePixelAccessor<TPixel, VDimension> ImagePixelAccessorType;
    typedef itk::SmartPointer<mitk::Image> ImagePointer;
    typedef itk::SmartPointer<const mitk::Image> ImageConstPointer;
 
    ImagePixelReadAccessor(ImageConstPointer iP,
                           const ImageDataItem *iDI = nullptr,
                           int OptionFlags = ImageAccessorBase::DefaultBehavior)
      : ImagePixelAccessor<TPixel, VDimension>(iP, iDI), m_ReadAccessor(iP, iDI, OptionFlags)
    {
    }
 
    ImagePixelReadAccessor(ImagePointer iP,
                           const ImageDataItem *iDI = nullptr,
                           int OptionFlags = ImageAccessorBase::DefaultBehavior)
      : ImagePixelAccessor<TPixel, VDimension>(iP.GetPointer(), iDI), m_ReadAccessor(iP, iDI, OptionFlags)
    {
    }
 
    ImagePixelReadAccessor(Image *iP,
                           const ImageDataItem *iDI = nullptr,
                           int OptionFlags = ImageAccessorBase::DefaultBehavior)
      : ImagePixelAccessor<TPixel, VDimension>(iP, iDI), m_ReadAccessor(mitk::Image::ConstPointer(iP), iDI, OptionFlags)
    {
    }
 
    ImagePixelReadAccessor(const Image *iP,
                           const ImageDataItem *iDI = nullptr,
                           int OptionFlags = ImageAccessorBase::DefaultBehavior)
      : ImagePixelAccessor<TPixel, VDimension>(iP, iDI), m_ReadAccessor(iP, iDI, OptionFlags)
    {
    }
 
    ~ImagePixelReadAccessor() override {}
    const TPixel &GetPixelByIndex(const itk::Index<VDimension> &idx) const
    {
      unsigned int offset = ImagePixelAccessorType::GetOffset(idx);
 
      return *(((TPixel *)m_ReadAccessor.m_AddressBegin) + offset);
    }
 
    itk::VariableLengthVector<TPixel> GetConsecutivePixelsAsVector(const itk::Index<VDimension> &idx,
                                                                   int nrComponents) const
    {
      return itk::VariableLengthVector<TPixel>(
        (TPixel *)m_ReadAccessor.m_AddressBegin +
          ImagePixelAccessorType::GetOffset(idx) * m_ReadAccessor.GetImage()->GetPixelType().GetNumberOfComponents(),
        nrComponents);
    }
 
    const TPixel &GetPixelByIndexSafe(const itk::Index<VDimension> &idx) const
    {
      unsigned int offset = ImagePixelAccessorType::GetOffset(idx);
 
      TPixel *targetAddress = ((TPixel *)m_ReadAccessor.m_AddressBegin) + offset;
 
      if (!(targetAddress >= m_ReadAccessor.m_AddressBegin && targetAddress < m_ReadAccessor.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_ReadAccessor.GetImage()->GetGeometry()->WorldToIndex(position, itkIndex);
 
      return GetPixelByIndex(itkIndex);
    }
 
    const TPixel &GetPixelByWorldCoordinates(mitk::Point3D position, unsigned int timestep)
    {
      itk::Index<3> itkIndex;
      m_ReadAccessor.GetImage()->GetGeometry()->WorldToIndex(position, itkIndex);
      if (m_ReadAccessor.GetImage()->GetTimeSteps() < timestep)
      {
        timestep = m_ReadAccessor.GetImage()->GetTimeSteps();
      }
      itk::Index<4> itk4Index;
      for (int i = 0; i < 3; ++i)
        itk4Index[i] = itkIndex[i];
 
      itk4Index[3] = timestep;
      return GetPixelByIndex(itk4Index);
    }
 
    inline const TPixel *GetData() const { return static_cast<const TPixel *>(m_ReadAccessor.m_AddressBegin); }
  protected:
    // protected members
 
  private:
    ImageReadAccessor m_ReadAccessor;
 
    ImagePixelReadAccessor &operator=(const ImagePixelReadAccessor &); // Not implemented on purpose.
    ImagePixelReadAccessor(const ImagePixelReadAccessor &);
  };
 
  template <class TPixel>
  mitk::ScalarType FastSinglePixelAccess(mitk::PixelType,
                                         mitk::Image::Pointer im,
                                         ImageDataItem *item,
                                         itk::Index<3> idx,
                                         mitk::ScalarType &val,
                                         int component = 0)
  {
    ImagePixelReadAccessor<TPixel, 3> imAccess(im, item, mitk::ImageAccessorBase::IgnoreLock);
    val = imAccess.GetConsecutivePixelsAsVector(idx, component + 1).GetElement(component);
    return val;
  }
 
  template <class TPixel>
  mitk::ScalarType FastSinglePixelAccess(mitk::PixelType,
    mitk::Image::ConstPointer im,
    const ImageDataItem* item,
    itk::Index<3> idx,
    mitk::ScalarType& val,
    int component = 0)
  {
    ImagePixelReadAccessor<TPixel, 3> imAccess(im, item, mitk::ImageAccessorBase::IgnoreLock);
    val = imAccess.GetConsecutivePixelsAsVector(idx, component + 1).GetElement(component);
    return val;
  }
 
}
 
#endif