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
|
/*=========================================================================
*
* 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 itkConicShellInteriorExteriorSpatialFunction_h
#define itkConicShellInteriorExteriorSpatialFunction_h
#include "vnl/vnl_vector.h"
#include "itkInteriorExteriorSpatialFunction.h"
#include "itkCovariantVector.h"
namespace itk
{
/**
* \class ConicShellInteriorExteriorSpatialFunction
* \brief Spatial function implementation of a conic shell
*
* We are creating search areas from BoundaryPoint1 in which to look for
* candidate BoundaryPoint2's with which to form core atoms. Assume the
* "worst case" that BoundaryPoint2 is somewhere in that search area pointing
* directly at BoundaryPoint1.
*
* The search area (ConicShell?) from each BoundaryPoint1 has the following
* parameters:
*
* DistanceMax and DistanceMin from the location of the BoundaryPoint
*
* AngleMax from the line along the gradient at the boundary point.
* This is determined in n dimensions by taking the dot product of two vectors,
* (1) the normalized gradient at BoundaryPoint1 and
* (2) the normalized vector from BoundaryPoint1 to BoundaryPoint2.
*
* If the absolute value of that dot product is greater than (1 - epsilon)
* then you are in the ConicShell. This epsilon is the same one determining
* face-to-faceness in the IEEE TMI paper.
*
* The polarity indicates which direction along the gradient of BoundaryPoint1
* the function is to be evaluated.
*
* \ingroup SpatialFunctions
*
*
* \ingroup ITKCommon
*/
template <unsigned int VDimension = 3, typename TInput = Point<double, VDimension>>
class ITK_TEMPLATE_EXPORT ConicShellInteriorExteriorSpatialFunction
: public InteriorExteriorSpatialFunction<VDimension, TInput>
{
public:
ITK_DISALLOW_COPY_AND_MOVE(ConicShellInteriorExteriorSpatialFunction);
/** Standard class type aliases. */
using Self = ConicShellInteriorExteriorSpatialFunction;
using Superclass = InteriorExteriorSpatialFunction<VDimension, TInput>;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(ConicShellInteriorExteriorSpatialFunction);
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Input type for the function. */
using typename Superclass::InputType;
/** Output type for the function. */
using typename Superclass::OutputType;
/** The type of vector used to store the gradient info. */
using GradientType = CovariantVector<double, VDimension>;
/** Evaluates the function at a given position. */
OutputType
Evaluate(const InputType & position) const override;
/** Set/Get the origin of the function. */
itkGetConstMacro(Origin, InputType);
itkSetMacro(Origin, InputType);
/** Set/Get the gradient at the origin of the function. */
GradientType
GetOriginGradient()
{
return m_OriginGradient;
}
void
SetOriginGradient(GradientType grad);
/** Set/Get the minimum search distance. */
itkGetConstMacro(DistanceMin, double);
itkSetMacro(DistanceMin, double);
/** Set/Get the maximum search distance. */
itkGetConstMacro(DistanceMax, double);
itkSetMacro(DistanceMax, double);
/** Set/Get the tolerance of the in/out comparison. */
itkGetConstMacro(Epsilon, double);
itkSetMacro(Epsilon, double);
/** Set/Get direction along the gradient to search.
* Set to true to use the direction that the gradient is pointing;
* set to false for the opposite direction. */
itkGetConstMacro(Polarity, bool);
itkSetMacro(Polarity, bool);
itkBooleanMacro(Polarity);
protected:
ConicShellInteriorExteriorSpatialFunction() = default;
~ConicShellInteriorExteriorSpatialFunction() override = default;
void
PrintSelf(std::ostream & os, Indent indent) const override;
private:
InputType m_Origin{};
GradientType m_OriginGradient{};
double m_DistanceMin{ 0.0 };
double m_DistanceMax{ 0.0 };
double m_Epsilon{ 0.0 };
bool m_Polarity{ false };
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkConicShellInteriorExteriorSpatialFunction.hxx"
#endif
#endif
|
