itkImageToImageFilterDetail.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.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef __itkImageToImageFilterDetail_h
#define __itkImageToImageFilterDetail_h

#include "itkImageRegion.h"
#include "itkSmartPointer.h"

namespace itk
{
namespace ImageToImageFilterDetail
{

struct DispatchBase {};

template< bool >
struct BooleanDispatch {};

template< int >
struct IntDispatch:public DispatchBase {};

template< unsigned int >
struct UnsignedIntDispatch:public DispatchBase {};

template< bool B1, bool B2 >
struct BinaryBooleanDispatch {

  typedef BooleanDispatch< B1 > FirstType;
  typedef BooleanDispatch< B2 > SecondType;
};

template< int D1, int D2 >
struct BinaryIntDispatch {

  typedef IntDispatch< D1 > FirstType;
  typedef IntDispatch< D2 > SecondType;
};

template< unsigned int D1, unsigned int D2 >
struct BinaryUnsignedIntDispatch:public DispatchBase {

  typedef UnsignedIntDispatch< D1 > FirstType;
  typedef UnsignedIntDispatch< D2 > SecondType;

  typedef IntDispatch < ( D1 > D2 ) - ( D1 < D2 ) > ComparisonType;
  typedef IntDispatch< 0 >                          FirstEqualsSecondType;
  typedef IntDispatch< 1 >                          FirstGreaterThanSecondType;
  typedef IntDispatch< -1 >                         FirstLessThanSecondType;
};

template< unsigned int D1, unsigned int D2 >
void ImageToImageFilterDefaultCopyRegion(const typename
                                         BinaryUnsignedIntDispatch< D1, D2 >::FirstEqualsSecondType &,
                                         ImageRegion< D1 > & destRegion,
                                         const ImageRegion< D2 > & srcRegion)
{
  destRegion = srcRegion;
}

template< unsigned int D1, unsigned int D2 >
void ImageToImageFilterDefaultCopyRegion(const typename
                                         BinaryUnsignedIntDispatch< D1, D2 >::FirstLessThanSecondType &,
                                         ImageRegion< D1 > & destRegion,
                                         const ImageRegion< D2 > & srcRegion)
{
  // Source dimension is greater than the destination dimension, copy the
  // first part of the source into the destination
  unsigned int dim;

  Index< D1 >         destIndex;
  Size< D1 >          destSize;
  const Index< D2 > & srcIndex = srcRegion.GetIndex();
  const Size< D2 > &  srcSize = srcRegion.GetSize();

  // copy what we can
  for ( dim = 0; dim < D1; ++dim )
    {
    destIndex[dim] = srcIndex[dim];
    destSize[dim] = srcSize[dim];
    }

  destRegion.SetIndex(destIndex);
  destRegion.SetSize(destSize);
}

template< unsigned int D1, unsigned int D2 >
void ImageToImageFilterDefaultCopyRegion(const typename
                                         BinaryUnsignedIntDispatch< D1, D2 >::FirstGreaterThanSecondType &,
                                         ImageRegion< D1 > & destRegion,
                                         const ImageRegion< D2 > & srcRegion)
{
  // Source dimension is less than the destination dimension, copy source
  // into the first part of the destination and set zeros elsewhere.
  unsigned int dim;

  Index< D1 >         destIndex;
  Size< D1 >          destSize;
  const Index< D2 > & srcIndex = srcRegion.GetIndex();
  const Size< D2 > &  srcSize = srcRegion.GetSize();

  // copy what we can
  for ( dim = 0; dim < D2; ++dim )
    {
    destIndex[dim] = srcIndex[dim];
    destSize[dim] = srcSize[dim];
    }
  // fill in the rest of the dimensions with zero/one
  for (; dim < D1; ++dim )
    {
    destIndex[dim] = 0;
    destSize[dim] = 1;
    }

  destRegion.SetIndex(destIndex);
  destRegion.SetSize(destSize);
}

template< unsigned int D1, unsigned int D2 >
class ImageRegionCopier
{
public:
  virtual void operator()(ImageRegion< D1 > & destRegion,
                          const ImageRegion< D2 > & srcRegion) const
  {
    typedef typename BinaryUnsignedIntDispatch< D1, D2 >::ComparisonType ComparisonType;
    ImageToImageFilterDefaultCopyRegion< D1, D2 >(
      ComparisonType(),
      destRegion, srcRegion);
  }

  virtual ~ImageRegionCopier() {}
};

template< unsigned int D1, unsigned int D2 >
std::ostream & operator<<(std::ostream & os,
                          const ImageRegionCopier< D1, D2 > &)
{
  os << "ImageRegionCopier: "
     << typeid( ImageRegionCopier< D1, D2 > ).name() << std::endl;
  return os;
}

template< unsigned int D1, unsigned int D2 >
bool operator!=(const ImageRegionCopier< D1, D2 > & c1,
                const ImageRegionCopier< D1, D2 > & c2)
{
  return &c1 != &c2;
}
} // end of namespace ImageToImageFilterDetail
} // end namespace itk

#endif