otbFunctorImageFilter.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2020 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * 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
 *
 * 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 otbFunctorImageFilter_h
#define otbFunctorImageFilter_h

#include "otbVariadicNamedInputsImageFilter.h"
#include "otbImage.h"
#include "otbVectorImage.h"
#include "itkRGBPixel.h"
#include "itkRGBAPixel.h"
#include "itkFixedArray.h"
#include "itkDefaultConvertPixelTraits.h"
#include <type_traits>
#include "itkConstNeighborhoodIterator.h"
#include "otbImage.h"

namespace otb
{
template <class T>
struct IsNeighborhood : std::false_type
{
};

template <class T>
struct IsNeighborhood<const itk::ConstNeighborhoodIterator<Image<T>>&> : std::true_type
{
};

template <class T>
struct IsNeighborhood<const itk::ConstNeighborhoodIterator<VectorImage<T>>&> : std::true_type
{
};

template <class T>
struct IsSuitableType : std::is_scalar<T>::type
{
};

template <class T>
struct IsSuitableType<std::complex<T>> : IsSuitableType<T>::type
{
};

template <class T>
struct IsSuitableType<itk::VariableLengthVector<T>> : IsSuitableType<T>::type
{
};

template <class T, unsigned int N>
struct IsSuitableType<itk::FixedArray<T, N>> : IsSuitableType<T>::type
{
};

template <class T>
struct IsSuitableType<itk::RGBPixel<T>> : IsSuitableType<T>::type
{
};

template <class T>
struct IsSuitableType<itk::RGBAPixel<T>> : IsSuitableType<T>::type
{
};

template <class T>
struct PixelTypeDeduction
{
  static_assert(IsSuitableType<T>::value, "T can not be used as a template parameter for Image or VectorImage classes.");
  using PixelType = T;
};

template <class T>
struct PixelTypeDeduction<itk::ConstNeighborhoodIterator<Image<T>>>
{
  static_assert(IsSuitableType<T>::value, "T can not be used as a template parameter for Image or VectorImage classes.");
  using PixelType = T;
};

template <class T>
struct PixelTypeDeduction<itk::ConstNeighborhoodIterator<VectorImage<T>>>
{
  static_assert(IsSuitableType<T>::value, "T can not be used as a template parameter for Image or VectorImage classes.");
  using PixelType = itk::VariableLengthVector<T>;
};

template <class T>
struct ImageTypeDeduction
{
  using ImageType = otb::Image<T>;
};

template <class T>
struct ImageTypeDeduction<itk::VariableLengthVector<T>>
{
  using ImageType = otb::VectorImage<T>;
};

// Helper to remove const, volatite and Ref qualifier (until c++20
template <typename T>
using RemoveCVRef = typename std::remove_cv<typename std::remove_reference<T>::type>::type;

template <typename T>
struct RetrieveOperator
{
  static_assert(std::is_class<T>::value || std::is_function<T>::value, "T is not a class or function");
  using Type = decltype(&T::operator());
};

template <typename T, typename TNameMap>
struct FunctorFilterSuperclassHelper : public FunctorFilterSuperclassHelper<typename RetrieveOperator<T>::Type, TNameMap>
{
};

namespace functor_filter_details
{
template <typename R, typename TNameMap, typename... T>
struct FunctorFilterSuperclassHelperImpl
{
  // OutputImageType is derived from return type R
  using OutputImageType = typename ImageTypeDeduction<R>::ImageType;
  // InputImageType is derived using pixel type deduction and image
  // type deduction
  template <typename V>
  using InputImageType = typename ImageTypeDeduction<typename PixelTypeDeduction<RemoveCVRef<V>>::PixelType>::ImageType;

  // Filter type is either VariadicInputsImageFilter or
  // VariadicNamedInputsImageFilter depending on if there is a
  // TNameMap or not
  using FilterType = typename std::conditional<std::is_void<TNameMap>::value, VariadicInputsImageFilter<OutputImageType, InputImageType<T>...>,
                                               VariadicNamedInputsImageFilter<OutputImageType, TNameMap, InputImageType<T>...>>::type;

