diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
index 7624375be4..077752104f 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,992 +1,996 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkImageStatisticsView.h"
 
 // Qt includes
 #include <qclipboard.h>
 #include <qscrollbar.h>
 
 // berry includes
 #include <berryIWorkbenchPage.h>
 
 // mitk includes
 #include "mitkNodePredicateDataType.h"
 #include "mitkPlanarFigureInteractor.h"
 
 // itk includes
 #include "itksys/SystemTools.hxx"
 #include <mitkILinkedRenderWindowPart.h>
 #include <QmitkRenderWindow.h>
 
 const std::string QmitkImageStatisticsView::VIEW_ID = "org.mitk.views.imagestatistics";
 const int QmitkImageStatisticsView::STAT_TABLE_BASE_HEIGHT = 180;
 
 QmitkImageStatisticsView::QmitkImageStatisticsView(QObject* /*parent*/, const char* /*name*/)
   : m_Controls( NULL ),
   m_TimeStepperAdapter( NULL ),
   m_SelectedImage( NULL ),
   m_SelectedImageMask( NULL ),
   m_SelectedPlanarFigure( NULL ),
   m_ImageObserverTag( -1 ),
   m_ImageMaskObserverTag( -1 ),
   m_PlanarFigureObserverTag( -1 ),
   m_TimeObserverTag( -1 ),
   m_CurrentStatisticsValid( false ),
   m_StatisticsUpdatePending( false ),
   m_DataNodeSelectionChanged ( false ),
   m_Visible(false)
 {
   this->m_CalculationThread = new QmitkImageStatisticsCalculationThread;
 }
 
 QmitkImageStatisticsView::~QmitkImageStatisticsView()
 {
   if ( m_SelectedImage != NULL )
     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
   if ( m_SelectedImageMask != NULL )
     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
   if ( m_SelectedPlanarFigure != NULL )
     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
 
   while(this->m_CalculationThread->isRunning()) // wait until thread has finished
   {
     itksys::SystemTools::Delay(100);
   }
   delete this->m_CalculationThread;
 }
 
 void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkImageStatisticsViewControls;
     m_Controls->setupUi(parent);
     CreateConnections();
 
     m_Controls->m_ErrorMessageLabel->hide();
     m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
     m_Controls->m_BinSizeFrame->setVisible(false);
   }
 }
 
 void QmitkImageStatisticsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(this->m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardHistogramButtonClicked()) );
     connect( (QObject*)(this->m_Controls->m_ButtonCopyStatisticsToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardStatisticsButtonClicked()) );
     connect( (QObject*)(this->m_Controls->m_IgnoreZerosCheckbox), SIGNAL(clicked()),(QObject*) this, SLOT(OnIgnoreZerosCheckboxClicked()) );
     connect( (QObject*) this->m_CalculationThread, SIGNAL(finished()),this, SLOT( OnThreadedStatisticsCalculationEnds()),Qt::QueuedConnection);
     connect( (QObject*) this, SIGNAL(StatisticsUpdate()),this, SLOT( RequestStatisticsUpdate()), Qt::QueuedConnection);
     connect( (QObject*) this->m_Controls->m_StatisticsTable, SIGNAL(cellDoubleClicked(int,int)),this, SLOT( JumpToCoordinates(int,int)) );
     connect( (QObject*) (this->m_Controls->m_barRadioButton), SIGNAL(clicked()), (QObject*) (this->m_Controls->m_JSHistogram), SLOT(OnBarRadioButtonSelected()));
     connect( (QObject*) (this->m_Controls->m_lineRadioButton), SIGNAL(clicked()), (QObject*) (this->m_Controls->m_JSHistogram), SLOT(OnLineRadioButtonSelected()));
     connect( (QObject*) (this->m_Controls->m_HistogramBinSizeSpinbox), SIGNAL(editingFinished()), this, SLOT(OnHistogramBinSizeBoxValueChanged()));
     connect( (QObject*)(this->m_Controls->m_UseDefaultBinSizeBox), SIGNAL(clicked()),(QObject*) this, SLOT(OnDefaultBinSizeBoxChanged()) );
   }
 }
 
 void QmitkImageStatisticsView::OnDefaultBinSizeBoxChanged()
 {
     if (m_CalculationThread!=NULL)
         m_Controls->m_HistogramBinSizeSpinbox->setValue(m_CalculationThread->GetHistogramBinSize());
     if (m_Controls->m_UseDefaultBinSizeBox->isChecked())
         m_Controls->m_BinSizeFrame->setVisible(false);
     else
         m_Controls->m_BinSizeFrame->setVisible(true);
 }
 
 void QmitkImageStatisticsView::PartClosed( berry::IWorkbenchPartReference::Pointer )
 {
 }
 
 void QmitkImageStatisticsView::OnTimeChanged(const itk::EventObject& e)
 {
   if (this->m_SelectedDataNodes.isEmpty() || this->m_SelectedImage == NULL)
     return;
 
   const mitk::SliceNavigationController::GeometryTimeEvent* timeEvent =
     dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent*>(&e);
   assert(timeEvent != NULL);
   unsigned int timestep = timeEvent->GetPos();
 
   if (this->m_SelectedImage->GetTimeSteps() > 1)
   {
     for (unsigned int x = 0; x < this->m_Controls->m_StatisticsTable->columnCount(); x++)
     {
       for (unsigned int y = 0; y < this->m_Controls->m_StatisticsTable->rowCount(); y++)
       {
         QTableWidgetItem* item = this->m_Controls->m_StatisticsTable->item(y, x);
         if (item == NULL)
           break;
 
         if (x == timestep)
         {
           item->setBackgroundColor(Qt::yellow);
         }
         else
         {
           if (y % 2 == 0)
             item->setBackground(this->m_Controls->m_StatisticsTable->palette().base());
           else
             item->setBackground(this->m_Controls->m_StatisticsTable->palette().alternateBase());
         }
       }
     }
 
     this->m_Controls->m_StatisticsTable->viewport()->update();
   }
 
   if ((this->m_SelectedImage->GetTimeSteps() == 1 && timestep == 0) ||
       this->m_SelectedImage->GetTimeSteps() > 1)
   {
     // display histogram for selected timestep
     this->m_Controls->m_JSHistogram->ClearHistogram();
     QmitkImageStatisticsCalculationThread::HistogramType::Pointer histogram =
       this->m_CalculationThread->GetTimeStepHistogram(timestep);
 
     if (histogram.IsNotNull())
     {
       this->m_Controls->m_JSHistogram->ComputeHistogram(histogram.GetPointer());
 //      this->m_Controls->m_JSHistogram->SignalGraphChanged();
 
       // hacky way to make sure the protected SignalGraphChanged() is called
       if (this->m_Controls->m_JSHistogram->GetUseLineGraph())
       {
         this->m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
         this->m_Controls->m_JSHistogram->OnLineRadioButtonSelected();
       }
       else
       {
         this->m_Controls->m_JSHistogram->OnLineRadioButtonSelected();
         this->m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
       }
     }
   }
 }
 
 void QmitkImageStatisticsView::JumpToCoordinates(int row ,int col)
 {
   if(m_SelectedDataNodes.isEmpty())
   {
     MITK_WARN("QmitkImageStatisticsView") << "No data node selected for statistics calculation." ;
     return;
   }
 
   mitk::Point3D world;
   if (row==4 && !m_WorldMinList.empty())
     world = m_WorldMinList[col];
   else if (row==3 && !m_WorldMaxList.empty())
     world = m_WorldMaxList[col];
   else
     return;
 
   mitk::IRenderWindowPart* part = this->GetRenderWindowPart();
   if (part)
   {
     part->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(world);
     part->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SelectSliceByPoint(world);
     part->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SelectSliceByPoint(world);
 
     mitk::SliceNavigationController::GeometryTimeEvent timeEvent(this->m_SelectedImage->GetTimeGeometry(), col);
     part->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetGeometryTime(timeEvent);
   }
 }
 
 void QmitkImageStatisticsView::OnIgnoreZerosCheckboxClicked()
 {
   emit StatisticsUpdate();
 }
 
 void QmitkImageStatisticsView::OnClipboardHistogramButtonClicked()
 {
   if ( m_CurrentStatisticsValid )
   {
     const unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
 
     typedef mitk::ImageStatisticsCalculator::HistogramType HistogramType;
     const HistogramType *histogram = this->m_CalculationThread->GetTimeStepHistogram(t).GetPointer();
 
     QString clipboard( "Measurement \t Frequency\n" );
     for ( HistogramType::ConstIterator it = histogram->Begin();
       it != histogram->End();
       ++it )
     {
       if( m_Controls->m_HistogramBinSizeSpinbox->value() == 1)
       {
         clipboard = clipboard.append( "%L1 \t %L2\n" )
           .arg( it.GetMeasurementVector()[0], 0, 'f', 0 )
           .arg( it.GetFrequency() );
       }
       else
       {
         clipboard = clipboard.append( "%L1 \t %L2\n" )
           .arg( it.GetMeasurementVector()[0], 0, 'f', 2 )
           .arg( it.GetFrequency() );
       }
     }
 
     QApplication::clipboard()->setText(
       clipboard, QClipboard::Clipboard );
   }
   else
   {
     QApplication::clipboard()->clear();
   }
 }
 
 void QmitkImageStatisticsView::OnClipboardStatisticsButtonClicked()
 {
   QLocale tempLocal;
   QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
   if ( this->m_CurrentStatisticsValid )
   {
     const std::vector<mitk::ImageStatisticsCalculator::Statistics> &statistics =
         this->m_CalculationThread->GetStatisticsData();
     const unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->
         GetPos();
 
     // Copy statistics to clipboard ("%Ln" will use the default locale for
     // number formatting)
     QString clipboard( "Mean \t StdDev \t RMS \t Max \t Min \t N \t V (mm³)\n" );
     clipboard = clipboard.append( "%L1 \t %L2 \t %L3 \t %L4 \t %L5 \t %L6 \t %L7" )
       .arg( statistics[t].GetMean(), 0, 'f', 10 )
       .arg( statistics[t].GetSigma(), 0, 'f', 10 )
       .arg( statistics[t].GetRMS(), 0, 'f', 10 )
       .arg( statistics[t].GetMax(), 0, 'f', 10 )
       .arg( statistics[t].GetMin(), 0, 'f', 10 )
       .arg( statistics[t].GetN() )
       .arg( m_Controls->m_StatisticsTable->item( 0, 6 )->text().toDouble(), 0, 'f', 10 );
 
     QApplication::clipboard()->setText(
       clipboard, QClipboard::Clipboard );
   }
   else
   {
     QApplication::clipboard()->clear();
   }
   QLocale::setDefault(tempLocal);
 }
 
 void QmitkImageStatisticsView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*part*/,
                                                   const QList<mitk::DataNode::Pointer> &selectedNodes )
 {
   if (this->m_Visible)
   {
     this->SelectionChanged( selectedNodes );
   }
   else
   {
     this->m_DataNodeSelectionChanged = true;
   }
 }
 
 void QmitkImageStatisticsView::SelectionChanged(const QList<mitk::DataNode::Pointer> &selectedNodes)
 {
   if( this->m_StatisticsUpdatePending )
   {
     this->m_DataNodeSelectionChanged = true;
     return; // not ready for new data now!
   }
 
   if (selectedNodes.size() == this->m_SelectedDataNodes.size())
   {
     int i = 0;
     for (; i < selectedNodes.size(); ++i)
     {
       if (selectedNodes.at(i) != this->m_SelectedDataNodes.at(i))
       {
         break;
       }
     }
     // node selection did not change
     if (i == selectedNodes.size()) return;
   }
 
+  //reset the feature image and image mask field
+  m_Controls->m_SelectedFeatureImageLabel->setText("None");
+  m_Controls->m_SelectedMaskLabel->setText("None");
+
   this->ReinitData();
   if (selectedNodes.isEmpty())
   {
     m_Controls->m_JSHistogram->ClearHistogram();
     m_Controls->m_lineRadioButton->setEnabled(true);
     m_Controls->m_barRadioButton->setEnabled(true);
     m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
     m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
 //    m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
     m_Controls->m_InfoLabel->setText(QString(""));
 
     //   m_Controls->horizontalLayout_3->setEnabled(false);
     m_Controls->groupBox->setEnabled(false);
     m_Controls->groupBox_3->setEnabled(false);
   }
   else
   {
     //  m_Controls->horizontalLayout_3->setEnabled(true);
     m_Controls->groupBox->setEnabled(true);
     m_Controls->groupBox_3->setEnabled(true);
   }
   if(selectedNodes.size() == 1 || selectedNodes.size() == 2)
   {
     bool isBinary = false;
     selectedNodes.value(0)->GetBoolProperty("binary",isBinary);
     if(isBinary)
     {
       m_Controls->m_JSHistogram->ClearHistogram();
       m_Controls->m_lineRadioButton->setEnabled(true);
       m_Controls->m_barRadioButton->setEnabled(true);
       m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
       m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
 //      m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
       m_Controls->m_InfoLabel->setText(QString(""));
     }
     for (int i= 0; i< selectedNodes.size(); ++i)
     {
       this->m_SelectedDataNodes.push_back(selectedNodes.at(i));
     }
     this->m_DataNodeSelectionChanged = false;
     this->m_Controls->m_ErrorMessageLabel->setText( "" );
     this->m_Controls->m_ErrorMessageLabel->hide();
     emit StatisticsUpdate();
   }
   else
   {
     this->m_DataNodeSelectionChanged = false;
   }
 }
 
 void QmitkImageStatisticsView::ReinitData()
 {
   while( this->m_CalculationThread->isRunning()) // wait until thread has finished
   {
     itksys::SystemTools::Delay(100);
   }
 
   if(this->m_SelectedImage != NULL)
   {
     this->m_SelectedImage->RemoveObserver( this->m_ImageObserverTag);
     this->m_SelectedImage = NULL;
   }
   if(this->m_SelectedImageMask != NULL)
   {
     this->m_SelectedImageMask->RemoveObserver( this->m_ImageMaskObserverTag);
     this->m_SelectedImageMask = NULL;
   }
   if(this->m_SelectedPlanarFigure != NULL)
   {
     this->m_SelectedPlanarFigure->RemoveObserver( this->m_PlanarFigureObserverTag);
     this->m_SelectedPlanarFigure = NULL;
   }
   this->m_SelectedDataNodes.clear();
   this->m_StatisticsUpdatePending = false;
 
   m_Controls->m_ErrorMessageLabel->setText( "" );
   m_Controls->m_ErrorMessageLabel->hide();
   this->InvalidateStatisticsTableView();
   m_Controls->m_JSHistogram->ClearHistogram();
   m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
 }
 
 void QmitkImageStatisticsView::OnThreadedStatisticsCalculationEnds()
 {
   std::stringstream message;
   message << "";
   m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
   m_Controls->m_ErrorMessageLabel->hide();
   this->WriteStatisticsToGUI();
 }
 
 void QmitkImageStatisticsView::UpdateStatistics()
 {
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   if ( renderPart == NULL )
   {
     this->m_StatisticsUpdatePending =  false;
     return;
   }
   m_WorldMinList.clear();
   m_WorldMaxList.clear();
 
   // classify selected nodes
   mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
 
   std::string maskName = std::string();
   std::string maskType = std::string();
   std::string featureImageName = std::string();
   unsigned int maskDimension = 0;
 
   // reset data from last run
   ITKCommandType::Pointer changeListener = ITKCommandType::New();
   changeListener->SetCallbackFunction( this, &QmitkImageStatisticsView::SelectedDataModified );
 
   mitk::DataNode::Pointer planarFigureNode;
   for( int i= 0 ; i < this->m_SelectedDataNodes.size(); ++i)
   {
     mitk::PlanarFigure::Pointer planarFig = dynamic_cast<mitk::PlanarFigure*>(this->m_SelectedDataNodes.at(i)->GetData());
     if( imagePredicate->CheckNode(this->m_SelectedDataNodes.at(i)) )
     {
       bool isMask = false;
       this->m_SelectedDataNodes.at(i)->GetPropertyValue("binary", isMask);
 
       if( this->m_SelectedImageMask == NULL && isMask)
       {
         this->m_SelectedImageMask = dynamic_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
         this->m_ImageMaskObserverTag = this->m_SelectedImageMask->AddObserver(itk::ModifiedEvent(), changeListener);
 
         maskName = this->m_SelectedDataNodes.at(i)->GetName();
         maskType = m_SelectedImageMask->GetNameOfClass();
         maskDimension = 3;
       }
       else if( !isMask )
       {
         if(this->m_SelectedImage == NULL)
         {
           this->m_SelectedImage = static_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
           this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
         }
         featureImageName = this->m_SelectedDataNodes.at(i)->GetName();
       }
     }
     else if (planarFig.IsNotNull())
     {
       if(this->m_SelectedPlanarFigure == NULL)
       {
         this->m_SelectedPlanarFigure = planarFig;
         this->m_PlanarFigureObserverTag  =
           this->m_SelectedPlanarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), changeListener);
         maskName = this->m_SelectedDataNodes.at(i)->GetName();
         maskType = this->m_SelectedPlanarFigure->GetNameOfClass();
         maskDimension = 2;
         planarFigureNode = m_SelectedDataNodes.at(i);
       }
     }
     else
     {
       std::stringstream message;
       message << "<font color='red'>" << "Invalid data node type!" << "</font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
     }
   }
 
   if(maskName == "")
   {
     maskName = "None";
     maskType = "";
     maskDimension = 0;
   }
 
   if(featureImageName == "")
   {
     featureImageName = "None";
   }
 
   if (m_SelectedPlanarFigure != NULL && m_SelectedImage == NULL)
   {
     mitk::DataStorage::SetOfObjects::ConstPointer parentSet = this->GetDataStorage()->GetSources(planarFigureNode);
     for (int i=0; i<parentSet->Size(); i++)
     {
       mitk::DataNode::Pointer node = parentSet->ElementAt(i);
       if( imagePredicate->CheckNode(node) )
       {
         bool isMask = false;
         node->GetPropertyValue("binary", isMask);
 
         if( !isMask )
         {
           if(this->m_SelectedImage == NULL)
           {
             this->m_SelectedImage = static_cast<mitk::Image*>(node->GetData());
             this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
           }
         }
       }
     }
   }
 
   unsigned int timeStep = renderPart->GetTimeNavigationController()->GetTime()->GetPos();
 
   if ( m_SelectedImage != NULL && m_SelectedImage->IsInitialized())
   {
     // Check if a the selected image is a multi-channel image. If yes, statistics
     // cannot be calculated currently.
     if ( m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
     {
       std::stringstream message;
       message << "<font color='red'>Multi-component images not supported.</font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
 
       this->InvalidateStatisticsTableView();
       m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
       m_Controls->m_JSHistogram->ClearHistogram();
       m_CurrentStatisticsValid = false;
       this->m_StatisticsUpdatePending = false;
       m_Controls->m_lineRadioButton->setEnabled(true);
       m_Controls->m_barRadioButton->setEnabled(true);
       m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
       m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
 //      m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
       m_Controls->m_InfoLabel->setText(QString(""));
       return;
     }
 
     std::stringstream maskLabel;
     maskLabel << maskName;
     if ( maskDimension > 0 )
     {
       maskLabel << "  [" << maskDimension << "D " << maskType << "]";
     }
     m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
     m_Controls->m_SelectedFeatureImageLabel->setText(featureImageName.c_str());
 
     // check time step validity
     if(m_SelectedImage->GetDimension() <= 3 && timeStep > m_SelectedImage->GetDimension(3)-1)
     {
       timeStep = m_SelectedImage->GetDimension(3)-1;
     }
 
     // Add the used mask time step to the mask label so the user knows which mask time step was used
     // if the image time step is bigger than the total number of mask time steps (see
     // ImageStatisticsCalculator::ExtractImageAndMask)
     if (m_SelectedImageMask != NULL)
     {
       unsigned int maskTimeStep = timeStep;
 
       if (maskTimeStep >= m_SelectedImageMask->GetTimeSteps())
       {
         maskTimeStep = m_SelectedImageMask->GetTimeSteps() - 1;
       }
 
       m_Controls->m_SelectedMaskLabel->setText(m_Controls->m_SelectedMaskLabel->text() +
                                                QString(" (t=") +
                                                QString::number(maskTimeStep) +
                                                QString(")"));
     }
 
     //// initialize thread and trigger it
     this->m_CalculationThread->SetIgnoreZeroValueVoxel( m_Controls->m_IgnoreZerosCheckbox->isChecked() );
     this->m_CalculationThread->Initialize( m_SelectedImage, m_SelectedImageMask, m_SelectedPlanarFigure );
     this->m_CalculationThread->SetTimeStep( timeStep );
     this->m_CalculationThread->SetHistogramBinSize(m_Controls->m_HistogramBinSizeSpinbox->value());
     std::stringstream message;
     message << "<font color='red'>Calculating statistics...</font>";
     m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
     m_Controls->m_ErrorMessageLabel->show();
 
     try
     {
       // Compute statistics
       this->m_CalculationThread->SetUseDefaultBinSize(m_Controls->m_UseDefaultBinSizeBox->isChecked());
       this->m_CalculationThread->start();
     }
     catch ( const mitk::Exception& e)
     {
       std::stringstream message;
       message << "<font color='red'>" << e.GetDescription() << "</font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
       this->m_StatisticsUpdatePending = false;
     }
     catch ( const std::runtime_error &e )
     {
       // In case of exception, print error message on GUI
       std::stringstream message;
       message << "<font color='red'>" << e.what() << "</font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
       this->m_StatisticsUpdatePending = false;
     }
     catch ( const std::exception &e )
     {
       MITK_ERROR << "Caught exception: " << e.what();
 
       // In case of exception, print error message on GUI
       std::stringstream message;
       message << "<font color='red'>Error! Unequal Dimensions of Image and Segmentation. No recompute possible </font>";
       m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
       m_Controls->m_ErrorMessageLabel->show();
       this->m_StatisticsUpdatePending = false;
     }
   }
   else
   {
     this->m_StatisticsUpdatePending = false;
   }
 }
 
 void QmitkImageStatisticsView::SelectedDataModified()
 {
   if( !m_StatisticsUpdatePending )
   {
     emit StatisticsUpdate();
   }
 }
 
 void QmitkImageStatisticsView::NodeRemoved(const mitk::DataNode *node)
 {
   while(this->m_CalculationThread->isRunning()) // wait until thread has finished
   {
     itksys::SystemTools::Delay(100);
   }
 
   if (node->GetData() == m_SelectedImage)
   {
     m_SelectedImage = NULL;
   }
 }
 
 void QmitkImageStatisticsView::RequestStatisticsUpdate()
 {
   if ( !m_StatisticsUpdatePending )
   {
     if(this->m_DataNodeSelectionChanged)
     {
       this->SelectionChanged(this->GetCurrentSelection());
     }
     else
     {
       this->m_StatisticsUpdatePending = true;
       this->UpdateStatistics();
     }
   }
   if (this->GetRenderWindowPart())
     this->GetRenderWindowPart()->RequestUpdate();
 }
 
 void QmitkImageStatisticsView::OnHistogramBinSizeBoxValueChanged()
 {
   this->UpdateStatistics();
 }
 void QmitkImageStatisticsView::WriteStatisticsToGUI()
 {
   m_Controls->m_lineRadioButton->setEnabled(true);
   m_Controls->m_barRadioButton->setEnabled(true);
   m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
   m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
 //  m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
   m_Controls->m_InfoLabel->setText(QString(""));
 
   if(m_DataNodeSelectionChanged)
   {
     this->m_StatisticsUpdatePending = false;
     this->RequestStatisticsUpdate();
     return;    // stop visualization of results and calculate statistics of new selection
   }
 
   if ( this->m_CalculationThread->GetStatisticsUpdateSuccessFlag())
   {
     if ( this->m_CalculationThread->GetStatisticsChangedFlag() )
     {
       // Do not show any error messages
       m_Controls->m_ErrorMessageLabel->hide();
       m_CurrentStatisticsValid = true;
     }
 
     if (m_Controls->m_barRadioButton->isChecked())
     {
       m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
     }
     m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
     m_Controls->m_HistogramBinSizeSpinbox->setValue( this->m_CalculationThread->GetHistogramBinSize() );
     //m_Controls->m_JSHistogram->ComputeHistogram( this->m_CalculationThread->GetTimeStepHistogram(this->m_CalculationThread->GetTimeStep()).GetPointer() );
     this->FillStatisticsTableView( this->m_CalculationThread->GetStatisticsData(), this->m_CalculationThread->GetStatisticsImage());
   }
   else
   {
     m_Controls->m_SelectedMaskLabel->setText( "None" );
     m_Controls->m_ErrorMessageLabel->setText( m_CalculationThread->GetLastErrorMessage().c_str() );
     m_Controls->m_ErrorMessageLabel->show();
     // Clear statistics and histogram
     this->InvalidateStatisticsTableView();
     m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
     //m_Controls->m_JSHistogram->clearHistogram();
     m_CurrentStatisticsValid = false;
 
     // If a (non-closed) PlanarFigure is selected, display a line profile widget
     if ( m_SelectedPlanarFigure != NULL )
     {
       // Check if the (closed) planar figure is out of bounds and so no image mask could be calculated--> Intensity Profile can not be calculated
       bool outOfBounds = false;
       if ( m_SelectedPlanarFigure->IsClosed() && m_SelectedImageMask == NULL)
       {
         outOfBounds = true;
         std::stringstream message;
         message << "<font color='red'>Planar figure is on a rotated image plane or outside the image bounds.</font>";
         m_Controls->m_InfoLabel->setText(message.str().c_str());
       }
 
       // check whether PlanarFigure is initialized
       const mitk::PlaneGeometry *planarFigurePlaneGeometry = m_SelectedPlanarFigure->GetPlaneGeometry();
       if ( planarFigurePlaneGeometry == NULL || outOfBounds)
       {
         // Clear statistics, histogram, and GUI
         this->InvalidateStatisticsTableView();
         m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
         m_Controls->m_JSHistogram->ClearHistogram();
         m_CurrentStatisticsValid = false;
         m_Controls->m_ErrorMessageLabel->hide();
         m_Controls->m_SelectedMaskLabel->setText( "None" );
         this->m_StatisticsUpdatePending = false;
         m_Controls->m_lineRadioButton->setEnabled(true);
         m_Controls->m_barRadioButton->setEnabled(true);
         m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
         m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
 //        m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
         if (!outOfBounds)
           m_Controls->m_InfoLabel->setText(QString(""));
         return;
       }
       unsigned int timeStep = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
       m_Controls->m_JSHistogram->SetImage(this->m_CalculationThread->GetStatisticsImage());
       m_Controls->m_JSHistogram->SetPlanarFigure(m_SelectedPlanarFigure);
       m_Controls->m_JSHistogram->ComputeIntensityProfile(timeStep);
       m_Controls->m_lineRadioButton->setEnabled(false);
       m_Controls->m_barRadioButton->setEnabled(false);
       m_Controls->m_HistogramBinSizeSpinbox->setEnabled(false);
       m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(false);
 //      m_Controls->m_HistogramBinSizeLabel->setEnabled(false);
       std::stringstream message;
       message << "<font color='red'>Only linegraph available for an intesityprofile!</font>";
       m_Controls->m_InfoLabel->setText(message.str().c_str());
     }
   }
   this->m_StatisticsUpdatePending = false;
 }
 
 void QmitkImageStatisticsView::FillStatisticsTableView(
   const std::vector<mitk::ImageStatisticsCalculator::Statistics> &s,
   const mitk::Image *image )
 {
   this->m_Controls->m_StatisticsTable->setColumnCount(image->GetTimeSteps());
   this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(image->GetTimeSteps() > 1);
 
   int decimals = 2;
 
   mitk::PixelType doublePix = mitk::MakeScalarPixelType< double >();
   mitk::PixelType floatPix = mitk::MakeScalarPixelType< float >();
   if (image->GetPixelType()==doublePix || image->GetPixelType()==floatPix)
   {
     decimals = 5;
   }
 
   for (unsigned int t = 0; t < image->GetTimeSteps(); t++)
   {
     this->m_Controls->m_StatisticsTable->setHorizontalHeaderItem(t,
       new QTableWidgetItem(QString::number(t)));
 
     if (s[t].GetMaxIndex().size()==3)
     {
       mitk::Point3D index, max, min;
       index[0] = s[t].GetMaxIndex()[0];
       index[1] = s[t].GetMaxIndex()[1];
       index[2] = s[t].GetMaxIndex()[2];
       m_SelectedImage->GetGeometry()->IndexToWorld(index, max);
       this->m_WorldMaxList.push_back(max);
       index[0] = s[t].GetMinIndex()[0];
       index[1] = s[t].GetMinIndex()[1];
       index[2] = s[t].GetMinIndex()[2];
       m_SelectedImage->GetGeometry()->IndexToWorld(index, min);
       this->m_WorldMinList.push_back(min);
     }
 
 
     this->m_Controls->m_StatisticsTable->setItem( 0, t, new QTableWidgetItem(
       QString("%1").arg(s[t].GetMean(), 0, 'f', decimals) ) );
     this->m_Controls->m_StatisticsTable->setItem( 1, t, new QTableWidgetItem(
       QString("%1").arg(s[t].GetSigma(), 0, 'f', decimals) ) );
 
     this->m_Controls->m_StatisticsTable->setItem( 2, t, new QTableWidgetItem(
       QString("%1").arg(s[t].GetRMS(), 0, 'f', decimals) ) );
 
     QString max; max.append(QString("%1").arg(s[t].GetMax(), 0, 'f', decimals));
     max += " (";
     for (int i=0; i<s[t].GetMaxIndex().size(); i++)
     {
       max += QString::number(s[t].GetMaxIndex()[i]);
       if (i<s[t].GetMaxIndex().size()-1)
         max += ",";
     }
     max += ")";
     this->m_Controls->m_StatisticsTable->setItem( 3, t, new QTableWidgetItem( max ) );
 
     QString min; min.append(QString("%1").arg(s[t].GetMin(), 0, 'f', decimals));
     min += " (";
     for (int i=0; i<s[t].GetMinIndex().size(); i++)
     {
       min += QString::number(s[t].GetMinIndex()[i]);
       if (i<s[t].GetMinIndex().size()-1)
         min += ",";
     }
     min += ")";
     this->m_Controls->m_StatisticsTable->setItem( 4, t, new QTableWidgetItem( min ) );
 
     this->m_Controls->m_StatisticsTable->setItem( 5, t, new QTableWidgetItem(
       QString("%1").arg(s[t].GetN()) ) );
 
     const mitk::BaseGeometry *geometry = image->GetGeometry();
     if ( geometry != NULL )
     {
       const mitk::Vector3D &spacing = image->GetGeometry()->GetSpacing();
       double volume = spacing[0] * spacing[1] * spacing[2] * (double) s[t].GetN();
       this->m_Controls->m_StatisticsTable->setItem( 6, t, new QTableWidgetItem(
         QString("%1").arg(volume, 0, 'f', decimals) ) );
     }
     else
     {
       this->m_Controls->m_StatisticsTable->setItem( 6, t, new QTableWidgetItem(
         "NA" ) );
     }
   }
 
   this->m_Controls->m_StatisticsTable->resizeColumnsToContents();
   int height = STAT_TABLE_BASE_HEIGHT;
 
   if (this->m_Controls->m_StatisticsTable->horizontalHeader()->isVisible())
     height += this->m_Controls->m_StatisticsTable->horizontalHeader()->height();
 
   if (this->m_Controls->m_StatisticsTable->horizontalScrollBar()->isVisible())
     height += this->m_Controls->m_StatisticsTable->horizontalScrollBar()->height();
 
   this->m_Controls->m_StatisticsTable->setMinimumHeight(height);
 
   // make sure the current timestep's column is highlighted (and the correct histogram is displayed)
   unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->
     GetPos();
   mitk::SliceNavigationController::GeometryTimeEvent timeEvent(this->m_SelectedImage->GetTimeGeometry(),
     t);
   this->OnTimeChanged(timeEvent);
 
   QString hotspotMean; hotspotMean.append(QString("%1").arg(s[t].GetHotspotStatistics().GetMean(), 0, 'f', decimals));
     hotspotMean += " (";
     for (int i=0; i<s[t].GetHotspotIndex().size(); i++)
     {
         hotspotMean += QString::number(s[t].GetHotspotIndex()[i]);
         if (i<s[t].GetHotspotIndex().size()-1)
             hotspotMean += ",";
     }
     hotspotMean += ")";
 
   this->m_Controls->m_StatisticsTable->setItem( 7, t, new QTableWidgetItem( hotspotMean ) );
 
 
   QString hotspotMax; hotspotMax.append(QString("%1").arg(s[t].GetHotspotStatistics().GetMax(), 0, 'f', decimals));
     hotspotMax += " (";
     for (int i=0; i<s[t].GetHotspotStatistics().GetMaxIndex().size(); i++)
     {
         hotspotMax += QString::number(s[t].GetHotspotStatistics().GetMaxIndex()[i]);
         if (i<s[t].GetHotspotStatistics().GetMaxIndex().size()-1)
             hotspotMax += ",";
     }
     hotspotMax += ")";
 
   this->m_Controls->m_StatisticsTable->setItem( 8, t, new QTableWidgetItem( hotspotMax ) );
 
 
   QString hotspotMin; hotspotMin.append(QString("%1").arg(s[t].GetHotspotStatistics().GetMin(), 0, 'f', decimals));
     hotspotMin += " (";
     for (int i=0; i<s[t].GetHotspotStatistics().GetMinIndex().size(); i++)
     {
         hotspotMin += QString::number(s[t].GetHotspotStatistics().GetMinIndex()[i]);
         if (i<s[t].GetHotspotStatistics().GetMinIndex().size()-1)
             hotspotMin += ",";
     }
     hotspotMin += ")";
 
   this->m_Controls->m_StatisticsTable->setItem( 9, t, new QTableWidgetItem( hotspotMin ) );
 }
 
 void QmitkImageStatisticsView::InvalidateStatisticsTableView()
 {
   this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(false);
   this->m_Controls->m_StatisticsTable->setColumnCount(1);
 
   for ( unsigned int i = 0; i < this->m_Controls->m_StatisticsTable->rowCount(); ++i )
   {
     {
       this->m_Controls->m_StatisticsTable->setItem( i, 0, new QTableWidgetItem( "NA" ) );
     }
   }
 
   this->m_Controls->m_StatisticsTable->setMinimumHeight(STAT_TABLE_BASE_HEIGHT);
 }
 
 void QmitkImageStatisticsView::Activated()
 {
 }
 
 void QmitkImageStatisticsView::Deactivated()
 {
 }
 
 void QmitkImageStatisticsView::Visible()
 {
   m_Visible = true;
 
   mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
 
   if (renderWindow)
   {
     itk::ReceptorMemberCommand<QmitkImageStatisticsView>::Pointer cmdTimeEvent =
       itk::ReceptorMemberCommand<QmitkImageStatisticsView>::New();
     cmdTimeEvent->SetCallbackFunction(this, &QmitkImageStatisticsView::OnTimeChanged);
 
     // It is sufficient to add the observer to the axial render window since the GeometryTimeEvent
     // is always triggered by all views.
     m_TimeObserverTag = renderWindow->GetQmitkRenderWindow("axial")->
       GetSliceNavigationController()->
       AddObserver(mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), cmdTimeEvent);
   }
 
 
 
   if (m_DataNodeSelectionChanged)
   {
     if (this->IsCurrentSelectionValid())
     {
       this->SelectionChanged(this->GetCurrentSelection());
     }
     else
     {
       this->SelectionChanged(this->GetDataManagerSelection());
     }
     m_DataNodeSelectionChanged = false;
   }
 }
 
 void QmitkImageStatisticsView::Hidden()
 {
   m_Visible = false;
 
   // The slice navigation controller observer is removed here instead of in the destructor.
   // If it was called in the destructor, the application would freeze because the view's
   // destructor gets called after the render windows have been destructed.
   if ( m_TimeObserverTag != NULL )
   {
     mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
 
     if (renderWindow)
     {
       renderWindow->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->
         RemoveObserver( m_TimeObserverTag );
     }
     m_TimeObserverTag = NULL;
   }
 
 }
 
 void QmitkImageStatisticsView::SetFocus()
 {
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
index 060183b87f..95fbd48e0a 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
@@ -1,958 +1,962 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #define MEASUREMENT_DEBUG MITK_DEBUG("QmitkMeasurementView") << __LINE__ << ": "
 
 #include "QmitkMeasurementView.h"
 
 #include <QtGui>
 
 #include <mitkIPropertyFilters.h>
 #include <mitkPropertyFilter.h>
 #include <mitkVtkLayerController.h>
 #include <mitkWeakPointer.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarEllipse.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarAngle.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarLine.h>
 #include <mitkPlanarCross.h>
 #include <mitkPlanarFourPointAngle.h>
 #include <mitkPlanarDoubleEllipse.h>
 #include <mitkPlanarBezierCurve.h>
 #include <mitkPlanarSubdivisionPolygon.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <QmitkRenderWindow.h>
 #include <mitkImage.h>
 
 #include "mitkPluginActivator.h"
 #include "usModuleRegistry.h"
 
 template <class T>
 static T* GetService()
 {
   ctkPluginContext* context = mitk::PluginActivator::GetContext();
   ctkServiceReference serviceRef = context->getServiceReference<T>();
 
   return serviceRef
     ? context->getService<T>(serviceRef)
     : NULL;
 }
 
 struct QmitkPlanarFigureData
 {
   QmitkPlanarFigureData()
     : m_Figure(0), m_EndPlacementObserverTag(0), m_SelectObserverTag(0), m_StartInteractionObserverTag(0), m_EndInteractionObserverTag(0)
   {
   }
 
   mitk::PlanarFigure* m_Figure;
   unsigned int m_EndPlacementObserverTag;
   unsigned int m_SelectObserverTag;
   unsigned int m_StartInteractionObserverTag;
   unsigned int m_EndInteractionObserverTag;
 };
 
 struct QmitkMeasurementViewData
 {
   QmitkMeasurementViewData()
     : m_LineCounter(0), m_PathCounter(0), m_AngleCounter(0),
       m_FourPointAngleCounter(0), m_CircleCounter(0), m_EllipseCounter(0),
       m_DoubleEllipseCounter(0), m_RectangleCounter(0), m_PolygonCounter(0),
       m_BezierCurveCounter(0), m_SubdivisionPolygonCounter(0), m_UnintializedPlanarFigure(false)
   {
   }
 
   // internal vars
   unsigned int m_LineCounter;
   unsigned int m_PathCounter;
   unsigned int m_AngleCounter;
   unsigned int m_FourPointAngleCounter;
   unsigned int m_CircleCounter;
   unsigned int m_EllipseCounter;
   unsigned int m_DoubleEllipseCounter;
   unsigned int m_RectangleCounter;
   unsigned int m_PolygonCounter;
   unsigned int m_BezierCurveCounter;
   unsigned int m_SubdivisionPolygonCounter;
   QList<mitk::DataNode::Pointer> m_CurrentSelection;
   std::map<mitk::DataNode*, QmitkPlanarFigureData> m_DataNodeToPlanarFigureData;
   mitk::WeakPointer<mitk::DataNode> m_SelectedImageNode;
   bool m_UnintializedPlanarFigure;
 
   // WIDGETS
   QWidget* m_Parent;
   QLabel* m_SelectedImageLabel;
   QAction* m_DrawLine;
   QAction* m_DrawPath;
   QAction* m_DrawAngle;
   QAction* m_DrawFourPointAngle;
   QAction* m_DrawRectangle;
   QAction* m_DrawPolygon;
   QAction* m_DrawCircle;
   QAction* m_DrawEllipse;
   QAction* m_DrawDoubleEllipse;
   QAction* m_DrawBezierCurve;
   QAction* m_DrawSubdivisionPolygon;
   QToolBar* m_DrawActionsToolBar;
   QActionGroup* m_DrawActionsGroup;
   QTextBrowser* m_SelectedPlanarFiguresText;
   QPushButton* m_CopyToClipboard;
   QGridLayout* m_Layout;
 };
 
 const std::string QmitkMeasurementView::VIEW_ID = "org.mitk.views.measurement";
 
 QmitkMeasurementView::QmitkMeasurementView()
   : d( new QmitkMeasurementViewData )
 {
 }
 QmitkMeasurementView::~QmitkMeasurementView()
 {
   this->RemoveAllInteractors();
   delete d;
 }
 void QmitkMeasurementView::CreateQtPartControl(QWidget* parent)
 {
   d->m_Parent = parent;
 
   // image label
   QLabel* selectedImageLabel = new QLabel("Reference Image: ");
   d->m_SelectedImageLabel = new QLabel;
   d->m_SelectedImageLabel->setStyleSheet("font-weight: bold;");
 
   d->m_DrawActionsToolBar = new QToolBar;
   d->m_DrawActionsGroup = new QActionGroup(this);
   d->m_DrawActionsGroup->setExclusive(true);
 
   //# add actions
   MEASUREMENT_DEBUG << "Draw Line";
   QAction* currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/line.png"), "Draw Line");
   currentAction->setCheckable(true);
   d->m_DrawLine = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Path";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/path.png"), "Draw Path");
   currentAction->setCheckable(true);
   d->m_DrawPath = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/angle.png"), "Draw Angle");
   currentAction->setCheckable(true);
   d->m_DrawAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Four Point Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/four-point-angle.png"), "Draw Four Point Angle");
   currentAction->setCheckable(true);
   d->m_DrawFourPointAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Circle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/circle.png"), "Draw Circle");
   currentAction->setCheckable(true);
   d->m_DrawCircle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Ellipse";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/ellipse.png"), "Draw Ellipse");
   currentAction->setCheckable(true);
   d->m_DrawEllipse = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Double Ellipse";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/doubleellipse.png"), "Draw Double Ellipse");
   currentAction->setCheckable(true);
   d->m_DrawDoubleEllipse = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Rectangle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/rectangle.png"), "Draw Rectangle");
   currentAction->setCheckable(true);
   d->m_DrawRectangle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Polygon";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/polygon.png"), "Draw Polygon");
   currentAction->setCheckable(true);
   d->m_DrawPolygon = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Bezier Curve";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/beziercurve.png"), "Draw Bezier Curve");
   currentAction->setCheckable(true);
   d->m_DrawBezierCurve = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Subdivision Polygon";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/subdivisionpolygon.png"), "Draw Subdivision Polygon");
   currentAction->setCheckable(true);
   d->m_DrawSubdivisionPolygon = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   // planar figure details text
   d->m_SelectedPlanarFiguresText = new QTextBrowser;
 
   // copy to clipboard button
   d->m_CopyToClipboard = new QPushButton("Copy to Clipboard");
 
   d->m_Layout = new QGridLayout;
   d->m_Layout->addWidget(selectedImageLabel, 0, 0, 1, 1);
   d->m_Layout->addWidget(d->m_SelectedImageLabel, 0, 1, 1, 1);
   d->m_Layout->addWidget(d->m_DrawActionsToolBar, 1, 0, 1, 2);
   d->m_Layout->addWidget(d->m_SelectedPlanarFiguresText, 2, 0, 1, 2);
   d->m_Layout->addWidget(d->m_CopyToClipboard, 3, 0, 1, 2);
 
   d->m_Parent->setLayout(d->m_Layout);
 
   // create connections
   this->CreateConnections();
 
   // readd interactors and observers
   this->AddAllInteractors();
 }
 void QmitkMeasurementView::CreateConnections()
 {
   QObject::connect( d->m_DrawLine, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawLineTriggered(bool) ) );
   QObject::connect( d->m_DrawPath, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawPathTriggered(bool) ) );
   QObject::connect( d->m_DrawAngle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawFourPointAngle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawFourPointAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawCircle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawCircleTriggered(bool) ) );
   QObject::connect( d->m_DrawEllipse, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawEllipseTriggered(bool) ) );
   QObject::connect( d->m_DrawDoubleEllipse, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawDoubleEllipseTriggered(bool) ) );
   QObject::connect( d->m_DrawRectangle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawRectangleTriggered(bool) ) );
   QObject::connect( d->m_DrawPolygon, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawPolygonTriggered(bool) ) );
   QObject::connect( d->m_DrawBezierCurve, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawBezierCurveTriggered(bool) ) );
   QObject::connect( d->m_DrawSubdivisionPolygon, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawSubdivisionPolygonTriggered(bool) ) );
   QObject::connect( d->m_CopyToClipboard, SIGNAL( clicked(bool) ), this, SLOT( CopyToClipboard(bool) ) );
 }
 
 void QmitkMeasurementView::NodeAdded( const mitk::DataNode* node )
 {
   // add observer for selection in renderwindow
   mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
   bool isPositionMarker (false);
   node->GetBoolProperty("isContourMarker", isPositionMarker);
   if( figure && !isPositionMarker )
   {
     MEASUREMENT_DEBUG << "figure added. will add interactor if needed.";
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer() );
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( nonConstNode );
       //      nonConstNode->SetBoolProperty( "planarfigure.isextendable", true );
     }
     else
     {
       // just to be sure that the interactor is not added twice
       //    mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
     }
 
     MEASUREMENT_DEBUG << "adding interactor to globalinteraction";
     //  mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
 
     MEASUREMENT_DEBUG << "will now add observers for planarfigure";
     QmitkPlanarFigureData data;
     data.m_Figure = figure;
 
     // add observer for event when figure has been placed
     typedef itk::SimpleMemberCommand< QmitkMeasurementView > SimpleCommandType;
     SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
     initializationCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureInitialized );
     data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
     // add observer for event when figure is picked (selected)
     typedef itk::MemberCommand< QmitkMeasurementView > MemberCommandType;
     MemberCommandType::Pointer selectCommand = MemberCommandType::New();
     selectCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureSelected );
     data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
     startInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::DisableCrosshairNavigation);
     data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
     endInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::EnableCrosshairNavigation);
     data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
     // adding to the map of tracked planarfigures
     d->m_DataNodeToPlanarFigureData[nonConstNode] = data;
   }
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::NodeChanged(const mitk::DataNode* node)
 {
   // DETERMINE IF WE HAVE TO RENEW OUR DETAILS TEXT (ANY NODE CHANGED IN OUR SELECTION?)
   bool renewText = false;
   for( int i=0; i < d->m_CurrentSelection.size(); ++i )
   {
     if( node == d->m_CurrentSelection.at(i) )
     {
       renewText = true;
       break;
     }
   }
 
   if(renewText)
   {
     MEASUREMENT_DEBUG << "Selected nodes changed. Refreshing text.";
     this->UpdateMeasurementText();
   }
 
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::CheckForTopMostVisibleImage(mitk::DataNode* _NodeToNeglect)
 {
   d->m_SelectedImageNode = this->DetectTopMostVisibleImage().GetPointer();
   if( d->m_SelectedImageNode.GetPointer() == _NodeToNeglect )
     d->m_SelectedImageNode = 0;
 
   if( d->m_SelectedImageNode.IsNotNull() && d->m_UnintializedPlanarFigure == false )
   {
     MEASUREMENT_DEBUG << "Reference image found";
     d->m_SelectedImageLabel->setText( QString::fromStdString( d->m_SelectedImageNode->GetName() ) );
     d->m_DrawActionsToolBar->setEnabled(true);
     MEASUREMENT_DEBUG << "Updating Measurement text";
   }
   else
   {
     MEASUREMENT_DEBUG << "No reference image available. Will disable actions for creating new planarfigures";
     if( d->m_UnintializedPlanarFigure == false )
       d->m_SelectedImageLabel->setText( "No visible image available." );
 
     d->m_DrawActionsToolBar->setEnabled(false);
   }
 }
 
 void QmitkMeasurementView::NodeRemoved(const mitk::DataNode* node)
 {
   MEASUREMENT_DEBUG << "node removed from data storage";
 
   mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.find(nonConstNode);
 
   bool isFigureFinished = false;
   bool isPlaced = false;
 
   if( it != d->m_DataNodeToPlanarFigureData.end() )
   {
     QmitkPlanarFigureData& data = it->second;
     // remove observers
     data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
     data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
     data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
     data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
     MEASUREMENT_DEBUG << "removing from the list of tracked planar figures";
 
     isFigureFinished = data.m_Figure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
     if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
       PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
     }
     d->m_DataNodeToPlanarFigureData.erase( it );
   }
 
   mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes =
       GetDataStorage()->GetDerivations(node,isPlanarFigure);
 
   for (unsigned int x = 0; x < nodes->size(); x++)
   {
     mitk::PlanarFigure* planarFigure  = dynamic_cast<mitk::PlanarFigure*>  (nodes->at(x)->GetData());
     if (planarFigure != NULL) {
 
       isFigureFinished = planarFigure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
       if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
         GetDataStorage()->Remove(nodes->at(x));
         if( !d->m_DataNodeToPlanarFigureData.empty() )
         {
           std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it2 =
               d->m_DataNodeToPlanarFigureData.find(nodes->at(x));
           //check if returned it2 valid
           if( it2 != d->m_DataNodeToPlanarFigureData.end() )
           {
             d->m_DataNodeToPlanarFigureData.erase( it2 );// removing planar figure from tracked figure list
             PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
             EnableCrosshairNavigation();
           }
         }
       }
     }
   }
   this->CheckForTopMostVisibleImage(nonConstNode);
 }
 
 
 void QmitkMeasurementView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
   MEASUREMENT_DEBUG << "planar figure " << object << " selected";
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.begin();
 
   d->m_CurrentSelection.clear();
   while( it != d->m_DataNodeToPlanarFigureData.end())
   {
     mitk::DataNode* node = it->first;
     QmitkPlanarFigureData& data = it->second;
 
     if( data.m_Figure == object )
     {
       MITK_DEBUG << "selected node found. enabling selection";
       node->SetSelected(true);
       d->m_CurrentSelection.push_back( node );
     }
     else
     {
       node->SetSelected(false);
     }
 
     ++it;
   }
   this->UpdateMeasurementText();
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::PlanarFigureInitialized()
 {
   MEASUREMENT_DEBUG << "planar figure initialized";
   d->m_UnintializedPlanarFigure = false;
   d->m_DrawActionsToolBar->setEnabled(true);
 
   d->m_DrawLine->setChecked(false);
   d->m_DrawPath->setChecked(false);
   d->m_DrawAngle->setChecked(false);
   d->m_DrawFourPointAngle->setChecked(false);
   d->m_DrawCircle->setChecked(false);
   d->m_DrawEllipse->setChecked(false);
   d->m_DrawDoubleEllipse->setChecked(false);
   d->m_DrawRectangle->setChecked(false);
   d->m_DrawPolygon->setChecked(false);
   d->m_DrawBezierCurve->setChecked(false);
   d->m_DrawSubdivisionPolygon->setChecked(false);
 }
 
 void QmitkMeasurementView::SetFocus()
 {
   d->m_SelectedImageLabel->setFocus();
 }
 
 void QmitkMeasurementView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
                                               const QList<mitk::DataNode::Pointer> &nodes)
 {
   MEASUREMENT_DEBUG << "Determine the top most visible image";
   MEASUREMENT_DEBUG << "The PlanarFigure interactor will take the currently visible PlaneGeometry from the slice navigation controller";
 
   this->CheckForTopMostVisibleImage();
 
   MEASUREMENT_DEBUG << "refreshing selection and detailed text";
   d->m_CurrentSelection = nodes;
   this->UpdateMeasurementText();
   // bug 16600: deselecting all planarfigures by clicking on datamanager when no node is selected
   if(d->m_CurrentSelection.size() == 0)
   {
+    // bug 18440: resetting the selected image label here because unselecting the
+    // current node did not reset the label
+    d->m_SelectedImageLabel->setText( "No visible image available." );
+
     mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
     mitk::DataStorage::SetOfObjects::ConstPointer planarFigures = this->GetDataStorage()->GetSubset( isPlanarFigure );
     // setting all planar figures which are not helper objects not selected
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=planarFigures->Begin(); it!=planarFigures->End(); it++)
     {
       mitk::DataNode* node = it.Value();
       bool isHelperObject(false);
       node->GetBoolProperty("helper object", isHelperObject);
       if(!isHelperObject)
       {
         node->SetSelected(false);
       }
     }
   }
 
   for( int i=d->m_CurrentSelection.size()-1; i>= 0; --i)
   {
     mitk::DataNode* node = d->m_CurrentSelection.at(i);
     mitk::PlanarFigure* _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     // the last selected planar figure
 
     if (_PlanarFigure && _PlanarFigure->GetPlaneGeometry())
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       mitk::ILinkedRenderWindowPart* linkedRenderWindow = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
       if(! linkedRenderWindow )
       {
         return;
       }
 
       QmitkRenderWindow* RenderWindow1 = linkedRenderWindow->GetQmitkRenderWindow( "axial") ;
       QmitkRenderWindow* RenderWindow2 = linkedRenderWindow->GetQmitkRenderWindow( "sagittal") ;
       QmitkRenderWindow* RenderWindow3 = linkedRenderWindow->GetQmitkRenderWindow( "coronal") ;
       QmitkRenderWindow* RenderWindow4 = linkedRenderWindow->GetQmitkRenderWindow( "3d") ;
 
       if (node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow1;
       }
 
       if (!selectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, RenderWindow2->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow2;
       }
 
       if (!selectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,RenderWindow3->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow3;
       }
 
       if (!selectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, RenderWindow4->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow4;
       }
 
       const mitk::PlaneGeometry* _PlaneGeometry = dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetPlaneGeometry());
 
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::PlaneGeometry::ConstPointer _Plane1 = RenderWindow1->GetRenderer()->GetCurrentWorldPlaneGeometry();
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::PlaneGeometry::ConstPointer _Plane2 = RenderWindow2->GetRenderer()->GetCurrentWorldPlaneGeometry();
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::PlaneGeometry::ConstPointer _Plane3 = RenderWindow3->GetRenderer()->GetCurrentWorldPlaneGeometry();
       mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
       normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
       normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
       normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
       normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
       double ang1 = angle(normal, normal1);
       double ang2 = angle(normal, normal2);
       double ang3 = angle(normal, normal3);
 
       if(ang1 < ang2 && ang1 < ang3)
       {
         selectedRenderWindow = RenderWindow1;
       }
       else
       {
         if(ang2 < ang3)
         {
           selectedRenderWindow = RenderWindow2;
         }
         else
         {
           selectedRenderWindow = RenderWindow3;
         }
       }
 
       // re-orient view
       if (selectedRenderWindow)
       {
         const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(centerP, _PlaneGeometry->GetNormal());
       }
     }
     break;
   }
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::ActionDrawLineTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarLine::Pointer figure = mitk::PlanarLine::New();
   QString qString = QString("Line%1").arg(++d->m_LineCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarLine initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPathTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::IPropertyFilters* propertyFilters = GetService<mitk::IPropertyFilters>();
 
   if (propertyFilters != NULL)
   {
     mitk::PropertyFilter filter;
     filter.AddEntry("ClosedPlanarPolygon", mitk::PropertyFilter::Blacklist);
 
     propertyFilters->AddFilter(filter, "PlanarPolygon");
   }
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOff();
   QString qString = QString("Path%1").arg(++d->m_PathCounter);
   mitk::DataNode::Pointer node = this->AddFigureToDataStorage(figure, qString);
   mitk::BoolProperty::Pointer closedProperty = mitk::BoolProperty::New( false );
   node->SetProperty("ClosedPlanarPolygon", closedProperty);
   node->SetProperty("planarfigure.isextendable",mitk::BoolProperty::New(true));
 
   MEASUREMENT_DEBUG << "PlanarPath initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarAngle::Pointer figure = mitk::PlanarAngle::New();
   QString qString = QString("Angle%1").arg(++d->m_AngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawFourPointAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarFourPointAngle::Pointer figure =
       mitk::PlanarFourPointAngle::New();
   QString qString = QString("Four Point Angle%1").arg(++d->m_FourPointAngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarFourPointAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawCircleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
   QString qString = QString("Circle%1").arg(++d->m_CircleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarCircle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawEllipseTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
   QString qString = QString("Ellipse%1").arg(++d->m_EllipseCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarEllipse initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawDoubleEllipseTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarDoubleEllipse::Pointer figure = mitk::PlanarDoubleEllipse::New();
   QString qString = QString("DoubleEllipse%1").arg(++d->m_DoubleEllipseCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarDoubleEllipse initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawBezierCurveTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarBezierCurve::Pointer figure = mitk::PlanarBezierCurve::New();
   QString qString = QString("BezierCurve%1").arg(++d->m_BezierCurveCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarBezierCurve initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawSubdivisionPolygonTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarSubdivisionPolygon::Pointer figure = mitk::PlanarSubdivisionPolygon::New();
   QString qString = QString("SubdivisionPolygon%1").arg(++d->m_SubdivisionPolygonCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarSubdivisionPolygon initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawRectangleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
   QString qString = QString("Rectangle%1").arg(++d->m_RectangleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarRectangle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPolygonTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOn();
   QString qString = QString("Polygon%1").arg(++d->m_PolygonCounter);
   mitk::DataNode::Pointer node = this->AddFigureToDataStorage(figure, qString);
   node->SetProperty("planarfigure.isextendable",mitk::BoolProperty::New(true));
 
   MEASUREMENT_DEBUG << "PlanarPolygon initialized...";
 }
 
 void QmitkMeasurementView::CopyToClipboard( bool checked )
 {
   Q_UNUSED(checked)
 
   MEASUREMENT_DEBUG << "Copying current Text to clipboard...";
   QString clipboardText = d->m_SelectedPlanarFiguresText->toPlainText();
   QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::AddFigureToDataStorage(
     mitk::PlanarFigure* figure, const QString& name)
 {
   // add as
   MEASUREMENT_DEBUG << "Adding new figure to datastorage...";
   if( d->m_SelectedImageNode.IsNull() )
   {
     MITK_ERROR << "No reference image available";
     return 0;
   }
 
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName(name.toStdString());
   newNode->SetData(figure);
   // set as selected
   newNode->SetSelected( true );
   this->GetDataStorage()->Add(newNode, d->m_SelectedImageNode);
 
   // set all others in selection as deselected
   for( int i=0; i<d->m_CurrentSelection.size(); ++i)
     d->m_CurrentSelection.at(i)->SetSelected(false);
   d->m_CurrentSelection.clear();
   d->m_CurrentSelection.push_back( newNode );
   this->UpdateMeasurementText();
   this->DisableCrosshairNavigation();
   d->m_DrawActionsToolBar->setEnabled(false);
   d->m_UnintializedPlanarFigure = true;
   return newNode;
 }
 
 void QmitkMeasurementView::UpdateMeasurementText()
 {
   d->m_SelectedPlanarFiguresText->clear();
 
   QString infoText;
   QString plainInfoText;
   int j = 1;
   mitk::PlanarFigure* _PlanarFigure = 0;
   mitk::PlanarAngle* planarAngle = 0;
   mitk::PlanarFourPointAngle* planarFourPointAngle = 0;
   mitk::DataNode::Pointer node = 0;
 
   for (int i=0; i<d->m_CurrentSelection.size(); ++i, ++j)
   {
     plainInfoText.clear();
     node = d->m_CurrentSelection.at(i);
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     if( !_PlanarFigure )
       continue;
 
     if(j>1)
       infoText.append("<br />");
 
     infoText.append(QString("<b>%1</b><hr />").arg(QString::fromStdString(
                                                      node->GetName())));
     plainInfoText.append(QString("%1").arg(QString::fromStdString(
                                              node->GetName())));
 
     planarAngle = dynamic_cast<mitk::PlanarAngle*> (_PlanarFigure);
     if(!planarAngle)
     {
       planarFourPointAngle = dynamic_cast<mitk::PlanarFourPointAngle*> (_PlanarFigure);
     }
 
     double featureQuantity = 0.0;
     for (unsigned int k = 0; k < _PlanarFigure->GetNumberOfFeatures(); ++k)
     {
       if ( !_PlanarFigure->IsFeatureActive( k ) ) continue;
 
       featureQuantity = _PlanarFigure->GetQuantity(k);
       if ((planarAngle && k == planarAngle->FEATURE_ID_ANGLE)
           || (planarFourPointAngle && k == planarFourPointAngle->FEATURE_ID_ANGLE))
         featureQuantity = featureQuantity * 180 / vnl_math::pi;
 
       infoText.append(
             QString("<i>%1</i>: %2 %3") .arg(QString(
                                                _PlanarFigure->GetFeatureName(k))) .arg(featureQuantity, 0, 'f',
                                                                                        2) .arg(QString(_PlanarFigure->GetFeatureUnit(k))));
 
       plainInfoText.append(
             QString("\n%1: %2 %3") .arg(QString(_PlanarFigure->GetFeatureName(k))) .arg(
               featureQuantity, 0, 'f', 2) .arg(QString(
                                                  _PlanarFigure->GetFeatureUnit(k))));
 
       if(k+1 != _PlanarFigure->GetNumberOfFeatures())
         infoText.append("<br />");
     }
 
     if (j != d->m_CurrentSelection.size())
       infoText.append("<br />");
   }
 
   d->m_SelectedPlanarFiguresText->setHtml(infoText);
 }
 
 void QmitkMeasurementView::AddAllInteractors()
 {
   MEASUREMENT_DEBUG << "Adding interactors and observers to all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer planarFigures = this->GetAllPlanarFigures();
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=planarFigures->Begin();
     it!=planarFigures->End(); it++)
   {
     this->NodeAdded( it.Value() );
   }
 }
 
 void QmitkMeasurementView::RemoveAllInteractors()
 {
   MEASUREMENT_DEBUG << "Removing interactors and observers from all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer planarFigures = this->GetAllPlanarFigures();
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=planarFigures->Begin();
     it!=planarFigures->End(); it++)
   {
     this->NodeRemoved( it.Value() );
   }
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::DetectTopMostVisibleImage()
 {
   // get all images from the data storage which are not a segmentation
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
   mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
 
   mitk::DataStorage::SetOfObjects::ConstPointer Images
       = this->GetDataStorage()->GetSubset( isNormalImage );
 
 
   mitk::DataNode::Pointer currentNode;
   int maxLayer = itk::NumericTraits<int>::min();
 
   // iterate over selection
   for (mitk::DataStorage::SetOfObjects::ConstIterator sofIt = Images->Begin(); sofIt != Images->End(); ++sofIt)
   {
     mitk::DataNode::Pointer node = sofIt->Value();
     if ( node.IsNull() )
       continue;
     if (node->IsVisible(NULL) == false)
       continue;
     // we also do not want to assign planar figures to helper objects ( even if they are of type image )
     if (node->GetProperty("helper object"))
       continue;
 
     int layer = 0;
     node->GetIntProperty("layer", layer);
     if ( layer < maxLayer )
     {
       continue;
     }
     else
     {
       maxLayer = layer;
       currentNode = node;
     }
   }
 
   return currentNode;
 }
 
 void QmitkMeasurementView::EnableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "EnableCrosshairNavigation";
 
   // enable the crosshair navigation
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "enabling linked navigation";
     linkedRenderWindow->EnableLinkedNavigation(true);
     linkedRenderWindow->EnableSlicingPlanes(true);
   }
 }
 
 void QmitkMeasurementView::DisableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "DisableCrosshairNavigation";
 
   // disable the crosshair navigation during the drawing
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "disabling linked navigation";
     linkedRenderWindow->EnableLinkedNavigation(false);
     linkedRenderWindow->EnableSlicingPlanes(false);
   }
 }
 
 mitk::DataStorage::SetOfObjects::ConstPointer QmitkMeasurementView::GetAllPlanarFigures() const
 {
   mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
   mitk::NodePredicateProperty::Pointer isNotHelperObject = mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(false));
   mitk::NodePredicateAnd::Pointer isNotHelperButPlanarFigure = mitk::NodePredicateAnd::New( isPlanarFigure, isNotHelperObject );
 
   return this->GetDataStorage()->GetSubset( isPlanarFigure );
 }