itkSparseFieldLevelSetImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSparseFieldLevelSetImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-04-25 12:28:10 $
  Version:   $Revision: 1.27 $

  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 __itkSparseFieldLevelSetImageFilter_h
#define __itkSparseFieldLevelSetImageFilter_h

#include "itkFiniteDifferenceImageFilter.h"
#include "itkMultiThreader.h"
#include "itkSparseFieldLayer.h"
#include "itkObjectStore.h"
#include <vector>
#include "itkNeighborhoodIterator.h"

namespace itk {

template <class TValueType>
class SparseFieldLevelSetNode
{
public:
  TValueType               m_Value;
  SparseFieldLevelSetNode *Next;
  SparseFieldLevelSetNode *Previous;
};

template <class TNeighborhoodType>
class SparseFieldCityBlockNeighborList
{
public:
  typedef TNeighborhoodType                     NeighborhoodType;
  typedef typename NeighborhoodType::OffsetType OffsetType;
  typedef typename NeighborhoodType::RadiusType RadiusType;
  itkStaticConstMacro(Dimension, unsigned int,
                      NeighborhoodType::Dimension );

  const RadiusType &GetRadius() const
    { return m_Radius; }
  
  const unsigned int &GetArrayIndex(unsigned int i) const
    { return m_ArrayIndex[i]; }

  const OffsetType &GetNeighborhoodOffset(unsigned int i) const
    { return m_NeighborhoodOffset[i]; }

  const unsigned int &GetSize() const
    { return m_Size; }

  int GetStride(unsigned int i)
    { return m_StrideTable[i]; }
  
  SparseFieldCityBlockNeighborList();
  ~SparseFieldCityBlockNeighborList() {}

  void Print(std::ostream &os) const;
  
private:
  unsigned int              m_Size;
  RadiusType                m_Radius;
  std::vector<unsigned int> m_ArrayIndex;
  std::vector<OffsetType>   m_NeighborhoodOffset;

  unsigned m_StrideTable[Dimension];
};

  
template <class TInputImage, class TOutputImage>
class ITK_EXPORT SparseFieldLevelSetImageFilter :
  public FiniteDifferenceImageFilter<TInputImage, TOutputImage>
{
public:

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

  typedef typename Superclass::TimeStepType           TimeStepType;
  typedef typename Superclass::RadiusType             RadiusType;
  typedef typename Superclass::NeighborhoodScalesType NeighborhoodScalesType;

  itkNewMacro(Self);

  itkTypeMacro(SparseFieldLevelSetImageFilter, FiniteDifferenceImageFilter);

  typedef TInputImage                         InputImageType;
  typedef TOutputImage                        OutputImageType;
  typedef typename OutputImageType::IndexType IndexType;
  itkStaticConstMacro(ImageDimension, unsigned int,
                      TOutputImage::ImageDimension);

  typedef typename OutputImageType::ValueType ValueType;

  typedef SparseFieldLevelSetNode<IndexType> LayerNodeType;

  typedef SparseFieldLayer<LayerNodeType> LayerType;
  typedef typename LayerType::Pointer     LayerPointerType;

  typedef std::vector<LayerPointerType> LayerListType;

  typedef signed char StatusType;

  typedef Image<StatusType, itkGetStaticConstMacro(ImageDimension)>
  StatusImageType;

  typedef ObjectStore<LayerNodeType> LayerNodeStorageType;

  typedef std::vector<ValueType> UpdateBufferType;

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

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

  //  itkGetConstMacro(RMSChange, ValueType);

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

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

#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:
  SparseFieldLevelSetImageFilter();
  ~SparseFieldLevelSetImageFilter();
  virtual void PrintSelf(std::ostream& os, Indent indent) const;

  inline virtual ValueType CalculateUpdateValue(
    const IndexType &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(StatusType from, StatusType to);

  void ConstructActiveLayer();

  void InitializeActiveLayerValues();

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

  void PropagateAllLayerValues();

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

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

  void ProcessOutsideList(LayerType *OutsideList, StatusType ChangeToStatus);

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

  SparseFieldCityBlockNeighborList<NeighborhoodIterator<OutputImageType> >
  m_NeighborList;

  double m_ConstantGradientValue;

  static ValueType m_ValueOne;

  static ValueType m_ValueZero;

  static StatusType m_StatusChanging;

  static StatusType m_StatusActiveChangingUp;

  static StatusType m_StatusActiveChangingDown;

  static StatusType m_StatusBoundaryPixel;

  static StatusType m_StatusNull;

  typename OutputImageType::Pointer m_ShiftedImage;

  LayerListType m_Layers;

  unsigned int m_NumberOfLayers;

  typename StatusImageType::Pointer m_StatusImage;

  typename LayerNodeStorageType::Pointer m_LayerNodeStore;

  ValueType m_IsoSurfaceValue;

  UpdateBufferType m_UpdateBuffer;

  //  ValueType m_RMSChange;  

  bool m_InterpolateSurfaceLocation;

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

  bool m_BoundsCheckingActive;

};
  
  
} // end namespace itk

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

#endif