itkFFTImageFilterFactory.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.
 *
 *=========================================================================*/
 
#ifndef itkFFTImageFilterFactory_h
#define itkFFTImageFilterFactory_h
 
#include "itkImage.h"
#include "itkObjectFactoryBase.h"
#include "itkVersion.h"
 
#include <type_traits>
 
namespace itk
{
 
// Compile-time predicates selecting which precisions a templated FFT filter
// is registered for. Both default to enabled; an FFT backend specializes the
// relevant predicate to std::false_type when its matching precision is
// unavailable (e.g. FFTW without ITK_USE_FFTWD).
template <template <typename, typename> class TFFTImageFilter>
struct FFTImageFilterEnableFloat : std::true_type
{};
template <template <typename, typename> class TFFTImageFilter>
struct FFTImageFilterEnableDouble : std::true_type
{};

template <template <typename, typename> class TFFTImageFilter>
struct FFTImageFilterTraits
{};
 

template <template <typename, typename> class TFFTImageFilter,
          template <typename, unsigned int> class TInput = Image,
          template <typename, unsigned int> class TOutput = Image>
class FFTImageFilterFactory : public ObjectFactoryBase
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(FFTImageFilterFactory);
 
  using Self = FFTImageFilterFactory;
  using Superclass = ObjectFactoryBase;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  const char *
  GetITKSourceVersion() const override
  {
    return ITK_SOURCE_VERSION;
  }
  const char *
  GetDescription() const override
  {
    return "An FFTImageFilter factory";
  }

  itkFactorylessNewMacro(Self);

  itkOverrideGetNameOfClassMacro(FFTImageFilterFactory);

  static void
  RegisterOneFactory()
  {
    auto factory = FFTImageFilterFactory::New();
 
    ObjectFactoryBase::RegisterFactoryInternal(factory);
  }
 
protected:
  template <typename InputPixelType, typename OutputPixelType, unsigned int D, unsigned int... ImageDimensions>
  void
  OverrideFFTImageFilterType(const std::integer_sequence<unsigned int, D, ImageDimensions...> &)
  {
    using InputImageType = TInput<InputPixelType, D>;
    using OutputImageType = TOutput<OutputPixelType, D>;
    this->RegisterOverride(typeid(typename TFFTImageFilter<InputImageType, OutputImageType>::Superclass).name(),
                           typeid(TFFTImageFilter<InputImageType, OutputImageType>).name(),
                           "FFT Image Filter Override",
                           true,
                           CreateObjectFunction<TFFTImageFilter<InputImageType, OutputImageType>>::New());
    OverrideFFTImageFilterType<InputPixelType, OutputPixelType>(
      std::integer_sequence<unsigned int, ImageDimensions...>{});
  }
  template <typename InputPixelType, typename OutputPixelType>
  void
  OverrideFFTImageFilterType(const std::integer_sequence<unsigned int> &)
  {}

  FFTImageFilterFactory()
  {
    if constexpr (FFTImageFilterEnableFloat<TFFTImageFilter>::value)
    {
      OverrideFFTImageFilterType<typename FFTImageFilterTraits<TFFTImageFilter>::template InputPixelType<float>,
                                 typename FFTImageFilterTraits<TFFTImageFilter>::template OutputPixelType<float>>(
        typename FFTImageFilterTraits<TFFTImageFilter>::FilterDimensions{});
    }
 
    if constexpr (FFTImageFilterEnableDouble<TFFTImageFilter>::value)
    {
      OverrideFFTImageFilterType<typename FFTImageFilterTraits<TFFTImageFilter>::template InputPixelType<double>,
                                 typename FFTImageFilterTraits<TFFTImageFilter>::template OutputPixelType<double>>(
        typename FFTImageFilterTraits<TFFTImageFilter>::FilterDimensions{});
    }
  }
};
 
} // namespace itk
 
#endif // itkFFTImageFilterFactory_h