itkGPUFiniteDifferenceImageFilter.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
 *
 *         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 itkGPUFiniteDifferenceImageFilter_h
#define itkGPUFiniteDifferenceImageFilter_h
 
#include "itkGPUInPlaceImageFilter.h"
#include "itkGPUFiniteDifferenceFunction.h"
#include "itkFiniteDifferenceImageFilter.h"
#include "itkTimeProbe.h"
#include "itkGPUFiniteDifferenceFilterEnum.h"
 
namespace itk
{
 
template <typename TInputImage,
          typename TOutputImage,
          typename TParentImageFilter = FiniteDifferenceImageFilter<TInputImage, TOutputImage>>
class ITK_TEMPLATE_EXPORT GPUFiniteDifferenceImageFilter
  : public GPUInPlaceImageFilter<TInputImage, TOutputImage, TParentImageFilter>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(GPUFiniteDifferenceImageFilter);
 
  using Self = GPUFiniteDifferenceImageFilter;
  using GPUSuperclass = GPUInPlaceImageFilter<TInputImage, TOutputImage, TParentImageFilter>;
  using CPUSuperclass = TParentImageFilter;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkTypeMacro(GPUFiniteDifferenceImageFilter, GPUInPlaceImageFilter);
 
  using InputImageType = TInputImage;
  using OutputImageType = TOutputImage;
 
  static constexpr unsigned int ImageDimension = OutputImageType::ImageDimension;
 
  using OutputPixelType = typename TOutputImage::PixelType;
  using InputPixelType = typename TInputImage::PixelType;
  using PixelType = OutputPixelType;
 
  using OutputPixelValueType = typename NumericTraits<OutputPixelType>::ValueType;
  using InputPixelValueType = typename NumericTraits<InputPixelType>::ValueType;
 
  using FiniteDifferenceFunctionType = typename GPUFiniteDifferenceFunction<TOutputImage>::DifferenceFunctionType;
  using TimeStepType = typename FiniteDifferenceFunctionType::TimeStepType;
  using RadiusType = typename FiniteDifferenceFunctionType::RadiusType;
  using NeighborhoodScalesType = typename FiniteDifferenceFunctionType::NeighborhoodScalesType;
 
  const typename FiniteDifferenceFunctionType::Pointer &
  GetDifferenceFunction() const override
  {
    return this->m_DifferenceFunction;
  }
 
  void
  SetDifferenceFunction(FiniteDifferenceFunctionType * differenceFunction) override
  {
    itkDebugMacro("setting m_DifferenceFunction to " << differenceFunction);
    if (this->m_DifferenceFunction != differenceFunction)
    {
      this->m_DifferenceFunction = differenceFunction;
      this->Modified();
    }
  }
 
#if !defined(ITK_LEGACY_REMOVE)
 
  using FilterStateType = GPUFiniteDifferenceFilterEnum;
  // We need to expose the enum values at the class level for backwards compatibility
  static constexpr GPUFiniteDifferenceFilterEnum UNINITIALIZED = GPUFiniteDifferenceFilterEnum::UNINITIALIZED;
  static constexpr GPUFiniteDifferenceFilterEnum INITIALIZED = GPUFiniteDifferenceFilterEnum::INITIALIZED;
#endif
 
  void
  SetStateToInitialized()
  {
    this->SetState(GPUFiniteDifferenceFilterEnum::INITIALIZED);
  }
 
  void
  SetStateToUninitialized()
  {
    this->SetState(GPUFiniteDifferenceFilterEnum::UNINITIALIZED);
  }
 
#if !defined(ITK_WRAPPING_PARSER)
  itkSetMacro(State, GPUFiniteDifferenceFilterEnum);
  itkGetConstReferenceMacro(State, GPUFiniteDifferenceFilterEnum);
#endif
 
 
#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro(OutputPixelIsFloatingPointCheck, (Concept::IsFloatingPoint<OutputPixelValueType>));
  // End concept checking
#endif
 
  itkGetConstReferenceMacro(InitTime, TimeProbe);
  itkGetConstReferenceMacro(ComputeUpdateTime, TimeProbe);
  itkGetConstReferenceMacro(ApplyUpdateTime, TimeProbe);
  itkGetConstReferenceMacro(SmoothFieldTime, TimeProbe);
 
protected:
  GPUFiniteDifferenceImageFilter();
  ~GPUFiniteDifferenceImageFilter() override;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  AllocateUpdateBuffer() override = 0;
 
  virtual void
  GPUApplyUpdate(const TimeStepType & dt) = 0;
 
  virtual TimeStepType
  GPUCalculateChange() = 0;
 
  void
  CopyInputToOutput() override = 0;
 
  void
  GPUGenerateData() override;
 
  void
  GenerateInputRequestedRegion() override;
 
  bool
  Halt() override;
 
  bool
  ThreadedHalt(void * itkNotUsed(threadInfo)) override
  {
    return this->Halt();
  }
 
  void
  Initialize() override
  {}
 
  void
  InitializeIteration() override
  {
    m_DifferenceFunction->InitializeIteration();
  }
 
  TimeStepType
  ResolveTimeStep(const std::vector<TimeStepType> & timeStepList, const std::vector<bool> & valid) const override;
 
  void
  PostProcessOutput() override
  {}
 
  TimeProbe m_InitTime, m_ComputeUpdateTime, m_ApplyUpdateTime, m_SmoothFieldTime;
 
private:
  void
  InitializeFunctionCoefficients();
 
  typename FiniteDifferenceFunctionType::Pointer m_DifferenceFunction;
 
  bool m_UseImageSpacing;
 
  GPUFiniteDifferenceFilterEnum m_State;
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkGPUFiniteDifferenceImageFilter.hxx"
#endif
 
#endif