itkImageRegion.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImageRegion.h,v $
  Language:  C++
  Date:      $Date: 2006-04-20 14:54:09 $
  Version:   $Revision: 1.28 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkImageRegion_h
#define __itkImageRegion_h

#include "itkRegion.h"

#include "itkIndex.h"
#include "itkSize.h"
#include "itkContinuousIndex.h"

namespace itk
{
// Forward declaration of ImageBase so it can be declared a friend
// (needed for PrintSelf mechanism)  
template <unsigned int VImageDimension> class ImageBase;

  
template <unsigned int VImageDimension>
class ITK_EXPORT ImageRegion: public Region
{
public:
  typedef ImageRegion              Self;
  typedef Region  Superclass;

  itkTypeMacro(ImageRegion, Region);

  itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension);

  itkStaticConstMacro(SliceDimension, unsigned int,
                      (VImageDimension - (VImageDimension > 1)));

  static unsigned int GetImageDimension() 
    { return VImageDimension; }

  typedef Index<VImageDimension>  IndexType;
  typedef typename IndexType::IndexValueType IndexValueType;

  typedef Size<VImageDimension>  SizeType;
  typedef typename SizeType::SizeValueType SizeValueType;

  typedef ImageRegion<itkGetStaticConstMacro(SliceDimension)> SliceRegion;

  virtual typename Superclass::RegionType GetRegionType() const
    {return Superclass::ITK_STRUCTURED_REGION;}

  ImageRegion();

  virtual ~ImageRegion();

  ImageRegion(const Self& region): Region(region), m_Index( region.m_Index ), m_Size( region.m_Size ) {}

  ImageRegion(const IndexType &index, const SizeType &size)
    { m_Index = index; m_Size = size; };

  ImageRegion(const SizeType &size)
    { m_Size = size; m_Index.Fill(0); } ;

  void operator=(const Self& region) 
    { m_Index = region.m_Index;  m_Size = region.m_Size; };

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

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

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

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

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

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

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

  bool
  operator!=(const Self &region) const
    {
      bool same = 1;
      same = (m_Index == region.m_Index);
      same = same && (m_Size == region.m_Size);
      return !same;
    }

  
  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<long>(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( index[i] < static_cast<TCoordRepType>( m_Index[i] ) ) 
          {
          return false;
          }
        // bound is the last valid pixel location
        const TCoordRepType bound = static_cast<TCoordRepType>(
                              m_Index[i] + static_cast<long>(m_Size[i]) - 1);

        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;
      SizeType  size = region.GetSize();
      for(unsigned int i=0; i<ImageDimension; i++) 
        {
        endCorner[i] = beginCorner[i] + size[i] - 1;
        }
      if( ! this->IsInside( endCorner ) )
        {
        return false;
        }
      return true;
    }

  unsigned long GetNumberOfPixels() const;

  void PadByRadius(unsigned long radius);
  void PadByRadius(const unsigned long radius[VImageDimension]);
  void PadByRadius(const SizeType &radius);

  bool Crop(const Self& region);

  SliceRegion Slice(const unsigned long dim) const;

protected:
  virtual void PrintSelf(std::ostream& os, Indent indent) const;

private:
  IndexType           m_Index;
  SizeType            m_Size;

  friend class ImageBase<VImageDimension>;
};


template<unsigned int VImageDimension>
std::ostream & operator<<(std::ostream &os, const ImageRegion<VImageDimension> &region);

} // end namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_ImageRegion(_, EXPORT, x, y) namespace itk { \
  _(1(class EXPORT ImageRegion< ITK_TEMPLATE_1 x >)) \
  _(1(EXPORT std::ostream& operator<<(std::ostream&, \
                                      const ImageRegion< ITK_TEMPLATE_1 x >&))) \
  namespace Templates { typedef ImageRegion< ITK_TEMPLATE_1 x > ImageRegion##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkImageRegion+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkImageRegion.txx"
#endif

#endif

---