itkFastMarchingImageFilter.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 __itkFastMarchingImageFilter_h
#define __itkFastMarchingImageFilter_h

#include "itkImageToImageFilter.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkLevelSet.h"
#include "vnl/vnl_math.h"

#include <functional>
#include <queue>

namespace itk
{
template<
  class TLevelSet,
  class TSpeedImage = Image< float, ::itk::GetImageDimension< TLevelSet >::ImageDimension > >
class ITK_EXPORT FastMarchingImageFilter:
  public ImageToImageFilter< TSpeedImage, TLevelSet >
{
public:
  typedef FastMarchingImageFilter    Self;
  typedef ImageSource< TLevelSet >   Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(FastMarchingImageFilter, ImageSource);

  typedef LevelSetTypeDefault< TLevelSet >            LevelSetType;
  typedef typename LevelSetType::LevelSetImageType    LevelSetImageType;
  typedef typename LevelSetType::LevelSetPointer      LevelSetPointer;
  typedef typename LevelSetType::PixelType            PixelType;
  typedef typename LevelSetType::NodeType             NodeType;
  typedef typename NodeType::IndexType                NodeIndexType;
  typedef typename LevelSetType::NodeContainer        NodeContainer;
  typedef typename LevelSetType::NodeContainerPointer NodeContainerPointer;
  typedef typename LevelSetImageType::SizeType        OutputSizeType;
  typedef typename LevelSetImageType::RegionType      OutputRegionType;
  typedef typename LevelSetImageType::SpacingType     OutputSpacingType;
  typedef typename LevelSetImageType::DirectionType   OutputDirectionType;
  typedef typename LevelSetImageType::PointType       OutputPointType;

  class AxisNodeType:public NodeType
  {
public:
    int GetAxis() const { return m_Axis; }
    void SetAxis(int axis) { m_Axis = axis; }
    const AxisNodeType & operator=(const NodeType & node)
    { this->NodeType::operator=(node); return *this; }
private:
    int m_Axis;
  };

  typedef TSpeedImage SpeedImageType;

  typedef typename SpeedImageType::Pointer      SpeedImagePointer;
  typedef typename SpeedImageType::ConstPointer SpeedImageConstPointer;

  itkStaticConstMacro(SetDimension, unsigned int,
                      LevelSetType::SetDimension);
  itkStaticConstMacro(SpeedImageDimension, unsigned int,
                      SpeedImageType::ImageDimension);

  typedef Index< itkGetStaticConstMacro(SetDimension) > IndexType;

  enum LabelType { FarPoint = 0, AlivePoint,
                   TrialPoint, InitialTrialPoint, OutsidePoint };

  typedef Image< unsigned char, itkGetStaticConstMacro(SetDimension) > LabelImageType;

  typedef typename LabelImageType::Pointer LabelImagePointer;

  template< typename TPixel >
  void SetBinaryMask( Image< TPixel, SetDimension >* iImage )
    {
    typedef Image< TPixel, SetDimension > InternalImageType;
    typedef ImageRegionConstIteratorWithIndex< InternalImageType >
        InternalRegionIterator;
    InternalRegionIterator b_it( iImage, iImage->GetLargestPossibleRegion() );
    b_it.GoToBegin();

    TPixel zero_value = NumericTraits< TPixel >::Zero;
    size_t NumberOfPoints = 0;

    NodeType node;
    node.SetValue( 0. );

    while( !b_it.IsAtEnd() )
      {
      if( b_it.Get() == zero_value )
        {
        if( NumberOfPoints == 0 )
          {
          m_OutsidePoints = NodeContainer::New();
          }
        node.SetIndex( b_it.GetIndex() );
        m_OutsidePoints->InsertElement( NumberOfPoints++, node );

        }
      ++b_it;
      }
    this->Modified();
    }

  void SetOutsidePoints(NodeContainer *points)
  {
    m_OutsidePoints = points;
    this->Modified();
  }

  void SetAlivePoints(NodeContainer *points)
  {
    m_AlivePoints = points;
    this->Modified();
  }

  NodeContainerPointer GetAlivePoints()
  {
    return m_AlivePoints;
  }

  void SetTrialPoints(NodeContainer *points)
  {
    m_TrialPoints = points;
    this->Modified();
  }

  NodeContainerPointer GetTrialPoints()
  {
    return m_TrialPoints;
  }

  LabelImagePointer GetLabelImage() const
  {
    return m_LabelImage;
  }

  void SetSpeedConstant(double value)
  {
    m_SpeedConstant = value;
    m_InverseSpeed = -1.0 * vnl_math_sqr(1.0 / m_SpeedConstant);
    this->Modified();
  }

  itkGetConstReferenceMacro(SpeedConstant, double);

  itkSetMacro(NormalizationFactor, double);
  itkGetConstMacro(NormalizationFactor, double);

  itkSetMacro(StoppingValue, double);

  itkGetConstReferenceMacro(StoppingValue, double);

  itkSetMacro(CollectPoints, bool);

  itkGetConstReferenceMacro(CollectPoints, bool);
  itkBooleanMacro(CollectPoints);

  NodeContainerPointer GetProcessedPoints() const
  {
    return m_ProcessedPoints;
  }

  virtual void SetOutputSize(const OutputSizeType & size)
  { m_OutputRegion = size; }
  virtual OutputSizeType GetOutputSize() const
  { return m_OutputRegion.GetSize(); }
  itkSetMacro(OutputRegion, OutputRegionType);
  itkGetConstReferenceMacro(OutputRegion, OutputRegionType);
  itkSetMacro(OutputSpacing, OutputSpacingType);
  itkGetConstReferenceMacro(OutputSpacing, OutputSpacingType);
  itkSetMacro(OutputDirection, OutputDirectionType);
  itkGetConstReferenceMacro(OutputDirection, OutputDirectionType);
  itkSetMacro(OutputOrigin, OutputPointType);
  itkGetConstReferenceMacro(OutputOrigin, OutputPointType);
  itkSetMacro(OverrideOutputInformation, bool);
  itkGetConstReferenceMacro(OverrideOutputInformation, bool);
  itkBooleanMacro(OverrideOutputInformation);

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro( SameDimensionCheck,
                   ( Concept::SameDimension< SetDimension, SpeedImageDimension > ) );
  itkConceptMacro( SpeedConvertibleToDoubleCheck,
                   ( Concept::Convertible< typename TSpeedImage::PixelType, double > ) );
  itkConceptMacro( DoubleConvertibleToLevelSetCheck,
                   ( Concept::Convertible< double, PixelType > ) );
  itkConceptMacro( LevelSetOStreamWritableCheck,
                   ( Concept::OStreamWritable< PixelType > ) );

#endif
protected:
  FastMarchingImageFilter();
  ~FastMarchingImageFilter(){}
  void PrintSelf(std::ostream & os, Indent indent) const;

  virtual void Initialize(LevelSetImageType *);

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

  virtual double UpdateValue(const IndexType & index,
                             const SpeedImageType *, LevelSetImageType *);

  const AxisNodeType & GetNodeUsedInCalculation(unsigned int idx) const
  { return m_NodesUsed[idx]; }

  void GenerateData();

  virtual void GenerateOutputInformation();

  virtual void EnlargeOutputRequestedRegion(DataObject *output);

  itkGetConstReferenceMacro(LargeValue, PixelType);

  OutputRegionType m_BufferedRegion;
  typedef typename LevelSetImageType::IndexType LevelSetIndexType;
  LevelSetIndexType m_StartIndex;
  LevelSetIndexType m_LastIndex;

  itkGetConstReferenceMacro(StartIndex, LevelSetIndexType);
  itkGetConstReferenceMacro(LastIndex, LevelSetIndexType);
private:
  FastMarchingImageFilter(const Self &); //purposely not implemented
  void operator=(const Self &);          //purposely not implemented

  NodeContainerPointer m_AlivePoints;
  NodeContainerPointer m_TrialPoints;
  NodeContainerPointer m_OutsidePoints;

  LabelImagePointer m_LabelImage;

  double m_SpeedConstant;
  double m_InverseSpeed;
  double m_StoppingValue;

  bool                 m_CollectPoints;
  NodeContainerPointer m_ProcessedPoints;

  OutputRegionType    m_OutputRegion;
  OutputPointType     m_OutputOrigin;
  OutputSpacingType   m_OutputSpacing;
  OutputDirectionType m_OutputDirection;
  bool                m_OverrideOutputInformation;

  typename LevelSetImageType::PixelType m_LargeValue;
  AxisNodeType m_NodesUsed[SetDimension];

  typedef std::vector< AxisNodeType >  HeapContainer;
  typedef std::greater< AxisNodeType > NodeComparer;
  typedef std::priority_queue< AxisNodeType, HeapContainer, NodeComparer >
  HeapType;

  HeapType m_TrialHeap;

  double m_NormalizationFactor;
};
} // namespace itk

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

#endif