  // InputHasNeighborhood is derived from IsNeighborhood
  using InputHasNeighborhood = std::tuple<typename IsNeighborhood<T>::type...>;
};
} // End namespace functor_filter_details

template <typename R, typename... T, typename TNameMap>
struct FunctorFilterSuperclassHelper<R (*)(T...), TNameMap>
{
  using OutputImageType      = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::OutputImageType;
  using FilterType           = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::FilterType;
  using InputHasNeighborhood = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::InputHasNeighborhood;
};

template <typename C, typename R, typename... T, typename TNameMap>
struct FunctorFilterSuperclassHelper<R (C::*)(T...) const, TNameMap>
{
  using OutputImageType      = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::OutputImageType;
  using FilterType           = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::FilterType;
  using InputHasNeighborhood = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::InputHasNeighborhood;
};

template <typename C, typename R, typename... T, typename TNameMap>
struct FunctorFilterSuperclassHelper<R (C::*)(T...), TNameMap>
{
  using OutputImageType      = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::OutputImageType;
  using FilterType           = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::FilterType;
  using InputHasNeighborhood = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::InputHasNeighborhood;
};

template <typename R, typename... T, typename TNameMap>
struct FunctorFilterSuperclassHelper<void (*)(R&, T...), TNameMap>
{
  using OutputImageType      = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::OutputImageType;
  using FilterType           = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::FilterType;
  using InputHasNeighborhood = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::InputHasNeighborhood;
};

template <typename C, typename R, typename... T, typename TNameMap>
struct FunctorFilterSuperclassHelper<void (C::*)(R&, T...) const, TNameMap>
{
  using OutputImageType      = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::OutputImageType;
  using FilterType           = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::FilterType;
  using InputHasNeighborhood = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::InputHasNeighborhood;
};

template <typename C, typename R, typename... T, typename TNameMap>
struct FunctorFilterSuperclassHelper<void (C::*)(R&, T...), TNameMap>
{
  using OutputImageType      = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::OutputImageType;
  using FilterType           = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::FilterType;
  using InputHasNeighborhood = typename functor_filter_details::FunctorFilterSuperclassHelperImpl<R, TNameMap, T...>::InputHasNeighborhood;
};


template <typename Functor, typename TNameMap = void>
auto NewFunctorFilter(Functor f, itk::Size<2> radius = {{0, 0}});


template <class TFunction, class TNameMap = void>
class ITK_EXPORT FunctorImageFilter : public FunctorFilterSuperclassHelper<TFunction, TNameMap>::FilterType
{

public:
  // Standard typedefs
  using Self         = FunctorImageFilter;
  using FunctorType  = TFunction;
  using Pointer      = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;

  // Superclass through the helper struct
  using SuperclassHelper      = FunctorFilterSuperclassHelper<TFunction, TNameMap>;
  using Superclass            = typename SuperclassHelper::FilterType;
  using OutputImageType       = typename Superclass::OutputImageType;
  using OutputImageRegionType = typename OutputImageType::RegionType;

  // A tuple of bool of the same size as the number of arguments in
  // the functor
  using InputHasNeighborhood = typename SuperclassHelper::InputHasNeighborhood;
  using InputTypesTupleType  = typename Superclass::InputTypesTupleType;
  template <size_t I>
  using InputImageType = typename Superclass::template InputImageType<I>;
  using Superclass::NumberOfInputs;

  itkTypeMacro(FunctorImageFilter, VariadicInputsImageFilter);

  template <typename F = TFunction>
  static std::enable_if_t<std::is_default_constructible<F>::value, Pointer> New()
  {
    // Explicit default construct
    FunctorType f;

    // Create a filter out of it
    Pointer p = new Self(f, {{0, 0}});
    p->UnRegister();
    return p;
  }

  template <typename F = TFunction>
  static std::enable_if_t<!std::is_default_constructible<F>::value, Pointer> New()
  {
    static_assert(std::is_default_constructible<F>::value,
                  "Cannot call New() "
                  "function as the functor used for the filter creation is not default "
                  "constructible");

    return nullptr;
  }

  FunctorType& GetModifiableFunctor()
  {
    this->Modified();
    return m_Functor;
  }

  const FunctorType& GetFunctor() const
  {
    return m_Functor;
  }

protected:
  FunctorImageFilter(const FunctorType& f, itk::Size<2> radius) : m_Functor(f), m_Radius(radius){};
  FunctorImageFilter(const Self&) = delete;
  void operator=(const Self&) = delete;
  ~FunctorImageFilter()       = default;

private:
  friend auto NewFunctorFilter<TFunction, TNameMap>(TFunction f, itk::Size<2> radius);

  void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, itk::ThreadIdType threadId) override;

  void GenerateInputRequestedRegion(void) override;

  void GenerateOutputInformation() override;


  // The functor member
  FunctorType m_Functor;

  // Radius if needed
  itk::Size<2> m_Radius;
};

// Actual implementation of NewFunctorFilter free function
template <typename Functor, typename TNameMap>
auto NewFunctorFilter(Functor f, itk::Size<2> radius)
{
  using FilterType  = FunctorImageFilter<Functor, TNameMap>;
  using PointerType = typename FilterType::Pointer;

  PointerType p = new FilterType(f, radius);
  p->UnRegister();
  return p;
}

template <typename F>
struct NumberOfOutputBandsDecorator : public F
{
public:
  constexpr NumberOfOutputBandsDecorator(F t, unsigned int nbComp) : F(t), m_NumberOfOutputBands(nbComp)
  {
  }

  constexpr size_t OutputSize(...) const
  {
    return m_NumberOfOutputBands;
  }

private:
  unsigned int m_NumberOfOutputBands;
};

template <typename Functor, typename TNameMap = void>
auto NewFunctorFilter(Functor f, unsigned int numberOfOutputBands, itk::Size<2> radius)
{
  using FunctorType = NumberOfOutputBandsDecorator<Functor>;
  FunctorType decoratedF(f, numberOfOutputBands);
  return NewFunctorFilter<FunctorType, TNameMap>(decoratedF, radius);
}

} // namespace otb

#ifndef OTB_MANUAL_INSTANTIATION
#include "otbFunctorImageFilter.hxx"
#endif

#endif