itkImplicitManifoldNormalVectorFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImplicitManifoldNormalVectorFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-05-12 17:22:49 $
  Version:   $Revision: 1.6 $

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

#include "itkConstNeighborhoodIterator.h"
#include "itkNormalVectorFunctionBase.h"
#include "itkFiniteDifferenceSparseImageFilter.h"
#include "itkVector.h"

namespace itk {

template <class TInputImage, class TSparseOutputImage>
class ITK_EXPORT ImplicitManifoldNormalVectorFilter  
  : public FiniteDifferenceSparseImageFilter <TInputImage, TSparseOutputImage>
{
public:  

  typedef ImplicitManifoldNormalVectorFilter Self;
  typedef FiniteDifferenceSparseImageFilter <
    TInputImage,
    TSparseOutputImage>                      Superclass;
  typedef SmartPointer<Self>                 Pointer;
  typedef SmartPointer<const Self>           ConstPointer;

  itkTypeMacro(ImplicitManifoldNormalVectorFilter,
               FiniteDifferenceSparseImageFilter);

  itkNewMacro(Self);

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

  typedef typename Superclass::InputImageType  InputImageType;
  typedef typename Superclass::IndexType       IndexType;
  typedef typename Superclass::NodeDataType    NormalVectorType;
  typedef typename Superclass::NodeValueType   NodeValueType;
  typedef typename Superclass::FiniteDifferenceFunctionType
                                               FiniteDifferenceFunctionType;

  typedef typename Superclass::SparseOutputImageType SparseOutputImageType;
  typedef typename Superclass::OutputNodeType        NormalBandNodeType;
  typedef typename Superclass::NodeListType          NodeListType;
  
  typedef ConstNeighborhoodIterator <InputImageType> InputImageIteratorType;

  typedef NormalVectorFunctionBase <SparseOutputImageType> NormalFunctionType;

  typedef typename FiniteDifferenceFunctionType::RadiusType RadiusType;

  void SetNormalFunction( NormalFunctionType *nf );  

  itkSetMacro(MaxIteration, unsigned int);
  itkGetConstMacro(MaxIteration, unsigned int);
  itkSetMacro(IsoLevelLow,  NodeValueType);
  itkGetConstMacro(IsoLevelLow,  NodeValueType);
  itkSetMacro(IsoLevelHigh, NodeValueType);
  itkGetConstMacro(IsoLevelHigh, NodeValueType);
  itkSetMacro(MinVectorNorm, NodeValueType);
  itkGetConstMacro(MinVectorNorm, NodeValueType);
  itkSetMacro(UnsharpMaskingFlag, bool);
  itkGetConstMacro(UnsharpMaskingFlag, bool);
  itkSetMacro(UnsharpMaskingWeight, NodeValueType);
  itkGetConstMacro(UnsharpMaskingWeight, NodeValueType);
 
protected:   
  ImplicitManifoldNormalVectorFilter();  
  ~ImplicitManifoldNormalVectorFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void Initialize();

  void SetNormalBand();

  void InitializeNormalBandNode( NormalBandNodeType *node,
                                 const InputImageIteratorType &it );

  virtual void CopyInputToOutput() {};

  virtual bool Halt()
    {
    if (this->GetElapsedIterations() == m_MaxIteration)
      {
      return true;
      }
    else
      {
      return false;
      }
    }
protected:

  virtual NormalVectorType DataConstraint( const NormalVectorType &data ) const 
    {
    return (data / (m_MinVectorNorm + data.GetNorm()));
    }

  virtual void PostProcessOutput();

private:
  ImplicitManifoldNormalVectorFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
    
  NormalFunctionType *m_NormalFunction;

  unsigned int m_MaxIteration;

  NodeValueType m_IsoLevelLow, m_IsoLevelHigh;

  NodeValueType m_MinVectorNorm;

  bool m_UnsharpMaskingFlag;

  NodeValueType m_UnsharpMaskingWeight;

  unsigned long m_Indicator[itkGetStaticConstMacro(ImageDimension)];
  unsigned int  m_NumVertex;
  NodeValueType m_DimConst;
  NodeValueType m_DimConst2;
  RadiusType    m_ManifoldRadius;

};

}// end namespace itk

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

#endif