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 0cc6f6cbf8..611d7f994a 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,794 +1,797 @@
 /*===================================================================
 
 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"
 
 #include <limits>
 
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qlineedit.h>
 #include <qclipboard.h>
 #include <qfiledialog.h>
 
 #include <berryIEditorPart.h>
 #include <berryIWorkbenchPage.h>
 #include <berryPlatform.h>
 
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkSliderNavigatorWidget.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkProperties.h"
 
 #include "mitkProgressBar.h"
 
 // Includes for image processing
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 
 #include "mitkDataNodeObject.h"
 #include "mitkNodePredicateData.h"
 #include "mitkPlanarFigureInteractor.h"
 
 #include <itkVectorImage.h>
 
 const std::string QmitkImageStatisticsView::VIEW_ID =
 "org.mitk.views.imagestatistics";
 
 class QmitkRequestStatisticsUpdateEvent : public QEvent
 {
 public:
   enum Type
   {
     StatisticsUpdateRequest = QEvent::MaxUser - 1025
   };
 
   QmitkRequestStatisticsUpdateEvent()
     : QEvent( (QEvent::Type) StatisticsUpdateRequest ) {};
 };
 
 
 
 typedef itk::Image<short, 3>                 ImageType;
 typedef itk::Image<float, 3>                 FloatImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>  VectorImageType;
 
 inline bool my_isnan(float x)
  {
    volatile float d = x;
 
    if(d!=d)
      return true;
 
    if(d==d)
      return false;
    return d != d;
 
  }
 
 QmitkImageStatisticsView::QmitkImageStatisticsView(QObject* /*parent*/, const char* /*name*/)
 : m_Controls( NULL ),
   m_TimeStepperAdapter( NULL ),
   m_SelectedImageNode( NULL ),
   m_SelectedImage( NULL ),
   m_SelectedMaskNode( NULL ),
   m_SelectedImageMask( NULL ),
   m_SelectedPlanarFigure( NULL ),
   m_ImageObserverTag( -1 ),
   m_ImageMaskObserverTag( -1 ),
   m_PlanarFigureObserverTag( -1 ),
   m_CurrentStatisticsValid( false ),
   m_StatisticsUpdatePending( false ),
   m_Visible(false)
 {
 }
 
 
 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 );
 }
 
 
 void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkImageStatisticsViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_ErrorMessageLabel->hide();
 
     m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
     m_Controls->m_LineProfileWidget->SetPathModeToPlanarFigure();
   }
 }
 
 
 
 void QmitkImageStatisticsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ClipboardHistogramButtonClicked()));
     connect( (QObject*)(m_Controls->m_ButtonCopyStatisticsToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ClipboardStatisticsButtonClicked()));
     connect( (QObject*)(m_Controls->m_IgnoreZerosCheckbox), SIGNAL(clicked()),(QObject*) this, SLOT(IgnoreZerosCheckboxClicked()));
   }
 }
 
 void QmitkImageStatisticsView::IgnoreZerosCheckboxClicked(  )
 {
   UpdateStatistics();
 }
 
 void QmitkImageStatisticsView::ClipboardHistogramButtonClicked()
 {
   if ( m_CurrentStatisticsValid && (m_CurrentStatisticsCalculator.IsNotNull()) )
   {
     typedef mitk::ImageStatisticsCalculator::HistogramType HistogramType;
     const HistogramType *histogram = m_CurrentStatisticsCalculator->GetHistogram();
 
     QString clipboard( "Measurement \t Frequency\n" );
     for ( HistogramType::ConstIterator it = histogram->Begin();
           it != histogram->End();
           ++it )
     {
       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::ClipboardStatisticsButtonClicked()
 {
   if ( m_CurrentStatisticsValid && (m_CurrentStatisticsCalculator.IsNotNull()) )
   {
     const mitk::ImageStatisticsCalculator::Statistics &statistics =
       m_CurrentStatisticsCalculator->GetStatistics();
 
     // 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.Mean, 0, 'f', 10 )
       .arg( statistics.Sigma, 0, 'f', 10 )
       .arg( statistics.RMS, 0, 'f', 10 )
       .arg( statistics.Max, 0, 'f', 10 )
       .arg( statistics.Min, 0, 'f', 10 )
       .arg( statistics.N )
       .arg( m_Controls->m_StatisticsTable->item( 0, 6 )->text() );
 
     QApplication::clipboard()->setText(
       clipboard, QClipboard::Clipboard );
   }
   else
   {
     QApplication::clipboard()->clear();
   }
 }
 
 
 void QmitkImageStatisticsView::FillStatisticsTableView(
   const mitk::ImageStatisticsCalculator::Statistics &s,
   const mitk::Image *image )
 {
   m_Controls->m_StatisticsTable->setItem( 0, 0, new QTableWidgetItem(
     QString("%1").arg(s.Mean, 0, 'f', 2) ) );
 
   m_Controls->m_StatisticsTable->setItem( 0, 1, new QTableWidgetItem(
     QString("%1").arg(s.Sigma, 0, 'f', 2) ) );
 
   m_Controls->m_StatisticsTable->setItem( 0, 2, new QTableWidgetItem(
     QString("%1").arg(s.RMS, 0, 'f', 2) ) );
 
   m_Controls->m_StatisticsTable->setItem( 0, 3, new QTableWidgetItem(
     QString("%1").arg(s.Max, 0, 'f', 2) ) );
 
   m_Controls->m_StatisticsTable->setItem( 0, 4, new QTableWidgetItem(
     QString("%1").arg(s.Min, 0, 'f', 2) ) );
 
   m_Controls->m_StatisticsTable->setItem( 0, 5, new QTableWidgetItem(
     QString("%1").arg(s.N) ) );
 
   const mitk::Geometry3D *geometry = image->GetGeometry();
   if ( geometry != NULL )
   {
     const mitk::Vector3D &spacing = image->GetGeometry()->GetSpacing();
     double volume = spacing[0] * spacing[1] * spacing[2] * (double) s.N;
     m_Controls->m_StatisticsTable->setItem( 0, 6, new QTableWidgetItem(
       QString("%1").arg(volume, 0, 'f', 2) ) );
   }
   else
   {
     m_Controls->m_StatisticsTable->setItem( 0, 6, new QTableWidgetItem(
       "NA" ) );
   }
 }
 
 
 void QmitkImageStatisticsView::InvalidateStatisticsTableView()
 {
   for ( unsigned int i = 0; i < 7; ++i )
   {
     m_Controls->m_StatisticsTable->setItem( 0, i, new QTableWidgetItem( "NA" ) );
   }
 }
 
 
 void QmitkImageStatisticsView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*part*/,
                                                    const QList<mitk::DataNode::Pointer> &selectedNodes )
 {
   // Clear any unreferenced images
   this->RemoveOrphanImages();
 
   if ( !m_Visible || selectedNodes.isEmpty())
   {
     return;
   }
 
   // Check if selection makeup consists only of valid nodes:
   // One image, segmentation or planarFigure
   // One image and one of the other two
   bool tooManyNodes( true );
   bool invalidNodes( true );
 
   if ( selectedNodes.size() < 3 )
   {
     tooManyNodes = false;
   }
 
   QList<mitk::DataNode::Pointer> nodes(selectedNodes);
   if( !tooManyNodes )
   {
     unsigned int numberImages = 0;
     unsigned int numberSegmentations = 0;
     unsigned int numberPlanarFigures = 0;
 
     for ( int index = 0; index < nodes.size(); index++ )
     {
       m_SelectedImageMask = dynamic_cast< mitk::Image * >( nodes[ index ]->GetData() );
       m_SelectedPlanarFigure = dynamic_cast< mitk::PlanarFigure * >( nodes[ index ]->GetData() );
 
+      bool isPositionMarker (false);
+      nodes[index]->GetBoolProperty("isContourMarker", isPositionMarker);
+
       if ( m_SelectedImageMask != NULL )
       {
         bool isMask( false );
         nodes[ index ]->GetPropertyValue("binary", isMask);
         if ( !isMask )
         {
           numberImages++;
         }
         else
         {
           numberSegmentations++;
           if ( numberImages != 0 ) // image should be last element
           {
             std::swap( nodes[ index ], nodes[ index - 1 ] );
           }
         }
       }
-      else if ( m_SelectedPlanarFigure != NULL )
+      else if ( m_SelectedPlanarFigure != NULL && !isPositionMarker)
       {
         numberPlanarFigures++;
         if ( numberImages != 0 ) // image should be last element
         {
           std::swap( nodes[ index ], nodes[ index - 1 ] );
         }
       }
     }
 
     if ( ( numberPlanarFigures + numberSegmentations + numberImages ) == nodes.size() && //No invalid nodes
       ( numberPlanarFigures + numberSegmentations ) < 2 && numberImages < 2
       // maximum of one image and/or one of either planar figure or segmentation
       )
     {
       invalidNodes = false;
     }
   }
 
   if ( nodes.empty() || tooManyNodes || invalidNodes )
   {
     // Nothing to do: invalidate image, clear statistics, histogram, and GUI
     m_SelectedImage = NULL;
     this->InvalidateStatisticsTableView() ;
     m_Controls->m_HistogramWidget->ClearItemModel();
     m_Controls->m_LineProfileWidget->ClearItemModel();
 
     m_CurrentStatisticsValid = false;
     m_Controls->m_ErrorMessageLabel->hide();
     m_Controls->m_SelectedMaskLabel->setText( "None" );
     return;
   }
 
   // Get selected element
 
   mitk::DataNode *selectedNode = nodes.front();
   mitk::Image *selectedImage = dynamic_cast< mitk::Image * >( selectedNode->GetData() );
 
   // Find the next parent/grand-parent node containing an image, if any
   mitk::DataStorage::SetOfObjects::ConstPointer parentObjects;
   mitk::DataNode *parentNode = NULL;
   mitk::Image *parentImage = NULL;
 
   // Possibly previous change listeners
   if ( (m_SelectedPlanarFigure != NULL) && (m_PlanarFigureObserverTag >= 0) )
   {
     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
     m_PlanarFigureObserverTag = -1;
   }
   if ( (m_SelectedImage != NULL) && (m_ImageObserverTag >= 0) )
   {
     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
     m_ImageObserverTag = -1;
   }
   if ( (m_SelectedImageMask != NULL) && (m_ImageMaskObserverTag >= 0) )
   {
     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
     m_ImageMaskObserverTag = -1;
   }
 
   // Deselect all images and masks by default
   m_SelectedImageNode = NULL;
   m_SelectedImage = NULL;
   m_SelectedMaskNode = NULL;
   m_SelectedImageMask = NULL;
   m_SelectedPlanarFigure = NULL;
 
   {
     unsigned int parentObjectIndex = 0;
     parentObjects = this->GetDataStorage()->GetSources( selectedNode );
     while( parentObjectIndex < parentObjects->Size() )
     {
       // Use first parent object (if multiple parents are present)
       parentNode = parentObjects->ElementAt( parentObjectIndex );
       parentImage = dynamic_cast< mitk::Image * >( parentNode->GetData() );
       if( parentImage != NULL )
       {
         break;
       }
       parentObjectIndex++;
     }
   }
 
   if ( nodes.size() == 2 )
   {
     parentNode = nodes.back();
     parentImage = dynamic_cast< mitk::Image * >( parentNode->GetData() );
   }
 
   if ( parentImage != NULL )
   {
     m_SelectedImageNode = parentNode;
     m_SelectedImage = parentImage;
 
     // Check if a valid mask has been selected (Image or PlanarFigure)
     m_SelectedImageMask = dynamic_cast< mitk::Image * >( selectedNode->GetData() );
     m_SelectedPlanarFigure = dynamic_cast< mitk::PlanarFigure * >( selectedNode->GetData() );
 
     // Check whether ImageMask is a binary segmentation
 
     if ( (m_SelectedImageMask != NULL) )
     {
       bool isMask( false );
       selectedNode->GetPropertyValue("binary", isMask);
       if ( !isMask )
       {
         m_SelectedImageNode = selectedNode;
         m_SelectedImage = selectedImage;
         m_SelectedImageMask = NULL;
       }
       else
       {
         m_SelectedMaskNode = selectedNode;
       }
     }
     else if ( (m_SelectedPlanarFigure != NULL) )
     {
       m_SelectedMaskNode = selectedNode;
     }
   }
   else if ( selectedImage != NULL )
   {
     m_SelectedImageNode = selectedNode;
     m_SelectedImage = selectedImage;
   }
 
 
   typedef itk::SimpleMemberCommand< QmitkImageStatisticsView > ITKCommandType;
   ITKCommandType::Pointer changeListener;
   changeListener = ITKCommandType::New();
   changeListener->SetCallbackFunction( this, &QmitkImageStatisticsView::RequestStatisticsUpdate );
 
   // Add change listeners to selected objects
   if ( m_SelectedImage != NULL )
   {
     m_ImageObserverTag = m_SelectedImage->AddObserver(
       itk::ModifiedEvent(), changeListener );
   }
 
   if ( m_SelectedImageMask != NULL )
   {
     m_ImageMaskObserverTag = m_SelectedImageMask->AddObserver(
       itk::ModifiedEvent(), changeListener );
   }
 
   if ( m_SelectedPlanarFigure != NULL )
   {
     m_PlanarFigureObserverTag = m_SelectedPlanarFigure->AddObserver(
       mitk::EndInteractionPlanarFigureEvent(), changeListener );
   }
 
 
   // Clear statistics / histogram GUI if nothing is selected
   if ( m_SelectedImage == NULL )
   {
     // Clear statistics, histogram, and GUI
     this->InvalidateStatisticsTableView();
     m_Controls->m_HistogramWidget->ClearItemModel();
     m_Controls->m_LineProfileWidget->ClearItemModel();
     m_CurrentStatisticsValid = false;
     m_Controls->m_ErrorMessageLabel->hide();
     m_Controls->m_SelectedMaskLabel->setText( "None" );
   }
   else
   {
     // Else, request statistics and GUI update
     this->RequestStatisticsUpdate();
   }
 }
 
 
 void QmitkImageStatisticsView::UpdateStatistics()
 {
 
   // Remove any cached images that are no longer referenced elsewhere
   this->RemoveOrphanImages();
 
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   if ( renderPart == NULL )
   {
     return;
   }
 
   unsigned int timeStep = renderPart->GetTimeNavigationController()->GetTime()->GetPos();
 
   if ( m_SelectedImage != NULL )
   {
     // 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_HistogramWidget->ClearItemModel();
       m_CurrentStatisticsValid = false;
       return;
     }
 
     // Retrieve ImageStatisticsCalculator from has map (or create a new one
     // for this image if non-existant)
     ImageStatisticsMapType::iterator it =
       m_ImageStatisticsMap.find( m_SelectedImage );
 
     if ( it != m_ImageStatisticsMap.end() )
     {
       m_CurrentStatisticsCalculator = it->second;
       MITK_INFO << "Retrieving StatisticsCalculator";
     }
     else
     {
       m_CurrentStatisticsCalculator = mitk::ImageStatisticsCalculator::New();
       m_CurrentStatisticsCalculator->SetImage( m_SelectedImage );
       m_ImageStatisticsMap[m_SelectedImage] = m_CurrentStatisticsCalculator;
       MITK_INFO << "Creating StatisticsCalculator";
     }
 
     std::string maskName;
     std::string maskType;
     unsigned int maskDimension;
 
     if ( m_SelectedImageMask != NULL )
     {
       m_CurrentStatisticsCalculator->SetImageMask( m_SelectedImageMask );
       m_CurrentStatisticsCalculator->SetMaskingModeToImage();
 
       maskName = m_SelectedMaskNode->GetName();
       maskType = m_SelectedImageMask->GetNameOfClass();
       maskDimension = 3;
     }
     else if ( m_SelectedPlanarFigure != NULL )
     {
       m_CurrentStatisticsCalculator->SetPlanarFigure( m_SelectedPlanarFigure );
       m_CurrentStatisticsCalculator->SetMaskingModeToPlanarFigure();
 
       maskName = m_SelectedMaskNode->GetName();
       maskType = m_SelectedPlanarFigure->GetNameOfClass();
       maskDimension = 2;
     }
     else
     {
       m_CurrentStatisticsCalculator->SetMaskingModeToNone();
 
       maskName = "None";
       maskType = "";
       maskDimension = 0;
     }
 
     if(m_Controls->m_IgnoreZerosCheckbox->isChecked())
     {
       m_CurrentStatisticsCalculator->SetIgnorePixelValue(0);
       m_CurrentStatisticsCalculator->SetDoIgnorePixelValue(true);
     }
     else
     {
       m_CurrentStatisticsCalculator->SetDoIgnorePixelValue(false);
     }
 
     std::stringstream maskLabel;
     maskLabel << maskName;
     if ( maskDimension > 0 )
     {
       maskLabel << "  [" << maskDimension << "D " << maskType << "]";
     }
 
     m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
 
     bool statisticsChanged = false;
     bool statisticsCalculationSuccessful = false;
 
     // Initialize progress bar
     mitk::ProgressBar::GetInstance()->AddStepsToDo( 100 );
 
     // Install listener for progress events and initialize progress bar
     typedef itk::SimpleMemberCommand< QmitkImageStatisticsView > ITKCommandType;
     ITKCommandType::Pointer progressListener;
     progressListener = ITKCommandType::New();
     progressListener->SetCallbackFunction( this, &QmitkImageStatisticsView::UpdateProgressBar );
     unsigned long progressObserverTag = m_CurrentStatisticsCalculator
       ->AddObserver( itk::ProgressEvent(), progressListener );
 
     // show wait cursor
     this->WaitCursorOn();
 
     try
     {
       // Compute statistics
       statisticsChanged =
         m_CurrentStatisticsCalculator->ComputeStatistics( timeStep );
 
       statisticsCalculationSuccessful = true;
     }
     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();
     }
     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();
     }
 
     m_CurrentStatisticsCalculator->RemoveObserver( progressObserverTag );
 
     // Make sure that progress bar closes
     mitk::ProgressBar::GetInstance()->Progress( 100 );
 
     // remove wait cursor
     this->WaitCursorOff();
 
     if ( statisticsCalculationSuccessful )
     {
       if ( statisticsChanged )
       {
         // Do not show any error messages
         m_Controls->m_ErrorMessageLabel->hide();
 
         m_CurrentStatisticsValid = true;
       }
 
       m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
       m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
       m_Controls->m_HistogramWidget->SetHistogram(
         m_CurrentStatisticsCalculator->GetHistogram( timeStep ) );
       m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
 
       MITK_INFO << "UpdateItemModelFromHistogram()";
 
       this->FillStatisticsTableView(
         m_CurrentStatisticsCalculator->GetStatistics( timeStep ),
         m_SelectedImage );
     }
     else
     {
       m_Controls->m_SelectedMaskLabel->setText( "None" );
 
       // Clear statistics and histogram
       this->InvalidateStatisticsTableView();
       m_Controls->m_HistogramWidget->ClearItemModel();
       m_CurrentStatisticsValid = false;
 
 
       // If a (non-closed) PlanarFigure is selected, display a line profile widget
       if ( m_SelectedPlanarFigure != NULL )
       {
         // check whether PlanarFigure is initialized
         const mitk::Geometry2D *planarFigureGeometry2D = m_SelectedPlanarFigure->GetGeometry2D();
         if ( planarFigureGeometry2D == NULL )
         {
           // Clear statistics, histogram, and GUI
           this->InvalidateStatisticsTableView();
           m_Controls->m_HistogramWidget->ClearItemModel();
           m_Controls->m_LineProfileWidget->ClearItemModel();
           m_CurrentStatisticsValid = false;
           m_Controls->m_ErrorMessageLabel->hide();
           m_Controls->m_SelectedMaskLabel->setText( "None" );
           return;
         }
         // TODO: enable line profile widget
         m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 1 );
         m_Controls->m_LineProfileWidget->SetImage( m_SelectedImage );
         m_Controls->m_LineProfileWidget->SetPlanarFigure( m_SelectedPlanarFigure );
         m_Controls->m_LineProfileWidget->UpdateItemModelFromPath();
       }
     }
   }
 }
 
 void QmitkImageStatisticsView::UpdateProgressBar()
 {
   mitk::ProgressBar::GetInstance()->Progress();
 }
 
 
 void QmitkImageStatisticsView::RequestStatisticsUpdate()
 {
   if ( !m_StatisticsUpdatePending )
   {
     QApplication::postEvent( this, new QmitkRequestStatisticsUpdateEvent );
     m_StatisticsUpdatePending = true;
   }
 }
 
 
 void QmitkImageStatisticsView::RemoveOrphanImages()
 {
   ImageStatisticsMapType::iterator it = m_ImageStatisticsMap.begin();
 
   while ( it != m_ImageStatisticsMap.end() )
   {
     mitk::Image *image = it->first;
     mitk::ImageStatisticsCalculator *calculator = it->second;
     ++it;
 
     mitk::NodePredicateData::Pointer hasImage = mitk::NodePredicateData::New( image );
     if ( this->GetDataStorage()->GetNode( hasImage ) == NULL )
     {
       if ( m_SelectedImage == image )
       {
         m_SelectedImage = NULL;
         m_SelectedImageNode = NULL;
       }
       if ( m_CurrentStatisticsCalculator == calculator )
       {
         m_CurrentStatisticsCalculator = NULL;
       }
       m_ImageStatisticsMap.erase( image );
       it = m_ImageStatisticsMap.begin();
     }
   }
 }
 
 
 bool QmitkImageStatisticsView::event( QEvent *event )
 {
   if ( event->type() == (QEvent::Type) QmitkRequestStatisticsUpdateEvent::StatisticsUpdateRequest )
   {
     // Update statistics
 
     m_StatisticsUpdatePending = false;
 
     this->UpdateStatistics();
     return true;
   }
 
   return false;
 }
 
 void QmitkImageStatisticsView::ComputeIntensityProfile( mitk::PlanarLine* line )
 {
   double sampling = 300;
   QmitkVtkHistogramWidget::HistogramType::Pointer histogram = QmitkVtkHistogramWidget::HistogramType::New();
   itk::Size<1> siz;
   siz[0] = sampling;
   itk::FixedArray<double,1> lower, higher;
   lower.Fill(0);
     mitk::Point3D begin = line->GetWorldControlPoint(0);
   mitk::Point3D end = line->GetWorldControlPoint(1);
   itk::Vector<double,3> direction = (end - begin);
   higher.Fill(direction.GetNorm());
   histogram->Initialize(siz, lower, higher);
   for(int i = 0; i < sampling; i++)
   {
     //mitk::Point3D location = begin + double(i)/sampling * direction;
     double d = m_SelectedImage->GetPixelValueByWorldCoordinate(begin + double(i)/sampling * direction);
     histogram->SetFrequency(i,d);
   }
   m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
   m_Controls->m_HistogramWidget->SetHistogram( histogram );
   m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
 
 }
 
 
 void QmitkImageStatisticsView::Activated()
 {
 }
 
 void QmitkImageStatisticsView::Deactivated()
 {
 }
 
 void QmitkImageStatisticsView::Visible()
 {
   m_Visible = true;
   this->OnSelectionChanged(this->GetSite()->GetPage()->FindView("org.mitk.views.datamanager"),
                            this->GetDataManagerSelection());
 }
 
 void QmitkImageStatisticsView::Hidden()
 {
   m_Visible = false;
 }
 
 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 a982cb2094..95d13f0d35 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
