Medical Imaging Interaction Toolkit  2018.4.99-389bf124
Medical Imaging Interaction Toolkit
mitkLevelWindowTest.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 "mitkImageWriteAccessor.h"
14 #include "mitkLevelWindow.h"
15 #include <mitkImage.h>
16 
17 /*
18 * Reseting the Levelwindow to default values:
19 * i.e. Range = -1000..1000, Level = 0 and Window = 500
20 */
21 void resetLevelWindow(mitk::LevelWindow &lw)
22 {
23  // Default window bounds
24  lw.SetRangeMinMax(-10000, 10000);
25  lw.SetLevelWindow(0, 500, false);
26  if (lw.GetRangeMin() != -10000 || lw.GetRangeMax() != 10000 || lw.GetLevel() != 0 || lw.GetWindow() != 500)
27  {
28  std::cout << "[Failed] To reset Levelwindow" << std::endl;
29  }
30 }
31 
32 int mitkLevelWindowTest(int, char *[])
33 {
34  std::cout << "Testing mitk::LevelWindow " << std::endl;
35 
36  std::cout << "Testing mitk::LevelWindow constructor with Level and Window ";
37  auto levWin = new mitk::LevelWindow(256, 500);
38  std::cout << "[PASSED]" << std::endl;
39 
40  std::cout << "Testing mitk::LevelWindow GetDefaultWindow ";
41  mitk::ScalarType defaultWindow = levWin->GetDefaultWindow();
42  if (!(defaultWindow == 500))
43  {
44  std::cout << defaultWindow << " [FAILED]" << std::endl;
45  return EXIT_FAILURE;
46  }
47  std::cout << "[PASSED]" << std::endl;
48 
49  std::cout << "Testing mitk::LevelWindow GetDefaultLevel ";
50  mitk::ScalarType defaultLevel = levWin->GetDefaultLevel();
51  if (!(defaultLevel == 256))
52  {
53  std::cout << "[FAILED]" << std::endl;
54  return EXIT_FAILURE;
55  }
56  std::cout << "[PASSED]" << std::endl;
57 
58  std::cout << "Testing mitk::LevelWindow GetWindow ";
59  mitk::ScalarType window = levWin->GetWindow();
60  if (!(window == 500))
61  {
62  std::cout << "[FAILED]" << std::endl;
63  return EXIT_FAILURE;
64  }
65  std::cout << "[PASSED]" << std::endl;
66 
67  std::cout << "Testing mitk::LevelWindow GetMin ";
68  if (!(levWin->GetLowerWindowBound() == 6))
69  {
70  std::cout << "[FAILED]" << std::endl;
71  return EXIT_FAILURE;
72  }
73  std::cout << "[PASSED]" << std::endl;
74 
75  std::cout << "Testing mitk::LevelWindow GetMax ";
76  if (!(levWin->GetUpperWindowBound() == 506))
77  {
78  std::cout << "[FAILED]" << std::endl;
79  return EXIT_FAILURE;
80  }
81  std::cout << "[PASSED]" << std::endl;
82 
83  std::cout << "Testing mitk::LevelWindow GetLevel ";
84  mitk::ScalarType level = levWin->GetLevel();
85  if (!(level == 256))
86  {
87  std::cout << "[FAILED]" << std::endl;
88  return EXIT_FAILURE;
89  }
90  std::cout << "[PASSED]" << std::endl;
91 
92  std::cout << "Testing mitk::LevelWindow GetWindow : GetDefaultWindow ";
93  if (!(defaultWindow == window))
94  {
95  std::cout << "[FAILED]" << std::endl;
96  return EXIT_FAILURE;
97  }
98  std::cout << "[PASSED]" << std::endl;
99 
100  std::cout << "Testing mitk::LevelWindow GetLevel : GetDefaultLevel ";
101  if (!(defaultLevel == level))
102  {
103  std::cout << "[FAILED]" << std::endl;
104  return EXIT_FAILURE;
105  }
106  std::cout << "[PASSED]" << std::endl;
107 
108  std::cout << "Testing mitk::LevelWindow SetLevelWindow ";
109  levWin->SetLevelWindow(20, 100);
110  if (!(levWin->GetLevel() == 20))
111  {
112  std::cout << "[FAILED]" << std::endl;
113  return EXIT_FAILURE;
114  }
115  if (!(levWin->GetWindow() == 100))
116  {
117  std::cout << "[FAILED]" << std::endl;
118  return EXIT_FAILURE;
119  }
120  std::cout << "[PASSED]" << std::endl;
121 
122  std::cout << "Testing mitk::LevelWindow SetLevelWindow ";
123  levWin->SetLevelWindow(levWin->GetDefaultLevel(), levWin->GetDefaultWindow());
124  if (!(levWin->GetLevel() == 256) && !(levWin->GetWindow() == 500))
125  {
126  std::cout << "[FAILED]" << std::endl;
127  return EXIT_FAILURE;
128  }
129  std::cout << "[PASSED]" << std::endl;
130 
131  std::cout << "Testing mitk::LevelWindow SetDefaultLevelWindow ";
132  levWin->SetDefaultLevelWindow(20, 200);
133  if (!(levWin->GetDefaultLevel() == 20) && !(levWin->GetDefaultWindow() == 200))
134  {
135  std::cout << "[FAILED]" << std::endl;
136  return EXIT_FAILURE;
137  }
138  std::cout << "[PASSED]" << std::endl;
139 
140  std::cout << "Testing mitk::LevelWindow ResetDefaultLevelWindow ";
141  levWin->SetLevelWindow(100, 50);
142  levWin->ResetDefaultLevelWindow();
143  // double a = levWin->GetLevel();
144  // double d = levWin->GetWindow();
145 
146  if (!((levWin->GetLevel() == 20) && (levWin->GetWindow() == 200)))
147  {
148  std::cout << "[FAILED]" << std::endl;
149  return EXIT_FAILURE;
150  }
151  std::cout << "[PASSED]" << std::endl;
152 
153  std::cout << "Testing mitk::LevelWindow SetWindowBounds ";
154  levWin->SetWindowBounds(0, 2);
155  if (!((levWin->GetLowerWindowBound() == 0) && (levWin->GetUpperWindowBound() == 2) && (levWin->GetLevel() == 1) &&
156  (levWin->GetWindow() == 2)))
157  {
158  std::cout << "[FAILED]" << std::endl;
159  return EXIT_FAILURE;
160  }
161  levWin->ResetDefaultLevelWindow();
162  std::cout << "[PASSED]" << std::endl;
163 
164  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with rangemin = rangemax";
165  levWin->SetRangeMinMax(2000, 2000);
166  if (!(levWin->GetRangeMin() == 1999 && levWin->GetRangeMax() == 2000))
167  {
168  std::cout << "[FAILED]" << std::endl;
169  return EXIT_FAILURE;
170  }
171  std::cout << "[PASSED]" << std::endl;
172 
173  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with rangemin > rangemax";
174  levWin->SetRangeMinMax(2100, 2000);
175  if (!(levWin->GetRangeMin() == 2000 && levWin->GetRangeMax() == 2100))
176  {
177  std::cout << "[FAILED]" << std::endl;
178  return EXIT_FAILURE;
179  }
180  std::cout << "[PASSED]" << std::endl;
181 
182  std::cout << "Testing mitk::LevelWindow SetRangeMinMax ";
183  levWin->SetRangeMinMax(-1000, 2000);
184  std::cout << "[PASSED]" << std::endl;
185 
186  std::cout << "Testing mitk::LevelWindow GetRangeMin ";
187  if (!(levWin->GetRangeMin() == -1000))
188  {
189  std::cout << "[FAILED]" << std::endl;
190  return EXIT_FAILURE;
191  }
192  std::cout << "[PASSED]" << std::endl;
193 
194  std::cout << "Testing mitk::LevelWindow GetRangeMax ";
195  if (!(levWin->GetRangeMax() == 2000))
196  {
197  std::cout << "[FAILED]" << std::endl;
198  return EXIT_FAILURE;
199  }
200  std::cout << "[PASSED]" << std::endl;
201 
202  std::cout << "Testing mitk::LevelWindow GetRange ";
203  if (!((levWin->GetRangeMax() - levWin->GetRangeMin()) == levWin->GetRange()))
204  {
205  std::cout << "[FAILED]" << std::endl;
206  return EXIT_FAILURE;
207  }
208  std::cout << "[PASSED]" << std::endl;
209 
210  std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries with rangemin = rangemax";
211  levWin->SetDefaultBoundaries(2000, 2000);
212  if (!(levWin->GetDefaultLowerBound() == 1999 && levWin->GetDefaultUpperBound() == 2000))
213  {
214  std::cout << "[FAILED]" << std::endl;
215  return EXIT_FAILURE;
216  }
217  std::cout << "[PASSED]" << std::endl;
218 
219  std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries with rangemin > rangemax";
220  levWin->SetDefaultBoundaries(2100, 2000);
221  if (!(levWin->GetDefaultLowerBound() == 2000 && levWin->GetDefaultUpperBound() == 2100))
222  {
223  std::cout << "[FAILED]" << std::endl;
224  return EXIT_FAILURE;
225  }
226  std::cout << "[PASSED]" << std::endl;
227 
228  std::cout << "Testing mitk::LevelWindow SetDefaultBoundaries ";
229  levWin->SetDefaultBoundaries(-2000, 8000);
230  std::cout << "[PASSED]" << std::endl;
231 
232  std::cout << "Testing mitk::LevelWindow GetDefaultLowerBound ";
233  if (!(levWin->GetDefaultLowerBound() == -2000))
234  {
235  std::cout << "[FAILED]" << std::endl;
236  return EXIT_FAILURE;
237  }
238  std::cout << "[PASSED]" << std::endl;
239 
240  std::cout << "Testing mitk::LevelWindow GetDefaultUpperBound ";
241  if (!(levWin->GetDefaultUpperBound() == 8000))
242  {
243  std::cout << "[FAILED]" << std::endl;
244  return EXIT_FAILURE;
245  }
246  std::cout << "[PASSED]" << std::endl;
247 
248  std::cout << "Testing mitk::LevelWindow ResetDefaultRangeMinMax ";
249  levWin->ResetDefaultRangeMinMax();
250  if (!((levWin->GetRangeMin() == levWin->GetDefaultLowerBound()) &&
251  (levWin->GetRangeMax() == levWin->GetDefaultUpperBound())))
252  {
253  std::cout << "[FAILED]" << std::endl;
254  return EXIT_FAILURE;
255  }
256  std::cout << "[PASSED]" << std::endl;
257 
258  std::cout << "Testing mitk::LevelWindow minRange > maxRange ";
259  levWin->SetRangeMinMax(2000, 1000);
260  if (!((levWin->GetRangeMin() == 1000) && (levWin->GetRangeMax() == 2000)))
261  {
262  std::cout << "[FAILED]" << std::endl;
263  return EXIT_FAILURE;
264  }
265  levWin->SetRangeMinMax(2000, -1000);
266  if (!((levWin->GetRangeMin() == -1000) && (levWin->GetRangeMax() == 2000)))
267  {
268  std::cout << "[FAILED]" << std::endl;
269  return EXIT_FAILURE;
270  }
271  levWin->SetRangeMinMax(-2000, -3000);
272  if (!((levWin->GetRangeMin() == -3000) && (levWin->GetRangeMax() == -2000)))
273  {
274  std::cout << "[FAILED]" << std::endl;
275  return EXIT_FAILURE;
276  }
277  levWin->SetRangeMinMax(0, -1000);
278  if (!((levWin->GetRangeMin() == -1000) && (levWin->GetRangeMax() == 0)))
279  {
280  std::cout << "[FAILED]" << std::endl;
281  return EXIT_FAILURE;
282  }
283  levWin->SetRangeMinMax(2000, 0);
284  if (!((levWin->GetRangeMin() == 0) && (levWin->GetRangeMax() == 2000)))
285  {
286  std::cout << "[FAILED]" << std::endl;
287  return EXIT_FAILURE;
288  }
289  levWin->SetRangeMinMax(-10000, 10000);
290  std::cout << "[PASSED]" << std::endl;
291 
292  std::cout << "Testing mitk::LevelWindow defaultMinRange > defaultMaxRange ";
293  levWin->SetDefaultBoundaries(2000, 1000);
294  if (!((levWin->GetDefaultLowerBound() == 1000) && (levWin->GetDefaultUpperBound() == 2000)))
295  {
296  std::cout << "[FAILED]" << std::endl;
297  return EXIT_FAILURE;
298  }
299  levWin->SetDefaultBoundaries(2000, -1000);
300  if (!((levWin->GetDefaultLowerBound() == -1000) && (levWin->GetDefaultUpperBound() == 2000)))
301  {
302  std::cout << "[FAILED]" << std::endl;
303  return EXIT_FAILURE;
304  }
305  levWin->SetDefaultBoundaries(-2000, -3000);
306  if (!((levWin->GetDefaultLowerBound() == -3000) && (levWin->GetDefaultUpperBound() == -2000)))
307  {
308  std::cout << "[FAILED]" << std::endl;
309  return EXIT_FAILURE;
310  }
311  levWin->SetDefaultBoundaries(0, -1000);
312  if (!((levWin->GetDefaultLowerBound() == -1000) && (levWin->GetDefaultUpperBound() == 0)))
313  {
314  std::cout << "[FAILED]" << std::endl;
315  return EXIT_FAILURE;
316  }
317  levWin->SetDefaultBoundaries(2000, 0);
318  if (!((levWin->GetDefaultLowerBound() == 0) && (levWin->GetDefaultUpperBound() == 2000)))
319  {
320  std::cout << "[FAILED]" << std::endl;
321  return EXIT_FAILURE;
322  }
323  levWin->SetDefaultBoundaries(-10000, 10000);
324  std::cout << "[PASSED]" << std::endl;
325 
326  std::cout << "Testing mitk::LevelWindow min > max ";
327  levWin->SetWindowBounds(2000, 1000);
328  if (!((levWin->GetLowerWindowBound() == 1000) && (levWin->GetUpperWindowBound() == 2000)))
329  {
330  std::cout << "[FAILED]" << std::endl;
331  return EXIT_FAILURE;
332  }
333  levWin->SetWindowBounds(2000, -1000);
334  if (!((levWin->GetLowerWindowBound() == -1000) && (levWin->GetUpperWindowBound() == 2000)))
335  {
336  std::cout << "[FAILED]" << std::endl;
337  return EXIT_FAILURE;
338  }
339  levWin->SetWindowBounds(-2000, -3000);
340  if (!((levWin->GetLowerWindowBound() == -3000) && (levWin->GetUpperWindowBound() == -2000)))
341  {
342  std::cout << "[FAILED]" << std::endl;
343  return EXIT_FAILURE;
344  }
345  levWin->SetWindowBounds(0, -1000);
346  if (!((levWin->GetLowerWindowBound() == -1000) && (levWin->GetUpperWindowBound() == 0)))
347  {
348  std::cout << "[FAILED]" << std::endl;
349  return EXIT_FAILURE;
350  }
351  levWin->SetWindowBounds(2000, 0);
352  if (!((levWin->GetLowerWindowBound() == 0) && (levWin->GetUpperWindowBound() == 2000)))
353  {
354  std::cout << "[FAILED]" << std::endl;
355  return EXIT_FAILURE;
356  }
357  levWin->ResetDefaultLevelWindow();
358  std::cout << "[PASSED]" << std::endl;
359 
360  // minmax > maxrange, minmax < minrange, min<maxrange & max >maxrange, min < minrange & max > minrange
361  // max < minrange & min > minrange, min > maxrange & max < maxrange, min < minrange & max > maxrange
362  // min > maxrange & max < minrange
363  std::cout << "Testing mitk::LevelWindow max > min > maxrange autoexpand = FALSE";
364  levWin->SetWindowBounds(11000, 12000, false);
365  if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
366  {
367  std::cout << "[FAILED]" << levWin->GetLowerWindowBound() << "," << levWin->GetUpperWindowBound() << std::endl;
368  return EXIT_FAILURE;
369  }
370  levWin->ResetDefaultLevelWindow();
371  std::cout << "[PASSED]" << std::endl;
372 
373  std::cout << "Testing mitk::LevelWindow max > min > maxrange autoexpand = TRUE";
374  levWin->SetWindowBounds(11000, 12000);
375  if (!((levWin->GetLowerWindowBound() == 11000) && (levWin->GetUpperWindowBound() == 12000)))
376  {
377  std::cout << "[FAILED]" << levWin->GetLowerWindowBound() << "," << levWin->GetUpperWindowBound() << std::endl;
378  return EXIT_FAILURE;
379  }
380  levWin->ResetDefaultLevelWindow();
381  std::cout << "[PASSED]" << std::endl;
382 
383  // Reset default window
384  resetLevelWindow(*levWin);
385 
386  std::cout << "Testing mitk::LevelWindow min > max > maxrange autoexpand = FALSE";
387  levWin->SetWindowBounds(12000, 11000, false);
388  if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
389  {
390  std::cout << "[FAILED]" << std::endl;
391  return EXIT_FAILURE;
392  }
393  levWin->ResetDefaultLevelWindow();
394  std::cout << "[PASSED]" << std::endl;
395 
396  std::cout << "Testing mitk::LevelWindow min > max > maxrange autoexpand = TRUE";
397  levWin->SetWindowBounds(12000, 11000);
398  if (!((levWin->GetLowerWindowBound() == 11000) && (levWin->GetUpperWindowBound() == 12000)))
399  {
400  std::cout << "[FAILED]" << std::endl;
401  return EXIT_FAILURE;
402  }
403  levWin->ResetDefaultLevelWindow();
404  std::cout << "[PASSED]" << std::endl;
405 
406  resetLevelWindow(*levWin);
407 
408  std::cout << "Testing mitk::LevelWindow min < max < minrange autoexpand = FALSE";
409  levWin->SetWindowBounds(-12000, -11000, false);
410  if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
411  {
412  std::cout << "[FAILED]" << std::endl;
413  return EXIT_FAILURE;
414  }
415  levWin->ResetDefaultLevelWindow();
416  std::cout << "[PASSED]" << std::endl;
417 
418  std::cout << "Testing mitk::LevelWindow min < max < minrange autoexpand = TRUE";
419  levWin->SetWindowBounds(-12000, -11000);
420  if (!((levWin->GetLowerWindowBound() == -12000) && (levWin->GetUpperWindowBound() == -11000)))
421  {
422  std::cout << "[FAILED]" << std::endl;
423  return EXIT_FAILURE;
424  }
425  levWin->ResetDefaultLevelWindow();
426  std::cout << "[PASSED]" << std::endl;
427 
428  resetLevelWindow(*levWin);
429 
430  std::cout << "Testing mitk::LevelWindow max < min < minrange autoexpand = FALSE";
431  levWin->SetWindowBounds(-11000, -12000, false);
432  if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
433  {
434  std::cout << "[FAILED]: Expected (-10000, -9999): " << levWin->GetLowerWindowBound() << " - "
435  << levWin->GetUpperWindowBound() << std::endl;
436  return EXIT_FAILURE;
437  }
438  levWin->ResetDefaultLevelWindow();
439  std::cout << "[PASSED]" << std::endl;
440 
441  std::cout << "Testing mitk::LevelWindow max < min < minrange autoexpand = TRUE";
442  levWin->SetWindowBounds(-11000, -12000);
443  if (!((levWin->GetLowerWindowBound() == -12000) && (levWin->GetUpperWindowBound() == -11000)))
444  {
445  std::cout << "[FAILED]" << std::endl;
446  return EXIT_FAILURE;
447  }
448  levWin->ResetDefaultLevelWindow();
449  std::cout << "[PASSED]" << std::endl;
450 
451  resetLevelWindow(*levWin);
452 
453  std::cout << "Testing mitk::LevelWindow min < maxrang & max > maxrange autoexpand = FALSE";
454  levWin->SetWindowBounds(9999, 12000, false);
455  if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
456  {
457  std::cout << "[FAILED]" << std::endl;
458  return EXIT_FAILURE;
459  }
460  levWin->ResetDefaultLevelWindow();
461  std::cout << "[PASSED]" << std::endl;
462 
463  std::cout << "Testing mitk::LevelWindow min < maxrang & max > maxrange autoexpand = TRUE";
464  levWin->SetWindowBounds(9999, 12000);
465  if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 12000)))
466  {
467  std::cout << "[FAILED]" << std::endl;
468  return EXIT_FAILURE;
469  }
470  levWin->ResetDefaultLevelWindow();
471  std::cout << "[PASSED]" << std::endl;
472 
473  resetLevelWindow(*levWin);
474 
475  std::cout << "Testing mitk::LevelWindow min < minrange & max > minrange autoexpand = FALSE";
476  levWin->SetWindowBounds(-11000, -9999, false);
477  if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
478  {
479  std::cout << "[FAILED]" << std::endl;
480  return EXIT_FAILURE;
481  }
482  levWin->ResetDefaultLevelWindow();
483  std::cout << "[PASSED]" << std::endl;
484 
485  std::cout << "Testing mitk::LevelWindow min < minrange & max > minrange autoexpand = TRUE";
486  levWin->SetWindowBounds(-11000, -9999);
487  if (!((levWin->GetLowerWindowBound() == -11000) && (levWin->GetUpperWindowBound() == -9999)))
488  {
489  std::cout << "[FAILED]" << std::endl;
490  return EXIT_FAILURE;
491  }
492  levWin->ResetDefaultLevelWindow();
493  std::cout << "[PASSED]" << std::endl;
494 
495  resetLevelWindow(*levWin);
496 
497  std::cout << "Testing mitk::LevelWindow min < minrange & max > maxrange autoexpand = FALSE";
498  levWin->SetWindowBounds(-11000, 11000, false);
499  if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == 10000)))
500  {
501  std::cout << "[FAILED]" << std::endl;
502  return EXIT_FAILURE;
503  }
504  levWin->ResetDefaultLevelWindow();
505  std::cout << "[PASSED]" << std::endl;
506 
507  std::cout << "Testing mitk::LevelWindow min < minrange & max > maxrange autoexpand = TRUE";
508  levWin->SetWindowBounds(-11000, 11000);
509  if (!((levWin->GetLowerWindowBound() == -11000) && (levWin->GetUpperWindowBound() == 11000)))
510  {
511  std::cout << "[FAILED]" << std::endl;
512  return EXIT_FAILURE;
513  }
514  levWin->ResetDefaultLevelWindow();
515  std::cout << "[PASSED]" << std::endl;
516 
517  resetLevelWindow(*levWin);
518 
519  std::cout << "Testing mitk::LevelWindow maxrange > min = max > minrange autoexpand = FALSE";
520  levWin->SetWindowBounds(5000, 5000, false);
521  if (!((levWin->GetLowerWindowBound() == 4999.5) && (levWin->GetUpperWindowBound() == 5000.5)))
522  {
523  std::cout << "[FAILED]: Expected (4999.5, 5000.5): " << levWin->GetLowerWindowBound() << " - "
524  << levWin->GetUpperWindowBound() << std::endl;
525  return EXIT_FAILURE;
526  }
527  levWin->ResetDefaultLevelWindow();
528  std::cout << "[PASSED]" << std::endl;
529 
530  std::cout << "Testing mitk::LevelWindow maxrange > min = max > minrange autoexpand = TRUE";
531  levWin->SetWindowBounds(5000, 5000);
532  if (!((levWin->GetLowerWindowBound() == 4999.5) && (levWin->GetUpperWindowBound() == 5000.5)))
533  {
534  std::cout << "[FAILED]" << std::endl;
535  return EXIT_FAILURE;
536  }
537  levWin->ResetDefaultLevelWindow();
538  std::cout << "[PASSED]" << std::endl;
539 
540  resetLevelWindow(*levWin);
541 
542  std::cout << "Testing mitk::LevelWindow min = max = minrange autoexpand = FALSE";
543  levWin->SetWindowBounds(-10000, -10000, false);
544  if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
545  {
546  std::cout << "[FAILED]: Expected (-10000, -9999): " << levWin->GetLowerWindowBound() << " - "
547  << levWin->GetUpperWindowBound() << " . " << levWin->GetRangeMin() << std::endl;
548  return EXIT_FAILURE;
549  }
550  levWin->ResetDefaultLevelWindow();
551  std::cout << "[PASSED]" << std::endl;
552 
553  std::cout << "Testing mitk::LevelWindow min = max = minrange autoexpand = TRUE";
554  levWin->SetWindowBounds(-10000, -10000);
555  if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
556  {
557  std::cout << "[FAILED]" << std::endl;
558  return EXIT_FAILURE;
559  }
560  levWin->ResetDefaultLevelWindow();
561  std::cout << "[PASSED]" << std::endl;
562 
563  resetLevelWindow(*levWin);
564 
565  std::cout << "Testing mitk::LevelWindow min = max = maxrange autoexpand = FALSE";
566  levWin->SetWindowBounds(10000, 10000, false);
567  if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
568  {
569  std::cout << "[FAILED]" << std::endl;
570  return EXIT_FAILURE;
571  }
572  levWin->ResetDefaultLevelWindow();
573  std::cout << "[PASSED]" << std::endl;
574 
575  std::cout << "Testing mitk::LevelWindow min = max = maxrange autoexpand = TRUE";
576  levWin->SetWindowBounds(10000, 10000);
577  if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
578  {
579  std::cout << "[FAILED]" << std::endl;
580  return EXIT_FAILURE;
581  }
582  levWin->ResetDefaultLevelWindow();
583  std::cout << "[PASSED]" << std::endl;
584 
585  resetLevelWindow(*levWin);
586 
587  std::cout << "Testing mitk::LevelWindow min = max > maxrange autoexpand = FALSE";
588  levWin->SetWindowBounds(11000, 11000, false);
589  if (!((levWin->GetLowerWindowBound() == 9999) && (levWin->GetUpperWindowBound() == 10000)))
590  {
591  std::cout << "[FAILED]" << std::endl;
592  return EXIT_FAILURE;
593  }
594  levWin->ResetDefaultLevelWindow();
595  std::cout << "[PASSED]" << std::endl;
596 
597  std::cout << "Testing mitk::LevelWindow min = max > maxrange autoexpand = TRUE";
598  levWin->SetWindowBounds(11000, 11000);
599  if (!((levWin->GetLowerWindowBound() == 10999) && (levWin->GetUpperWindowBound() == 11000)))
600  {
601  std::cout << "[FAILED]" << std::endl;
602  return EXIT_FAILURE;
603  }
604  levWin->ResetDefaultLevelWindow();
605  std::cout << "[PASSED]" << std::endl;
606 
607  resetLevelWindow(*levWin);
608 
609  std::cout << "Testing mitk::LevelWindow min = max < minrange autoexpand = FALSE";
610  levWin->SetWindowBounds(-11000, -11000, false);
611  if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9999)))
612  {
613  std::cout << "[FAILED]" << std::endl;
614  return EXIT_FAILURE;
615  }
616  levWin->ResetDefaultLevelWindow();
617  std::cout << "[PASSED]" << std::endl;
618 
619  std::cout << "Testing mitk::LevelWindow min = max < minrange autoexpand = TRUE";
620  levWin->SetWindowBounds(-11000, -11000);
621  if (!((levWin->GetLowerWindowBound() == -11000) && (levWin->GetUpperWindowBound() == -10999)))
622  {
623  std::cout << "[FAILED]" << std::endl;
624  return EXIT_FAILURE;
625  }
626  levWin->ResetDefaultLevelWindow();
627  std::cout << "[PASSED]" << std::endl;
628 
629  resetLevelWindow(*levWin);
630 
631  std::cout << "Testing mitk::LevelWindow maxrange > min > minrange > max autoexpand = FALSE";
632  levWin->SetWindowBounds(-9000, -11000, false);
633  if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == -9000)))
634  {
635  std::cout << "[FAILED]" << std::endl;
636  return EXIT_FAILURE;
637  }
638  levWin->ResetDefaultLevelWindow();
639  std::cout << "[PASSED]" << std::endl;
640 
641  std::cout << "Testing mitk::LevelWindow maxrange > min > minrange > max autoexpand = TRUE";
642  levWin->SetWindowBounds(-9000, -11000, true);
643  if (!((levWin->GetLowerWindowBound() == -11000) && (levWin->GetUpperWindowBound() == -9000)))
644  {
645  std::cout << "[FAILED]" << std::endl;
646  return EXIT_FAILURE;
647  }
648  levWin->ResetDefaultLevelWindow();
649  std::cout << "[PASSED]" << std::endl;
650 
651  resetLevelWindow(*levWin);
652 
653  std::cout << "Testing mitk::LevelWindow min > maxrange > minrange > max autoexpand = FALSE";
654  levWin->SetWindowBounds(11000, -11000, false);
655  if (!((levWin->GetLowerWindowBound() == -10000) && (levWin->GetUpperWindowBound() == 10000)))
656  {
657  std::cout << "[FAILED]" << std::endl;
658  return EXIT_FAILURE;
659  }
660  levWin->ResetDefaultLevelWindow();
661  std::cout << "[PASSED]" << std::endl;
662 
663  std::cout << "Testing mitk::LevelWindow min > maxrange > minrange > max autoexpand = TRUE";
664  levWin->SetWindowBounds(11000, -11000);
665  if (!((levWin->GetLowerWindowBound() == -11000) && (levWin->GetUpperWindowBound() == 11000)))
666  {
667  std::cout << "[FAILED]" << std::endl;
668  return EXIT_FAILURE;
669  }
670  levWin->ResetDefaultLevelWindow();
671  std::cout << "[PASSED]" << std::endl;
672 
673  resetLevelWindow(*levWin);
674 
675  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with maxrange < min < max autoexpand = FALSE";
676  levWin->SetRangeMinMax(-20000, -15000);
677  if (!((levWin->GetLowerWindowBound() == -15001) && (levWin->GetUpperWindowBound() == -15000)))
678  {
679  std::cout << "[FAILED]" << std::endl;
680  return EXIT_FAILURE;
681  }
682  levWin->ResetDefaultRangeMinMax();
683  levWin->ResetDefaultLevelWindow();
684  std::cout << "[PASSED]" << std::endl;
685 
686  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange > maxrange & maxrange < min < max ";
687  levWin->ResetDefaultLevelWindow();
688  levWin->SetRangeMinMax(-15000, -20000);
689  if (!((levWin->GetLowerWindowBound() == -15001) && (levWin->GetUpperWindowBound() == -15000)))
690  {
691  std::cout << "[FAILED]" << std::endl;
692  return EXIT_FAILURE;
693  }
694  levWin->ResetDefaultRangeMinMax();
695  levWin->ResetDefaultLevelWindow();
696  std::cout << "[PASSED]" << std::endl;
697 
698  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange < min < maxrange < max autoexpand = FALSE";
699  levWin->SetRangeMinMax(-80, 1000);
700  levWin->SetWindowBounds(-1000, 110, false);
701  if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 110)))
702  {
703  std::cout << "[FAILED]" << std::endl;
704  return EXIT_FAILURE;
705  }
706  levWin->ResetDefaultRangeMinMax();
707  levWin->ResetDefaultLevelWindow();
708  std::cout << "[PASSED]" << std::endl;
709 
710  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange < min < maxrange < max autoexpand = TRUE";
711  levWin->SetRangeMinMax(-80, 1000);
712  levWin->SetWindowBounds(-1000, 110);
713  if (!((levWin->GetLowerWindowBound() == -1000) && (levWin->GetUpperWindowBound() == 110)))
714  {
715  std::cout << "[FAILED]" << std::endl;
716  return EXIT_FAILURE;
717  }
718  levWin->ResetDefaultRangeMinMax();
719  levWin->ResetDefaultLevelWindow();
720  std::cout << "[PASSED]" << std::endl;
721 
722  resetLevelWindow(*levWin);
723 
724  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with maxrange < minrange & minrange < min < maxrange < max "
725  "autoexpand = FALSE";
726  levWin->SetRangeMinMax(1000, -80);
727  levWin->SetWindowBounds(-1000, 110, false);
728  if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 110)))
729  {
730  std::cout << "[FAILED]" << std::endl;
731  return EXIT_FAILURE;
732  }
733  levWin->ResetDefaultRangeMinMax();
734  levWin->ResetDefaultLevelWindow();
735  std::cout << "[PASSED]" << std::endl;
736 
737  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with maxrange < minrange & minrange < min < maxrange < max "
738  "autoexpand = TRUE";
739  levWin->SetRangeMinMax(1000, -80);
740  levWin->SetWindowBounds(-1000, 110);
741  if (!((levWin->GetLowerWindowBound() == -1000) && (levWin->GetUpperWindowBound() == 110)))
742  {
743  std::cout << "[FAILED]" << std::endl;
744  return EXIT_FAILURE;
745  }
746  levWin->ResetDefaultRangeMinMax();
747  levWin->ResetDefaultLevelWindow();
748  std::cout << "[PASSED]" << std::endl;
749 
750  resetLevelWindow(*levWin);
751 
752  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with min < minrange < maxrange <max ";
753  levWin->SetRangeMinMax(20, 110);
754  if (!((levWin->GetLowerWindowBound() == 20) && (levWin->GetUpperWindowBound() == 110)))
755  {
756  std::cout << "[FAILED]" << std::endl;
757  return EXIT_FAILURE;
758  }
759  levWin->ResetDefaultRangeMinMax();
760  levWin->ResetDefaultLevelWindow();
761  std::cout << "[PASSED]" << std::endl;
762 
763  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minRange > maxRange & min < maxrange < max ";
764  levWin->SetWindowBounds(-90, 1000);
765  levWin->SetRangeMinMax(100, -80);
766 
767  if (!((levWin->GetLowerWindowBound() == -80) && (levWin->GetUpperWindowBound() == 100)))
768  {
769  std::cout << "[FAILED]" << std::endl;
770  return EXIT_FAILURE;
771  }
772  levWin->ResetDefaultRangeMinMax();
773  levWin->ResetDefaultLevelWindow();
774  std::cout << "[PASSED]" << std::endl;
775 
776  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minRange > maxRange & min < minrange < maxrange <max ";
777  levWin->SetRangeMinMax(20, 100);
778  if (!((levWin->GetLowerWindowBound() == 20) && (levWin->GetUpperWindowBound() == 100)))
779  {
780  std::cout << "[FAILED]" << std::endl;
781  return EXIT_FAILURE;
782  }
783  levWin->ResetDefaultRangeMinMax();
784  levWin->ResetDefaultLevelWindow();
785  std::cout << "[PASSED]" << std::endl;
786 
787  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with min < max < minrange ";
788  levWin->SetRangeMinMax(20000, 15000);
789  if (!((levWin->GetLowerWindowBound() == 15000) && (levWin->GetUpperWindowBound() == 15001)))
790  {
791  std::cout << "[FAILED]" << std::endl;
792  return EXIT_FAILURE;
793  }
794  levWin->ResetDefaultRangeMinMax();
795  levWin->ResetDefaultLevelWindow();
796  std::cout << "[PASSED]" << std::endl;
797 
798  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with minrange > maxrange & min < max < minrange ";
799  levWin->SetRangeMinMax(20000, 15000);
800  if (!((levWin->GetLowerWindowBound() == 15000) && (levWin->GetUpperWindowBound() == 15001)))
801  {
802  std::cout << "[FAILED]" << std::endl;
803  return EXIT_FAILURE;
804  }
805  levWin->ResetDefaultRangeMinMax();
806  levWin->ResetDefaultLevelWindow();
807  std::cout << "[PASSED]" << std::endl;
808 
809  std::cout << "Testing mitk::LevelWindow SetRangeMinMax with min < minrange <max ";
810  levWin->SetRangeMinMax(-20000, -15000);
811  if (!((levWin->GetLowerWindowBound() == -15001) && (levWin->GetUpperWindowBound() == -15000)))
812  {
813  std::cout << "[FAILED]" << std::endl;
814  return EXIT_FAILURE;
815  }
816  levWin->ResetDefaultRangeMinMax();
817  levWin->ResetDefaultLevelWindow();
818  std::cout << "[PASSED]" << std::endl;
819 
820  // auch für default levelwindow und default range
821 
822  // Create Image out of nowhere
823  mitk::Image::Pointer image;
824  // mitk::PixelType pt(typeid(int));
825  unsigned int dim[] = {100, 100, 20};
826 
827  std::cout << "Creating image: ";
828  image = mitk::Image::New();
829  // image->DebugOn();
830 
831  image->Initialize(mitk::MakePixelType<int, int, 1>(), 3, dim);
832  mitk::ImageWriteAccessor imAccess(image);
833  auto *p = (int *)imAccess.GetData();
834 
835  int size = dim[0] * dim[1] * dim[2];
836  int i;
837  for (i = 0; i < size; ++i, ++p)
838  *p = i;
839  std::cout << "[PASSED]" << std::endl;
840 
841  std::cout << "Testing mitk::LevelWindow SetAuto ";
842  mitk::LevelWindow levelwindow;
843  levelwindow.SetAuto(image);
844  std::cout << "[PASSED]" << std::endl;
845 
846  std::cout << "Testing mitk::LevelWindow constructor with mitkLevelWindow ";
847  const mitk::LevelWindow *lw = new mitk::LevelWindow(levelwindow);
848  if (!(lw->GetRange() == levelwindow.GetRange()))
849  {
850  std::cout << "[FAILED]" << std::endl;
851  delete lw;
852  return EXIT_FAILURE;
853  }
854  std::cout << "[PASSED]" << std::endl;
855 
856  std::cout << "Testing mitk::LevelWindow destructor ";
857  delete levWin;
858  delete lw;
859 
860  std::cout << "[PASSED]" << std::endl;
861 
862  mitk::LevelWindow levelWindow(50, 100);
863  levelWindow.SetRangeMinMax(0, 100);
864  // test range restriction/adaption for SetLevelWindow and SetWindowBounds
865  std::cout << "Testing range restriction of mitk::LevelWindow::SetWindowBounds() autoexpand = FALSE";
866  mitk::ScalarType initialUpperBound = levelWindow.GetUpperWindowBound();
867  mitk::ScalarType initialLowerBound = levelWindow.GetLowerWindowBound();
868  levelWindow.SetWindowBounds(-10, 110, false);
869  if (levelWindow.GetUpperWindowBound() != initialUpperBound || levelWindow.GetLowerWindowBound() != initialLowerBound)
870  {
871  std::cout << "[FAILED]" << std::endl;
872  return EXIT_FAILURE;
873  }
874  std::cout << "[PASSED]" << std::endl;
875 
876  std::cout << "Testing range restriction of mitk::LevelWindow::SetWindowBounds() autoexpand = TRUE";
877  levelWindow.SetWindowBounds(-10, 110);
878  if (levelWindow.GetUpperWindowBound() != 110 || levelWindow.GetLowerWindowBound() != -10)
879  {
880  std::cout << "[FAILED]" << std::endl;
881  return EXIT_FAILURE;
882  }
883  std::cout << "[PASSED]" << std::endl;
884 
885  levelWindow.SetRangeMinMax(0, 100);
886  levelWindow.SetLevelWindow(50, 100);
887 
888  std::cout << "Testing range restriction of mitk::LevelWindow::SetLevelWindow() autoexpand = FALSE";
889  levelWindow.SetLevelWindow(60, 100, false);
890  if (levelWindow.GetUpperWindowBound() != initialUpperBound)
891  {
892  std::cout << "[FAILED]" << std::endl;
893  return EXIT_FAILURE;
894  }
895  std::cout << "[PASSED]" << std::endl;
896 
897  std::cout << "Testing range restriction of mitk::LevelWindow::SetLevelWindow() autoexpand = TRUE";
898  levelWindow.SetLevelWindow(60, 100);
899  if (levelWindow.GetUpperWindowBound() != initialUpperBound + 10)
900  {
901  std::cout << "[FAILED]" << std::endl;
902  return EXIT_FAILURE;
903  }
904  std::cout << "[PASSED]" << std::endl;
905 
906  levelWindow.SetRangeMinMax(0, 100);
907  levelWindow.SetLevelWindow(50, 100);
908 
909  std::cout << "Testing range restriction of mitk::LevelWindow::SetLevelWindow() autoexpand = FALSE";
910  levelWindow.SetLevelWindow(40, 100, false);
911  if (levelWindow.GetLowerWindowBound() != initialLowerBound)
912  {
913  std::cout << "[FAILED]" << std::endl;
914  return EXIT_FAILURE;
915  }
916  std::cout << "[PASSED]" << std::endl;
917 
918  std::cout << "Testing range restriction of mitk::LevelWindow::SetLevelWindow() autoexpand = TRUE";
919  levelWindow.SetLevelWindow(40, 100);
920  if (levelWindow.GetLowerWindowBound() != initialLowerBound - 10)
921  {
922  std::cout << "[FAILED]" << std::endl;
923  return EXIT_FAILURE;
924  }
925  std::cout << "[PASSED]" << std::endl;
926 
927  std::cout << "Testing range adaption of mitk::LevelWindow::SetWindowBounds()";
928  levelWindow.SetWindowBounds(-10, 90, true); // ture == force
929  if (levelWindow.GetUpperWindowBound() != 90.0 || levelWindow.GetLowerWindowBound() != -10.0)
930  {
931  std::cout << "[FAILED]" << std::endl;
932  return EXIT_FAILURE;
933  }
934  std::cout << "[PASSED]" << std::endl;
935 
936  std::cout << "Testing range adaption of mitk::LevelWindow::SetWindowBounds()";
937  levelWindow.SetWindowBounds(-20, 110, true); // ture == force
938  if (levelWindow.GetUpperWindowBound() != 110.0 || levelWindow.GetLowerWindowBound() != -20.0)
939  {
940  std::cout << "[FAILED]" << std::endl;
941  return EXIT_FAILURE;
942  }
943  std::cout << "[PASSED]" << std::endl;
944 
945  std::cout << "Testing range adaption of mitk::LevelWindow::SetLevelWindow()";
946  levelWindow.SetLevelWindow(50, 140, true); // ture == force
947  if (levelWindow.GetUpperWindowBound() != 120.0 || levelWindow.GetLowerWindowBound() != -20.0)
948  {
949  std::cout << "[FAILED]" << std::endl;
950  return EXIT_FAILURE;
951  }
952  std::cout << "[PASSED]" << std::endl;
953 
954  std::cout << "Testing c'tor with x-ray values (formerly did not expand range enough)";
955  mitk::LevelWindow crLevelWindow(16352, 16444);
956  if (crLevelWindow.GetLevel() != 16352.0 || crLevelWindow.GetWindow() != 16444.0)
957  {
958  std::cout << "[FAILED]" << std::endl;
959  return EXIT_FAILURE;
960  }
961  std::cout << "[PASSED]" << std::endl;
962 
963  std::cout << "[PASSED]" << std::endl;
964  std::cout << "[TEST DONE]" << std::endl;
965  return EXIT_SUCCESS;
966 }
mitk::LevelWindow::SetWindowBounds
void SetWindowBounds(ScalarType lowerBound, ScalarType upperBound, bool expandRangesIfNecessary=true)
Definition: mitkLevelWindow.cpp:130
mitk::LevelWindow::GetLevel
ScalarType GetLevel() const
method that returns the level value, i.e. the center of the current grey value interval ...
Definition: mitkLevelWindow.cpp:85
mitk::ScalarType
double ScalarType
Definition: mitkNumericConstants.h:20
mitk::ImageWriteAccessor::GetData
void * GetData()
Gives full data access.
Definition: mitkImageWriteAccessor.h:47
mitk::LevelWindow::SetRangeMinMax
void SetRangeMinMax(ScalarType min, ScalarType max)
Definition: mitkLevelWindow.cpp:159
mitk::LevelWindow
The LevelWindow class Class to store level/window values.
Definition: mitkLevelWindow.h:44
mitk::LevelWindow::GetUpperWindowBound
ScalarType GetUpperWindowBound() const
Definition: mitkLevelWindow.cpp:115
mitk::LevelWindow::GetRange
ScalarType GetRange() const
returns the size of the grey value range
Definition: mitkLevelWindow.cpp:200
resetLevelWindow
void resetLevelWindow(mitk::LevelWindow &lw)
Definition: mitkLevelWindowTest.cpp:21
mitk::LevelWindow::SetAuto
void SetAuto(const Image *image, bool tryPicTags=true, bool guessByCentralSlice=true, unsigned selectedComponent=0)
sets level/window to optimize the contrast of the given Image
Definition: mitkLevelWindow.cpp:256
image
mitk::Image::Pointer image
Definition: GenericFittingMiniApp.cpp:43
mitk::Image::New
static Pointer New()
mitk::LevelWindow::GetRangeMax
ScalarType GetRangeMax() const
Definition: mitkLevelWindow.cpp:195
mitkLevelWindowTest
int mitkLevelWindowTest(int, char *[])
Definition: mitkLevelWindowTest.cpp:32
mitk::LevelWindow::GetWindow
ScalarType GetWindow() const
returns the current window size, i.e the range size of the current grey value interval ...
Definition: mitkLevelWindow.cpp:90
mitk::LevelWindow::GetRangeMin
ScalarType GetRangeMin() const
Definition: mitkLevelWindow.cpp:190
mitk::ImageWriteAccessor
ImageWriteAccessor class to get locked write-access for a particular image part.
Definition: mitkImageWriteAccessor.h:25
mitk::LevelWindow::SetLevelWindow
void SetLevelWindow(ScalarType level, ScalarType window, bool expandRangesIfNecessary=true)
Definition: mitkLevelWindow.cpp:125
mitk::LevelWindow::GetLowerWindowBound
ScalarType GetLowerWindowBound() const
Definition: mitkLevelWindow.cpp:110