mitkImageDataItem.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 mitkImageDataItem_h
#define mitkImageDataItem_h
 
#include <mitkCommon.h>
#include <MitkCoreExports.h>
#include <mitkImageDescriptor.h>
 
class vtkImageData;
 
namespace mitk
{
  class PixelType;
  class ImageVtkReadAccessor;
  class ImageVtkWriteAccessor;
 
  class Image;
 
  class MITKCORE_EXPORT ImageDataItem : public itk::LightObject
  {
    friend class ImageAccessorBase;
    friend class ImageWriteAccessor;
    friend class ImageReadAccessor;
 
    template <class TPixel, unsigned int VDimension>
    friend class ImagePixelAccessor;
 
    friend class Image;
 
    //  template<class TOutputImage>
    //  friend class ImageToItk;
 
  public:
    typedef itk::SmartPointer<mitk::Image> ImagePointer;           
    typedef itk::SmartPointer<const mitk::Image> ImageConstPointer; 
 
    mitkClassMacroItkParent(ImageDataItem, itk::LightObject);
 
    ImageDataItem(const ImageDataItem &aParent,
                  const mitk::ImageDescriptor::Pointer desc,
                  int timestep,
                  unsigned int dimension,
                  void *data = nullptr,
                  bool manageMemory = false,
                  size_t offset = 0);
 
    ~ImageDataItem() override;
 
    ImageDataItem(const mitk::ImageDescriptor::Pointer desc, int timestep, void *data, bool manageMemory);
 
    ImageDataItem(const mitk::PixelType &type,
                  int timestep,
                  unsigned int dimension,
                  unsigned int *dimensions,
                  void *data,
                  bool manageMemory);
 
    ImageDataItem(const ImageDataItem &other) = delete;
    ImageDataItem &operator=(const ImageDataItem &other) = delete;
 
    bool IsComplete() const { return m_IsComplete; }
 
    void SetComplete(bool complete) { m_IsComplete = complete; }
 
    int GetOffset() const { return m_Offset; }
 
    PixelType GetPixelType() const { return *m_PixelType; }
 
    void SetTimestep(int t) { m_Timestep = t; }
 
    void SetManageMemory(bool b) { m_ManageMemory = b; }
 
    int GetDimension() const { return m_Dimension; }
 
    int GetDimension(int i) const
    {
      int returnValue = 0;
 
      // return the true size if dimension available
      if (i < (int)m_Dimension)
        returnValue = m_Dimensions[i];
 
      return returnValue;
    }
 
    ImageDataItem::ConstPointer GetParent() const { return m_Parent; }
 
    ImageVtkReadAccessor *GetVtkImageAccessor(ImageConstPointer iP) const;
 
    ImageVtkWriteAccessor *GetVtkImageAccessor(ImagePointer iP);
 
    bool GetManageMemory() const { return m_ManageMemory; }
 
    virtual void ConstructVtkImageData(ImageConstPointer iP) const;
 
    size_t GetSize() const { return m_Size; }
 
    virtual void Modified() const;
 
  protected:
    void* GetData() const { return m_Data; }
 
    unsigned char *m_Data;
 
    PixelType *m_PixelType;
 
    bool m_ManageMemory;
 
    mutable vtkImageData *m_VtkImageData;
    mutable ImageVtkReadAccessor *m_VtkImageReadAccessor;
    ImageVtkWriteAccessor *m_VtkImageWriteAccessor;
    int m_Offset;
 
    bool m_IsComplete;
 
    size_t m_Size;
 
  private:
    void ComputeItemSize(const unsigned int *dimensions, unsigned int dimension);
 
    ImageDataItem::ConstPointer m_Parent;
 
    unsigned int m_Dimension;
 
    unsigned int m_Dimensions[MAX_IMAGE_DIMENSIONS];
 
    int m_Timestep;
  };
 
} // namespace mitk
 
#endif