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;
  }
 
#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 & 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