itkImageToImageFilterDetail.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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
 
 
  Index<D1>         destIndex;
  Size<D1>          destSize;
  const Index<D2> & srcIndex = srcRegion.GetIndex();
  const Size<D2> &  srcSize = srcRegion.GetSize();
 
  // copy what we can
  for (unsigned int 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.
  Index<D1>         destIndex;
  Size<D1>          destSize;
  const Index<D2> & srcIndex = srcRegion.GetIndex();
  const Size<D2> &  srcSize = srcRegion.GetSize();
  // copy what we can
  {
    unsigned int dim = 0;
    for (; 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