itkLabelObject.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 itkLabelObject_h
#define itkLabelObject_h
 
#include <deque>
#include "itkLightObject.h"
#include "itkLabelObjectLine.h"
#include "itkWeakPointer.h"
#include "itkObjectFactory.h"
 
namespace itk
{
template <typename TLabel, unsigned int VImageDimension>
class ITK_TEMPLATE_EXPORT LabelObject : public LightObject
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(LabelObject);

  using Self = LabelObject;
  using Superclass = LightObject;
  using LabelObjectType = Self;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
  using ConstWeakPointer = WeakPointer<const Self>;

  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(LabelObject);
 
  static constexpr unsigned int ImageDimension = VImageDimension;
 
  using IndexType = Index<VImageDimension>;
  using OffsetType = Offset<VImageDimension>;
  using LabelType = TLabel;
  using LineType = LabelObjectLine<VImageDimension>;
  using LengthType = typename LineType::LengthType;
  using AttributeType = unsigned int;
  using SizeValueType = itk::SizeValueType;
 
  static constexpr AttributeType LABEL = 0;
 
  static AttributeType
  GetAttributeFromName(const std::string & s);
 
  static std::string
  GetNameFromAttribute(const AttributeType & a);

  const LabelType &
  GetLabel() const;
 
  void
  SetLabel(const LabelType & label);

  bool
  HasIndex(const IndexType & idx) const;

  void
  AddIndex(const IndexType & idx);

  bool
  RemoveIndex(const IndexType & idx);

  void
  AddLine(const IndexType & idx, const LengthType & length);

  void
  AddLine(const LineType & line);
 
  SizeValueType
  GetNumberOfLines() const;
 
  const LineType &
  GetLine(SizeValueType i) const;
 
  LineType &
  GetLine(SizeValueType i);

  SizeValueType
  Size() const;

  bool
  Empty() const;
 
  void
  Clear();

  IndexType
  GetIndex(SizeValueType offset) const;

  template <typename TSourceLabelObject>
  void
  CopyLinesFrom(const TSourceLabelObject * src);

  template <typename TSourceLabelObject>
  void
  CopyAttributesFrom(const TSourceLabelObject * src);

  template <typename TSourceLabelObject>
  void
  CopyAllFrom(const TSourceLabelObject * src);

  void
  Optimize();

  void
  Shift(OffsetType offset);

  class ConstLineIterator
  {
  public:
    ConstLineIterator() = default;
 
    ConstLineIterator(const Self * lo)
      : m_Begin(lo->m_LineContainer.begin())
      , m_End(lo->m_LineContainer.end())
    {
      m_Iterator = m_Begin;
    }
 
    ConstLineIterator(const ConstLineIterator & iter)
      : m_Iterator(iter.m_Iterator)
      , m_Begin(iter.m_Begin)
      , m_End(iter.m_End)
    {}
 
    ConstLineIterator &
    operator=(const ConstLineIterator & iter) = default;
 
    [[nodiscard]] const LineType &
    GetLine() const
    {
      return *m_Iterator;
    }
 
    ConstLineIterator
    operator++(int)
    {
      const ConstLineIterator tmp = *this;
      ++(*this);
      return tmp;
    }
 
    ConstLineIterator &
    operator++()
    {
      ++m_Iterator;
      return *this;
    }
 
    bool
    operator==(const ConstLineIterator & iter) const
    {
      return m_Iterator == iter.m_Iterator && m_Begin == iter.m_Begin && m_End == iter.m_End;
    }
 
    ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(ConstLineIterator);
 
    void
    GoToBegin()
    {
      m_Iterator = m_Begin;
    }
 
    [[nodiscard]] bool
    IsAtEnd() const
    {
      return m_Iterator == m_End;
    }
 
  private:
    using LineContainerType = typename std::deque<LineType>;
    using InternalIteratorType = typename LineContainerType::const_iterator;
    InternalIteratorType m_Iterator;
    InternalIteratorType m_Begin;
    InternalIteratorType m_End;
  };

  class ConstIndexIterator
  {
  public:
    ConstIndexIterator()
      : m_Iterator()
      , m_Begin()
      , m_End()
    {
      m_Index.Fill(0);
    }
 
    ConstIndexIterator(const Self * lo)
      : m_Begin(lo->m_LineContainer.begin())
      , m_End(lo->m_LineContainer.end())
    {
      GoToBegin();
    }
 
    ConstIndexIterator(const ConstIndexIterator & iter)
      : m_Iterator(iter.m_Iterator)
      , m_Begin(iter.m_Begin)
      , m_End(iter.m_End)
      , m_Index(iter.m_Index)
    {}
 
    ConstIndexIterator &
    operator=(const ConstIndexIterator & iter) = default;
 
    [[nodiscard]] const IndexType &
    GetIndex() const
    {
      return m_Index;
    }
 
    ConstIndexIterator &
    operator++()
    {
      m_Index[0]++;
      if (m_Index[0] >= m_Iterator->GetIndex()[0] + (OffsetValueType)m_Iterator->GetLength())
      {
        // we've reached the end of the line - go to the next one
        ++m_Iterator;
        NextValidLine();
      }
      return *this;
    }
 
    ConstIndexIterator
    operator++(int)
    {
      ConstIndexIterator tmp = *this;
      ++(*this);
      return tmp;
    }
 
    bool
    operator==(const ConstIndexIterator & iter) const
    {
      return m_Index == iter.m_Index && m_Iterator == iter.m_Iterator && m_Begin == iter.m_Begin && m_End == iter.m_End;
    }
 
    ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(ConstIndexIterator);
 
    void
    GoToBegin()
    {
      m_Iterator = m_Begin;
      m_Index.Fill(0);
      NextValidLine();
    }
 
    [[nodiscard]] bool
    IsAtEnd() const
    {
      return m_Iterator == m_End;
    }
 
  private:
    using LineContainerType = typename std::deque<LineType>;
    using InternalIteratorType = typename LineContainerType::const_iterator;
    void
    NextValidLine()
    {
      // search for the next valid position
      while (m_Iterator != m_End && m_Iterator->GetLength() == 0)
      {
        ++m_Iterator;
      }
      if (m_Iterator != m_End)
      {
        m_Index = m_Iterator->GetIndex();
      }
    }
 
    InternalIteratorType m_Iterator;
    InternalIteratorType m_Begin;
    InternalIteratorType m_End;
    IndexType            m_Index;
  };
 
protected:
  LabelObject();
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
private:
  using LineContainerType = typename std::deque<LineType>;
 
  LineContainerType m_LineContainer{};
  LabelType         m_Label{};
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkLabelObject.hxx"
#endif
 
#endif