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 {

  using FirstType = BooleanDispatch< B1 >;
  using SecondType = BooleanDispatch< B2 >;
};

template< int D1, int D2 >
struct BinaryIntDispatch {

  using FirstType = IntDispatch< D1 >;
  using SecondType = IntDispatch< D2 >;
};

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

  using FirstType = UnsignedIntDispatch< D1 >;
  using SecondType = UnsignedIntDispatch< D2 >;

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

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
  {
    using ComparisonType = typename BinaryUnsignedIntDispatch< D1, D2 >::ComparisonType;
    ImageToImageFilterDefaultCopyRegion< D1, D2 >(
      ComparisonType(),
      destRegion, srcRegion);
  }

  virtual ~ImageRegionCopier() = default;
};

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


template< unsigned int D1, unsigned int D2 >
void ImageToImageFilterDefaultCopyInformation(const typename
                                              BinaryUnsignedIntDispatch< D1, D2 >::FirstEqualsSecondType &,
                                              ImageBase< D1 >* destImage,
                                              const ImageBase< D2 >* srcImage)
{
  destImage->CopyInformation(srcImage);
}


template< unsigned int D1, unsigned int D2 >
void ImageToImageFilterDefaultCopyInformation(const typename
                                              BinaryUnsignedIntDispatch< D1, D2 >::FirstGreaterThanSecondType &,
                                              ImageBase< D1 >* destImage,
                                              const ImageBase< D2 >* srcImage)
{
  using DestinationImageType = ImageBase<D1>;
  using SourceImageType = ImageBase<D2>;

  // Copy what we can from the image from spacing and origin of the input
  // This logic needs to be augmented with logic that select which
  // dimensions to copy
  const typename SourceImageType::SpacingType &inputSpacing = srcImage->GetSpacing();
  const typename SourceImageType::PointType &inputOrigin = srcImage->GetOrigin();
  const typename SourceImageType::DirectionType &inputDirection = srcImage->GetDirection();

  typename DestinationImageType::SpacingType destSpacing;
  typename DestinationImageType::PointType destOrigin;
  typename DestinationImageType::DirectionType destDirection;

  // copy the input to the output and fill the rest of the
  // output with zeros.
  unsigned int i = 0;
  for (; i < SourceImageType::ImageDimension; ++i )
    {
    destSpacing[i] = inputSpacing[i];
    destOrigin[i] = inputOrigin[i];
    for ( unsigned int j = 0; j < DestinationImageType::ImageDimension; j++ )
      {
      if ( j < SourceImageType::ImageDimension )
        {
        destDirection[j][i] = inputDirection[j][i];
        }
      else
        {
        destDirection[j][i] = 0.0;
        }
      }
    }
  for (; i < DestinationImageType::ImageDimension; ++i )
    {
    destSpacing[i] = 1.0;
    destOrigin[i] = 0.0;
    for ( unsigned int j = 0; j < DestinationImageType::ImageDimension; j++ )
      {
      if ( j == i )
        {
        destDirection[j][i] = 1.0;
        }
      else
        {
        destDirection[j][i] = 0.0;
        }
      }
    }

  // set the spacing and origin
  destImage->SetSpacing(destSpacing);
  destImage->SetOrigin(destOrigin);
  destImage->SetDirection(destDirection);
  // propagate vector length info
  destImage->SetNumberOfComponentsPerPixel( srcImage->GetNumberOfComponentsPerPixel() );
}


template< unsigned int D1, unsigned int D2 >
class ImageInformationCopier
{
public:
  virtual void operator()(ImageBase< D1 > * destImage,
                          const ImageBase< D2 > * srcImage) const
  {
    using ComparisonType = typename BinaryUnsignedIntDispatch< D1, D2 >::ComparisonType;
    ImageToImageFilterDefaultCopyInformation< D1, D2 >(
      ComparisonType(),
      destImage, srcImage);
  }

  virtual ~ImageInformationCopier() = default;
};


} // end of namespace ImageToImageFilterDetail
} // end namespace itk

#endif