Medical Imaging Interaction Toolkit  2016.11.0
Medical Imaging Interaction Toolkit
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
mitkPlaneGeometryTest.cpp
Go to the documentation of this file.
1 /*===================================================================
2 
3 The Medical Imaging Interaction Toolkit (MITK)
4 
5 Copyright (c) German Cancer Research Center,
6 Division of Medical and Biological Informatics.
7 All rights reserved.
8 
9 This software is distributed WITHOUT ANY WARRANTY; without
10 even the implied warranty of MERCHANTABILITY or FITNESS FOR
11 A PARTICULAR PURPOSE.
12 
13 See LICENSE.txt or http://www.mitk.org for details.
14 
15 ===================================================================*/
16 
17 #include "mitkAffineTransform3D.h"
18 #include "mitkBaseGeometry.h"
19 #include "mitkGeometry3D.h"
20 #include "mitkInteractionConst.h"
21 #include "mitkLine.h"
22 #include "mitkPlaneGeometry.h"
23 #include "mitkRotationOperation.h"
24 #include "mitkSlicedGeometry3D.h"
25 #include "mitkThinPlateSplineCurvedGeometry.h"
26 
27 #include <mitkTestFixture.h>
28 #include <mitkTestingMacros.h>
29 
30 #include <vnl/vnl_quaternion.h>
31 #include <vnl/vnl_quaternion.txx>
32 
33 #include <fstream>
34 #include <iomanip>
35 
36 static const mitk::ScalarType testEps = 1E-9; // the epsilon used in this test == at least float precision.
37 
38 class mitkPlaneGeometryTestSuite : public mitk::TestFixture
39 {
40  CPPUNIT_TEST_SUITE(mitkPlaneGeometryTestSuite);
41  MITK_TEST(TestInitializeStandardPlane);
42  MITK_TEST(TestProjectPointOntoPlane);
43  MITK_TEST(TestPlaneGeometryCloning);
44  MITK_TEST(TestInheritance);
45  MITK_TEST(TestSetExtendInMM);
46  MITK_TEST(TestRotate);
47  MITK_TEST(TestClone);
48  MITK_TEST(TestPlaneComparison);
49  MITK_TEST(TestAxialInitialization);
50  MITK_TEST(TestFrontalInitialization);
51  MITK_TEST(TestSaggitalInitialization);
52  MITK_TEST(TestLefthandedCoordinateSystem);
53 
54  // Currently commented out, see See bug 15990
55  // MITK_TEST(testPlaneGeometryInitializeOrder);
56  MITK_TEST(TestIntersectionPoint);
57  MITK_TEST(TestCase1210);
58 
59  CPPUNIT_TEST_SUITE_END();
60 
61 private:
62  // private test members that are initialized by setUp()
63  mitk::PlaneGeometry::Pointer planegeometry;
64  mitk::Point3D origin;
65  mitk::Vector3D right, bottom, normal, spacing;
66  mitk::ScalarType width, height;
67  mitk::ScalarType widthInMM, heightInMM, thicknessInMM;
68 
69 public:
70  void setUp() override
71  {
72  planegeometry = mitk::PlaneGeometry::New();
73  width = 100;
74  widthInMM = width;
75  height = 200;
76  heightInMM = height;
77  thicknessInMM = 1.0;
78  mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
79  mitk::FillVector3D(right, widthInMM, 0, 0);
80  mitk::FillVector3D(bottom, 0, heightInMM, 0);
81  mitk::FillVector3D(normal, 0, 0, thicknessInMM);
82  mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
83 
84  planegeometry->InitializeStandardPlane(right, bottom);
85  planegeometry->SetOrigin(origin);
86  planegeometry->SetSpacing(spacing);
87  }
88 
89  void tearDown() override {}
90  // This test verifies inheritance behaviour, this test will fail if the behaviour changes in the future
91  void TestInheritance()
92  {
93  mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
94  mitk::Geometry3D::Pointer g3d = dynamic_cast<mitk::Geometry3D *>(plane.GetPointer());
95  CPPUNIT_ASSERT_MESSAGE("Planegeometry should not be castable to Geometry 3D", g3d.IsNull());
96 
97  mitk::BaseGeometry::Pointer base = dynamic_cast<mitk::BaseGeometry *>(plane.GetPointer());
98  CPPUNIT_ASSERT_MESSAGE("Planegeometry should be castable to BaseGeometry", base.IsNotNull());
99 
100  g3d = mitk::Geometry3D::New();
101  base = dynamic_cast<mitk::BaseGeometry *>(g3d.GetPointer());
102  CPPUNIT_ASSERT_MESSAGE("Geometry3D should be castable to BaseGeometry", base.IsNotNull());
103 
104  mitk::SlicedGeometry3D::Pointer sliced = mitk::SlicedGeometry3D::New();
105  g3d = dynamic_cast<mitk::Geometry3D *>(sliced.GetPointer());
106  CPPUNIT_ASSERT_MESSAGE("SlicedGeometry3D should not be castable to Geometry3D", g3d.IsNull());
107 
108  mitk::ThinPlateSplineCurvedGeometry::Pointer thin = mitk::ThinPlateSplineCurvedGeometry::New();
109  plane = dynamic_cast<mitk::PlaneGeometry *>(thin.GetPointer());
110  CPPUNIT_ASSERT_MESSAGE("AbstractTransformGeometry should be castable to PlaneGeometry", plane.IsNotNull());
111 
112  plane = mitk::PlaneGeometry::New();
113  mitk::AbstractTransformGeometry::Pointer atg = dynamic_cast<mitk::AbstractTransformGeometry *>(plane.GetPointer());
114  CPPUNIT_ASSERT_MESSAGE("PlaneGeometry should not be castable to AbstractTransofrmGeometry", atg.IsNull());
115  }
116 
117  void TestLefthandedCoordinateSystem()
118  {
126  planegeometry = mitk::PlaneGeometry::New();
127  width = 100;
128  widthInMM = 5;
129  height = 200;
130  heightInMM = 3;
131  thicknessInMM = 1.0;
132  mitk::FillVector3D(right, widthInMM, 0, 0);
133  mitk::FillVector3D(bottom, 0, heightInMM, 0);
134  // This one negative sign results in lefthanded coordinate orientation and det(matrix) < 0.
135  mitk::FillVector3D(normal, 0, 0, -thicknessInMM);
136 
137  mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
138 
139  mitk::AffineTransform3D::MatrixType matrix;
140  mitk::AffineTransform3D::MatrixType::InternalMatrixType &vnl_matrix = matrix.GetVnlMatrix();
141 
142  vnl_matrix.set_column(0, right);
143  vnl_matrix.set_column(1, bottom);
144  vnl_matrix.set_column(2, normal);
145 
146  // making sure that we didn't screw up this special test case or else fail deadly:
147  assert(vnl_determinant(vnl_matrix) < 0.0);
148 
149  transform->SetIdentity();
150  transform->SetMatrix(matrix);
151 
152  planegeometry->InitializeStandardPlane(width, height, transform); // Crux of the matter.
153  CPPUNIT_ASSERT_MESSAGE(
154  "Testing if IndexToWorldMatrix is correct after InitializeStandardPlane( width, height, transform ) ",
155  mitk::MatrixEqualElementWise(planegeometry->GetIndexToWorldTransform()->GetMatrix(), matrix));
156 
157  mitk::Point3D p_index;
158  p_index[0] = 10.;
159  p_index[1] = 10.;
160  p_index[2] = 0.;
161  mitk::Point3D p_world;
162  mitk::Point3D p_expectedResult;
163  p_expectedResult[0] = 50.;
164  p_expectedResult[1] = 30.;
165  p_expectedResult[2] = 0.;
166 
167  ((mitk::BaseGeometry::Pointer)planegeometry)->IndexToWorld(p_index, p_world); // Crux of the matter.
168  CPPUNIT_ASSERT_MESSAGE("Testing if IndexToWorld(a,b) function works correctly with lefthanded matrix ",
169  mitk::Equal(p_world, p_expectedResult, testEps));
170  }
171 
172  // See bug 1210
173  // Test does not use standard Parameters
174  void TestCase1210()
175  {
176  mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
177 
178  mitk::Point3D origin;
179  mitk::Vector3D right, down, spacing;
180 
181  mitk::FillVector3D(origin, 4.5, 7.3, 11.2);
182  mitk::FillVector3D(right, 1.015625, 1.015625, 1.1999969482421875);
183 
184  mitk::FillVector3D(down, 1.4012984643248170709237295832899161312802619418765e-45, 0, 0);
185  mitk::FillVector3D(spacing,
186  0,
187  1.4713633875410579244699160624544119378442750389703e-43,
188  9.2806360452222355258639080851310540729807238879469e-32);
189 
190  std::cout << "Testing InitializeStandardPlane(rightVector, downVector, spacing = NULL): " << std::endl;
191  CPPUNIT_ASSERT_NO_THROW(planegeometry->InitializeStandardPlane(right, down, &spacing));
192  /*
193  std::cout << "Testing width, height and thickness (in units): ";
194  if((mitk::Equal(planegeometry->GetExtent(0),width)==false) ||
195  (mitk::Equal(planegeometry->GetExtent(1),height)==false) ||
196  (mitk::Equal(planegeometry->GetExtent(2),1)==false)
197  )
198  {
199  std::cout<<"[FAILED]"<<std::endl;
200  return EXIT_FAILURE;
201  }
202  std::cout<<"[PASSED]"<<std::endl;
203 
204  std::cout << "Testing width, height and thickness (in mm): ";
205  if((mitk::Equal(planegeometry->GetExtentInMM(0),widthInMM)==false) ||
206  (mitk::Equal(planegeometry->GetExtentInMM(1),heightInMM)==false) ||
207  (mitk::Equal(planegeometry->GetExtentInMM(2),thicknessInMM)==false)
208  )
209  {
210  std::cout<<"[FAILED]"<<std::endl;
211  return EXIT_FAILURE;
212  }
213  */
214  }
215 
232  // Test does not use standard Parameters
233  void TestIntersectionPoint()
234  {
235  // init plane with its parameter
236  mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
237 
238  mitk::Point3D origin;
239  origin[0] = 0.0;
240  origin[1] = 2.0;
241  origin[2] = 0.0;
242 
243  mitk::Vector3D normal;
244  normal[0] = 0.0;
245  normal[1] = 1.0;
246  normal[2] = 0.0;
247 
248  myPlaneGeometry->InitializePlane(origin, normal);
249 
250  // generate points and line for intersection testing
251  // point distance of given line > 1
252  mitk::Point3D pointP1;
253  pointP1[0] = 2.0;
254  pointP1[1] = 1.0;
255  pointP1[2] = 0.0;
256 
257  mitk::Point3D pointP2;
258  pointP2[0] = 2.0;
259  pointP2[1] = 4.0;
260  pointP2[2] = 0.0;
261 
262  mitk::Vector3D lineDirection;
263  lineDirection[0] = pointP2[0] - pointP1[0];
264  lineDirection[1] = pointP2[1] - pointP1[1];
265  lineDirection[2] = pointP2[2] - pointP1[2];
266 
267  mitk::Line3D xingline(pointP1, lineDirection);
268  mitk::Point3D calcXingPoint;
269  myPlaneGeometry->IntersectionPoint(xingline, calcXingPoint);
270 
271  // point distance of given line < 1
272  mitk::Point3D pointP3;
273  pointP3[0] = 2.0;
274  pointP3[1] = 2.2;
275  pointP3[2] = 0.0;
276 
277  mitk::Point3D pointP4;
278  pointP4[0] = 2.0;
279  pointP4[1] = 1.7;
280  pointP4[2] = 0.0;
281 
282  mitk::Vector3D lineDirection2;
283  lineDirection2[0] = pointP4[0] - pointP3[0];
284  lineDirection2[1] = pointP4[1] - pointP3[1];
285  lineDirection2[2] = pointP4[2] - pointP3[2];
286 
287  mitk::Line3D xingline2(pointP3, lineDirection2);
288  mitk::Point3D calcXingPoint2;
289  myPlaneGeometry->IntersectionPoint(xingline2, calcXingPoint2);
290 
291  // intersection points must be the same
292  CPPUNIT_ASSERT_MESSAGE("Failed to calculate Intersection Point", calcXingPoint == calcXingPoint2);
293  }
294 
300  // Test does not use standard Parameters
301  void TestProjectPointOntoPlane()
302  {
303  mitk::PlaneGeometry::Pointer myPlaneGeometry = mitk::PlaneGeometry::New();
304 
305  // create normal
306  mitk::Vector3D normal;
307  normal[0] = 0.0;
308  normal[1] = 0.0;
309  normal[2] = 1.0;
310 
311  // create origin
312  mitk::Point3D origin;
313  origin[0] = -27.582859;
314  origin[1] = 50;
315  origin[2] = 200.27742;
316 
317  // initialize plane geometry
318  myPlaneGeometry->InitializePlane(origin, normal);
319 
320  // output to descripe the test
321  std::cout << "Testing PlaneGeometry according to bug #3409" << std::endl;
322  std::cout << "Our normal is: " << normal << std::endl;
323  std::cout << "So ALL projected points should have exactly the same z-value!" << std::endl;
324 
325  // create a number of points
326  mitk::Point3D myPoints[5];
327  myPoints[0][0] = -27.582859;
328  myPoints[0][1] = 50.00;
329  myPoints[0][2] = 200.27742;
330 
331  myPoints[1][0] = -26.58662;
332  myPoints[1][1] = 50.00;
333  myPoints[1][2] = 200.19026;
334 
335  myPoints[2][0] = -26.58662;
336  myPoints[2][1] = 50.00;
337  myPoints[2][2] = 200.33124;
338 
339  myPoints[3][0] = 104.58662;
340  myPoints[3][1] = 452.12313;
341  myPoints[3][2] = 866.41236;
342 
343  myPoints[4][0] = -207.58662;
344  myPoints[4][1] = 312.00;
345  myPoints[4][2] = -300.12346;
346 
347  // project points onto plane
348  mitk::Point3D myProjectedPoints[5];
349  for (unsigned int i = 0; i < 5; ++i)
350  {
351  myProjectedPoints[i] = myPlaneGeometry->ProjectPointOntoPlane(myPoints[i]);
352  }
353 
354  // compare z-values with z-value of plane (should be equal)
355  bool allPointsOnPlane = true;
356  for (auto &myProjectedPoint : myProjectedPoints)
357  {
358  if (fabs(myProjectedPoint[2] - origin[2]) > mitk::sqrteps)
359  {
360  allPointsOnPlane = false;
361  }
362  }
363  CPPUNIT_ASSERT_MESSAGE("All points lie not on the same plane", allPointsOnPlane);
364  }
365 
366  void TestPlaneGeometryCloning()
367  {
368  mitk::PlaneGeometry::Pointer geometry2D = createPlaneGeometry();
369 
370  try
371  {
372  mitk::PlaneGeometry::Pointer clone = geometry2D->Clone();
373  itk::Matrix<mitk::ScalarType, 3, 3> matrix = clone->GetIndexToWorldTransform()->GetMatrix();
374  CPPUNIT_ASSERT_MESSAGE("Test if matrix element exists...", matrix[0][0] == 31);
375 
376  double origin = geometry2D->GetOrigin()[0];
377  CPPUNIT_ASSERT_MESSAGE("First Point of origin as expected...", mitk::Equal(origin, 8));
378 
379  double spacing = geometry2D->GetSpacing()[0];
380  CPPUNIT_ASSERT_MESSAGE("First Point of spacing as expected...", mitk::Equal(spacing, 31));
381  }
382  catch (...)
383  {
384  CPPUNIT_FAIL("Error during access on a member of cloned geometry");
385  }
386  // direction [row] [coloum]
387  MITK_TEST_OUTPUT(<< "Casting a rotated 2D ITK Image to a MITK Image and check if Geometry is still same");
388  }
389 
390  void TestPlaneGeometryInitializeOrder()
391  {
392  mitk::Vector3D mySpacing;
393  mySpacing[0] = 31;
394  mySpacing[1] = 0.1;
395  mySpacing[2] = 5.4;
396  mitk::Point3D myOrigin;
397  myOrigin[0] = 8;
398  myOrigin[1] = 9;
399  myOrigin[2] = 10;
400  mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
401  itk::Matrix<mitk::ScalarType, 3, 3> transMatrix;
402  transMatrix.Fill(0);
403  transMatrix[0][0] = 1;
404  transMatrix[1][1] = 2;
405  transMatrix[2][2] = 4;
406 
407  myTransform->SetMatrix(transMatrix);
408 
409  mitk::PlaneGeometry::Pointer geometry2D1 = mitk::PlaneGeometry::New();
410  geometry2D1->SetIndexToWorldTransform(myTransform);
411  geometry2D1->SetSpacing(mySpacing);
412  geometry2D1->SetOrigin(myOrigin);
413 
414  mitk::PlaneGeometry::Pointer geometry2D2 = mitk::PlaneGeometry::New();
415  geometry2D2->SetSpacing(mySpacing);
416  geometry2D2->SetOrigin(myOrigin);
417  geometry2D2->SetIndexToWorldTransform(myTransform);
418 
419  mitk::PlaneGeometry::Pointer geometry2D3 = mitk::PlaneGeometry::New();
420  geometry2D3->SetIndexToWorldTransform(myTransform);
421  geometry2D3->SetSpacing(mySpacing);
422  geometry2D3->SetOrigin(myOrigin);
423  geometry2D3->SetIndexToWorldTransform(myTransform);
424 
425  CPPUNIT_ASSERT_MESSAGE("Origin of Geometry 1 matches that of Geometry 2.",
426  mitk::Equal(geometry2D1->GetOrigin(), geometry2D2->GetOrigin()));
427  CPPUNIT_ASSERT_MESSAGE("Origin of Geometry 1 match those of Geometry 3.",
428  mitk::Equal(geometry2D1->GetOrigin(), geometry2D3->GetOrigin()));
429  CPPUNIT_ASSERT_MESSAGE("Origin of Geometry 2 match those of Geometry 3.",
430  mitk::Equal(geometry2D2->GetOrigin(), geometry2D3->GetOrigin()));
431 
432  CPPUNIT_ASSERT_MESSAGE("Spacing of Geometry 1 match those of Geometry 2.",
433  mitk::Equal(geometry2D1->GetSpacing(), geometry2D2->GetSpacing()));
434  CPPUNIT_ASSERT_MESSAGE("Spacing of Geometry 1 match those of Geometry 3.",
435  mitk::Equal(geometry2D1->GetSpacing(), geometry2D3->GetSpacing()));
436  CPPUNIT_ASSERT_MESSAGE("Spacing of Geometry 2 match those of Geometry 3.",
437  mitk::Equal(geometry2D2->GetSpacing(), geometry2D3->GetSpacing()));
438 
439  CPPUNIT_ASSERT_MESSAGE("Transformation of Geometry 1 match those of Geometry 2.",
440  compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(),
441  geometry2D2->GetIndexToWorldTransform()->GetMatrix()));
442  CPPUNIT_ASSERT_MESSAGE("Transformation of Geometry 1 match those of Geometry 3.",
443  compareMatrix(geometry2D1->GetIndexToWorldTransform()->GetMatrix(),
444  geometry2D3->GetIndexToWorldTransform()->GetMatrix()));
445  CPPUNIT_ASSERT_MESSAGE("Transformation of Geometry 2 match those of Geometry 3.",
446  compareMatrix(geometry2D2->GetIndexToWorldTransform()->GetMatrix(),
447  geometry2D3->GetIndexToWorldTransform()->GetMatrix()));
448  }
449 
450  void TestInitializeStandardPlane()
451  {
452  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: width",
453  mitk::Equal(planegeometry->GetExtent(0), width, testEps));
454  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: height",
455  mitk::Equal(planegeometry->GetExtent(1), height, testEps));
456  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: depth",
457  mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
458 
459  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: width in mm",
460  mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
461  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: heght in mm",
462  mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
463  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: depth in mm",
464  mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
465 
466  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: AxisVectorRight",
467  mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
468  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: AxisVectorBottom",
469  mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
470  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with default Spacing: AxisVectorNormal",
471  mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
472 
473  mitk::Vector3D spacing;
474  thicknessInMM = 1.5;
475  normal.Normalize();
476  normal *= thicknessInMM;
477  mitk::FillVector3D(spacing, 1.0, 1.0, thicknessInMM);
478  planegeometry->InitializeStandardPlane(right.GetVnlVector(), bottom.GetVnlVector(), &spacing);
479 
480  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: width",
481  mitk::Equal(planegeometry->GetExtent(0), width, testEps));
482  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: height",
483  mitk::Equal(planegeometry->GetExtent(1), height, testEps));
484  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: depth",
485  mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
486 
487  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: width in mm",
488  mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
489  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: height in mm",
490  mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
491  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: depth in mm",
492  mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
493 
494  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: AxisVectorRight",
495  mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
496  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: AxisVectorBottom",
497  mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
498  CPPUNIT_ASSERT_MESSAGE("Testing correct Standard Plane initialization with custom Spacing: AxisVectorNormal",
499  mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
500 
501  ;
502  }
503 
504  void TestSetExtendInMM()
505  {
506  normal.Normalize();
507  normal *= thicknessInMM;
508  planegeometry->SetExtentInMM(2, thicknessInMM);
509  CPPUNIT_ASSERT_MESSAGE("Testing SetExtentInMM(2, ...), querying by GetExtentInMM(2): ",
510  mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
511  CPPUNIT_ASSERT_MESSAGE("Testing SetExtentInMM(2, ...), querying by GetAxisVector(2) and comparing to normal: ",
512  mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
513 
514  planegeometry->SetOrigin(origin);
515  CPPUNIT_ASSERT_MESSAGE("Testing SetOrigin", mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
516 
517  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() after SetOrigin: Right",
518  mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
519  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() after SetOrigin: Bottom",
520  mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
521  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() after SetOrigin: Normal",
522  mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
523 
524  mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
525  }
526 
527  void TestRotate()
528  {
529  // Changing the IndexToWorldTransform to a rotated version by SetIndexToWorldTransform() (keep origin):
530  mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
531  mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
532  vnlmatrix = planegeometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
533  mitk::VnlVector axis(3);
534  mitk::FillVector3D(axis, 1.0, 1.0, 1.0);
535  axis.normalize();
536  vnl_quaternion<mitk::ScalarType> rotation(axis, 0.223);
537  vnlmatrix = rotation.rotation_matrix_transpose() * vnlmatrix;
538  mitk::Matrix3D matrix;
539  matrix = vnlmatrix;
540  transform->SetMatrix(matrix);
541  transform->SetOffset(planegeometry->GetIndexToWorldTransform()->GetOffset());
542 
543  right.SetVnlVector(rotation.rotation_matrix_transpose() * right.GetVnlVector());
544  bottom.SetVnlVector(rotation.rotation_matrix_transpose() * bottom.GetVnlVector());
545  normal.SetVnlVector(rotation.rotation_matrix_transpose() * normal.GetVnlVector());
546  planegeometry->SetIndexToWorldTransform(transform);
547 
548  // The origin changed,because m_Origin=m_IndexToWorldTransform->GetOffset()+GetAxisVector(2)*0.5
549  // and the AxisVector changes due to the rotation. In other words: the rotation was done around
550  // the corner of the box, not around the planes origin. Now change it to a rotation around
551  // the origin, simply by re-setting the origin to the original one:
552  planegeometry->SetOrigin(origin);
553 
554  CPPUNIT_ASSERT_MESSAGE("Testing whether SetIndexToWorldTransform kept origin: ",
555  mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
556 
557  mitk::Point2D point;
558  point[0] = 4;
559  point[1] = 3;
560  mitk::Point2D dummy;
561  planegeometry->WorldToIndex(point, dummy);
562  planegeometry->IndexToWorld(dummy, dummy);
563  CPPUNIT_ASSERT_MESSAGE("Testing consistency of index and world coordinates.", dummy == point);
564 
565  CPPUNIT_ASSERT_MESSAGE("Testing width of rotated version: ",
566  mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
567  CPPUNIT_ASSERT_MESSAGE("Testing height of rotated version: ",
568  mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
569  CPPUNIT_ASSERT_MESSAGE("Testing thickness of rotated version: ",
570  mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
571 
572  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of rotated version: right ",
573  mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
574  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of rotated version: bottom",
575  mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
576  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of rotated version: normal",
577  mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
578 
579  CPPUNIT_ASSERT_MESSAGE(
580  "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
581  mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(), planegeometry->GetExtentInMM(0), testEps));
582  CPPUNIT_ASSERT_MESSAGE(
583  "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
584  mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(), planegeometry->GetExtentInMM(1), testEps));
585  CPPUNIT_ASSERT_MESSAGE(
586  "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
587  mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(), planegeometry->GetExtentInMM(2), testEps));
588 
589  mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
590 
591  width *= 2;
592  height *= 3;
593  planegeometry->SetSizeInUnits(width, height);
594  CPPUNIT_ASSERT_MESSAGE("Testing SetSizeInUnits() of rotated version: ",
595  mitk::Equal(planegeometry->GetExtent(0), width, testEps));
596  CPPUNIT_ASSERT_MESSAGE("Testing SetSizeInUnits() of rotated version: ",
597  mitk::Equal(planegeometry->GetExtent(1), height, testEps));
598  CPPUNIT_ASSERT_MESSAGE("Testing SetSizeInUnits() of rotated version: ",
599  mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
600 
601  CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of version with changed size in units: ",
602  mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
603  CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of version with changed size in units: ",
604  mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
605  CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of version with changed size in units: ",
606  mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
607 
608  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of version with changed size in units: right ",
609  mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
610  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of version with changed size in units: bottom",
611  mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
612  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of version with changed size in units: normal",
613  mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
614 
615  CPPUNIT_ASSERT_MESSAGE(
616  "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
617  mitk::Equal(planegeometry->GetAxisVector(0).GetNorm(), planegeometry->GetExtentInMM(0), testEps));
618  CPPUNIT_ASSERT_MESSAGE(
619  "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
620  mitk::Equal(planegeometry->GetAxisVector(1).GetNorm(), planegeometry->GetExtentInMM(1), testEps));
621  CPPUNIT_ASSERT_MESSAGE(
622  "Testing GetAxisVector(direction).GetNorm() != planegeometry->GetExtentInMM(direction) of rotated version: ",
623  mitk::Equal(planegeometry->GetAxisVector(2).GetNorm(), planegeometry->GetExtentInMM(2), testEps));
624 
625  mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
626  }
627 
628  void TestClone()
629  {
630  mitk::PlaneGeometry::Pointer clonedplanegeometry =
631  dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
632  // Cave: Statement below is negated!
633  CPPUNIT_ASSERT_MESSAGE("Testing Clone(): ",
634  !((clonedplanegeometry.IsNull()) || (clonedplanegeometry->GetReferenceCount() != 1)));
635  CPPUNIT_ASSERT_MESSAGE("Testing origin of cloned version: ",
636  mitk::Equal(clonedplanegeometry->GetOrigin(), origin, testEps));
637 
638  CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of cloned version: ",
639  mitk::Equal(clonedplanegeometry->GetExtent(0), width, testEps));
640  CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of cloned version: ",
641  mitk::Equal(clonedplanegeometry->GetExtent(1), height, testEps));
642  CPPUNIT_ASSERT_MESSAGE("Testing extent (in units) of cloned version: ",
643  mitk::Equal(clonedplanegeometry->GetExtent(2), 1, testEps));
644 
645  CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of cloned version: ",
646  mitk::Equal(clonedplanegeometry->GetExtentInMM(0), widthInMM, testEps));
647  CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of cloned version: ",
648  mitk::Equal(clonedplanegeometry->GetExtentInMM(1), heightInMM, testEps));
649  CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of cloned version: ",
650  mitk::Equal(clonedplanegeometry->GetExtentInMM(2), thicknessInMM, testEps));
651 
652  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of cloned version: right",
653  mitk::Equal(clonedplanegeometry->GetAxisVector(0), right, testEps));
654  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of cloned version: bottom",
655  mitk::Equal(clonedplanegeometry->GetAxisVector(1), bottom, testEps));
656  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of cloned version: normal",
657  mitk::Equal(clonedplanegeometry->GetAxisVector(2), normal, testEps));
658 
659  mappingTests2D(clonedplanegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
660  }
661 
662  void TestSaggitalInitialization()
663  {
664  mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
665  mitk::PlaneGeometry::Pointer clonedplanegeometry = planegeometry->Clone();
666 
667  // Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Sagittal, zPosition = 0, frontside=true):
668  planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Sagittal);
669 
670  mitk::Vector3D newright, newbottom, newnormal;
671  mitk::ScalarType newthicknessInMM;
672 
673  newright = bottom;
674  newthicknessInMM = widthInMM / width * 1.0; // extent in normal direction is 1;
675  newnormal = right;
676  newnormal.Normalize();
677  newnormal *= newthicknessInMM;
678  newbottom = normal;
679  newbottom.Normalize();
680  newbottom *= thicknessInMM;
681 
682  CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of sagitally initialized version:",
683  mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0, testEps));
684 
685  // ok, corner was fine, so we can dare to believe the origin is ok.
686  origin = planegeometry->GetOrigin();
687 
688  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagitally initialized version: ",
689  mitk::Equal(planegeometry->GetExtent(0), height, testEps));
690  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagitally initialized version: ",
691  mitk::Equal(planegeometry->GetExtent(1), 1, testEps));
692  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of sagitally initialized version: ",
693  mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
694 
695  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagitally initialized version: ",
696  mitk::Equal(planegeometry->GetExtentInMM(0), heightInMM, testEps));
697  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagitally initialized version: ",
698  mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
699  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of sagitally initialized version: ",
700  mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps));
701 
702  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagitally initialized version: ",
703  mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
704  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagitally initialized version: ",
705  mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
706  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of sagitally initialized version: ",
707  mitk::Equal(planegeometry->GetAxisVector(2), newnormal, testEps));
708 
709  mappingTests2D(planegeometry, height, 1, heightInMM, thicknessInMM, origin, newright, newbottom);
710 
711  // set origin back to the one of the axial slice:
712  origin = clonedplanegeometry->GetOrigin();
713  // Testing backside initialization: InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition
714  // = 0, frontside=false, rotated=true):
715  planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Axial, 0, false, true);
716  mitk::Point3D backsideorigin;
717  backsideorigin = origin + clonedplanegeometry->GetAxisVector(1); //+clonedplanegeometry->GetAxisVector(2);
718 
719  CPPUNIT_ASSERT_MESSAGE("Testing origin of backsidedly, axially initialized version: ",
720  mitk::Equal(planegeometry->GetOrigin(), backsideorigin, testEps));
721 
722  mitk::Point3D backsidecornerpoint0;
723  backsidecornerpoint0 =
724  cornerpoint0 + clonedplanegeometry->GetAxisVector(1); //+clonedplanegeometry->GetAxisVector(2);
725  CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of sagitally initialized version: ",
726  mitk::Equal(planegeometry->GetCornerPoint(0), backsidecornerpoint0, testEps));
727 
728  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of backsidedly, axially initialized version "
729  "(should be same as in mm due to unit spacing, except for thickness, which is always 1): ",
730  mitk::Equal(planegeometry->GetExtent(0), width, testEps));
731  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of backsidedly, axially initialized version "
732  "(should be same as in mm due to unit spacing, except for thickness, which is always 1): ",
733  mitk::Equal(planegeometry->GetExtent(1), height, testEps));
734  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in units) of backsidedly, axially initialized version "
735  "(should be same as in mm due to unit spacing, except for thickness, which is always 1): ",
736  mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
737 
738  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ",
739  mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
740  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ",
741  mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
742  CPPUNIT_ASSERT_MESSAGE("Testing width, height and thickness (in mm) of backsidedly, axially initialized version: ",
743  mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
744 
745  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of backsidedly, axially initialized version: ",
746  mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
747  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of backsidedly, axially initialized version: ",
748  mitk::Equal(planegeometry->GetAxisVector(1), -bottom, testEps));
749  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of backsidedly, axially initialized version: ",
750  mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps)); // T22254: Flipped sign
751 
752  mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, backsideorigin, right, -bottom);
753  }
754 
755  void TestFrontalInitialization()
756  {
757  mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
758 
759  mitk::PlaneGeometry::Pointer clonedplanegeometry =
760  dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
761  //--------
762 
763  mitk::Vector3D newright, newbottom, newnormal;
764  mitk::ScalarType newthicknessInMM;
765 
766  // Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Frontal, zPosition = 0, frontside=true)
767  planegeometry->InitializeStandardPlane(clonedplanegeometry, mitk::PlaneGeometry::Frontal);
768  newright = right;
769  newbottom = normal;
770  newbottom.Normalize();
771  newbottom *= thicknessInMM;
772  newthicknessInMM = heightInMM / height * 1.0 /*extent in normal direction is 1*/;
773  newnormal = -bottom;
774  newnormal.Normalize();
775  newnormal *= newthicknessInMM;
776 
777  CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of frontally initialized version: ",
778  mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0, testEps));
779 
780  // ok, corner was fine, so we can dare to believe the origin is ok.
781  origin = planegeometry->GetOrigin();
782 
783  CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of frontally initialized version: ",
784  mitk::Equal(planegeometry->GetExtent(0), width, testEps));
785  CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of frontally initialized version: ",
786  mitk::Equal(planegeometry->GetExtent(1), 1, testEps));
787  CPPUNIT_ASSERT_MESSAGE("Testing thickness (in units) of frontally initialized version: ",
788  mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
789 
790  CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of frontally initialized version: ",
791  mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
792  CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of frontally initialized version: ",
793  mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
794  CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of frontally initialized version: ",
795  mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps));
796 
797  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of frontally initialized version: ",
798  mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
799  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of frontally initialized version: ",
800  mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
801  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of frontally initialized version: ",
802  mitk::Equal(planegeometry->GetAxisVector(2), -newnormal, testEps)); // T22254: Flipped sign
803 
804  mappingTests2D(planegeometry, width, 1, widthInMM, thicknessInMM, origin, newright, newbottom);
805 
806  // Changing plane to in-plane unit spacing using SetSizeInUnits:
807  planegeometry->SetSizeInUnits(planegeometry->GetExtentInMM(0), planegeometry->GetExtentInMM(1));
808 
809  CPPUNIT_ASSERT_MESSAGE("Testing origin of unit spaced, frontally initialized version: ",
810  mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
811 
812  CPPUNIT_ASSERT_MESSAGE(
813  "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
814  mitk::Equal(planegeometry->GetExtent(0), widthInMM, testEps));
815  CPPUNIT_ASSERT_MESSAGE(
816  "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
817  mitk::Equal(planegeometry->GetExtent(1), thicknessInMM, testEps));
818  CPPUNIT_ASSERT_MESSAGE(
819  "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
820  mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
821 
822  CPPUNIT_ASSERT_MESSAGE(
823  "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
824  mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
825  CPPUNIT_ASSERT_MESSAGE(
826  "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
827  mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
828  CPPUNIT_ASSERT_MESSAGE(
829  "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
830  mitk::Equal(planegeometry->GetExtentInMM(2), newthicknessInMM, testEps));
831 
832  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
833  mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
834  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
835  mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
836  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
837  mitk::Equal(planegeometry->GetAxisVector(2), -newnormal, testEps)); // T22254: Flipped sign
838 
839  mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
840 
841  // Changing plane to unit spacing also in normal direction using SetExtentInMM(2, 1.0):
842  planegeometry->SetExtentInMM(2, 1.0);
843  newnormal.Normalize();
844 
845  CPPUNIT_ASSERT_MESSAGE("Testing origin of unit spaced, frontally initialized version: ",
846  mitk::Equal(planegeometry->GetOrigin(), origin, testEps));
847 
848  CPPUNIT_ASSERT_MESSAGE(
849  "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
850  mitk::Equal(planegeometry->GetExtent(0), widthInMM, testEps));
851  CPPUNIT_ASSERT_MESSAGE(
852  "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
853  mitk::Equal(planegeometry->GetExtent(1), thicknessInMM, testEps));
854  CPPUNIT_ASSERT_MESSAGE(
855  "Testing width, height and thickness (in units) of unit spaced, frontally initialized version: ",
856  mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
857 
858  CPPUNIT_ASSERT_MESSAGE(
859  "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
860  mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
861  CPPUNIT_ASSERT_MESSAGE(
862  "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
863  mitk::Equal(planegeometry->GetExtentInMM(1), thicknessInMM, testEps));
864  CPPUNIT_ASSERT_MESSAGE(
865  "Testing width, height and thickness (in mm) of unit spaced, frontally initialized version: ",
866  mitk::Equal(planegeometry->GetExtentInMM(2), 1.0, testEps));
867 
868  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
869  mitk::Equal(planegeometry->GetAxisVector(0), newright, testEps));
870  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
871  mitk::Equal(planegeometry->GetAxisVector(1), newbottom, testEps));
872  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of unit spaced, frontally initialized version: ",
873  mitk::Equal(planegeometry->GetAxisVector(2), -newnormal, testEps)); // T22254: Flipped sign
874  mappingTests2D(planegeometry, widthInMM, thicknessInMM, widthInMM, thicknessInMM, origin, newright, newbottom);
875  }
876 
877  void TestAxialInitialization()
878  {
879  mitk::Point3D cornerpoint0 = planegeometry->GetCornerPoint(0);
880 
881  // Clone, move, rotate and test for 'IsParallel' and 'IsOnPlane'
882  mitk::PlaneGeometry::Pointer clonedplanegeometry =
883  dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
884 
885  CPPUNIT_ASSERT_MESSAGE("Testing Clone(): ",
886  !((clonedplanegeometry.IsNull()) || (clonedplanegeometry->GetReferenceCount() != 1)));
887 
888  std::cout << "Testing InitializeStandardPlane(clonedplanegeometry, planeorientation = Axial, zPosition = 0, "
889  "frontside=true): "
890  << std::endl;
891  planegeometry->InitializeStandardPlane(clonedplanegeometry);
892 
893  CPPUNIT_ASSERT_MESSAGE("Testing origin of axially initialized version: ",
894  mitk::Equal(planegeometry->GetOrigin(), origin));
895 
896  CPPUNIT_ASSERT_MESSAGE("Testing GetCornerPoint(0) of axially initialized version: ",
897  mitk::Equal(planegeometry->GetCornerPoint(0), cornerpoint0));
898 
899  CPPUNIT_ASSERT_MESSAGE("Testing width (in units) of axially initialized version (should be same as in mm due to "
900  "unit spacing, except for thickness, which is always 1): ",
901  mitk::Equal(planegeometry->GetExtent(0), width, testEps));
902  CPPUNIT_ASSERT_MESSAGE("Testing height (in units) of axially initialized version (should be same as in mm due to "
903  "unit spacing, except for thickness, which is always 1): ",
904  mitk::Equal(planegeometry->GetExtent(1), height, testEps));
905  CPPUNIT_ASSERT_MESSAGE("Testing thickness (in units) of axially initialized version (should be same as in mm due "
906  "to unit spacing, except for thickness, which is always 1): ",
907  mitk::Equal(planegeometry->GetExtent(2), 1, testEps));
908 
909  CPPUNIT_ASSERT_MESSAGE("Testing width (in mm) of axially initialized version: ",
910  mitk::Equal(planegeometry->GetExtentInMM(0), widthInMM, testEps));
911  CPPUNIT_ASSERT_MESSAGE("Testing height (in mm) of axially initialized version: ",
912  mitk::Equal(planegeometry->GetExtentInMM(1), heightInMM, testEps));
913  CPPUNIT_ASSERT_MESSAGE("Testing thickness (in mm) of axially initialized version: ",
914  mitk::Equal(planegeometry->GetExtentInMM(2), thicknessInMM, testEps));
915 
916  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of axially initialized version: ",
917  mitk::Equal(planegeometry->GetAxisVector(0), right, testEps));
918  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of axially initialized version: ",
919  mitk::Equal(planegeometry->GetAxisVector(1), bottom, testEps));
920  CPPUNIT_ASSERT_MESSAGE("Testing GetAxisVector() of axially initialized version: ",
921  mitk::Equal(planegeometry->GetAxisVector(2), normal, testEps));
922 
923  mappingTests2D(planegeometry, width, height, widthInMM, heightInMM, origin, right, bottom);
924  }
925 
926  void TestPlaneComparison()
927  {
928  // Clone, move, rotate and test for 'IsParallel' and 'IsOnPlane'
929  mitk::PlaneGeometry::Pointer clonedplanegeometry2 =
930  dynamic_cast<mitk::PlaneGeometry *>(planegeometry->Clone().GetPointer());
931 
932  CPPUNIT_ASSERT_MESSAGE("Testing Clone(): ",
933  !((clonedplanegeometry2.IsNull()) || (clonedplanegeometry2->GetReferenceCount() != 1)));
934  CPPUNIT_ASSERT_MESSAGE("Testing wheter original and clone are at the same position",
935  clonedplanegeometry2->IsOnPlane(planegeometry.GetPointer()));
936  CPPUNIT_ASSERT_MESSAGE(" Asserting that origin is on the plane cloned plane:",
937  clonedplanegeometry2->IsOnPlane(origin));
938 
939  mitk::VnlVector newaxis(3);
940  mitk::FillVector3D(newaxis, 1.0, 1.0, 1.0);
941  newaxis.normalize();
942  vnl_quaternion<mitk::ScalarType> rotation2(newaxis, 0.0);
943 
944  mitk::Vector3D clonednormal = clonedplanegeometry2->GetNormal();
945  mitk::Point3D clonedorigin = clonedplanegeometry2->GetOrigin();
946 
947  auto planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), 180.0);
948 
949  clonedplanegeometry2->ExecuteOperation(planerot);
950  CPPUNIT_ASSERT_MESSAGE(" Asserting that a flipped plane is still on the original plane: ",
951  clonedplanegeometry2->IsOnPlane(planegeometry.GetPointer()));
952 
953  clonedorigin += clonednormal;
954  clonedplanegeometry2->SetOrigin(clonedorigin);
955 
956  CPPUNIT_ASSERT_MESSAGE("Testing if the translated (cloned, flipped) plane is parallel to its origin plane: ",
957  clonedplanegeometry2->IsParallel(planegeometry));
958  delete planerot;
959 
960  planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), 0.5);
961  clonedplanegeometry2->ExecuteOperation(planerot);
962 
963  CPPUNIT_ASSERT_MESSAGE("Testing if a non-paralell plane gets recognized as not paralell [rotation +0.5 degree] : ",
964  !clonedplanegeometry2->IsParallel(planegeometry));
965  delete planerot;
966 
967  planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), -1.0);
968  clonedplanegeometry2->ExecuteOperation(planerot);
969 
970  CPPUNIT_ASSERT_MESSAGE("Testing if a non-paralell plane gets recognized as not paralell [rotation -0.5 degree] : ",
971  !clonedplanegeometry2->IsParallel(planegeometry));
972  delete planerot;
973 
974  planerot = new mitk::RotationOperation(mitk::OpROTATE, origin, clonedplanegeometry2->GetAxisVector(0), 360.5);
975  clonedplanegeometry2->ExecuteOperation(planerot);
976 
977  CPPUNIT_ASSERT_MESSAGE("Testing if a non-paralell plane gets recognized as paralell [rotation 360 degree] : ",
978  clonedplanegeometry2->IsParallel(planegeometry));
979  }
980 
981 private:
982  // helper Methods for the Tests
983 
984  mitk::PlaneGeometry::Pointer createPlaneGeometry()
985  {
986  mitk::Vector3D mySpacing;
987  mySpacing[0] = 31;
988  mySpacing[1] = 0.1;
989  mySpacing[2] = 5.4;
990  mitk::Point3D myOrigin;
991  myOrigin[0] = 8;
992  myOrigin[1] = 9;
993  myOrigin[2] = 10;
994  mitk::AffineTransform3D::Pointer myTransform = mitk::AffineTransform3D::New();
995  itk::Matrix<mitk::ScalarType, 3, 3> transMatrix;
996  transMatrix.Fill(0);
997  transMatrix[0][0] = 1;
998  transMatrix[1][1] = 2;
999  transMatrix[2][2] = 4;
1000 
1001  myTransform->SetMatrix(transMatrix);
1002 
1003  mitk::PlaneGeometry::Pointer geometry2D = mitk::PlaneGeometry::New();
1004  geometry2D->SetIndexToWorldTransform(myTransform);
1005  geometry2D->SetSpacing(mySpacing);
1006  geometry2D->SetOrigin(myOrigin);
1007  return geometry2D;
1008  }
1009 
1010  bool compareMatrix(itk::Matrix<mitk::ScalarType, 3, 3> left, itk::Matrix<mitk::ScalarType, 3, 3> right)
1011  {
1012  bool equal = true;
1013  for (int i = 0; i < 3; ++i)
1014  for (int j = 0; j < 3; ++j)
1015  equal &= mitk::Equal(left[i][j], right[i][j]);
1016  return equal;
1017  }
1018 
1022  void mappingTests2D(const mitk::PlaneGeometry *planegeometry,
1023  const mitk::ScalarType &width,
1024  const mitk::ScalarType &height,
1025  const mitk::ScalarType &widthInMM,
1026  const mitk::ScalarType &heightInMM,
1027  const mitk::Point3D &origin,
1028  const mitk::Vector3D &right,
1029  const mitk::Vector3D &bottom)
1030  {
1031  std::cout << "Testing mapping Map(pt2d_mm(x=widthInMM/2.3,y=heightInMM/2.5), pt3d_mm) and compare with expected: ";
1032  mitk::Point2D pt2d_mm;
1033  mitk::Point3D pt3d_mm, expected_pt3d_mm;
1034  pt2d_mm[0] = widthInMM / 2.3;
1035  pt2d_mm[1] = heightInMM / 2.5;
1036  expected_pt3d_mm = origin + right * (pt2d_mm[0] / right.GetNorm()) + bottom * (pt2d_mm[1] / bottom.GetNorm());
1037  planegeometry->Map(pt2d_mm, pt3d_mm);
1038  CPPUNIT_ASSERT_MESSAGE(
1039  "Testing mapping Map(pt2d_mm(x=widthInMM/2.3,y=heightInMM/2.5), pt3d_mm) and compare with expected",
1040  mitk::Equal(pt3d_mm, expected_pt3d_mm, testEps));
1041 
1042  std::cout << "Testing mapping Map(pt3d_mm, pt2d_mm) and compare with expected: ";
1043  mitk::Point2D testpt2d_mm;
1044  planegeometry->Map(pt3d_mm, testpt2d_mm);
1045  std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
1046  std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
1047  std::cout << std::setprecision(12) << "10*mitk::eps " << 10 * mitk::eps << std::endl;
1048  // This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
1049  CPPUNIT_ASSERT_MESSAGE("Testing mapping Map(pt3d_mm, pt2d_mm) and compare with expected",
1050  mitk::Equal(pt2d_mm, testpt2d_mm, 10 * mitk::eps));
1051 
1052  std::cout << "Testing IndexToWorld(pt2d_units, pt2d_mm) and compare with expected: ";
1053  mitk::Point2D pt2d_units;
1054  pt2d_units[0] = width / 2.0;
1055  pt2d_units[1] = height / 2.0;
1056  pt2d_mm[0] = widthInMM / 2.0;
1057  pt2d_mm[1] = heightInMM / 2.0;
1058  planegeometry->IndexToWorld(pt2d_units, testpt2d_mm);
1059  std::cout << std::setprecision(12) << "Expected pt2d_mm " << pt2d_mm << std::endl;
1060  std::cout << std::setprecision(12) << "Result testpt2d_mm " << testpt2d_mm << std::endl;
1061  std::cout << std::setprecision(12) << "10*mitk::eps " << 10 * mitk::eps << std::endl;
1062  // This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
1063  CPPUNIT_ASSERT_MESSAGE("Testing IndexToWorld(pt2d_units, pt2d_mm) and compare with expected: ",
1064  mitk::Equal(pt2d_mm, testpt2d_mm, 10 * mitk::eps));
1065 
1066  std::cout << "Testing WorldToIndex(pt2d_mm, pt2d_units) and compare with expected: ";
1067  mitk::Point2D testpt2d_units;
1068  planegeometry->WorldToIndex(pt2d_mm, testpt2d_units);
1069 
1070  std::cout << std::setprecision(12) << "Expected pt2d_units " << pt2d_units << std::endl;
1071  std::cout << std::setprecision(12) << "Result testpt2d_units " << testpt2d_units << std::endl;
1072  std::cout << std::setprecision(12) << "10*mitk::eps " << 10 * mitk::eps << std::endl;
1073  // This eps is temporarily set to 10*mitk::eps. See bug #15037 for details.
1074  CPPUNIT_ASSERT_MESSAGE("Testing WorldToIndex(pt2d_mm, pt2d_units) and compare with expected:",
1075  mitk::Equal(pt2d_units, testpt2d_units, 10 * mitk::eps));
1076  }
1077 };
1078 MITK_TEST_SUITE_REGISTRATION(mitkPlaneGeometry)
mitk::Line
Descibes a line.
Definition: mitkLine.h:32
mitk::Pointer
itk::SmartPointer< Self > Pointer
Definition: mitkRenderingManager.h:389
mitk::Geometry3D
Standard implementation of BaseGeometry.
Definition: mitkGeometry3D.h:37
MITK_TEST_SUITE_REGISTRATION
MITK_TEST_SUITE_REGISTRATION(mitkImageToItk)
mitk::MatrixEqualElementWise
bool MatrixEqualElementWise(const vnl_matrix_fixed< TCoordRep, NRows, NCols > &matrix1, const vnl_matrix_fixed< TCoordRep, NRows, NCols > &matrix2, mitk::ScalarType epsilon=mitk::eps)
Check for element-wise matrix equality with a user defined accuracy.
Definition: mitkMatrix.h:144
mitk::SlicedGeometry3D::New
static Pointer New()
mitk::PlaneGeometry::Map
virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const
Project a 3D point given in mm (pt3d_mm) onto the 2D geometry. The result is a 2D point in mm (pt2d_m...
Definition: mitkPlaneGeometry.cpp:869
mitk::VnlVector
vnl_vector< ScalarType > VnlVector
Definition: mitkVector.h:138
mitk::ScalarType
double ScalarType
Definition: mitkNumericConstants.h:24
MITK_TEST
#define MITK_TEST(TESTMETHOD)
Adds a test to the current test suite.
Definition: mitkTestingMacros.h:306
mitk::PlaneGeometry::Axial
Definition: mitkPlaneGeometry.h:89
mitk::Geometry3D::New
static Pointer New()
mitkInteractionConst.h
Constants for most interaction classes, due to the generic StateMachines.
rotation
static Matrix3D rotation
Definition: mitkAffineTransformBaseTest.cpp:28
mitk::PlaneGeometry::WorldToIndex
virtual void WorldToIndex(const Point2D &pt_mm, Point2D &pt_units) const
Definition: mitkPlaneGeometry.cpp:128
mitk::PlaneGeometry::IndexToWorld
virtual void IndexToWorld(const Point2D &pt_units, Point2D &pt_mm) const
Definition: mitkPlaneGeometry.cpp:122
mitk::PlaneGeometry::Frontal
Definition: mitkPlaneGeometry.h:91
mitk::FillVector3D
void FillVector3D(Tout &out, mitk::ScalarType x, mitk::ScalarType y, mitk::ScalarType z)
Definition: mitkArray.h:110
mitk::BaseGeometry::Pointer
itk::SmartPointer< Self > Pointer
Definition: mitkBaseGeometry.h:104
MITK_TEST_OUTPUT
#define MITK_TEST_OUTPUT(x)
Output some text.
Definition: mitkTestingMacros.h:54
clone
static void clone(T *&dst, S *src, int n)
Definition: svm.cpp:73
mitk::TestFixture
Test fixture for parameterized tests.
Definition: mitkTestFixture.h:90
mitk::AbstractTransformGeometry
Describes a geometry defined by an vtkAbstractTransform and a plane.
Definition: mitkAbstractTransformGeometry.h:48
createPlaneGeometry
static mitk::PlaneGeometry::Pointer createPlaneGeometry()
Definition: mitkSlicedGeometry3DTest.cpp:30
testEps
static const mitk::ScalarType testEps
Definition: mitkPlaneGeometryTest.cpp:36
mitk::sqrteps
MITKCORE_EXPORT const ScalarType sqrteps
Definition: mitkNumericConstants.cpp:22
mitk::Equal
MITKNEWMODULE_EXPORT bool Equal(mitk::ExampleDataStructure *leftHandSide, mitk::ExampleDataStructure *rightHandSide, mitk::ScalarType eps, bool verbose)
Returns true if the example data structures are considered equal.
Definition: mitkExampleDataStructure.cpp:60
mitk::PlaneGeometry::New
static Pointer New()
mitk::eps
MITKCORE_EXPORT const ScalarType eps
Definition: mitkNumericConstants.cpp:21
mitk::PlaneGeometry
Describes a two-dimensional, rectangular plane.
Definition: mitkPlaneGeometry.h:80
mitk::RotationOperation
Operation, that holds everything necessary for an rotation operation on mitk::BaseData.
Definition: mitkRotationOperation.h:29
mitk::BaseGeometry
BaseGeometry Describes the geometry of a data object.
Definition: mitkBaseGeometry.h:101
mitk::PlaneGeometry::Sagittal
Definition: mitkPlaneGeometry.h:90
mitk::New
static itkEventMacro(BoundingShapeInteractionEvent, itk::AnyEvent) class MITKBOUNDINGSHAPE_EXPORT BoundingShapeInteractor Pointer New()
Basic interaction methods for mitk::GeometryData.