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"
 
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 : public Region
{
public:
  using Self = ImageRegion;
  using Superclass = Region;
 
  itkTypeMacro(ImageRegion, Region);
 
  static constexpr unsigned int ImageDimension = VImageDimension;
 
  static constexpr unsigned int SliceDimension = ImageDimension - (ImageDimension > 1);
 
  static unsigned int
  GetImageDimension()
  {
    return ImageDimension;
  }
 
  using IndexType = Index<Self::ImageDimension>;
  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<Self::ImageDimension>;
  using SizeValueType = typename SizeType::SizeValueType;
 
  using SliceRegion = ImageRegion<Self::SliceDimension>;
 
  Superclass::RegionEnum
  GetRegionType() const override
  {
    return Superclass::RegionEnum::ITK_STRUCTURED_REGION;
  }
 
  ImageRegion() noexcept = default;
 
  ~ImageRegion() override = 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 TCoordRepType>
  bool
  IsInside(const ContinuousIndex<TCoordRepType, VImageDimension> & index) const
  {
    constexpr TCoordRepType 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;
 
protected:
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
private:
  IndexType m_Index = { { 0 } };
  SizeType  m_Size = { { 0 } };
 
  friend class ImageBase<VImageDimension>;
};
 
template <unsigned int VImageDimension>
std::ostream &
operator<<(std::ostream & os, const ImageRegion<VImageDimension> & region);
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkImageRegion.hxx"
#endif
 
#endif