itkChainCodePath2D.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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_MOVE(ChainCodePath2D);

  static constexpr unsigned int Dimension = 2;

  using Self = ChainCodePath2D;
  using Superclass = ChainCodePath<2>;
 
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkOverrideGetNameOfClassMacro(ChainCodePath2D);

  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 descendants

  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