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 <cmath>

namespace itk
{
template< typename TImageType >
class ITK_TEMPLATE_EXPORT NormalBandNode
{
public:

  using LevelSetImageType = TImageType;

  using NodeValueType = typename LevelSetImageType::PixelType;

  using IndexType = typename LevelSetImageType::IndexType;

  using NodeDataType = Vector< NodeValueType,
                   TImageType ::ImageDimension >;

  NodeDataType m_Data;

  NodeDataType m_InputData;

  NodeDataType m_Update;

  NodeDataType
    m_ManifoldNormal[TImageType::ImageDimension];

  NodeDataType m_Flux[TImageType::ImageDimension];

  NodeValueType m_Curvature;

  bool m_CurvatureFlag;

  IndexType m_Index;

  NormalBandNode *Next;
  NormalBandNode *Previous;
};

template< typename TInputImage, typename TOutputImage >
class ITK_TEMPLATE_EXPORT SparseFieldFourthOrderLevelSetImageFilter:
  public SparseFieldLevelSetImageFilter< TInputImage, TOutputImage >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(SparseFieldFourthOrderLevelSetImageFilter);

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

  itkTypeMacro(SparseFieldFourthOrderLevelSetImageFilter,
               SparseFieldLevelSetImageFilter);

  static constexpr unsigned int ImageDimension = Superclass::ImageDimension;

  using OutputImageType = typename Superclass::OutputImageType;
  using ValueType = typename Superclass::ValueType;
  using IndexType = typename Superclass::IndexType;
  using LayerType = typename Superclass::LayerType;
  using RadiusType = typename Superclass::RadiusType;
  using NeighborhoodScalesType = typename Superclass::NeighborhoodScalesType;

  using NodeType = NormalBandNode< OutputImageType >;

  using SparseImageType = SparseImage< NodeType,
                       Self::ImageDimension >;

  using NormalVectorType = typename NodeType::NodeDataType;

  using SparseImageIteratorType = NeighborhoodIterator< SparseImageType >;

  using NormalVectorFilterType =
      ImplicitManifoldNormalVectorFilter< OutputImageType, SparseImageType >;

  using NormalVectorFunctionType = NormalVectorDiffusionFunction<SparseImageType>;

  //using RadiusType = typename NormalVectorFunctionType::RadiusType;

  using LevelSetFunctionType = LevelSetFunctionWithRefitTerm< OutputImageType,
                                         SparseImageType >;

  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)std::ceil( m_CurvatureBandWidth
                          + Self::ImageDimension );
  }

  void SetNumberOfLayers(const unsigned int n) override
  {
    unsigned int nm = std::max (this->GetMinimumNumberOfLayers (), n);

    if ( nm != this->GetNumberOfLayers() )
      {
      Superclass::SetNumberOfLayers (nm);
      this->Modified();
      }
  }

  void InitializeIteration() override
  {
    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
  // Begin concept checking
  itkConceptMacro( OutputHasNumericTraitsCheck,
                   ( Concept::HasNumericTraits< ValueType > ) );
  // End concept checking
#endif

protected:
  SparseFieldFourthOrderLevelSetImageFilter();
  ~SparseFieldFourthOrderLevelSetImageFilter() override = default;
  void PrintSelf(std::ostream & os, Indent indent) const override;

  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;

};
} // end namespace itk

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

#endif