diff --git a/Modules/QmitkExt/QmitkHistogramJSWidget.cpp b/Modules/QmitkExt/QmitkHistogramJSWidget.cpp
index baaace81ba..c0a2e33188 100644
--- a/Modules/QmitkExt/QmitkHistogramJSWidget.cpp
+++ b/Modules/QmitkExt/QmitkHistogramJSWidget.cpp
@@ -1,238 +1,293 @@
 /*===================================================================
 
 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 "QmitkHistogramJSWidget.h"
+#include "mitkPixelTypeMultiplex.h"
+#include <mitkImagePixelReadAccessor.h>
+#include "mitkRenderingManager.h"
+#include "mitkBaseRenderer.h"
+#include "mitkImageTimeSelector.h"
+#include "mitkExtractSliceFilter.h"
 
 QmitkHistogramJSWidget::QmitkHistogramJSWidget(QWidget *parent) :
   QWebView(parent)
 {
-  // set histogram to barchart in first instance
+  // set histogram type to barchart in first instance
   m_UseLineGraph = false;
 
-  // prepare html for use
+  // set html from source
   connect(page()->mainFrame(), SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(AddJSObject()));
   QUrl myUrl = QUrl("qrc:/qmitk/Histogram.html");
   setUrl(myUrl);
 
-  // set Scrollbars to always disabled
+  // set Scrollbars to be always disabled
   page()->mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
   page()->mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
 
   m_ParametricPath = ParametricPathType::New();
 }
 
 QmitkHistogramJSWidget::~QmitkHistogramJSWidget()
 {
 
 }
 
-// adds an Object of Type QmitkHistogramJSWidget to the JavaScript
+// adds an Object of Type QmitkHistogramJSWidget to the JavaScript, using QtWebkitBridge
 void QmitkHistogramJSWidget::AddJSObject()
 {
   page()->mainFrame()->addToJavaScriptWindowObject(QString("histogramData"), this);
 }
 
 
-// reloads WebView, everytime his size has been changed, so the size of the Histogram fits to the size of the widget
+// reloads WebView, everytime its size has been changed, so the size of the Histogram fits to the size of the widget
 void QmitkHistogramJSWidget::resizeEvent(QResizeEvent* resizeEvent)
 {
   QWebView::resizeEvent(resizeEvent);
   this->reload();
 }
 
 // method to expose data to JavaScript by using properties
 void QmitkHistogramJSWidget::ComputeHistogram(HistogramType* histogram)
 {
   m_Histogram = histogram;
   HistogramConstIteratorType startIt = m_Histogram->End();
   HistogramConstIteratorType endIt = m_Histogram->End();
   HistogramConstIteratorType it;
   ClearData();
   unsigned int i = 0;
   bool firstValue = false;
-  // filter frequencies of 0 to guarantee a better view while using a mask
+  // removes frequencies of 0, which are outside the first and last bin
   for (it = m_Histogram->Begin() ; it != m_Histogram->End(); ++it)
   {
     if (it.GetFrequency() > 0.0)
     {
       endIt = it;
       if (!firstValue)
       {
         firstValue = true;
         startIt = it;
       }
     }
   }
   ++endIt;
+  // generating Lists of measurement and frequencies
   for (it = startIt ; it != endIt; ++it, ++i)
   {
     QVariant frequency = it.GetFrequency();
     QVariant measurement = it.GetMeasurementVector()[0];
     m_Frequency.insert(i, frequency);
     m_Measurement.insert(i, measurement);
   }
   m_IntensityProfile = false;
   this->SignalDataChanged();
 }
 
 void QmitkHistogramJSWidget::ClearData()
 {
   m_Frequency.clear();
   m_Measurement.clear();
 }
 
 void QmitkHistogramJSWidget::ClearHistogram()
 {
   this->ClearData();
   this->SignalDataChanged();
 }
 
 QList<QVariant> QmitkHistogramJSWidget::GetFrequency()
 {
   return m_Frequency;
 }
 
 QList<QVariant> QmitkHistogramJSWidget::GetMeasurement()
 {
   return m_Measurement;
 }
 
 bool QmitkHistogramJSWidget::GetUseLineGraph()
 {
   return m_UseLineGraph;
 }
 
 void QmitkHistogramJSWidget::OnBarRadioButtonSelected()
 {
   m_UseLineGraph = false;
   this->SignalGraphChanged();
 }
 
 void QmitkHistogramJSWidget::OnLineRadioButtonSelected()
 {
   m_UseLineGraph = true;
   this->SignalGraphChanged();
 }
 
 void QmitkHistogramJSWidget::SetImage(mitk::Image* image)
 {
   m_Image = image;
 }
 
 void QmitkHistogramJSWidget::SetPlanarFigure(const mitk::PlanarFigure* planarFigure)
 {
   m_PlanarFigure = planarFigure;
 }
 
-void QmitkHistogramJSWidget::ComputeIntensityProfile()
+template <class PixelType>
+void ReadPixel(mitk::PixelType ptype, mitk::Image::Pointer image, mitk::Index3D indexPoint, double& value)
+{
+  if (image->GetDimension() == 2)
+  {
+    mitk::ImagePixelReadAccessor<PixelType,2> readAccess(image, image->GetSliceData(0));
+    itk::Index<2> idx;
+    idx[0] = indexPoint[0];
+    idx[1] = indexPoint[1];
+    value = readAccess.GetPixelByIndex(idx);
+  }
+  else if (image->GetDimension() == 3)
+  {
+    mitk::ImagePixelReadAccessor<PixelType,3> readAccess(image, image->GetVolumeData(0));
+    itk::Index<3> idx;
+    idx[0] = indexPoint[0];
+    idx[1] = indexPoint[1];
+    idx[2] = indexPoint[2];
+    value = readAccess.GetPixelByIndex(idx);
+  }
+  else
+  {
+    //unhandled
+  }
+}
+
+void QmitkHistogramJSWidget::ComputeIntensityProfile(unsigned int timeStep)
 {
   this->ClearData();
   m_ParametricPath->Initialize();
 
   if (m_PlanarFigure.IsNull())
   {
-    throw std::invalid_argument("PlanarFigure not set!");
+    mitkThrow() << "PlanarFigure not set!";
   }
 
   if (m_Image.IsNull())
   {
-    throw std::invalid_argument("Image not set!");
+    mitkThrow() << "Image not set!";
   }
 
+  // Get 2D geometry frame of PlanarFigure
   mitk::Geometry2D* planarFigureGeometry2D = dynamic_cast<mitk::Geometry2D*>(m_PlanarFigure->GetGeometry(0));
   if (planarFigureGeometry2D == NULL)
   {
-    throw std::invalid_argument("PlanarFigure has no valid geometry!");
+    mitkThrow() << "PlanarFigure has no valid geometry!";
   }
 
+  // Get 3D geometry from Image (needed for conversion of point to index)
   mitk::Geometry3D* imageGeometry = m_Image->GetGeometry(0);
   if (imageGeometry == NULL)
   {
-    throw std::invalid_argument("Image has no valid geometry!");
+    mitkThrow() << "Image has no valid geometry!";
   }
 
-  typedef mitk::PlanarFigure::PolyLineType VertexContainerType;
+  // Get first poly-line of PlanarFigure (other possible poly-lines in PlanarFigure
+  // are not supported)
   const VertexContainerType vertexContainer = m_PlanarFigure->GetPolyLine(0);
 
   VertexContainerType::const_iterator it;
   for (it = vertexContainer.begin(); it != vertexContainer.end(); ++it)
   {
+    // Map PlanarFigure 2D point to 3D point
     mitk::Point3D point3D;
     planarFigureGeometry2D->Map(it->Point, point3D);
 
+    // Convert world to index coordinates
     mitk::Point3D indexPoint3D;
     imageGeometry->WorldToIndex(point3D, indexPoint3D);
 
     ParametricPathType::OutputType index;
     index[0] = indexPoint3D[0];
     index[1] = indexPoint3D[1];
     index[2] = indexPoint3D[2];
 
+    // Add index to parametric path
     m_ParametricPath->AddVertex(index);
   }
 
   m_DerivedPath = m_ParametricPath;
 
   if (m_DerivedPath.IsNull())
   {
-    throw std::invalid_argument("No path set!");
+    mitkThrow() << "No path set!";
   }
 
+  // Fill item model with line profile data
   double distance = 0.0;
   mitk::Point3D currentWorldPoint;
 
   double t;
   unsigned int i = 0;
-  int k = 0;
   for (i = 0, t = m_DerivedPath->StartOfInput(); ;++i)
   {
     const PathType::OutputType &continousIndex = m_DerivedPath->Evaluate(t);
 
     mitk::Point3D worldPoint;
     imageGeometry->IndexToWorld(continousIndex, worldPoint);
 
     if (i == 0)
     {
       currentWorldPoint = worldPoint;
     }
 
+
     distance += currentWorldPoint.EuclideanDistanceTo(worldPoint);
     mitk::Index3D indexPoint;
     imageGeometry->WorldToIndex(worldPoint, indexPoint);
-    double intensity = m_Image->GetPixelValueByIndex(indexPoint);
+    const mitk::PixelType ptype = m_Image->GetPixelType();
+    double intensity = 0.0;
+    if (m_Image->GetDimension() == 4)
+    {
+      mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
+      timeSelector->SetInput(m_Image);
+      timeSelector->SetTimeNr(timeStep);
+      timeSelector->Update();
+      mitk::Image::Pointer image = timeSelector->GetOutput();
+      mitkPixelTypeMultiplex3( ReadPixel, ptype, image, indexPoint, intensity);
+    }
+    else
+    {
+      mitkPixelTypeMultiplex3( ReadPixel, ptype, m_Image, indexPoint, intensity);
+    }
 
     m_Measurement.insert(i, distance);
     m_Frequency.insert(i, intensity);
 
+    // Go to next index; when iteration offset reaches zero, iteration is finished
     PathType::OffsetType offset = m_DerivedPath->IncrementInput(t);
     if (!(offset[0] || offset[1] || offset[2]))
     {
       break;
     }
 
     currentWorldPoint = worldPoint;
   }
 
   m_IntensityProfile = true;
   m_UseLineGraph = true;
   this->SignalDataChanged();
 }
 
 bool QmitkHistogramJSWidget::GetIntensityProfile()
 {
   return m_IntensityProfile;
 }
diff --git a/Modules/QmitkExt/QmitkHistogramJSWidget.h b/Modules/QmitkExt/QmitkHistogramJSWidget.h
index 26d379b4c2..7d59f82199 100644
--- a/Modules/QmitkExt/QmitkHistogramJSWidget.h
+++ b/Modules/QmitkExt/QmitkHistogramJSWidget.h
@@ -1,270 +1,275 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #ifndef QMITKHISTOGRAMJSWIDGET_H
 #define QMITKHISTOGRAMJSWIDGET_H
 
 #include <QWidget>
 #include <QUrl>
 #include <QtWebKit/QtWebKit>
 #include "QmitkExtExports.h"
 #include <QVariant>
 #include "mitkImage.h"
 #include "mitkPlanarFigure.h"
 #include <itkPolyLineParametricPath.h>
 
 /**
 * \brief Widget which shows a histogram using JavaScript.
 *
 * This class is a QWebView. It shows the histogram for a selected image
-* or segmentation. It also can also display an intesity profile for
-* path elements, which lay over an image.
+* or segmentation. It also can display an intesity profile for
+* path elements, which lais over an image.
 */
 class QmitkExt_EXPORT QmitkHistogramJSWidget : public QWebView
 {
   Q_OBJECT
 
   /**
   * \brief Measurement property.
   *
-  * This property is used in JavaScript as member of current object.
+  * This property is used in JavaScript as member of the current object.
+  * It holds a QList, containing the measurements of the current histogram.
   * @see GetMeasurement()
   */
   Q_PROPERTY(QList<QVariant> measurement
              READ GetMeasurement)
 
   /**
   * \brief Frequency property.
   *
-  * This property is used in JavaScript as member of current object.
+  * This property is used in JavaScript as member of the current object.
+  * It holds a QList, containing the frequencies of the current histogram.
   * @see GetFrequency()
   */
   Q_PROPERTY(QList<QVariant> frequency
              READ GetFrequency)
 
   /**
   * \brief Line graph property.
   *
-  * This property is used in JavaScript as member of current object.
+  * This property is used in JavaScript as member of the current object.
+  * It holds a boolean, which sais wether to use a line or not.
   * @see GetUseLineGraph()
   */
   Q_PROPERTY(bool useLineGraph
              READ GetUseLineGraph)
 
   /**
   * @brief Intesity profile property.
   *
-  * This property is used in JavaScript as member of current object.
+  * This property is used in JavaScript as member of the current object.
+  * It holds a boolean, which sais wether to use an intesity profile or not.
   * @see GetIntensityProfile()
   */
   Q_PROPERTY(bool intensityProfile
              READ GetIntensityProfile)
 
 public:
   typedef mitk::Image::HistogramType HistogramType;
   typedef mitk::Image::HistogramType::ConstIterator HistogramConstIteratorType;
   typedef itk::PolyLineParametricPath< 3 > ParametricPathType;
   typedef itk::ParametricPath< 3 >::Superclass PathType;
+  typedef mitk::PlanarFigure::PolyLineType VertexContainerType;
 
   explicit QmitkHistogramJSWidget(QWidget *parent = 0);
 
 
   ~QmitkHistogramJSWidget();
 
   /**
   * \brief Event which notifies a change of the widget size.
   *
-  * Reimplemented event from QWebView::resizeEvent(),
+  * Reimplemented from QWebView::resizeEvent(),
   * reloads the webframe
   */
   void resizeEvent(QResizeEvent* resizeEvent);
 
   /**
   * \brief Calculates the histogram.
   *
-  * This function filters all frequencies of 0 to the first and after the last bin.
-  * Writes the measurement and frequency, which are given from the HistogramType, into
+  * This function removes all frequencies of 0 until the first bin and behind the last bin.
+  * It writes the measurement and frequency, which are given from the HistogramType, into
   * m_Measurement and m_Frequency.
-  * Calls the signal DataChanged to update the shown information in the webframe.
+  * The SignalDataChanged is called, to update the information, which is displayed in the webframe.
   */
   void ComputeHistogram(HistogramType* histogram);
 
   /**
   * \brief Calculates the intesityprofile.
   *
-  * m_Image and m_PlanarFigure must be set first!
-  * Calculates an intensity profile for a pathelement which lies over an image.
+  * If an image and a pathelement are set, this function
+  * calculates an intensity profile for a pathelement which lies over an image.
   * Sets m_IntensityProfile and m_UseLineGraph to true.
-  * Calls SignalDataChanged to update the shown information in the webframe.
+  * The SignalDataChanged is called, to update the information, which is displayed in the webframe.
   */
-  void ComputeIntensityProfile();
+  void ComputeIntensityProfile(unsigned int timeStep = 0);
 
   /**
   * \brief Clears the Histogram.
   *
-  * This function clears the data and calls the signal DataChanged to update
-  * the shown information in the webframe.
+  * This function clears the data and calls SignalDataChanged to update
+  * the displayed information in the webframe.
   */
   void ClearHistogram();
 
   /**
-  * \brief Get operation for measurement.
+  * \brief Getter for measurement.
   *
   * @return List of measurements.
   */
   QList<QVariant> GetMeasurement();
 
   /**
-  * \brief Get operation for frequency.
+  * \brief Getter for frequency.
   *
   * @return List of frequencies.
   */
   QList<QVariant> GetFrequency();
 
   /**
-  * \brief Get operation for uselineGraph.
+  * \brief Getter for uselineGraph.
   *
   * @return True if a linegraph should be used.
   */
   bool GetUseLineGraph();
 
   /**
-  * \brief Get operation for intensity profile.
+  * \brief Getter for intensity profile.
   *
   * @return True if current histogram is an intesityprofile
   */
   bool GetIntensityProfile();
 
   /**
-  * \brief Set operation for reference image.
+  * \brief Setter for reference image.
   *
   * @param image The corresponding image for an intensity profile.
   */
   void SetImage(mitk::Image* image);
 
   /**
-  * \brief Set operation for  planarFigure.
+  * \brief Setter for planarFigure.
   *
   * @param planarFigure The pathelement for an intensity profile.
   */
   void SetPlanarFigure(const mitk::PlanarFigure* planarFigure);
 
 private:
 
   /**
   * \brief List of frequencies.
   *
   * A QList which holds the frequencies of the current histogram
   * or holds the intesities of current intensity profile.
   */
   QList<QVariant> m_Frequency;
 
   /**
   * \brief List of measurements.
   *
   * A QList which holds the measurements of the current histogram
   * or holds the distances of current intensity profile.
   */
   QList<QVariant> m_Measurement;
 
   /**
   * \brief Reference image.
   *
   * Holds the image to calculate an intesity profile.
   */
   mitk::Image::Pointer m_Image;
 
   /**
   * \brief Pathelement.
   *
   * Holds a not closed planar figure to calculate an intesity profile.
   */
   mitk::PlanarFigure::ConstPointer m_PlanarFigure;
 
   bool m_UseLineGraph;
   bool m_IntensityProfile;
 
   /**
   * Holds the current histogram
   */
   HistogramType::ConstPointer m_Histogram;
 
   /**
   * Path derived either form user-specified path or from PlanarFigure-generated
   * path
   */
   PathType::ConstPointer m_DerivedPath;
 
   /**
   * Parametric path as generated from PlanarFigure
   */
   ParametricPathType::Pointer m_ParametricPath;
 
   /**
   * \brief Clears data.
   *
   * Clears the QLists m_Measurement and m_Frequency
   */
   void ClearData();
 
 private slots:
 
   /**
   * \brief Adds an object to JavaScript.
   *
   * Adds an object of the widget to JavaScript.
   * By using this object JavaScript can react to the signals of the widget
   * and can access the QProperties as members of the object.
   */
   void AddJSObject();
 
 public slots:
 
   /**
   * \brief Slot for radiobutton m_barRadioButton.
   *
   * Sets m_UseLineGraph to false.
   * Calls signal GraphChanged to update the graph in the webframe.
   */
   void OnBarRadioButtonSelected();
 
   /**
   * \brief Slot for radiobutton m_lineRadioButton.
   *
   * Sets m_UseLineGraph to true.
   * Calls signal GraphChanged to update the graph in the webframe.
   */
   void OnLineRadioButtonSelected();
 
 signals:
 
   /**
   * \brief Signal data has changed.
   *
   * It has to be called when the data of the histogram or intesity profile has changed.
   */
   void SignalDataChanged();
 
   /**
   * \brief Signal graph has changed.
   *
   * It has to be called when the graph changed from barchart to linegraph. Vice versa.
   */
   void SignalGraphChanged();
 };
 
 #endif // QMITKHISTOGRAMJSWIDGET_H
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 c96f8f5406..4a7f2d3d74 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,721 +1,722 @@
 /*===================================================================
 
 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>
 
 // 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";
 
 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_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);
     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*)(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()));
   }
 }
 
 void QmitkImageStatisticsView::JumpToCoordinates(int row ,int col)
 {
     mitk::Point3D world;
     if (row==4)
         world = m_WorldMin;
     else if (row==3)
         world = m_WorldMax;
     else
         return;
 
     mitk::IRenderWindowPart* part = this->GetRenderWindowPart();
     if (part)
     {
         part->GetRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(world);
         part->GetRenderWindow("sagittal")->GetSliceNavigationController()->SelectSliceByPoint(world);
         part->GetRenderWindow("coronal")->GetSliceNavigationController()->SelectSliceByPoint(world);
     }
 }
 
 void QmitkImageStatisticsView::OnIgnoreZerosCheckboxClicked()
 {
   emit StatisticsUpdate();
 }
 
 void QmitkImageStatisticsView::OnClipboardHistogramButtonClicked()
 {
   if ( m_CurrentStatisticsValid )
   {
     typedef mitk::ImageStatisticsCalculator::HistogramType HistogramType;
     const HistogramType *histogram = this->m_CalculationThread->GetTimeStepHistogram().GetPointer();
 
     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::OnClipboardStatisticsButtonClicked()
 {
   if ( this->m_CurrentStatisticsValid )
   {
     const mitk::ImageStatisticsCalculator::Statistics &statistics =
       this->m_CalculationThread->GetStatisticsData();
 
     // 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::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;
   }
 
   this->ReinitData();
   if (!selectedNodes.size())
   {
     m_Controls->m_JSHistogram->ClearHistogram();
     m_Controls->m_lineRadioButton->setEnabled(true);
     m_Controls->m_barRadioButton->setEnabled(true);
     m_Controls->m_InfoLabel->setText(QString(""));
   }
   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_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_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_WorldMin.Fill(-1);
   m_WorldMax.Fill(-1);
 
  // classify selected nodes
   mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
 
   std::string maskName = std::string();
   std::string maskType = 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);
         }
       }
     }
     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 (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_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() );
 
     // check time step validity
     if(m_SelectedImage->GetDimension() <= 3 && timeStep > m_SelectedImage->GetDimension(3)-1)
     {
       timeStep = m_SelectedImage->GetDimension(3)-1;
     }
 
     //// 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 );
     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->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::WriteStatisticsToGUI()
 {
   m_Controls->m_lineRadioButton->setEnabled(true);
   m_Controls->m_barRadioButton->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_JSHistogram->ComputeHistogram( this->m_CalculationThread->GetTimeStepHistogram().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 whether PlanarFigure is initialized
       const mitk::Geometry2D *planarFigureGeometry2D = m_SelectedPlanarFigure->GetGeometry2D();
       if ( planarFigureGeometry2D == NULL )
       {
         // 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_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();
+      m_Controls->m_JSHistogram->ComputeIntensityProfile(timeStep);
       m_Controls->m_lineRadioButton->setEnabled(false);
       m_Controls->m_barRadioButton->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::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++)
   {
     double d = m_SelectedImage->GetPixelValueByWorldCoordinate(begin + double(i)/sampling * direction);
     histogram->SetFrequency(i,d);
   }
   m_Controls->m_JSHistogram->ComputeHistogram( histogram );
 }
 
 void QmitkImageStatisticsView::FillStatisticsTableView(
   const mitk::ImageStatisticsCalculator::Statistics &s,
   const mitk::Image *image )
 {
     if (s.MaxIndex.size()==3)
     {
         mitk::Point3D index;
         index[0] = s.MaxIndex[0];
         index[1] = s.MaxIndex[1];
         index[2] = s.MaxIndex[2];
         m_SelectedImage->GetGeometry()->IndexToWorld(index, m_WorldMax);
         index[0] = s.MinIndex[0];
         index[1] = s.MinIndex[1];
         index[2] = s.MinIndex[2];
         m_SelectedImage->GetGeometry()->IndexToWorld(index, m_WorldMin);
     }
 
     int decimals = 2;
 
     mitk::PixelType doublePix = mitk::MakeScalarPixelType< double >();
     mitk::PixelType floatPix = mitk::MakeScalarPixelType< float >();
     if (image->GetPixelType()==doublePix || image->GetPixelType()==floatPix)
         decimals = 5;
 
   this->m_Controls->m_StatisticsTable->setItem( 0, 0, new QTableWidgetItem(
     QString("%1").arg(s.Mean, 0, 'f', decimals) ) );
   this->m_Controls->m_StatisticsTable->setItem( 0, 1, new QTableWidgetItem(
     QString("%1").arg(s.Sigma, 0, 'f', decimals) ) );
 
   this->m_Controls->m_StatisticsTable->setItem( 0, 2, new QTableWidgetItem(
     QString("%1").arg(s.RMS, 0, 'f', decimals) ) );
 
     QString max; max.append(QString("%1").arg(s.Max, 0, 'f', decimals));
     max += " (";
     for (int i=0; i<s.MaxIndex.size(); i++)
     {
         max += QString::number(s.MaxIndex[i]);
         if (i<s.MaxIndex.size()-1)
             max += ",";
     }
     max += ")";
   this->m_Controls->m_StatisticsTable->setItem( 0, 3, new QTableWidgetItem( max ) );
 
     QString min; min.append(QString("%1").arg(s.Min, 0, 'f', decimals));
     min += " (";
     for (int i=0; i<s.MinIndex.size(); i++)
     {
         min += QString::number(s.MinIndex[i]);
         if (i<s.MinIndex.size()-1)
             min += ",";
     }
     min += ")";
   this->m_Controls->m_StatisticsTable->setItem( 0, 4, new QTableWidgetItem( min ) );
 
   this->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;
     this->m_Controls->m_StatisticsTable->setItem( 0, 6, new QTableWidgetItem(
       QString("%1").arg(volume, 0, 'f', decimals) ) );
   }
   else
   {
     this->m_Controls->m_StatisticsTable->setItem( 0, 6, new QTableWidgetItem(
       "NA" ) );
   }
 }
 
 void QmitkImageStatisticsView::InvalidateStatisticsTableView()
 {
   for ( unsigned int i = 0; i < 7; ++i )
   {
     this->m_Controls->m_StatisticsTable->setItem( 0, i, new QTableWidgetItem( "NA" ) );
   }
 }
 
 void QmitkImageStatisticsView::Activated()
 {
 }
 
 void QmitkImageStatisticsView::Deactivated()
 {
 }
 
 void QmitkImageStatisticsView::Visible()
 {
   m_Visible = true;
   if (m_DataNodeSelectionChanged)
   {
     if (this->IsCurrentSelectionValid())
     {
       this->SelectionChanged(this->GetCurrentSelection());
     }
     else
     {
       this->SelectionChanged(this->GetDataManagerSelection());
     }
     m_DataNodeSelectionChanged = false;
   }
 }
 
 void QmitkImageStatisticsView::Hidden()
 {
   m_Visible = false;
 }
 
 void QmitkImageStatisticsView::SetFocus()
 {
 }