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 FastMarchingUpwindGradientImageFilter:
  public FastMarchingImageFilter< TLevelSet, TSpeedImage >
{
public:
  typedef FastMarchingUpwindGradientImageFilter             Self;
  typedef FastMarchingImageFilter< TLevelSet, TSpeedImage > Superclass;
  typedef SmartPointer< Self >                              Pointer;
  typedef SmartPointer< const Self >                        ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(FastMarchingUpwindGradientImageFilter, FastMarchingImageFilter);

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

  typedef typename Superclass::IndexType         IndexType;
  typedef typename Superclass::OutputSpacingType OutputSpacingType;
  typedef typename Superclass::LevelSetIndexType LevelSetIndexType;

  typedef typename Superclass::OutputPointType PointType;

  itkStaticConstMacro(SetDimension, unsigned int, Superclass::SetDimension);

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

  NodeContainerPointer GetTargetPoints()
  { return m_TargetPoints; }

  NodeContainerPointer GetReachedTargetPoints()
  { return m_ReachedTargetPoints; }

  typedef CovariantVector< PixelType,
                           itkGetStaticConstMacro(SetDimension) > GradientPixelType;

  typedef Image< GradientPixelType,
                 itkGetStaticConstMacro(SetDimension) > GradientImageType;

  typedef typename GradientImageType::Pointer GradientImagePointer;

  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(){}
  void PrintSelf(std::ostream & os, Indent indent) const;

  virtual void Initialize(LevelSetImageType *);

  void GenerateData();

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

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

private:
  FastMarchingUpwindGradientImageFilter(const Self &); //purposely not
                                                       // implemented
  void operator=(const Self &);                        //purposely not
                                                       // implemented

  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