itkSparseFieldFourthOrderLevelSetImageFilter.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 __itkSparseFieldFourthOrderLevelSetImageFilter_h
#define __itkSparseFieldFourthOrderLevelSetImageFilter_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 SizeValueType  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.hxx"
#endif

#endif