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
 *
 *         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.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  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() ITK_NOEXCEPT = default;
 
  ~ImageRegion() override = default;
 
  ImageRegion(const Self &) ITK_NOEXCEPT = default;
 
  ImageRegion(const IndexType & index, const SizeType & size) ITK_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) ITK_NOEXCEPT : m_Size(size)
  {
    // Note: m_Index is initialized by its C++11 default member initializer.
  }
 
  Self &
  operator=(const Self &) ITK_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 ITK_NOEXCEPT
  {
    return (m_Index == region.m_Index) && (m_Size == region.m_Size);
  }
 
  bool
  operator!=(const Self & region) const ITK_NOEXCEPT
  {
    return !(*this == region);
  }
 
  bool
  IsInside(const IndexType & index) const
  {
    for (unsigned int i = 0; i < ImageDimension; i++)
    {
      if (index[i] < m_Index[i])
      {
        return false;
      }
      if (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
  {
    for (unsigned int i = 0; i < ImageDimension; i++)
    {
      if (Math::RoundHalfIntegerUp<IndexValueType>(index[i]) < static_cast<IndexValueType>(m_Index[i]))
      {
        return false;
      }
      // bound is the last valid pixel location
      const auto bound = static_cast<TCoordRepType>(m_Index[i] + m_Size[i] - 0.5);
 
      /* Note for NaN: test using negation of a positive test in order
       * to always evaluate to true (and thus return false) when index[i]
       * is NaN. The cast above to integer via RoundHalfIntegerUp will cast
       * NaN into a platform-dependent value (large negative, -1 or large
       * positive, empirically). Thus this test here is relied on
       * to 'catch' NaN's. */
      if (!(index[i] <= bound))
      {
        return false;
      }
    }
    return true;
  }
 
  bool
  IsInside(const Self & region) const
  {
    IndexType beginCorner = region.GetIndex();
 
    if (!this->IsInside(beginCorner))
    {
      return false;
    }
    IndexType        endCorner;
    const SizeType & size = region.GetSize();
    for (unsigned int i = 0; i < ImageDimension; i++)
    {
      endCorner[i] = beginCorner[i] + static_cast<OffsetValueType>(size[i]) - 1;
    }
    if (!this->IsInside(endCorner))
    {
      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