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
|
/*=========================================================================
*
* 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 itkCollidingFrontsImageFilter_h
#define itkCollidingFrontsImageFilter_h
#include "itkFastMarchingUpwindGradientImageFilter.h"
#include "itkImageToImageFilter.h"
namespace itk
{
/** \class CollidingFrontsImageFilter
*
* \brief Selects a region of space where two independent fronts run towards
* each other.
*
* The filter can be used to quickly segment anatomical structures (e.g. for
* level set initialization).
*
* The filter uses two instances of FastMarchingUpwindGradientImageFilter to
* compute the gradients of arrival times of two wavefronts propagating from
* two sets of seeds. The input of the filter is used as the speed of the two
* wavefronts. The output is the dot product between the two gradient vector
* fields.
*
* The filter works on the following basic idea. In the regions where the dot
* product between the two gradient fields is negative, the two fronts
* propagate in opposite directions. In the regions where the dot product is
* positive, the two fronts propagate in the same direction. This can be used
* to extract the region of space between two sets of points.
*
* If StopOnTargets is On, then each front will stop as soon as all seeds of
* the other front have been reached. This can markedly speed up the execution
* of the filter, since wave propagation does not take place on the complete
* image.
*
* Optionally, a connectivity criterion can be applied to the resulting dot
* product image. In this case, the only negative region in the output image is
* the one connected to the seeds.
*
* \author Luca Antiga Ph.D. Biomedical Technologies Laboratory,
* Bioengineering Department, Mario Negri Institute, Italy.
*
* \ingroup ITKLevelSets
*/
template< typename TInputImage, typename TOutputImage >
class CollidingFrontsImageFilter:
public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
/** Standard class typedefs. */
typedef CollidingFrontsImageFilter Self;
typedef ImageToImageFilter< TInputImage, TOutputImage > 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(CollidingFrontsImageFilter, ImageToImageFilter);
/** Extract some information from the image types. Dimensionality
* of the two images is assumed to be the same. */
typedef typename TOutputImage::PixelType OutputPixelType;
typedef typename TInputImage::PixelType InputPixelType;
typedef typename NumericTraits< InputPixelType >::RealType RealType;
/** Extract some information from the image types. Dimensionality
* of the two images is assumed to be the same. */
itkStaticConstMacro(ImageDimension, unsigned int,
TOutputImage::ImageDimension);
/** Image typedef support */
typedef TInputImage InputImageType;
typedef TInputImage SpeedImageType;
typedef typename InputImageType::Pointer InputImagePointer;
typedef TOutputImage OutputImageType;
typedef TOutputImage LevelSetImageType;
typedef typename OutputImageType::Pointer OutputImagePointer;
/** Superclass typedefs. */
typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
/** FastMarchingUpwindGradientImageFilter typedefs. */
typedef itk::FastMarchingUpwindGradientImageFilter< LevelSetImageType,
SpeedImageType > FastMarchingUpwindGradientImageFilterType;
/** Typedef support of level set method types. */
typedef typename FastMarchingUpwindGradientImageFilterType::PixelType
PixelType;
typedef typename FastMarchingUpwindGradientImageFilterType::NodeType
NodeType;
typedef typename FastMarchingUpwindGradientImageFilterType::NodeContainer
NodeContainer;
typedef typename FastMarchingUpwindGradientImageFilterType::NodeContainerPointer
NodeContainerPointer;
typedef typename FastMarchingUpwindGradientImageFilterType::GradientImageType
GradientImageType;
typedef typename FastMarchingUpwindGradientImageFilterType::IndexType IndexType;
/** Set the container of Seed Points representing the first initial front.
* Seed points are represented as a VectorContainer of LevelSetNodes. */
void SetSeedPoints1(NodeContainer *points)
{
m_SeedPoints1 = points;
this->Modified();
}
/** Get the container of Seed Points representing the first initial front. */
NodeContainerPointer GetSeedPoints1()
{ return m_SeedPoints1; }
/** Set the container of Seed Points representing the second initial front.
* Seed points are represented as a VectorContainer of LevelSetNodes. */
void SetSeedPoints2(NodeContainer *points)
{
m_SeedPoints2 = points;
this->Modified();
}
/** Get the container of Seed Points representing the second initial front. */
NodeContainerPointer GetSeedPoints2()
{ return m_SeedPoints2; }
itkSetMacro(NegativeEpsilon, double);
itkGetConstMacro(NegativeEpsilon, double);
itkSetMacro(ApplyConnectivity, bool);
itkGetConstMacro(ApplyConnectivity, bool);
itkBooleanMacro(ApplyConnectivity);
itkSetMacro(StopOnTargets, bool);
itkGetConstMacro(StopOnTargets, bool);
itkBooleanMacro(StopOnTargets);
#ifdef ITK_USE_CONCEPT_CHECKING
// Begin concept checking
itkConceptMacro( InputHasNumericTraitsCheck,
( Concept::HasNumericTraits< InputPixelType > ) );
// End concept checking
#endif
protected:
CollidingFrontsImageFilter();
virtual ~CollidingFrontsImageFilter() {}
void GenerateData() ITK_OVERRIDE;
void PrintSelf(std::ostream &, Indent) const ITK_OVERRIDE;
private:
CollidingFrontsImageFilter(const Self &) ITK_DELETE_FUNCTION;
void operator=(const Self &) ITK_DELETE_FUNCTION;
NodeContainerPointer m_SeedPoints1;
NodeContainerPointer m_SeedPoints2;
bool m_StopOnTargets;
bool m_ApplyConnectivity;
double m_NegativeEpsilon;
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkCollidingFrontsImageFilter.hxx"
#endif
#endif
|
