itkMultiphaseSparseFiniteDifferenceImageFilter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMultiphaseSparseFiniteDifferenceImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-05-15 20:43:38 $
  Version:   $Revision: 1.7 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

#ifndef __itkMultiphaseSparseFiniteDifferenceImageFilter_h
#define __itkMultiphaseSparseFiniteDifferenceImageFilter_h

#include "itkMultiphaseFiniteDifferenceImageFilter.h"
#include "itkMultiThreader.h"
#include "itkSparseFieldLayer.h"
#include "itkObjectStore.h"
#include "itkNeighborhoodIterator.h"
#include "itkZeroCrossingImageFilter.h"
#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIterator.h"
#include "itkShiftScaleImageFilter.h"
#include "itkNeighborhoodAlgorithm.h"
#include "itkSparseFieldLevelSetImageFilter.h"

#include <vector>

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

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

  itkNewMacro(Self);

  itkTypeMacro( MultiphaseSparseFiniteDifferenceImageFilter, MultiphaseFiniteDifferenceImageFilter );

  typedef typename Superclass::TimeStepType               TimeStepType;

  typedef typename Superclass::InputImageType             InputImageType;
  typedef typename Superclass::InputSizeType              InputSizeType;
  typedef typename Superclass::InputImagePointer          InputImagePointer;
  typedef typename Superclass::InputRegionType            InputRegionType;
  typedef typename Superclass::InputSpacingType           InputSpacingType;
  typedef typename Superclass::InputPointType             InputPointType;

  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 OutputImageType::ValueType             ValueType;
  typedef typename Superclass::OutputIndexType            OutputIndexType;
  typedef typename Superclass::OutputIndexValueType       OutputIndexValueType;
  typedef typename Superclass::OutputPixelType            OutputPixelType;

  typedef typename Superclass::IdCellType                 IdCellType;


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

  typedef typename Superclass::FiniteDifferenceFunctionType
    FiniteDifferenceFunctionType;
  typedef typename Superclass::FiniteDifferenceFunctionPointer
    FiniteDifferenceFunctionPointer;
  typedef typename FiniteDifferenceFunctionType::FloatOffsetType
    FiniteDifferenceFunctionFloatOffsetType;

  typedef SparseFieldLevelSetNode< OutputIndexType >    LayerNodeType;

  typedef SparseFieldLayer< LayerNodeType >             LayerType;
  typedef typename LayerType::Pointer                   LayerPointerType;
  typedef typename LayerType::Iterator                  LayerIterator;
  typedef typename LayerType::ConstIterator             LayerConstIterator;

  typedef std::vector< LayerPointerType >               LayerListType;
  typedef typename LayerListType::iterator              LayerListIterator;
  typedef typename LayerListType::const_iterator        LayerListConstIterator;


  typedef signed char                                   StatusType;

  typedef Image< StatusType, itkGetStaticConstMacro(ImageDimension) >
                                                        StatusImageType;
  typedef typename StatusImageType::Pointer             StatusImagePointer;

  typedef ZeroCrossingImageFilter<OutputImageType, OutputImageType>
    ZeroCrossingFilterType;
  typedef typename ZeroCrossingFilterType::Pointer
    ZeroCrossingFilterPointer;

  typedef ObjectStore< LayerNodeType >            LayerNodeStorageType;
  typedef typename LayerNodeStorageType::Pointer  LayerNodeStoragePointer;

  typedef std::vector< ValueType >                  UpdateBufferType;
  typedef typename UpdateBufferType::const_iterator UpdateBufferConstIterator;

  itkSetMacro( NumberOfLayers, unsigned int );
  itkGetConstMacro( NumberOfLayers, unsigned int );

  itkSetMacro( IsoSurfaceValue, ValueType );
  itkGetConstMacro( IsoSurfaceValue, ValueType );

  itkSetMacro(InterpolateSurfaceLocation, bool);
  itkGetConstMacro(InterpolateSurfaceLocation, bool);

  void InterpolateSurfaceLocationOn()
  { this->SetInterpolateSurfaceLocation( true ); }
  void InterpolateSurfaceLocationOff()
  { this->SetInterpolateSurfaceLocation( false ); }

  void SetFunctionCount( const IdCellType& n )
    {
    this->Superclass::SetFunctionCount( n );

    m_SparseData.resize( this->m_FunctionCount, 0 );

    for( IdCellType i = 0; i < this->m_FunctionCount; i++ )
      {
      m_SparseData[i] = new SparseDataStruct( i );
      }
    }


