Medical Imaging Interaction Toolkit  2016.11.0
Medical Imaging Interaction Toolkit
mitkTimeGeometryTest.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 "mitkGeometry3D.h"
18 #include "mitkTimeGeometry.h"
19 
20 #include "mitkInteractionConst.h"
21 #include "mitkRotationOperation.h"
22 #include <mitkImageCast.h>
23 #include <mitkMatrixConvert.h>
24 
25 #include "mitkTestingMacros.h"
26 #include <fstream>
27 #include <mitkVector.h>
28 
29 #include "mitkImageGenerator.h"
30 #include "mitkPointSet.h"
31 #include <limits>
32 #include <mitkStandaloneDataStorage.h>
33 
34 static const mitk::ScalarType test_eps = 1E-6; /* some reference values in the test seem
35 to have been calculated with float precision. Thus, set this to float precision epsilon.*/
36 static const mitk::ScalarType test_eps_square = 1E-3;
37 
38 class mitkTimeGeometryTestClass
39 {
40 public:
41  void Translation_Image_MovedOrigin(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
42  {
43  // DimX, DimY, DimZ,
44  mitk::Image::Pointer image =
45  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
46  mitk::BaseGeometry::Pointer geometry = image->GetTimeGeometry()->GetGeometryForTimeStep(0);
47  mitk::Point3D imageOrigin = geometry->GetOrigin();
48  mitk::Point3D expectedOrigin;
49  expectedOrigin[0] = 0;
50  expectedOrigin[1] = 0;
51  expectedOrigin[2] = 0;
52  MITK_TEST_CONDITION(mitk::Equal(imageOrigin, expectedOrigin), "Original origin match expected origin");
53 
54  expectedOrigin[0] = 0.325;
55  expectedOrigin[1] = 0.487;
56  expectedOrigin[2] = 0.78;
57 
58  mitk::Vector3D translationVector;
59  translationVector[0] = expectedOrigin[0];
60  translationVector[1] = expectedOrigin[1];
61  translationVector[2] = expectedOrigin[2];
62 
63  for (mitk::TimeStepType timeStep = 0; timeStep < image->GetTimeGeometry()->CountTimeSteps(); ++timeStep)
64  {
65  image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep)->Translate(translationVector);
66  }
67  imageOrigin = image->GetGeometry(0)->GetOrigin();
68  MITK_TEST_CONDITION(mitk::Equal(imageOrigin, expectedOrigin), "Translated origin match expected origin");
69 
70  expectedOrigin[0] = 2 * translationVector[0];
71  expectedOrigin[1] = 2 * translationVector[1];
72  expectedOrigin[2] = 2 * translationVector[2];
73 
74  for (mitk::TimeStepType timeStep = 0; timeStep < image->GetTimeGeometry()->CountTimeSteps(); ++timeStep)
75  {
76  image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep)->Translate(translationVector);
77  }
78  imageOrigin = image->GetGeometry(0)->GetOrigin();
79  MITK_TEST_CONDITION(mitk::Equal(imageOrigin, expectedOrigin), "Translated origin match expected origin");
80  }
81 
82  void Rotate_Image_RotatedPoint(mitk::BaseData *baseData,
83  unsigned int /*DimX*/,
84  unsigned int /*DimY*/,
85  unsigned int /*DimZ*/,
86  unsigned int /*DimT*/)
87  {
88  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
89  mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
90 
91  // DimX, DimY, DimZ,
92  dataNode->SetData(baseData);
93  ds->Add(dataNode);
94  mitk::BaseGeometry::Pointer geometry = baseData->GetTimeGeometry()->GetGeometryForTimeStep(0);
95  mitk::Point3D expectedPoint;
96  expectedPoint[0] = 3 * 0.5;
97  expectedPoint[1] = 3 * 0.33;
98  expectedPoint[2] = 3 * 0.78;
99  mitk::Point3D originalPoint;
100  originalPoint[0] = 3;
101  originalPoint[1] = 3;
102  originalPoint[2] = 3;
103  mitk::Point3D worldPoint;
104  geometry->IndexToWorld(originalPoint, worldPoint);
105  MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint, test_eps),
106  "Index-to-World without rotation as expected ");
107 
108  mitk::Point3D pointOfRotation;
109  pointOfRotation[0] = 0;
110  pointOfRotation[1] = 0;
111  pointOfRotation[2] = 0;
112  mitk::Vector3D vectorOfRotation;
113  vectorOfRotation[0] = 1;
114  vectorOfRotation[1] = 0.5;
115  vectorOfRotation[2] = 0.2;
116  mitk::ScalarType angleOfRotation = 73.0;
117  auto rotation = new mitk::RotationOperation(mitk::OpROTATE, pointOfRotation, vectorOfRotation, angleOfRotation);
118 
119  baseData->GetTimeGeometry()->ExecuteOperation(rotation);
120  delete rotation;
121 
122  expectedPoint[0] = 2.6080379;
123  expectedPoint[1] = -0.75265157;
124  expectedPoint[2] = 1.1564401;
125 
126  baseData->GetGeometry(0)->IndexToWorld(originalPoint, worldPoint);
127  MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint, test_eps), "Rotation returns expected values ");
128  }
129 
130  void Scale_Image_ScaledPoint(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
131  {
132  // DimX, DimY, DimZ,
133  mitk::Image::Pointer image =
134  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
135  mitk::BaseGeometry::Pointer geometry = image->GetTimeGeometry()->GetGeometryForTimeStep(0);
136  mitk::Point3D expectedPoint;
137  expectedPoint[0] = 3 * 0.5;
138  expectedPoint[1] = 3 * 0.33;
139  expectedPoint[2] = 3 * 0.78;
140  mitk::Point3D originalPoint;
141  originalPoint[0] = 3;
142  originalPoint[1] = 3;
143  originalPoint[2] = 3;
144  mitk::Point3D worldPoint;
145  geometry->IndexToWorld(originalPoint, worldPoint);
146  MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint, test_eps),
147  "Index-to-World with old Scaling as expected ");
148 
149  mitk::Vector3D newSpacing;
150  newSpacing[0] = 2;
151  newSpacing[1] = 1.254;
152  newSpacing[2] = 0.224;
153  image->SetSpacing(newSpacing);
154  expectedPoint[0] = 3 * 2;
155  expectedPoint[1] = 3 * 1.254;
156  expectedPoint[2] = 3 * 0.224;
157 
158  image->GetGeometry(0)->IndexToWorld(originalPoint, worldPoint);
159  MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint),
160  "Index-toWorld with new Scaling returns expected values ");
161  }
162 
163  void GetMinimumTimePoint_4DBaseData_Zero(mitk::BaseData *baseData, unsigned int /*DimT*/)
164  {
165  baseData->Update();
166  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
167  mitk::TimePointType expectedTimePoint = geometry->GetMinimumTimePoint();
168  MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, 0), "Returns correct minimum time point ");
169  }
170 
171  void GetMaximumTimePoint_4DBaseData_DimT(mitk::BaseData *baseData, unsigned int DimT)
172  {
173  baseData->Update();
174  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
175  mitk::TimePointType expectedTimePoint = geometry->GetMaximumTimePoint();
176  MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, DimT), "Returns correct maximum time point ");
177  }
178 
179  void CountTimeSteps_Image_ReturnDimT(
180  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
181  {
182  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
183  mitk::TimeStepType expectedTimeSteps = geometry->CountTimeSteps();
184  MITK_TEST_CONDITION(mitk::Equal(expectedTimeSteps, DimT), "Returns correct number of time Steps ");
185  }
186 
187  void GetMinimumTimePoint_3DImage_Min(mitk::BaseData *baseData,
188  unsigned int /*DimX*/,
189  unsigned int /*DimY*/,
190  unsigned int /*DimZ*/,
191  unsigned int /*DimT*/)
192  {
193  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
194  mitk::TimePointType expectedTimePoint = geometry->GetMinimumTimePoint();
195  MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, -std::numeric_limits<mitk::TimePointType>().max()),
196  "Returns correct minimum time point ");
197  }
198 
199  void GetMaximumTimePoint_3DImage_Max(mitk::BaseData *baseData,
200  unsigned int /*DimX*/,
201  unsigned int /*DimY*/,
202  unsigned int /*DimZ*/,
203  unsigned int /*DimT*/)
204  {
205  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
206  mitk::TimePointType expectedTimePoint = geometry->GetMaximumTimePoint();
207  MITK_INFO << expectedTimePoint;
208  MITK_INFO << std::numeric_limits<mitk::TimePointType>().max();
209  MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, std::numeric_limits<mitk::TimePointType>().max()),
210  "Returns correct maximum time point ");
211  }
212 
213  void GetTimeBounds_4DImage_ZeroAndDimT(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
214  {
215  mitk::Image::Pointer image =
216  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
217  mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
218  mitk::TimeBounds expectedTimeBounds = geometry->GetTimeBounds();
219  MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[0], 0), "Returns correct minimum time point ");
220  MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[1], DimT), "Returns correct maximum time point ");
221  }
222 
223  void GetTimeBounds_3DImage_ZeroAndDimT(mitk::BaseData *baseData,
224  unsigned int /*DimX*/,
225  unsigned int /*DimY*/,
226  unsigned int /*DimZ*/,
227  unsigned int /*DimT*/)
228  {
229  baseData->Update();
230  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
231  mitk::TimeBounds expectedTimeBounds = geometry->GetTimeBounds();
232  MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[0], -std::numeric_limits<mitk::TimePointType>().max()),
233  "Returns correct minimum time point ");
234  MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[1], std::numeric_limits<mitk::TimePointType>().max()),
235  "Returns correct maximum time point ");
236  }
237 
238  void IsValidTimePoint_ImageValidTimePoint_True(
239  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
240  {
241  baseData->Update();
242  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
243  bool isValid = geometry->IsValidTimePoint(DimT - 1);
244  MITK_TEST_CONDITION(mitk::Equal(isValid, true), "Is valid time Point correct minimum time point ");
245  }
246 
247  void IsValidTimePoint_ImageNegativInvalidTimePoint_False(unsigned int DimX,
248  unsigned int DimY,
249  unsigned int DimZ,
250  unsigned int DimT)
251  {
252  mitk::Image::Pointer image =
253  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
254  mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
255  bool isValid = geometry->IsValidTimePoint(-DimT);
256  MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
257  }
258 
259  void IsValidTimePoint_ImageInvalidTimePoint_False(unsigned int DimX,
260  unsigned int DimY,
261  unsigned int DimZ,
262  unsigned int DimT)
263  {
264  mitk::Image::Pointer image =
265  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
266  mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
267  bool isValid = geometry->IsValidTimePoint(DimT + 1);
268  MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
269  }
270 
271  void IsValidTimeStep_ImageValidTimeStep_True(
272  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
273  {
274  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
275  bool isValid = geometry->IsValidTimeStep(DimT - 1);
276  MITK_TEST_CONDITION(mitk::Equal(isValid, true), "Is valid time Point correct minimum time point ");
277  }
278 
279  void IsValidTimeStep_ImageNegativInvalidTimeStep_False(
280  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
281  {
282  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
283  bool isValid = geometry->IsValidTimeStep(-DimT);
284  MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
285  }
286 
287  void IsValidTimeStep_ImageInvalidTimeStep_False(
288  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
289  {
290  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
291  bool isValid = geometry->IsValidTimeStep(DimT);
292  MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
293  }
294 
295  void TimeStepToTimePoint_ImageValidTimeStep_TimePoint(
296  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
297  {
298  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
299  mitk::TimePointType timePoint = geometry->TimeStepToTimePoint(DimT - 1);
300  MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT - 1), "Calculated right time Point for Time Step ");
301  }
302 
303  void TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(
304  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
305  {
306  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
307  mitk::TimePointType timePoint = geometry->TimeStepToTimePoint(DimT + 1);
308  MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT + 1), "Calculated right time Point for invalid Time Step ");
309  }
310 
311  void TimePointToTimeStep_ImageValidTimePoint_TimePoint(
312  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
313  {
314  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
315  mitk::TimeStepType timePoint = geometry->TimePointToTimeStep(DimT - 0.5);
316  MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT - 1), "Calculated right time step for valid time point");
317  }
318 
319  void TimePointToTimeStep_4DImageInvalidTimePoint_TimePoint(unsigned int DimX,
320  unsigned int DimY,
321  unsigned int DimZ,
322  unsigned int DimT)
323  {
324  mitk::Image::Pointer image =
325  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
326  mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
327  mitk::TimeStepType timePoint = geometry->TimePointToTimeStep(DimT + 1.5);
328  MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT + 1), "Calculated right time step for invalid time point");
329  }
330 
331  void TimePointToTimeStep_4DImageNegativInvalidTimePoint_TimePoint(unsigned int DimX,
332  unsigned int DimY,
333  unsigned int DimZ,
334  unsigned int DimT)
335  {
336  mitk::Image::Pointer image =
337  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
338  mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
339  mitk::TimePointType negativTimePoint = (-1.0 * DimT) - 1.5;
340  mitk::TimeStepType timePoint = geometry->TimePointToTimeStep(negativTimePoint);
341  MITK_TEST_CONDITION(mitk::Equal(timePoint, 0), "Calculated right time step for negativ invalid time point");
342  }
343 
344  void GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(mitk::BaseData *baseData,
345  mitk::ScalarType inputX,
346  mitk::ScalarType inputY,
347  mitk::ScalarType inputZ,
348  mitk::ScalarType outputX,
349  mitk::ScalarType outputY,
350  mitk::ScalarType outputZ,
351  unsigned int DimT)
352  {
353  baseData->Update();
354  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
355  mitk::BaseGeometry::Pointer geometry3D = geometry->GetGeometryForTimeStep(DimT - 1);
356  MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
357 
358  mitk::Point3D expectedPoint;
359  expectedPoint[0] = outputX;
360  expectedPoint[1] = outputY;
361  expectedPoint[2] = outputZ;
362  mitk::Point3D originalPoint;
363  originalPoint[0] = inputX;
364  originalPoint[1] = inputY;
365  originalPoint[2] = inputZ;
366  mitk::Point3D worldPoint;
367  geometry3D->IndexToWorld(originalPoint, worldPoint);
368  MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint, test_eps), "Geometry transformation match expection. ");
369  }
370 
371  void GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(
372  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
373  {
374  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
375  mitk::BaseGeometry::Pointer geometry3D = geometry->GetGeometryForTimeStep(DimT + 1);
376  MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned");
377  }
378 
379  void GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(mitk::BaseData *baseData,
380  mitk::ScalarType inputX,
381  mitk::ScalarType inputY,
382  mitk::ScalarType inputZ,
383  mitk::ScalarType outputX,
384  mitk::ScalarType outputY,
385  mitk::ScalarType outputZ,
386  unsigned int DimT)
387  {
388  baseData->Update();
389  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
390  mitk::BaseGeometry::Pointer geometry3D = geometry->GetGeometryForTimePoint(DimT - 0.5);
391  MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
392 
393  mitk::Point3D expectedPoint;
394  expectedPoint[0] = outputX;
395  expectedPoint[1] = outputY;
396  expectedPoint[2] = outputZ;
397  mitk::Point3D originalPoint;
398  originalPoint[0] = inputX;
399  originalPoint[1] = inputY;
400  originalPoint[2] = inputZ;
401  mitk::Point3D worldPoint;
402  geometry3D->IndexToWorld(originalPoint, worldPoint);
403  MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint, test_eps), "Geometry transformation match expection. ");
404  }
405 
406  void GetGeometryForTimePoint_4DImageInvalidTimePoint_NullPointer(unsigned int DimX,
407  unsigned int DimY,
408  unsigned int DimZ,
409  unsigned int DimT)
410  {
411  mitk::Image::Pointer image =
412  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
413  mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
414  mitk::BaseGeometry::Pointer geometry3D = geometry->GetGeometryForTimePoint(DimT + 1);
415  MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned with invalid time point");
416  }
417 
418  void GetGeometryForTimePoint_4DImageNEgativInvalidTimePoint_NullPointer(unsigned int DimX,
419  unsigned int DimY,
420  unsigned int DimZ,
421  unsigned int DimT)
422  {
423  mitk::Image::Pointer image =
424  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
425  mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
426  mitk::TimePointType timePoint = (-1.0 * (DimT)) - 1;
427  mitk::BaseGeometry::Pointer geometry3D = geometry->GetGeometryForTimePoint(timePoint);
428  MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned with invalid negativ time point");
429  }
430 
431  void GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(mitk::BaseData *baseData, unsigned int DimT)
432  {
433  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
434  mitk::BaseGeometry::Pointer geometry3D = geometry->GetGeometryCloneForTimeStep(DimT - 1);
435  MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
436 
437  mitk::Point3D expectedPoint;
438  mitk::Point3D originalPoint;
439  originalPoint[0] = 3;
440  originalPoint[1] = 3;
441  originalPoint[2] = 3;
442  mitk::Point3D worldPoint;
443  geometry3D->IndexToWorld(originalPoint, expectedPoint);
444 
445  mitk::Vector3D translationVector;
446  translationVector[0] = 5;
447  translationVector[1] = 8;
448  translationVector[2] = 7;
449  geometry3D->Translate(translationVector);
450 
451  geometry3D = geometry->GetGeometryForTimeStep(DimT - 1);
452  geometry3D->IndexToWorld(originalPoint, worldPoint);
453  MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Geometry transformation not changed. ");
454  }
455 
456  void GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(
457  mitk::BaseData *baseData, unsigned int /*DimX*/, unsigned int /*DimY*/, unsigned int /*DimZ*/, unsigned int DimT)
458  {
459  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
460  mitk::BaseGeometry::Pointer geometry3D = geometry->GetGeometryCloneForTimeStep(DimT + 1);
461  MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned");
462  }
463 
464  void SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(mitk::BaseData *baseData,
465  mitk::ScalarType scaleX,
466  mitk::ScalarType scaleY,
467  mitk::ScalarType scaleZ,
468  unsigned int DimT)
469  {
470  baseData->Update();
471  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
472  mitk::BaseGeometry::Pointer geometry3D = geometry->GetGeometryCloneForTimeStep(DimT - 1);
473  MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
474 
475  mitk::Vector3D translationVector;
476  translationVector[0] = 5;
477  translationVector[1] = 8;
478  translationVector[2] = 7;
479  geometry3D->Translate(translationVector);
480 
481  geometry->SetTimeStepGeometry(geometry3D, DimT - 1);
482 
483  mitk::Point3D expectedPoint;
484  expectedPoint[0] = 3 * scaleX + 5;
485  expectedPoint[1] = 3 * scaleY + 8;
486  expectedPoint[2] = 3 * scaleZ + 7;
487  mitk::Point3D originalPoint;
488  originalPoint[0] = 3;
489  originalPoint[1] = 3;
490  originalPoint[2] = 3;
491  mitk::Point3D worldPoint;
492  geometry->GetGeometryForTimeStep(DimT - 1)->IndexToWorld(originalPoint, worldPoint);
493  MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint, test_eps), "Geometry transformation match expection. ");
494  }
495 
496  void Expand_BaseDataDoubleSize_SizeChanged(mitk::BaseData *baseData, unsigned int DimT)
497  {
498  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
499  MITK_TEST_CONDITION(geometry->CountTimeSteps() == DimT, "Number of time Steps match expection. ");
500 
501  geometry->Expand(DimT * 2);
502  MITK_TEST_CONDITION(geometry->CountTimeSteps() == DimT * 2, "Number of time Steps match expection. ");
503 
504  mitk::BaseGeometry::Pointer geometry3D = geometry->GetGeometryForTimeStep(DimT * 2 - 1);
505  MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry is generated. ");
506  }
507 
508  void CheckBounds_BaseData_PointsAsExpected(mitk::BaseData *baseData,
509  mitk::ScalarType minX,
510  mitk::ScalarType minY,
511  mitk::ScalarType minZ,
512  mitk::ScalarType maxX,
513  mitk::ScalarType maxY,
514  mitk::ScalarType maxZ)
515  {
516  baseData->Update();
517  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
518 
519  mitk::Point3D expectedPoint;
520 
521  expectedPoint[0] = minX;
522  expectedPoint[1] = minY;
523  expectedPoint[2] = minZ;
524  mitk::Point3D point = geometry->GetCornerPointInWorld(0);
525  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 0 as expected ");
526  point = geometry->GetCornerPointInWorld(true, true, true);
527  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 0 as expected ");
528 
529  point = geometry->GetCornerPointInWorld(1);
530  expectedPoint[0] = minX;
531  expectedPoint[1] = minY;
532  expectedPoint[2] = maxZ;
533  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "GBounding Point 1 as expected ");
534  point = geometry->GetCornerPointInWorld(true, true, false);
535  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 1 as expected ");
536 
537  point = geometry->GetCornerPointInWorld(2);
538  expectedPoint[0] = minX;
539  expectedPoint[1] = maxY;
540  expectedPoint[2] = minZ;
541  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 2 as expected ");
542  point = geometry->GetCornerPointInWorld(true, false, true);
543  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 2 as expected ");
544 
545  point = geometry->GetCornerPointInWorld(3);
546  expectedPoint[0] = minX;
547  expectedPoint[1] = maxY;
548  expectedPoint[2] = maxZ;
549  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 3 as expected ");
550  point = geometry->GetCornerPointInWorld(true, false, false);
551  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 3 as expected ");
552 
553  point = geometry->GetCornerPointInWorld(4);
554  expectedPoint[0] = maxX;
555  expectedPoint[1] = minY;
556  expectedPoint[2] = minZ;
557  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 4 as expected ");
558  point = geometry->GetCornerPointInWorld(false, true, true);
559  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 4 as expected ");
560 
561  point = geometry->GetCornerPointInWorld(5);
562  expectedPoint[0] = maxX;
563  expectedPoint[1] = minY;
564  expectedPoint[2] = maxZ;
565  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 5 as expected ");
566  point = geometry->GetCornerPointInWorld(false, true, false);
567  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 5 as expected ");
568 
569  point = geometry->GetCornerPointInWorld(6);
570  expectedPoint[0] = maxX;
571  expectedPoint[1] = maxY;
572  expectedPoint[2] = minZ;
573  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 6 as expected ");
574  point = geometry->GetCornerPointInWorld(false, false, true);
575  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 6 as expected ");
576 
577  point = geometry->GetCornerPointInWorld(7);
578  expectedPoint[0] = maxX;
579  expectedPoint[1] = maxY;
580  expectedPoint[2] = maxZ;
581  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 7 as expected ");
582  point = geometry->GetCornerPointInWorld(false, false, false);
583  MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point, test_eps), "Bounding Point 7 as expected ");
584  }
585 
586  void CheckLength_BaseData_AsExpected(mitk::BaseData *baseData, double length, double squareLength)
587  {
588  baseData->Update();
589  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
590 
591  double dimension = geometry->GetDiagonalLengthInWorld();
592  MITK_TEST_CONDITION(mitk::Equal(dimension, length, test_eps), "Length as expected ");
593 
594  dimension = geometry->GetDiagonalLength2InWorld();
595  MITK_TEST_CONDITION(mitk::Equal(dimension, squareLength, test_eps_square), "Square length as expected ");
596  }
597 
598  void CheckPointInside_BaseDataPointInside_True(mitk::BaseData *baseData,
599  mitk::ScalarType pointX,
600  mitk::ScalarType pointY,
601  mitk::ScalarType pointZ)
602  {
603  baseData->Update();
604  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
605 
606  mitk::Point3D expectedPoint;
607 
608  expectedPoint[0] = pointX;
609  expectedPoint[1] = pointY;
610  expectedPoint[2] = pointZ;
611  bool isInside = geometry->IsWorldPointInside(expectedPoint);
612  MITK_TEST_CONDITION(isInside, "Point is inside Image...");
613  }
614 
615  void CheckPointInside_BaseDataPointOutside_False(mitk::BaseData *baseData,
616  mitk::ScalarType pointX,
617  mitk::ScalarType pointY,
618  mitk::ScalarType pointZ)
619  {
620  baseData->Update();
621  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
622 
623  mitk::Point3D expectedPoint;
624 
625  expectedPoint[0] = pointX;
626  expectedPoint[1] = pointY;
627  expectedPoint[2] = pointZ;
628  bool isInside = geometry->IsWorldPointInside(expectedPoint);
629  MITK_TEST_CONDITION(!isInside, "Point is outside Image...");
630  }
631 
632  void CheckBounds_Image_AsSet(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
633  {
634  mitk::Image::Pointer image =
635  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(DimX, DimY, DimZ, DimT, 0.5, 0.33, 0.78, 100);
636  mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
637 
638  mitk::BoundingBox::BoundsArrayType bound = geometry->GetBoundsInWorld();
639  bool isEqual = true;
640  isEqual = isEqual && mitk::Equal(bound[0], -0.5 * 0.5, test_eps);
641  isEqual = isEqual && mitk::Equal(bound[1], 29.5 * 0.5, test_eps);
642  isEqual = isEqual && mitk::Equal(bound[2], -0.5 * 0.33, test_eps);
643  isEqual = isEqual && mitk::Equal(bound[3], 24.5 * 0.33, test_eps);
644  isEqual = isEqual && mitk::Equal(bound[4], -0.5 * 0.78, test_eps);
645  isEqual = isEqual && mitk::Equal(bound[5], 19.5 * 0.78, test_eps);
646 
647  MITK_TEST_CONDITION(isEqual, "Bounds as precalculated...");
648  }
649 
650  void CheckBounds_BaseData_AsSet(mitk::BaseData *baseData,
651  mitk::ScalarType minBoundX,
652  mitk::ScalarType maxBoundX,
653  mitk::ScalarType minBoundY,
654  mitk::ScalarType maxBoundY,
655  mitk::ScalarType minBoundZ,
656  mitk::ScalarType maxBoundZ)
657  {
658  baseData->Update();
659  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
660 
661  mitk::BoundingBox::BoundsArrayType bound = geometry->GetBoundsInWorld();
662  bool isEqual = true;
663  isEqual = isEqual && mitk::Equal(bound[0], minBoundX);
664  isEqual = isEqual && mitk::Equal(bound[1], maxBoundX);
665  isEqual = isEqual && mitk::Equal(bound[2], minBoundY);
666  isEqual = isEqual && mitk::Equal(bound[3], maxBoundY);
667  isEqual = isEqual && mitk::Equal(bound[4], minBoundZ);
668  isEqual = isEqual && mitk::Equal(bound[5], maxBoundZ);
669 
670  MITK_TEST_CONDITION(isEqual, "Bounds as precalculated...");
671  }
672 
673  void CheckExtent_BaseData_AsSet(mitk::BaseData *baseData, double extentX, double extentY, double extentZ)
674  {
675  baseData->Update();
676  mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
677 
678  bool isEqual = true;
679  isEqual = isEqual && mitk::Equal(geometry->GetExtentInWorld(0), extentX, test_eps); // 30*0.5);
680  isEqual = isEqual && mitk::Equal(geometry->GetExtentInWorld(1), extentY, test_eps); // 25*0.33);
681  isEqual = isEqual && mitk::Equal(geometry->GetExtentInWorld(2), extentZ, test_eps); // 20*0.78);
682 
683  MITK_TEST_CONDITION(isEqual, "Extent as precalculated...");
684  }
685 
686  mitk::PointSet::Pointer makePointset()
687  {
688  mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
689  mitk::Point3D pointA, pointB, pointC;
690  pointA.Fill(1);
691  pointB.Fill(2);
692  pointC.Fill(3);
693  pointSet->SetPoint(1, pointA);
694  pointSet->SetPoint(2, pointB);
695  pointSet->SetPoint(3, pointC);
696  pointSet->Update();
697  MITK_INFO << pointSet->GetPoint(0);
698  MITK_INFO << pointSet->GetPoint(1);
699  MITK_INFO << pointSet->GetPoint(2);
700  MITK_INFO << pointSet->GetPoint(3);
701 
702  mitk::PointSet::Pointer pointSet2 = pointSet->Clone();
703  MITK_INFO << pointSet2->GetPoint(0);
704  MITK_INFO << pointSet2->GetPoint(1);
705  MITK_INFO << pointSet2->GetPoint(2);
706  MITK_INFO << pointSet2->GetPoint(3);
707 
708  return pointSet;
709  }
710 };
711 
712 int mitkTimeGeometryTest(int /*argc*/, char * /*argv*/ [])
713 {
714  MITK_TEST_BEGIN(mitkTimeGeometryTest);
715 
716  mitkTimeGeometryTestClass testClass;
717 
718  MITK_TEST_OUTPUT(<< "Test for 3D image");
719  mitk::Image::Pointer image =
720  mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(30, 25, 20, 1, 0.5, 0.33, 0.78, 100);
721  testClass.Translation_Image_MovedOrigin(30, 25, 20, 1);
722  testClass.Rotate_Image_RotatedPoint(image->Clone(), 30, 25, 20, 1);
723  testClass.Scale_Image_ScaledPoint(30, 25, 20, 1);
724  testClass.CountTimeSteps_Image_ReturnDimT(image->Clone(), 30, 25, 20, 1);
725  testClass.GetMinimumTimePoint_3DImage_Min(image->Clone(), 30, 25, 20, 1);
726  testClass.GetMaximumTimePoint_3DImage_Max(image->Clone(), 30, 25, 20, 1);
727  testClass.GetTimeBounds_3DImage_ZeroAndDimT(image->Clone(), 30, 25, 20, 1);
728  testClass.IsValidTimePoint_ImageValidTimePoint_True(image->Clone(), 30, 25, 20, 1);
729  testClass.IsValidTimeStep_ImageValidTimeStep_True(image->Clone(), 30, 25, 20, 1);
730  testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(image->Clone(), 30, 25, 20, 1);
731  testClass.IsValidTimeStep_ImageInvalidTimeStep_False(image->Clone(), 30, 25, 20, 1);
732  testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(image->Clone(), 30, 25, 20, 1);
733  testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(image->Clone(), 30, 25, 20, 1);
734  testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(image->Clone(), 30, 25, 20, 1);
735  testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(
736  image->Clone(), 3, 3, 3, 3 * 0.5, 3 * 0.33, 3 * 0.78, 1);
737  testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30, 25, 20, 1);
738  testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(
739  image->Clone(), 3, 3, 3, 3 * 0.5, 3 * 0.33, 3 * 0.78, 1);
740  testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 1);
741  testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30, 25, 20, 1);
742  testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 0.5, 0.33, 0.78, 1);
743  testClass.Expand_BaseDataDoubleSize_SizeChanged(image->Clone(), 1);
744  testClass.CheckBounds_BaseData_PointsAsExpected(
745  image->Clone(), -0.5 * 0.5, -0.5 * 0.33, -0.5 * 0.78, 29.5 * 0.5, 24.5 * 0.33, 19.5 * 0.78);
746  testClass.CheckLength_BaseData_AsExpected(image->Clone(), 23.160796233014466, 536.42248214721712);
747  testClass.CheckPointInside_BaseDataPointInside_True(image->Clone(), 10, 5, 5);
748  testClass.CheckPointInside_BaseDataPointOutside_False(image->Clone(), 100, 500, 100);
749  testClass.CheckBounds_Image_AsSet(30, 25, 20, 1);
750  testClass.CheckExtent_BaseData_AsSet(image->Clone(), 30 * 0.5, 25 * 0.33, 20 * 0.78);
751 
752  MITK_TEST_OUTPUT(<< "Test for 2D image");
753  image = mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(30, 25, 1, 1, 0.5, 0.33, 0.78, 100);
754  testClass.Translation_Image_MovedOrigin(30, 25, 1, 1);
755  testClass.Rotate_Image_RotatedPoint(image->Clone(), 30, 25, 1, 1);
756  testClass.Scale_Image_ScaledPoint(30, 25, 1, 1);
757  testClass.CountTimeSteps_Image_ReturnDimT(image->Clone(), 30, 25, 1, 1);
758  testClass.GetMinimumTimePoint_3DImage_Min(image->Clone(), 30, 25, 1, 1);
759  testClass.GetMaximumTimePoint_3DImage_Max(image->Clone(), 30, 25, 1, 1);
760  testClass.GetTimeBounds_3DImage_ZeroAndDimT(image->Clone(), 30, 25, 1, 1);
761  testClass.IsValidTimePoint_ImageValidTimePoint_True(image->Clone(), 30, 25, 1, 1);
762  testClass.IsValidTimeStep_ImageValidTimeStep_True(image->Clone(), 30, 25, 1, 1);
763  testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(image->Clone(), 30, 25, 1, 1);
764  testClass.IsValidTimeStep_ImageInvalidTimeStep_False(image->Clone(), 30, 25, 1, 1);
765  testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(image->Clone(), 30, 25, 1, 1);
766  testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(image->Clone(), 30, 25, 1, 1);
767  testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(image->Clone(), 30, 25, 1, 1);
768  testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(
769  image->Clone(), 3, 3, 3, 3 * 0.5, 3 * 0.33, 3 * 0.78, 1);
770  testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30, 25, 1, 1);
771  testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(
772  image->Clone(), 3, 3, 3, 3 * 0.5, 3 * 0.33, 3 * 0.78, 1);
773  testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 1);
774  testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30, 25, 1, 1);
775  testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 0.5, 0.33, 0.78, 1);
776  testClass.Expand_BaseDataDoubleSize_SizeChanged(image->Clone(), 1);
777  testClass.CheckBounds_BaseData_PointsAsExpected(
778  image->Clone(), -0.5 * 0.5, -0.5 * 0.33, -0.5 * 0.78, 29.5 * 0.5, 24.5 * 0.33, 0.5 * 0.78);
779  testClass.CheckLength_BaseData_AsExpected(image->Clone(), 17.1368287615, 293.6709);
780  testClass.CheckPointInside_BaseDataPointInside_True(image->Clone(), 10, 5, 0);
781  testClass.CheckPointInside_BaseDataPointOutside_False(image->Clone(), 100, 500, 0.5);
782  testClass.CheckExtent_BaseData_AsSet(image->Clone(), 30 * 0.5, 25 * 0.33, 1 * 0.78);
783 
784  MITK_TEST_OUTPUT(<< "Test for 3D+time image");
785  image = mitk::ImageGenerator::GenerateRandomImage<mitk::ScalarType>(30, 25, 20, 5, 0.5, 0.33, 0.78, 100);
786  testClass.Translation_Image_MovedOrigin(30, 25, 20, 5); // Test with 3D+t-Image
787  testClass.Rotate_Image_RotatedPoint(image->Clone(), 30, 25, 20, 5); // Test with 3D+t-Image
788  testClass.Scale_Image_ScaledPoint(30, 25, 20, 5); // Test with 3D+t-Image
789  testClass.CountTimeSteps_Image_ReturnDimT(image->Clone(), 30, 25, 20, 5);
790  testClass.GetMinimumTimePoint_4DBaseData_Zero(image->Clone(), 5);
791  testClass.GetMaximumTimePoint_4DBaseData_DimT(image->Clone(), 5);
792  testClass.GetTimeBounds_4DImage_ZeroAndDimT(30, 25, 20, 5);
793  testClass.IsValidTimePoint_ImageValidTimePoint_True(image->Clone(), 30, 25, 20, 5);
794  testClass.IsValidTimePoint_ImageNegativInvalidTimePoint_False(30, 25, 20, 5);
795  testClass.IsValidTimePoint_ImageInvalidTimePoint_False(30, 25, 20, 5);
796  testClass.IsValidTimeStep_ImageValidTimeStep_True(image->Clone(), 30, 25, 20, 5);
797  testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(image->Clone(), 30, 25, 20, 5);
798  testClass.IsValidTimeStep_ImageInvalidTimeStep_False(image->Clone(), 30, 25, 20, 5);
799  testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(image->Clone(), 30, 25, 20, 5);
800  testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(image->Clone(), 30, 25, 20, 5);
801  testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(image->Clone(), 30, 25, 20, 5);
802  testClass.TimePointToTimeStep_4DImageInvalidTimePoint_TimePoint(30, 25, 20, 5);
803  testClass.TimePointToTimeStep_4DImageNegativInvalidTimePoint_TimePoint(30, 25, 20, 5);
804  testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(
805  image->Clone(), 3, 3, 3, 3 * 0.5, 3 * 0.33, 3 * 0.78, 5);
806  testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30, 25, 20, 5);
807  testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(
808  image->Clone(), 3, 3, 3, 3 * 0.5, 3 * 0.33, 3 * 0.78, 5);
809  testClass.GetGeometryForTimePoint_4DImageInvalidTimePoint_NullPointer(30, 25, 20, 5);
810  testClass.GetGeometryForTimePoint_4DImageNEgativInvalidTimePoint_NullPointer(30, 25, 20, 5);
811  testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 5);
812  testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30, 25, 20, 5);
813  testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 0.5, 0.33, 0.78, 5);
814  testClass.Expand_BaseDataDoubleSize_SizeChanged(image->Clone(), 5);
815  testClass.CheckBounds_BaseData_PointsAsExpected(
816  image->Clone(), -0.5 * 0.5, -0.5 * 0.33, -0.5 * 0.78, 29.5 * 0.5, 24.5 * 0.33, 19.5 * 0.78);
817  testClass.CheckLength_BaseData_AsExpected(image->Clone(), 23.160796233014466, 536.42248214721712);
818  testClass.CheckPointInside_BaseDataPointInside_True(image->Clone(), 10, 5, 5);
819  testClass.CheckPointInside_BaseDataPointOutside_False(image->Clone(), 100, 100, 500);
820  testClass.CheckBounds_Image_AsSet(30, 25, 20, 5);
821  testClass.CheckExtent_BaseData_AsSet(image->Clone(), 30 * 0.5, 25 * 0.33, 20 * 0.78);
822 
823  /*
824  MITK_TEST_OUTPUT(<< "Test for 2D+time image");
825  testClass.Translation_Image_MovedOrigin(30,25,1 ,5); // Test with 2D+t-Image
826  testClass.Rotate_Image_RotatedPoint(30,25,1 ,5); // Test with 2D+t-Image
827  testClass.Scale_Image_ScaledPoint(30,25,1 ,5); // Test with 2D+t-Image
828  */
829 
830  mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
831  mitk::Point3D pointA, pointB, pointC;
832  pointA.Fill(1);
833  pointB.Fill(2);
834  pointC.Fill(3);
835  pointSet->SetPoint(0, pointA);
836  pointSet->SetPoint(1, pointB);
837  pointSet->SetPoint(2, pointC);
838  testClass.CountTimeSteps_Image_ReturnDimT(pointSet->Clone(), 30, 25, 20, 1);
839  // testClass.GetMinimumTimePoint_3DImage_Min(pointSet->Clone(),30,25,20,1);
840  // testClass.GetMaximumTimePoint_3DImage_Max(pointSet->Clone(),30,25,20,1);
841  // testClass.GetTimeBounds_3DImage_ZeroAndDimT(pointSet->Clone(),30,25,20,1);
842  testClass.IsValidTimePoint_ImageValidTimePoint_True(pointSet->Clone(), 30, 25, 20, 1);
843  testClass.IsValidTimeStep_ImageValidTimeStep_True(pointSet->Clone(), 30, 25, 20, 1);
844  testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(pointSet->Clone(), 30, 25, 20, 1);
845  testClass.IsValidTimeStep_ImageInvalidTimeStep_False(pointSet->Clone(), 30, 25, 20, 1);
846  testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(pointSet->Clone(), 30, 25, 20, 1);
847  testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(pointSet->Clone(), 30, 25, 20, 1);
848  testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(pointSet->Clone(), 30, 25, 20, 1);
849  testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(pointSet->Clone(), 3, 3, 3, 3, 3, 3, 1);
850  testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(pointSet->Clone(), 30, 25, 20, 1);
851  testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(pointSet->Clone(), 3, 3, 3, 3, 3, 3, 1);
852  testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(pointSet->Clone(), 1);
853  testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(pointSet->Clone(), 30, 25, 20, 1);
854  testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(pointSet->Clone(), 1, 1, 1, 1);
855  testClass.Expand_BaseDataDoubleSize_SizeChanged(pointSet->Clone(), 1);
856  testClass.CheckBounds_BaseData_PointsAsExpected(pointSet->Clone(), 1, 1, 1, 3, 3, 3);
857  testClass.CheckLength_BaseData_AsExpected(pointSet->Clone(), 3.46410161, 12);
858  testClass.CheckPointInside_BaseDataPointInside_True(pointSet->Clone(), 2, 2, 3);
859  testClass.CheckPointInside_BaseDataPointOutside_False(pointSet->Clone(), 4, 5, 1);
860  testClass.CheckBounds_BaseData_AsSet(pointSet->Clone(), 1, 3, 1, 3, 1, 3);
861  testClass.CheckExtent_BaseData_AsSet(pointSet->Clone(), 2, 2, 2);
862 
863  MITK_TEST_END();
864 
865  return EXIT_SUCCESS;
866 }
test_eps_square
static const mitk::ScalarType test_eps_square
Definition: mitkTimeGeometryTest.cpp:36
mitk::TimeBounds
itk::FixedArray< ScalarType, 2 > TimeBounds
Standard typedef for time-bounds.
Definition: mitkBaseGeometry.h:49
MITK_INFO
#define MITK_INFO
Definition: mitkLogMacros.h:22
mitk::BaseData
Base of all data objects.
Definition: mitkBaseData.h:39
mitkTimeGeometryTest
int mitkTimeGeometryTest(int, char *[])
Definition: mitkTimeGeometryTest.cpp:712
mitk::ScalarType
double ScalarType
Definition: mitkNumericConstants.h:24
mitk::PointSet::New
static Pointer New()
mitk::BaseData::GetTimeGeometry
const mitk::TimeGeometry * GetTimeGeometry() const
Return the TimeGeometry of the data as const pointer.
Definition: mitkBaseData.h:52
MITK_TEST_BEGIN
section GeneralTestsDeprecatedOldTestingStyle Deprecated macros All tests with MITK_TEST_BEGIN()
mitkInteractionConst.h
Constants for most interaction classes, due to the generic StateMachines.
rotation
static Matrix3D rotation
Definition: mitkAffineTransformBaseTest.cpp:28
MITK_TEST_OUTPUT
#define MITK_TEST_OUTPUT(x)
Output some text.
Definition: mitkTestingMacros.h:54
test_eps
static const mitk::ScalarType test_eps
Definition: mitkTimeGeometryTest.cpp:34
mitk::TimeGeometry::ExecuteOperation
virtual void ExecuteOperation(Operation *op) override
Executes the given operation on all time steps.
Definition: mitkTimeGeometry.cpp:163
mitk::DataNode::New
static Pointer New()
MITK_TEST_CONDITION
#define MITK_TEST_CONDITION(COND, MSG)
Definition: mitkTestingMacros.h:114
mitk::TimePointType
mitk::ScalarType TimePointType
Definition: mitkTimeGeometry.h:30
mitk::TimeStepType
std::vcl_size_t TimeStepType
Definition: mitkTimeGeometry.h:31
max
static T max(T x, T y)
Definition: svm.cpp:70
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::BaseGeometry::IndexToWorld
void IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
Convert (continuous or discrete) index coordinates of a vector vec_units to world coordinates (in mm)...
Definition: mitkBaseGeometry.cpp:520
mitk::TimeGeometry::GetGeometryForTimeStep
virtual BaseGeometry::Pointer GetGeometryForTimeStep(TimeStepType timeStep) const =0
Returns the geometry which corresponds to the given time step.
originalPoint
static Point3D originalPoint
Definition: mitkAffineTransformBaseTest.cpp:29
MITK_TEST_END
and MITK_TEST_END()
mitk::BaseData::GetGeometry
mitk::BaseGeometry * GetGeometry(int t=0) const
Return the geometry, which is a TimeGeometry, of the data as non-const pointer.
Definition: mitkBaseData.h:129
mitk::RotationOperation
Operation, that holds everything necessary for an rotation operation on mitk::BaseData.
Definition: mitkRotationOperation.h:29
BoundsArrayType
BoundingBoxType::BoundsArrayType BoundsArrayType
Definition: mitkBaseGeometryTest.cpp:47