mitkSlicedData.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 mitkSlicedData_h
#define mitkSlicedData_h
 
#include <itkImageRegion.h>
#include <itkIndex.h>
#include <itkOffset.h>
#include <itkSize.h>
#include <mitkBaseData.h>
#include <mitkSlicedGeometry3D.h>
#include <MitkCoreExports.h>
 
namespace mitk
{
  class SlicedGeometry3D;
 
  class MITKCORE_EXPORT SlicedData : public BaseData
  {
  public:
    mitkClassMacro(SlicedData, BaseData);
 
    itkStaticConstMacro(RegionDimension, unsigned int, 5);
 
    typedef itk::ImageRegion<RegionDimension> RegionType;
 
    typedef itk::Index<RegionDimension> IndexType;
    typedef IndexType::IndexValueType IndexValueType;
 
    typedef itk::Offset<RegionDimension> OffsetType;
    typedef OffsetType::OffsetValueType OffsetValueType;
 
    typedef itk::Size<RegionDimension> SizeType;
    typedef SizeType::SizeValueType SizeValueType;
 
    void UpdateOutputInformation() override;
 
    void PrepareForNewData() override;
 
    void SetRequestedRegionToLargestPossibleRegion() override;
 
    bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
 
    bool VerifyRequestedRegion() override;
 
    void SetRequestedRegion(const itk::DataObject *data) override;
 
    virtual void SetRequestedRegion(SlicedData::RegionType *region);
 
    void SetLargestPossibleRegion(SlicedData::RegionType *region);
 
    const RegionType &GetLargestPossibleRegion() const { return m_LargestPossibleRegion; }
 
    virtual const RegionType &GetRequestedRegion() const { return m_RequestedRegion; }
 
    virtual bool IsSliceSet(int s = 0, int t = 0, int n = 0) const = 0;
 
    virtual bool IsVolumeSet(int t = 0, int n = 0) const = 0;
 
    virtual bool IsChannelSet(int n = 0) const = 0;
 
    void CopyInformation(const itk::DataObject *data) override;
 
    unsigned int GetNumberOfChannels() const { return m_LargestPossibleRegion.GetSize(4); }
 
    SlicedGeometry3D *GetSlicedGeometry(unsigned int t = 0) const;
 
    const SlicedGeometry3D *GetUpdatedSlicedGeometry(unsigned int t = 0);
 
    void SetGeometry(BaseGeometry *aGeometry3D) override;
 
    void SetOrigin(const Point3D &origin) override;
 
    virtual void SetSpacing(const ScalarType aSpacing[]);
 
    virtual void SetSpacing(mitk::Vector3D aSpacing);
 
  protected:
    SlicedData();
    SlicedData(const SlicedData &other);
    ~SlicedData() override;
    RegionType m_LargestPossibleRegion;
 
    mutable RegionType m_RequestedRegion;
    mutable bool m_RequestedRegionInitialized;
 
    RegionType m_BufferedRegion;
    bool m_UseLargestPossibleRegion;
  };
 
} // namespace mitk
 
#endif