itkImageAlgorithm.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 itkImageAlgorithm_h
#define itkImageAlgorithm_h

#include "itkImageRegionIterator.h"

#include <type_traits>

namespace itk
{

template <typename TPixelType, unsigned int VImageDimension > class VectorImage;


struct ImageAlgorithm
{

    using TrueType = std::true_type;
    using FalseType = std::false_type;


  template<typename InputImageType, typename OutputImageType>
  static void Copy( const InputImageType *inImage, OutputImageType *outImage,
                    const typename InputImageType::RegionType &inRegion,
                    const typename OutputImageType::RegionType &outRegion )
  {
    ImageAlgorithm::DispatchedCopy( inImage, outImage, inRegion, outRegion );
  }

  template<typename TPixel1, typename TPixel2, unsigned int VImageDimension>
  static void Copy( const Image<TPixel1, VImageDimension> * inImage,
                               Image<TPixel2, VImageDimension> * outImage,
                               const typename Image<TPixel1, VImageDimension>::RegionType &inRegion,
                               const typename Image<TPixel2, VImageDimension>::RegionType &outRegion )
  {
    using _ImageType1 = Image<TPixel1, VImageDimension>;
    using _ImageType2 = Image<TPixel2, VImageDimension>;
    ImageAlgorithm::DispatchedCopy( inImage, outImage, inRegion, outRegion,
                                    std::is_convertible<typename _ImageType1::PixelType,
                                    typename _ImageType2::PixelType>()
                                   );
  }

  template<typename TPixel1, typename TPixel2, unsigned int VImageDimension>
  static void Copy( const VectorImage<TPixel1, VImageDimension> * inImage,
                               VectorImage<TPixel2, VImageDimension> * outImage,
                               const typename VectorImage<TPixel1, VImageDimension>::RegionType &inRegion,
                               const typename VectorImage<TPixel2, VImageDimension>::RegionType &outRegion )
  {
    using _ImageType1 = VectorImage<TPixel1, VImageDimension>;
    using _ImageType2 = VectorImage<TPixel2, VImageDimension>;
    ImageAlgorithm::DispatchedCopy( inImage, outImage, inRegion, outRegion,
                                    std::is_convertible<typename _ImageType1::PixelType,
                                    typename _ImageType2::PixelType>()
                                   );
  }


  template<typename InputImageType, typename OutputImageType>
  static typename OutputImageType::RegionType
  EnlargeRegionOverBox(const typename InputImageType::RegionType & inputRegion,
                       const InputImageType* inputImage,
                       const OutputImageType* outputImage);

private:

  template<typename InputImageType, typename OutputImageType>
  static void DispatchedCopy( const InputImageType *inImage, OutputImageType *outImage,
                              const typename InputImageType::RegionType &inRegion,
                              const typename OutputImageType::RegionType &outRegion, TrueType isSpecialized );

  template<typename InputImageType, typename OutputImageType>
  static void DispatchedCopy( const InputImageType *inImage, OutputImageType *outImage,
                              const typename InputImageType::RegionType &inRegion,
                              const typename OutputImageType::RegionType &outRegion, FalseType isSpecialized = FalseType() );


  template <typename TImageType>
  struct PixelSize
  {
    static size_t Get( const TImageType *)
      {
      return 1;
      }
  };

  template <typename TPixelType, unsigned int VImageDimension>
  struct PixelSize< VectorImage<TPixelType, VImageDimension> >
  {
    using ImageType = VectorImage<TPixelType, VImageDimension>;
    static size_t Get( const  ImageType * i )
      {
      const size_t vectorLength = ImageType::AccessorFunctorType::GetVectorLength(i);
      return vectorLength;
      }
  };

  template<typename TInputType, typename TOutputType>
  struct StaticCast
    {
    TOutputType operator() (const TInputType i) { return static_cast<TOutputType>(i); }
    };


  template<typename TType>
  static TType* CopyHelper(const TType *first, const TType *last, TType *result)
    {
    // Note: On some MS compilers the following may generate a
    // warning. Please include itkMacro.h before <algorithm> or
    // another stl header to avoid.
    return std::copy(first, last, result);
    }

  template<typename TInputType, typename TOutputType>
  static TOutputType* CopyHelper(const TInputType *first, const TInputType *last, TOutputType *result)
    {
    return std::transform(first, last, result, StaticCast<TInputType,TOutputType>());
    }


};
} // end namespace itk


#ifndef ITK_MANUAL_INSTANTIATION
#include "itkImageAlgorithm.hxx"
#endif


#endif //itkImageAlgorithm_h