itkImplicitManifoldNormalVectorFilter.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 itkImplicitManifoldNormalVectorFilter_h
#define itkImplicitManifoldNormalVectorFilter_h

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

namespace itk
{
template< typename TInputImage, typename 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);
  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 ITK_OVERRIDE;

  virtual void Initialize() ITK_OVERRIDE;

  void SetNormalBand();

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

  virtual void CopyInputToOutput() ITK_OVERRIDE {}

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

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

  virtual void PostProcessOutput() ITK_OVERRIDE;

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.hxx"
#endif

#endif