#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(OutputEqualityComparableCheck,
    (Concept::EqualityComparable<typename TOutputImage::PixelType>));
  itkConceptMacro(DoubleConvertibleToOutputCheck,
    (Concept::Convertible<double, typename TOutputImage::PixelType>));
  itkConceptMacro(OutputOStreamWritableCheck,
    (Concept::OStreamWritable<typename TOutputImage::PixelType>));

#endif

protected:
  MultiphaseSparseFiniteDifferenceImageFilter();
  ~MultiphaseSparseFiniteDifferenceImageFilter()
    {
    while( !m_SparseData.empty() )
      {
      if( m_SparseData.back() )
        {
        delete m_SparseData.back();
        }
      m_SparseData.pop_back();
      }
    }

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

  // This data structure is created for each phase
  struct SparseDataStruct
    {
    SparseDataStruct( const IdCellType& index )
      {
      m_LayerNodeStore = LayerNodeStorageType::New();
      m_LayerNodeStore->SetGrowthStrategyToExponential();
      m_Index = index;
      }

    SparseFieldCityBlockNeighborList< NeighborhoodIterator<OutputImageType> >
      m_NeighborList;

    LayerListType m_Layers;

    StatusImagePointer m_StatusImage;

    OutputImagePointer m_ShiftedImage;

    LayerNodeStoragePointer m_LayerNodeStore;

    UpdateBufferType m_UpdateBuffer;

    IdCellType m_Index;
    };

  inline virtual ValueType CalculateUpdateValue(
    const OutputIndexType &itkNotUsed(idx),
    const TimeStepType &dt,
    const ValueType &value,
    const ValueType &change)
    {
    return (value + dt * change);
    }

  virtual void PostProcessOutput();

  virtual void InitializeBackgroundPixels();

  void Initialize();

  void CopyInputToOutput();

  void AllocateUpdateBuffer();

  void ApplyUpdate(TimeStepType dt);

  TimeStepType CalculateChange();

  void ConstructLayer(SparseDataStruct *sparsePtr, StatusType from, StatusType
to);

  void ConstructActiveLayer();

  void InitializeActiveLayerValues();

  void PropagateLayerValues(SparseDataStruct *sparsePtr, StatusType from,
    StatusType to, StatusType promote, int InOrOut);

  void PropagateAllLayerValues();

  void PropagateFunctionLayerValues( unsigned int functionIndex );

  void UpdateActiveLayerValues( TimeStepType dt, LayerType *StatusUpList,
    LayerType *StatusDownList );

  void ProcessStatusList( LayerType *InputList, LayerType *OutputList,
    StatusType ChangeToStatus, StatusType SearchForStatus);

  void ProcessOutsideList(LayerType *OutsideList, StatusType ChangeToStatus);

  void InitializeIteration();

  virtual void UpdatePixel(unsigned int itkNotUsed(functionIndex), unsigned int itkNotUsed(idx),
    NeighborhoodIterator<OutputImageType> & itkNotUsed(iterator), ValueType & itkNotUsed(newValue),
    bool & itkNotUsed(status) ){};

  itkGetConstMacro( ValueZero, ValueType );
  itkGetConstMacro( ValueOne, ValueType );

  static double m_ConstantGradientValue;

  static const ValueType m_ValueOne;

  static const ValueType m_ValueZero;

  static const StatusType m_StatusChanging;

  static const StatusType m_StatusActiveChangingUp;

  static const StatusType m_StatusActiveChangingDown;

  static const StatusType m_StatusBoundaryPixel;

  static const StatusType m_StatusNull;

  std::vector< SparseDataStruct* > m_SparseData;

  unsigned int m_NumberOfLayers;

  ValueType m_IsoSurfaceValue;

  bool m_InterpolateSurfaceLocation;

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

  unsigned int    m_CurrentFunctionIndex;

  bool m_BoundsCheckingActive;
};


} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMultiphaseSparseFiniteDifferenceImageFilter.txx"
#endif

#endif

---