ImageContainerByITKImage.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

// ----------------------- Standard services ------------------------------

namespace DGtal
{
  namespace experimental
  {

    template<typename TDomain, typename TValue>
    inline
    ImageContainerByITKImage<TDomain, TValue>::~ImageContainerByITKImage()
    {
    }

    template <typename TDomain, typename TValue>
    inline
    ImageContainerByITKImage<TDomain, TValue>::ImageContainerByITKImage(const Point &aPointA,
        const Point &aPointB)
        :  myITKImagePointer(ITKImage::New())
    {
      typename ITKImage::IndexType start;
      typename ITKImage::SizeType size;

      if (aPointA < aPointB)
      {
        myLowerBound = aPointA;
        myUpperBound = aPointB;
      }
      else
      {
        myLowerBound = aPointB;
        myUpperBound = aPointA;
      }
      Point dec = myUpperBound - myLowerBound;

      //copy of domain information
      for (Dimension k = 0; k < dimension; k++)
      {
        start[k] = myLowerBound[k];
        size[k] = dec[k];
      }

      myRegion.SetSize( size );
      myRegion.SetIndex( start );

      myITKImagePointer->SetRegions(myRegion);
      myITKImagePointer->Allocate();

      //ConstIterators
      myConstItBegin = ConstIterator( myITKImagePointer, myRegion);
      myConstItBegin.GoToBegin();
      myConstItEnd = ConstIterator( myITKImagePointer, myRegion);
      myConstItEnd.GoToEnd();

      //Iterators
      myItBegin = Iterator( myITKImagePointer, myRegion);
      myItBegin.GoToBegin();
      myItEnd = Iterator( myITKImagePointer, myRegion);
      myItEnd.GoToEnd();
    }

    template <typename TDomain, typename TValue>
    inline
    ImageContainerByITKImage<TDomain, TValue>::ImageContainerByITKImage(const Point &aPointA,
        const Point &aPointB, ITKImagePointer &aRef)
        :  myITKImagePointer(aRef)
    {
      typename ITKImage::IndexType start;
      typename ITKImage::SizeType size;

      if (aPointA < aPointB)
      {
        myLowerBound = aPointA;
        myUpperBound = aPointB;
      }
      else
      {
        myLowerBound = aPointB;
        myUpperBound = aPointA;
      }
      Point dec = myUpperBound - myLowerBound;

      //copy of domain information
      for (Dimension k = 0; k < dimension; k++)
      {
        start[k] = myLowerBound[k];
        size[k] = dec[k];
      }

      myRegion.SetSize( size );
      myRegion.SetIndex( start );

      myITKImagePointer->SetRegions(myRegion);      

      //ConstIterators
      myConstItBegin = ConstIterator( myITKImagePointer, myRegion);
      myConstItBegin.GoToBegin();
      myConstItEnd = ConstIterator( myITKImagePointer, myRegion);
      myConstItEnd.GoToEnd();

      //Iterators
      myItBegin = Iterator( myITKImagePointer, myRegion);
      myItBegin.GoToBegin();
      myItEnd = Iterator( myITKImagePointer, myRegion);
      myItEnd.GoToEnd();
    }


    // Interface - public :


    template <typename TDomain, typename TValue>
    inline
    TValue
    ImageContainerByITKImage<TDomain, TValue>::operator()(const Point &aPoint) const
    {
      typename ITKImage::IndexType p;
      for (Dimension k = 0; k < dimension; k++)
        p[k] = aPoint[k];
      return myITKImagePointer->GetPixel(p);
    }

    template <typename TDomain, typename TValue>
    inline
    TValue
    ImageContainerByITKImage<TDomain, TValue>::operator()(const ConstIterator &it) const
    {
      return it.Get();
    }

    template <typename TDomain, typename TValue>
    inline
    TValue
    ImageContainerByITKImage<TDomain, TValue>::operator()(const Iterator &it) const
    {
      return it.Get();
    }

    template <typename Domain, typename T>
    inline
    void
    ImageContainerByITKImage<Domain, T>::setValue(const Point &aPoint, const T &V)
    {
      typename ITKImage::IndexType p;
      for (Dimension k = 0; k < dimension; k++)
        p[k] = aPoint[k];
      myITKImagePointer->SetPixel(p, V);
    }

    template <typename Domain, typename T>
    inline
    void
    ImageContainerByITKImage<Domain, T>::setValue(Iterator &it, const T &V)
    {
      it.Set(V);
    }

    template<typename TDomain, typename TValue>
    inline
    void
    ImageContainerByITKImage<TDomain, TValue>::selfDisplay ( std::ostream & out ) const
    {
      out << "[ImageContainerByITKImage] valuetype=" << sizeof(TValue) 
    << "bytes lower=" << myLowerBound << " upper=" 
    << myUpperBound;
    }

    template<typename TDomain, typename TValue>
    inline
    bool
    ImageContainerByITKImage<TDomain, TValue>::isValid() const
    {
      return true;
    }

  }


  // Implementation of inline functions                                        //

  template<typename TDomain, typename TValue>
  inline
  std::ostream&
  operator<< ( std::ostream & out,
      const experimental::ImageContainerByITKImage<TDomain, TValue> & object )
  {
    object.selfDisplay( out );
    return out;
  }
}
//                                                                           //