itkImageIORegion.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImageIORegion.h,v $
  Language:  C++
  Date:      $Date: 2009-07-12 10:52:54 $
  Version:   $Revision: 1.25 $

  Copyright (c) Insight Software 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 <algorithm>
#include "itkRegion.h"
#include "itkObjectFactory.h"
#include "itkImageRegion.h"
#include "itkIndex.h"
#include "itkSize.h"

namespace itk
{

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

  typedef size_t                  SizeValueType;
  typedef ptrdiff_t               IndexValueType;
  typedef ptrdiff_t               OffsetValueType;


  typedef std::vector<IndexValueType>  IndexType;

  typedef std::vector<SizeValueType>   SizeType;

  typedef Superclass::RegionType       RegionType;

  itkTypeMacro(ImageIORegion, Region);

  unsigned int GetImageDimension() const;

  unsigned int GetRegionDimension() const;

  virtual RegionType GetRegionType() const;

  ImageIORegion(unsigned int dimension);

  ImageIORegion();

  virtual ~ImageIORegion();

  ImageIORegion(const Self& region);

  void operator=(const Self& region);

  void SetIndex(const IndexType &index);

  const IndexType & GetIndex() const;

  void SetSize(const SizeType &size);

  const SizeType & GetSize() const;

  SizeValueType GetSize(unsigned long i) const;
  IndexValueType GetIndex(unsigned long i) const;
  void SetSize(const unsigned long i, SizeValueType size);
  void SetIndex(const unsigned long i, IndexValueType idx);

  bool operator==(const Self &region) const;

  bool operator!=(const Self &region) const;

  bool IsInside(const IndexType &index) const;

  bool IsInside(const Self &region) const;

  SizeValueType GetNumberOfPixels( void ) const;

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

private:
  unsigned int      m_ImageDimension;
  IndexType         m_Index;
  SizeType          m_Size;
};


// Declare operator<<
extern std::ostream & operator<<(std::ostream &os, const ImageIORegion &region); 

template< unsigned int VDimension >
class ImageIORegionAdaptor
{
public:
  typedef ImageRegion<VDimension>  ImageRegionType;
  typedef ImageIORegion            ImageIORegionType;

  typedef typename ImageRegionType::SizeType  ImageSizeType;
  typedef typename ImageRegionType::IndexType ImageIndexType;

  itkLegacyMacro(static void Convert( const ImageRegionType & outImageRegion, ImageIORegionType & inIORegion) );

  static void Convert( const ImageRegionType & inImageRegion, ImageIORegionType & outIORegion, const ImageIndexType &largestRegionIndex)
    {
    //
    // The ImageRegion and ImageIORegion objects may have different dimensions.
    // Here we only copy the common dimensions between the two. If the ImageRegion
    // has more dimensions than the ImageIORegion, then the defaults of the ImageRegion
    // will take care of the remaining codimension. If the ImageRegion has less dimensions
    // than the ImageIORegion, then the remaining IO dimensions are simply ignored.
    //
    const unsigned int ioDimension = outIORegion.GetImageDimension();
    const unsigned int imageDimension = VDimension;

    unsigned int minDimension = ( ioDimension > imageDimension ) ? imageDimension : ioDimension;

    ImageSizeType  size  = inImageRegion.GetSize();
    ImageIndexType index = inImageRegion.GetIndex();
    
    for( unsigned int i = 0; i < minDimension; i++ )
      {
      outIORegion.SetSize(  i, size[i] );
      outIORegion.SetIndex( i, index[i] - largestRegionIndex[i]);
      }

    //
    // Fill in the remaining codimension (if any) with default values
    //
    for( unsigned int k = minDimension; k < ioDimension; k++ )
      {
      outIORegion.SetSize(  k, 1 ); // Note that default size in IO is 1 not 0
      outIORegion.SetIndex( k, 0 );
      }
    }

  itkLegacyMacro(static void Convert( const ImageIORegionType & inIORegion, ImageRegionType & outImageRegion) );
  

  static void Convert( const ImageIORegionType & inIORegion, ImageRegionType & outImageRegion, const ImageIndexType &largestRegionIndex )
    {
    ImageSizeType  size;
    ImageIndexType index;

    size.Fill(1);  // initialize with default values
    index.Fill(0);

    //
    // The ImageRegion and ImageIORegion objects may have different dimensions.
    // Here we only copy the common dimensions between the two. If the ImageRegion
    // has more dimensions than the ImageIORegion, then the defaults of the ImageRegion
    // will take care of the remaining codimension. If the ImageRegion has less dimensions
    // than the ImageIORegion, then the remaining IO dimensions are simply ignored.
    //
    const unsigned int ioDimension = inIORegion.GetImageDimension();
    const unsigned int imageDimension = VDimension;

    unsigned int minDimension = ( ioDimension > imageDimension ) ? imageDimension : ioDimension;

    for(unsigned int i=0; i<minDimension; i++)
      {
      size[i]  = inIORegion.GetSize(i);
      index[i] = inIORegion.GetIndex(i) + largestRegionIndex[i];
      }

    outImageRegion.SetSize( size );
    outImageRegion.SetIndex( index );
    }
};

#if !defined(ITK_LEGACY_REMOVE)
template< unsigned int VDimension >
void ImageIORegionAdaptor<VDimension>::Convert( const ImageRegionType & inImageRegion, ImageIORegionType & outIORegion ) 
{
  itkGenericLegacyBodyMacro(ImageIORegionAdaptor::Convert, 4.0);
  // the index argument is required
  ImageIndexType index;
  index.Fill(0);
  ImageIORegionAdaptor<VDimension>::Convert(inImageRegion, outIORegion, index);
}

template< unsigned int VDimension >
void ImageIORegionAdaptor<VDimension>::Convert( const ImageIORegionType & inIORegion, ImageRegionType & outImageRegion )
{
  itkGenericLegacyBodyMacro(ImageIORegionAdaptor::Convert, 4.0);
  // the index argument is required
  ImageIndexType index;
  index.Fill(0);
  ImageIORegionAdaptor<VDimension>::Convert(inIORegion, outImageRegion, index);
}
#endif

} // end namespace itk

#endif