itkFastMarchingBase.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 itkFastMarchingBase_h
#define itkFastMarchingBase_h
 
#include "itkIntTypes.h"
#include "itkFastMarchingStoppingCriterionBase.h"
#include "itkFastMarchingTraits.h"
#include "ITKFastMarchingExport.h"
 
#include <queue>
#include <functional>
 
namespace itk
{
class FastMarchingTraitsEnums
{
public:
 
  enum class TopologyCheck : uint8_t
  {
    Nothing = 0,
    NoHandles,
    Strict
  };
};
// Define how to print enumeration
extern ITKFastMarching_EXPORT std::ostream &
                              operator<<(std::ostream & out, const FastMarchingTraitsEnums::TopologyCheck value);
 
template <typename TInput, typename TOutput>
class ITK_TEMPLATE_EXPORT FastMarchingBase : public FastMarchingTraits<TInput, TOutput>::SuperclassType
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(FastMarchingBase);
 
  using Traits = FastMarchingTraits<TInput, TOutput>;
  using SuperclassType = typename Traits::SuperclassType;
 
  using Self = FastMarchingBase;
  using Superclass = typename FastMarchingTraits<TInput, TOutput>::SuperclassType;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkOverrideGetNameOfClassMacro(FastMarchingBase);
 
  using InputDomainType = typename Traits::InputDomainType;
  using InputDomainPointer = typename Traits::InputDomainPointer;
  using InputPixelType = typename Traits::InputPixelType;
 
  using OutputDomainType = typename Traits::OutputDomainType;
  using OutputDomainPointer = typename Traits::OutputDomainPointer;
  using OutputPixelType = typename Traits::OutputPixelType;
 
  using NodeType = typename Traits::NodeType;
 
  using NodePairType = typename Traits::NodePairType;
  using NodePairContainerType = typename Traits::NodePairContainerType;
  using NodePairContainerPointer = typename Traits::NodePairContainerPointer;
  using NodePairContainerConstIterator = typename Traits::NodePairContainerConstIterator;
 
  using LabelType = typename Traits::LabelType;
 
  using StoppingCriterionType = FastMarchingStoppingCriterionBase<TInput, TOutput>;
  using StoppingCriterionPointer = typename StoppingCriterionType::Pointer;
 
  /*
  using ElementIdentifier = long;
 
  using PriorityQueueElementType = MinPriorityQueueElementWrapper< NodeType,
    OutputPixelType,
    ElementIdentifier >;
 
  using PriorityQueueType = PriorityQueueContainer< PriorityQueueElementType,
    PriorityQueueElementType, OutputPixelType, ElementIdentifier >;
  using PriorityQueuePointer = typename PriorityQueueType::Pointer;
  */
 
  using TopologyCheckEnum = FastMarchingTraitsEnums::TopologyCheck;
#if !defined(ITK_LEGACY_REMOVE)
  using TopologyCheckType = FastMarchingTraitsEnums::TopologyCheck;
  static constexpr TopologyCheckEnum Nothing = TopologyCheckEnum::Nothing;
  static constexpr TopologyCheckEnum NoHandles = TopologyCheckEnum::NoHandles;
  static constexpr TopologyCheckEnum Strict = TopologyCheckEnum::Strict;
#endif
 
  itkSetEnumMacro(TopologyCheck, TopologyCheckEnum);
  itkGetConstReferenceMacro(TopologyCheck, TopologyCheckEnum);
  itkSetObjectMacro(TrialPoints, NodePairContainerType);
  itkGetModifiableObjectMacro(TrialPoints, NodePairContainerType);
  itkSetObjectMacro(AlivePoints, NodePairContainerType);
  itkGetModifiableObjectMacro(AlivePoints, NodePairContainerType);
  itkSetObjectMacro(ProcessedPoints, NodePairContainerType);
  itkGetModifiableObjectMacro(ProcessedPoints, NodePairContainerType);
  itkSetObjectMacro(ForbiddenPoints, NodePairContainerType);
  itkGetModifiableObjectMacro(ForbiddenPoints, NodePairContainerType);
  itkSetObjectMacro(StoppingCriterion, StoppingCriterionType);
  itkGetModifiableObjectMacro(StoppingCriterion, StoppingCriterionType);
 
  itkGetMacro(SpeedConstant, double);
  itkSetMacro(SpeedConstant, double);
 
  itkGetMacro(NormalizationFactor, double);
  itkSetMacro(NormalizationFactor, double);
 
  itkGetMacro(TargetReachedValue, OutputPixelType);
 
  itkSetMacro(CollectPoints, bool);
 
  itkGetConstReferenceMacro(CollectPoints, bool);
  itkBooleanMacro(CollectPoints);
protected:
  FastMarchingBase();
 
  ~FastMarchingBase() override = default;
 
  StoppingCriterionPointer m_StoppingCriterion{};
 
  double m_SpeedConstant{};
  double m_InverseSpeed{};
  double m_NormalizationFactor{};
 
  OutputPixelType m_TargetReachedValue{};
  OutputPixelType m_LargeValue{};
  OutputPixelType m_TopologyValue{};
 
  NodePairContainerPointer m_TrialPoints{};
  NodePairContainerPointer m_AlivePoints{};
  NodePairContainerPointer m_ProcessedPoints{};
  NodePairContainerPointer m_ForbiddenPoints{};
 
  bool m_CollectPoints{};
 
  // PriorityQueuePointer m_Heap;
  using HeapContainerType = std::vector<NodePairType>;
  using NodeComparerType = std::greater<NodePairType>;
 
  using PriorityQueueType = std::priority_queue<NodePairType, HeapContainerType, NodeComparerType>;
 
  PriorityQueueType m_Heap{};
 
  TopologyCheckEnum m_TopologyCheck{};
 
  virtual IdentifierType
  GetTotalNumberOfNodes() const = 0;
 
  virtual const OutputPixelType
  GetOutputValue(OutputDomainType * oDomain, const NodeType & iNode) const = 0;
 
  virtual void
  SetOutputValue(OutputDomainType * oDomain, const NodeType & iNode, const OutputPixelType & iValue) = 0;
 
  virtual unsigned char
  GetLabelValueForGivenNode(const NodeType & iNode) const = 0;
 
  virtual void
  SetLabelValueForGivenNode(const NodeType & iNode, const LabelType & iLabel) = 0;
 
  virtual void
  UpdateNeighbors(OutputDomainType * oDomain, const NodeType & iNode) = 0;
 
  virtual void
  UpdateValue(OutputDomainType * oDomain, const NodeType & iNode) = 0;
 
  virtual bool
  CheckTopology(OutputDomainType * oDomain, const NodeType & iNode) = 0;
 
  void
  Initialize(OutputDomainType * oDomain);
 
  virtual void
  InitializeOutput(OutputDomainType * oDomain) = 0;
 
  void
  GenerateData() override;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
};
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkFastMarchingBase.hxx"
#endif
 
#endif