itkFastMarchingUpwindGradientImageFilter.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 itkFastMarchingUpwindGradientImageFilter_h
#define itkFastMarchingUpwindGradientImageFilter_h

#include "itkFastMarchingImageFilter.h"
#include "itkImage.h"

namespace itk
{
template<
  typename TLevelSet,
  typename TSpeedImage = Image< float,  TLevelSet ::ImageDimension > >
class ITK_TEMPLATE_EXPORT FastMarchingUpwindGradientImageFilter:
  public FastMarchingImageFilter< TLevelSet, TSpeedImage >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(FastMarchingUpwindGradientImageFilter);

  using Self = FastMarchingUpwindGradientImageFilter;
  using Superclass = FastMarchingImageFilter< TLevelSet, TSpeedImage >;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;

  itkNewMacro(Self);

  itkTypeMacro(FastMarchingUpwindGradientImageFilter, FastMarchingImageFilter);

  using LevelSetType = typename Superclass::LevelSetType;
  using SpeedImageType = typename Superclass::SpeedImageType;
  using LevelSetImageType = typename Superclass::LevelSetImageType;
  using LevelSetPointer = typename Superclass::LevelSetPointer;
  using SpeedImageConstPointer = typename Superclass::SpeedImageConstPointer;
  using LabelImageType = typename Superclass::LabelImageType;
  using PixelType = typename Superclass::PixelType;
  using AxisNodeType = typename Superclass::AxisNodeType;
  using NodeType = typename Superclass::NodeType;
  using NodeContainer = typename Superclass::NodeContainer;
  using NodeContainerPointer = typename Superclass::NodeContainerPointer;

  using IndexType = typename Superclass::IndexType;
  using OutputSpacingType = typename Superclass::OutputSpacingType;
  using LevelSetIndexType = typename Superclass::LevelSetIndexType;

  using PointType = typename Superclass::OutputPointType;

  static constexpr unsigned int SetDimension = Superclass::SetDimension;

  void SetTargetPoints(NodeContainer *points)
  {
    m_TargetPoints = points;
    this->Modified();
  }

  NodeContainerPointer GetTargetPoints()
  { return m_TargetPoints; }

  NodeContainerPointer GetReachedTargetPoints()
  { return m_ReachedTargetPoints; }

  using GradientPixelType = CovariantVector< PixelType,
                           Self::SetDimension >;

  using GradientImageType = Image< GradientPixelType,
                 Self::SetDimension >;

  using GradientImagePointer = typename GradientImageType::Pointer;

  GradientImagePointer GetGradientImage() const
  { return m_GradientImage; }

  itkSetMacro(GenerateGradientImage, bool);

  itkGetConstReferenceMacro(GenerateGradientImage, bool);
  itkBooleanMacro(GenerateGradientImage);

  itkSetMacro(TargetOffset, double);

  itkGetConstReferenceMacro(TargetOffset, double);

  itkSetMacro(TargetReachedMode, int);
  itkGetConstReferenceMacro(TargetReachedMode, int);
  void SetTargetReachedModeToNoTargets()
  { this->SetTargetReachedMode(NoTargets); }
  void SetTargetReachedModeToOneTarget()
  { this->SetTargetReachedMode(OneTarget); }
  void SetTargetReachedModeToSomeTargets(SizeValueType numberOfTargets)
  {
    this->SetTargetReachedMode(SomeTargets);
    m_NumberOfTargets = numberOfTargets;
  }

  void SetTargetReachedModeToAllTargets()
  { this->SetTargetReachedMode(AllTargets); }

  itkGetConstReferenceMacro(NumberOfTargets, SizeValueType);

  itkGetConstReferenceMacro(TargetValue, double);

  enum {
    NoTargets,
    OneTarget,
    SomeTargets,
    AllTargets
    };

#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro( LevelSetDoubleDivisionOperatorsCheck,
                   ( Concept::DivisionOperators< typename TLevelSet::PixelType, double > ) );
  itkConceptMacro( LevelSetDoubleDivisionAndAssignOperatorsCheck,
                   ( Concept::DivisionAndAssignOperators< typename TLevelSet::PixelType, double > ) );
  // End concept checking
#endif

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

  void Initialize(LevelSetImageType *) override;

  void GenerateData() override;

  void UpdateNeighbors(const IndexType & index,
                               const SpeedImageType *, LevelSetImageType *) override;

  virtual void ComputeGradient(const IndexType & index,
                               const LevelSetImageType *output,
                               const LabelImageType *labelImage,
                               GradientImageType *gradientImage);

private:
  NodeContainerPointer m_TargetPoints;
  NodeContainerPointer m_ReachedTargetPoints;

  GradientImagePointer m_GradientImage;

  bool m_GenerateGradientImage;

  double m_TargetOffset;

  int m_TargetReachedMode;

  double m_TargetValue;

  SizeValueType m_NumberOfTargets;
};
} // namespace itk

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

#endif