itkLevelSetEvolutionBase.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
 *
 *         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 itkLevelSetEvolutionBase_h
#define itkLevelSetEvolutionBase_h
 
#include <list>
 
#include "itkImage.h"
#include "itkDiscreteLevelSetImage.h"
#include "itkImageRegionIteratorWithIndex.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkSignedMaurerDistanceMapImageFilter.h"
#include "itkNumericTraits.h"
#include "itkLevelSetEvolutionStoppingCriterion.h"
 
namespace itk
{
template <typename TEquationContainer, typename TLevelSet>
class ITK_TEMPLATE_EXPORT LevelSetEvolutionBase : public Object
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(LevelSetEvolutionBase);
 
  using Self = LevelSetEvolutionBase;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
  using Superclass = Object;
 
  itkTypeMacro(LevelSetEvolutionBase, Object);
 
  using EquationContainerType = TEquationContainer;
  using EquationContainerPointer = typename EquationContainerType::Pointer;
  using TermContainerType = typename EquationContainerType::TermContainerType;
  using TermContainerPointer = typename TermContainerType::Pointer;
 
  using TermType = typename TermContainerType::TermType;
  using TermPointer = typename TermType::Pointer;
 
  using InputImageType = typename TermContainerType::InputImageType;
  using InputImagePixelType = typename InputImageType::PixelType;
  using InputImageConstPointer = typename InputImageType::ConstPointer;
  using InputImageRegionType = typename InputImageType::RegionType;
  using InputPixelRealType = typename NumericTraits<InputImagePixelType>::RealType;
 
  static constexpr unsigned int ImageDimension = InputImageType::ImageDimension;
 
  using LevelSetContainerType = typename TermContainerType::LevelSetContainerType;
 
  using LevelSetIdentifierType = typename LevelSetContainerType::LevelSetIdentifierType;
 
  using LevelSetType = TLevelSet;
  using LevelSetInputType = typename LevelSetType::InputType;
  using LevelSetOutputType = typename LevelSetType::OutputType;
  using LevelSetOutputRealType = typename LevelSetType::OutputRealType;
  using LevelSetDataType = typename LevelSetType::LevelSetDataType;
 
  using IdListType = typename LevelSetContainerType::IdListType;
  using IdListIterator = typename LevelSetContainerType::IdListIterator;
  using IdListConstIterator = typename LevelSetContainerType::IdListConstIterator;
  using IdListImageType = typename LevelSetContainerType::IdListImageType;
  using CacheImageType = typename LevelSetContainerType::CacheImageType;
 
  using DomainMapImageFilterType = typename LevelSetContainerType::DomainMapImageFilterType;
 
  using StoppingCriterionType = LevelSetEvolutionStoppingCriterion<LevelSetContainerType>;
  using StoppingCriterionPointer = typename StoppingCriterionType::Pointer;
 
  itkSetObjectMacro(LevelSetContainer, LevelSetContainerType);
  itkGetModifiableObjectMacro(LevelSetContainer, LevelSetContainerType);
 
  itkSetMacro(Alpha, LevelSetOutputRealType);
  itkGetMacro(Alpha, LevelSetOutputRealType);
 
  void
  SetTimeStep(const LevelSetOutputRealType & iDt);
 
  itkSetObjectMacro(EquationContainer, EquationContainerType);
  itkGetModifiableObjectMacro(EquationContainer, EquationContainerType);
 
  itkSetObjectMacro(StoppingCriterion, StoppingCriterionType);
  itkGetModifiableObjectMacro(StoppingCriterion, StoppingCriterionType);
 
  itkGetConstMacro(NumberOfIterations, IdentifierType);
 
  void
  Update();
 
protected:
  LevelSetEvolutionBase();
 
  ~LevelSetEvolutionBase() override = default;
 
  void
  CheckSetUp();
 
  void
  InitializeIteration();
 
  void
  Evolve();
 
  virtual void
  AllocateUpdateBuffer();
 
  virtual void
  ComputeIteration();
 
  virtual void
  ComputeTimeStepForNextIteration();
 
  virtual void
  UpdateLevelSets() = 0;
 
  virtual void
  UpdateEquations() = 0;
 
  StoppingCriterionPointer m_StoppingCriterion;
 
  EquationContainerPointer                m_EquationContainer;
  typename LevelSetContainerType::Pointer m_LevelSetContainer;
 
  LevelSetOutputRealType m_Alpha;
  LevelSetOutputRealType m_Dt;
  LevelSetOutputRealType m_RMSChangeAccumulator;
  bool                   m_UserGloballyDefinedTimeStep;
  IdentifierType         m_NumberOfIterations;
 
  typename LevelSetContainerType::Iterator m_LevelSetContainerIteratorToProcessWhenThreading;
  typename LevelSetContainerType::Iterator m_LevelSetUpdateContainerIteratorToProcessWhenThreading;
};
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkLevelSetEvolutionBase.hxx"
#endif
 
#endif // itkLevelSetEvolutionBase_h