itkImageRegion.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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;
  typedef IndexValueType  IndexValueArrayType[ImageDimension];
  typedef OffsetValueType OffsetTableType[ImageDimension+1];

  using SizeType = Size< Self::ImageDimension >;
  using SizeValueType = typename SizeType::SizeValueType;

  using SliceRegion = ImageRegion< Self::SliceDimension >;

  typename Superclass::RegionType GetRegionType() const override
  { return Superclass::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