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 ITK_TEMPLATE_EXPORT ChainCodePath2D:public
  ChainCodePath< 2 >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(ChainCodePath2D);

  static constexpr unsigned int Dimension = 2;

  using Self = ChainCodePath2D;
  using Superclass = ChainCodePath< 2 >;

  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;

  itkTypeMacro(ChainCodePath2D, ChainCodePath);

  using OutputType = Superclass::OutputType;
  using InputType = Superclass::InputType;

  using OffsetType = OutputType;
  using IndexType = Index< 2 >;

  using ChainCodeType = Superclass::ChainCodeType;
  using ChainCodeSizeType = Superclass::ChainCodeSizeType;

  using ChainCode2DType = std::vector< int >;

  // Functions inherited from Path

  OutputType Evaluate(const InputType & input) const override;

  IndexType EvaluateToIndex(const InputType & input) const override;

  OffsetType IncrementInput(InputType & input) const override;

  // Functions specific to ChainCodePath and its descendents

  itkNewMacro(Self);

  ChainCodeSizeType NumberOfSteps() const override { return m_Chain2D.size(); }

  inline void InsertStep(InputType position, int encodedStep)
  {
    m_Chain2D.insert(m_Chain2D.begin() + position, encodedStep);
    this->Modified();
  }

  void InsertStep(InputType position, OffsetType step) override
  {
    m_Chain2D.insert( m_Chain2D.begin() + position, EncodeOffset(step) );
    this->Modified();
  }

  inline void ChangeStep(InputType position, int encodedStep)
  {
    m_Chain2D[position] = encodedStep;
    this->Modified();
  }

  void ChangeStep(InputType position, OffsetType step) override
  {
    m_Chain2D[position] = EncodeOffset(step);
    this->Modified();
  }

  void Clear() override
  {
    m_Chain2D.clear();
    this->Modified();
  }

  std::string GetChainCodeAsString() const;

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

  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:
  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