itkImplicitManifoldNormalVectorFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImplicitManifoldNormalVectorFilter.h,v $
  Language:  C++
  Date:      $Date: 2003/09/10 14:28:50 $
  Version:   $Revision: 1.3 $

  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 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);
  itkGetMacro(MaxIteration, unsigned int);
  itkSetMacro(IsoLevelLow,  NodeValueType);
  itkGetMacro(IsoLevelLow,  NodeValueType);
  itkSetMacro(IsoLevelHigh, NodeValueType);
  itkGetMacro(IsoLevelHigh, NodeValueType);
  itkSetMacro(MinVectorNorm, NodeValueType);
  itkGetMacro(MinVectorNorm, NodeValueType);
  itkSetMacro(UnsharpMaskingFlag, bool);
  itkGetMacro(UnsharpMaskingFlag, bool);
  itkSetMacro(UnsharpMaskingWeight, NodeValueType);
  itkGetMacro(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() {};

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, m_DimConst2;
  RadiusType    m_ManifoldRadius;

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

  virtual void PostProcessOutput();

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

}// end namespace itk

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

#endif

---