itkFiniteDifferenceImageFilter.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 __itkFiniteDifferenceImageFilter_h
#define __itkFiniteDifferenceImageFilter_h

#include "itkInPlaceImageFilter.h"
#include "itkFiniteDifferenceFunction.h"

namespace itk
{
template< class TInputImage, class TOutputImage >
class ITK_EXPORT FiniteDifferenceImageFilter:
  public InPlaceImageFilter< TInputImage, TOutputImage >
{
public:

  typedef FiniteDifferenceImageFilter                     Self;
  typedef InPlaceImageFilter< TInputImage, TOutputImage > Superclass;
  typedef SmartPointer< Self >                            Pointer;
  typedef SmartPointer< const Self >                      ConstPointer;

  itkTypeMacro(FiniteDifferenceImageFilter, InPlaceImageFilter);

  typedef TInputImage  InputImageType;
  typedef TOutputImage OutputImageType;

  itkStaticConstMacro(ImageDimension, unsigned int, OutputImageType::ImageDimension);

  typedef typename TOutputImage::PixelType OutputPixelType;
  typedef typename TInputImage::PixelType  InputPixelType;
  typedef OutputPixelType                  PixelType;

  typedef typename NumericTraits< OutputPixelType >::ValueType OutputPixelValueType;
  typedef typename NumericTraits< InputPixelType >::ValueType  InputPixelValueType;

  typedef FiniteDifferenceFunction< TOutputImage >            FiniteDifferenceFunctionType;
  typedef typename FiniteDifferenceFunctionType::TimeStepType TimeStepType;

  typedef typename FiniteDifferenceFunctionType::RadiusType             RadiusType;
  typedef typename FiniteDifferenceFunctionType::NeighborhoodScalesType NeighborhoodScalesType;

  itkGetConstReferenceMacro(ElapsedIterations, IdentifierType);

  itkGetConstReferenceObjectMacro(DifferenceFunction,
                                  FiniteDifferenceFunctionType);

  itkSetObjectMacro(DifferenceFunction, FiniteDifferenceFunctionType);

  itkSetMacro(NumberOfIterations, IdentifierType);
  itkGetConstReferenceMacro(NumberOfIterations, IdentifierType);

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

  itkSetMacro(MaximumRMSError, double);
  itkGetConstReferenceMacro(MaximumRMSError, double);

  itkSetMacro(RMSChange, double);
  itkGetConstReferenceMacro(RMSChange, double);

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

  itkSetMacro( IsInitialized, bool );
  itkGetMacro( IsInitialized, bool );

  void SetStateToUninitialized() { this->SetIsInitialized( false ); }
  void SetStateToInitialized() { this->SetIsInitialized( true ); }

#ifdef ITK_USE_STRICT_CONCEPT_CHECKING

  itkConceptMacro( OutputPixelIsFloatingPointCheck,
                   ( Concept::IsFloatingPoint< OutputPixelValueType > ) );

#endif

protected:

  FiniteDifferenceImageFilter();
  virtual ~FiniteDifferenceImageFilter();

  bool m_IsInitialized;

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

  virtual void AllocateUpdateBuffer() = 0;

  virtual void ApplyUpdate(const TimeStepType& dt) = 0;

  virtual TimeStepType CalculateChange() = 0;

  virtual void CopyInputToOutput() = 0;

  virtual void GenerateData();

  virtual void GenerateInputRequestedRegion();

  virtual bool Halt();

  virtual bool ThreadedHalt( void *itkNotUsed(threadInfo) ) { return this->Halt(); }

  virtual void Initialize() {}

  virtual void InitializeIteration()
  { m_DifferenceFunction->InitializeIteration(); }

  virtual TimeStepType ResolveTimeStep(const std::vector< TimeStepType >& timeStepList,
                                       const std::vector< bool >& valid ) const;

  itkSetMacro(ElapsedIterations, IdentifierType);

  virtual void PostProcessOutput() {}

  IdentifierType m_NumberOfIterations;

  IdentifierType m_ElapsedIterations;

  bool m_ManualReinitialization;

  double m_RMSChange;
  double m_MaximumRMSError;

private:
  FiniteDifferenceImageFilter(const Self &); //purposely not implemented
  void operator=(const Self &);              //purposely not implemented

  void InitializeFunctionCoefficients();

  bool m_UseImageSpacing;

  typename FiniteDifferenceFunctionType::Pointer m_DifferenceFunction;
};
} // end namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_FiniteDifferenceImageFilter(_, EXPORT, TypeX, TypeY)     \
  namespace itk                                                               \
  {                                                                           \
  _( 2 ( class EXPORT FiniteDifferenceImageFilter< ITK_TEMPLATE_2 TypeX > ) ) \
  namespace Templates                                                         \
  {                                                                           \
  typedef FiniteDifferenceImageFilter< ITK_TEMPLATE_2 TypeX >                 \
  FiniteDifferenceImageFilter##TypeY;                                       \
  }                                                                           \
  }

#if ITK_TEMPLATE_EXPLICIT
#include "Templates/itkFiniteDifferenceImageFilter+-.h"
#endif

#if ITK_TEMPLATE_TXX
#include "itkFiniteDifferenceImageFilter.hxx"
#endif

#endif