itkShapedNeighborhoodIterator.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 itkShapedNeighborhoodIterator_h
#define itkShapedNeighborhoodIterator_h
 
#include <vector>
#include <list>
#include <type_traits> // For add_const_t.
#include "itkConstShapedNeighborhoodIterator.h"
 
namespace itk
{
template <typename TImage, typename TBoundaryCondition = ZeroFluxNeumannBoundaryCondition<TImage>>
class ITK_TEMPLATE_EXPORT ShapedNeighborhoodIterator
  : public ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition>
{
public:
  using InternalPixelType = typename TImage::InternalPixelType;
  using PixelType = typename TImage::PixelType;

  static constexpr unsigned int Dimension = TImage::ImageDimension;

  using Self = ShapedNeighborhoodIterator;
  using Superclass = ConstShapedNeighborhoodIterator<TImage, TBoundaryCondition>;

  using typename Superclass::OffsetType;
  using OffsetValueType = typename OffsetType::OffsetValueType;
  using typename Superclass::RadiusType;
  using typename Superclass::SizeType;
  using typename Superclass::SizeValueType;
  using typename Superclass::ConstIterator;
  using typename Superclass::IndexListType;
  using typename Superclass::BoundaryConditionType;
  using typename Superclass::ImageBoundaryConditionPointerType;
  using typename Superclass::NeighborhoodType;
  using typename Superclass::IndexType;
  using typename Superclass::ImageType;
  using typename Superclass::RegionType;
  using typename Superclass::IndexValueType;

  struct Iterator : public Superclass::ConstIterator
  {
    Iterator() = default;
    Iterator(Self * s)
      : ConstIterator(s)
    {}
 
    ~Iterator() = default;
    Iterator &
    operator=(const Iterator & o)
    {
      ConstIterator::operator=(o);
      return *this;
    }
 
    // Promote to public
    void
    Set(const PixelType & v) const
    {
      ConstIterator::ProtectedSet(v);
    }
 
  protected:
    friend Self;
 
    Iterator(const Self * s, const typename IndexListType::const_iterator & li)
      : ConstIterator(s, li)
    {}
  };

  ShapedNeighborhoodIterator() = default;

  ~ShapedNeighborhoodIterator() override = default;

  ShapedNeighborhoodIterator(const ShapedNeighborhoodIterator & o) = delete;

  ShapedNeighborhoodIterator(const SizeType & radius, ImageType * ptr, const RegionType & region)
    : Superclass(radius, ptr, region)
  {}
 
#ifndef ITK_FUTURE_LEGACY_REMOVE
  ITK_FUTURE_DEPRECATED(
    "This constructor is intended to be removed. For a `const` image, use ConstShapedNeighborhoodIterator instead!")
  ShapedNeighborhoodIterator(const SizeType & radius, std::add_const_t<ImageType> * ptr, const RegionType & region)
    : Superclass(radius, ptr, region)
  {
    // Note: parameter type `std::add_const_t<ImageType> *` prevents accidental class template argument deduction
    // (CTAD).
  }
#endif
 
  // Expose the following methods from the superclass.  This is a restricted
  // subset of the methods available for NeighborhoodIterator.
  using Superclass::SetPixel;
  using Superclass::SetCenterPixel;
 

  Self &
  operator=(const Self & orig)
  {
    Superclass::operator=(orig);
    return *this;
  }

  Iterator
  Begin()
  {
    return Iterator(this, this->m_ActiveIndexList.begin());
  }
  Iterator
  End()
  {
    return Iterator(this, this->m_ActiveIndexList.end());
  }

 
  using Superclass::Begin;
  using Superclass::End;
 
protected:
  friend Superclass;
 
  using typename Superclass::NeighborIndexType;
};
} // namespace itk
 
#endif