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
|
/*=========================================================================
*
* Copyright NumFOCUS
*
* 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
*
* https://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 itkFastMarchingQuadEdgeMeshFilterBase_h
#define itkFastMarchingQuadEdgeMeshFilterBase_h
#include "itkFastMarchingBase.h"
#include "itkFastMarchingTraits.h"
namespace itk
{
/**
* \class FastMarchingQuadEdgeMeshFilterBase
\brief Fast Marching Method on QuadEdgeMesh
The speed function is specified by the input mesh. Data associated to each
point is considered as the speed function. The speed function is set using
the method SetInput().
If the speed function is constant and of value one, fast marching results is
an approximate geodesic function from the initial alive points.
Implementation of this class is based on
"Fast Marching Methods on Triangulated Domains", Kimmel, R., and Sethian, J.A.,
Proc. Nat. Acad. Sci., 95, pp. 8341-8435, 1998.
\ingroup ITKFastMarching
*/
template <typename TInput, typename TOutput>
class ITK_TEMPLATE_EXPORT FastMarchingQuadEdgeMeshFilterBase : public FastMarchingBase<TInput, TOutput>
{
public:
ITK_DISALLOW_COPY_AND_MOVE(FastMarchingQuadEdgeMeshFilterBase);
using Self = FastMarchingQuadEdgeMeshFilterBase;
using Superclass = FastMarchingBase<TInput, TOutput>;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
using typename Superclass::Traits;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(FastMarchingQuadEdgeMeshFilterBase);
using InputMeshType = typename Superclass::InputDomainType;
using InputMeshPointer = typename Superclass::InputDomainPointer;
using typename Superclass::InputPixelType;
using InputPointType = typename InputMeshType::PointType;
using InputPointIdentifierType = typename InputMeshType::PointIdentifier;
using OutputMeshType = typename Superclass::OutputDomainType;
using OutputMeshPointer = typename Superclass::OutputDomainPointer;
using typename Superclass::OutputPixelType;
using OutputPointType = typename OutputMeshType::PointType;
using OutputVectorType = typename OutputPointType::VectorType;
using OutputVectorRealType = typename OutputVectorType::RealValueType;
using OutputQEType = typename OutputMeshType::QEType;
using OutputPointIdentifierType = typename OutputMeshType::PointIdentifier;
using OutputPointsContainer = typename OutputMeshType::PointsContainer;
using OutputPointsContainerPointer = typename OutputPointsContainer::Pointer;
using OutputPointsContainerIterator = typename OutputPointsContainer::Iterator;
using OutputPointDataContainer = typename OutputMeshType::PointDataContainer;
using OutputPointDataContainerPointer = typename OutputPointDataContainer::Pointer;
using OutputCellsContainer = typename OutputMeshType::CellsContainer;
using OutputCellsContainerPointer = typename OutputCellsContainer::Pointer;
using OutputCellsContainerConstIterator = typename OutputCellsContainer::ConstIterator;
using OutputCellType = typename OutputMeshType::CellType;
using NodeType = typename Traits::NodeType;
using NodePairType = typename Traits::NodePairType;
using NodePairContainerType = typename Traits::NodePairContainerType;
using NodePairContainerPointer = typename Traits::NodePairContainerPointer;
using NodePairContainerConstIterator = typename Traits::NodePairContainerConstIterator;
// using NodeContainerType = typename Traits::NodeContainerType;
// using NodeContainerPointer = typename Traits::NodeContainerPointer;
// using NodeContainerConstIterator = typename Traits::NodeContainerConstIterator;
using typename Superclass::LabelType;
using NodeLabelMapType = std::map<NodeType, LabelType>;
using NodeLabelMapIterator = typename NodeLabelMapType::iterator;
using NodeLabelMapConstIterator = typename NodeLabelMapType::const_iterator;
protected:
FastMarchingQuadEdgeMeshFilterBase();
~FastMarchingQuadEdgeMeshFilterBase() override = default;
NodeLabelMapType m_Label{};
IdentifierType
GetTotalNumberOfNodes() const override;
void
SetOutputValue(OutputMeshType * oMesh, const NodeType & iNode, const OutputPixelType & iValue) override;
const OutputPixelType
GetOutputValue(OutputMeshType * oMesh, const NodeType & iNode) const override;
unsigned char
GetLabelValueForGivenNode(const NodeType & iNode) const override;
void
SetLabelValueForGivenNode(const NodeType & iNode, const LabelType & iLabel) override;
void
UpdateNeighbors(OutputMeshType * oMesh, const NodeType & iNode) override;
void
UpdateValue(OutputMeshType * oMesh, const NodeType & iNode) override;
const OutputVectorRealType
Solve(OutputMeshType * oMesh,
const NodeType & iId,
const OutputPointType & iCurrentPoint,
const OutputVectorRealType & iF,
const NodeType & iId1,
const OutputPointType & iP1,
const bool iIsFar1,
const OutputVectorRealType iVal1,
const NodeType & iId2,
const OutputPointType & iP2,
const bool iIsFar2,
const OutputVectorRealType & iVal2) const;
const OutputVectorRealType
ComputeUpdate(const OutputVectorRealType & iVal1,
const OutputVectorRealType & iVal2,
const OutputVectorRealType & iNorm1,
const OutputVectorRealType & iSqNorm1,
const OutputVectorRealType & iNorm2,
const OutputVectorRealType & iSqNorm2,
const OutputVectorRealType & iDot,
const OutputVectorRealType & iF) const;
bool
UnfoldTriangle(OutputMeshType * oMesh,
const OutputPointIdentifierType & iId,
const OutputPointType & iP,
const OutputPointIdentifierType & iId1,
const OutputPointType & iP1,
const OutputPointIdentifierType & iId2,
const OutputPointType & iP2,
OutputVectorRealType & oNorm,
OutputVectorRealType & oSqNorm,
OutputVectorRealType & oDot1,
OutputVectorRealType & oDot2,
OutputPointIdentifierType & oId) const;
bool
CheckTopology(OutputMeshType * oMesh, const NodeType & iNode) override;
void
InitializeOutput(OutputMeshType * oMesh) override;
private:
const InputMeshType * m_InputMesh{};
};
} // namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkFastMarchingQuadEdgeMeshFilterBase.hxx"
#endif
#endif // itkFastMarchingQuadEdgeMeshFilterBase_h
|
