itkImageIORegion.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.
 *
 *=========================================================================*/
#ifndef __itkImageIORegion_h
#define __itkImageIORegion_h

#include <algorithm>
#include "itkIntTypes.h"
#include "itkObjectFactory.h"
#include "itkImageRegion.h"

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

  typedef ::itk::SizeValueType    SizeValueType;
  typedef ::itk::IndexValueType   IndexValueType;
  typedef ::itk::OffsetValueType  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 ITK_EXPORT 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;

  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);
      }
  }

  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);
  }
};
} // end namespace itk

#endif