itkSparseFieldLayer.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSparseFieldLayer.h,v $
  Language:  C++
  Date:      $Date: 2008-10-18 16:11:13 $
  Version:   $Revision: 1.8 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 __itkSparseFieldLayer_h
#define __itkSparseFieldLayer_h

#include "itkObjectFactory.h"
#include "itkObject.h"
#include <vector>

namespace itk {

template <class TNodeType>
class ConstSparseFieldLayerIterator
{
public:
  const TNodeType& operator*() const
    { return *m_Pointer; }

  const TNodeType* operator->() const
    { return m_Pointer; }

  const TNodeType* GetPointer() const
    { return m_Pointer; }
  
  bool operator==(const ConstSparseFieldLayerIterator o) const
    {
    if (m_Pointer == o.m_Pointer) return true;
    else return false;
    }

  bool operator!=(const ConstSparseFieldLayerIterator o) const
    {
    if (m_Pointer != o.m_Pointer) return true;
    else return false;
    }

  ConstSparseFieldLayerIterator &operator++()
    {
    m_Pointer = m_Pointer->Next;
    return *this;
    }

  ConstSparseFieldLayerIterator &operator--()
    {
    m_Pointer = m_Pointer->Previous;
    return *this;
    }

  ConstSparseFieldLayerIterator()
    { m_Pointer=0; }

  ConstSparseFieldLayerIterator(TNodeType *p)
    { m_Pointer=p; }

  ~ConstSparseFieldLayerIterator() {}

protected:
  TNodeType *m_Pointer;
};

template <class TNodeType>
class SparseFieldLayerIterator
  : public ConstSparseFieldLayerIterator<TNodeType>
{
public:
  typedef ConstSparseFieldLayerIterator<TNodeType> Superclass;

  SparseFieldLayerIterator() : Superclass()
    {}

  SparseFieldLayerIterator(TNodeType *p) : Superclass(p)
    {}

  TNodeType &operator*()
    { return *this->m_Pointer; }

  TNodeType* operator->()
    { return this->m_Pointer; }

  TNodeType* GetPointer()
    { return this->m_Pointer; }
  
  SparseFieldLayerIterator &operator++()
    {
    this->m_Pointer = this->m_Pointer->Next;
    return *this;
    }

  SparseFieldLayerIterator &operator--()
    {
    this->m_Pointer = this->m_Pointer->Previous;
    return *this;
    }

  SparseFieldLayerIterator &operator=(Superclass &sc)
    {
    this->m_Pointer = const_cast<TNodeType*> (sc.GetPointer());
    return *this;
    }
};


template <class TNodeType>
class ITK_EXPORT SparseFieldLayer
    : public Object
{
public:
  typedef SparseFieldLayer          Self;
  typedef Object                    Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(SparseFieldLayer, Object);

  typedef TNodeType NodeType;

  typedef NodeType ValueType;

  typedef SparseFieldLayerIterator<NodeType> Iterator;

  typedef ConstSparseFieldLayerIterator<NodeType> ConstIterator;

  struct RegionType 
    {
    ConstIterator first;
    ConstIterator last;  // this is one past the actual last element
    };   

  typedef std::vector<RegionType> RegionListType;

  NodeType *Front()
    { return m_HeadNode->Next; }

  const NodeType *Front() const
    { return m_HeadNode->Next; }

  void PopFront()
    {
    m_HeadNode->Next = m_HeadNode->Next->Next;
    m_HeadNode->Next->Previous = m_HeadNode;
    m_Size -= 1;
    }

  void PushFront(NodeType *n)
    {
    n->Next = m_HeadNode->Next;
    n->Previous = m_HeadNode;
    m_HeadNode->Next->Previous = n;
    m_HeadNode->Next = n;
    m_Size += 1;
    }

  void Unlink(NodeType *n)
    {
    n->Previous->Next = n->Next;
    n->Next->Previous = n->Previous;
    m_Size -= 1;
    }

  Iterator Begin()
    { return Iterator(m_HeadNode->Next); }

  ConstIterator Begin() const
    { return ConstIterator(m_HeadNode->Next); }

  Iterator End()
    { return Iterator(m_HeadNode); }

  ConstIterator End() const
    { return ConstIterator(m_HeadNode); }

  bool Empty() const
    {
    if (m_HeadNode->Next == m_HeadNode) return true;
    else return false;
    }

  unsigned int Size() const;

  RegionListType SplitRegions(int num) const;

protected:
  SparseFieldLayer();
  ~SparseFieldLayer();
  virtual void PrintSelf(std::ostream& os, Indent indent) const;
  
private:
  SparseFieldLayer(const Self&);    //purposely not implemented
  void operator=(const Self&);      //purposely not implemented
  
  NodeType *   m_HeadNode;
  unsigned int m_Size;
};


} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkSparseFieldLayer.txx"
#endif

#endif

---