itkSparseFieldFourthOrderLevelSetImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSparseFieldFourthOrderLevelSetImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2008-03-03 13:58:46 $
  Version:   $Revision: 1.15 $

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

#include "itkSparseImage.h"
#include "itkNormalVectorDiffusionFunction.h"
#include "itkImplicitManifoldNormalVectorFilter.h"
#include "itkLevelSetFunctionWithRefitTerm.h"
#include "itkSparseFieldLevelSetImageFilter.h"
#include <math.h>

namespace itk {

template <class TImageType>
class NormalBandNode
{
public:

  typedef TImageType LevelSetImageType;

  typedef typename LevelSetImageType::PixelType  NodeValueType;

  typedef typename LevelSetImageType::IndexType  IndexType;

  typedef Vector <NodeValueType,
                  ::itk::GetImageDimension<TImageType>::ImageDimension>
  NodeDataType;

  NodeDataType m_Data;

  NodeDataType m_InputData;

  NodeDataType m_Update;

  NodeDataType
  m_ManifoldNormal[::itk::GetImageDimension<TImageType>::ImageDimension];

  NodeDataType m_Flux [::itk::GetImageDimension<TImageType>::ImageDimension];

  NodeValueType m_Curvature;

  bool          m_CurvatureFlag;

  IndexType m_Index;  

  NormalBandNode *Next;  
  NormalBandNode *Previous;
};

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

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

  itkTypeMacro(SparseFieldFourthOrderLevelSetImageFilter,
               SparseFieldLevelSetImageFilter);

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

  typedef typename Superclass::OutputImageType OutputImageType;
  typedef typename Superclass::ValueType ValueType;
  typedef typename Superclass::IndexType IndexType;
  typedef typename Superclass::LayerType LayerType;
  typedef typename Superclass::RadiusType RadiusType;
  typedef typename Superclass::NeighborhoodScalesType NeighborhoodScalesType;

  typedef NormalBandNode <OutputImageType> NodeType;

  typedef SparseImage <NodeType,
                       itkGetStaticConstMacro(ImageDimension)> SparseImageType;

  typedef typename NodeType::NodeDataType NormalVectorType;

  typedef NeighborhoodIterator <SparseImageType> SparseImageIteratorType;

  typedef ImplicitManifoldNormalVectorFilter <OutputImageType, SparseImageType>
  NormalVectorFilterType;

  typedef NormalVectorDiffusionFunction <SparseImageType>
  NormalVectorFunctionType;

  //typedef typename NormalVectorFunctionType::RadiusType RadiusType;

  typedef LevelSetFunctionWithRefitTerm <OutputImageType,
                                         SparseImageType> LevelSetFunctionType; 

  itkGetConstReferenceMacro(MaxRefitIteration,unsigned int);
  itkSetMacro(MaxRefitIteration,unsigned int);
  itkGetConstReferenceMacro(MaxNormalIteration,unsigned int);
  itkSetMacro(MaxNormalIteration,unsigned int);
  itkGetConstReferenceMacro(CurvatureBandWidth,ValueType);
  itkSetMacro(CurvatureBandWidth,ValueType);
  itkGetConstReferenceMacro(RMSChangeNormalProcessTrigger, ValueType);
  itkSetMacro(RMSChangeNormalProcessTrigger, ValueType);
  itkGetConstReferenceMacro(NormalProcessType, int);
  itkSetMacro(NormalProcessType, int);
  itkGetConstReferenceMacro(NormalProcessConductance, ValueType);
  itkSetMacro(NormalProcessConductance, ValueType);
  itkSetMacro(NormalProcessUnsharpFlag, bool);
  itkGetConstReferenceMacro(NormalProcessUnsharpFlag, bool);
  itkSetMacro(NormalProcessUnsharpWeight, ValueType);
  itkGetConstReferenceMacro(NormalProcessUnsharpWeight, ValueType);

  void SetLevelSetFunction( LevelSetFunctionType *lsf );

  unsigned int GetMinimumNumberOfLayers() const
  {
    return (int)vcl_ceil(m_CurvatureBandWidth+
                     itkGetStaticConstMacro(ImageDimension));
  }

  virtual void SetNumberOfLayers( const unsigned int n )
  {
    unsigned int nm = vnl_math_max (this->GetMinimumNumberOfLayers (), n );
    if (nm != this->GetNumberOfLayers())
      {
      Superclass::SetNumberOfLayers (nm);
      this->Modified();
      }
  }

  virtual void InitializeIteration()
  {
    Superclass::InitializeIteration();
    ValueType rmschange = this->GetRMSChange();

    if ( ( this->GetElapsedIterations()==0 ) ||
         ( m_RefitIteration == m_MaxRefitIteration ) ||
         ( rmschange <= m_RMSChangeNormalProcessTrigger ) ||
         ( this->ActiveLayerCheckBand() ) )
      {
      if ( ( this->GetElapsedIterations() != 0 ) &&
           ( rmschange <= m_RMSChangeNormalProcessTrigger ) &&
           ( m_RefitIteration <= 1) )
        {
        m_ConvergenceFlag = true;
        }

      m_RefitIteration = 0;
      ProcessNormals();
      }
    
    m_RefitIteration++;
  }

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(OutputHasNumericTraitsCheck,
                  (Concept::HasNumericTraits<ValueType>));

#endif

protected:
  SparseFieldFourthOrderLevelSetImageFilter();
  ~SparseFieldFourthOrderLevelSetImageFilter() {};
  virtual void PrintSelf(std::ostream& os, Indent indent) const;


  ValueType ComputeCurvatureFromSparseImageNeighborhood
  ( SparseImageIteratorType &neighborhood ) const;

  void ComputeCurvatureTarget( const OutputImageType *distanceImage,
                               SparseImageType *sparseImage ) const;

  void ProcessNormals();

  bool ActiveLayerCheckBand() const;

private:
  unsigned int m_RefitIteration;

  unsigned int m_MaxRefitIteration;

  unsigned int m_MaxNormalIteration;

  ValueType m_RMSChangeNormalProcessTrigger;

  bool m_ConvergenceFlag;

  LevelSetFunctionType *m_LevelSetFunction;

  ValueType m_CurvatureBandWidth;

  int m_NormalProcessType;

  ValueType m_NormalProcessConductance;

  bool m_NormalProcessUnsharpFlag;

  ValueType m_NormalProcessUnsharpWeight;

  static const unsigned long m_NumVertex;
  static const ValueType m_DimConst;

  SparseFieldFourthOrderLevelSetImageFilter(const Self&);
  //purposely not implemented
  void operator=(const Self&); //purposely not implemented
};

} // end namespace itk

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

#endif

---