itkLabelMap.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
 *
 *         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 itkLabelMap_h
#define itkLabelMap_h
 
#include "itkImageBase.h"
#include "itkWeakPointer.h"
#include <map>
 
namespace itk
{
template <typename TLabelObject>
class ITK_TEMPLATE_EXPORT LabelMap : public ImageBase<TLabelObject::ImageDimension>
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(LabelMap);
 
  using Self = LabelMap;
  using Superclass = ImageBase<TLabelObject::ImageDimension>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
  using ConstWeakPointer = WeakPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(LabelMap, ImageBase);
 
  using LabelObjectType = TLabelObject;
 
  using LabelObjectPointerType = typename LabelObjectType::Pointer;
 
  using SizeValueType = typename Superclass::SizeValueType;
  using LengthType = SizeValueType;
 
  static constexpr unsigned int ImageDimension = LabelObjectType::ImageDimension;
 
  using LabelType = typename LabelObjectType::LabelType;
  using PixelType = LabelType;
 
  using LabelVectorType = std::vector<LabelType>;
  using LabelObjectVectorType = std::vector<LabelObjectPointerType>;
 
  using IndexType = typename Superclass::IndexType;
 
  using OffsetType = typename Superclass::OffsetType;
 
  using SizeType = typename Superclass::SizeType;
 
  using DirectionType = typename Superclass::DirectionType;
 
  using RegionType = typename Superclass::RegionType;
 
  using SpacingType = typename Superclass::SpacingType;
 
  using PointType = typename Superclass::PointType;
 
  using OffsetValueType = typename Superclass::OffsetValueType;
 
  void
  Initialize() override;
 
  void
  Allocate(bool initialize = false) override;
 
  virtual void
  Graft(const Self * imgData);
 
  LabelObjectType *
  GetLabelObject(const LabelType & label);
  const LabelObjectType *
  GetLabelObject(const LabelType & label) const;
 
  bool
  HasLabel(const LabelType label) const;
 
  LabelObjectType *
  GetNthLabelObject(const SizeValueType & pos);
  const LabelObjectType *
  GetNthLabelObject(const SizeValueType & pos) const;
 
  const LabelType &
  GetPixel(const IndexType & idx) const;
 
  void
  SetPixel(const IndexType & idx, const LabelType & label);
 
  void
  AddPixel(const IndexType & idx, const LabelType & label);
 
  void
  RemovePixel(const IndexType & idx, const LabelType & label);
 
  void
  SetLine(const IndexType & idx, const LengthType & length, const LabelType & label);
 
  LabelObjectType *
  GetLabelObject(const IndexType & idx) const;
 
  void
  AddLabelObject(LabelObjectType * labelObject);
 
  void
  PushLabelObject(LabelObjectType * labelObject);
 
  void
  RemoveLabelObject(LabelObjectType * labelObject);
 
  void
  RemoveLabel(const LabelType & label);
 
  void
  ClearLabels();
 
  typename Self::SizeValueType
  GetNumberOfLabelObjects() const;
 
  LabelVectorType
  GetLabels() const;
 
  LabelObjectVectorType
  GetLabelObjects() const;
 
  itkGetConstMacro(BackgroundValue, LabelType);
  itkSetMacro(BackgroundValue, LabelType);
 
  void
  PrintLabelObjects(std::ostream & os) const;
 
  void
  PrintLabelObjects() const
  {
    this->PrintLabelObjects(std::cerr);
  }
 
  void
  Optimize();
 
  class ConstIterator
  {
  public:
    ConstIterator() = default;
 
    ConstIterator(const Self * lm)
    {
      m_Begin = lm->m_LabelObjectContainer.begin();
      m_End = lm->m_LabelObjectContainer.end();
      m_Iterator = m_Begin;
    }
 
    ConstIterator(const ConstIterator & iter)
    {
      m_Iterator = iter.m_Iterator;
      m_Begin = iter.m_Begin;
      m_End = iter.m_End;
    }
 
