itkImageIORegion.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImageIORegion.h,v $
  Language:  C++
  Date:      $Date: 2003/02/26 20:25:53 $
  Version:   $Revision: 1.6 $

  Copyright (c) 2002 Insight Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.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 __itkImageIORegion_h
#define __itkImageIORegion_h

#include "itkRegion.h"
#include "itkObjectFactory.h"

namespace itk
{

class ITK_EXPORT ImageIORegion: public Region
{
public:
  typedef ImageIORegion              Self;
  typedef Region  Superclass;

  itkTypeMacro(ImageIORegion, Region);

  unsigned int GetImageDimension() const
    { return m_ImageDimension; }

  typedef std::vector<long>  IndexType;

  typedef std::vector<long>  SizeType;
  
  virtual Superclass::RegionType GetRegionType() const
    {return Superclass::ITK_STRUCTURED_REGION;}

  ImageIORegion(unsigned int dimension)
    {
      m_ImageDimension = dimension;
      m_Index.resize(m_ImageDimension);
      m_Size.resize(m_ImageDimension);
      std::fill(m_Index.begin(), m_Index.end(), 0);
      std::fill(m_Size.begin(), m_Size.end(), 0);
    }
  
  ImageIORegion()
    {
      m_ImageDimension = 2;
      m_Index.resize(2);
      m_Size.resize(2);
      std::fill(m_Index.begin(), m_Index.end(), 0);
      std::fill(m_Size.begin(), m_Size.end(), 0);
    }
  
  virtual ~ImageIORegion(){};

  ImageIORegion(const Self& region): Region()
    { 
      m_Index =region.m_Index; 
      m_Size = region.m_Size; 
      m_ImageDimension = region.m_ImageDimension;
    }
  
  void operator=(const Self& region) 
    { 
      m_Index = region.m_Index;  
      m_Size = region.m_Size;
      m_ImageDimension = region.m_ImageDimension;
    };

  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(const unsigned long i, long size)
    {m_Size[i] = size;}
  void SetIndex(const unsigned long i, long idx)
    {m_Index[i] = idx;}

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

  bool
  operator!=(const Self &region) const
    {
      bool same = 1;
      same = (m_Index == region.m_Index);
      same = same && (m_Size == region.m_Size);
      same = same && (m_ImageDimension == region.m_ImageDimension);
      return !same;
    }
  
  bool
  IsInside(const IndexType &index) const
    {
      for(unsigned int i=0; i<m_ImageDimension; i++)
        {
        if( index[i] < m_Index[i] ) 
          {
          return false;
          }
        if( index[i] >= m_Index[i] + m_Size[i] ) 
          {
          return false;
          }
        }
      return true;
    }
 
  unsigned long GetNumberOfPixels() const;

protected:

private:
  unsigned int m_ImageDimension;
  std::vector<long> m_Index;
  std::vector<long> m_Size;
};


inline std::ostream & operator<<(std::ostream &os, const ImageIORegion &region)
{
  os << "Dimension: " << region.GetImageDimension() << std::endl;
  os << "Index: ";
  for(ImageIORegion::IndexType::const_iterator i = region.GetIndex().begin();
      i != region.GetIndex().end(); ++i)
    {
    os << *i << " ";
    }
  os << std::endl;
  os << "Index: ";
  for(ImageIORegion::SizeType::const_iterator k = region.GetSize().begin();
      k != region.GetSize().end(); ++k)
    {
    os << *k << " ";
    }
  os << std::endl;
  return os;
}

} // end namespace itk

#endif

---