itkConstNeighborhoodIteratorWithOnlyIndex.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 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:
  ITK_DEFAULT_COPY_AND_MOVE(ConstNeighborhoodIteratorWithOnlyIndex);
 
  using DimensionValueType = unsigned int;
 
  static constexpr DimensionValueType Dimension = TImage::ImageDimension;
 
  using DummyNeighborhoodPixelType = char;
 
  using Self = ConstNeighborhoodIteratorWithOnlyIndex;
  using Superclass = Neighborhood<DummyNeighborhoodPixelType, Self::Dimension>;
 
  using typename Superclass::OffsetType;
  using typename Superclass::RadiusType;
  using typename Superclass::SizeType;
  using typename Superclass::Iterator;
  using 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() = default;
 
  ~ConstNeighborhoodIteratorWithOnlyIndex() override = default;
 
  ConstNeighborhoodIteratorWithOnlyIndex(const SizeType & radius, const ImageType * ptr, const RegionType & region);
 
  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;
  }
 
  IndexType
  GetIndex() const
  {
    return m_Loop;
  }
 
  IndexType
  GetIndex(const OffsetType & o) const
  {
    return (this->GetIndex() + o);
  }
 
  IndexType
  GetIndex(NeighborIndexType i) const
  {
    return (this->GetIndex() + this->GetOffset(i));
  }
 
  RegionType
  GetRegion() const
  {
    return m_Region;
  }
 
  IndexType
  GetBeginIndex() const
  {
    return m_BeginIndex;
  }
 
  RegionType
  GetBoundingBoxAsImageRegion() const;
 
  void
  GoToBegin();
 
  void
  GoToEnd();
 
  void
  Initialize(const SizeType & radius, const ImageType * ptr, const RegionType & region);
 
  bool
  IsAtBegin() const
  {
    return (this->GetIndex() == m_BeginIndex);
  }
 
  bool
  IsAtEnd() const;
 
  Self &
  operator++();
 
  Self &
  operator--();
 
  bool
  operator==(const Self & it) const
  {
    return it.GetIndex() == this->GetIndex();
  }
 
  ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(Self);
 
  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) const
  {
    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:
  void
  SetLoop(const IndexType & p)
  {
    m_Loop = p;
    m_IsInBoundsValid = false;
  }
 
  void
  SetBound(const SizeType &);
 
  void
  SetBeginIndex(const IndexType & start)
  {
    m_BeginIndex = start;
  }
 
  void
  SetEndIndex();
 
  IndexType m_BeginIndex{ { 0 } };
 
  IndexType m_Bound{ { 0 } };
 
  typename ImageType::ConstPointer m_ConstImage{};
 
  IndexType m_EndIndex{ { 0 } };
 
  IndexType m_Loop{ { 0 } };
 
  RegionType m_Region{};
 
  mutable bool m_InBounds[Dimension]{ false };
 
  mutable bool m_IsInBounds{ false };
 
  mutable bool m_IsInBoundsValid{ false };
 
  IndexType m_InnerBoundsLow{};
 
  IndexType m_InnerBoundsHigh{};
 
  bool m_NeedToUseBoundaryCondition{ false };
};
 
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