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