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
|
/*=========================================================================
*
* 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.
*
*=========================================================================*/
#include "itkBinaryThresholdSpatialFunction.h"
#include "itkSphereSignedDistanceFunction.h"
#include "itkFloodFilledSpatialFunctionConditionalConstIterator.h"
#include "itkTestingMacros.h"
/**
* This module tests the sphereality of the
* BinaryThresholdSpatialFunction class.
*
* In particular, it creates a SphereSignedDistanceFunction object
* connect it to a BinaryThresholdSpatialFunction class.
*
* The sphere parameters are set at radius of 5 and center of (0,0).
* Membership (i.e. with user specified threshold) is evaluated at
* several point and compared to expected values.
* The test fails if the evaluated results is not the same as expected
* results.
*
*/
int
itkBinaryThresholdSpatialFunctionTest(int, char *[])
{
using CoordRep = double;
constexpr unsigned int Dimension = 2;
using SphereFunctionType = itk::SphereSignedDistanceFunction<CoordRep, Dimension>;
using FunctionType = itk::BinaryThresholdSpatialFunction<SphereFunctionType>;
using PointType = SphereFunctionType::PointType;
using ParametersType = SphereFunctionType::ParametersType;
auto sphere = SphereFunctionType::New();
// We must initialize the sphere before use
sphere->Initialize();
ParametersType parameters(sphere->GetNumberOfParameters());
parameters.Fill(0.0);
parameters[0] = 5.0;
sphere->SetParameters(parameters);
std::cout << "SphereParameters: " << sphere->GetParameters() << std::endl;
// Create a binary threshold function
auto function = FunctionType::New();
ITK_EXERCISE_BASIC_OBJECT_METHODS(function, BinaryThresholdSpatialFunction, SpatialFunction);
// Connect the sphere function
function->SetFunction(sphere);
// Set the thresholds
double lowerThreshold = -3.0;
double upperThreshold = 4.0;
function->SetLowerThreshold(lowerThreshold);
ITK_TEST_SET_GET_VALUE(lowerThreshold, function->GetLowerThreshold());
function->SetUpperThreshold(upperThreshold);
ITK_TEST_SET_GET_VALUE(upperThreshold, function->GetUpperThreshold());
PointType point;
for (double p = 0.0; p < 10.0; p += 1.0)
{
point.Fill(p);
FunctionType::OutputType output = function->Evaluate(point);
std::cout << "f(" << point << ") = " << output;
std::cerr << " [" << function->GetFunction()->Evaluate(point);
std::cout << "] " << std::endl;
// Check results
CoordRep val = p * std::sqrt(2.0) - parameters[0];
bool expected = (lowerThreshold <= val && upperThreshold >= val);
if (output != expected)
{
std::cerr << "Test failed!" << std::endl;
std::cerr << "Error at point: " << point << std::endl;
std::cerr << "Expected function value is: " << expected << ", but got: " << output << std::endl;
return EXIT_FAILURE;
}
}
//
// In the following, we demsonstrate how BinaryThresholdSpatialFunction
// can be used to iterate over pixels whose signed distance is
// within [lowerThreshold, upperThreshold] of the zero level set defining
// the sphere.
//
// Set up a dummy image
using ImageType = itk::Image<unsigned char, Dimension>;
auto image = ImageType::New();
ImageType::SizeType size;
size.Fill(10);
image->SetRegions(size);
image->Allocate();
image->FillBuffer(255);
// Set up the conditional iterator
using IteratorType = itk::FloodFilledSpatialFunctionConditionalConstIterator<ImageType, FunctionType>;
IteratorType iterator(image, function);
iterator.SetOriginInclusionStrategy();
// Add a seed that already inside the region
ImageType::IndexType index;
index[0] = 0;
index[1] = 3;
iterator.AddSeed(index);
// Get the seeds and display them
std::cout << "Iterator seeds";
for (auto seed : iterator.GetSeeds())
{
std::cout << ' ' << seed;
}
std::cout << std::endl;
iterator.GoToBegin();
while (!iterator.IsAtEnd())
{
index = iterator.GetIndex();
image->TransformIndexToPhysicalPoint(index, point);
double value = sphere->Evaluate(point);
// Check if value is within range
if (value < lowerThreshold || value > upperThreshold)
{
std::cerr << "Test failed!" << std::endl;
std::cerr << "Error at index: " << index << std::endl;
std::cout << "Point value: " << value << " is not within thresholds [" << lowerThreshold << ", " << upperThreshold
<< ']' << std::endl;
return EXIT_FAILURE;
}
++iterator;
}
std::cout << "Test passed." << std::endl;
return EXIT_SUCCESS;
}
|
