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
|
/*=========================================================================
*
* 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.
*
*=========================================================================*/
#include "itkBSplineTransform.h"
#include "itkBSplineTransformParametersAdaptor.h"
int itkBSplineTransformParametersAdaptorTest(int, char * [] )
{
const unsigned int SpaceDimension = 3;
const unsigned int SplineOrder = 3;
typedef double CoordinateRepType;
typedef itk::BSplineTransform<CoordinateRepType, SpaceDimension, SplineOrder> TransformType;
/**
* Define the transformation domain
*/
typedef TransformType::OriginType OriginType;
OriginType origin;
origin.Fill( 5.0 );
typedef TransformType::PhysicalDimensionsType PhysicalDimensionsType;
PhysicalDimensionsType dimensions;
dimensions.Fill( 100 );
typedef TransformType::MeshSizeType MeshSizeType;
MeshSizeType meshSize;
meshSize.Fill( 10 );
typedef TransformType::DirectionType DirectionType;
DirectionType direction;
direction.SetIdentity();
/**
* Instantiate a transform
*/
TransformType::Pointer transform = TransformType::New();
transform->SetTransformDomainOrigin( origin );
transform->SetTransformDomainPhysicalDimensions( dimensions );
transform->SetTransformDomainMeshSize( meshSize );
transform->SetTransformDomainDirection( direction );
/**
* Allocate memory for the parameters
*/
typedef TransformType::ParametersType ParametersType;
unsigned long numberOfParameters = transform->GetNumberOfParameters();
ParametersType parameters( numberOfParameters );
parameters.Fill( itk::NumericTraits<ParametersType::ValueType>::ZeroValue());
/**
* Set the parameters in the transform
*/
transform->SetParameters( parameters );
typedef TransformType::ImageType CoefficientImageType;
CoefficientImageType::IndexType index;
index.Fill( 5 );
transform->GetCoefficientImages()[0]->SetPixel( index, 5.0 );
TransformType::InputPointType point;
point.Fill( 50.0 );
TransformType::OutputPointType outputPointBeforeAdapt = transform->TransformPoint( point );
/**
* Instantiate the adaptor
* we keep the transform domain definition the same except we increase
* the mesh size which increases the number of control points in the grid.
*/
TransformType::MeshSizeType requiredMeshSize;
for( unsigned int d = 0; d < SpaceDimension; d++ )
{
requiredMeshSize[d] = ( d + 1 ) * meshSize[d];
}
TransformType::SizeType gridSizeBefore =
transform->GetCoefficientImages()[0]->GetLargestPossibleRegion().GetSize();
typedef itk::BSplineTransformParametersAdaptor<TransformType> AdaptorType;
AdaptorType::Pointer adaptor = AdaptorType::New();
adaptor->SetTransform( transform );
adaptor->SetRequiredTransformDomainMeshSize( requiredMeshSize );
adaptor->SetRequiredTransformDomainOrigin( transform->GetTransformDomainOrigin() );
adaptor->SetRequiredTransformDomainDirection( transform->GetTransformDomainDirection() );
adaptor->SetRequiredTransformDomainPhysicalDimensions( transform->GetTransformDomainPhysicalDimensions() );
try
{
adaptor->AdaptTransformParameters();
}
catch(...)
{
std::cerr << "Error in adapting transform." << std::endl;
return EXIT_FAILURE;
}
ParametersType fixedParameters = adaptor->GetRequiredFixedParameters();
std::cout << "Fixed parameters: " << fixedParameters << std::endl;
adaptor->SetRequiredFixedParameters( fixedParameters );
if( adaptor->GetRequiredTransformDomainMeshSize() != transform->GetTransformDomainMeshSize() )
{
std::cerr << "required transform domain mesh size conversion is incorrect." << std::endl;
return EXIT_FAILURE;
}
if( adaptor->GetRequiredTransformDomainOrigin() != transform->GetTransformDomainOrigin() )
{
std::cerr << "required transform domain origin conversion is incorrect." << std::endl;
return EXIT_FAILURE;
}
if( adaptor->GetRequiredTransformDomainDirection() != transform->GetTransformDomainDirection() )
{
std::cerr << "required transform domain direction conversion is incorrect." << std::endl;
return EXIT_FAILURE;
}
if( adaptor->GetRequiredTransformDomainPhysicalDimensions() != transform->GetTransformDomainPhysicalDimensions() )
{
std::cerr << "required transform domain physical dimensions conversion is incorrect." << std::endl;
return EXIT_FAILURE;
}
TransformType::SizeType gridSizeAfter =
transform->GetCoefficientImages()[0]->GetLargestPossibleRegion().GetSize();
TransformType::OutputPointType outputPointAfterAdapt = transform->TransformPoint( point );
std::cout << "Grid size before: " << gridSizeBefore << std::endl;
std::cout << "Grid size after: " << gridSizeAfter << std::endl;
std::cout << point << " to (before) " << outputPointBeforeAdapt << std::endl;
std::cout << point << " to (after) " << outputPointAfterAdapt << std::endl;
if( outputPointBeforeAdapt.EuclideanDistanceTo( outputPointAfterAdapt ) > 1e-6 )
{
std::cerr << "output points don't match up before and after adapt call." << std::endl;
return EXIT_FAILURE;
}
adaptor->Print( std::cout, 5 );
return EXIT_SUCCESS;
}
|
