itkSparseFieldLayer.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSparseFieldLayer.h,v $
  Language:  C++
  Date:      $Date: 2004/12/21 22:47:31 $
  Version:   $Revision: 1.7 $

  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;

  //  void Splice (SparseFieldLayer &);

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

---