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
QmitkStdMultiWidget.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 #define SMW_INFO MITK_INFO("widget.stdmulti")
18 
19 #include "QmitkStdMultiWidget.h"
20 
21 #include <QGridLayout>
22 #include <QHBoxLayout>
23 #include <QList>
24 #include <QMouseEvent>
25 #include <QTimer>
26 #include <QVBoxLayout>
27 #include <qsplitter.h>
28 
29 #include "mitkImagePixelReadAccessor.h"
30 #include "mitkPixelTypeMultiplex.h"
31 #include <mitkCameraController.h>
32 #include <mitkDataStorage.h>
33 #include <mitkImage.h>
34 #include <mitkInteractionConst.h>
35 #include <mitkLine.h>
36 #include <mitkNodePredicateBase.h>
37 #include <mitkNodePredicateDataType.h>
38 #include <mitkNodePredicateNot.h>
39 #include <mitkNodePredicateProperty.h>
40 #include <mitkOverlayManager.h>
41 #include <mitkPlaneGeometryDataMapper2D.h>
42 #include <mitkPointSet.h>
43 #include <mitkProperties.h>
44 #include <mitkStatusBar.h>
45 #include <mitkVtkLayerController.h>
46 #include <vtkCornerAnnotation.h>
47 #include <vtkMitkRectangleProp.h>
48 #include <vtkTextProperty.h>
49 
50 #include <iomanip>
51 
52 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
53  Qt::WindowFlags f,
54  mitk::RenderingManager *renderingManager,
55  mitk::BaseRenderer::RenderingMode::Type renderingMode,
56  const QString &name)
57  : QWidget(parent, f),
58  mitkWidget1(NULL),
59  mitkWidget2(NULL),
60  mitkWidget3(NULL),
61  mitkWidget4(NULL),
62  levelWindowWidget(NULL),
63  QmitkStdMultiWidgetLayout(NULL),
64  m_Layout(LAYOUT_DEFAULT),
65  m_PlaneMode(PLANE_MODE_SLICING),
66  m_RenderingManager(renderingManager),
67  m_GradientBackgroundFlag(true),
68  m_TimeNavigationController(NULL),
69  m_MainSplit(NULL),
70  m_LayoutSplit(NULL),
71  m_SubSplit1(NULL),
72  m_SubSplit2(NULL),
73  mitkWidget1Container(NULL),
74  mitkWidget2Container(NULL),
75  mitkWidget3Container(NULL),
76  mitkWidget4Container(NULL),
77  m_PendingCrosshairPositionEvent(false),
78  m_CrosshairNavigationEnabled(false)
79 {
80  /******************************************************
81  * Use the global RenderingManager if none was specified
82  * ****************************************************/
83  if (m_RenderingManager == NULL)
84  {
85  m_RenderingManager = mitk::RenderingManager::GetInstance();
86  }
87  m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
88 
89  /*******************************/
90  // Create Widget manually
91  /*******************************/
92 
93  // create Layouts
94  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
95  QmitkStdMultiWidgetLayout->setContentsMargins(0, 0, 0, 0);
96 
97  // Set Layout to widget
98  this->setLayout(QmitkStdMultiWidgetLayout);
99 
100  // create main splitter
101  m_MainSplit = new QSplitter(this);
102  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
103 
104  // create m_LayoutSplit and add to the mainSplit
105  m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
106  m_MainSplit->addWidget(m_LayoutSplit);
107 
108  // create m_SubSplit1 and m_SubSplit2
109  m_SubSplit1 = new QSplitter(m_LayoutSplit);
110  m_SubSplit2 = new QSplitter(m_LayoutSplit);
111 
112  // creae Widget Container
113  mitkWidget1Container = new QWidget(m_SubSplit1);
114  mitkWidget2Container = new QWidget(m_SubSplit1);
115  mitkWidget3Container = new QWidget(m_SubSplit2);
116  mitkWidget4Container = new QWidget(m_SubSplit2);
117 
118  mitkWidget1Container->setContentsMargins(0, 0, 0, 0);
119  mitkWidget2Container->setContentsMargins(0, 0, 0, 0);
120  mitkWidget3Container->setContentsMargins(0, 0, 0, 0);
121  mitkWidget4Container->setContentsMargins(0, 0, 0, 0);
122 
123  // create Widget Layout
124  QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container);
125  QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container);
126  QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container);
127  QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container);
128 
129  m_CornerAnnotations[0] = vtkSmartPointer<vtkCornerAnnotation>::New();
130  m_CornerAnnotations[1] = vtkSmartPointer<vtkCornerAnnotation>::New();
131  m_CornerAnnotations[2] = vtkSmartPointer<vtkCornerAnnotation>::New();
132  m_CornerAnnotations[3] = vtkSmartPointer<vtkCornerAnnotation>::New();
133 
134  m_RectangleProps[0] = vtkSmartPointer<vtkMitkRectangleProp>::New();
135  m_RectangleProps[1] = vtkSmartPointer<vtkMitkRectangleProp>::New();
136  m_RectangleProps[2] = vtkSmartPointer<vtkMitkRectangleProp>::New();
137  m_RectangleProps[3] = vtkSmartPointer<vtkMitkRectangleProp>::New();
138 
139  mitkWidgetLayout1->setMargin(0);
140  mitkWidgetLayout2->setMargin(0);
141  mitkWidgetLayout3->setMargin(0);
142  mitkWidgetLayout4->setMargin(0);
143 
144  // set Layout to Widget Container
145  mitkWidget1Container->setLayout(mitkWidgetLayout1);
146  mitkWidget2Container->setLayout(mitkWidgetLayout2);
147  mitkWidget3Container->setLayout(mitkWidgetLayout3);
148  mitkWidget4Container->setLayout(mitkWidgetLayout4);
149 
150  // set SizePolicy
151  mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
152  mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
153  mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
154  mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
155 
156  // insert Widget Container into the splitters
157  m_SubSplit1->addWidget(mitkWidget1Container);
158  m_SubSplit1->addWidget(mitkWidget2Container);
159 
160  m_SubSplit2->addWidget(mitkWidget3Container);
161  m_SubSplit2->addWidget(mitkWidget4Container);
162 
163  // Create RenderWindows 1
164  mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, name + ".widget1", NULL, m_RenderingManager, renderingMode);
165  mitkWidget1->SetLayoutIndex(AXIAL);
166  mitkWidgetLayout1->addWidget(mitkWidget1);
167 
168  // Create RenderWindows 2
169  mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, name + ".widget2", NULL, m_RenderingManager, renderingMode);
170  mitkWidget2->setEnabled(true);
171  mitkWidget2->SetLayoutIndex(SAGITTAL);
172  mitkWidgetLayout2->addWidget(mitkWidget2);
173 
174  // Create RenderWindows 3
175  mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, name + ".widget3", NULL, m_RenderingManager, renderingMode);
176  mitkWidget3->SetLayoutIndex(CORONAL);
177  mitkWidgetLayout3->addWidget(mitkWidget3);
178 
179  // Create RenderWindows 4
180  mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, name + ".widget4", NULL, m_RenderingManager, renderingMode);
181  mitkWidget4->SetLayoutIndex(THREE_D);
182  mitkWidgetLayout4->addWidget(mitkWidget4);
183 
184  // create SignalSlot Connection
185  connect(mitkWidget1, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
186  connect(mitkWidget1, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
187  connect(mitkWidget1, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
188  connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int)));
189 
190  connect(mitkWidget2, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
191  connect(mitkWidget2, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
192  connect(mitkWidget2, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
193  connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int)));
194 
195  connect(mitkWidget3, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
196  connect(mitkWidget3, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
197  connect(mitkWidget3, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
198  connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int)));
199 
200  connect(mitkWidget4, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
201  connect(mitkWidget4, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
202  connect(mitkWidget4, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
203  connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int)));
204 
205  // Create Level Window Widget
206  levelWindowWidget = new QmitkLevelWindowWidget(m_MainSplit); // this
207  levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
208  QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
209  sizePolicy.setHorizontalStretch(0);
210  sizePolicy.setVerticalStretch(0);
211  sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth());
212  levelWindowWidget->setSizePolicy(sizePolicy);
213  levelWindowWidget->setMaximumWidth(50);
214 
215  // add LevelWindow Widget to mainSplitter
216  m_MainSplit->addWidget(levelWindowWidget);
217 
218  // show mainSplitt and add to Layout
219  m_MainSplit->show();
220 
221  // resize Image.
222  this->resize(QSize(364, 477).expandedTo(minimumSizeHint()));
223 
224  // Initialize the widgets.
225  this->InitializeWidget();
226 
227  // Activate Widget Menu
228  this->ActivateMenuWidget(true);
229 }
230 
231 void QmitkStdMultiWidget::InitializeWidget()
232 {
233  // Make all black and overwrite renderwindow 4
234  this->FillGradientBackgroundWithBlack();
235  // This is #191919 in hex
236  float tmp1[3] = {0.098f, 0.098f, 0.098f};
237  // This is #7F7F7F in hex
238  float tmp2[3] = {0.498f, 0.498f, 0.498f};
239  m_GradientBackgroundColors[3] = std::make_pair(mitk::Color(tmp1), mitk::Color(tmp2));
240 
241  // Yellow is default color for widget4
242  m_DecorationColorWidget4[0] = 1.0f;
243  m_DecorationColorWidget4[1] = 1.0f;
244  m_DecorationColorWidget4[2] = 0.0f;
245 
246  // transfer colors in WorldGeometry-Nodes of the associated Renderer
247  mitk::IntProperty::Pointer layer;
248  // of widget 1
249  m_PlaneNode1 = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
250  m_PlaneNode1->SetColor(GetDecorationColor(0));
251  layer = mitk::IntProperty::New(1000);
252  m_PlaneNode1->SetProperty("layer", layer);
253 
254  // ... of widget 2
255  m_PlaneNode2 = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
256  m_PlaneNode2->SetColor(GetDecorationColor(1));
257  layer = mitk::IntProperty::New(1000);
258  m_PlaneNode2->SetProperty("layer", layer);
259 
260  // ... of widget 3
261  m_PlaneNode3 = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
262  m_PlaneNode3->SetColor(GetDecorationColor(2));
263  layer = mitk::IntProperty::New(1000);
264  m_PlaneNode3->SetProperty("layer", layer);
265 
266  // The parent node
267  m_ParentNodeForGeometryPlanes =
268  mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
269  layer = mitk::IntProperty::New(1000);
270  m_ParentNodeForGeometryPlanes->SetProperty("layer", layer);
271 
272  mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New();
273  mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetOverlayManager(OverlayManager);
274  mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetOverlayManager(OverlayManager);
275  mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetOverlayManager(OverlayManager);
276  mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetOverlayManager(OverlayManager);
277 
278  mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
279  // Set plane mode (slicing/rotation behavior) to slicing (default)
280  m_PlaneMode = PLANE_MODE_SLICING;
281 
282  // Set default view directions for SNCs
283  mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
284  mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
285  mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
286  mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
287 
288  SetDecorationProperties("Axial", GetDecorationColor(0), 0);
289  SetDecorationProperties("Sagittal", GetDecorationColor(1), 1);
290  SetDecorationProperties("Coronal", GetDecorationColor(2), 2);
291  SetDecorationProperties("3D", GetDecorationColor(3), 3);
292 
293  // connect to the "time navigation controller": send time via sliceNavigationControllers
294  m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget1->GetSliceNavigationController(), false);
295  m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget2->GetSliceNavigationController(), false);
296  m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget3->GetSliceNavigationController(), false);
297  m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget4->GetSliceNavigationController(), false);
298  mitkWidget1->GetSliceNavigationController()->ConnectGeometrySendEvent(
299  mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
300 
301  // reverse connection between sliceNavigationControllers and m_TimeNavigationController
302  mitkWidget1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
303  mitkWidget2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
304  mitkWidget3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
305  // mitkWidget4->GetSliceNavigationController()
306  // ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
307 
308  m_MouseModeSwitcher = mitk::MouseModeSwitcher::New();
309 
310  // setup the department logo rendering
311  m_LogoRendering = mitk::LogoOverlay::New();
312  mitk::BaseRenderer::Pointer renderer4 = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
313  m_LogoRendering->SetOpacity(0.5);
314  mitk::Point2D offset;
315  offset.Fill(0.03);
316  m_LogoRendering->SetOffsetVector(offset);
317  m_LogoRendering->SetRelativeSize(0.15);
318  m_LogoRendering->SetCornerPosition(1);
319  m_LogoRendering->SetLogoImagePath("DefaultLogo");
320  renderer4->GetOverlayManager()->AddOverlay(m_LogoRendering.GetPointer(), renderer4);
321 }
322 
323 void QmitkStdMultiWidget::FillGradientBackgroundWithBlack()
324 {
325  // We have 4 widgets and ...
326  for (unsigned int i = 0; i < 4; ++i)
327  {
328  float black[3] = {0.0f, 0.0f, 0.0f};
329  m_GradientBackgroundColors[i] = std::make_pair(mitk::Color(black), mitk::Color(black));
330  }
331 }
332 
333 std::pair<mitk::Color, mitk::Color> QmitkStdMultiWidget::GetGradientColors(unsigned int widgetNumber)
334 {
335  if (widgetNumber > 3)
336  {
337  MITK_ERROR << "Decoration color for unknown widget!";
338  float black[3] = {0.0f, 0.0f, 0.0f};
339  return std::make_pair(mitk::Color(black), mitk::Color(black));
340  }
341  return m_GradientBackgroundColors[widgetNumber];
342 }
343 
344 mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
345 {
346  // The implementation looks a bit messy here, but it avoids
347  // synchronization of the color of the geometry nodes and an
348  // internal member here.
349  // Default colors were chosen for decent visibitliy.
350  // Feel free to change your preferences in the workbench.
351  float tmp[3] = {0.0f, 0.0f, 0.0f};
352  switch (widgetNumber)
353  {
354  case 0:
355  {
356  if (m_PlaneNode1.IsNotNull())
357  {
358  if (m_PlaneNode1->GetColor(tmp))
359  {
360  return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
361  }
362  }
363  float red[3] = {0.753f, 0.0f, 0.0f}; // This is #C00000 in hex
364  return mitk::Color(red);
365  }
366  case 1:
367  {
368  if (m_PlaneNode2.IsNotNull())
369  {
370  if (m_PlaneNode2->GetColor(tmp))
371  {
372  return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
373  }
374  }
375  float green[3] = {0.0f, 0.69f, 0.0f}; // This is #00B000 in hex
376  return mitk::Color(green);
377  }
378  case 2:
379  {
380  if (m_PlaneNode3.IsNotNull())
381  {
382  if (m_PlaneNode3->GetColor(tmp))
383  {
384  return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
385  }
386  }
387  float blue[3] = {0.0, 0.502f, 1.0f}; // This is #0080FF in hex
388  return mitk::Color(blue);
389  }
390  case 3:
391  {
392  return m_DecorationColorWidget4;
393  }
394  default:
395  MITK_ERROR << "Decoration color for unknown widget!";
396  float black[3] = {0.0f, 0.0f, 0.0f};
397  return mitk::Color(black);
398  }
399 }
400 
401 std::string QmitkStdMultiWidget::GetCornerAnnotationText(unsigned int widgetNumber)
402 {
403  if (widgetNumber > 3)
404  {
405  MITK_ERROR << "Decoration color for unknown widget!";
406  return std::string("");
407  }
408  return std::string(m_CornerAnnotations[widgetNumber]->GetText(0));
409 }
410 
411 QmitkStdMultiWidget::~QmitkStdMultiWidget()
412 {
413  DisablePositionTracking();
414  // DisableNavigationControllerEventListening();
415 
416  m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController());
417  m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController());
418  m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController());
419  m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController());
420 }
421 
422 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
423 {
424  if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() &&
425  m_ParentNodeForGeometryPlanes.IsNotNull())
426  {
427  if (m_DataStorage.IsNotNull())
428  {
429  m_DataStorage->Remove(m_PlaneNode1);
430  m_DataStorage->Remove(m_PlaneNode2);
431  m_DataStorage->Remove(m_PlaneNode3);
432  m_DataStorage->Remove(m_ParentNodeForGeometryPlanes);
433  }
434  }
435 }
436 
437 void QmitkStdMultiWidget::AddPlanesToDataStorage()
438 {
439  if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() &&
440  m_ParentNodeForGeometryPlanes.IsNotNull())
441  {
442  if (m_DataStorage.IsNotNull())
443  {
444  m_DataStorage->Add(m_ParentNodeForGeometryPlanes);
445  m_DataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
446  m_DataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
447  m_DataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
448  }
449  }
450 }
451 
452 void QmitkStdMultiWidget::changeLayoutTo2DImagesUp()
453 {
454  SMW_INFO << "changing layout to 2D images up... " << std::endl;
455 
456  // Hide all Menu Widgets
457  this->HideAllWidgetToolbars();
458 
459  delete QmitkStdMultiWidgetLayout;
460 
461  // create Main Layout
462  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
463 
464  // Set Layout to widget
465  this->setLayout(QmitkStdMultiWidgetLayout);
466 
467  // create main splitter
468  m_MainSplit = new QSplitter(this);
469  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
470 
471  // create m_LayoutSplit and add to the mainSplit
472  m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
473  m_MainSplit->addWidget(m_LayoutSplit);
474 
475  // add LevelWindow Widget to mainSplitter
476  m_MainSplit->addWidget(levelWindowWidget);
477 
478  // create m_SubSplit1 and m_SubSplit2
479  m_SubSplit1 = new QSplitter(m_LayoutSplit);
480  m_SubSplit2 = new QSplitter(m_LayoutSplit);
481 
482  // insert Widget Container into splitter top
483  m_SubSplit1->addWidget(mitkWidget1Container);
484  m_SubSplit1->addWidget(mitkWidget2Container);
485  m_SubSplit1->addWidget(mitkWidget3Container);
486 
487  // set SplitterSize for splitter top
488  QList<int> splitterSize;
489  splitterSize.push_back(1000);
490  splitterSize.push_back(1000);
491  splitterSize.push_back(1000);
492  m_SubSplit1->setSizes(splitterSize);
493 
494  // insert Widget Container into splitter bottom
495  m_SubSplit2->addWidget(mitkWidget4Container);
496 
497  // set SplitterSize for splitter m_LayoutSplit
498  splitterSize.clear();
499  splitterSize.push_back(400);
500  splitterSize.push_back(1000);
501  m_LayoutSplit->setSizes(splitterSize);
502 
503  // show mainSplitt
504  m_MainSplit->show();
505 
506  // show Widget if hidden
507  if (mitkWidget1->isHidden())
508  mitkWidget1->show();
509  if (mitkWidget2->isHidden())
510  mitkWidget2->show();
511  if (mitkWidget3->isHidden())
512  mitkWidget3->show();
513  if (mitkWidget4->isHidden())
514  mitkWidget4->show();
515 
516  // Change Layout Name
517  m_Layout = LAYOUT_2D_IMAGES_UP;
518 
519  // update Layout Design List
520  mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
521  mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
522  mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
523  mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
524 
525  // update Alle Widgets
526  this->UpdateAllWidgets();
527 }
528 
529 void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft()
530 {
531  SMW_INFO << "changing layout to 2D images left... " << std::endl;
532 
533  // Hide all Menu Widgets
534  this->HideAllWidgetToolbars();
535 
536  delete QmitkStdMultiWidgetLayout;
537 
538  // create Main Layout
539  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
540 
541  // create main splitter
542  m_MainSplit = new QSplitter(this);
543  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
544 
545  // create m_LayoutSplit and add to the mainSplit
546  m_LayoutSplit = new QSplitter(m_MainSplit);
547  m_MainSplit->addWidget(m_LayoutSplit);
548 
549  // add LevelWindow Widget to mainSplitter
550  m_MainSplit->addWidget(levelWindowWidget);
551 
552  // create m_SubSplit1 and m_SubSplit2
553  m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
554  m_SubSplit2 = new QSplitter(m_LayoutSplit);
555 
556  // insert Widget into the splitters
557  m_SubSplit1->addWidget(mitkWidget1Container);
558  m_SubSplit1->addWidget(mitkWidget2Container);
559  m_SubSplit1->addWidget(mitkWidget3Container);
560 
561  // set splitterSize of SubSplit1
562  QList<int> splitterSize;
563  splitterSize.push_back(1000);
564  splitterSize.push_back(1000);
565  splitterSize.push_back(1000);
566  m_SubSplit1->setSizes(splitterSize);
567 
568  m_SubSplit2->addWidget(mitkWidget4Container);
569 
570  // set splitterSize of Layout Split
571  splitterSize.clear();
572  splitterSize.push_back(400);
573  splitterSize.push_back(1000);
574  m_LayoutSplit->setSizes(splitterSize);
575 
576  // show mainSplitt and add to Layout
577  m_MainSplit->show();
578 
579  // show Widget if hidden
580  if (mitkWidget1->isHidden())
581  mitkWidget1->show();
582  if (mitkWidget2->isHidden())
583  mitkWidget2->show();
584  if (mitkWidget3->isHidden())
585  mitkWidget3->show();
586  if (mitkWidget4->isHidden())
587  mitkWidget4->show();
588 
589  // update Layout Name
590  m_Layout = LAYOUT_2D_IMAGES_LEFT;
591 
592  // update Layout Design List
593  mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
594  mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
595  mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
596  mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
597 
598  // update Alle Widgets
599  this->UpdateAllWidgets();
600 }
601 
602 void QmitkStdMultiWidget::SetDecorationProperties(std::string text, mitk::Color color, int widgetNumber)
603 {
604  if (widgetNumber > 3)
605  {
606  MITK_ERROR << "Unknown render window for annotation.";
607  return;
608  }
609  vtkRenderer *renderer = this->GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer();
610  if (!renderer)
611  return;
612  vtkSmartPointer<vtkCornerAnnotation> annotation = m_CornerAnnotations[widgetNumber];
613  annotation->SetText(0, text.c_str());
614  annotation->SetMaximumFontSize(12);
615  annotation->GetTextProperty()->SetColor(color[0], color[1], color[2]);
616  if (!renderer->HasViewProp(annotation))
617  {
618  renderer->AddViewProp(annotation);
619  }
620  vtkSmartPointer<vtkMitkRectangleProp> frame = m_RectangleProps[widgetNumber];
621  frame->SetColor(color[0], color[1], color[2]);
622  if (!renderer->HasViewProp(frame))
623  {
624  renderer->AddViewProp(frame);
625  }
626 }
627 
628 void QmitkStdMultiWidget::SetCornerAnnotationVisibility(bool visibility)
629 {
630  for (int i = 0; i < 4; ++i)
631  {
632  m_CornerAnnotations[i]->SetVisibility(visibility);
633  }
634 }
635 
636 bool QmitkStdMultiWidget::IsCornerAnnotationVisible(void) const
637 {
638  return m_CornerAnnotations[0]->GetVisibility() > 0;
639 }
640 
641 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow(unsigned int number)
642 {
643  switch (number)
644  {
645  case 0:
646  return this->GetRenderWindow1();
647  case 1:
648  return this->GetRenderWindow2();
649  case 2:
650  return this->GetRenderWindow3();
651  case 3:
652  return this->GetRenderWindow4();
653  default:
654  MITK_ERROR << "Requested unknown render window";
655  break;
656  }
657  return NULL;
658 }
659 
660 void QmitkStdMultiWidget::changeLayoutToDefault()
661 {
662  SMW_INFO << "changing layout to default... " << std::endl;
663 
664  // Hide all Menu Widgets
665  this->HideAllWidgetToolbars();
666 
667  delete QmitkStdMultiWidgetLayout;
668 
669  // create Main Layout
670  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
671 
672  // create main splitter
673  m_MainSplit = new QSplitter(this);
674  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
675 
676  // create m_LayoutSplit and add to the mainSplit
677  m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
678  m_MainSplit->addWidget(m_LayoutSplit);
679 
680  // add LevelWindow Widget to mainSplitter
681  m_MainSplit->addWidget(levelWindowWidget);
682 
683  // create m_SubSplit1 and m_SubSplit2
684  m_SubSplit1 = new QSplitter(m_LayoutSplit);
685  m_SubSplit2 = new QSplitter(m_LayoutSplit);
686 
687  // insert Widget container into the splitters
688  m_SubSplit1->addWidget(mitkWidget1Container);
689  m_SubSplit1->addWidget(mitkWidget2Container);
690 
691  m_SubSplit2->addWidget(mitkWidget3Container);
692  m_SubSplit2->addWidget(mitkWidget4Container);
693 
694  // set splitter Size
695  QList<int> splitterSize;
696  splitterSize.push_back(1000);
697  splitterSize.push_back(1000);
698  m_SubSplit1->setSizes(splitterSize);
699  m_SubSplit2->setSizes(splitterSize);
700  m_LayoutSplit->setSizes(splitterSize);
701 
702  // show mainSplitt and add to Layout
703  m_MainSplit->show();
704 
705  // show Widget if hidden
706  if (mitkWidget1->isHidden())
707  mitkWidget1->show();
708  if (mitkWidget2->isHidden())
709  mitkWidget2->show();
710  if (mitkWidget3->isHidden())
711  mitkWidget3->show();
712  if (mitkWidget4->isHidden())
713  mitkWidget4->show();
714 
715  m_Layout = LAYOUT_DEFAULT;
716 
717  // update Layout Design List
718  mitkWidget1->LayoutDesignListChanged(LAYOUT_DEFAULT);
719  mitkWidget2->LayoutDesignListChanged(LAYOUT_DEFAULT);
720  mitkWidget3->LayoutDesignListChanged(LAYOUT_DEFAULT);
721  mitkWidget4->LayoutDesignListChanged(LAYOUT_DEFAULT);
722 
723  // update Alle Widgets
724  this->UpdateAllWidgets();
725 }
726 
727 void QmitkStdMultiWidget::changeLayoutToBig3D()
728 {
729  SMW_INFO << "changing layout to big 3D ..." << std::endl;
730 
731  // Hide all Menu Widgets
732  this->HideAllWidgetToolbars();
733 
734  delete QmitkStdMultiWidgetLayout;
735 
736  // create Main Layout
737  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
738 
739  // create main splitter
740  m_MainSplit = new QSplitter(this);
741  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
742 
743  // add widget Splitter to main Splitter
744  m_MainSplit->addWidget(mitkWidget4Container);
745 
746  // add LevelWindow Widget to mainSplitter
747  m_MainSplit->addWidget(levelWindowWidget);
748 
749  // show mainSplitt and add to Layout
750  m_MainSplit->show();
751 
752  // show/hide Widgets
753  mitkWidget1->hide();
754  mitkWidget2->hide();
755  mitkWidget3->hide();
756  if (mitkWidget4->isHidden())
757  mitkWidget4->show();
758 
759  m_Layout = LAYOUT_BIG_3D;
760 
761  // update Layout Design List
762  mitkWidget1->LayoutDesignListChanged(LAYOUT_BIG_3D);
763  mitkWidget2->LayoutDesignListChanged(LAYOUT_BIG_3D);
764  mitkWidget3->LayoutDesignListChanged(LAYOUT_BIG_3D);
765  mitkWidget4->LayoutDesignListChanged(LAYOUT_BIG_3D);
766 
767  // update Alle Widgets
768  this->UpdateAllWidgets();
769  mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget4->GetVtkRenderWindow());
770 }
771 
772 void QmitkStdMultiWidget::changeLayoutToWidget1()
773 {
774  SMW_INFO << "changing layout to big Widget1 ..." << std::endl;
775 
776  // Hide all Menu Widgets
777  this->HideAllWidgetToolbars();
778 
779  delete QmitkStdMultiWidgetLayout;
780 
781  // create Main Layout
782  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
783 
784  // create main splitter
785  m_MainSplit = new QSplitter(this);
786  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
787 
788  // add widget Splitter to main Splitter
789  m_MainSplit->addWidget(mitkWidget1Container);
790 
791  // add LevelWindow Widget to mainSplitter
792  m_MainSplit->addWidget(levelWindowWidget);
793 
794  // show mainSplitt and add to Layout
795  m_MainSplit->show();
796 
797  // show/hide Widgets
798  if (mitkWidget1->isHidden())
799  mitkWidget1->show();
800  mitkWidget2->hide();
801  mitkWidget3->hide();
802  mitkWidget4->hide();
803 
804  m_Layout = LAYOUT_WIDGET1;
805 
806  // update Layout Design List
807  mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET1);
808  mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET1);
809  mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET1);
810  mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET1);
811 
812  // update Alle Widgets
813  this->UpdateAllWidgets();
814 
815  mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget1->GetVtkRenderWindow());
816 }
817 
818 void QmitkStdMultiWidget::changeLayoutToWidget2()
819 {
820  SMW_INFO << "changing layout to big Widget2 ..." << std::endl;
821 
822  // Hide all Menu Widgets
823  this->HideAllWidgetToolbars();
824 
825  delete QmitkStdMultiWidgetLayout;
826 
827  // create Main Layout
828  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
829 
830  // create main splitter
831  m_MainSplit = new QSplitter(this);
832  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
833 
834  // add widget Splitter to main Splitter
835  m_MainSplit->addWidget(mitkWidget2Container);
836 
837  // add LevelWindow Widget to mainSplitter
838  m_MainSplit->addWidget(levelWindowWidget);
839 
840  // show mainSplitt and add to Layout
841  m_MainSplit->show();
842 
843  // show/hide Widgets
844  mitkWidget1->hide();
845  if (mitkWidget2->isHidden())
846  mitkWidget2->show();
847  mitkWidget3->hide();
848  mitkWidget4->hide();
849 
850  m_Layout = LAYOUT_WIDGET2;
851 
852  // update Layout Design List
853  mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET2);
854  mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET2);
855  mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET2);
856  mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET2);
857 
858  // update Alle Widgets
859  this->UpdateAllWidgets();
860  mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget2->GetVtkRenderWindow());
861 }
862 
863 void QmitkStdMultiWidget::changeLayoutToWidget3()
864 {
865  SMW_INFO << "changing layout to big Widget3 ..." << std::endl;
866 
867  // Hide all Menu Widgets
868  this->HideAllWidgetToolbars();
869 
870  delete QmitkStdMultiWidgetLayout;
871 
872  // create Main Layout
873  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
874 
875  // create main splitter
876  m_MainSplit = new QSplitter(this);
877  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
878 
879  // add widget Splitter to main Splitter
880  m_MainSplit->addWidget(mitkWidget3Container);
881 
882  // add LevelWindow Widget to mainSplitter
883  m_MainSplit->addWidget(levelWindowWidget);
884 
885  // show mainSplitt and add to Layout
886  m_MainSplit->show();
887 
888  // show/hide Widgets
889  mitkWidget1->hide();
890  mitkWidget2->hide();
891  if (mitkWidget3->isHidden())
892  mitkWidget3->show();
893  mitkWidget4->hide();
894 
895  m_Layout = LAYOUT_WIDGET3;
896 
897  // update Layout Design List
898  mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET3);
899  mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET3);
900  mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET3);
901  mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET3);
902 
903  // update Alle Widgets
904  this->UpdateAllWidgets();
905  mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget3->GetVtkRenderWindow());
906 }
907 
908 void QmitkStdMultiWidget::changeLayoutToRowWidget3And4()
909 {
910  SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
911 
912  // Hide all Menu Widgets
913  this->HideAllWidgetToolbars();
914 
915  delete QmitkStdMultiWidgetLayout;
916 
917  // create Main Layout
918  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
919 
920  // create main splitter
921  m_MainSplit = new QSplitter(this);
922  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
923 
924  // create m_LayoutSplit and add to the mainSplit
925  m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
926  m_MainSplit->addWidget(m_LayoutSplit);
927 
928  // add LevelWindow Widget to mainSplitter
929  m_MainSplit->addWidget(levelWindowWidget);
930 
931  // add Widgets to splitter
932  m_LayoutSplit->addWidget(mitkWidget3Container);
933  m_LayoutSplit->addWidget(mitkWidget4Container);
934 
935  // set Splitter Size
936  QList<int> splitterSize;
937  splitterSize.push_back(1000);
938  splitterSize.push_back(1000);
939  m_LayoutSplit->setSizes(splitterSize);
940 
941  // show mainSplitt and add to Layout
942  m_MainSplit->show();
943 
944  // show/hide Widgets
945  mitkWidget1->hide();
946  mitkWidget2->hide();
947  if (mitkWidget3->isHidden())
948  mitkWidget3->show();
949  if (mitkWidget4->isHidden())
950  mitkWidget4->show();
951 
952  m_Layout = LAYOUT_ROW_WIDGET_3_AND_4;
953 
954  // update Layout Design List
955  mitkWidget1->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
956  mitkWidget2->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
957  mitkWidget3->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
958  mitkWidget4->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
959 
960  // update Alle Widgets
961  this->UpdateAllWidgets();
962 }
963 
964 void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4()
965 {
966  SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl;
967 
968  // Hide all Menu Widgets
969  this->HideAllWidgetToolbars();
970 
971  delete QmitkStdMultiWidgetLayout;
972 
973  // create Main Layout
974  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
975 
976  // create main splitter
977  m_MainSplit = new QSplitter(this);
978  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
979 
980  // create m_LayoutSplit and add to the mainSplit
981  m_LayoutSplit = new QSplitter(m_MainSplit);
982  m_MainSplit->addWidget(m_LayoutSplit);
983 
984  // add LevelWindow Widget to mainSplitter
985  m_MainSplit->addWidget(levelWindowWidget);
986 
987  // add Widgets to splitter
988  m_LayoutSplit->addWidget(mitkWidget3Container);
989  m_LayoutSplit->addWidget(mitkWidget4Container);
990 
991  // set SplitterSize
992  QList<int> splitterSize;
993  splitterSize.push_back(1000);
994  splitterSize.push_back(1000);
995  m_LayoutSplit->setSizes(splitterSize);
996 
997  // show mainSplitt and add to Layout
998  m_MainSplit->show();
999 
1000  // show/hide Widgets
1001  mitkWidget1->hide();
1002  mitkWidget2->hide();
1003  if (mitkWidget3->isHidden())
1004  mitkWidget3->show();
1005  if (mitkWidget4->isHidden())
1006  mitkWidget4->show();
1007 
1008  m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4;
1009 
1010  // update Layout Design List
1011  mitkWidget1->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
1012  mitkWidget2->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
1013  mitkWidget3->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
1014  mitkWidget4->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
1015 
1016  // update Alle Widgets
1017  this->UpdateAllWidgets();
1018 }
1019 
1020 void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4()
1021 {
1022  SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
1023 
1024  this->changeLayoutToRowWidget3And4();
1025 
1026  m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4;
1027 }
1028 
1029 void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4()
1030 {
1031  SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
1032 
1033  // Hide all Menu Widgets
1034  this->HideAllWidgetToolbars();
1035 
1036  delete QmitkStdMultiWidgetLayout;
1037 
1038  // create Main Layout
1039  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
1040 
1041  // create main splitter
1042  m_MainSplit = new QSplitter(this);
1043  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
1044 
1045  // create m_LayoutSplit and add to the mainSplit
1046  m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
1047  m_MainSplit->addWidget(m_LayoutSplit);
1048 
1049  // add LevelWindow Widget to mainSplitter
1050  m_MainSplit->addWidget(levelWindowWidget);
1051 
1052  // create m_SubSplit1 and m_SubSplit2
1053  m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
1054  m_SubSplit2 = new QSplitter(m_LayoutSplit);
1055 
1056  // insert Widget into the splitters
1057  m_SubSplit1->addWidget(mitkWidget2Container);
1058 
1059  m_SubSplit2->addWidget(mitkWidget3Container);
1060  m_SubSplit2->addWidget(mitkWidget4Container);
1061 
1062  // set Splitter Size
1063  QList<int> splitterSize;
1064  splitterSize.push_back(1000);
1065  splitterSize.push_back(1000);
1066  m_SubSplit2->setSizes(splitterSize);
1067  splitterSize.clear();
1068  splitterSize.push_back(500);
1069  splitterSize.push_back(1000);
1070  m_LayoutSplit->setSizes(splitterSize);
1071 
1072  // show mainSplitt
1073  m_MainSplit->show();
1074 
1075  // show Widget if hidden
1076  mitkWidget1->hide();
1077  if (mitkWidget2->isHidden())
1078  mitkWidget2->show();
1079  if (mitkWidget3->isHidden())
1080  mitkWidget3->show();
1081  if (mitkWidget4->isHidden())
1082  mitkWidget4->show();
1083 
1084  m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4;
1085 
1086  // update Layout Design List
1087  mitkWidget1->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
1088  mitkWidget2->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
1089  mitkWidget3->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
1090  mitkWidget4->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
1091 
1092  // update Alle Widgets
1093  this->UpdateAllWidgets();
1094 }
1095 
1096 void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget()
1097 {
1098  SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl;
1099 
1100  // Hide all Menu Widgets
1101  this->HideAllWidgetToolbars();
1102 
1103  delete QmitkStdMultiWidgetLayout;
1104 
1105  // create Main Layout
1106  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
1107 
1108  // create main splitter
1109  m_MainSplit = new QSplitter(this);
1110  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
1111 
1112  // create m_LayoutSplit and add to the mainSplit
1113  m_LayoutSplit = new QSplitter(m_MainSplit);
1114  m_MainSplit->addWidget(m_LayoutSplit);
1115 
1116  // add LevelWindow Widget to mainSplitter
1117  m_MainSplit->addWidget(levelWindowWidget);
1118 
1119  // create m_SubSplit1 and m_SubSplit2
1120  m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
1121  m_SubSplit2 = new QSplitter(m_LayoutSplit);
1122 
1123  // add Widgets to splitter
1124  m_SubSplit1->addWidget(mitkWidget1Container);
1125  m_SubSplit1->addWidget(mitkWidget2Container);
1126  m_SubSplit2->addWidget(mitkWidget4Container);
1127 
1128  // set Splitter Size
1129  QList<int> splitterSize;
1130  splitterSize.push_back(1000);
1131  splitterSize.push_back(1000);
1132  m_SubSplit1->setSizes(splitterSize);
1133  m_LayoutSplit->setSizes(splitterSize);
1134 
1135  // show mainSplitt and add to Layout
1136  m_MainSplit->show();
1137 
1138  // show/hide Widgets
1139  if (mitkWidget1->isHidden())
1140  mitkWidget1->show();
1141  if (mitkWidget2->isHidden())
1142  mitkWidget2->show();
1143  mitkWidget3->hide();
1144  if (mitkWidget4->isHidden())
1145  mitkWidget4->show();
1146 
1147  m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET;
1148 
1149  // update Layout Design List
1150  mitkWidget1->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
1151  mitkWidget2->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
1152  mitkWidget3->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
1153  mitkWidget4->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
1154 
1155  // update Alle Widgets
1156  this->UpdateAllWidgets();
1157 }
1158 
1159 void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D()
1160 {
1161  SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl;
1162 
1163  // Hide all Menu Widgets
1164  this->HideAllWidgetToolbars();
1165 
1166  delete QmitkStdMultiWidgetLayout;
1167 
1168  // create Main Layout
1169  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
1170 
1171  // create main splitter
1172  m_MainSplit = new QSplitter(this);
1173  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
1174 
1175  // create m_LayoutSplit and add to the mainSplit
1176  m_LayoutSplit = new QSplitter(m_MainSplit);
1177  m_MainSplit->addWidget(m_LayoutSplit);
1178 
1179  // add LevelWindow Widget to mainSplitter
1180  m_MainSplit->addWidget(levelWindowWidget);
1181 
1182  // create m_SubSplit1 and m_SubSplit2
1183  m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
1184  m_SubSplit2 = new QSplitter(m_LayoutSplit);
1185 
1186  // add Widgets to splitter
1187  m_SubSplit1->addWidget(mitkWidget1Container);
1188  m_SubSplit1->addWidget(mitkWidget4Container);
1189  m_SubSplit2->addWidget(mitkWidget2Container);
1190 
1191  // set Splitter Size
1192  QList<int> splitterSize;
1193  splitterSize.push_back(1000);
1194  splitterSize.push_back(1000);
1195  m_SubSplit1->setSizes(splitterSize);
1196  m_LayoutSplit->setSizes(splitterSize);
1197 
1198  // show mainSplitt and add to Layout
1199  m_MainSplit->show();
1200 
1201  // show/hide Widgets
1202  if (mitkWidget1->isHidden())
1203  mitkWidget1->show();
1204  if (mitkWidget2->isHidden())
1205  mitkWidget2->show();
1206  mitkWidget3->hide();
1207  if (mitkWidget4->isHidden())
1208  mitkWidget4->show();
1209 
1210  m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET;
1211 
1212  // update Layout Design List
1213  mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
1214  mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
1215  mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
1216  mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
1217 
1218  // update Alle Widgets
1219  this->UpdateAllWidgets();
1220 }
1221 
1222 void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown()
1223 {
1224  SMW_INFO << "changing layout to 2D up and 3D down" << std::endl;
1225 
1226  // Hide all Menu Widgets
1227  this->HideAllWidgetToolbars();
1228 
1229  delete QmitkStdMultiWidgetLayout;
1230 
1231  // create Main Layout
1232  QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
1233 
1234  // Set Layout to widget
1235  this->setLayout(QmitkStdMultiWidgetLayout);
1236 
1237  // create main splitter
1238  m_MainSplit = new QSplitter(this);
1239  QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
1240 
1241  // create m_LayoutSplit and add to the mainSplit
1242  m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
1243  m_MainSplit->addWidget(m_LayoutSplit);
1244 
1245  // add LevelWindow Widget to mainSplitter
1246  m_MainSplit->addWidget(levelWindowWidget);
1247 
1248  // create m_SubSplit1 and m_SubSplit2
1249  m_SubSplit1 = new QSplitter(m_LayoutSplit);
1250  m_SubSplit2 = new QSplitter(m_LayoutSplit);
1251 
1252  // insert Widget Container into splitter top
1253  m_SubSplit1->addWidget(mitkWidget1Container);
1254 
1255  // set SplitterSize for splitter top
1256  QList<int> splitterSize;
1257  // insert Widget Container into splitter bottom
1258  m_SubSplit2->addWidget(mitkWidget4Container);
1259  // set SplitterSize for splitter m_LayoutSplit
1260  splitterSize.clear();
1261  splitterSize.push_back(700);
1262  splitterSize.push_back(700);
1263  m_LayoutSplit->setSizes(splitterSize);
1264 
1265  // show mainSplitt
1266  m_MainSplit->show();
1267 
1268  // show/hide Widgets
1269  if (mitkWidget1->isHidden())
1270  mitkWidget1->show();
1271  mitkWidget2->hide();
1272  mitkWidget3->hide();
1273  if (mitkWidget4->isHidden())
1274  mitkWidget4->show();
1275 
1276  m_Layout = LAYOUT_2D_UP_AND_3D_DOWN;
1277 
1278  // update Layout Design List
1279  mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
1280  mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
1281  mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
1282  mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
1283 
1284  // update all Widgets
1285  this->UpdateAllWidgets();
1286 }
1287 
1288 void QmitkStdMultiWidget::SetDataStorage(mitk::DataStorage *ds)
1289 {
1290  if (ds == m_DataStorage)
1291  {
1292  return;
1293  }
1294 
1295  mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds);
1296  mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds);
1297  mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds);
1298  mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds);
1299  m_DataStorage = ds;
1300 }
1301 
1302 void QmitkStdMultiWidget::Fit()
1303 {
1304  vtkSmartPointer<vtkRenderer> vtkrenderer;
1305  vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer();
1306  if (vtkrenderer != NULL)
1307  vtkrenderer->ResetCamera();
1308 
1309  vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer();
1310  if (vtkrenderer != NULL)
1311  vtkrenderer->ResetCamera();
1312 
1313  vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer();
1314  if (vtkrenderer != NULL)
1315  vtkrenderer->ResetCamera();
1316 
1317  vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer();
1318  if (vtkrenderer != NULL)
1319  vtkrenderer->ResetCamera();
1320 
1321  mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCameraController()->Fit();
1322  mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCameraController()->Fit();
1323  mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCameraController()->Fit();
1324  mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCameraController()->Fit();
1325 
1326  int w = vtkObject::GetGlobalWarningDisplay();
1327  vtkObject::GlobalWarningDisplayOff();
1328 
1329  vtkObject::SetGlobalWarningDisplay(w);
1330 }
1331 
1332 void QmitkStdMultiWidget::InitPositionTracking()
1333 {
1334  // TODO POSITIONTRACKER
1335 }
1336 
1337 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
1338 {
1339  // add the displayed planes of the multiwidget to a node to which the subtree
1340  // @a planesSubTree points ...
1341 
1342  mitk::PlaneGeometryDataMapper2D::Pointer mapper;
1343 
1344  // ... of widget 1
1345  mitk::BaseRenderer *renderer1 = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow());
1346  m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
1347  m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
1348  m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
1349  m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
1350  m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
1351  mapper = mitk::PlaneGeometryDataMapper2D::New();
1352  m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
1353 
1354  // ... of widget 2
1355  mitk::BaseRenderer *renderer2 = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow());
1356  m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
1357  m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
1358  m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
1359  m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
1360  m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
1361  mapper = mitk::PlaneGeometryDataMapper2D::New();
1362  m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
1363 
1364  // ... of widget 3
1365  mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow());
1366  m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
1367  m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
1368  m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
1369  m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
1370  m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
1371  mapper = mitk::PlaneGeometryDataMapper2D::New();
1372  m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
1373 
1374  m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
1375  m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
1376  m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
1377 }
1378 
1379 mitk::SliceNavigationController *QmitkStdMultiWidget::GetTimeNavigationController()
1380 {
1381  return m_TimeNavigationController;
1382 }
1383 
1384 void QmitkStdMultiWidget::EnableStandardLevelWindow()
1385 {
1386  levelWindowWidget->disconnect(this);
1387  levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage());
1388  levelWindowWidget->show();
1389 }
1390 
1391 void QmitkStdMultiWidget::DisableStandardLevelWindow()
1392 {
1393  levelWindowWidget->disconnect(this);
1394  levelWindowWidget->hide();
1395 }
1396 
1397 // CAUTION: Legacy code for enabling Qt-signal-controlled view initialization.
1398 // Use RenderingManager::InitializeViews() instead.
1399 bool QmitkStdMultiWidget::InitializeStandardViews(const mitk::Geometry3D *geometry)
1400 {
1401  return m_RenderingManager->InitializeViews(geometry);
1402 }
1403 
1404 void QmitkStdMultiWidget::RequestUpdate()
1405 {
1406  m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow());
1407  m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow());
1408  m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow());
1409  m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow());
1410 }
1411 
1412 void QmitkStdMultiWidget::ForceImmediateUpdate()
1413 {
1414  m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow());
1415  m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow());
1416  m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow());
1417  m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow());
1418 }
1419 
1420 void QmitkStdMultiWidget::wheelEvent(QWheelEvent *e)
1421 {
1422  emit WheelMoved(e);
1423 }
1424 
1425 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent *e)
1426 {
1427 }
1428 
1429 void QmitkStdMultiWidget::moveEvent(QMoveEvent *e)
1430 {
1431  QWidget::moveEvent(e);
1432 
1433  // it is necessary to readjust the position of the overlays as the StdMultiWidget has moved
1434  // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
1435  emit Moved();
1436 }
1437 
1438 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow1() const
1439 {
1440  return mitkWidget1;
1441 }
1442 
1443 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow2() const
1444 {
1445  return mitkWidget2;
1446 }
1447 
1448 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow3() const
1449 {
1450  return mitkWidget3;
1451 }
1452 
1453 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow4() const
1454 {
1455  return mitkWidget4;
1456 }
1457 
1458 const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const
1459 {
1460  const mitk::PlaneGeometry *plane1 = mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
1461  const mitk::PlaneGeometry *plane2 = mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
1462  const mitk::PlaneGeometry *plane3 = mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
1463 
1464  mitk::Line3D line;
1465  if ((plane1 != NULL) && (plane2 != NULL) && (plane1->IntersectionLine(plane2, line)))
1466  {
1467  mitk::Point3D point;
1468  if ((plane3 != NULL) && (plane3->IntersectionPoint(line, point)))
1469  {
1470  return point;
1471  }
1472  }
1473  // TODO BUG POSITIONTRACKER;
1474  mitk::Point3D p;
1475  return p;
1476  // return m_LastLeftClickPositionSupplier->GetCurrentPoint();
1477 }
1478 
1479 void QmitkStdMultiWidget::EnablePositionTracking()
1480 {
1481 }
1482 
1483 void QmitkStdMultiWidget::DisablePositionTracking()
1484 {
1485 }
1486 
1487 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
1488 {
1489  mitk::Point2D pointOnDisplay;
1490  renderer->WorldToDisplay(p, pointOnDisplay);
1491 
1492  if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
1493  pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
1494  pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
1495  pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
1496  {
1497  mitk::Point2D pointOnPlane;
1498  renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
1499  renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
1500  }
1501 }
1502 
1503 void QmitkStdMultiWidget::MoveCrossToPosition(const mitk::Point3D &newPosition)
1504 {
1505  mitkWidget1->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
1506  mitkWidget2->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
1507  mitkWidget3->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
1508 
1509  m_RenderingManager->RequestUpdateAll();
1510 }
1511 
1512 void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
1513 {
1514  if (!m_PendingCrosshairPositionEvent)
1515  {
1516  m_PendingCrosshairPositionEvent = true;
1517  QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed()));
1518  }
1519 }
1520 
1521 mitk::DataNode::Pointer QmitkStdMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
1522 {
1523  mitk::Point3D crosshairPos = this->GetCrossPosition();
1524  mitk::DataNode::Pointer node;
1525  int maxlayer = -32768;
1526 
1527  if (nodes.IsNotNull())
1528  {
1529  mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
1530  // find node with largest layer, that is the node shown on top in the render window
1531  for (unsigned int x = 0; x < nodes->size(); x++)
1532  {
1533  if ((nodes->at(x)->GetData()->GetGeometry() != NULL) &&
1534  nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos))
1535  {
1536  int layer = 0;
1537  if (!(nodes->at(x)->GetIntProperty("layer", layer)))
1538  continue;
1539  if (layer > maxlayer)
1540  {
1541  if (static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(baseRenderer))
1542  {
1543  node = nodes->at(x);
1544  maxlayer = layer;
1545  }
1546  }
1547  }
1548  }
1549  }
1550  return node;
1551 }
1552 
1553 void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
1554 {
1555  m_PendingCrosshairPositionEvent = false;
1556 
1557  // find image with highest layer
1558  mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
1559  mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
1560 
1561  mitk::DataNode::Pointer node;
1562  mitk::DataNode::Pointer topSourceNode;
1563  mitk::Image::Pointer image;
1564  bool isBinary = false;
1565  node = this->GetTopLayerNode(nodes);
1566  int component = 0;
1567  if (node.IsNotNull())
1568  {
1569  node->GetBoolProperty("binary", isBinary);
1570  if (isBinary)
1571  {
1572  mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = m_DataStorage->GetSources(node, NULL, true);
1573  if (!sourcenodes->empty())
1574  {
1575  topSourceNode = this->GetTopLayerNode(sourcenodes);
1576  }
1577  if (topSourceNode.IsNotNull())
1578  {
1579  image = dynamic_cast<mitk::Image *>(topSourceNode->GetData());
1580  topSourceNode->GetIntProperty("Image.Displayed Component", component);
1581  }
1582  else
1583  {
1584  image = dynamic_cast<mitk::Image *>(node->GetData());
1585  node->GetIntProperty("Image.Displayed Component", component);
1586  }
1587  }
1588  else
1589  {
1590  image = dynamic_cast<mitk::Image *>(node->GetData());
1591  node->GetIntProperty("Image.Displayed Component", component);
1592  }
1593  }
1594 
1595  mitk::Point3D crosshairPos = this->GetCrossPosition();
1596  std::string statusText;
1597  std::stringstream stream;
1598  itk::Index<3> p;
1599  mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
1600  unsigned int timestep = baseRenderer->GetTimeStep();
1601 
1602  if (image.IsNotNull() && (image->GetTimeSteps() > timestep))
1603  {
1604  image->GetGeometry()->WorldToIndex(crosshairPos, p);
1605  stream.precision(2);
1606  stream << "Position: <" << std::fixed << crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", "
1607  << std::fixed << crosshairPos[2] << "> mm";
1608  stream << "; Index: <" << p[0] << ", " << p[1] << ", " << p[2] << "> ";
1609 
1610  mitk::ScalarType pixelValue;
1611 
1612  mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
1613  image->GetChannelDescriptor().GetPixelType(),
1614  image,
1615  image->GetVolumeData(baseRenderer->GetTimeStep()),
1616  p,
1617  pixelValue,
1618  component);
1619 
1620  if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
1621  {
1622  stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific << pixelValue << " ";
1623  }
1624  else
1625  {
1626  stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << pixelValue << " ";
1627  }
1628  }
1629  else
1630  {
1631  stream << "No image information at this position!";
1632  }
1633 
1634  statusText = stream.str();
1635  mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
1636 }
1637 
1638 int QmitkStdMultiWidget::GetLayout() const
1639 {
1640  return m_Layout;
1641 }
1642 
1643 bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const
1644 {
1645  return m_GradientBackgroundFlag;
1646 }
1647 
1648 void QmitkStdMultiWidget::EnableGradientBackground()
1649 {
1650  // gradient background is by default only in widget 4, otherwise
1651  // interferences between 2D rendering and VTK rendering may occur.
1652  for (unsigned int i = 0; i < 4; ++i)
1653  {
1654  GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOn();
1655  }
1656  m_GradientBackgroundFlag = true;
1657 }
1658 
1659 void QmitkStdMultiWidget::DisableGradientBackground()
1660 {
1661  for (unsigned int i = 0; i < 4; ++i)
1662  {
1663  GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOff();
1664  }
1665  m_GradientBackgroundFlag = false;
1666 }
1667 
1668 void QmitkStdMultiWidget::EnableDepartmentLogo()
1669 {
1670  m_LogoRendering->SetVisibility(true);
1671  RequestUpdate();
1672 }
1673 
1674 void QmitkStdMultiWidget::DisableDepartmentLogo()
1675 {
1676  m_LogoRendering->SetVisibility(false);
1677  RequestUpdate();
1678 }
1679 
1680 bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const
1681 {
1682  return m_LogoRendering->IsVisible(mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
1683 }
1684 
1685 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
1686 {
1687  if (m_DataStorage.IsNotNull())
1688  {
1689  mitk::DataNode *n = m_DataStorage->GetNamedNode(widgetName);
1690  if (n != NULL)
1691  n->SetVisibility(visible, renderer);
1692  }
1693 }
1694 
1695 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
1696 {
1697  if (m_PlaneNode1.IsNotNull())
1698  {
1699  m_PlaneNode1->SetVisibility(visible, renderer);
1700  }
1701  if (m_PlaneNode2.IsNotNull())
1702  {
1703  m_PlaneNode2->SetVisibility(visible, renderer);
1704  }
1705  if (m_PlaneNode3.IsNotNull())
1706  {
1707  m_PlaneNode3->SetVisibility(visible, renderer);
1708  }
1709  m_RenderingManager->RequestUpdateAll();
1710 }
1711 
1712 void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
1713 {
1714  // do your job and lock or unlock slices.
1715  GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
1716  GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
1717  GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
1718 }
1719 
1720 void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
1721 {
1722  // do your job and lock or unlock slices.
1723  GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
1724  GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
1725  GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
1726 }
1727 
1728 void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked(bool link)
1729 {
1730  emit WidgetPlanesRotationLinked(link);
1731 }
1732 
1733 void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
1734 {
1735  MITK_DEBUG << "Changing crosshair mode to " << userMode;
1736 
1737  emit WidgetNotifyNewCrossHairMode(userMode);
1738  // Convert user interface mode to actual mode
1739  {
1740  switch (userMode)
1741  {
1742  case 0:
1743  m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::MITK);
1744  break;
1745  case 1:
1746  m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATION);
1747  break;
1748 
1749  case 2:
1750  m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATIONLINKED);
1751  break;
1752 
1753  case 3:
1754  m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::SWIVEL);
1755  break;
1756  }
1757  }
1758 }
1759 
1760 void QmitkStdMultiWidget::SetGradientBackgroundColorForRenderWindow(const mitk::Color &upper,
1761  const mitk::Color &lower,
1762  unsigned int widgetNumber)
1763 {
1764  if (widgetNumber > 3)
1765  {
1766  MITK_ERROR << "Gradientbackground for unknown widget!";
1767  return;
1768  }
1769  m_GradientBackgroundColors[widgetNumber].first = upper;
1770  m_GradientBackgroundColors[widgetNumber].second = lower;
1771  vtkRenderer *renderer = GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer();
1772  renderer->SetBackground2(upper[0], upper[1], upper[2]);
1773  renderer->SetBackground(lower[0], lower[1], lower[2]);
1774  m_GradientBackgroundFlag = true;
1775 }
1776 
1777 void QmitkStdMultiWidget::SetGradientBackgroundColors(const mitk::Color &upper, const mitk::Color &lower)
1778 {
1779  for (unsigned int i = 0; i < 4; ++i)
1780  {
1781  vtkRenderer *renderer = GetRenderWindow(i)->GetRenderer()->GetVtkRenderer();
1782  renderer->SetBackground2(upper[0], upper[1], upper[2]);
1783  renderer->SetBackground(lower[0], lower[1], lower[2]);
1784  }
1785  m_GradientBackgroundFlag = true;
1786 }
1787 
1788 void QmitkStdMultiWidget::SetDepartmentLogoPath(const char *path)
1789 {
1790  m_LogoRendering->SetLogoImagePath(path);
1791  mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
1792  m_LogoRendering->Update(renderer);
1793  RequestUpdate();
1794 }
1795 
1796 void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing(bool activate)
1797 {
1798  if (activate)
1799  {
1800  this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
1801  }
1802 }
1803 
1804 void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation(bool activate)
1805 {
1806  if (activate)
1807  {
1808  this->SetWidgetPlaneMode(PLANE_MODE_ROTATION);
1809  }
1810 }
1811 
1812 void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel(bool activate)
1813 {
1814  if (activate)
1815  {
1816  this->SetWidgetPlaneMode(PLANE_MODE_SWIVEL);
1817  }
1818 }
1819 
1820 void QmitkStdMultiWidget::OnLayoutDesignChanged(int layoutDesignIndex)
1821 {
1822  switch (layoutDesignIndex)
1823  {
1824  case LAYOUT_DEFAULT:
1825  {
1826  this->changeLayoutToDefault();
1827  break;
1828  }
1829  case LAYOUT_2D_IMAGES_UP:
1830  {
1831  this->changeLayoutTo2DImagesUp();
1832  break;
1833  }
1834  case LAYOUT_2D_IMAGES_LEFT:
1835  {
1836  this->changeLayoutTo2DImagesLeft();
1837  break;
1838  }
1839  case LAYOUT_BIG_3D:
1840  {
1841  this->changeLayoutToBig3D();
1842  break;
1843  }
1844  case LAYOUT_WIDGET1:
1845  {
1846  this->changeLayoutToWidget1();
1847  break;
1848  }
1849  case LAYOUT_WIDGET2:
1850  {
1851  this->changeLayoutToWidget2();
1852  break;
1853  }
1854  case LAYOUT_WIDGET3:
1855  {
1856  this->changeLayoutToWidget3();
1857  break;
1858  }
1859  case LAYOUT_2X_2D_AND_3D_WIDGET:
1860  {
1861  this->changeLayoutTo2x2Dand3DWidget();
1862  break;
1863  }
1864  case LAYOUT_ROW_WIDGET_3_AND_4:
1865  {
1866  this->changeLayoutToRowWidget3And4();
1867  break;
1868  }
1869  case LAYOUT_COLUMN_WIDGET_3_AND_4:
1870  {
1871  this->changeLayoutToColumnWidget3And4();
1872  break;
1873  }
1874  case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4:
1875  {
1876  this->changeLayoutToRowWidgetSmall3andBig4();
1877  break;
1878  }
1879  case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4:
1880  {
1881  this->changeLayoutToSmallUpperWidget2Big3and4();
1882  break;
1883  }
1884  case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET:
1885  {
1886  this->changeLayoutToLeft2Dand3DRight2D();
1887  break;
1888  }
1889  };
1890 }
1891 
1892 void QmitkStdMultiWidget::UpdateAllWidgets()
1893 {
1894  mitkWidget1->resize(mitkWidget1Container->frameSize().width() - 1, mitkWidget1Container->frameSize().height());
1895  mitkWidget1->resize(mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height());
1896 
1897  mitkWidget2->resize(mitkWidget2Container->frameSize().width() - 1, mitkWidget2Container->frameSize().height());
1898  mitkWidget2->resize(mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height());
1899 
1900  mitkWidget3->resize(mitkWidget3Container->frameSize().width() - 1, mitkWidget3Container->frameSize().height());
1901  mitkWidget3->resize(mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height());
1902 
1903  mitkWidget4->resize(mitkWidget4Container->frameSize().width() - 1, mitkWidget4Container->frameSize().height());
1904  mitkWidget4->resize(mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height());
1905 }
1906 
1907 void QmitkStdMultiWidget::HideAllWidgetToolbars()
1908 {
1909  mitkWidget1->HideRenderWindowMenu();
1910  mitkWidget2->HideRenderWindowMenu();
1911  mitkWidget3->HideRenderWindowMenu();
1912  mitkWidget4->HideRenderWindowMenu();
1913 }
1914 
1915 void QmitkStdMultiWidget::ActivateMenuWidget(bool state)
1916 {
1917  mitkWidget1->ActivateMenuWidget(state, this);
1918  mitkWidget2->ActivateMenuWidget(state, this);
1919  mitkWidget3->ActivateMenuWidget(state, this);
1920  mitkWidget4->ActivateMenuWidget(state, this);
1921 }
1922 
1923 bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
1924 {
1925  return mitkWidget1->GetActivateMenuWidgetFlag();
1926 }
1927 
1928 void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
1929 {
1930  switch (widgetNumber)
1931  {
1932  case 0:
1933  if (m_PlaneNode1.IsNotNull())
1934  {
1935  m_PlaneNode1->SetColor(color);
1936  }
1937  break;
1938  case 1:
1939  if (m_PlaneNode2.IsNotNull())
1940  {
1941  m_PlaneNode2->SetColor(color);
1942  }
1943  break;
1944  case 2:
1945  if (m_PlaneNode3.IsNotNull())
1946  {
1947  m_PlaneNode3->SetColor(color);
1948  }
1949  break;
1950  case 3:
1951  m_DecorationColorWidget4 = color;
1952  break;
1953  default:
1954  MITK_ERROR << "Decoration color for unknown widget!";
1955  break;
1956  }
1957 }
1958 
1959 void QmitkStdMultiWidget::ResetCrosshair()
1960 {
1961  if (m_DataStorage.IsNotNull())
1962  {
1963  m_RenderingManager->InitializeViewsByBoundingObjects(m_DataStorage);
1964  // m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
1965  // reset interactor to normal slicing
1966  this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
1967  }
1968 }
1969 
1970 void QmitkStdMultiWidget::EnableColoredRectangles()
1971 {
1972  m_RectangleProps[0]->SetVisibility(1);
1973  m_RectangleProps[1]->SetVisibility(1);
1974  m_RectangleProps[2]->SetVisibility(1);
1975  m_RectangleProps[3]->SetVisibility(1);
1976 }
1977 
1978 void QmitkStdMultiWidget::DisableColoredRectangles()
1979 {
1980  m_RectangleProps[0]->SetVisibility(0);
1981  m_RectangleProps[1]->SetVisibility(0);
1982  m_RectangleProps[2]->SetVisibility(0);
1983  m_RectangleProps[3]->SetVisibility(0);
1984 }
1985 
1986 bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const
1987 {
1988  return m_RectangleProps[0]->GetVisibility() > 0;
1989 }
1990 
1991 mitk::MouseModeSwitcher *QmitkStdMultiWidget::GetMouseModeSwitcher()
1992 {
1993  return m_MouseModeSwitcher;
1994 }
1995 
1996 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1()
1997 {
1998  return this->m_PlaneNode1;
1999 }
2000 
2001 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2()
2002 {
2003  return this->m_PlaneNode2;
2004 }
2005 
2006 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3()
2007 {
2008  return this->m_PlaneNode3;
2009 }
2010 
2011 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id)
2012 {
2013  switch (id)
2014  {
2015  case 1:
2016  return this->m_PlaneNode1;
2017  break;
2018  case 2:
2019  return this->m_PlaneNode2;
2020  break;
2021  case 3:
2022  return this->m_PlaneNode3;
2023  break;
2024  default:
2025  return NULL;
2026  }
2027 }
mitkWidget4
mitk::RenderWindow::Pointer mitkWidget4
Definition: QtFreeRender.cpp:57
mitk::FastSinglePixelAccess
mitk::ScalarType FastSinglePixelAccess(mitk::PixelType, mitk::Image::Pointer im, ImageDataItem *item, itk::Index< 3 > idx, mitk::ScalarType &val, int component=0)
Definition: mitkImagePixelReadAccessor.h:168
mitk::RenderingManager::InitializeViews
virtual bool InitializeViews(const BaseGeometry *geometry, RequestType type=REQUEST_UPDATE_ALL, bool preserveRoughOrientationInWorldSpace=false)
Definition: mitkRenderingManager.cpp:300
QmitkRenderWindow::LayoutDesignListChanged
void LayoutDesignListChanged(int layoutDesignIndex)
Definition: QmitkRenderWindow.cpp:102
QmitkStdMultiWidget::PLANE_MODE_SWIVEL
Definition: QmitkStdMultiWidget.h:271
mitk::BaseRenderer::GetCurrentWorldPlaneGeometryNode
virtual DataNode * GetCurrentWorldPlaneGeometryNode()
Get a DataNode pointing to a data object containing the current 2D-worldgeometry. ...
QmitkStdMultiWidget::m_RectangleProps
vtkSmartPointer< vtkMitkRectangleProp > m_RectangleProps[4]
Definition: QmitkStdMultiWidget.h:411
QmitkStdMultiWidget::WheelMoved
void WheelMoved(QWheelEvent *)
mitk::Line
Descibes a line.
Definition: mitkLine.h:32
line
static char * line
Definition: svm.cpp:2884
QmitkStdMultiWidget::GetRenderWindow1
QmitkRenderWindow * GetRenderWindow1() const
Definition: QmitkStdMultiWidget.cpp:1438
mitk::DataStorage
Data management class that handles 'was created by' relations.
Definition: mitkDataStorage.h:47
QmitkStdMultiWidget::GetCornerAnnotationText
std::string GetCornerAnnotationText(unsigned int widgetNumber)
GetCornerAnnotationText Getter for corner annotation text.
Definition: QmitkStdMultiWidget.cpp:401
mitk::RenderingManager::GetTimeNavigationController
const SliceNavigationController * GetTimeNavigationController() const
Definition: mitkRenderingManager.cpp:511
QmitkStdMultiWidget::GetGradientColors
std::pair< mitk::Color, mitk::Color > GetGradientColors(unsigned int widgetNumber)
GetGradientColors Getter for gradientbackground colors.
Definition: QmitkStdMultiWidget.cpp:333
mitk::Geometry3D
Standard implementation of BaseGeometry.
Definition: mitkGeometry3D.h:37
mitk::SliceNavigationController::SelectSliceByPoint
void SelectSliceByPoint(const mitk::Point3D &point)
Positions the SNC according to the specified point.
Definition: mitkSliceNavigationController.cpp:431
QmitkStdMultiWidget::GetMouseModeSwitcher
mitk::MouseModeSwitcher * GetMouseModeSwitcher()
Definition: QmitkStdMultiWidget.cpp:1991
mitk::PlaneGeometry::IntersectionPoint
bool IntersectionPoint(const Line3D &line, Point3D &intersectionPoint) const
Calculate intersection point between the plane and a line.
Definition: mitkPlaneGeometry.cpp:722
mitk::DataNode::SetVisibility
void SetVisibility(bool visible, const mitk::BaseRenderer *renderer=nullptr, const char *propertyKey="visible")
Convenience method for setting visibility properties (instances of BoolProperty)
Definition: mitkDataNode.cpp:410
QmitkStdMultiWidget::m_PlaneNode2
mitk::DataNode::Pointer m_PlaneNode2
Definition: QmitkStdMultiWidget.h:378
mitk::BaseRenderer::GetInstance
static BaseRenderer * GetInstance(vtkRenderWindow *renWin)
Definition: mitkBaseRenderer.cpp:49
QmitkStdMultiWidget::LAYOUT_2X_2D_AND_3D_WIDGET
Definition: QmitkStdMultiWidget.h:282
tmp2
std::string tmp2
Definition: usServiceProperties.cpp:77
mitk::SliceNavigationController::GetRenderer
BaseRenderer * GetRenderer() const
Gets the BaseRenderer associated with this SNC (if any). While the BaseRenderer is not directly used ...
Definition: mitkSliceNavigationController.cpp:552
QmitkStdMultiWidget::InitializeStandardViews
bool InitializeStandardViews(const mitk::Geometry3D *geometry)
Definition: QmitkStdMultiWidget.cpp:1399
QmitkStdMultiWidget::IsDepartmentLogoEnabled
bool IsDepartmentLogoEnabled() const
Definition: QmitkStdMultiWidget.cpp:1680
QmitkStdMultiWidget::LAYOUT_WIDGET1
Definition: QmitkStdMultiWidget.h:279
QmitkStdMultiWidget::LAYOUT_2D_UP_AND_3D_DOWN
Definition: QmitkStdMultiWidget.h:288
mitk::PlaneGeometry::Map
virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const
Project a 3D point given in mm (pt3d_mm) onto the 2D geometry. The result is a 2D point in mm (pt2d_m...
Definition: mitkPlaneGeometry.cpp:869
QmitkStdMultiWidget::m_MouseModeSwitcher
mitk::MouseModeSwitcher::Pointer m_MouseModeSwitcher
Definition: QmitkStdMultiWidget.h:369
MITK_ERROR
#define MITK_ERROR
Definition: mitkLogMacros.h:24
mitk::ScalarType
double ScalarType
Definition: mitkNumericConstants.h:24
mitkWidget2
mitk::RenderWindow::Pointer mitkWidget2
Definition: QtFreeRender.cpp:55
QmitkStdMultiWidget::SetGradientBackgroundColors
void SetGradientBackgroundColors(const mitk::Color &upper, const mitk::Color &lower)
Definition: QmitkStdMultiWidget.cpp:1777
QmitkStdMultiWidget::GetTimeNavigationController
mitk::SliceNavigationController * GetTimeNavigationController()
Definition: QmitkStdMultiWidget.cpp:1379
QmitkStdMultiWidget::WidgetNotifyNewCrossHairMode
void WidgetNotifyNewCrossHairMode(int)
QmitkRenderWindow::SetLayoutIndex
void SetLayoutIndex(unsigned int layoutIndex)
Definition: QmitkRenderWindow.cpp:87
QmitkStdMultiWidget::LAYOUT_2D_IMAGES_UP
Definition: QmitkStdMultiWidget.h:276
mitk::BaseRenderer
Organizes the rendering process.
Definition: mitkBaseRenderer.h:70
mitk::BaseRenderer::Standard3D
Definition: mitkBaseRenderer.h:117
QmitkStdMultiWidget::mitkWidget4
QmitkRenderWindow * mitkWidget4
Definition: QmitkStdMultiWidget.h:263
QmitkStdMultiWidget::mitkWidget2
QmitkRenderWindow * mitkWidget2
Definition: QmitkStdMultiWidget.h:261
SMW_INFO
#define SMW_INFO
Definition: QmitkStdMultiWidget.cpp:17
QmitkStdMultiWidget::SetDepartmentLogoPath
void SetDepartmentLogoPath(const char *path)
Definition: QmitkStdMultiWidget.cpp:1788
QmitkStdMultiWidget::GetWidgetPlane
mitk::DataNode::Pointer GetWidgetPlane(int id)
Convenience method to access node of widget planes.
Definition: QmitkStdMultiWidget.cpp:2011
QmitkStdMultiWidget::LAYOUT_COLUMN_WIDGET_3_AND_4
Definition: QmitkStdMultiWidget.h:284
mitk::BaseRenderer::GetTime
ScalarType GetTime() const
Get the time in ms of the currently displayed content.
Definition: mitkBaseRenderer.cpp:402
MITK_DEBUG
#define MITK_DEBUG
Definition: mitkLogMacros.h:26
QmitkStdMultiWidget::SetDecorationColor
void SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
SetDecorationColor Set the color of the decoration of the 4 widgets.
Definition: QmitkStdMultiWidget.cpp:1928
GetDataStorage
static mitk::DataStorage::Pointer GetDataStorage()
Definition: mitkMeshMitkLoader.cpp:29
QmitkStdMultiWidget::LAYOUT_2D_IMAGES_LEFT
Definition: QmitkStdMultiWidget.h:277
QmitkStdMultiWidget::PLANE_MODE_ROTATION
Definition: QmitkStdMultiWidget.h:270
QmitkStdMultiWidget::HandleCrosshairPositionEvent
void HandleCrosshairPositionEvent()
Listener to the CrosshairPositionEvent.
Definition: QmitkStdMultiWidget.cpp:1512
mitk::MouseModeSwitcher::New
static Pointer New()
mitk::BaseRenderer::GetCurrentWorldPlaneGeometry
virtual const PlaneGeometry * GetCurrentWorldPlaneGeometry()
Get the current 2D-worldgeometry (m_CurrentWorldPlaneGeometry) used for 2D-rendering.
QmitkStdMultiWidget::THREE_D
Definition: QmitkStdMultiWidget.h:296
QmitkStdMultiWidget::ActivateMenuWidget
void ActivateMenuWidget(bool state)
activate Menu Widget. true: activated, false: deactivated
Definition: QmitkStdMultiWidget.cpp:1915
mitkInteractionConst.h
Constants for most interaction classes, due to the generic StateMachines.
QmitkRenderWindow::GetVtkRenderWindow
virtual vtkRenderWindow * GetVtkRenderWindow() override
Definition: QmitkRenderWindow.h:86
QmitkStdMultiWidget::m_CornerAnnotations
vtkSmartPointer< vtkCornerAnnotation > m_CornerAnnotations[4]
Definition: QmitkStdMultiWidget.h:410
QmitkStdMultiWidget::GetRenderWindow2
QmitkRenderWindow * GetRenderWindow2() const
Definition: QmitkStdMultiWidget.cpp:1443
mitk::SliceNavigationController::Original
Definition: mitkSliceNavigationController.h:171
QmitkStdMultiWidget::IsColoredRectanglesEnabled
bool IsColoredRectanglesEnabled() const
Definition: QmitkStdMultiWidget.cpp:1986
QmitkStdMultiWidget::IsCornerAnnotationVisible
bool IsCornerAnnotationVisible(void) const
Definition: QmitkStdMultiWidget.cpp:636
mitk::SliceNavigationController::SetSliceRotationLocked
virtual void SetSliceRotationLocked(bool _arg)
Feature option to lock slice rotation.
QmitkStdMultiWidget::m_PlaneNode1
mitk::DataNode::Pointer m_PlaneNode1
m_PlaneNode1 the 3 helper objects which contain the plane geometry.
Definition: QmitkStdMultiWidget.h:377
QmitkStdMultiWidget::FillGradientBackgroundWithBlack
void FillGradientBackgroundWithBlack()
FillGradientBackgroundWithBlack Internal helper method to initialize the gradient background colors w...
Definition: QmitkStdMultiWidget.cpp:323
QmitkStdMultiWidget::mitkWidget1
QmitkRenderWindow * mitkWidget1
Definition: QmitkStdMultiWidget.h:260
QmitkStdMultiWidget::LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET
Definition: QmitkStdMultiWidget.h:287
mitk::SliceNavigationController::Axial
Definition: mitkSliceNavigationController.h:168
QmitkStdMultiWidget::m_PlaneNode3
mitk::DataNode::Pointer m_PlaneNode3
Definition: QmitkStdMultiWidget.h:379
QmitkStdMultiWidget::SetWidgetPlaneMode
void SetWidgetPlaneMode(int mode)
Definition: QmitkStdMultiWidget.cpp:1733
mitk::SliceNavigationController
Controls the selection of the slice the associated BaseRenderer will display.
Definition: mitkSliceNavigationController.h:152
QmitkStdMultiWidget::GetGradientBackgroundFlag
bool GetGradientBackgroundFlag() const
Definition: QmitkStdMultiWidget.cpp:1643
QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed
void HandleCrosshairPositionEventDelayed()
Receives the signal from HandleCrosshairPositionEvent, executes the StatusBar update.
Definition: QmitkStdMultiWidget.cpp:1553
QmitkStdMultiWidget::m_RenderingManager
mitk::RenderingManager * m_RenderingManager
Definition: QmitkStdMultiWidget.h:363
mitk::ConstPointer
itk::SmartPointer< const Self > ConstPointer
Definition: mitkRenderingManager.h:389
QmitkStdMultiWidget::LAYOUT_WIDGET3
Definition: QmitkStdMultiWidget.h:281
QmitkStdMultiWidget::OnLayoutDesignChanged
void OnLayoutDesignChanged(int layoutDesignIndex)
Definition: QmitkStdMultiWidget.cpp:1820
QmitkStdMultiWidget::GetTopLayerNode
mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
Definition: QmitkStdMultiWidget.cpp:1521
QmitkStdMultiWidget::levelWindowWidget
QmitkLevelWindowWidget * levelWindowWidget
Definition: QmitkStdMultiWidget.h:264
QmitkStdMultiWidget::LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4
Definition: QmitkStdMultiWidget.h:285
mitk::BoolProperty::New
static Pointer New()
mitk::SliceNavigationController::Sagittal
Definition: mitkSliceNavigationController.h:169
QmitkStdMultiWidget::SetWidgetPlanesRotationLocked
void SetWidgetPlanesRotationLocked(bool locked)
Definition: QmitkStdMultiWidget.cpp:1720
QmitkStdMultiWidget::SetWidgetPlaneVisibility
void SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer=NULL)
Definition: QmitkStdMultiWidget.cpp:1685
QmitkStdMultiWidget::GetCrossPosition
const mitk::Point3D GetCrossPosition() const
Definition: QmitkStdMultiWidget.cpp:1458
QmitkStdMultiWidget::GetDecorationColor
mitk::Color GetDecorationColor(unsigned int widgetNumber)
GetDecorationColorForWidget Get the color for annotation, crosshair and rectangle.
Definition: QmitkStdMultiWidget.cpp:344
offset
static Vector3D offset
Definition: mitkAffineTransformBaseTest.cpp:27
QmitkStdMultiWidget::LAYOUT_DEFAULT
Definition: QmitkStdMultiWidget.h:275
mitk::ColorProperty
The ColorProperty class RGB color property.
Definition: mitkColorProperty.h:51
mitk::BaseRenderer::WorldToDisplay
void WorldToDisplay(const Point3D &worldIndex, Point2D &displayPoint) const
This method converts a 3D world index to the display point using the geometry of the renderWindow...
Definition: mitkBaseRenderer.cpp:703
QmitkStdMultiWidget::CORONAL
Definition: QmitkStdMultiWidget.h:295
mitk::SliceNavigationController::ConnectGeometryTimeEvent
void ConnectGeometryTimeEvent(T *receiver, bool connectSendEvent=true)
Definition: mitkSliceNavigationController.h:355
mitkWidget1
mitk::RenderWindow::Pointer mitkWidget1
Example of a NON QT DEPENDENT MITK RENDERING APPLICATION.
Definition: QtFreeRender.cpp:54
mitk::RenderingManager::SetRenderWindowFocus
void SetRenderWindowFocus(vtkRenderWindow *focusWindow)
Sets a flag to the given renderwindow to indicated that it has the focus e.g. has been clicked recent...
Definition: mitkRenderingManager.cpp:727
QmitkStdMultiWidget::EnsureDisplayContainsPoint
void EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
Definition: QmitkStdMultiWidget.cpp:1487
mitk::RenderingManager
Manager for coordinating the rendering process.
Definition: mitkRenderingManager.h:79
mitk::DataNode::New
static Pointer New()
QmitkStdMultiWidget::moveEvent
void moveEvent(QMoveEvent *e) override
Definition: QmitkStdMultiWidget.cpp:1429
QmitkRenderWindow::GetActivateMenuWidgetFlag
bool GetActivateMenuWidgetFlag()
Definition: QmitkRenderWindow.h:84
mitk::RenderingManager::GetInstance
static RenderingManager * GetInstance()
Definition: mitkRenderingManager.cpp:101
mitk::BaseRenderer::GetCameraController
virtual CameraController * GetCameraController()
QmitkStdMultiWidget::GetRenderWindow4
QmitkRenderWindow * GetRenderWindow4() const
Definition: QmitkStdMultiWidget.cpp:1453
QmitkStdMultiWidget::mitkWidget3
QmitkRenderWindow * mitkWidget3
Definition: QmitkStdMultiWidget.h:262
mitk::Image
Image class for storing images.
Definition: mitkImage.h:76
mitkWidget3
mitk::RenderWindow::Pointer mitkWidget3
Definition: QtFreeRender.cpp:56
mitk::SliceNavigationController::GetCurrentPlaneGeometry
const mitk::PlaneGeometry * GetCurrentPlaneGeometry()
Returns the currently selected Plane in the current BaseGeometry (if existent).
Definition: mitkSliceNavigationController.cpp:535
QmitkRenderWindow
MITK implementation of the QVTKWidget.
Definition: QmitkRenderWindow.h:39
QmitkStdMultiWidget::MoveCrossToPosition
void MoveCrossToPosition(const mitk::Point3D &newPosition)
Definition: QmitkStdMultiWidget.cpp:1503
mitk::RenderWindowBase::GetRenderer
virtual mitk::VtkPropRenderer * GetRenderer()
Definition: mitkRenderWindowBase.cpp:113
mitk::RenderingManager::ForceImmediateUpdate
void ForceImmediateUpdate(vtkRenderWindow *renderWindow)
Definition: mitkRenderingManager.cpp:216
QmitkStdMultiWidget::SetDataStorage
void SetDataStorage(mitk::DataStorage *ds)
Definition: QmitkStdMultiWidget.cpp:1288
mitk::BaseRenderer::Standard2D
Definition: mitkBaseRenderer.h:116
mitk::BaseRenderer::GetViewportSize
virtual int * GetViewportSize() const
Definition: mitkBaseRenderer.cpp:501
mitk::Color
itk::RGBPixel< float > Color
Color Standard RGB color typedef (float)
Definition: mitkColorProperty.h:39
QmitkLevelWindowWidget::SetDataStorage
void SetDataStorage(mitk::DataStorage *ds)
Definition: QmitkLevelWindowWidget.cpp:29
QmitkStdMultiWidget::m_TimeNavigationController
mitk::SliceNavigationController * m_TimeNavigationController
Definition: QmitkStdMultiWidget.h:370
QmitkStdMultiWidget::GetWidgetPlane1
mitk::DataNode::Pointer GetWidgetPlane1()
Access node of widget plane 1.
Definition: QmitkStdMultiWidget.cpp:1996
mitk::BaseRenderer::GetTimeStep
virtual unsigned int GetTimeStep() const
QmitkStdMultiWidget::WidgetPlanesRotationLinked
void WidgetPlanesRotationLinked(bool)
mitk::StatusBar::GetInstance
static StatusBar * GetInstance()
static method to get the GUI dependent StatusBar-instance so the methods DisplayText, etc. can be called No reference counting, cause of decentral static use!
Definition: mitkStatusBar.cpp:144
QmitkStdMultiWidget::GetWidgetPlane2
mitk::DataNode::Pointer GetWidgetPlane2()
Access node of widget plane 2.
Definition: QmitkStdMultiWidget.cpp:2001
QmitkStdMultiWidget::AXIAL
Definition: QmitkStdMultiWidget.h:293
QmitkStdMultiWidget::wheelEvent
void wheelEvent(QWheelEvent *e) override
Definition: QmitkStdMultiWidget.cpp:1420
QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing
void SetWidgetPlaneModeToSlicing(bool activate)
Definition: QmitkStdMultiWidget.cpp:1796
mitk::RenderingManager::RequestUpdate
void RequestUpdate(vtkRenderWindow *renderWindow)
Definition: mitkRenderingManager.cpp:193
QmitkStdMultiWidget::GetWidgetPlane3
mitk::DataNode::Pointer GetWidgetPlane3()
Access node of widget plane 3.
Definition: QmitkStdMultiWidget.cpp:2006
QmitkStdMultiWidget::SetCornerAnnotationVisibility
void SetCornerAnnotationVisibility(bool visibility)
Definition: QmitkStdMultiWidget.cpp:628
mitk::IntProperty::New
static Pointer New()
QmitkStdMultiWidget::m_ParentNodeForGeometryPlanes
mitk::DataNode::Pointer m_ParentNodeForGeometryPlanes
m_ParentNodeForGeometryPlanes This helper object is added to the datastorage and contains the 3 plane...
Definition: QmitkStdMultiWidget.h:384
mitk::BaseRenderer::GetName
const char * GetName() const
get the name of the Renderer
Definition: mitkBaseRenderer.h:355
QmitkStdMultiWidget::mousePressEvent
void mousePressEvent(QMouseEvent *e) override
Definition: QmitkStdMultiWidget.cpp:1425
mitk::SliceNavigationController::Frontal
Definition: mitkSliceNavigationController.h:170
QmitkStdMultiWidget::PLANE_MODE_SLICING
Definition: QmitkStdMultiWidget.h:269
mitk::PlaneGeometry::IntersectionLine
bool IntersectionLine(const PlaneGeometry *plane, Line3D &crossline) const
Calculate the intersecting line of two planes.
Definition: mitkPlaneGeometry.cpp:663
QmitkStdMultiWidget::SetWidgetPlanesVisibility
void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer=NULL)
Definition: QmitkStdMultiWidget.cpp:1695
QmitkStdMultiWidget::SetGradientBackgroundColorForRenderWindow
void SetGradientBackgroundColorForRenderWindow(const mitk::Color &upper, const mitk::Color &lower, unsigned int widgetNumber)
SetGradientBackgroundColorForRenderWindow background for a widget.
Definition: QmitkStdMultiWidget.cpp:1760
mitk::StatusBar::DisplayGreyValueText
void DisplayGreyValueText(const char *t)
Definition: mitkStatusBar.cpp:69
QmitkStdMultiWidget::m_GradientBackgroundColors
std::pair< mitk::Color, mitk::Color > m_GradientBackgroundColors[4]
m_GradientBackgroundColors Contains the colors of the gradient background.
Definition: QmitkStdMultiWidget.h:398
QmitkStdMultiWidget::LAYOUT_BIG_3D
Definition: QmitkStdMultiWidget.h:278
QmitkStdMultiWidget::RemovePlanesFromDataStorage
void RemovePlanesFromDataStorage()
called when the StdMultiWidget is closed to remove the 3 widget planes and the helper node from the D...
Definition: QmitkStdMultiWidget.cpp:422
QmitkStdMultiWidget::GetRenderWindow3
QmitkRenderWindow * GetRenderWindow3() const
Definition: QmitkStdMultiWidget.cpp:1448
QmitkStdMultiWidget::GetRenderWindow
QmitkRenderWindow * GetRenderWindow(unsigned int number)
GetRenderWindow convinience method to get a widget.
Definition: QmitkStdMultiWidget.cpp:641
mitk::RenderWindowBase::GetSliceNavigationController
virtual mitk::SliceNavigationController * GetSliceNavigationController()
Definition: mitkRenderWindowBase.cpp:87
QmitkRenderWindow::ActivateMenuWidget
void ActivateMenuWidget(bool state, QmitkStdMultiWidget *stdMultiWidget=0)
Definition: QmitkRenderWindow.cpp:249
mitkPixelTypeMultiplex5
#define mitkPixelTypeMultiplex5(function, ptype, param1, param2, param3, param4, param5)
Definition: mitkPixelTypeMultiplex.h:150
mitk::PlaneGeometry
Describes a two-dimensional, rectangular plane.
Definition: mitkPlaneGeometry.h:80
mitk::DataNode::SetProperty
void SetProperty(const char *propertyKey, BaseProperty *property, const mitk::BaseRenderer *renderer=nullptr)
Set the property (instance of BaseProperty) with key propertyKey in the PropertyList of the renderer ...
Definition: mitkDataNode.cpp:473
tmp1
US_USE_NAMESPACE std::string tmp1
Definition: usServiceProperties.cpp:76
m_TimeNavigationController
mitk::SliceNavigationController * m_TimeNavigationController
Definition: QtFreeRender.cpp:65
mitk::SliceNavigationController::SetSliceLocked
virtual void SetSliceLocked(bool _arg)
Feature option to lock planes during mouse interaction. This option flag disables the mouse event whi...
mitk::CameraController::MoveCameraToPoint
void MoveCameraToPoint(const Point2D &planePoint)
MoveCameraToPoint Move camera so that the point on the plane is in the view center.
Definition: mitkCameraController.cpp:205
QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel
void SetWidgetPlaneModeToSwivel(bool activate)
Definition: QmitkStdMultiWidget.cpp:1812
QmitkStdMultiWidget::SAGITTAL
Definition: QmitkStdMultiWidget.h:294
mitk::BaseRenderer::GetVtkRenderer
vtkRenderer * GetVtkRenderer() const
Definition: mitkBaseRenderer.h:128
QmitkStdMultiWidget::m_LogoRendering
mitk::LogoOverlay::Pointer m_LogoRendering
Definition: QmitkStdMultiWidget.h:365
QmitkStdMultiWidget::m_DataStorage
mitk::DataStorage::Pointer m_DataStorage
Definition: QmitkStdMultiWidget.h:372
mitk::BaseRenderer::RenderingMode::Type
Type
Definition: mitkBaseRenderer.h:80
QmitkStdMultiWidget::SetDecorationProperties
void SetDecorationProperties(std::string text, mitk::Color color, int widgetNumber)
SetCornerAnnotation Create a corner annotation for a widget.
Definition: QmitkStdMultiWidget.cpp:602
mitk::RenderingManager::InitializeViewsByBoundingObjects
virtual void InitializeViewsByBoundingObjects(const DataStorage *)
Initializes the renderwindows by the aggregated geometry of all objects that are held in the data sto...
Definition: mitkRenderingManager.cpp:281
mitk::LogoOverlay::New
static Pointer New()
mitk::StringProperty::New
static Pointer New()
QmitkStdMultiWidget::LAYOUT_WIDGET2
Definition: QmitkStdMultiWidget.h:280
mitk::RenderingManager::RequestUpdateAll
void RequestUpdateAll(RequestType type=REQUEST_UPDATE_ALL)
Definition: mitkRenderingManager.cpp:251
QmitkStdMultiWidget::QmitkStdMultiWidget
QmitkStdMultiWidget(QWidget *parent=0, Qt::WindowFlags f=0, mitk::RenderingManager *renderingManager=0, mitk::BaseRenderer::RenderingMode::Type renderingMode=mitk::BaseRenderer::RenderingMode::Standard, const QString &name="stdmulti")
Definition: QmitkStdMultiWidget.cpp:52
QmitkStdMultiWidget::m_DecorationColorWidget4
mitk::Color m_DecorationColorWidget4
m_DecorationColorWidget4 color for annotation and rectangle of widget 4.
Definition: QmitkStdMultiWidget.h:392
mitk::DataNode
Class for nodes of the DataTree.
Definition: mitkDataNode.h:66
QmitkStdMultiWidget::SetWidgetPlaneModeToRotation
void SetWidgetPlaneModeToRotation(bool activate)
Definition: QmitkStdMultiWidget.cpp:1804
QmitkStdMultiWidget::LAYOUT_ROW_WIDGET_3_AND_4
Definition: QmitkStdMultiWidget.h:283
QmitkStdMultiWidget::QmitkStdMultiWidgetLayout
QHBoxLayout * QmitkStdMultiWidgetLayout
Definition: QmitkStdMultiWidget.h:358
mitk::OverlayManager::New
static Pointer New()
QmitkStdMultiWidget::SetWidgetPlanesRotationLinked
void SetWidgetPlanesRotationLinked(bool link)
Definition: QmitkStdMultiWidget.cpp:1728
QmitkStdMultiWidget::SetWidgetPlanesLocked
void SetWidgetPlanesLocked(bool locked)
Definition: QmitkStdMultiWidget.cpp:1712
QmitkStdMultiWidget::LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4
Definition: QmitkStdMultiWidget.h:286
mitk::New
static itkEventMacro(BoundingShapeInteractionEvent, itk::AnyEvent) class MITKBOUNDINGSHAPE_EXPORT BoundingShapeInteractor Pointer New()
Basic interaction methods for mitk::GeometryData.