@@ -1,702 +1,704 @@
 /*===================================================================
 
 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 <mitkVtkLayerController.h>
 #include <mitkWeakPointer.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarAngle.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarLine.h>
 #include <mitkPlanarCross.h>
 #include <mitkPlanarFourPointAngle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkNodePredicateDataType.h>
 #include <QmitkRenderWindow.h>
 
 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_EllipseCounter(0),
       m_RectangleCounter(0), m_PolygonCounter(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_EllipseCounter;
   unsigned int m_RectangleCounter;
   unsigned int m_PolygonCounter;
   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_DrawEllipse;
   QAction* m_DrawRectangle;
   QAction* m_DrawPolygon;
   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_DrawEllipse = 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);
 
   // 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_DrawEllipse, SIGNAL( triggered(bool) )
     , this, SLOT( ActionDrawEllipseTriggered(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_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());
-  if( figure )
+  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->GetInteractor());
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", nonConstNode);
     }
     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);
 
   if( it != d->m_DataNodeToPlanarFigureData.end() )
   {
     QmitkPlanarFigureData& data = it->second;
 
     MEASUREMENT_DEBUG << "removing figure interactor to globalinteraction";
     mitk::Interactor::Pointer oldInteractor = node->GetInteractor();
 //    if(oldInteractor.IsNotNull())
 //      mitk::GlobalInteraction::GetInstance()->RemoveInteractor(oldInteractor);
 
     // 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";
     d->m_DataNodeToPlanarFigureData.erase( it );
   }
 
   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_DrawEllipse->setChecked(false);
   d->m_DrawRectangle->setChecked(false);
   d->m_DrawPolygon->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();   
 
   for( int i=d->m_CurrentSelection.size()-1; i>= 0; --i)
   {
     mitk::DataNode* node = d->m_CurrentSelection.at(i);
 
     mitk::PlanarFigure* _PlanarFigure =
         _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     // the last selected planar figure
     if( _PlanarFigure )
     {
       mitk::ILinkedRenderWindowPart* linkedRenderWindow =
           dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
       if( linkedRenderWindow )
       {
         mitk::Point3D centerP = _PlanarFigure->GetGeometry()->GetOrigin();
         linkedRenderWindow->GetRenderWindow("transversal")->GetSliceNavigationController()->SelectSliceByPoint(centerP);
       }
       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::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);
 
   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::ActionDrawEllipseTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
   QString qString = QString("Circle%1").arg(++d->m_EllipseCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarCircle 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);
   this->AddFigureToDataStorage(figure, qString);
 
   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( size_t 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;
   unsigned int j = 1;
   mitk::PlanarFigure* _PlanarFigure = 0;
   mitk::PlanarAngle* planarAngle = 0;
   mitk::PlanarFourPointAngle* planarFourPointAngle = 0;
   mitk::DataNode::Pointer node = 0;
 
   for (unsigned 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 to all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
   const mitk::DataNode* node = 0;
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
     ; it++)
   {
     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
     this->NodeAdded( node );
   }
 }
 
 void QmitkMeasurementView::RemoveAllInteractors()
 {
   MEASUREMENT_DEBUG << "Removing interactors and observers from all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
   const mitk::DataNode* node = 0;
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
     ; it++)
   {
     node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
     this->NodeRemoved( node );
   }
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::DetectTopMostVisibleImage()
 {
   // get all images from the data storage
   mitk::DataStorage::SetOfObjects::ConstPointer Images
       = this->GetDataStorage()->GetSubset( mitk::NodePredicateDataType::New("Image") );
 
   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;
     int layer = 0;
     node->GetIntProperty("layer", layer);
     if ( layer < maxLayer )
       continue;
 
     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);
   }
 }