itkSparseFieldFourthOrderLevelSetImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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_MOVE(SparseFieldFourthOrderLevelSetImageFilter);

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

  itkOverrideGetNameOfClassMacro(SparseFieldFourthOrderLevelSetImageFilter);

  static constexpr unsigned int ImageDimension = Superclass::ImageDimension;

  using typename Superclass::OutputImageType;
  using typename Superclass::ValueType;
  using typename Superclass::IndexType;
  using typename Superclass::LayerType;
  using typename Superclass::RadiusType;
  using 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);
  itkBooleanMacro(NormalProcessUnsharpFlag);
  itkSetMacro(NormalProcessUnsharpWeight, ValueType);
  itkGetConstReferenceMacro(NormalProcessUnsharpWeight, ValueType);

  void
  SetLevelSetFunction(LevelSetFunctionType * lsf);

  unsigned int
  GetMinimumNumberOfLayers() const
  {
    return static_cast<int>(std::ceil(m_CurvatureBandWidth + Self::ImageDimension));
  }

  void
  SetNumberOfLayers(const unsigned int n) override
  {
    const unsigned int nm = std::max(this->GetMinimumNumberOfLayers(), n);
 
    if (nm != this->GetNumberOfLayers())
    {
      Superclass::SetNumberOfLayers(nm);
      this->Modified();
    }
  }

  void
  InitializeIteration() override
  {
    Superclass::InitializeIteration();
    const 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;
  }
 
  itkConceptMacro(OutputHasNumericTraitsCheck, (Concept::HasNumericTraits<ValueType>));
 
protected:
  SparseFieldFourthOrderLevelSetImageFilter();
  ~SparseFieldFourthOrderLevelSetImageFilter() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;

  ValueType
  ComputeCurvatureFromSparseImageNeighborhood(SparseImageIteratorType & it) 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