MITK-IGT
IGT Extension of MITK
Loading...
Searching...
No Matches
mitkNavigationDataLandmarkTransformFilterTest.cpp
Go to the documentation of this file.
1/*============================================================================
2
3The Medical Imaging Interaction Toolkit (MITK)
4
5Copyright (c) German Cancer Research Center (DKFZ)
6All rights reserved.
7
8Use of this source code is governed by a 3-clause BSD license that can be
9found in the LICENSE file.
10
11============================================================================*/
12
13#include "mitkNavigationDataLandmarkTransformFilter.h"
14#include "mitkNavigationData.h"
15
16#include "mitkTestingMacros.h"
17
18#include <iostream>
19
20class mitkNavigationDataLandmarkTransformFilterTestClass
21 {
22 public:
23
24 static void TestInstantiation()
25 {
26 // let's create an object of our class
27 mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
28
29 // first test: did this work?
30 // using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
31 // it makes no sense to continue without an object.
32 MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
33 }
34
35 static void TestFilter()
36 {
37 // let's create an object of our class
38 mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
39
40 // first test: did this work?
41 // using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
42 // it makes no sense to continue without an object.
43 MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
44
45 /*create helper objects: source and target pointSets for landmark transform*/
46 mitk::Point3D sPoint1, sPoint2, sPoint3, tPoint1, tPoint2, tPoint3;
47 mitk::FillVector3D(sPoint1, 1.1, 1.1, 1.1);
48 mitk::FillVector3D(sPoint2, 2.2, 2.2, 2.2);
49 mitk::FillVector3D(sPoint3, 3.3, 3.3, 3.3);
50
51 mitk::FillVector3D(tPoint1, 2.1, 2.1, 2.1);
52 mitk::FillVector3D(tPoint2, 3.2, 3.2, 3.2);
53 mitk::FillVector3D(tPoint3, 4.3, 4.3, 4.3);
54
55 mitk::PointSet::Pointer sourcePoints = mitk::PointSet::New();
56 mitk::PointSet::Pointer targetPoints = mitk::PointSet::New();
57
58 sourcePoints->SetPoint(0,sPoint1);
59 sourcePoints->SetPoint(1,sPoint2);
60 sourcePoints->SetPoint(2,sPoint3);
61
62 targetPoints->SetPoint(0,tPoint1);
63 targetPoints->SetPoint(1,tPoint2);
64 targetPoints->SetPoint(2,tPoint3);
65
66 /* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
67 mitk::NavigationData::PositionType initialPos1,initialPos2, resultPos1,resultPos2;
68 mitk::FillVector3D(initialPos1, 1.1, 1.1, 1.1);
69 mitk::FillVector3D(initialPos2, 22.2,22.2, 22.2);
70 mitk::FillVector3D(resultPos1, 2.1, 2.1, 2.1);
71 mitk::FillVector3D(resultPos2, 23.2, 23.2, 23.2);
72 mitk::NavigationData::OrientationType initialOri(0.1, 0.1, 0.1, 0.1);
73 mitk::ScalarType initialError(0.0);
74 bool initialValid(true);
75
76 mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
77 nd1->SetPosition(initialPos1);
78 nd1->SetOrientation(initialOri);
79 nd1->SetPositionAccuracy(initialError);
80 nd1->SetDataValid(initialValid);
81
82 mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
83 nd2->SetPosition(initialPos2);
84 nd2->SetOrientation(initialOri);
85 nd2->SetPositionAccuracy(initialError);
86 nd2->SetDataValid(initialValid);
87
88
89 myFilter->SetInput(0,nd1);
90 MITK_TEST_CONDITION(myFilter->GetInput(0) == nd1, "Testing Set-/GetInput() ND1");
91
92 mitk::NavigationData* output1 = myFilter->GetOutput();
93 MITK_TEST_CONDITION_REQUIRED(output1 != nullptr, "Testing GetOutput() ND1");
94
95 MITK_TEST_CONDITION(myFilter->IsInitialized() == false, "Testing IsInitialized() before setting source points");
96
97 myFilter->SetSourceLandmarks(sourcePoints);
98 MITK_TEST_CONDITION(myFilter->IsInitialized() == false, "Testing IsInitialized() after setting source points and before setting target points");
99
100 mitk::PointSet::Pointer zeroTargetPoints = mitk::PointSet::New();
101
102 MITK_TEST_FOR_EXCEPTION(itk::ExceptionObject, myFilter->SetTargetLandmarks(zeroTargetPoints));
103 MITK_TEST_CONDITION(myFilter->IsInitialized() == false, "Testing IsInitialized() after setting target pointset with insufficient points");
104
105 myFilter->SetTargetLandmarks(targetPoints);
106 MITK_TEST_CONDITION(myFilter->IsInitialized() == true, "Testing IsInitialized() after setting source& target points");
107
108 //------------------------landmark transform should be initialized at this point------------------------
109 output1->Update();
110 MITK_TEST_CONDITION_REQUIRED(
111 mitk::Equal(output1->GetPosition(), resultPos1),
112 "Testing ND1 position correctly transformed");
113
114
115 //------------------------add another ND------------------------
116 myFilter->SetInput(1,nd2);
117 MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() ND2");
118
119 mitk::NavigationData* output2 = myFilter->GetOutput(1);
120 MITK_TEST_CONDITION_REQUIRED(output2 != nullptr, "Testing GetOutput() ND2");
121
122 //------------------------update output1 but check result2------------------------
123 output1->Update();
124 MITK_TEST_CONDITION_REQUIRED(
125 mitk::Equal(output2->GetPosition(), resultPos2),
126 "Testing ND2 position correctly transformed");
127
128 //------------------------update ND on slot 1------------------------
129 mitk::FillVector3D(initialPos2, 222.22, 222.22, 222.22);
130 mitk::FillVector3D(resultPos2, 223.22, 223.22, 223.22);
131 nd2->SetPosition(initialPos2);
132 myFilter->SetInput(1,nd2);
133 MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() ND2 after updating value");
134
135 output2 = myFilter->GetOutput(1);
136 MITK_TEST_CONDITION_REQUIRED(output2 != nullptr, "Testing GetOutput() ND2 after updating value");
137
138 //------------------------update output2 and check result2------------------------
139 output2->Update();
140 MITK_TEST_CONDITION(
141 mitk::Equal(output2->GetPosition(), resultPos2, 0.00001),
142 "Testing ND2 position correctly transformed after updating value");
143
144
145 //------------------------change target PointSet------------------------
146 mitk::FillVector3D(tPoint1, 3.1, 3.1, 3.1);
147 mitk::FillVector3D(tPoint2, 4.2, 4.2, 4.2);
148 mitk::FillVector3D(tPoint3, 5.3, 5.3, 5.3);
149 mitk::FillVector3D(resultPos1, 3.1 ,3.1 ,3.1);
150 mitk::FillVector3D(resultPos2, 224.22, 224.22, 224.22);
151
152
153 targetPoints->SetPoint(0,tPoint1);
154 targetPoints->SetPoint(1,tPoint2);
155 targetPoints->SetPoint(2,tPoint3);
156
157 myFilter->SetTargetLandmarks(targetPoints);
158
159 output1->Update();
160
161 MITK_TEST_CONDITION(
162 mitk::Equal(output1->GetPosition(), resultPos1),
163 "Testing ND1 position correctly transformed after targetPointSet changed");
164
165 MITK_TEST_CONDITION(
166 mitk::Equal(output2->GetPosition(), resultPos2, 0.00001),
167 "Testing ND2 position correctly transformed after targetPointSet changed");
168
169
170 //------------------------change source PointSet------------------------
171 mitk::FillVector3D(sPoint1, 0.1, 0.1, 0.1);
172 mitk::FillVector3D(sPoint2, 1.2, 1.2, 1.2);
173 mitk::FillVector3D(sPoint3, 2.3, 2.3, 2.3);
174 mitk::FillVector3D(resultPos1, 4.1 ,4.1 ,4.1);
175 mitk::FillVector3D(resultPos2, 225.22, 225.22, 225.22);
176
177
178 sourcePoints->SetPoint(0,sPoint1);
179 sourcePoints->SetPoint(1,sPoint2);
180 sourcePoints->SetPoint(2,sPoint3);
181
182 myFilter->SetSourceLandmarks(sourcePoints);
183
184 output1->Update();
185
186 MITK_TEST_CONDITION(
187 mitk::Equal(output1->GetPosition(), resultPos1, 0.00001),
188 "Testing ND1 position correctly transformed after sourcePointSet changed");
189
190 MITK_TEST_CONDITION(
191 mitk::Equal(output2->GetPosition(), resultPos2,0.00001),
192 "Testing ND2 position correctly transformed after sourcePointSet changed");
193
194 //--------------------- Test ICP initialization --------------------------
195 {
196 mitk::PointSet::Pointer sourcePoints = mitk::PointSet::New();
197 mitk::Point3D s1, s2, s3, s4, s5, s6;
198 mitk::FillVector3D(s1, 1.1, 1.1, 1.1);
199 mitk::FillVector3D(s2, 2.2, 2.2, 2.2);
200 mitk::FillVector3D(s3, 3.3, 3.3, 3.3);
201 mitk::FillVector3D(s4, 4.4, 4.4, 4.4);
202 mitk::FillVector3D(s5, 5.5, 5.5, 5.5);
203 mitk::FillVector3D(s6, 6.6, 6.6, 6.6);
204 sourcePoints->SetPoint(1, s4); // use random source point order
205 sourcePoints->SetPoint(2, s6);
206 sourcePoints->SetPoint(3, s3);
207 sourcePoints->SetPoint(4, s1);
208 sourcePoints->SetPoint(5, s2);
209 sourcePoints->SetPoint(6, s5);
210
211 mitk::PointSet::Pointer targetPoints = mitk::PointSet::New();
212 mitk::Point3D t1, t2, t3, t4, t5, t6;
213 mitk::FillVector3D(t1, 2.1, 2.1, 102.1); // ==> targets have offset [1, 1, 101]
214 mitk::FillVector3D(t2, 3.2, 3.2, 103.2);
215 mitk::FillVector3D(t3, 4.3, 4.3, 104.3);
216 mitk::FillVector3D(t4, 5.4, 5.4, 105.4);
217 mitk::FillVector3D(t5, 6.5, 6.5, 106.5);
218 mitk::FillVector3D(t6, 7.6, 7.6, 107.6);
219 targetPoints->SetPoint(1, t1);
220 targetPoints->SetPoint(2, t2);
221 targetPoints->SetPoint(3, t3);
222 targetPoints->SetPoint(4, t4);
223 targetPoints->SetPoint(5, t5);
224 targetPoints->SetPoint(6, t6);
225
226 mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
227 myFilter->UseICPInitializationOn();
228 myFilter->SetSourceLandmarks(sourcePoints);
229 myFilter->SetTargetLandmarks(targetPoints); // errors would raise exceptions
230
231 // prepare input
232 mitk::NavigationData::PositionType initialPos1, resultPos1;
233 mitk::FillVector3D(initialPos1, 1.1, 1.1, 1.1);
234 mitk::FillVector3D(resultPos1, 2.1, 2.1, 102.1);
235 mitk::NavigationData::OrientationType initialOri(0.1, 0.1, 0.1, 0.1);
236 mitk::ScalarType initialError(0.0);
237 bool initialValid(true);
238 mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
239 nd1->SetPosition(initialPos1);
240 nd1->SetOrientation(initialOri);
241 nd1->SetPositionAccuracy(initialError);
242 nd1->SetDataValid(initialValid);
243
244 myFilter->SetInput(0, nd1);
245 mitk::NavigationData::Pointer output = myFilter->GetOutput();
246
247 output->Update();
248
249 MITK_TEST_CONDITION(mitk::Equal(output->GetPosition(), resultPos1,0.00001), "Testing ND1 position correctly transformed after ICP initialization");
250 }
251
252 //------------------------catch exception --> source points < 3------------------------
253 mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter2 = mitk::NavigationDataLandmarkTransformFilter::New();
254 MITK_TEST_CONDITION_REQUIRED(myFilter2.IsNotNull(),"Testing instantiation for second filter");
255
256 mitk::PointSet::Pointer sourcePoints2 = mitk::PointSet::New();
257 MITK_TEST_FOR_EXCEPTION(std::exception, myFilter2->SetSourceLandmarks(sourcePoints2););
258
259
260 //------------------------catch exception --> target points < 3------------------------
261 mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter3 = mitk::NavigationDataLandmarkTransformFilter::New();
262 MITK_TEST_CONDITION_REQUIRED(myFilter3.IsNotNull(),"Testing instantiation for second filter");
263
264 mitk::PointSet::Pointer targetPoints2 = mitk::PointSet::New();
265 MITK_TEST_FOR_EXCEPTION(std::exception, myFilter3->SetTargetLandmarks(targetPoints2););
266
267
268 //------------------------rotate orientation------------------------
269 myFilter=nullptr;
270 myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
271
272 mitk::FillVector3D(sPoint1, 1.1, 1.1, 1.1);
273 mitk::FillVector3D(sPoint2, 1.1, -1.1, 1.1);
274 mitk::FillVector3D(sPoint3, -1.1, -1.1, 1.1);
275
276 mitk::FillVector3D(tPoint1, -1.1, 1.1, 1.1);
277 mitk::FillVector3D(tPoint2, 1.1, 1.1, 1.1);
278 mitk::FillVector3D(tPoint3, 1.1, -1.1, 1.1);
279
280 sourcePoints->SetPoint(0,sPoint1);
281 sourcePoints->SetPoint(1,sPoint2);
282 sourcePoints->SetPoint(2,sPoint3);
283
284 targetPoints->SetPoint(0,tPoint1);
285 targetPoints->SetPoint(1,tPoint2);
286 targetPoints->SetPoint(2,tPoint3);
287
288 myFilter->SetSourceLandmarks(sourcePoints);
289 myFilter->SetTargetLandmarks(targetPoints);
290
291 //set initial orientation (x y z r)
292 mitk::NavigationData::OrientationType initialQuat(0.0, 0.0, 0.0, 1.0);
293 mitk::NavigationData::OrientationType resultQuat(0.0, 0.0, -0.7071, -0.7071);
294
295 //set position
296 mitk::FillVector3D(initialPos1, 2.2, 2.2, 2.2);
297 mitk::FillVector3D(resultPos1, -2.2, 2.2, 2.2);
298
299 nd1->SetOrientation(initialQuat);
300 nd1->SetPosition(initialPos1);
301
302 myFilter->SetInput(0,nd1);
303
304 output1 = myFilter->GetOutput();
305 output1->Update();
306
307 MITK_TEST_CONDITION(
308 mitk::Equal(output1->GetPosition(), resultPos1, 0.00001),
309 "Testing ND1 position correctly transformed ");
310
311 MITK_TEST_CONDITION(
312 mitk::Equal(output1->GetOrientation(), resultQuat, 0.00001),
313 "Testing ND1 orientation correctly transformed ");
314 MITK_TEST_OUTPUT(<<"Orientation1");
315 MITK_TEST_OUTPUT(<<output1->GetOrientation());
316 MITK_TEST_OUTPUT(<<"qX:");
317 MITK_TEST_OUTPUT(<<output1->GetOrientation().x());
318 MITK_TEST_OUTPUT(<<"qY:");
319 MITK_TEST_OUTPUT(<<output1->GetOrientation().y());
320 MITK_TEST_OUTPUT(<<"qZ:");
321 MITK_TEST_OUTPUT(<<output1->GetOrientation().z());
322 MITK_TEST_OUTPUT(<<"qR:");
323 MITK_TEST_OUTPUT(<<output1->GetOrientation().r());
324 MITK_TEST_OUTPUT(<<"angle:");
325 //MITK_TEST_OUTPUT(<<output1->angle());
326 //TODO: something was modified on vnl_quaternion, check what. DONE
327 MITK_TEST_OUTPUT(<<"Orientation2");
328 MITK_TEST_OUTPUT(<<resultQuat);
329 MITK_TEST_OUTPUT(<<"qX:");
330 MITK_TEST_OUTPUT(<<resultQuat.x());
331 MITK_TEST_OUTPUT(<<"qY:");
332 MITK_TEST_OUTPUT(<<resultQuat.y());
333 MITK_TEST_OUTPUT(<<"qZ:");
334 MITK_TEST_OUTPUT(<<resultQuat.z());
335 MITK_TEST_OUTPUT(<<"qR:");
336 MITK_TEST_OUTPUT(<<resultQuat.r());
337
338
339
340 //------------------------test FRE calculation------------------------
341 mitk::PointSet::Pointer refSet = mitk::PointSet::New();
342 mitk::PointSet::Pointer movSet = mitk::PointSet::New();
343
344 mitk::Point3D refPoint;
345 mitk::Point3D movPoint;
346
347 //Point 0
348 refPoint.Fill(0); refSet->SetPoint(0, refPoint);
349 movPoint.Fill(1); movSet->SetPoint(0, movPoint);
350
351 //Point 1
352 refPoint[0]=3; refPoint[1]=0; refPoint[2]=0; refSet->SetPoint(1, refPoint);
353 movPoint[0]=2; movPoint[1]=1; movPoint[2]=1; movSet->SetPoint(1, movPoint);
354
355 //Point 2
356 refPoint[0]=0; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(2, refPoint);
357 movPoint[0]=1; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(2, movPoint);
358
359 //Point 3
360 refPoint[0]=3; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(3, refPoint);
361 movPoint[0]=2; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(3, movPoint);
362
363
364 //Point 4
365 refPoint[0]=0; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(4, refPoint);
366 movPoint[0]=1; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(4, movPoint);
367
368 //Point 5
369 refPoint[0]=3; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(5, refPoint);
370 movPoint[0]=2; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(5, movPoint);
371
372 //Point 6
373 refPoint[0]=0; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(6, refPoint);
374 movPoint[0]=1; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(6, movPoint);
375
376 //Point 7
377 refPoint[0]=3; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(7, refPoint);
378 movPoint[0]=2; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(7, movPoint);
379
380 mitk::NavigationDataLandmarkTransformFilter::Pointer myFREFilter = mitk::NavigationDataLandmarkTransformFilter::New();
381 myFREFilter->SetSourceLandmarks(refSet);
382 myFREFilter->SetTargetLandmarks(movSet);
383
384 //very simple test case, everything is the same (min = max = mean = RMS = abs max error)
385 //but still ok to see if the methods work without a crash
386 MITK_TEST_CONDITION_REQUIRED(mitk::Equal(myFREFilter->GetFRE(), (double) sqrt(3.0), 0.00001), "Testing mean error calculation");
387 MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetMaxError() == (double) sqrt(3.0),"Testing max error calculation");
388 MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetMinError() == (double) sqrt(3.0),"Testing min error calculation");
389 MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetRMSError() == (double) sqrt(3.0),"Testing RMS error calculation");
390 MITK_TEST_CONDITION_REQUIRED(mitk::Equal(myFREFilter->GetFREStdDev(), (double) 0.0, 0.00001),"Testing SD calculation");
391 MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetAbsMaxError() == (double) sqrt(3.0),"Testing abs max error calculation");
392 MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetErrorVector().size() == 8,"Testing method GetErrorVector");
393
394 //todo: extend by a more complex test case with different values?
395 }
396
397 static void TestPrintSelfMethod()
398 {
399 mitk::PointSet::Pointer refSet = mitk::PointSet::New();
400 mitk::PointSet::Pointer movSet = mitk::PointSet::New();
401
402 mitk::Point3D refPoint;
403 mitk::Point3D movPoint;
404
405 //Point 0
406 refPoint.Fill(0); refSet->SetPoint(0, refPoint);
407 movPoint.Fill(1); movSet->SetPoint(0, movPoint);
408
409 //Point 1
410 refPoint[0]=3; refPoint[1]=0; refPoint[2]=0; refSet->SetPoint(1, refPoint);
411 movPoint[0]=2; movPoint[1]=1; movPoint[2]=1; movSet->SetPoint(1, movPoint);
412
413 //Point 2
414 refPoint[0]=0; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(2, refPoint);
415 movPoint[0]=1; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(2, movPoint);
416
417 //Point 3
418 refPoint[0]=3; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(3, refPoint);
419 movPoint[0]=2; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(3, movPoint);
420
421 //Point 4
422 refPoint[0]=0; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(4, refPoint);
423 movPoint[0]=1; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(4, movPoint);
424
425 //Point 5
426 refPoint[0]=3; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(5, refPoint);
427 movPoint[0]=2; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(5, movPoint);
428
429 //Point 6
430 refPoint[0]=0; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(6, refPoint);
431 movPoint[0]=1; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(6, movPoint);
432
433 //Point 7
434 refPoint[0]=3; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(7, refPoint);
435 movPoint[0]=2; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(7, movPoint);
436
437 mitk::NavigationDataLandmarkTransformFilter::Pointer myFREFilter = mitk::NavigationDataLandmarkTransformFilter::New();
438 myFREFilter->SetSourceLandmarks(refSet);
439 myFREFilter->SetTargetLandmarks(movSet);
440
441 bool success = false;
442 try
443 {
444 MITK_INFO << "Testing printing of object: " << myFREFilter;
445 success = true;
446 }
447 catch(...)
448 {
449 MITK_ERROR << "Error while printing the object";
450 }
451 MITK_TEST_CONDITION_REQUIRED(success,"Testing printing object to a stream");
452 }
453
454 static void TestFilterInvalidCases()
455 {
456 mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
457 mitk::PointSet::Pointer refSet = mitk::PointSet::New();
458 mitk::PointSet::Pointer movSet = mitk::PointSet::New();
459
460 mitk::Point3D refPoint;
461 mitk::Point3D movPoint;
462
463 //Point 0
464 refPoint.Fill(0); refSet->SetPoint(0, refPoint);
465 movPoint.Fill(1); movSet->SetPoint(0, movPoint);
466
467 //Point 1
468 refPoint[0]=3; refPoint[1]=0; refPoint[2]=0; refSet->SetPoint(1, refPoint);
469 movPoint[0]=2; movPoint[1]=1; movPoint[2]=1; movSet->SetPoint(1, movPoint);
470
471 //Point 2
472 refPoint[0]=0; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(2, refPoint);
473 movPoint[0]=1; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(2, movPoint);
474
475 myFilter->SetUseICPInitialization(true);
476
477 bool exceptionThrown = false;
478 try
479 { //should throw exception because less than 6 points
480 myFilter->SetSourceLandmarks(refSet);
481 myFilter->SetTargetLandmarks(movSet);
482 }
483 catch(itk::ExceptionObject&)
484 {
485 exceptionThrown = true;
486 }
487 MITK_TEST_CONDITION_REQUIRED(exceptionThrown,"Testing invalid number of landmarks when using ICP initialization.")
488
489 }
490
491 };
492
mitk::NavigationData::OrientationType
mitk::Quaternion OrientationType
Type that holds the orientation part of the tracking data.
Definition mitkNavigationData.h:52
mitk::NavigationData::PositionType
mitk::Point3D PositionType
Type that holds the position part of the tracking data.
Definition mitkNavigationData.h:48
mitkNavigationDataLandmarkTransformFilterTest
int mitkNavigationDataLandmarkTransformFilterTest(int, char *[])
Definition mitkNavigationDataLandmarkTransformFilterTest.cpp:496
mitk::Equal
MITKIGTBASE_EXPORT bool Equal(const mitk::NavigationData &leftHandSide, const mitk::NavigationData &rightHandSide, ScalarType eps=mitk::eps, bool verbose=false)
Equal A function comparing two navigation data objects for beeing equal in meta- and imagedata.
Definition mitkNavigationData.cpp:319