itkSpatiallyDenseSparseVectorImage.h

Go to the documentation of this file.

/*=========================================================================

 Program:   Spatially Dense Sparse Vector Image

 Copyright (c) Pew-Thian Yap. All rights reserved.
 See http://www.unc.edu/~ptyap/ for details.

 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.

 =========================================================================*/

#ifndef __itkSpatiallyDenseSparseVectorImage_h
#define __itkSpatiallyDenseSparseVectorImage_h

#include "itkImage.h"
#include "itkSpatiallyDenseSparseVectorImagePixelAccessor.h"
#include "itkSpatiallyDenseSparseVectorImagePixelAccessorFunctor.h"
#include "itkSpatiallyDenseSparseVectorImageNeighborhoodAccessorFunctor.h"
#include "itkNeighborhoodAccessorFunctor.h"
#include "itkVariableLengthVector.h"
#include "itkSparseVector.h"


namespace itk
{

template <class TValueType, unsigned int VImageDimension, typename TKeyType = unsigned long>
class ITK_EXPORT SpatiallyDenseSparseVectorImage :
    public ImageBase< VImageDimension >
{
public:
  typedef SpatiallyDenseSparseVectorImage  Self;
  typedef ImageBase< VImageDimension >     Superclass;
  typedef SmartPointer<Self>               Pointer;
  typedef SmartPointer<const Self>         ConstPointer;
  typedef WeakPointer<const Self>          ConstWeakPointer;

  itkNewMacro(Self);

  itkTypeMacro(SpatiallyDenseSparseVectorImage, Image);

  typedef VariableLengthVector< TValueType > PixelType;

  typedef TValueType ValueType;
  typedef TKeyType KeyType;
  typedef SparseVector<TValueType, TKeyType> InternalPixelType;

  typedef InternalPixelType IOPixelType;

  itkStaticConstMacro( ImageDimension, unsigned int, VImageDimension );

  typedef ImportImageContainer< SizeValueType, InternalPixelType > PixelContainer;

  typedef typename PixelContainer::Pointer PixelContainerPointer;
  typedef typename PixelContainer::ConstPointer PixelContainerConstPointer;

  typedef typename InternalPixelType::InternalDataType PixelMapType;
  typedef typename PixelMapType::iterator PixelMapIterator;
  typedef typename PixelMapType::const_iterator PixelMapConstIterator;

  typedef typename Superclass::IndexType IndexType;

  typedef typename Superclass::OffsetType OffsetType;

  typedef typename Superclass::SizeType SizeType;

  typedef typename Superclass::DirectionType DirectionType;

  typedef typename Superclass::RegionType RegionType;

  typedef typename Superclass::SpacingType SpacingType;

  typedef typename Superclass::PointType PointType;

  typedef typename Superclass::OffsetValueType OffsetValueType;

  typedef unsigned long VectorLengthType;

  typedef SpatiallyDenseSparseVectorImagePixelAccessor<
    ValueType, KeyType > AccessorType;

  typedef SpatiallyDenseSparseVectorImagePixelAccessorFunctor< Self >
    AccessorFunctorType;

  typedef SpatiallyDenseSparseVectorImageNeighborhoodAccessorFunctor< Self >
    NeighborhoodAccessorFunctorType;

//  void Allocate();
  void Allocate(bool UseDefaultConstructor = false) ITK_OVERRIDE;

//  using Superclass::SetRegions;
  void SetRegions(const RegionType & region) ITK_OVERRIDE
    {
    this->SetLargestPossibleRegion(region);
    this->SetBufferedRegion(region);
    this->SetRequestedRegion(region);
    }

  void SetRegions(const SizeType & size) ITK_OVERRIDE
    {
    RegionType region; region.SetSize(size);
    this->SetLargestPossibleRegion(region);
    this->SetBufferedRegion(region);
    this->SetRequestedRegion(region);
    }

  virtual void SetBufferedRegion(const RegionType &region) ITK_OVERRIDE
    {
    this->ComputeOffsetTable();
    this->Modified();
    }

  virtual const RegionType& GetBufferedRegion() const ITK_OVERRIDE
  { return this->GetLargestPossibleRegion(); }

  virtual void Initialize() ITK_OVERRIDE;

  OffsetValueType ComputeOffset(const IndexType &ind) const
  {
    OffsetValueType offset=0;
    const OffsetValueType *offsetTable = this->GetOffsetTable();

    for (int i=ImageDimension-1; i > 0; i--)
      {
      offset += ind[i]*offsetTable[i];
      }
    offset += ind[0];

    return offset;
  }

  void FillBuffer(const PixelType& value);

   void SetPixel( const IndexType &index, const PixelType &value )
    {
    PixelMapType *map = (this->GetInternalPixel(index)).GetDataPointer();

    map->clear();

    for ( VectorLengthType i = 0; i < m_VectorLength; i++ )
      {
      if ( value[i] != 0 )
        {
        (*map)[i] = value[i];
        }
      }
    }

  const PixelType GetPixel(const IndexType &index) const
    {
    PixelType pixel;
    pixel.SetSize(m_VectorLength);

    const PixelMapType *map = (this->GetInternalPixel(index)).GetDataPointer();

    for ( VectorLengthType i = 0; i < m_VectorLength; i++ )
      {
      typename PixelMapType::const_iterator it = map->find( i );

      if ( it == map->end() )
        {
        pixel[i] = m_FillBufferValue[i];
        }
      else
        {
        pixel[i] = it->second;
        }
      }

    return pixel;
    }

  PixelType GetPixel(const IndexType &index)
  {
    PixelType pixel;
    pixel.SetSize(m_VectorLength);

    const PixelMapType *map = (this->GetInternalPixel(index)).GetDataPointer();

    for ( VectorLengthType i = 0; i < m_VectorLength; i++ )
      {
      typename PixelMapType::const_iterator it = map->find( i );

      if ( it == map->end() )
        {
        pixel[i] = m_FillBufferValue[i];
        }
      else
        {
        pixel[i] = it->second;
        }
      }

    return pixel;
  }

  const InternalPixelType & GetInternalPixel(const IndexType &index) const
    {
    OffsetValueType offset = this->ComputeOffset(index);
    return (*m_Container)[offset];
    }

  InternalPixelType & GetInternalPixel(const IndexType &index)
    {
    OffsetValueType offset = this->ComputeOffset(index);
    return (*m_Container)[offset];
    }

  PixelType operator[](const IndexType &index)
     { return this->GetPixel(index); }

  PixelType operator[](const IndexType &index) const
     { return this->GetPixel(index); }

  PixelContainer* GetPixelContainer()
  {
    return m_Container.GetPointer();
  }

  const PixelContainer* GetPixelContainer() const
  {
    return m_Container.GetPointer();
  }

  InternalPixelType * GetBufferPointer()
  {
    return m_Container->GetBufferPointer();
  }
  const InternalPixelType * GetBufferPointer() const
  {
    return m_Container->GetBufferPointer();
  }

  void SetPixelContainer( PixelContainer *container );

  virtual void Graft(const DataObject *data) ITK_OVERRIDE;

  AccessorType GetPixelAccessor( void )
  {
    return AccessorType(m_FillBufferValue, m_VectorLength);
  }

  const AccessorType GetPixelAccessor( void ) const
  {
    return AccessorType(m_FillBufferValue, m_VectorLength);
  }

  NeighborhoodAccessorFunctorType GetNeighborhoodAccessor()
  {
    return NeighborhoodAccessorFunctorType(m_FillBufferValue, m_VectorLength);
  }

  const NeighborhoodAccessorFunctorType GetNeighborhoodAccessor() const
  {
    return NeighborhoodAccessorFunctorType(m_FillBufferValue, m_VectorLength);
  }

  itkSetMacro(VectorLength, VectorLengthType);
  itkGetConstReferenceMacro(VectorLength, VectorLengthType);

  virtual unsigned int GetNumberOfComponentsPerPixel() const ITK_OVERRIDE;

  virtual void SetNumberOfComponentsPerPixel(unsigned int n) ITK_OVERRIDE;

protected:
  SpatiallyDenseSparseVectorImage();
  void PrintSelf( std::ostream& os, Indent indent ) const ITK_OVERRIDE;
  virtual ~SpatiallyDenseSparseVectorImage() {};

private:
  SpatiallyDenseSparseVectorImage( const Self & ); // purposely not implementated
  void operator=(const Self&); //purposely not implemented

  PixelContainerPointer m_Container;
  PixelType m_FillBufferValue;

  VectorLengthType m_VectorLength;
};


} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkSpatiallyDenseSparseVectorImage.hxx"
#endif

#endif