itkMultiphaseDenseFiniteDifferenceImageFilter.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 __itkMultiphaseDenseFiniteDifferenceImageFilter_h
#define __itkMultiphaseDenseFiniteDifferenceImageFilter_h

#include "itkMultiphaseFiniteDifferenceImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkSignedMaurerDistanceMapImageFilter.h"
#include "itkNumericTraits.h"
#include "itkNeighborhoodAlgorithm.h"

#include <list>

namespace itk
{
template< class TInputImage, class TFeatureImage, class TOutputImage, class TFunction,
          typename TIdCell = unsigned int >
class ITK_EXPORT MultiphaseDenseFiniteDifferenceImageFilter:
  public MultiphaseFiniteDifferenceImageFilter< TInputImage, TFeatureImage,
                                                TOutputImage, TFunction, TIdCell >
{
public:

  typedef MultiphaseDenseFiniteDifferenceImageFilter Self;
  typedef MultiphaseFiniteDifferenceImageFilter< TInputImage,
                                                 TFeatureImage, TOutputImage, TFunction, TIdCell >       Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkTypeMacro(MultiphaseDenseFiniteDifferenceImageFilter, ImageToImageFilter);

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

  typedef typename Superclass::InputImageType      InputImageType;
  typedef typename Superclass::InputImagePointer   InputImagePointer;
  typedef typename Superclass::InputRegionType     InputRegionType;
  typedef typename Superclass::InputSizeType       InputSizeType;
  typedef typename Superclass::InputSizeValueType  InputSizeValueType;
  typedef typename Superclass::InputIndexType      InputIndexType;
  typedef typename Superclass::InputIndexValueType InputIndexValueType;
  typedef typename Superclass::InputPixelType      InputPixelType;
  typedef typename Superclass::InputPointType      InputPointType;
  typedef typename Superclass::InputSpacingType    InputSpacingType;
  typedef typename InputImageType::ValueType       ValueType;

  typedef typename Superclass::FeatureImageType    FeatureImageType;
  typedef typename Superclass::FeatureSizeType     FeatureSizeType;
  typedef typename Superclass::FeatureImagePointer FeatureImagePointer;
  typedef typename Superclass::FeatureRegionType   FeatureRegionType;
  typedef typename Superclass::FeatureSpacingType  FeatureSpacingType;
  typedef typename Superclass::FeaturePointType    FeaturePointType;
  typedef typename Superclass::FeaturePixelType    FeaturePixelType;

  typedef typename Superclass::OutputImageType      OutputImageType;
  typedef typename Superclass::OutputImagePointer   OutputImagePointer;
  typedef typename Superclass::OutputRegionType     OutputRegionType;
  typedef typename Superclass::OutputSizeType       OutputSizeType;
  typedef typename Superclass::OutputSizeValueType  SizeValueType;
  typedef typename Superclass::OutputIndexType      OutputIndexType;
  typedef typename Superclass::OutputIndexValueType OutputIndexValueType;
  typedef typename OutputImageType::PixelType       OutputPixelType;

  typedef typename Superclass::IdCellType IdCellType;

  typedef BinaryThresholdImageFilter< InputImageType, InputImageType > ThresholdFilterType;
  typedef typename ThresholdFilterType::Pointer                        ThresholdFilterPointer;

  typedef SignedMaurerDistanceMapImageFilter< InputImageType, InputImageType > MaurerType;
  typedef typename MaurerType::Pointer                                         MaurerPointer;

  typedef typename Superclass::FiniteDifferenceFunctionType       FiniteDifferenceFunctionType;
  typedef typename Superclass::FiniteDifferenceFunctionPointer    FiniteDifferenceFunctionPointer;
  typedef typename FiniteDifferenceFunctionType::NeighborhoodType NeighborhoodIteratorType;

  typedef typename Superclass::TimeStepType TimeStepType;

  typedef NeighborhoodAlgorithm::ImageBoundaryFacesCalculator< InputImageType > FaceCalculatorType;
  typedef typename FaceCalculatorType::FaceListType                             FaceListType;

  void SetFunctionCount(const IdCellType & n);

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro( OutputTimesDoubleCheck,
                   ( Concept::MultiplyOperator< OutputPixelType, double > ) );
  itkConceptMacro( OutputAdditiveOperatorsCheck,
                   ( Concept::AdditiveOperators< OutputPixelType > ) );
  itkConceptMacro( InputConvertibleToOutputCheck,
                   ( Concept::Convertible< FeaturePixelType, OutputPixelType > ) );

#endif

  itkSetMacro(ReinitializeCounter, unsigned int);
  itkGetMacro(ReinitializeCounter, unsigned int);
protected:
  MultiphaseDenseFiniteDifferenceImageFilter()
  {
    this->m_ReinitializeCounter = 1;
    // FIXME: this->m_UpdateCounter really used?
    // this->m_UpdateCounter = 0;        // FIXME: Should this be a bool ?
  }

  ~MultiphaseDenseFiniteDifferenceImageFilter() {}

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

  virtual void CopyInputToOutput();

  virtual void PostProcessOutput();

  virtual void ApplyUpdate(TimeStepType dt);

  unsigned int m_ReinitializeCounter;  // FIXME: Should this be a boolean ?
  // unsigned int m_UpdateCounter;        // FIXME: Should this be a boolean ?
private:
  MultiphaseDenseFiniteDifferenceImageFilter(const Self &);
  void operator=(const Self &); //purposely not implemented

  virtual void AllocateUpdateBuffer();

  virtual TimeStepType CalculateChange();

  std::vector< InputImagePointer > m_UpdateBuffers;
};
} // end namespace itk

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

#endif