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
132
133
134
135
136
137
138
139
|
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkGradientNDAnisotropicDiffusionFunction.h,v $
Language: C++
Date: $Date: 2008-01-18 20:07:32 $
Version: $Revision: 1.16 $
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 __itkGradientNDAnisotropicDiffusionFunction_h_
#define __itkGradientNDAnisotropicDiffusionFunction_h_
#include "itkScalarAnisotropicDiffusionFunction.h"
#include "itkNeighborhoodAlgorithm.h"
#include "itkNeighborhoodInnerProduct.h"
#include "itkDerivativeOperator.h"
namespace itk {
/** \class GradientNDAnisotropicDiffusionFunction
*
* This class implements an N-dimensional version of the classic Perona-Malik
* anisotropic diffusion equation for scalar-valued images. See
* itkAnisotropicDiffusionFunction for an overview of the anisotropic diffusion
* framework and equation.
*
* \par
* The conductance term for this implementation is chosen as a function of the
* gradient magnitude of the image at each point, reducing the strength of
* diffusion at edge pixels.
*
* \f[C(\mathbf{x}) = e^{-(\frac{\parallel \nabla U(\mathbf{x}) \parallel}{K})^2}\f].
*
* \par
* The numerical implementation of this equation is similar to that described
* in the Perona-Malik paper below, but uses a more robust technique
* for gradient magnitude estimation and has been generalized to N-dimensions.
*
* \par References
* Pietro Perona and Jalhandra Malik, ``Scale-space and edge detection using
* anisotropic diffusion,'' IEEE Transactions on Pattern Analysis Machine
* Intelligence, vol. 12, pp. 629-639, 1990.
*
* \sa AnisotropicDiffusionFunction
* \sa VectorAnisotropicDiffusionFunction
* \sa VectorGradientAnisotropicDiffusionFunction
* \sa CurvatureNDAnisotropicDiffusionFunction
* \ingroup FiniteDifferenceFunctions
* \ingroup ImageEnhancement
*/
template <class TImage>
class ITK_EXPORT GradientNDAnisotropicDiffusionFunction :
public ScalarAnisotropicDiffusionFunction<TImage>
{
public:
/** Standard class typedefs. */
typedef GradientNDAnisotropicDiffusionFunction Self;
typedef ScalarAnisotropicDiffusionFunction<TImage> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods) */
itkTypeMacro( GradientNDAnisotropicDiffusionFunction,
ScalarAnisotropicDiffusionFunction );
/** Inherit some parameters from the superclass type. */
typedef typename Superclass::ImageType ImageType;
typedef typename Superclass::PixelType PixelType;
typedef typename Superclass::PixelRealType PixelRealType;
typedef typename Superclass::TimeStepType TimeStepType;
typedef typename Superclass::RadiusType RadiusType;
typedef typename Superclass::NeighborhoodType NeighborhoodType;
typedef typename Superclass::FloatOffsetType FloatOffsetType;
/** Inherit some parameters from the superclass type. */
itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);
/** Compute the equation value. */
virtual PixelType ComputeUpdate(const NeighborhoodType &neighborhood,
void *globalData,
const FloatOffsetType& offset = FloatOffsetType(0.0)
);
/** This method is called prior to each iteration of the solver. */
virtual void InitializeIteration()
{
m_K = static_cast<PixelType>(this->GetAverageGradientMagnitudeSquared() *
this->GetConductanceParameter() * this->GetConductanceParameter() * -2.0f);
}
protected:
GradientNDAnisotropicDiffusionFunction();
~GradientNDAnisotropicDiffusionFunction() {}
void PrintSelf(std::ostream& os, Indent indent) const
{ Superclass::PrintSelf(os,indent); }
/** Inner product function. */
NeighborhoodInnerProduct<ImageType> m_InnerProduct;
/** Slices for the ND neighborhood. */
std::slice x_slice[ImageDimension];
std::slice xa_slice[ImageDimension][ImageDimension];
std::slice xd_slice[ImageDimension][ImageDimension];
/** Derivative operator. */
DerivativeOperator<PixelType, itkGetStaticConstMacro(ImageDimension)> dx_op;
/** Modified global average gradient magnitude term. */
PixelType m_K;
unsigned long m_Center;
unsigned long m_Stride[ImageDimension];
static double m_MIN_NORM;
private:
GradientNDAnisotropicDiffusionFunction(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
};
}// end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkGradientNDAnisotropicDiffusionFunction.txx"
#endif
#endif
|
