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
mitkArbitraryTimeGeometryTest.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 "mitkArbitraryTimeGeometry.h"
18 #include "mitkGeometry3D.h"
19 
20 #include "mitkTestFixture.h"
21 #include "mitkTestingMacros.h"
22 #include <limits>
23 
24 class mitkArbitraryTimeGeometryTestSuite : public mitk::TestFixture
25 {
26  CPPUNIT_TEST_SUITE(mitkArbitraryTimeGeometryTestSuite);
27  // Test the append method
28  MITK_TEST(CountTimeSteps);
29  MITK_TEST(GetMinimumTimePoint);
30  MITK_TEST(GetMaximumTimePoint);
31  MITK_TEST(GetTimeBounds);
32  MITK_TEST(IsValidTimePoint);
33  MITK_TEST(TimeStepToTimePoint);
34  MITK_TEST(TimePointToTimeStep);
35  MITK_TEST(GetGeometryCloneForTimeStep);
36  MITK_TEST(GetGeometryForTimeStep);
37  MITK_TEST(GetGeometryForTimePoint);
38  MITK_TEST(IsValid);
39  MITK_TEST(Expand);
40  MITK_TEST(ReplaceTimeStepGeometries);
41  MITK_TEST(ClearAllGeometries);
42  MITK_TEST(AppendTimeStep);
43 
44  CPPUNIT_TEST_SUITE_END();
45 
46 private:
47  mitk::Geometry3D::Pointer m_Geometry1;
48  mitk::Geometry3D::Pointer m_Geometry2;
49  mitk::Geometry3D::Pointer m_Geometry3;
50  mitk::Geometry3D::Pointer m_Geometry3_5;
51  mitk::Geometry3D::Pointer m_Geometry4;
52  mitk::Geometry3D::Pointer m_Geometry5;
53  mitk::Geometry3D::Pointer m_InvalidGeometry;
54  mitk::Geometry3D::Pointer m_NewGeometry;
55 
56  mitk::TimePointType m_Geometry1MinTP;
57  mitk::TimePointType m_Geometry2MinTP;
58  mitk::TimePointType m_Geometry3MinTP;
59  mitk::TimePointType m_Geometry3_5MinTP;
60  mitk::TimePointType m_Geometry4MinTP;
61  mitk::TimePointType m_Geometry5MinTP;
62  mitk::TimePointType m_NewGeometryMinTP;
63 
64  mitk::TimePointType m_Geometry1MaxTP;
65  mitk::TimePointType m_Geometry2MaxTP;
66  mitk::TimePointType m_Geometry3MaxTP;
67  mitk::TimePointType m_Geometry3_5MaxTP;
68  mitk::TimePointType m_Geometry4MaxTP;
69  mitk::TimePointType m_Geometry5MaxTP;
70  mitk::TimePointType m_NewGeometryMaxTP;
71 
72  mitk::ArbitraryTimeGeometry::Pointer m_emptyTimeGeometry;
73  mitk::ArbitraryTimeGeometry::Pointer m_initTimeGeometry;
74  mitk::ArbitraryTimeGeometry::Pointer m_12345TimeGeometry;
75  mitk::ArbitraryTimeGeometry::Pointer m_123TimeGeometry;
76 
77 public:
78  void setUp() override
79  {
80  mitk::TimeBounds bounds;
81  m_Geometry1 = mitk::Geometry3D::New();
82  m_Geometry2 = mitk::Geometry3D::New();
83  m_Geometry3 = mitk::Geometry3D::New();
84  m_Geometry3_5 = mitk::Geometry3D::New();
85  m_Geometry4 = mitk::Geometry3D::New();
86  m_Geometry5 = mitk::Geometry3D::New();
87 
88  m_Geometry1MinTP = 1;
89  m_Geometry2MinTP = 2;
90  m_Geometry3MinTP = 3;
91  m_Geometry3_5MinTP = 3.5;
92  m_Geometry4MinTP = 4;
93  m_Geometry5MinTP = 5;
94 
95  m_Geometry1MaxTP = 1.9;
96  m_Geometry2MaxTP = 2.9;
97  m_Geometry3MaxTP = 3.9;
98  m_Geometry3_5MaxTP = 3.9;
99  m_Geometry4MaxTP = 4.9;
100  m_Geometry5MaxTP = 5.9;
101 
102  m_NewGeometry = mitk::Geometry3D::New();
103  m_NewGeometryMinTP = 20;
104  m_NewGeometryMaxTP = 21.9;
105 
106  mitk::Point3D origin(42);
107  m_NewGeometry->SetOrigin(origin);
108 
109  m_emptyTimeGeometry = mitk::ArbitraryTimeGeometry::New();
110  m_emptyTimeGeometry->ClearAllGeometries();
111 
112  m_initTimeGeometry = mitk::ArbitraryTimeGeometry::New();
113  m_initTimeGeometry->Initialize();
114 
115  m_12345TimeGeometry = mitk::ArbitraryTimeGeometry::New();
116  m_12345TimeGeometry->ClearAllGeometries();
117  m_12345TimeGeometry->AppendTimeStep(m_Geometry1, m_Geometry1MaxTP, m_Geometry1MinTP);
118  m_12345TimeGeometry->AppendTimeStep(m_Geometry2, m_Geometry2MaxTP, m_Geometry2MinTP);
119  m_12345TimeGeometry->AppendTimeStep(m_Geometry3, m_Geometry3MaxTP, m_Geometry3MinTP);
120  m_12345TimeGeometry->AppendTimeStep(m_Geometry4, m_Geometry4MaxTP, m_Geometry4MinTP);
121  m_12345TimeGeometry->AppendTimeStep(m_Geometry5, m_Geometry5MaxTP, m_Geometry5MinTP);
122 
123  m_123TimeGeometry = mitk::ArbitraryTimeGeometry::New();
124  m_123TimeGeometry->ClearAllGeometries();
125  m_123TimeGeometry->AppendTimeStep(m_Geometry1, m_Geometry1MaxTP, m_Geometry1MinTP);
126  m_123TimeGeometry->AppendTimeStep(m_Geometry2, m_Geometry2MaxTP, m_Geometry2MinTP);
127  m_123TimeGeometry->AppendTimeStep(m_Geometry3, m_Geometry3MaxTP, m_Geometry3MinTP);
128  }
129 
130  void tearDown() override {}
131  void CountTimeSteps()
132  {
133  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->CountTimeSteps() == 0,
134  "Testing CountTimeSteps with m_emptyTimeGeometry");
135  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->CountTimeSteps() == 1,
136  "Testing CountTimeSteps with m_initTimeGeometry");
137  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 5,
138  "Testing CountTimeSteps with m_12345TimeGeometry");
139  }
140 
141  void GetMinimumTimePoint()
142  {
143  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMinimumTimePoint() == 0.0,
144  "Testing GetMinimumTimePoint with m_emptyTimeGeometry");
145  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMinimumTimePoint() == 0.0,
146  "Testing GetMinimumTimePoint with m_initTimeGeometry");
147  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMinimumTimePoint() == 1.0,
148  "Testing GetMinimumTimePoint with m_12345TimeGeometry");
149 
150  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMinimumTimePoint(2) == 0.0,
151  "Testing GetMinimumTimePoint(2) with m_emptyTimeGeometry");
152  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMinimumTimePoint(2) == 0.0,
153  "Testing GetMinimumTimePoint(2) with m_initTimeGeometry");
154  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMinimumTimePoint(2) == 2.9,
155  "Testing GetMinimumTimePoint(2) with m_12345TimeGeometry");
156  }
157 
158  void GetMaximumTimePoint()
159  {
160  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMaximumTimePoint() == 0.0,
161  "Testing GetMaximumTimePoint with m_emptyTimeGeometry");
162  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMaximumTimePoint() == 1.0,
163  "Testing GetMaximumTimePoint with m_initTimeGeometry");
164  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMaximumTimePoint() == 5.9,
165  "Testing GetMaximumTimePoint with m_12345TimeGeometry");
166 
167  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMaximumTimePoint(2) == 0.0,
168  "Testing GetMaximumTimePoint(2) with m_emptyTimeGeometry");
169  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMaximumTimePoint(2) == 0.0,
170  "Testing GetMaximumTimePoint(2) with m_initTimeGeometry");
171  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMaximumTimePoint(2) == 3.9,
172  "Testing GetMaximumTimePoint(2) with m_12345TimeGeometry");
173  }
174 
175  void GetTimeBounds()
176  {
177  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMaximumTimePoint(2) == 0.0,
178  "Testing GetMaximumTimePoint(2) with m_emptyTimeGeometry");
179  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetMaximumTimePoint(2) == 0.0,
180  "Testing GetMaximumTimePoint(2) with m_initTimeGeometry");
181  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMaximumTimePoint(2) == 3.9,
182  "Testing GetMaximumTimePoint(2) with m_12345TimeGeometry");
183 
184  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetTimeBounds()[0] == 0.0,
185  "Testing GetTimeBounds lower part with m_emptyTimeGeometry");
186  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetTimeBounds()[0] == 0.0,
187  "Testing GetTimeBounds lower part with m_initTimeGeometry");
188  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetTimeBounds()[0] == 1.0,
189  "Testing GetTimeBounds lower part with m_12345TimeGeometry");
190 
191  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetTimeBounds()[1] == 0.0,
192  "Testing GetTimeBounds with m_emptyTimeGeometry");
193  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetTimeBounds()[1] == 1.0,
194  "Testing GetTimeBounds with m_initTimeGeometry");
195  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetTimeBounds()[1] == 5.9,
196  "Testing GetTimeBounds with m_12345TimeGeometry");
197 
198  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetTimeBounds(3)[0] == 0.0,
199  "Testing GetTimeBounds(3) lower part with m_emptyTimeGeometry");
200  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetTimeBounds(3)[0] == 0.0,
201  "Testing GetTimeBounds(3) lower part with m_initTimeGeometry");
202  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetTimeBounds(3)[0] == 3.9,
203  "Testing GetTimeBounds(3) lower part with m_12345TimeGeometry");
204 
205  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetTimeBounds(3)[1] == 0.0,
206  "Testing GetTimeBounds(3) with m_emptyTimeGeometry");
207  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetTimeBounds(3)[1] == 0.0,
208  "Testing GetTimeBounds(3) with m_initTimeGeometry");
209  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetTimeBounds(3)[1] == 4.9,
210  "Testing GetTimeBounds(3) with m_12345TimeGeometry");
211  }
212 
213  void IsValidTimePoint()
214  {
215  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(-1) == false,
216  "Testing IsValidTimePoint(-1) with m_emptyTimeGeometry");
217  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(-1) == false,
218  "Testing IsValidTimePoint(-1) with m_initTimeGeometry");
219  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(-1) == false,
220  "Testing IsValidTimePoint(-1) with m_12345TimeGeometry");
221 
222  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(0) == false,
223  "Testing IsValidTimePoint(0) with m_emptyTimeGeometry");
224  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(0) == true,
225  "Testing IsValidTimePoint(0) with m_initTimeGeometry");
226  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(0) == false,
227  "Testing IsValidTimePoint(0) with m_12345TimeGeometry");
228 
229  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(1) == false,
230  "Testing IsValidTimePoint(1) with m_emptyTimeGeometry");
231  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(1) == false,
232  "Testing IsValidTimePoint(1) with m_initTimeGeometry");
233  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(1) == true,
234  "Testing IsValidTimePoint(1) with m_12345TimeGeometry");
235 
236  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(2.5) == false,
237  "Testing IsValidTimePoint(2.5) with m_emptyTimeGeometry");
238  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(2.5) == false,
239  "Testing IsValidTimePoint(2.5) with m_initTimeGeometry");
240  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(2.5) == true,
241  "Testing IsValidTimePoint(2.5) with m_12345TimeGeometry");
242 
243  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(5.89) == false,
244  "Testing IsValidTimePoint(5.89) with m_emptyTimeGeometry");
245  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(5.89) == false,
246  "Testing IsValidTimePoint(5.89) with m_initTimeGeometry");
247  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(5.89) == true,
248  "Testing IsValidTimePoint(5.89) with m_12345TimeGeometry");
249 
250  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimePoint(10) == false,
251  "Testing IsValidTimePoint(10) with m_emptyTimeGeometry");
252  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimePoint(10) == false,
253  "Testing IsValidTimePoint(10) with m_initTimeGeometry");
254  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimePoint(10) == false,
255  "Testing IsValidTimePoint(10) with m_12345TimeGeometry");
256 
257  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimeStep(0) == false,
258  "Testing IsValidTimeStep(0) with m_emptyTimeGeometry");
259  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimeStep(0) == true,
260  "Testing IsValidTimeStep(0) with m_initTimeGeometry");
261  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimeStep(0) == true,
262  "Testing IsValidTimeStep(0) with m_12345TimeGeometry");
263 
264  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimeStep(1) == false,
265  "Testing IsValidTimeStep(1) with m_emptyTimeGeometry");
266  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimeStep(1) == false,
267  "Testing IsValidTimeStep(1) with m_initTimeGeometry");
268  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimeStep(1) == true,
269  "Testing IsValidTimeStep(1) with m_12345TimeGeometry");
270 
271  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValidTimeStep(6) == false,
272  "Testing IsValidTimeStep(6) with m_emptyTimeGeometry");
273  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValidTimeStep(6) == false,
274  "Testing IsValidTimeStep(6) with m_initTimeGeometry");
275  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValidTimeStep(6) == false,
276  "Testing IsValidTimeStep(6) with m_12345TimeGeometry");
277  }
278 
279  void TimeStepToTimePoint()
280  {
281  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimeStepToTimePoint(0) == 0.0,
282  "Testing TimeStepToTimePoint(0) with m_emptyTimeGeometry");
283  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimeStepToTimePoint(0) == 0.0,
284  "Testing TimeStepToTimePoint(0) with m_initTimeGeometry");
285  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimeStepToTimePoint(0) == 1.0,
286  "Testing TimeStepToTimePoint(0) with m_12345TimeGeometry");
287 
288  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimeStepToTimePoint(1) == 0.0,
289  "Testing TimeStepToTimePoint(1) with m_emptyTimeGeometry");
290  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimeStepToTimePoint(1) == 0.0,
291  "Testing TimeStepToTimePoint(1) with m_initTimeGeometry");
292  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimeStepToTimePoint(1) == 1.9,
293  "Testing TimeStepToTimePoint(1) with m_12345TimeGeometry");
294 
295  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimeStepToTimePoint(6) == 0.0,
296  "Testing TimeStepToTimePoint(6) with m_emptyTimeGeometry");
297  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimeStepToTimePoint(6) == 0.0,
298  "Testing TimeStepToTimePoint(6) with m_initTimeGeometry");
299  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimeStepToTimePoint(6) == 0.0,
300  "Testing TimeStepToTimePoint(6) with m_12345TimeGeometry");
301  }
302 
303  void TimePointToTimeStep()
304  {
305  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimePointToTimeStep(0.0) == 0,
306  "Testing TimePointToTimeStep(0.0) with m_emptyTimeGeometry");
307  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimePointToTimeStep(0.0) == 0,
308  "Testing TimePointToTimeStep(0.0) with m_initTimeGeometry");
309  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(0.0) == 0,
310  "Testing TimePointToTimeStep(0.0) with m_12345TimeGeometry");
311 
312  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimePointToTimeStep(0.5) == 0,
313  "Testing TimePointToTimeStep(0.5) with m_emptyTimeGeometry");
314  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimePointToTimeStep(0.5) == 0,
315  "Testing TimePointToTimeStep(0.5) with m_initTimeGeometry");
316  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(0.5) == 0,
317  "Testing TimePointToTimeStep(0.5) with m_12345TimeGeometry");
318 
319  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimePointToTimeStep(3.5) == 0,
320  "Testing TimePointToTimeStep(3.5) with m_emptyTimeGeometry");
321  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimePointToTimeStep(3.5) == 0,
322  "Testing TimePointToTimeStep(3.5) with m_initTimeGeometry");
323  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(3.5) == 2,
324  "Testing TimePointToTimeStep(3.5) with m_12345TimeGeometry");
325 
326  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->TimePointToTimeStep(5.8) == 0,
327  "Testing TimePointToTimeStep(5.8) with m_emptyTimeGeometry");
328  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->TimePointToTimeStep(5.8) == 0,
329  "Testing TimePointToTimeStep(5.8) with m_initTimeGeometry");
330  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(5.8) == 4,
331  "Testing TimePointToTimeStep(5.8) with m_12345TimeGeometry");
332  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->TimePointToTimeStep(5.9) == 0,
333  "Testing TimePointToTimeStep(5.9) with m_12345TimeGeometry");
334  }
335 
336  void GetGeometryCloneForTimeStep()
337  {
338  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetGeometryCloneForTimeStep(0).IsNull(),
339  "Testing GetGeometryCloneForTimeStep(0) with m_emptyTimeGeometry");
340  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryCloneForTimeStep(0).IsNotNull(),
341  "Testing GetGeometryCloneForTimeStep(0) with m_initTimeGeometry");
342  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetGeometryCloneForTimeStep(0).IsNotNull(),
343  "Testing GetGeometryCloneForTimeStep(0) with m_12345TimeGeometry");
344  }
345 
346  void GetGeometryForTimeStep()
347  {
348  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetGeometryForTimeStep(0).IsNull(),
349  "Testing GetGeometryForTimePoint(0) with m_emptyTimeGeometry");
350  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryForTimeStep(0).IsNotNull(),
351  "Testing GetGeometryForTimePoint(0) with m_initTimeGeometry");
352  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryForTimeStep(1).IsNull(),
353  "Testing GetGeometryForTimePoint(1) with m_initTimeGeometry");
354  MITK_TEST_CONDITION_REQUIRED(
355  m_12345TimeGeometry->GetGeometryForTimeStep(0).GetPointer() == m_Geometry1.GetPointer(),
356  "Testing GetGeometryForTimePoint(0) with m_12345TimeGeometry");
357  MITK_TEST_CONDITION_REQUIRED(
358  m_12345TimeGeometry->GetGeometryForTimeStep(3).GetPointer() == m_Geometry4.GetPointer(),
359  "Testing GetGeometryForTimePoint(3) with m_12345TimeGeometry");
360  MITK_TEST_CONDITION_REQUIRED(
361  m_12345TimeGeometry->GetGeometryForTimeStep(4).GetPointer() == m_Geometry5.GetPointer(),
362  "Testing GetGeometryForTimePoint(4) with m_12345TimeGeometry");
363  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetGeometryForTimeStep(5).IsNull(),
364  "Testing GetGeometryForTimePoint(5) with m_12345TimeGeometry");
365  }
366 
367  void GetGeometryForTimePoint()
368  {
369  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetGeometryForTimePoint(0).IsNull(),
370  "Testing GetGeometryForTimeStep(0) with m_emptyTimeGeometry");
371  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryForTimePoint(0).IsNotNull(),
372  "Testing GetGeometryForTimeStep(0) with m_initTimeGeometry");
373  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetGeometryForTimePoint(0).IsNull(),
374  "Testing GetGeometryForTimeStep(0) with m_12345TimeGeometry");
375 
376  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetGeometryForTimePoint(1.5).IsNull(),
377  "Testing GetGeometryForTimeStep(1.5) with m_emptyTimeGeometry");
378  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->GetGeometryForTimePoint(1.5).IsNull(),
379  "Testing GetGeometryForTimeStep(1.5) with m_initTimeGeometry");
380  MITK_TEST_CONDITION_REQUIRED(
381  m_12345TimeGeometry->GetGeometryForTimePoint(1.5).GetPointer() == m_Geometry1.GetPointer(),
382  "Testing GetGeometryForTimeStep(1.5) with m_12345TimeGeometry");
383  MITK_TEST_CONDITION_REQUIRED(
384  m_12345TimeGeometry->GetGeometryForTimePoint(3.5).GetPointer() == m_Geometry3.GetPointer(),
385  "Testing GetGeometryForTimeStep(3.5) with m_12345TimeGeometry");
386  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetGeometryForTimePoint(5.9).IsNull(),
387  "Testing GetGeometryForTimeStep(5.9) with m_12345TimeGeometry");
388  }
389 
390  void IsValid()
391  {
392  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->IsValid() == false, "Testing IsValid() with m_emptyTimeGeometry");
393  MITK_TEST_CONDITION_REQUIRED(m_initTimeGeometry->IsValid() == true, "Testing IsValid() with m_initTimeGeometry");
394  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->IsValid() == true, "Testing IsValid() with m_12345TimeGeometry");
395  }
396 
397  void Expand()
398  {
399  m_12345TimeGeometry->Expand(3);
400  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 5,
401  "Testing Expand(3) doesn't change m_12345TimeGeometry");
402 
403  m_12345TimeGeometry->Expand(7);
404  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 7,
405  "Testing Expand(7) with m_12345TimeGeometry");
406  }
407 
408  void ReplaceTimeStepGeometries()
409  {
410  // Test replace time step geometries
411  m_12345TimeGeometry->ReplaceTimeStepGeometries(m_NewGeometry);
412  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 5,
413  "Testing ReplaceTimeStepGeometries() with m_12345TimeGeometry");
414  MITK_TEST_CONDITION_REQUIRED(
415  m_12345TimeGeometry->GetGeometryForTimeStep(0)->GetOrigin() == m_NewGeometry->GetOrigin(),
416  "Testing ReplaceTimeStepGeometries(): check if first geometry of m_12345TimeGeometry "
417  "was replaced m_12345TimeGeometry");
418  MITK_TEST_CONDITION_REQUIRED(
419  m_12345TimeGeometry->GetGeometryForTimeStep(4)->GetOrigin() == m_NewGeometry->GetOrigin(),
420  "Testing ReplaceTimeStepGeometries(): check if last geometry of m_12345TimeGeometry "
421  "was replaced m_12345TimeGeometry");
422  }
423 
424  void ClearAllGeometries()
425  {
426  // Test clear all geometries
427  m_12345TimeGeometry->ClearAllGeometries();
428  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->CountTimeSteps() == 0,
429  "Testing ClearAllGeometries() with m_12345TimeGeometry");
430  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMinimumTimePoint() == 0,
431  "Testing ClearAllGeometries() with m_12345TimeGeometry");
432  MITK_TEST_CONDITION_REQUIRED(m_12345TimeGeometry->GetMaximumTimePoint() == 0,
433  "Testing ClearAllGeometries() with m_12345TimeGeometry");
434  }
435 
436  void AppendTimeStep()
437  {
438  // Test append
439  MITK_TEST_FOR_EXCEPTION(mitk::Exception, m_123TimeGeometry->AppendTimeStep(NULL, 0, 1));
440  MITK_TEST_FOR_EXCEPTION(mitk::Exception, m_123TimeGeometry->AppendTimeStep(m_Geometry2, m_Geometry2MaxTP));
441 
442  m_emptyTimeGeometry->AppendTimeStep(m_Geometry4, m_Geometry4MaxTP, m_Geometry4MinTP);
443  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->CountTimeSteps() == 1,
444  "Testing AppendTimeStep() with m_emptyTimeGeometry");
445  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMinimumTimePoint() == 4,
446  "Testing ClearAllGeometries() with m_emptyTimeGeometry");
447  MITK_TEST_CONDITION_REQUIRED(m_emptyTimeGeometry->GetMaximumTimePoint() == 4.9,
448  "Testing ClearAllGeometries() with m_emptyTimeGeometry");
449 
450  MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->CountTimeSteps() == 3,
451  "Testing AppendTimeStep() with m_emptyTimeGeometry");
452  MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMinimumTimePoint() == 1,
453  "Testing ClearAllGeometries() with m_emptyTimeGeometry");
454  MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMaximumTimePoint() == 3.9,
455  "Testing ClearAllGeometries() with m_emptyTimeGeometry");
456  m_123TimeGeometry->AppendTimeStep(m_Geometry4, m_Geometry4MaxTP, m_Geometry4MinTP);
457  MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->CountTimeSteps() == 4,
458  "Testing AppendTimeStep() with m_123TimeGeometry");
459  MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMinimumTimePoint() == 1,
460  "Testing AppendTimeStep() with m_123TimeGeometry");
461  MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMaximumTimePoint() == 4.9,
462  "Testing AppendTimeStep() with m_123TimeGeometry");
463  MITK_TEST_CONDITION_REQUIRED(m_123TimeGeometry->GetMinimumTimePoint(3) == 3.9,
464  "Testing AppendTimeStep() with m_123TimeGeometry");
465  }
466 };
467 
468 MITK_TEST_SUITE_REGISTRATION(mitkArbitraryTimeGeometry)
MITK_TEST_SUITE_REGISTRATION
MITK_TEST_SUITE_REGISTRATION(mitkImageToItk)
mitk::TimeBounds
itk::FixedArray< ScalarType, 2 > TimeBounds
Standard typedef for time-bounds.
Definition: mitkBaseGeometry.h:49
MITK_TEST_CONDITION_REQUIRED
#define MITK_TEST_CONDITION_REQUIRED(COND, MSG)
Definition: mitkTestingMacros.h:135
MITK_TEST
#define MITK_TEST(TESTMETHOD)
Adds a test to the current test suite.
Definition: mitkTestingMacros.h:306
mitk::Geometry3D::New
static Pointer New()
MITK_TEST_FOR_EXCEPTION
#define MITK_TEST_FOR_EXCEPTION(EXCEPTIONCLASS, STATEMENT)
Simplified version of MITK_TEST_FOR_EXCEPTION_BEGIN / END for a single statement. ...
Definition: mitkTestingMacros.h:195
mitk::Exception
An object of this class represents an exception of MITK. Please don't instantiate exceptions manually...
Definition: mitkException.h:49
mitk::TestFixture
Test fixture for parameterized tests.
Definition: mitkTestFixture.h:90
mitk::TimePointType
mitk::ScalarType TimePointType
Definition: mitkTimeGeometry.h:30