mitk: QmitkMeasurement.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003  Program:   Medical Imaging & Interaction Toolkit
00004  Language:  C++
00005  Date:      $Date$
00006  Version:   $Revision: 15412 $
00007 
00008  Copyright (c) German Cancer Research Center, Division of Medical and
00009  Biological Informatics. All rights reserved.
00010  See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012  This software is distributed WITHOUT ANY WARRANTY; without even
00013  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014  PURPOSE.  See the above copyright notices for more information.
00015 
00016  =========================================================================*/
00017 
00018 #include <berryIEditorPart.h>
00019 #include <berryIWorkbenchPage.h>
00020 #include <berryPlatform.h>
00021 
00022 #include "mitkGlobalInteraction.h"
00023 #include "mitkPointSet.h"
00024 #include "mitkProperties.h"
00025 #include "mitkStringProperty.h"
00026 #include "mitkIDataStorageService.h"
00027 #include "mitkDataNodeObject.h"
00028 #include <mitkNodePredicateProperty.h>
00029 #include <mitkNodePredicateData.h>
00030 #include <mitkNodePredicateNot.h>
00031 #include <mitkNodePredicateAnd.h>
00032 #include <mitkDataNodeSelection.h>
00033 
00034 #include "mitkPlanarCircle.h"
00035 #include "mitkPlanarPolygon.h"
00036 #include "mitkPlanarAngle.h"
00037 #include "mitkPlanarRectangle.h"
00038 #include "mitkPlanarLine.h"
00039 #include "mitkPlanarCross.h"
00040 #include "mitkPlanarFourPointAngle.h"
00041 #include "mitkPlanarFigureInteractor.h"
00042 #include "mitkPlaneGeometry.h"
00043 #include "QmitkPlanarFiguresTableModel.h"
00044 
00045 #include "QmitkMeasurement.h"
00046 #include <QmitkRenderWindow.h>
00047 
00048 #include <QGridLayout>
00049 #include <QMainWindow>
00050 #include <QToolBar>
00051 #include <QLabel>
00052 #include <QTableView>
00053 #include <QClipboard>
00054 #include <QTextBrowser>
00055 
00056 #include <QmitkDataStorageTableModel.h>
00057 #include "mitkNodePredicateDataType.h"
00058 #include "mitkPlanarFigure.h"
00059 
00060 #include <vtkTextProperty.h>
00061 #include <vtkRenderer.h>
00062 #include <vtkCornerAnnotation.h>
00063 #include <mitkVtkLayerController.h>
00064 
00065 QmitkMeasurement::QmitkMeasurement() :
00066   m_Layout(0), m_DrawActionsToolBar(0),
00067       m_DrawActionsGroup(0), m_MeasurementInfoRenderer(0),
00068       m_MeasurementInfoAnnotation(0), m_SelectedPlanarFigures(0),
00069       m_SelectedImageNode(),
00070       m_LineCounter(0), m_PathCounter(0),
00071       m_AngleCounter(0), m_FourPointAngleCounter(0), m_EllipseCounter(0),
00072       m_RectangleCounter(0), m_PolygonCounter(0),
00073       m_CurrentFigureNodeInitialized(false), m_LastRenderWindow(0)
00074 {
00075 
00076 }
00077 
00078 QmitkMeasurement::~QmitkMeasurement()
00079 {
00080 
00081   m_MeasurementInfoRenderer->Delete();
00082 
00083   this->GetDefaultDataStorage()->AddNodeEvent -= mitk::MessageDelegate1<QmitkMeasurement
00084     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeAddedInDataStorage );
00085 
00086   m_SelectedPlanarFigures->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkMeasurement
00087     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeChanged ) );
00088 
00089   m_SelectedPlanarFigures->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkMeasurement
00090     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeRemoved ) );
00091 
00092   m_SelectedPlanarFigures->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkMeasurement
00093     , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkMeasurement::PropertyChanged ) );
00094 
00095   m_SelectedImageNode->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkMeasurement
00096     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeChanged ) );
00097 
00098   m_SelectedImageNode->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkMeasurement
00099     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeRemoved ) );
00100 
00101   m_SelectedImageNode->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkMeasurement
00102     , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkMeasurement::PropertyChanged ) );
00103 }
00104 
00105 void QmitkMeasurement::CreateQtPartControl(QWidget* parent)
00106 {
00107   m_MeasurementInfoRenderer = vtkRenderer::New();
00108   m_MeasurementInfoAnnotation = vtkCornerAnnotation::New();
00109   vtkTextProperty *textProp = vtkTextProperty::New();
00110 
00111   m_MeasurementInfoAnnotation->SetMaximumFontSize(12);
00112   textProp->SetColor(1.0, 1.0, 1.0);
00113   m_MeasurementInfoAnnotation->SetTextProperty(textProp);
00114 
00115   m_MeasurementInfoRenderer->AddActor(m_MeasurementInfoAnnotation);
00116   m_DrawActionsToolBar = new QToolBar;
00117   m_DrawActionsGroup = new QActionGroup(this);
00118   m_DrawActionsGroup->setExclusive(true);
00119 
00120   //# add actions
00121   QAction* currentAction = m_DrawActionsToolBar->addAction(QIcon(
00122       ":/measurement/line.png"), "Draw Line");
00123   m_DrawLine = currentAction;
00124   m_DrawLine->setCheckable(true);
00125   m_DrawActionsToolBar->addAction(currentAction);
00126   m_DrawActionsGroup->addAction(currentAction);
00127   QObject::connect( currentAction, SIGNAL( triggered(bool) )
00128       , this, SLOT( ActionDrawLineTriggered(bool) ) );
00129 
00130   currentAction = m_DrawActionsToolBar->addAction(QIcon(
00131       ":/measurement/path.png"), "Draw Path");
00132   m_DrawPath = currentAction;
00133   m_DrawPath->setCheckable(true);
00134   m_DrawActionsToolBar->addAction(currentAction);
00135   m_DrawActionsGroup->addAction(currentAction);
00136   QObject::connect( currentAction, SIGNAL( triggered(bool) )
00137       , this, SLOT( ActionDrawPathTriggered(bool) ) );
00138 
00139   currentAction = m_DrawActionsToolBar->addAction(QIcon(
00140       ":/measurement/angle.png"), "Draw Angle");
00141   m_DrawAngle = currentAction;
00142   m_DrawAngle->setCheckable(true);
00143   m_DrawActionsToolBar->addAction(currentAction);
00144   m_DrawActionsGroup->addAction(currentAction);
00145   QObject::connect( currentAction, SIGNAL( triggered(bool) )
00146       , this, SLOT( ActionDrawAngleTriggered(bool) ) );
00147 
00148   currentAction = m_DrawActionsToolBar->addAction(QIcon(
00149       ":/measurement/four-point-angle.png"), "Draw Four Point Angle");
00150   m_DrawFourPointAngle = currentAction;
00151   m_DrawFourPointAngle->setCheckable(true);
00152   m_DrawActionsToolBar->addAction(currentAction);
00153   m_DrawActionsGroup->addAction(currentAction);
00154   QObject::connect( currentAction, SIGNAL( triggered(bool) )
00155       , this, SLOT( ActionDrawFourPointAngleTriggered(bool) ) );
00156 
00157   currentAction = m_DrawActionsToolBar->addAction(QIcon(
00158       ":/measurement/circle.png"), "Draw Circle");
00159   m_DrawEllipse = currentAction;
00160   m_DrawEllipse->setCheckable(true);
00161   m_DrawActionsToolBar->addAction(currentAction);
00162   m_DrawActionsGroup->addAction(currentAction);
00163   QObject::connect( currentAction, SIGNAL( triggered(bool) )
00164       , this, SLOT( ActionDrawEllipseTriggered(bool) ) );
00165 
00166   currentAction = m_DrawActionsToolBar->addAction(QIcon(
00167       ":/measurement/rectangle.png"), "Draw Rectangle");
00168   m_DrawRectangle = currentAction;
00169   m_DrawRectangle->setCheckable(true);
00170   m_DrawActionsToolBar->addAction(currentAction);
00171   m_DrawActionsGroup->addAction(currentAction);
00172   QObject::connect( currentAction, SIGNAL( triggered(bool) )
00173       , this, SLOT( ActionDrawRectangleTriggered(bool) ) );
00174 
00175   currentAction = m_DrawActionsToolBar->addAction(QIcon(
00176       ":/measurement/polygon.png"), "Draw Polygon");
00177   m_DrawPolygon = currentAction;
00178   m_DrawPolygon->setCheckable(true);
00179   m_DrawActionsToolBar->addAction(currentAction);
00180   m_DrawActionsGroup->addAction(currentAction);
00181   QObject::connect( currentAction, SIGNAL( triggered(bool) )
00182       , this, SLOT( ActionDrawPolygonTriggered(bool) ) );
00183 
00184   QLabel* selectedImageLabel = new QLabel("Selected Image: ");
00185   m_SelectedImage = new QLabel;
00186   m_SelectedImage->setStyleSheet("font-weight: bold;");
00187   m_SelectedPlanarFiguresText = new QTextBrowser;
00188 
00189   m_CopyToClipboard = new QPushButton("Copy to Clipboard");
00190   QObject::connect( m_CopyToClipboard, SIGNAL( clicked(bool) )
00191       , this, SLOT( CopyToClipboard(bool) ) );
00192 
00193   m_Layout = new QGridLayout;
00194   m_Layout->addWidget(selectedImageLabel, 0, 0, 1, 1);
00195   m_Layout->addWidget(m_SelectedImage, 0, 1, 1, 1);
00196   m_Layout->addWidget(m_DrawActionsToolBar, 1, 0, 1, 2);
00197   m_Layout->addWidget(m_SelectedPlanarFiguresText, 2, 0, 1, 2);
00198   m_Layout->addWidget(m_CopyToClipboard, 3, 0, 1, 2);
00199   m_Layout->setRowStretch(0, 1);
00200   m_Layout->setRowStretch(1, 1);
00201   m_Layout->setRowStretch(2, 10);
00202   m_Layout->setRowStretch(3, 1);
00203   m_Layout->setContentsMargins(2, 2, 2, 2);
00204 
00205   parent->setLayout(m_Layout);
00206 
00207 
00208   m_SelectedPlanarFigures = mitk::DataStorageSelection::New(this->GetDefaultDataStorage(), false);
00209 
00210   m_SelectedPlanarFigures->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkMeasurement
00211     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeChanged ) );
00212 
00213   m_SelectedPlanarFigures->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkMeasurement
00214     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeRemoved ) );
00215 
00216   m_SelectedPlanarFigures->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkMeasurement
00217     , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkMeasurement::PropertyChanged ) );
00218 
00219   m_SelectedImageNode = mitk::DataStorageSelection::New(this->GetDefaultDataStorage(), false);
00220 
00221   m_SelectedImageNode->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkMeasurement
00222     , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkMeasurement::PropertyChanged ) );
00223 
00224   m_SelectedImageNode->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkMeasurement
00225     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeChanged ) );
00226 
00227   m_SelectedImageNode->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkMeasurement
00228     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeRemoved ) );
00229 
00230   this->GetDefaultDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkMeasurement
00231     , const mitk::DataNode*>( this, &QmitkMeasurement::NodeAddedInDataStorage ) );
00232 
00233 }
00234 
00235 void QmitkMeasurement::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
00236 {
00237   if ( nodes.empty() ) return;
00238 
00239   m_SelectedImageNode->RemoveAllNodes();
00240 
00241   mitk::DataNode* _DataNode = 0;
00242   mitk::BaseData* _BaseData;
00243   mitk::PlanarFigure* _PlanarFigure;
00244   mitk::Image* selectedImage;
00245   m_SelectedPlanarFigures->RemoveAllNodes();
00246 
00247   for (std::vector<mitk::DataNode*>::iterator it = nodes.begin();
00248       it != nodes.end();
00249       ++it)
00250   {
00251     _PlanarFigure = 0;
00252 
00253     _DataNode = *it;
00254 
00255     if (!_DataNode)
00256       continue;
00257 
00258     _BaseData = _DataNode->GetData();
00259 
00260     if (!_BaseData)
00261       continue;
00262 
00263     // planar figure selected
00264     if ((_PlanarFigure = dynamic_cast<mitk::PlanarFigure *> (_BaseData)))
00265     {
00266       // add to the selected planar figures
00267       m_SelectedPlanarFigures->AddNode(_DataNode);
00268       // take parent image as the selected image
00269       mitk::DataStorage::SetOfObjects::ConstPointer parents =
00270           this->GetDefaultDataStorage()->GetSources(_DataNode);
00271       if (parents->size() > 0)
00272       {
00273         mitk::DataNode::Pointer parent = parents->front();
00274         if ((selectedImage = dynamic_cast<mitk::Image *> (parent->GetData())))
00275         {
00276           *m_SelectedImageNode = parent;
00277         }
00278       }
00279 
00280     }
00281     else if ((selectedImage = dynamic_cast<mitk::Image *> (_BaseData)))
00282     {
00283       *m_SelectedImageNode = _DataNode;
00284       /*mitk::RenderingManager::GetInstance()->InitializeViews(
00285         selectedImage->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );*/
00286     }
00287   } // end for
00288 
00289   this->PlanarFigureSelectionChanged();
00290 }
00291 
00292 void QmitkMeasurement::PlanarFigureSelectionChanged()
00293 {
00294   if ( !this->IsActivated() ) return;
00295 
00296   if (m_SelectedImageNode->GetNode().IsNotNull())
00297   {
00298     mitk::Image* selectedImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
00299     if(selectedImage && selectedImage->GetDimension() > 3)
00300     {
00301       m_SelectedImageNode->RemoveAllNodes();
00302       m_SelectedImage->setText( "4D images are not supported." );
00303       m_DrawActionsToolBar->setEnabled(false);
00304     }
00305     else
00306     {
00307       m_SelectedImage->setText(QString::fromStdString(
00308           m_SelectedImageNode->GetNode()->GetName()));
00309       m_DrawActionsToolBar->setEnabled(true);
00310     }
00311   }
00312   else
00313   {
00314     m_SelectedImage->setText(
00315         "None. Please select an image.");
00316 
00317     m_DrawActionsToolBar->setEnabled(false);
00318   }
00319 
00320   if (m_SelectedPlanarFigures->GetSize() == 0){
00321     this->SetMeasurementInfoToRenderWindow("", this->GetActiveStdMultiWidget()->GetRenderWindow1());
00322     this->SetMeasurementInfoToRenderWindow("", this->GetActiveStdMultiWidget()->GetRenderWindow2());
00323     this->SetMeasurementInfoToRenderWindow("", this->GetActiveStdMultiWidget()->GetRenderWindow3());
00324     this->SetMeasurementInfoToRenderWindow("", this->GetActiveStdMultiWidget()->GetRenderWindow4());
00325   }
00326 
00327   unsigned int j = 1;
00328   mitk::PlanarFigure* _PlanarFigure = 0;
00329   mitk::PlanarAngle* planarAngle = 0;
00330   mitk::PlanarFourPointAngle* planarFourPointAngle = 0;
00331   mitk::DataNode::Pointer node = 0;
00332   m_SelectedPlanarFiguresText->clear();
00333   QString infoText;
00334   QString plainInfoText;
00335   std::vector<mitk::DataNode*> nodes = m_SelectedPlanarFigures->GetNodes();
00336 
00337   for (std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it
00338       != nodes.end(); ++it, ++j)
00339   {
00340     plainInfoText.clear();
00341     node = *it;
00342     if(j>1)
00343       infoText.append("<br />");
00344 
00345     infoText.append(QString("<b>%1</b><hr />").arg(QString::fromStdString(
00346         node->GetName())));
00347     plainInfoText.append(QString("%1").arg(QString::fromStdString(
00348         node->GetName())));
00349 
00350     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
00351 
00352     planarAngle = dynamic_cast<mitk::PlanarAngle*> (_PlanarFigure);
00353     if(!planarAngle)
00354     {
00355       planarFourPointAngle = dynamic_cast<mitk::PlanarFourPointAngle*> (_PlanarFigure);
00356     }
00357 
00358     if(!_PlanarFigure)
00359       continue;
00360 
00361     double featureQuantity = 0.0;
00362     for (unsigned int i = 0; i < _PlanarFigure->GetNumberOfFeatures(); ++i)
00363     {
00364       if ( !_PlanarFigure->IsFeatureActive( i ) ) continue;
00365 
00366       featureQuantity = _PlanarFigure->GetQuantity(i);
00367       if ((planarAngle && i == planarAngle->FEATURE_ID_ANGLE)
00368           || (planarFourPointAngle && i == planarFourPointAngle->FEATURE_ID_ANGLE))
00369         featureQuantity = featureQuantity * 180 / vnl_math::pi;
00370 
00371       infoText.append(
00372           QString("<i>%1</i>: %2 %3") .arg(QString(
00373               _PlanarFigure->GetFeatureName(i))) .arg(featureQuantity, 0, 'f',
00374               2) .arg(QString(_PlanarFigure->GetFeatureUnit(i))));
00375 
00376       plainInfoText.append(
00377           QString("\n%1: %2 %3") .arg(QString(_PlanarFigure->GetFeatureName(i))) .arg(
00378               featureQuantity, 0, 'f', 2) .arg(QString(
00379               _PlanarFigure->GetFeatureUnit(i))));
00380 
00381       if(i+1 != _PlanarFigure->GetNumberOfFeatures())
00382         infoText.append("<br />");
00383     }
00384 
00385     if (j != nodes.size())
00386       infoText.append("<br />");
00387   }
00388 
00389   m_SelectedPlanarFiguresText->setHtml(infoText);
00390 
00391   // for the last selected planar figure ...
00392   if (_PlanarFigure)
00393   {
00394     const mitk::PlaneGeometry
00395         * _PlaneGeometry =
00396             dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
00397 
00398     QmitkRenderWindow* selectedRenderWindow = 0;
00399     QmitkRenderWindow* RenderWindow1 =
00400         this->GetActiveStdMultiWidget()->GetRenderWindow1();
00401     QmitkRenderWindow* RenderWindow2 =
00402         this->GetActiveStdMultiWidget()->GetRenderWindow2();
00403     QmitkRenderWindow* RenderWindow3 =
00404         this->GetActiveStdMultiWidget()->GetRenderWindow3();
00405     QmitkRenderWindow* RenderWindow4 =
00406         this->GetActiveStdMultiWidget()->GetRenderWindow4();
00407     bool PlanarFigureInitializedWindow = false;
00408 
00409     // find initialized renderwindow
00410     if (node->GetBoolProperty("PlanarFigureInitializedWindow",
00411         PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
00412       selectedRenderWindow = RenderWindow1;
00413     if (!selectedRenderWindow && node->GetBoolProperty(
00414         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
00415         RenderWindow2->GetRenderer()))
00416       selectedRenderWindow = RenderWindow2;
00417     if (!selectedRenderWindow && node->GetBoolProperty(
00418         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
00419         RenderWindow3->GetRenderer()))
00420       selectedRenderWindow = RenderWindow3;
00421     if (!selectedRenderWindow && node->GetBoolProperty(
00422         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
00423         RenderWindow4->GetRenderer()))
00424       selectedRenderWindow = RenderWindow4;
00425 
00426     // make node visible
00427     if (selectedRenderWindow)
00428     {
00429       mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
00430       //selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
00431           //centerP, _PlaneGeometry->GetNormal());
00432       selectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
00433           centerP);
00434 
00435       // now paint infos also on renderwindow
00436       this->SetMeasurementInfoToRenderWindow(plainInfoText, selectedRenderWindow);
00437     }
00438   }
00439   // no last planarfigure
00440   else
00441     this->SetMeasurementInfoToRenderWindow("", 0);
00442 
00443   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00444 }
00445 
00446 void QmitkMeasurement::NodeAddedInDataStorage(const mitk::DataNode* node)
00447 {
00448   if(!m_Visible)
00449     return;
00450   mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
00451   mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(nonConstNode->GetData());
00452   if(figure)
00453   {
00454     mitk::PlanarFigureInteractor::Pointer figureInteractor
00455       = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
00456 
00457     if(figureInteractor.IsNull())
00458       figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", nonConstNode);
00459 
00460     // remove old interactor if present
00461     if( m_CurrentFigureNode.IsNotNull() && m_CurrentFigureNodeInitialized == false )
00462     {
00463       mitk::Interactor::Pointer oldInteractor = m_CurrentFigureNode->GetInteractor();
00464       if(oldInteractor.IsNotNull())
00465         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(oldInteractor);
00466 
00467       this->GetDefaultDataStorage()->Remove(m_CurrentFigureNode);
00468     }
00469 
00470     mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
00471   }
00472 }
00473 
00474 
00475 void QmitkMeasurement::PlanarFigureInitialized()
00476 {
00477   if(m_CurrentFigureNode.IsNull())
00478     return;
00479 
00480   m_CurrentFigureNodeInitialized = true;
00481 
00482   this->PlanarFigureSelectionChanged();
00483 
00484   m_DrawLine->setChecked(false);
00485   m_DrawPath->setChecked(false);
00486   m_DrawAngle->setChecked(false);
00487   m_DrawFourPointAngle->setChecked(false);
00488   m_DrawEllipse->setChecked(false);
00489   m_DrawRectangle->setChecked(false);
00490   m_DrawPolygon->setChecked(false);
00491 }
00492 
00493 
00494 void QmitkMeasurement::PlanarFigureSelected( itk::Object* object, const itk::EventObject& event )
00495 {
00496   // Mark to-be-edited PlanarFigure as selected
00497   mitk::PlanarFigure* figure = dynamic_cast< mitk::PlanarFigure* >( object );
00498   if ( figure != NULL )
00499   {
00500     // Get node corresponding to PlanarFigure
00501     mitk::DataNode* figureNode = this->GetDefaultDataStorage()->GetNode( 
00502       mitk::NodePredicateData::New( figure ) );
00503 
00504     // Select this node (and deselect all others)
00505     std::vector< mitk::DataNode* > selectedNodes = this->GetDataManagerSelection();
00506     for ( unsigned int i = 0; i < selectedNodes.size(); i++ )
00507     {
00508       selectedNodes[i]->SetSelected( false );
00509     }
00510     selectedNodes = m_SelectedPlanarFigures->GetNodes();
00511     for ( unsigned int i = 0; i < selectedNodes.size(); i++ )
00512     {
00513       selectedNodes[i]->SetSelected( false );
00514     }
00515     figureNode->SetSelected( true );
00516 
00517     m_CurrentFigureNode = figureNode;
00518 
00519     *m_SelectedPlanarFigures = figureNode;
00520 
00521 
00522     // Re-initialize after selecting new PlanarFigure
00523     this->PlanarFigureSelectionChanged();
00524   }
00525 }
00526 
00527 
00528 mitk::DataNode::Pointer QmitkMeasurement::DetectTopMostVisibleImage()
00529 {
00530   // get all images from the data storage
00531   mitk::DataStorage::SetOfObjects::ConstPointer Images = this->GetDefaultDataStorage()->GetSubset( mitk::NodePredicateDataType::New("Image") );
00532 
00533   mitk::DataNode::Pointer currentNode( m_SelectedImageNode->GetNode() );
00534   int maxLayer = itk::NumericTraits<int>::min();
00535 
00536   // iterate over selection
00537   for (mitk::DataStorage::SetOfObjects::ConstIterator sofIt = Images->Begin(); sofIt != Images->End(); ++sofIt)
00538   {
00539     mitk::DataNode::Pointer node = sofIt->Value();
00540     if ( node.IsNull() )
00541       continue;
00542     if (node->IsVisible(NULL) == false)
00543       continue;
00544     int layer = 0;
00545     node->GetIntProperty("layer", layer);
00546     if ( layer < maxLayer )
00547       continue;
00548 
00549     currentNode = node;
00550   }
00551 
00552   return currentNode;
00553 }
00554 
00555 void QmitkMeasurement::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
00556   const char *propertyKey, mitk::BaseProperty *property )
00557 {
00558   if ( m_CurrentFigureNode.IsNotNull() )
00559   {
00560     m_CurrentFigureNode->GetData()->RemoveObserver( m_EndPlacementObserverTag );
00561   }
00562 
00563   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
00564   newNode->SetName(name.toStdString());
00565   newNode->SetData(figure);
00566 
00567   // Add custom property, if available
00568   if ( (propertyKey != NULL) && (property != NULL) )
00569   {
00570     newNode->AddProperty( propertyKey, property );
00571   }
00572 
00573   // add observer for event when figure has been placed
00574   typedef itk::SimpleMemberCommand< QmitkMeasurement > SimpleCommandType;
00575   SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
00576   initializationCommand->SetCallbackFunction( this, &QmitkMeasurement::PlanarFigureInitialized );
00577   m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
00578 
00579   // add observer for event when figure is picked (selected)
00580   typedef itk::MemberCommand< QmitkMeasurement > MemberCommandType;
00581   MemberCommandType::Pointer selectCommand = MemberCommandType::New();
00582   selectCommand->SetCallbackFunction( this, &QmitkMeasurement::PlanarFigureSelected );
00583   m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
00584 
00585 
00586   // figure drawn on the topmost layer / image
00587   this->GetDataStorage()->Add(newNode, this->DetectTopMostVisibleImage() );
00588   std::vector<mitk::DataNode*> selectedNodes = GetDataManagerSelection();
00589   for(unsigned int i = 0; i < selectedNodes.size(); i++)
00590   {
00591     selectedNodes[i]->SetSelected(false);
00592   }
00593   selectedNodes = m_SelectedPlanarFigures->GetNodes();
00594   for(unsigned int i = 0; i < selectedNodes.size(); i++)
00595   {
00596     selectedNodes[i]->SetSelected(false);
00597   }
00598   newNode->SetSelected(true);
00599 
00600 
00601   m_CurrentFigureNodeInitialized = false;
00602   m_CurrentFigureNode = newNode;
00603 
00604   *m_SelectedPlanarFigures = newNode;
00605 
00606   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00607 }
00608 
00609 bool QmitkMeasurement::AssertDrawingIsPossible(bool checked)
00610 {
00611   if (m_SelectedImageNode->GetNode().IsNull())
00612   {
00613     checked = false;
00614     this->HandleException("Please select an image!", this->m_Parent, true);
00615     m_DrawLine->setChecked(false);
00616     return false;
00617   }
00618 
00619   this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(false);
00620   //this->GetActiveStdMultiWidget()->GetRenderWindow1()->FullScreenMode(true);
00621 
00622   return checked;
00623 }
00624 
00625 void QmitkMeasurement::ActionDrawLineTriggered(bool checked)
00626 {
00627   if(!this->AssertDrawingIsPossible(checked))
00628     return;
00629   mitk::PlanarLine::Pointer figure = mitk::PlanarLine::New();
00630   this->AddFigureToDataStorage(figure, QString("Line%1").arg(++m_LineCounter));
00631 
00632   MITK_INFO << "PlanarLine initialized...";
00633 }
00634 
00635 void QmitkMeasurement::ActionDrawPathTriggered(bool checked)
00636 {
00637   if(!this->AssertDrawingIsPossible(checked))
00638     return;
00639 
00640   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
00641   figure->ClosedOff();
00642 
00643   mitk::BoolProperty::Pointer closedProperty = mitk::BoolProperty::New( false );
00644   this->AddFigureToDataStorage(figure, QString("Path%1").arg(++m_PathCounter),
00645     "ClosedPlanarPolygon", closedProperty);
00646 
00647   MITK_INFO << "PlanarPath initialized...";
00648 }
00649 
00650 void QmitkMeasurement::ActionDrawAngleTriggered(bool checked)
00651 {
00652   if(!this->AssertDrawingIsPossible(checked))
00653     return;
00654 
00655   mitk::PlanarAngle::Pointer figure = mitk::PlanarAngle::New();
00656   this->AddFigureToDataStorage(figure, QString("Angle%1").arg(++m_AngleCounter));
00657 
00658   MITK_INFO << "PlanarAngle initialized...";
00659 }
00660 
00661 void QmitkMeasurement::ActionDrawFourPointAngleTriggered(bool checked)
00662 {
00663   if(!this->AssertDrawingIsPossible(checked))
00664     return;
00665 
00666   mitk::PlanarFourPointAngle::Pointer figure =
00667       mitk::PlanarFourPointAngle::New();
00668   this->AddFigureToDataStorage(figure, QString("Four Point Angle%1").arg(++m_FourPointAngleCounter));
00669 
00670   MITK_INFO << "PlanarFourPointAngle initialized...";
00671 }
00672 
00673 void QmitkMeasurement::ActionDrawEllipseTriggered(bool checked)
00674 {
00675   if(!this->AssertDrawingIsPossible(checked))
00676     return;
00677 
00678   mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
00679   this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_EllipseCounter));
00680 
00681   MITK_INFO << "PlanarCircle initialized...";
00682 }
00683 
00684 void QmitkMeasurement::ActionDrawRectangleTriggered(bool checked)
00685 {
00686   if(!this->AssertDrawingIsPossible(checked))
00687     return;
00688 
00689   mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
00690   this->AddFigureToDataStorage(figure, QString("Rectangle%1").arg(++m_RectangleCounter));
00691 
00692   MITK_INFO << "PlanarRectangle initialized...";
00693 }
00694 
00695 void QmitkMeasurement::ActionDrawPolygonTriggered(bool checked)
00696 {
00697   if(!this->AssertDrawingIsPossible(checked))
00698     return;
00699 
00700   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
00701   figure->ClosedOn();
00702   this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
00703 
00704   MITK_INFO << "PlanarPolygon initialized...";
00705 }
00706 
00707 void QmitkMeasurement::ActionDrawArrowTriggered(bool checked)
00708 {
00709   if(!this->AssertDrawingIsPossible(checked))
00710     return;
00711 
00712   MITK_WARN << "Draw Arrow not implemented yet.";
00713 }
00714 
00715 void QmitkMeasurement::ActionDrawTextTriggered(bool checked)
00716 {
00717   if(!this->AssertDrawingIsPossible(checked))
00718     return;
00719 
00720   MITK_WARN << "Draw Text not implemented yet.";
00721 }
00722 
00723 void QmitkMeasurement::Activated()
00724 {
00725   this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(false);
00726   //this->GetActiveStdMultiWidget()->GetRenderWindow1()->FullScreenMode(true);
00727 
00728   mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure
00729     = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
00730 
00731   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
00732   mitk::DataNode* node = 0;
00733   mitk::PlanarFigure* figure = 0;
00734   mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
00735   // finally add all nodes to the model
00736   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
00737     ; it++)
00738   {
00739     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
00740     figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
00741     if(figure)
00742     {
00743       figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
00744 
00745       if(figureInteractor.IsNull())
00746         figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", node);
00747 
00748       mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
00749     }
00750   }
00751 
00752   m_Visible = true;
00753 
00754 }
00755 
00756 void QmitkMeasurement::Deactivated()
00757 {
00758   this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(true);
00759   //this->GetActiveStdMultiWidget()->GetRenderWindow1()->FullScreenMode(false);
00760   this->SetMeasurementInfoToRenderWindow("", 0);
00761 
00762   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
00763   mitk::DataNode* node = 0;
00764   mitk::PlanarFigure* figure = 0;
00765   mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
00766   // finally add all nodes to the model
00767   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
00768     ; it++)
00769   {
00770     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
00771     figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
00772     if(figure)
00773     {
00774       figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
00775 
00776       if(figureInteractor)
00777         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
00778     }
00779   }
00780 
00781   m_Visible = false;
00782 }
00783 
00784 
00785 void QmitkMeasurement::PropertyChanged(const mitk::DataNode* /*node*/, const mitk::BaseProperty* /*prop*/)
00786 {
00787   this->PlanarFigureSelectionChanged();
00788 }
00789 
00790 void QmitkMeasurement::NodeChanged(const mitk::DataNode* /*node*/)
00791 {
00792   this->PlanarFigureSelectionChanged();
00793 }
00794 
00795 void QmitkMeasurement::NodeRemoved(const mitk::DataNode* /*node*/)
00796 {
00797   this->PlanarFigureSelectionChanged();
00798 }
00799 
00800 void QmitkMeasurement::CopyToClipboard(bool)
00801 {
00802   std::vector<QString> headerRow;
00803   std::vector<std::vector<QString> > rows;
00804   QString featureName;
00805   QString featureQuantity;
00806   std::vector<QString> newRow;
00807   headerRow.push_back("Name");
00808 
00809   std::vector<mitk::DataNode*> nodes = m_SelectedPlanarFigures->GetNodes();
00810 
00811   for (std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it
00812       != nodes.end(); ++it)
00813   {
00814     mitk::PlanarFigure* planarFigure =
00815         dynamic_cast<mitk::PlanarFigure*> ((*it)->GetData());
00816     if (!planarFigure)
00817       continue;
00818 
00819     newRow.clear();
00820     newRow.push_back(QString::fromStdString((*it)->GetName()));
00821     newRow.resize(headerRow.size());
00822     for (unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i)
00823     {
00824       if ( !planarFigure->IsFeatureActive( i ) ) continue;
00825 
00826       featureName = planarFigure->GetFeatureName(i);
00827       featureName.append(QString(" [%1]").arg(planarFigure->GetFeatureUnit(i)));
00828       std::vector<QString>::iterator itColumn = std::find(headerRow.begin(),
00829           headerRow.end(), featureName);
00830 
00831       featureQuantity
00832           = QString("%1").arg(planarFigure->GetQuantity(i)).replace(QChar('.'),
00833               ",");
00834       if (itColumn == headerRow.end())
00835       {
00836         headerRow.push_back(featureName);
00837         newRow.push_back(featureQuantity);
00838       } else
00839       {
00840         newRow[std::distance(headerRow.begin(), itColumn)] = featureQuantity;
00841       }
00842 
00843     }
00844     rows.push_back(newRow);
00845   }
00846 
00847   QString clipboardText;
00848   for (std::vector<QString>::iterator it = headerRow.begin(); it
00849       != headerRow.end(); ++it)
00850     clipboardText.append(QString("%1 \t").arg(*it));
00851 
00852   for (std::vector<std::vector<QString> >::iterator it = rows.begin(); it
00853       != rows.end(); ++it)
00854   {
00855     clipboardText.append("\n");
00856     for (std::vector<QString>::iterator it2 = (*it).begin(); it2 != (*it).end(); ++it2)
00857     {
00858       clipboardText.append(QString("%1 \t").arg(*it2));
00859     }
00860   }
00861 
00862   QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
00863 
00864 }
00865 
00866 void QmitkMeasurement::SetMeasurementInfoToRenderWindow(const QString& text,
00867     QmitkRenderWindow* _RenderWindow)
00868 {
00869   if(m_LastRenderWindow != _RenderWindow)
00870   {
00871 
00872     if(m_LastRenderWindow)
00873     {
00874       QObject::disconnect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
00875         , this, SLOT( OnRenderWindowDelete(QObject*) ) );
00876     }
00877     m_LastRenderWindow = _RenderWindow;
00878     if(m_LastRenderWindow)
00879     {
00880       QObject::connect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
00881         , this, SLOT( OnRenderWindowDelete(QObject*) ) );
00882     }
00883   }
00884 
00885   if(m_LastRenderWindow)
00886   {
00887     if (!text.isEmpty() && m_SelectedPlanarFigures->GetNode()->IsSelected())
00888     {
00889       m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
00890       mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->InsertForegroundRenderer(
00891         m_MeasurementInfoRenderer, true);
00892     }
00893     else
00894     {
00895       if (mitk::VtkLayerController::GetInstance(
00896         m_LastRenderWindow->GetRenderWindow()) ->IsRendererInserted(
00897         m_MeasurementInfoRenderer))
00898         mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->RemoveRenderer(
00899         m_MeasurementInfoRenderer);
00900     }
00901   }
00902 }
00903 
00904 
00905 void QmitkMeasurement::OnRenderWindowDelete(QObject * obj)
00906 {
00907   if(obj == m_LastRenderWindow)
00908     m_LastRenderWindow = 0;
00909 }