itkChainCodePath2D.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkChainCodePath2D.h,v $
  Language:  C++
  Date:      $Date: 2003/09/10 14:29:03 $
  Version:   $Revision: 1.5 $

  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 _itkChainCodePath2D_h
#define _itkChainCodePath2D_h

#include "itkChainCodePath.h"
#include "itkObjectFactory.h"
#include "itkIndex.h"
#include "itkOffset.h"
#include <vector>
#include <string>


namespace itk
{


class ITKCommon_EXPORT ChainCodePath2D : public
ChainCodePath<2>
{
public:
  itkStaticConstMacro(Dimension, unsigned int, 2);

  typedef ChainCodePath2D   Self;
  typedef ChainCodePath<2>  Superclass;

  typedef SmartPointer<Self>  Pointer;
  typedef SmartPointer<const Self>  ConstPointer;
  
  itkTypeMacro(ChainCodePath2D, ChainCodePath);

  
  typedef Superclass::OutputType   OutputType;
  typedef Superclass::InputType    InputType;

  typedef OutputType  OffsetType;
  typedef Index<2>    IndexType;

  typedef std::vector<OffsetType>  ChainCodeType;
  typedef std::vector<int>         ChainCode2DType;



  // Functions inherited from Path
  
  virtual OutputType Evaluate( const InputType & input ) const;
  
  virtual IndexType EvaluateToIndex( const InputType & input ) const;
  
  virtual OffsetType IncrementInput(InputType & input) const;



  // Functions specific to ChainCodePath and its descendents

  itkNewMacro( Self );
  
  inline unsigned int NumberOfSteps() const { return m_Chain2D.size(); }
  
  
  inline void InsertStep( InputType position, int encodedStep )
  {
    m_Chain2D.insert( m_Chain2D.begin()+position, encodedStep );
    this->Modified();
  }
  inline void InsertStep( InputType position, OffsetType step )
  {
    m_Chain2D.insert( m_Chain2D.begin()+position, EncodeOffset(step) );
    this->Modified();
  }
  
  
  inline void ChangeStep( InputType position, int encodedStep )
  {
    m_Chain2D[position]=encodedStep;
    this->Modified();
  }
  inline void ChangeStep( InputType position, OffsetType step )
  {
    m_Chain2D[position]=EncodeOffset(step);
    this->Modified();
  }
  
  virtual inline void Clear()
    {
    m_Chain2D.clear();
    this->Modified();
    }
  
  std::string GetChainCodeAsString(void) const;



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

  inline int EncodeOffset( OffsetType  step ) const
    {
    return m_FreemanCode[  step[0] + 1  ][  step[1] + 1  ];
    }
  inline OffsetType DecodeOffset( int encodedStep ) const
    {
    return m_ReverseFreemanCode[ encodedStep ];
    }



private:
  ChainCodePath2D(const Self&); //purposely not implemented
  void operator=(const Self&);  //purposely not implemented
  
  ChainCode2DType  m_Chain2D;   // the Freeman-encoded chain code
  
  // FreemanCode[][] implements a lookup table for converting offsets to a
  // Freeman code.  Within each dimension, the only allowable offset values are
  // { -1, 0, 1 }.  The y-axis is assumed to point up.  It is initialized in the
  // constructor.  Use it as follows:
  //
  //   encodedValue = m_FreemanCode[ x offset + 1 ][ y offset + 1 ]
  //
  int m_FreemanCode[3][3];

  // m_ReverseFreemanCode[ encodedValue ] implements a lookup table for the
  // inverse of m_FreemanCode[][].  It is initialized in the constructor.
  OffsetType m_ReverseFreemanCode[9];
};

} // namespace itk

#endif

---