itkConstNeighborhoodIteratorWithOnlyIndex.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 itkConstNeighborhoodIteratorWithOnlyIndex_h
#define itkConstNeighborhoodIteratorWithOnlyIndex_h

#include <vector>
#include <cstring>
#include <iostream>
#include "itkImage.h"
#include "itkNeighborhood.h"
#include "itkMacro.h"

namespace itk
{
template< typename TImage >
class ITK_TEMPLATE_EXPORT ConstNeighborhoodIteratorWithOnlyIndex:
  public Neighborhood< char, TImage::ImageDimension >
{
public:

  using DimensionValueType = unsigned int;

  static constexpr DimensionValueType Dimension = TImage::ImageDimension;

  using DummyNeighborhoodPixelType = char;

  using Self = ConstNeighborhoodIteratorWithOnlyIndex;
  using Superclass = Neighborhood< DummyNeighborhoodPixelType, Self::Dimension >;

  using OffsetType = typename Superclass::OffsetType;
  using RadiusType = typename Superclass::RadiusType;
  using SizeType = typename Superclass::SizeType;
  using Iterator = typename Superclass::Iterator;
  using ConstIterator = typename Superclass::ConstIterator;

  using ImageType = TImage;
  using RegionType = typename TImage::RegionType;
  using IndexType = Index< Self::Dimension >;
  using NeighborhoodType = Neighborhood< DummyNeighborhoodPixelType, Self::Dimension >;

  using NeighborIndexType = typename NeighborhoodType::NeighborIndexType;

  ConstNeighborhoodIteratorWithOnlyIndex();

  ~ConstNeighborhoodIteratorWithOnlyIndex() override = default;

  ConstNeighborhoodIteratorWithOnlyIndex(const ConstNeighborhoodIteratorWithOnlyIndex &);

  ConstNeighborhoodIteratorWithOnlyIndex(const SizeType & radius, const ImageType *ptr, const RegionType & region);

  Self & operator=(const Self & orig);

  void PrintSelf(std::ostream &, Indent) const override;

  OffsetType ComputeInternalIndex(NeighborIndexType n) const;

  IndexType GetBound() const
  {
    return m_Bound;
  }

  IndexValueType GetBound(NeighborIndexType n) const
  {
    return m_Bound[n];
  }

  const ImageType * GetImagePointer() const
  {
    return m_ConstImage;
  }

  ITK_ITERATOR_VIRTUAL IndexType GetIndex() const ITK_ITERATOR_FINAL
  {
    return m_Loop;
  }

  ITK_ITERATOR_VIRTUAL IndexType GetIndex(const OffsetType & o) const ITK_ITERATOR_FINAL
  {
    return ( this->GetIndex() + o );
  }

  ITK_ITERATOR_VIRTUAL IndexType GetIndex(NeighborIndexType i) const ITK_ITERATOR_FINAL
  {
    return ( this->GetIndex() + this->GetOffset(i) );
  }

  RegionType GetRegion() const
  {
    return m_Region;
  }

  IndexType GetBeginIndex() const
  {
    return m_BeginIndex;
  }

  RegionType GetBoundingBoxAsImageRegion() const;

  ITK_ITERATOR_VIRTUAL void GoToBegin() ITK_ITERATOR_FINAL;

  ITK_ITERATOR_VIRTUAL void GoToEnd() ITK_ITERATOR_FINAL;

  ITK_ITERATOR_VIRTUAL void Initialize(const SizeType & radius, const ImageType *ptr, const RegionType & region) ITK_ITERATOR_FINAL;

  ITK_ITERATOR_VIRTUAL bool IsAtBegin() const ITK_ITERATOR_FINAL
  {
    return ( this->GetIndex() == m_BeginIndex );
  }

  ITK_ITERATOR_VIRTUAL bool IsAtEnd() const ITK_ITERATOR_FINAL;

  Self & operator++();

  Self & operator--();

  bool operator==(const Self & it) const
  {
    return it.GetIndex() == this->GetIndex();
  }

  bool operator!=(const Self & it) const
  {
    return it.GetIndex() != this->GetIndex();
  }

  bool operator<(const Self & it) const;

  bool operator<=(const Self & it) const;

  bool operator>(const Self & it) const;

  bool operator>=(const Self & it) const;

  void SetLocation(const IndexType & position)
  {
    this->SetLoop(position);
  }

  Self & operator+=(const OffsetType &);

  Self & operator-=(const OffsetType &);

  OffsetType operator-(const Self & b)
  {
    return m_Loop - b.m_Loop;
  }

  bool InBounds() const;

  bool IndexInBounds(const NeighborIndexType n, OffsetType & internalIndex, OffsetType & offset ) const;

  void NeedToUseBoundaryConditionOn()
  {
    this->SetNeedToUseBoundaryCondition(true);
  }

  void NeedToUseBoundaryConditionOff()
  {
    this->SetNeedToUseBoundaryCondition(false);
  }

  void SetNeedToUseBoundaryCondition(bool b)
  {
    m_NeedToUseBoundaryCondition = b;
  }

  bool GetNeedToUseBoundaryCondition() const
  {
    return m_NeedToUseBoundaryCondition;
  }

protected:

  ITK_ITERATOR_VIRTUAL void SetLoop(const IndexType & p) ITK_ITERATOR_FINAL
  {
    m_Loop = p; m_IsInBoundsValid = false;
  }

  ITK_ITERATOR_VIRTUAL void SetBound(const SizeType &) ITK_ITERATOR_FINAL;

  ITK_ITERATOR_VIRTUAL void SetBeginIndex(const IndexType & start) ITK_ITERATOR_FINAL
  {
    m_BeginIndex = start;
  }

  ITK_ITERATOR_VIRTUAL void SetEndIndex() ITK_ITERATOR_FINAL;

  IndexType m_BeginIndex;

  IndexType m_Bound;

  typename ImageType::ConstPointer m_ConstImage;

  IndexType m_EndIndex;

  IndexType m_Loop;

  RegionType m_Region;

  mutable bool m_InBounds[Dimension];

  mutable bool m_IsInBounds;

  mutable bool m_IsInBoundsValid;

  IndexType m_InnerBoundsLow;

  IndexType m_InnerBoundsHigh;

  bool m_NeedToUseBoundaryCondition;
};

template< typename TImage >
inline ConstNeighborhoodIteratorWithOnlyIndex< TImage >
operator+(const ConstNeighborhoodIteratorWithOnlyIndex< TImage > & it,
          const typename ConstNeighborhoodIteratorWithOnlyIndex< TImage >
          ::OffsetType & ind)
{
  ConstNeighborhoodIteratorWithOnlyIndex< TImage > ret;
  ret = it;
  ret += ind;
  return ret;
}

template< typename TImage >
inline ConstNeighborhoodIteratorWithOnlyIndex< TImage >
operator+(const typename ConstNeighborhoodIteratorWithOnlyIndex< TImage >
          ::OffsetType & ind,
          const ConstNeighborhoodIteratorWithOnlyIndex< TImage > & it)
{  return ( it + ind ); }

template< typename TImage >
inline ConstNeighborhoodIteratorWithOnlyIndex< TImage >
operator-(const ConstNeighborhoodIteratorWithOnlyIndex< TImage > & it,
          const typename ConstNeighborhoodIteratorWithOnlyIndex< TImage >
          ::OffsetType & ind)
{
  ConstNeighborhoodIteratorWithOnlyIndex< TImage > ret;
  ret = it;
  ret -= ind;
  return ret;
}
} // namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkConstNeighborhoodIteratorWithOnlyIndex.hxx"
#endif

#endif