itkImageHelper.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImageHelper.h,v $
  Language:  C++
  Date:      $Date: 2005/09/11 18:12:56 $
  Version:   $Revision: 1.5 $

  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 __itkImageHelper_h
#define __itkImageHelper_h

#include "itkConceptChecking.h"

namespace itk
{

// Forward reference ImageBase
template <
  unsigned int NImageDimension
  > class ImageBase; 

template <unsigned int NImageDimension, unsigned int NLoop>
class ImageHelper
{
public:
  typedef ImageBase<NImageDimension>              ImageType;
  typedef typename ImageType::IndexType           IndexType;
  typedef typename ImageType::OffsetType          OffsetType;
  typedef typename ImageType::IndexValueType      IndexValueType;
  typedef typename ImageType::OffsetValueType     OffsetValueType;
  typedef Concept::Detail::UniqueType_bool<false> UniqueTypeBoolFalse;
  typedef Concept::Detail::UniqueType_bool<true>  UniqueTypeBoolTrue;

  inline static void ComputeIndex(const IndexType &bufferedRegionIndex,
                                  OffsetValueType offset,
                                  const OffsetValueType offsetTable[],
                                  IndexType &index)
    {
      ImageHelper<NImageDimension,NLoop-1>::        
      ComputeIndexInner(bufferedRegionIndex,
                        offset,
                        offsetTable,
                        index,
                        Concept::Detail::UniqueType_bool<(NLoop==1)>());
    }

  inline static void ComputeIndexInner(const IndexType &bufferedRegionIndex,    
                                       OffsetValueType &offset,
                                       const OffsetValueType offsetTable[],
                                       IndexType &index,
                                       const UniqueTypeBoolFalse& )
  {
    index[NLoop] = static_cast<IndexValueType>(offset / offsetTable[NLoop]);
    offset = offset - (index[NLoop] * offsetTable[NLoop]);
    index[NLoop] = index[NLoop] + bufferedRegionIndex[NLoop];
    ImageHelper<NImageDimension, NLoop-1>::        
      ComputeIndexInner(bufferedRegionIndex,
                        offset,
                        offsetTable,
                        index,
                        Concept::Detail::UniqueType_bool<(NLoop==1)>());
    
  }

  inline static void ComputeIndexInner(const IndexType &bufferedRegionIndex,
                                       OffsetValueType &offset,
                                       const OffsetValueType [],
                                       IndexType &index,
                                       const UniqueTypeBoolTrue& )
  {
    // Do last 
    index[0] = bufferedRegionIndex[0] + static_cast<IndexValueType>(offset);
  }

  // ComputeOffset
  //
  inline static void ComputeOffset(const IndexType &bufferedRegionIndex,
                                   const IndexType &index,
                                   const OffsetValueType offsetTable[],
                                   OffsetValueType &offset)
    {
      ImageHelper<NImageDimension,NLoop-1>::        
        ComputeOffsetInner(bufferedRegionIndex,
                           index,
                           offsetTable,
                           offset,
                           Concept::Detail::UniqueType_bool<(NLoop==1)>());
    }

  inline static void ComputeOffsetInner(const IndexType &bufferedRegionIndex,    
                                       const IndexType &index,
                                       const OffsetValueType offsetTable[],
                                       OffsetValueType &offset,
                                       const UniqueTypeBoolFalse& )
  {
    offset = offset + (index[NLoop] - bufferedRegionIndex[NLoop])*offsetTable[NLoop];
//    std::cout << "    offset += (index[" << NLoop << "] - bufferedRegionIndex[" << NLoop << "])*offsetTable[" << NLoop << "];" << std::endl;
    ImageHelper<NImageDimension, NLoop-1>::        
      ComputeOffsetInner(bufferedRegionIndex,
                        index,
                        offsetTable,
                        offset,
                        Concept::Detail::UniqueType_bool<(NLoop==1)>());
    
  }

  inline static void ComputeOffsetInner(const IndexType &bufferedRegionIndex,
                                        const IndexType &index,
                                        const OffsetValueType [],
                                        OffsetValueType &offset,
                                        const UniqueTypeBoolTrue& )
  {
    // Do last 
    offset = offset + index[0] - bufferedRegionIndex[0];
//    std::cout << "    offset += (index[0] - bufferedRegionIndex[0]);" << std::endl;
  }

};
} // end namespace itk

#endif

---