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
mitkLevelWindowManagerTest.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 "itkMersenneTwisterRandomVariateGenerator.h"
18 #include "mitkLevelWindowManager.h"
19 #include "mitkRenderingModeProperty.h"
20 #include "mitkStandaloneDataStorage.h"
21 #include <itkComposeImageFilter.h>
22 #include <itkEventObject.h>
23 #include <itkImageDuplicator.h>
24 #include <itkImageIterator.h>
25 #include <itkMersenneTwisterRandomVariateGenerator.h>
26 #include <mitkIOUtil.h>
27 #include <mitkImageCast.h>
28 #include <mitkTestingMacros.h>
29 
30 class mitkLevelWindowManagerTestClass
31 {
32 public:
33  static void TestInstantiation()
34  {
35  mitk::LevelWindowManager::Pointer manager;
36  manager = mitk::LevelWindowManager::New();
37  MITK_TEST_CONDITION_REQUIRED(manager.IsNotNull(), "Testing mitk::LevelWindowManager::New()");
38  }
39 
40  static void TestSetGetDataStorage()
41  {
42  mitk::LevelWindowManager::Pointer manager;
43  manager = mitk::LevelWindowManager::New();
44  MITK_TEST_OUTPUT(<< "Creating DataStorage: ");
45  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
46 
47  bool success = true;
48  try
49  {
50  manager->SetDataStorage(ds);
51  }
52  catch (std::exception &e)
53  {
54  success = false;
55  MITK_ERROR << "Exception: " << e.what();
56  }
57  MITK_TEST_CONDITION_REQUIRED(success, "Testing mitk::LevelWindowManager SetDataStorage() ");
58  MITK_TEST_CONDITION_REQUIRED(ds == manager->GetDataStorage(), "Testing mitk::LevelWindowManager GetDataStorage ");
59  }
60 
61  static void TestMethodsWithInvalidParameters()
62  {
63  mitk::LevelWindowManager::Pointer manager;
64  manager = mitk::LevelWindowManager::New();
65  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
66  manager->SetDataStorage(ds);
67 
68  bool success = false;
69  mitk::LevelWindowProperty::Pointer levelWindowProperty = mitk::LevelWindowProperty::New();
70  try
71  {
72  manager->SetLevelWindowProperty(levelWindowProperty);
73  }
74  catch (mitk::Exception &e)
75  {
76  success = true;
77  }
78  MITK_TEST_CONDITION(success, "Testing mitk::LevelWindowManager SetLevelWindowProperty with invalid parameter");
79  }
80 
81  static void TestOtherMethods()
82  {
83  mitk::LevelWindowManager::Pointer manager;
84  manager = mitk::LevelWindowManager::New();
85  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
86  manager->SetDataStorage(ds);
87 
88  MITK_TEST_CONDITION(manager->isAutoTopMost(), "Testing mitk::LevelWindowManager isAutoTopMost");
89 
90  // It is not clear what the following code is supposed to test. The expression in
91  // the catch(...) block does have no effect, so success is always true.
92  // Related bugs are 13894 and 13889
93  /*
94  bool success = true;
95  try
96  {
97  mitk::LevelWindow levelWindow = manager->GetLevelWindow();
98  manager->SetLevelWindow(levelWindow);
99  }
100  catch (...)
101  {
102  success == false;
103  }
104  MITK_TEST_CONDITION(success,"Testing mitk::LevelWindowManager GetLevelWindow() and SetLevelWindow()");
105  */
106 
107  manager->SetAutoTopMostImage(true);
108  MITK_TEST_CONDITION(manager->isAutoTopMost(), "Testing mitk::LevelWindowManager isAutoTopMost()");
109  }
110 
111  static void TestRemoveObserver(std::string testImageFile)
112  {
113  mitk::LevelWindowManager::Pointer manager;
114  manager = mitk::LevelWindowManager::New();
115  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
116  manager->SetDataStorage(ds);
117 
118  // add multiple objects to the data storage => multiple observers should be created
119  mitk::Image::Pointer image1 = mitk::IOUtil::LoadImage(testImageFile);
120  mitk::DataNode::Pointer node1 = mitk::DataNode::New();
121  node1->SetData(image1);
122  mitk::Image::Pointer image2 = mitk::IOUtil::LoadImage(testImageFile);
123  mitk::DataNode::Pointer node2 = mitk::DataNode::New();
124  node2->SetData(image2);
125  ds->Add(node1);
126  ds->Add(node2);
127 
128  MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 2, "Test if nodes have been added");
129  MITK_TEST_CONDITION_REQUIRED(
130  static_cast<int>(manager->GetRelevantNodes()->size()) == manager->GetNumberOfObservers(),
131  "Test if number of nodes is similar to number of observers");
132 
133  mitk::Image::Pointer image3 = mitk::IOUtil::LoadImage(testImageFile);
134  mitk::DataNode::Pointer node3 = mitk::DataNode::New();
135  node3->SetData(image3);
136  ds->Add(node3);
137  MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 3, "Test if another node have been added");
138  MITK_TEST_CONDITION_REQUIRED(
139  static_cast<int>(manager->GetRelevantNodes()->size()) == manager->GetNumberOfObservers(),
140  "Test if number of nodes is similar to number of observers");
141 
142  ds->Remove(node1);
143  MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 2, "Deleted node 1 (test GetRelevantNodes())");
144  MITK_TEST_CONDITION_REQUIRED(manager->GetNumberOfObservers() == 2, "Deleted node 1 (test GetNumberOfObservers())");
145 
146  ds->Remove(node2);
147  MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 1, "Deleted node 2 (test GetRelevantNodes())");
148  MITK_TEST_CONDITION_REQUIRED(manager->GetNumberOfObservers() == 1, "Deleted node 2 (test GetNumberOfObservers())");
149 
150  ds->Remove(node3);
151  MITK_TEST_CONDITION_REQUIRED(manager->GetRelevantNodes()->size() == 0, "Deleted node 3 (test GetRelevantNodes())");
152  MITK_TEST_CONDITION_REQUIRED(manager->GetNumberOfObservers() == 0, "Deleted node 3 (test GetNumberOfObservers())");
153  }
154 
155  static bool VerifyRenderingModes()
156  {
157  bool ok = (mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR == 1) &&
158  (mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR == 2) &&
159  (mitk::RenderingModeProperty::LOOKUPTABLE_COLOR == 3) &&
160  (mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR == 4);
161 
162  return ok;
163  }
164 
165  static void TestLevelWindowSliderVisibility(std::string testImageFile)
166  {
167  bool renderingModesValid = mitkLevelWindowManagerTestClass::VerifyRenderingModes();
168  if (!renderingModesValid)
169  {
170  MITK_ERROR << "Exception: Image Rendering.Mode property value types inconsistent.";
171  }
172 
173  mitk::LevelWindowManager::Pointer manager;
174  manager = mitk::LevelWindowManager::New();
175  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
176  manager->SetDataStorage(ds);
177 
178  // add multiple objects to the data storage => multiple observers should be created
179  mitk::Image::Pointer image1 = mitk::IOUtil::LoadImage(testImageFile);
180  mitk::DataNode::Pointer node1 = mitk::DataNode::New();
181  node1->SetData(image1);
182  ds->Add(node1);
183 
184  // mitk::DataNode::Pointer node1 = mitk::IOUtil::LoadDataNode( testImageFile );
185  mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
186  mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
187  std::vector<mitk::DataNode::Pointer> nodeVec;
188  // nodeVec.resize( 3 );
189  nodeVec.push_back(node1);
190  nodeVec.push_back(node2);
191  nodeVec.push_back(node3);
192 
193  typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType;
194  RandomGeneratorType::Pointer rnd = RandomGeneratorType::New();
195  rnd->Initialize();
196 
197  for (unsigned int i = 0; i < 8; ++i)
198  {
199  unsigned int parity = i;
200 
201  for (unsigned int img = 0; img < 3; ++img)
202  {
203  if (parity & 1)
204  {
205  int mode = rnd->GetIntegerVariate() % 3;
206  nodeVec[img]->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mode));
207  }
208  else
209  {
210  int mode = rnd->GetIntegerVariate() % 2;
211  nodeVec[img]->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(3 + mode));
212  }
213  parity >>= 1;
214  }
215 
216  MITK_TEST_CONDITION(
217  renderingModesValid && ((!manager->GetLevelWindowProperty() && !i) || (manager->GetLevelWindowProperty() && i)),
218  "Testing level window property member according to rendering mode");
219  }
220  }
221 
222  static void TestSetLevelWindowProperty(std::string testImageFile)
223  {
224  mitk::LevelWindowManager::Pointer manager = mitk::LevelWindowManager::New();
225  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
226  manager->SetDataStorage(ds);
227 
228  // add multiple objects to the data storage => multiple observers should be created
229  mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
230  mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
231  mitk::DataNode::Pointer node1 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
232 
233  node3->SetIntProperty("layer", 1);
234  node2->SetIntProperty("layer", 2);
235  node1->SetIntProperty("layer", 3);
236 
237  manager->SetAutoTopMostImage(true);
238 
239  bool isImageForLevelWindow1, isImageForLevelWindow2, isImageForLevelWindow3;
240  node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1);
241  node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2);
242  node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3);
243 
244  MITK_TEST_CONDITION(isImageForLevelWindow1 && !isImageForLevelWindow2 && !isImageForLevelWindow3,
245  "Testing exclusive imageForLevelWindow property for node 1.");
246 
247  manager->SetAutoTopMostImage(false);
248 
249  mitk::LevelWindowProperty::Pointer prop =
250  dynamic_cast<mitk::LevelWindowProperty *>(node2->GetProperty("levelwindow"));
251  manager->SetLevelWindowProperty(prop);
252  node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1);
253  node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2);
254  node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3);
255 
256  MITK_TEST_CONDITION(!isImageForLevelWindow1 && isImageForLevelWindow2 && !isImageForLevelWindow3,
257  "Testing exclusive imageForLevelWindow property for node 2.");
258 
259  prop = dynamic_cast<mitk::LevelWindowProperty *>(node3->GetProperty("levelwindow"));
260  manager->SetLevelWindowProperty(prop);
261  node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1);
262  node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2);
263  node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3);
264 
265  MITK_TEST_CONDITION(!isImageForLevelWindow1 && !isImageForLevelWindow2 && isImageForLevelWindow3,
266  "Testing exclusive imageForLevelWindow property for node 3.");
267 
268  prop = dynamic_cast<mitk::LevelWindowProperty *>(node1->GetProperty("levelwindow"));
269  manager->SetLevelWindowProperty(prop);
270  node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1);
271  node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2);
272  node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3);
273 
274  MITK_TEST_CONDITION(isImageForLevelWindow1 && !isImageForLevelWindow2 && !isImageForLevelWindow3,
275  "Testing exclusive imageForLevelWindow property for node 3.");
276  }
277 
278  static void TestImageForLevelWindowOnVisibilityChange(std::string testImageFile)
279  {
280  mitk::LevelWindowManager::Pointer manager = mitk::LevelWindowManager::New();
281  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
282  manager->SetDataStorage(ds);
283 
284  // add multiple objects to the data storage => multiple observers should be created
285  mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
286  mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
287  mitk::DataNode::Pointer node1 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
288 
289  node3->SetIntProperty("layer", 1);
290  node2->SetIntProperty("layer", 2);
291  node1->SetIntProperty("layer", 3);
292 
293  manager->SetAutoTopMostImage(false);
294 
295  bool isImageForLevelWindow1, isImageForLevelWindow2, isImageForLevelWindow3;
296  node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1);
297  node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2);
298  node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3);
299 
300  MITK_TEST_CONDITION(isImageForLevelWindow1 && !isImageForLevelWindow2 && !isImageForLevelWindow3,
301  "Testing initial imageForLevelWindow setting.");
302 
303  node1->SetVisibility(false);
304  node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1);
305  node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2);
306  node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3);
307 
308  MITK_TEST_CONDITION(!isImageForLevelWindow1 && isImageForLevelWindow2 && !isImageForLevelWindow3,
309  "Testing exclusive imageForLevelWindow property for node 2.");
310 
311  node2->SetVisibility(false);
312  node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1);
313  node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2);
314  node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3);
315 
316  MITK_TEST_CONDITION(!isImageForLevelWindow1 && !isImageForLevelWindow2 && isImageForLevelWindow3,
317  "Testing exclusive imageForLevelWindow property for node 3.");
318 
319  node3->SetVisibility(false);
320  node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1);
321  node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2);
322  node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3);
323 
324  MITK_TEST_CONDITION(!isImageForLevelWindow1 && !isImageForLevelWindow2 && isImageForLevelWindow3,
325  "Testing exclusive imageForLevelWindow property for node 3.");
326 
327  node1->SetVisibility(true);
328  node1->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow1);
329  node2->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow2);
330  node3->GetBoolProperty("imageForLevelWindow", isImageForLevelWindow3);
331 
332  MITK_TEST_CONDITION(isImageForLevelWindow1 && !isImageForLevelWindow2 && !isImageForLevelWindow3,
333  "Testing exclusive imageForLevelWindow property for node 3.");
334  }
335 
336  static void TestImageForLevelWindowOnRandomPropertyChange(std::string testImageFile)
337  {
338  typedef std::vector<bool> BoolVecType;
339  typedef BoolVecType::iterator IteratorType;
340  typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType;
341 
342  // initialize the data storage
343  mitk::LevelWindowManager::Pointer manager = mitk::LevelWindowManager::New();
344  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
345  manager->SetDataStorage(ds);
346 
347  mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
348  mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
349  mitk::DataNode::Pointer node1 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
350 
351  node3->SetIntProperty("layer", 1);
352  node2->SetIntProperty("layer", 2);
353  node1->SetIntProperty("layer", 3);
354 
355  // node visibilities
356  std::vector<bool> nodesVisible;
357  nodesVisible.resize(3);
358  std::fill(nodesVisible.begin(), nodesVisible.end(), true);
359 
360  // which node has the level window
361  std::vector<bool> nodesForLevelWindow;
362  nodesForLevelWindow.resize(3);
363  std::fill(nodesForLevelWindow.begin(), nodesForLevelWindow.end(), false);
364 
365  // the nodes themselves
366  std::vector<mitk::DataNode::Pointer> nodes;
367  nodes.push_back(node1);
368  nodes.push_back(node2);
369  nodes.push_back(node3);
370 
371  // status quo
372  manager->SetAutoTopMostImage(false);
373 
374  bool lvlWin1, lvlWin2, lvlWin3;
375  node1->GetBoolProperty("imageForLevelWindow", lvlWin1);
376  node2->GetBoolProperty("imageForLevelWindow", lvlWin2);
377  node3->GetBoolProperty("imageForLevelWindow", lvlWin3);
378 
379  MITK_TEST_CONDITION(lvlWin1 && !lvlWin2 && !lvlWin3, "Testing initial imageForLevelWindow setting.");
380 
381  nodesForLevelWindow[0] = lvlWin1;
382  nodesForLevelWindow[1] = lvlWin2;
383  nodesForLevelWindow[2] = lvlWin3;
384 
385  // prepare randomized visibility changes
386  RandomGeneratorType::Pointer ranGen = RandomGeneratorType::New();
387  ranGen->Initialize();
388 
389  int ranCount = 100;
390  int validCount = 0;
391  int invalidCount = 0;
392  int mustHaveLvlWindow = 4;
393  for (int run = 0; run < ranCount; ++run)
394  {
395  // toggle node visibility
396  int ran = ranGen->GetIntegerVariate(2);
397  nodes[ran]->SetBoolProperty("imageForLevelWindow", !nodesForLevelWindow[ran]);
398 
399  // one node must have the level window
400  std::vector<bool>::const_iterator found = std::find(nodesForLevelWindow.begin(), nodesForLevelWindow.end(), true);
401  if (found == nodesForLevelWindow.end())
402  {
403  break;
404  }
405 
406  // all invisible?
407  found = std::find(nodesVisible.begin(), nodesVisible.end(), true);
408 
409  if (!nodesForLevelWindow[ran])
410  {
411  mustHaveLvlWindow = pow(2, 2 - ran);
412  }
413  else
414  {
415  mustHaveLvlWindow = 4;
416  }
417 
418  // get the current status
419  node1->GetBoolProperty("imageForLevelWindow", lvlWin1);
420  node2->GetBoolProperty("imageForLevelWindow", lvlWin2);
421  node3->GetBoolProperty("imageForLevelWindow", lvlWin3);
422  nodesForLevelWindow[0] = lvlWin1;
423  nodesForLevelWindow[1] = lvlWin2;
424  nodesForLevelWindow[2] = lvlWin3;
425 
426  int hasLevelWindow = 0;
427  for (int i = 0; i < 3; ++i)
428  {
429  if (nodesForLevelWindow[i])
430  {
431  hasLevelWindow += pow(2, 2 - i);
432  }
433  }
434 
435  validCount += hasLevelWindow == mustHaveLvlWindow ? 1 : 0;
436 
437  // test sensitivity
438  int falseran = 0;
439  while (falseran == 0)
440  {
441  falseran = ranGen->GetIntegerVariate(7);
442  }
443  BoolVecType falseNodes;
444  falseNodes.push_back(falseran & 1 == 1 ? !lvlWin1 : lvlWin1);
445  falseran >>= 1;
446  falseNodes.push_back(falseran & 1 == 1 ? !lvlWin2 : lvlWin2);
447  falseran >>= 1;
448  falseNodes.push_back(falseran & 1 == 1 ? !lvlWin3 : lvlWin3);
449  int falseLevelWindow = 0;
450  for (int i = 0; i < 3; ++i)
451  {
452  if (falseNodes[i])
453  {
454  falseLevelWindow += pow(2, 2 - i);
455  }
456  }
457 
458  invalidCount += falseLevelWindow == mustHaveLvlWindow ? 0 : 1;
459 
460  // in case of errors proceed anyway
461  mustHaveLvlWindow = hasLevelWindow;
462  }
463 
464  MITK_TEST_CONDITION(validCount == ranCount, "Testing proper node for level window property.");
465  MITK_TEST_CONDITION(invalidCount == ranCount, "Sensitivity test.");
466  }
467 
468  static void TestImageForLevelWindowOnRandomVisibilityChange(std::string testImageFile)
469  {
470  typedef std::vector<bool> BoolVecType;
471  typedef BoolVecType::iterator IteratorType;
472  typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType;
473 
474  // initialize the data storage
475  mitk::LevelWindowManager::Pointer manager = mitk::LevelWindowManager::New();
476  mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
477  manager->SetDataStorage(ds);
478 
479  mitk::DataNode::Pointer node3 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
480  mitk::DataNode::Pointer node2 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
481  mitk::DataNode::Pointer node1 = mitk::IOUtil::Load(testImageFile, *ds)->GetElement(0);
482 
483  node3->SetIntProperty("layer", 1);
484  node2->SetIntProperty("layer", 2);
485  node1->SetIntProperty("layer", 3);
486 
487  // node visibilities
488  std::vector<bool> nodesVisible;
489  nodesVisible.resize(3);
490  std::fill(nodesVisible.begin(), nodesVisible.end(), true);
491 
492  // which node has the level window
493  std::vector<bool> nodesForLevelWindow;
494  nodesForLevelWindow.resize(3);
495  std::fill(nodesForLevelWindow.begin(), nodesForLevelWindow.end(), false);
496 
497  // the nodes themselves
498  std::vector<mitk::DataNode::Pointer> nodes;
499  nodes.push_back(node1);
500  nodes.push_back(node2);
501  nodes.push_back(node3);
502 
503  // status quo
504  manager->SetAutoTopMostImage(false);
505 
506  bool lvlWin1, lvlWin2, lvlWin3;
507  node1->GetBoolProperty("imageForLevelWindow", lvlWin1);
508  node2->GetBoolProperty("imageForLevelWindow", lvlWin2);
509  node3->GetBoolProperty("imageForLevelWindow", lvlWin3);
510 
511  MITK_TEST_CONDITION(lvlWin1 && !lvlWin2 && !lvlWin3, "Testing initial imageForLevelWindow setting.");
512 
513  nodesForLevelWindow[0] = lvlWin1;
514  nodesForLevelWindow[1] = lvlWin2;
515  nodesForLevelWindow[2] = lvlWin3;
516 
517  // prepare randomized visibility changes
518  RandomGeneratorType::Pointer ranGen = RandomGeneratorType::New();
519  ranGen->Initialize();
520 
521  int ranCount = 100;
522  int validCount = 0;
523  int invalidCount = 0;
524  int mustHaveLvlWindow = 4;
525  for (int run = 0; run < ranCount; ++run)
526  {
527  // toggle node visibility
528  int ran = ranGen->GetIntegerVariate(2);
529  nodesVisible[ran] = !nodesVisible[ran];
530  nodes[ran]->SetVisibility(nodesVisible[ran]);
531 
532  // one node must have the level window
533  std::vector<bool>::const_iterator found = std::find(nodesForLevelWindow.begin(), nodesForLevelWindow.end(), true);
534  if (found == nodesForLevelWindow.end())
535  {
536  break;
537  }
538  int ind = found - nodesForLevelWindow.begin();
539 
540  // all invisible?
541  found = std::find(nodesVisible.begin(), nodesVisible.end(), true);
542  bool allInvisible = (found == nodesVisible.end());
543 
544  // which node shall get the level window now
545  if (!allInvisible && !nodesVisible[ind])
546  {
547  int count = 0;
548  for (std::vector<bool>::const_iterator it = nodesVisible.begin(); it != nodesVisible.end(); ++it, ++count)
549  {
550  if (*it)
551  {
552  mustHaveLvlWindow = pow(2, 2 - count);
553  break;
554  }
555  }
556  }
557 
558  // get the current status
559  node1->GetBoolProperty("imageForLevelWindow", lvlWin1);
560  node2->GetBoolProperty("imageForLevelWindow", lvlWin2);
561  node3->GetBoolProperty("imageForLevelWindow", lvlWin3);
562  nodesForLevelWindow[0] = lvlWin1;
563  nodesForLevelWindow[1] = lvlWin2;
564  nodesForLevelWindow[2] = lvlWin3;
565 
566  int hasLevelWindow = 0;
567  for (int i = 0; i < 3; ++i)
568  {
569  if (nodesForLevelWindow[i])
570  {
571  hasLevelWindow += pow(2, 2 - i);
572  }
573  }
574 
575  if (hasLevelWindow != mustHaveLvlWindow)
576  {
577  int n = 5;
578  }
579 
580  validCount += hasLevelWindow == mustHaveLvlWindow ? 1 : 0;
581 
582  // test sensitivity
583  int falseran = 0;
584  while (falseran == 0)
585  {
586  falseran = ranGen->GetIntegerVariate(7);
587  }
588  BoolVecType falseNodes;
589  falseNodes.push_back(falseran & 1 == 1 ? !lvlWin1 : lvlWin1);
590  falseran >>= 1;
591  falseNodes.push_back(falseran & 1 == 1 ? !lvlWin2 : lvlWin2);
592  falseran >>= 1;
593  falseNodes.push_back(falseran & 1 == 1 ? !lvlWin3 : lvlWin3);
594  int falseLevelWindow = 0;
595  for (int i = 0; i < 3; ++i)
596  {
597  if (falseNodes[i])
598  {
599  falseLevelWindow += pow(2, 2 - i);
600  }
601  }
602 
603  invalidCount += falseLevelWindow == mustHaveLvlWindow ? 0 : 1;
604 
605  // in case of errors proceed anyway
606  mustHaveLvlWindow = hasLevelWindow;
607  }
608 
609  MITK_TEST_CONDITION(validCount == ranCount, "Testing proper node for level window property.");
610  MITK_TEST_CONDITION(invalidCount == ranCount, "Sensitivity test.");
611  }
612 };
613 
614 int mitkLevelWindowManagerTest(int argc, char *args[])
615 {
616  MITK_TEST_BEGIN("mitkLevelWindowManager");
617 
618  MITK_TEST_CONDITION_REQUIRED(argc >= 2, "Testing if test file is given.");
619  std::string testImage = args[1];
620 
621  mitkLevelWindowManagerTestClass::TestInstantiation();
622  mitkLevelWindowManagerTestClass::TestSetGetDataStorage();
623  mitkLevelWindowManagerTestClass::TestMethodsWithInvalidParameters();
624  mitkLevelWindowManagerTestClass::TestOtherMethods();
625  mitkLevelWindowManagerTestClass::TestRemoveObserver(testImage);
626  mitkLevelWindowManagerTestClass::TestLevelWindowSliderVisibility(testImage);
627  mitkLevelWindowManagerTestClass::TestSetLevelWindowProperty(testImage);
628  mitkLevelWindowManagerTestClass::TestImageForLevelWindowOnVisibilityChange(testImage);
629  mitkLevelWindowManagerTestClass::TestImageForLevelWindowOnRandomVisibilityChange(testImage);
630  mitkLevelWindowManagerTestClass::TestImageForLevelWindowOnRandomPropertyChange(testImage);
631 
632  MITK_TEST_END();
633 }
mitk::Pointer
itk::SmartPointer< Self > Pointer
Definition: mitkRenderingManager.h:389
mitk::LevelWindowProperty
The LevelWindowProperty class Property for the mitk::LevelWindow.
Definition: mitkLevelWindowProperty.h:41
mitk::LevelWindowProperty::New
static Pointer New()
MITK_ERROR
#define MITK_ERROR
Definition: mitkLogMacros.h:24
MITK_TEST_CONDITION_REQUIRED
#define MITK_TEST_CONDITION_REQUIRED(COND, MSG)
Definition: mitkTestingMacros.h:135
MITK_TEST_BEGIN
section GeneralTestsDeprecatedOldTestingStyle Deprecated macros All tests with MITK_TEST_BEGIN()
MITK_TEST_OUTPUT
#define MITK_TEST_OUTPUT(x)
Output some text.
Definition: mitkTestingMacros.h:54
mitk::DataNode::New
static Pointer New()
mitk::Exception
An object of this class represents an exception of MITK. Please don't instantiate exceptions manually...
Definition: mitkException.h:49
MITK_TEST_CONDITION
#define MITK_TEST_CONDITION(COND, MSG)
Definition: mitkTestingMacros.h:114
mitkLevelWindowManagerTest
int mitkLevelWindowManagerTest(int argc, char *args[])
Definition: mitkLevelWindowManagerTest.cpp:614
mitk::IOUtil::Load
static DataStorage::SetOfObjects::Pointer Load(const std::string &path, DataStorage &storage)
Load a file into the given DataStorage.
Definition: mitkIOUtil.cpp:483
MITK_TEST_END
and MITK_TEST_END()
mitk::LevelWindowManager::New
static Pointer New()
mitk::IOUtil::LoadImage
static mitk::Image::Pointer LoadImage(const std::string &path)
LoadImage Convenience method to load an arbitrary mitkImage.
Definition: mitkIOUtil.cpp:597
mitk::New
static itkEventMacro(BoundingShapeInteractionEvent, itk::AnyEvent) class MITKBOUNDINGSHAPE_EXPORT BoundingShapeInteractor Pointer New()
Basic interaction methods for mitk::GeometryData.