itkChainCodePath2D.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkChainCodePath2D_h
#define __itkChainCodePath2D_h

#include "itkChainCodePath.h"
#include "itkIndex.h"

#include <vector>
#include <string>

namespace itk
{
class 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 Superclass::ChainCodeType     ChainCodeType;
  typedef Superclass::ChainCodeSizeType ChainCodeSizeType;

  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 ChainCodeSizeType 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];
};
} // end namespace itk

#endif