itkUnaryFrequencyDomainFilter.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 itkUnaryFrequencyDomainFilter_h
#define itkUnaryFrequencyDomainFilter_h

#include <itkInPlaceImageFilter.h>
#include <itkFrequencyFFTLayoutImageRegionIteratorWithIndex.h>

namespace itk
{
template< typename TImageType,
  typename TFrequencyIterator = FrequencyFFTLayoutImageRegionIteratorWithIndex<TImageType> >
class UnaryFrequencyDomainFilter:
  public InPlaceImageFilter<TImageType, TImageType>
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(UnaryFrequencyDomainFilter);

  using Self = UnaryFrequencyDomainFilter;
  using Superclass = InPlaceImageFilter<TImageType, TImageType>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkNewMacro(Self);

  itkTypeMacro(UnaryFrequencyDomainFilter, InPlaceImageFilter);

  using ImageType = TImageType;
  using ImagePointer = typename ImageType::Pointer;
  using ImageConstPointer = typename ImageType::ConstPointer;
  using IndexType = typename TImageType::IndexType;
  using PixelType = typename TImageType::PixelType;

  using ImageRegionType = typename TImageType::RegionType;

  static constexpr unsigned int ImageDimension = TImageType::ImageDimension;

#ifdef ITK_USE_CONCEPT_CHECKING
  itkConceptMacro( ImageTypeHasNumericTraitsCheck,
                   ( Concept::HasNumericTraits< typename TImageType::PixelType > ) );
#endif

  using FrequencyIteratorType = TFrequencyIterator;
  using FrequencyValueType = typename FrequencyIteratorType::FrequencyValueType;

  itkSetMacro( ActualXDimensionIsOdd, bool );
  itkGetConstReferenceMacro(ActualXDimensionIsOdd, bool);
  itkBooleanMacro( ActualXDimensionIsOdd );

  using ConstRefFunctionType = double( const FrequencyIteratorType& );

  using ValueFunctionType = void( FrequencyIteratorType& );

#if !defined( ITK_WRAPPING_PARSER )

  void SetFunctor( const std::function<ConstRefFunctionType> &f)
  {
    auto inPlaceFunctor = [f]( FrequencyIteratorType& freq ) { freq.Value() *= f( freq ); };

    m_DynamicThreadedGenerateDataFunction = [this, inPlaceFunctor]( const ImageRegionType& outputRegionForThread ) {
      return this->DynamicThreadedGenerateDataWithFunctor( inPlaceFunctor, outputRegionForThread );
    };

    this->Modified();
  }

 void SetFunctor( const std::function<ValueFunctionType> &f)
  {
    m_DynamicThreadedGenerateDataFunction = [this, f]( const ImageRegionType& outputRegionForThread )
      { return this->DynamicThreadedGenerateDataWithFunctor(f, outputRegionForThread); };

    this->Modified();
  }


  void SetFunctor( ConstRefFunctionType *f)
  {
    auto inPlaceFunctor = [f]( FrequencyIteratorType& freq ) { freq.Value() *= f( freq ); };

    m_DynamicThreadedGenerateDataFunction = [this, inPlaceFunctor]( const ImageRegionType& outputRegionForThread ) {
      return this->DynamicThreadedGenerateDataWithFunctor( inPlaceFunctor, outputRegionForThread );
    };

    this->Modified();
  }

  void SetFunctor( ValueFunctionType *funcPointer)
  {
    m_DynamicThreadedGenerateDataFunction = [this, funcPointer]( const ImageRegionType& outputRegionForThread )
      { return this->DynamicThreadedGenerateDataWithFunctor(funcPointer, outputRegionForThread); };

    this->Modified();
  }


  template <typename TFunctor>
  void SetFunctor( const TFunctor & functor)
  {
    m_DynamicThreadedGenerateDataFunction = [this, functor]( const ImageRegionType& outputRegionForThread )
      { return this->DynamicThreadedGenerateDataWithFunctor(functor, outputRegionForThread); };

    this->Modified();
  }
#endif // !defined( ITK_WRAPPING_PARSER )

protected:
  UnaryFrequencyDomainFilter();
  void PrintSelf(std::ostream & os, Indent indent) const override;

  template <typename TFunctor>
  void DynamicThreadedGenerateDataWithFunctor( const TFunctor &, const ImageRegionType & outputRegionForThread );
  void DynamicThreadedGenerateData( const ImageRegionType & outputRegionForThread ) override;

private:
  std::function< void( const ImageRegionType& ) > m_DynamicThreadedGenerateDataFunction;

  bool m_ActualXDimensionIsOdd{false};
};
} // end namespace itk

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

#endif // itkUnaryFrequencyDomainFilter_h