ImageContainerByITKImage.h

 
#pragma once
 
#if defined(ImageContainerByITKImage_RECURSES)
#error Recursive header files inclusion detected in ImageContainerByITKImage.h
#else // defined(ImageContainerByITKImage_RECURSES)
#define ImageContainerByITKImage_RECURSES
 
#if !defined ImageContainerByITKImage_h
#define ImageContainerByITKImage_h
 
// Inclusions
#include "DGtal/base/Common.h"
#include "DGtal/base/CLabel.h"
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/images/DefaultConstImageRange.h"
#include "DGtal/images/DefaultImageRange.h"
 
#if defined(__GNUG__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#pragma GCC diagnostic ignored "-Wpedantic"
#endif
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation"
#endif
#include <itkImage.h>
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionIterator.h>
#include <iostream>
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
#if defined(__GNUG__)
#pragma GCC diagnostic pop
#endif
 
namespace DGtal
{
 
    // template class ImageContainerByITKImage
    template <typename TDomain, typename TValue>
    class ImageContainerByITKImage
    {
      // ----------------------- Standard services ------------------------------
    public:
 
      BOOST_CONCEPT_ASSERT(( concepts::CLabel<TValue> ));
      BOOST_CONCEPT_ASSERT(( concepts::CDomain<TDomain> ));
 
      typedef TValue Value;
      typedef TDomain Domain;
      typedef ImageContainerByITKImage<TDomain, TValue> Self;
 
      // static constants
      static const typename Domain::Dimension dimension = Domain::dimension;
 
      typedef typename Domain::Point Point;
      typedef typename Domain::Vector Vector;
      typedef typename Domain::Dimension Dimension;
      typedef typename Domain::Integer Integer;
      typedef typename Domain::Size Size;
      typedef Point Vertex;
      typedef PointVector<dimension, double> RealPoint;
      typedef RealPoint PhysicalPoint;
 
      typedef typename itk::Image< TValue, dimension> ITKImage;
      typedef typename itk::ImageBase<dimension>::SpacingValueType ITKSpacingValueType;
      typedef RealPoint ImageSpacing;
      typedef typename ITKImage::Pointer ITKImagePointer;
      typedef typename ITKImage::PixelContainer Container;
      typedef typename itk::ImageRegionConstIterator< ITKImage > ConstIterator;
      typedef typename itk::ImageRegionIterator< ITKImage > Iterator;
 
      typedef DefaultConstImageRange<Self> ConstRange;
      typedef DefaultImageRange<Self> Range;
 
      ImageContainerByITKImage(const Domain& aDomain);
 
      ImageContainerByITKImage(const ITKImagePointer &aRef);
 
      ImageContainerByITKImage(const ImageContainerByITKImage& other);
 
      ImageContainerByITKImage & operator=(const ImageContainerByITKImage & other);
 
      ~ImageContainerByITKImage();
 
      // ----------------------- Interface --------------------------------------
    public:
 
      void updateDomain(const Point & inputDomainShift = Point());
 
      ConstRange constRange() const
      {
          return ConstRange(*this);
      }
 
      Range range()
      {
          return Range(*this);
      }
 
      const Container & container() const
      {
        return *(myITKImagePointer->GetPixelContainer());
      }
      Container & container()
      {
        return *(myITKImagePointer->GetPixelContainer());
      }
 
      Value operator()(const Point &domainPoint) const;
 
      Value operator()(const ConstIterator &it) const;
 
      Value operator()(const Iterator &it) const;
 
      void setValue(const Point &domainPoint, const Value &aValue);
 
      void setValue(Iterator &it, const Value &V);
 
      // ------------------------- methods ------------------------------
 
 
      const Domain& domain() const
      {
          return myDomain;
      }
 
      inline
      ITKImagePointer getITKImagePointer() const
      {
          return myITKImagePointer;
      }
 
      inline
      const Point & getDomainShift() const
      {
          return myDomainShift;
      }
 
      // ------------------------- stream ------------------------------
 
      void selfDisplay ( std::ostream & out ) const;
 
      bool isValid() const;
 
      // ------------------------- Iterators ------------------------------
      inline
      ConstIterator begin() const
      {
          ConstIterator iter = ConstIterator(myITKImagePointer, myITKImagePointer->GetLargestPossibleRegion());
          iter.GoToBegin();
          return iter;
      }
 
      inline
      Iterator begin()
      {
          Iterator iter = Iterator(myITKImagePointer, myITKImagePointer->GetLargestPossibleRegion());
          iter.GoToBegin();
          return iter;
      }
 
      inline
      const ConstIterator end() const
      {
          ConstIterator iter = ConstIterator(myITKImagePointer, myITKImagePointer->GetLargestPossibleRegion());
          iter.GoToEnd();
          return iter;
      }
 
      inline
      Iterator end()
      {
          Iterator iter = Iterator(myITKImagePointer, myITKImagePointer->GetLargestPossibleRegion());
          iter.GoToEnd();
          return iter;
      }
 
      // ----------------- DomainPoint to/from IndexPoint interface -------------
 
      inline Point getDomainPointFromIndex(const Point &indexPoint) const;
 
      inline Point getIndexFromDomainPoint(const Point &domainPoint) const;
 
      inline Point getDomainPointFromItkIndex(const typename ITKImage::IndexType &itkIndexPoint) const;
 
      inline typename ITKImage::IndexType getItkIndexFromDomainPoint(const Point &domainPoint) const;
 
 
      // ------------------------- PhysicalPoint interface ----------------------
 
      inline PhysicalPoint getPhysicalPointFromDomainPoint(const Point &domainPoint) const;
 
      inline Point getDomainPointFromPhysicalPoint(const PhysicalPoint &physicalPoint) const;
 
      inline PhysicalPoint getLowerBoundAsPhysicalPoint() const;
      inline PhysicalPoint getUpperBoundAsPhysicalPoint() const;
      inline ImageSpacing getImageSpacing() const;
      inline void setImageSpacing(const ImageSpacing& s) const;
 
      // ------------------------- Private Datas --------------------------------
    private:
 
      // ------------------------- Hidden services ------------------------------
    protected:
 
      ImageContainerByITKImage();
 
      // ------------------------- Internals ------------------------------------
    private:
 
      ITKImagePointer myITKImagePointer;
      Domain myDomain; // cached from myITKImagePointer region. updated when calling update().
 
      Point myDomainShift = Point();
    }; // end of class ImageContainerByITKImage
 
  template <typename T, typename TV>
  std::ostream&
  operator<< ( std::ostream & out, const ImageContainerByITKImage<T, TV> & object );
 
}
// Includes inline functions.
#include "DGtal/images/ImageContainerByITKImage.ih"
 
//
 
#endif // !defined ImageContainerByITKImage_h
 
#undef ImageContainerByITKImage_RECURSES
#endif // else defined(ImageContainerByITKImage_RECURSES)