itkImageRegion.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.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef itkImageRegion_h
#define itkImageRegion_h
 
#include "itkRegion.h"
 
#include "itkSize.h"
#include "itkContinuousIndex.h"
#include "itkMath.h"
#include <type_traits> // For conditional and integral_constant.
#include <utility>     // For tuple_element and tuple_size.
 
// Macro added to each `ImageRegion` member function that overrides a virtual member function of `Region`, when legacy
// support is enabled. Without legacy support, `ImageRegion` will no longer inherit from `Region`, so then those
// `ImageRegion` member functions will no longer override.
#ifdef ITK_LEGACY_REMOVE
#  define itkRegionOverrideMacro // nothing
#else
#  define itkRegionOverrideMacro override
#endif
 
namespace itk
{
// Forward declaration of ImageBase so it can be declared a friend
// (needed for PrintSelf mechanism)
template <unsigned int VImageDimension>
class ITK_TEMPLATE_EXPORT ImageBase;

template <unsigned int VImageDimension>
class ITK_TEMPLATE_EXPORT ImageRegion final
#ifndef ITK_LEGACY_REMOVE
  // This inheritance is only there when legacy support is enabled.
  : public Region
#endif
{
public:
  using Self = ImageRegion;
 
#ifndef ITK_LEGACY_REMOVE
  using Superclass = Region;
#endif

  const char *
  GetNameOfClass() const itkRegionOverrideMacro
  {
    return "ImageRegion";
  }

  static constexpr unsigned int ImageDimension = VImageDimension;

  static constexpr unsigned int SliceDimension = ImageDimension - (ImageDimension > 1);

  static constexpr unsigned int
  GetImageDimension()
  {
    return ImageDimension;
  }

  using IndexType = Index<VImageDimension>;
  using IndexValueType = typename IndexType::IndexValueType;
  using OffsetType = typename IndexType::OffsetType;
  using OffsetValueType = typename OffsetType::OffsetValueType;
  using IndexValueArrayType = IndexValueType[ImageDimension];
  using OffsetTableType = OffsetValueType[ImageDimension + 1];

  using SizeType = Size<VImageDimension>;
  using SizeValueType = typename SizeType::SizeValueType;

  using SliceRegion = ImageRegion<Self::SliceDimension>;

  Region::RegionEnum
  GetRegionType() const itkRegionOverrideMacro
  {
    return Region::RegionEnum::ITK_STRUCTURED_REGION;
  }

  void
  Print(std::ostream & os, Indent indent = 0) const itkRegionOverrideMacro;

  ImageRegion() noexcept = default;

  ~ImageRegion() itkRegionOverrideMacro = default;

  ImageRegion(const Self &) noexcept = default;

  ImageRegion(const IndexType & index, const SizeType & size) noexcept
    : // Note: Use parentheses instead of curly braces to initialize data members,
      // to avoid AppleClang 6.0.0.6000056 compile errors, "no viable conversion..."
    m_Index(index)
    , m_Size(size)
  {}

  ImageRegion(const SizeType & size) noexcept
    : m_Size(size)
  {
    // Note: m_Index is initialized by its C++11 default member initializer.
  }

  Self &
  operator=(const Self &) noexcept = default;

  void
  SetIndex(const IndexType & index)
  {
    m_Index = index;
  }

  const IndexType &
  GetIndex() const
  {
    return m_Index;
  }
  IndexType &
  GetModifiableIndex()
  {
    return m_Index;
  }


  void
  SetSize(const SizeType & size)
  {
    m_Size = size;
  }

  const SizeType &
  GetSize() const
  {
    return m_Size;
  }
  SizeType &
  GetModifiableSize()
  {
    return m_Size;
  }


  void
  SetSize(unsigned int i, SizeValueType sze)
  {
    m_Size[i] = sze;
  }
  SizeValueType
  GetSize(unsigned int i) const
  {
    return m_Size[i];
  }


  void
  SetIndex(unsigned int i, IndexValueType sze)
  {
    m_Index[i] = sze;
  }
  IndexValueType
  GetIndex(unsigned int i) const
  {
    return m_Index[i];
  }


  IndexType
  GetUpperIndex() const;

  void
  SetUpperIndex(const IndexType & idx);

  void
  ComputeOffsetTable(OffsetTableType offsetTable) const;

  bool
  operator==(const Self & region) const noexcept
  {
    return (m_Index == region.m_Index) && (m_Size == region.m_Size);
  }
 
  ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(Self);

  bool
  IsInside(const IndexType & index) const
  {
    for (unsigned int i = 0; i < ImageDimension; ++i)
    {
      if (index[i] < m_Index[i] || index[i] >= m_Index[i] + static_cast<IndexValueType>(m_Size[i]))
      {
        return false;
      }
    }
    return true;
  }


  template <typename TCoordinate>
  bool
  IsInside(const ContinuousIndex<TCoordinate, VImageDimension> & index) const
  {
    constexpr TCoordinate half = 0.5;
    for (unsigned int i = 0; i < ImageDimension; ++i)
    {
      // Use negation of tests so that index[i]==NaN leads to returning false.
      if (!(index[i] >= m_Index[i] - half && index[i] <= (m_Index[i] + static_cast<IndexValueType>(m_Size[i])) - half))
      {
        return false;
      }
    }
    return true;
  }


  bool
  IsInside(const Self & otherRegion) const
  {
    const auto & otherIndex = otherRegion.m_Index;
    const auto & otherSize = otherRegion.m_Size;
 
    for (unsigned int i = 0; i < ImageDimension; ++i)
    {
      if (otherIndex[i] < m_Index[i] || otherSize[i] == 0 ||
          otherIndex[i] + static_cast<IndexValueType>(otherSize[i]) >
            m_Index[i] + static_cast<IndexValueType>(m_Size[i]))
      {
        return false;
      }
    }
    return true;
  }

  SizeValueType
  GetNumberOfPixels() const;

  void
  PadByRadius(OffsetValueType radius);
 
  void
  PadByRadius(const IndexValueArrayType radius);
 
  void
  PadByRadius(const SizeType & radius);

  bool
  ShrinkByRadius(OffsetValueType radius);
 
  bool
  ShrinkByRadius(const IndexValueArrayType radius);
 
  bool
  ShrinkByRadius(const SizeType & radius);

  bool
  Crop(const Self & region);

  SliceRegion
  Slice(const unsigned int dim) const;

  template <size_t VTupleIndex>
  [[nodiscard]] auto &
  get()
  {
    if constexpr (VTupleIndex == 0)
    {
      return m_Index;
    }
    else
    {
      static_assert(VTupleIndex == 1);
      return m_Size;
    }
  }


  template <size_t VTupleIndex>
  [[nodiscard]] const auto &
  get() const
  {
    if constexpr (VTupleIndex == 0)
    {
      return m_Index;
    }
    else
    {
      static_assert(VTupleIndex == 1);
      return m_Size;
    }
  }

 
protected:
  void
  PrintSelf(std::ostream & os, Indent indent) const itkRegionOverrideMacro;
 
private:
  IndexType m_Index = { { 0 } };
  SizeType  m_Size = { { 0 } };

  friend class ImageBase<VImageDimension>;
};
 
 
// Deduction guide to avoid compiler warnings (-wctad-maybe-unsupported) when using class template argument deduction.
template <unsigned int VImageDimension>
ImageRegion(const Index<VImageDimension> &, const Size<VImageDimension> &) -> ImageRegion<VImageDimension>;
 
 
template <unsigned int VImageDimension>
std::ostream &
operator<<(std::ostream & os, const ImageRegion<VImageDimension> & region);
} // end namespace itk
 
 
namespace std
{
#if defined(__clang__) && defined(__apple_build_version__) && (__clang_major__ <= 10)
#  pragma clang diagnostic push
// Old AppleClang 10.0.0 (Xcode 10.1, newest on macOS 10.13) produced some unimportant warnings, like:
// "warning: 'tuple_size' defined as a struct template here but previously declared as a class template"
#  pragma clang diagnostic ignored "-Wmismatched-tags"
#endif
 
// NOLINTBEGIN(cert-dcl58-cpp)
// Locally suppressed the following warning from Clang-Tidy (LLVM 17.0.1), as it appears undeserved.
// > warning: modification of 'std' namespace can result in undefined behavior [cert-dcl58-cpp]

template <unsigned int VImageDimension>
struct tuple_size<itk::ImageRegion<VImageDimension>> : integral_constant<size_t, 2>
{};

template <size_t VTupleIndex, unsigned int VImageDimension>
struct tuple_element<VTupleIndex, itk::ImageRegion<VImageDimension>>
  : conditional<VTupleIndex == 0, itk::Index<VImageDimension>, itk::Size<VImageDimension>>
{
  static_assert(VTupleIndex < tuple_size_v<itk::ImageRegion<VImageDimension>>);
};
 
// NOLINTEND(cert-dcl58-cpp)
 
#if defined(__clang__) && defined(__apple_build_version__) && (__clang_major__ <= 10)
#  pragma clang diagnostic pop
#endif
} // namespace std
 
#undef itkRegionOverrideMacro
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkImageRegion.hxx"
#endif
 
#endif