    ConstIterator &
    operator=(const ConstIterator & iter)
    {
      m_Iterator = iter.m_Iterator;
      m_Begin = iter.m_Begin;
      m_End = iter.m_End;
      return *this;
    }
 
    const LabelObjectType *
    GetLabelObject() const
    {
      return m_Iterator->second;
    }
 
    const LabelType &
    GetLabel() const
    {
      return m_Iterator->first;
    }
 
    ConstIterator
    operator++(int)
    {
      ConstIterator tmp = *this;
      ++(*this);
      return tmp;
    }
 
    ConstIterator &
    operator++()
    {
      ++m_Iterator;
      return *this;
    }
 
    bool
    operator==(const ConstIterator & iter) const
    {
      return m_Iterator == iter.m_Iterator && m_Begin == iter.m_Begin && m_End == iter.m_End;
    }
 
    bool
    operator!=(const ConstIterator & iter) const
    {
      return !(*this == iter);
    }
 
    void
    GoToBegin()
    {
      m_Iterator = m_Begin;
    }
 
    bool
    IsAtEnd() const
    {
      return m_Iterator == m_End;
    }
 
  private:
    using InternalIteratorType = typename std::map<LabelType, LabelObjectPointerType>::const_iterator;
    InternalIteratorType m_Iterator;
    InternalIteratorType m_Begin;
    InternalIteratorType m_End;
  };
 
  class Iterator
  {
  public:
    Iterator() = default;
 
    Iterator(Self * lm)
    {
      m_Begin = lm->m_LabelObjectContainer.begin();
      m_End = lm->m_LabelObjectContainer.end();
      m_Iterator = m_Begin;
    }
 
    Iterator(const Iterator & iter)
    {
      m_Iterator = iter.m_Iterator;
      m_Begin = iter.m_Begin;
      m_End = iter.m_End;
    }
 
    Iterator &
    operator=(const Iterator & iter)
    {
      m_Iterator = iter.m_Iterator;
      m_Begin = iter.m_Begin;
      m_End = iter.m_End;
      return *this;
    }
 
    LabelObjectType *
    GetLabelObject()
    {
      return m_Iterator->second;
    }
 
    const LabelType &
    GetLabel() const
    {
      return m_Iterator->first;
    }
 
    Iterator
    operator++(int)
    {
      Iterator tmp = *this;
      ++(*this);
      return tmp;
    }
 
    Iterator &
    operator++()
    {
      ++m_Iterator;
      return *this;
    }
 
    bool
    operator==(const Iterator & iter) const
    {
      return m_Iterator == iter.m_Iterator && m_Begin == iter.m_Begin && m_End == iter.m_End;
    }
 
    bool
    operator!=(const Iterator & iter) const
    {
      return !(*this == iter);
    }
 
    void
    GoToBegin()
    {
      m_Iterator = m_Begin;
    }
 
    bool
    IsAtEnd() const
    {
      return m_Iterator == m_End;
    }
 
  private:
    using InternalIteratorType = typename std::map<LabelType, LabelObjectPointerType>::iterator;
    InternalIteratorType m_Iterator;
    InternalIteratorType m_Begin;
    InternalIteratorType m_End;
 
    friend class LabelMap;
  };
 
protected:
  LabelMap();
  ~LabelMap() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
  void
  Graft(const DataObject * data) override;
  using Superclass::Graft;
 
private:
  using LabelObjectContainerType = std::map<LabelType, LabelObjectPointerType>;
  using LabelObjectContainerIterator = typename LabelObjectContainerType::iterator;
  using LabelObjectContainerConstIterator = typename LabelObjectContainerType::const_iterator;
 
  LabelObjectContainerType m_LabelObjectContainer;
  LabelType                m_BackgroundValue;
 
  void
  AddPixel(const LabelObjectContainerIterator & it, const IndexType & idx, const LabelType & iLabel);
 
  void
  RemovePixel(const LabelObjectContainerIterator & it, const IndexType & idx, bool iEmitModifiedEvent);
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkLabelMap.hxx"
#endif
 
#endif