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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: itkMultiScaleHessianBasedMeasureImageFilter.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 __itkMultiScaleHessianBasedMeasureImageFilter_h
#define __itkMultiScaleHessianBasedMeasureImageFilter_h
#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "itkHessianRecursiveGaussianImageFilter.h"
namespace itk
{
/**\class MultiScaleHessianBasedMeasureImageFilter
* \brief A filter to enhance structures using Hessian eigensystem-based
* measures in a multiscale framework
*
* The filter evaluates a Hessian-based enhancement measure, such as vesselness
* or objectness, at different scale levels. The Hessian-based measure is computed
* from the Hessian image at each scale level and the best response is selected.
*
* Minimum and maximum sigma value can be set using SetMinSigma and SetMaxSigma
* methods respectively. The number of scale levels is set using
* SetNumberOfSigmaSteps method. Exponentially distributed scale levels are
* computed within the bound set by the minimum and maximum sigma values
*
* The filter computes a second output image (accessed by the GetScalesOutput method)
* containing the scales at which each pixel gave the best reponse.
*
* \author Luca Antiga Ph.D. Medical Imaging Unit,
* Bioengineering Deparment, Mario Negri Institute, Italy.
*
* \sa HessianToObjectnessMeasureImageFilter
* \sa Hessian3DToVesselnessMeasureImageFilter
* \sa HessianSmoothed3DToVesselnessMeasureImageFilter
* \sa HessianRecursiveGaussianImageFilter
* \sa SymmetricEigenAnalysisImageFilter
* \sa SymmetricSecondRankTensor
*
* \ingroup IntensityImageFilters TensorObjects
*
*/
template <typename TInputImage,
typename THessianImage,
typename TOutputImage=TInputImage >
class ITK_EXPORT MultiScaleHessianBasedMeasureImageFilter
: public
ImageToImageFilter< TInputImage,TOutputImage >
{
public:
/** Standard class typedefs. */
typedef MultiScaleHessianBasedMeasureImageFilter Self;
typedef ImageToImageFilter<TInputImage,TOutputImage> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef TInputImage InputImageType;
typedef TOutputImage OutputImageType;
typedef THessianImage HessianImageType;
typedef ImageToImageFilter< HessianImageType, OutputImageType > HessianToMeasureFilterType;
typedef typename TInputImage::PixelType InputPixelType;
typedef typename TOutputImage::PixelType OutputPixelType;
typedef typename TOutputImage::RegionType OutputRegionType;
/** Image dimension. */
itkStaticConstMacro(ImageDimension, unsigned int, ::itk::GetImageDimension<InputImageType>::ImageDimension);
/** Types for Scales image */
typedef float ScalesPixelType;
typedef Image<ScalesPixelType, itkGetStaticConstMacro(ImageDimension)> ScalesImageType;
/** Hessian computation filter. */
typedef HessianRecursiveGaussianImageFilter< InputImageType, HessianImageType> HessianFilterType;
/** Update image buffer that holds the best objectness response. This is not redundant from
the output image because the latter may not be of float type, which is required for the comparisons
between responses at different scales. */
typedef Image< double, itkGetStaticConstMacro(ImageDimension) > UpdateBufferType;
typedef typename UpdateBufferType::ValueType BufferValueType;
typedef typename Superclass::DataObjectPointer DataObjectPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Runtime information support. */
itkTypeMacro(MultiScaleHessianBasedMeasureImageFilter,
ImageToImageFilter);
/** Set/Get macros for SigmaMin */
itkSetMacro(SigmaMinimum, double);
itkGetConstMacro(SigmaMinimum, double);
/** Set/Get macros for SigmaMax */
itkSetMacro(SigmaMaximum, double);
itkGetConstMacro(SigmaMaximum, double);
/** Set/Get macros for Number of Scales */
itkSetMacro(NumberOfSigmaSteps, unsigned int);
itkGetConstMacro(NumberOfSigmaSteps, unsigned int);
/** Set/Get HessianToMeasureFilter. This will be a filter that takes
Hessian input image and produces enhanced output scalar image. The filter must derive from
itk::ImageToImage filter */
itkSetObjectMacro( HessianToMeasureFilter, HessianToMeasureFilterType);
itkGetObjectMacro( HessianToMeasureFilter, HessianToMeasureFilterType);
/** Methods to turn on/off flag to inform the filter that the Hessian-based measure
is non-negative (classical measures like Sato's and Frangi's are), hence it has a minimum
at zero. In this case, the update buffer is initialized at zero, and the output scale and Hessian
are zero in case the Hessian-based measure returns zero for all scales. Otherwise, the minimum
output scale and Hessian are the ones obtained at scale SigmaMinimum. On by default.
*/
itkSetMacro(NonNegativeHessianBasedMeasure,bool);
itkGetConstMacro(NonNegativeHessianBasedMeasure,bool);
itkBooleanMacro(NonNegativeHessianBasedMeasure);
typedef enum { EquispacedSigmaSteps = 0,
LogarithmicSigmaSteps = 1 } SigmaStepMethodType;
/** Set/Get the method used to generate scale sequence (Equispaced
* or Logarithmic) */
itkSetMacro(SigmaStepMethod, SigmaStepMethodType);
itkGetConstMacro(SigmaStepMethod, SigmaStepMethodType);
/**Set equispaced sigma step method */
void SetSigmaStepMethodToEquispaced();
/**Set logartihmic sigma step method */
void SetSigmaStepMethodToLogarithmic();
/** Get the image containing the Hessian computed at the best
* response scale */
const HessianImageType* GetHessianOutput() const;
/** Get the image containing the scales at which each pixel gave the
* best response */
const ScalesImageType* GetScalesOutput() const;
void EnlargeOutputRequestedRegion (DataObject *);
/** Methods to turn on/off flag to generate an image with scale values at
* each pixel for the best vesselness response */
itkSetMacro(GenerateScalesOutput,bool);
itkGetConstMacro(GenerateScalesOutput,bool);
itkBooleanMacro(GenerateScalesOutput);
/** Methods to turn on/off flag to generate an image with hessian values at
* each pixel for the best vesselness response */
itkSetMacro(GenerateHessianOutput,bool);
itkGetConstMacro(GenerateHessianOutput,bool);
itkBooleanMacro(GenerateHessianOutput);
/** This is overloaded to create the Scales and Hessian output images */
virtual DataObjectPointer MakeOutput(unsigned int idx);
protected:
MultiScaleHessianBasedMeasureImageFilter();
~MultiScaleHessianBasedMeasureImageFilter() {};
void PrintSelf(std::ostream& os, Indent indent) const;
/** Generate Data */
void GenerateData( void );
private:
void UpdateMaximumResponse(double sigma);
double ComputeSigmaValue(int scaleLevel);
void AllocateUpdateBuffer();
//purposely not implemented
MultiScaleHessianBasedMeasureImageFilter(const Self&);
void operator=(const Self&); //purposely not implemented
bool m_NonNegativeHessianBasedMeasure;
double m_SigmaMinimum;
double m_SigmaMaximum;
unsigned int m_NumberOfSigmaSteps;
SigmaStepMethodType m_SigmaStepMethod;
typename HessianToMeasureFilterType::Pointer m_HessianToMeasureFilter;
typename HessianFilterType::Pointer m_HessianFilter;
typename UpdateBufferType::Pointer m_UpdateBuffer;
bool m_GenerateScalesOutput;
bool m_GenerateHessianOutput;
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMultiScaleHessianBasedMeasureImageFilter.txx"
#endif
#endif
|
