libinsighttoolkit3-dev 3.20.1-1 / usr / include / InsightToolkit / Algorithms / itkCannySegmentationLevelSetFunction.h

This file is indexed.

/usr/include/InsightToolkit/Algorithms/itkCannySegmentationLevelSetFunction.h is in libinsighttoolkit3-dev 3.20.1-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    itkCannySegmentationLevelSetFunction.h
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkCannySegmentationLevelSetFunction_h
#define __itkCannySegmentationLevelSetFunction_h

#include "itkSegmentationLevelSetFunction.h"
#include "itkCastImageFilter.h"
#include "itkCannyEdgeDetectionImageFilter.h"
#include "itkDanielssonDistanceMapImageFilter.h"

namespace itk {

/** \class CannySegmentationLevelSetFunction
 * \brief A refinement of the standard level-set function which computes a
 * speed term and advection term based on pseudo-Canny edges.  See
 * CannySegmentationLevelSetImageFilter for complete information.
 */
template <class TImageType, class TFeatureImageType = TImageType>
class ITK_EXPORT CannySegmentationLevelSetFunction
  : public SegmentationLevelSetFunction<TImageType, TFeatureImageType>
{
public:
  /** Standard class typedefs. */
  typedef CannySegmentationLevelSetFunction  Self;
  typedef SegmentationLevelSetFunction<TImageType, TFeatureImageType>
                                             Superclass;
  typedef SmartPointer<Self>                 Pointer;
  typedef SmartPointer<const Self>           ConstPointer;
  typedef TFeatureImageType                  FeatureImageType;

  /** Method for creation through the object factory. */
  itkNewMacro(Self);

  /** Run-time type information (and related methods) */
  itkTypeMacro( CannySegmentationLevelSetFunction, SegmentationLevelSetFunction );

  /** Extract some parameters from the superclass. */
  typedef typename Superclass::ImageType         ImageType;
  typedef typename Superclass::ScalarValueType   ScalarValueType;
  typedef typename Superclass::VectorImageType   VectorImageType;
  typedef typename Superclass::FeatureScalarType FeatureScalarType;
  typedef typename Superclass::RadiusType        RadiusType;

  /** Extract some parameters from the superclass. */
  itkStaticConstMacro(ImageDimension, unsigned int,
                      Superclass::ImageDimension);

  /** */
  void SetThreshold(ScalarValueType v)
    { m_Threshold = v; }
  ScalarValueType GetThreshold() const
    { return m_Threshold; }

  /** */
  void SetVariance(double v)
    { m_Variance = v; }
  double GetVariance() const
    { return m_Variance; }

  /** Compute the Speed Image. The Speed Image is the distance to the
      canny edges. */
  virtual void CalculateSpeedImage();

  /** Compute the advection image. The Advection Image is the gradeint
      image attenuated with the distance to the canny edges. */
  virtual void CalculateAdvectionImage();

  /** Compute the distance image. This is the distance to the canny
   * edges. */
  virtual void CalculateDistanceImage();

  virtual void Initialize(const RadiusType &r)
    {
    Superclass::Initialize(r);
    
    this->SetAdvectionWeight(-1.0 * NumericTraits<ScalarValueType>::One);
    this->SetPropagationWeight(-1.0 * NumericTraits<ScalarValueType>::One);
    this->SetCurvatureWeight(NumericTraits<ScalarValueType>::One);
    }

  ImageType *GetCannyImage()
    { return m_Canny->GetOutput(); }

protected:
  CannySegmentationLevelSetFunction()
    {
    m_Variance = 0.0;
    m_Threshold = NumericTraits<ScalarValueType>::Zero;
    m_Caster = CastImageFilter<FeatureImageType,ImageType>::New();
    m_Canny = CannyEdgeDetectionImageFilter<ImageType,ImageType>::New();
    m_Distance = DanielssonDistanceMapImageFilter<ImageType,ImageType>::New();
    }
  virtual ~CannySegmentationLevelSetFunction() {}

  CannySegmentationLevelSetFunction(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

private:
  ScalarValueType m_Variance;
  double          m_Threshold;

  typename CannyEdgeDetectionImageFilter<ImageType,ImageType>::Pointer m_Canny;

  typename DanielssonDistanceMapImageFilter<ImageType,ImageType>::Pointer m_Distance;

  typename CastImageFilter<FeatureImageType, ImageType>::Pointer m_Caster;

  
};
  
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkCannySegmentationLevelSetFunction.txx"
#endif

#endif

APT Browse - Built by Thomas Orozco.