diff --git a/Modules/ImageStatistics/mitkIntensityProfile.cpp b/Modules/ImageStatistics/mitkIntensityProfile.cpp
index 6b8f70f61e..eb93ca2bb7 100644
--- a/Modules/ImageStatistics/mitkIntensityProfile.cpp
+++ b/Modules/ImageStatistics/mitkIntensityProfile.cpp
@@ -1,337 +1,381 @@
/*===================================================================
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 <itkLinearInterpolateImageFunction.h>
#include <itkNearestNeighborInterpolateImageFunction.h>
#include <itkPolyLineParametricPath.h>
#include <itkWindowedSincInterpolateImageFunction.h>
#include <mitkImageAccessByItk.h>
#include <mitkImagePixelReadAccessor.h>
#include <mitkPixelTypeMultiplex.h>
#include "mitkIntensityProfile.h"
using namespace mitk;
template <class T>
static void ReadPixel(const PixelType&, Image::Pointer image, const itk::Index<3>& index, ScalarType* returnValue)
{
switch (image->GetDimension())
{
case 2:
{
ImagePixelReadAccessor<T, 2> readAccess(image, image->GetSliceData(0));
*returnValue = readAccess.GetPixelByIndex(reinterpret_cast<const itk::Index<2>&>(index));
break;
}
case 3:
{
ImagePixelReadAccessor<T, 3> readAccess(image, image->GetVolumeData(0));
*returnValue = readAccess.GetPixelByIndex(index);
break;
}
default:
*returnValue = 0;
break;
}
}
static IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, itk::PolyLineParametricPath<3>::Pointer path)
{
IntensityProfile::Pointer intensityProfile = IntensityProfile::New();
itk::PolyLineParametricPath<3>::InputType input = path->StartOfInput();
BaseGeometry* imageGeometry = image->GetGeometry();
const PixelType pixelType = image->GetPixelType();
IntensityProfile::MeasurementVectorType measurementVector;
itk::PolyLineParametricPath<3>::OffsetType offset;
Point3D worldPoint;
itk::Index<3> index;
do
{
imageGeometry->IndexToWorld(path->Evaluate(input), worldPoint);
imageGeometry->WorldToIndex(worldPoint, index);
mitkPixelTypeMultiplex3(ReadPixel, pixelType, image, index, measurementVector.GetDataPointer());
intensityProfile->PushBack(measurementVector);
offset = path->IncrementInput(input);
} while ((offset[0] | offset[1] | offset[2]) != 0);
return intensityProfile;
}
template <class TInputImage>
static typename itk::InterpolateImageFunction<TInputImage>::Pointer CreateInterpolateImageFunction(InterpolateImageFunction::Enum interpolator)
{
switch (interpolator)
{
case InterpolateImageFunction::NearestNeighbor:
return itk::NearestNeighborInterpolateImageFunction<TInputImage>::New().GetPointer();
case InterpolateImageFunction::Linear:
return itk::LinearInterpolateImageFunction<TInputImage>::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Blackman_3:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::BlackmanWindowFunction<3> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Blackman_4:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::BlackmanWindowFunction<4> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Blackman_5:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::BlackmanWindowFunction<5> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Cosine_3:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::CosineWindowFunction<3> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Cosine_4:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::CosineWindowFunction<4> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Cosine_5:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::CosineWindowFunction<5> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Hamming_3:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::HammingWindowFunction<3> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Hamming_4:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::HammingWindowFunction<4> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Hamming_5:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::HammingWindowFunction<5> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Lanczos_3:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::LanczosWindowFunction<3> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Lanczos_4:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::LanczosWindowFunction<4> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Lanczos_5:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::LanczosWindowFunction<5> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Welch_3:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::WelchWindowFunction<3> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Welch_4:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::WelchWindowFunction<4> >::New().GetPointer();
case InterpolateImageFunction::WindowedSinc_Welch_5:
return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::WelchWindowFunction<5> >::New().GetPointer();
default:
return itk::NearestNeighborInterpolateImageFunction<TInputImage>::New().GetPointer();
}
}
template <class TPixel, unsigned int VImageDimension>
static void ComputeIntensityProfile(itk::Image<TPixel, VImageDimension>* image, itk::PolyLineParametricPath<3>::Pointer path, unsigned int numSamples, InterpolateImageFunction::Enum interpolator, IntensityProfile::Pointer intensityProfile)
{
typename itk::InterpolateImageFunction<itk::Image<TPixel, VImageDimension> >::Pointer interpolateImageFunction = CreateInterpolateImageFunction<itk::Image<TPixel, VImageDimension> >(interpolator);
interpolateImageFunction->SetInputImage(image);
const itk::PolyLineParametricPath<3>::InputType startOfInput = path->StartOfInput();
const itk::PolyLineParametricPath<3>::InputType delta = 1.0 / (numSamples - 1);
IntensityProfile::MeasurementVectorType measurementVector;
for (unsigned int i = 0; i < numSamples; ++i)
{
measurementVector[0] = interpolateImageFunction->EvaluateAtContinuousIndex(path->Evaluate(startOfInput + i * delta));
intensityProfile->PushBack(measurementVector);
}
}
static IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, itk::PolyLineParametricPath<3>::Pointer path, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
{
IntensityProfile::Pointer intensityProfile = IntensityProfile::New();
AccessFixedDimensionByItk_n(image, ComputeIntensityProfile, 3, (path, numSamples, interpolator, intensityProfile));
return intensityProfile;
}
class AddPolyLineElementToPath
{
public:
AddPolyLineElementToPath(const PlaneGeometry* planarFigureGeometry, const BaseGeometry* imageGeometry, itk::PolyLineParametricPath<3>::Pointer path)
: m_PlanarFigureGeometry(planarFigureGeometry),
m_ImageGeometry(imageGeometry),
m_Path(path)
{
}
void operator()(const PlanarFigure::PolyLineElement& polyLineElement)
{
m_PlanarFigureGeometry->Map(polyLineElement, m_WorldPoint);
m_ImageGeometry->WorldToIndex(m_WorldPoint, m_ContinuousIndexPoint);
m_Vertex.CastFrom(m_ContinuousIndexPoint);
m_Path->AddVertex(m_Vertex);
}
private:
const PlaneGeometry* m_PlanarFigureGeometry;
const BaseGeometry* m_ImageGeometry;
itk::PolyLineParametricPath<3>::Pointer m_Path;
Point3D m_WorldPoint;
Point3D m_ContinuousIndexPoint;
itk::PolyLineParametricPath<3>::ContinuousIndexType m_Vertex;
};
static itk::PolyLineParametricPath<3>::Pointer CreatePathFromPlanarFigure(BaseGeometry* imageGeometry, PlanarFigure* planarFigure)
{
itk::PolyLineParametricPath<3>::Pointer path = itk::PolyLineParametricPath<3>::New();
const PlanarFigure::PolyLineType polyLine = planarFigure->GetPolyLine(0);
std::for_each(polyLine.begin(), polyLine.end(),
AddPolyLineElementToPath(planarFigure->GetPlaneGeometry(), imageGeometry, path));
return path;
}
static void AddPointToPath(const BaseGeometry* imageGeometry, const Point3D& point, itk::PolyLineParametricPath<3>::Pointer path)
{
Point3D continuousIndexPoint;
imageGeometry->WorldToIndex(point, continuousIndexPoint);
itk::PolyLineParametricPath<3>::ContinuousIndexType vertex;
vertex.CastFrom(continuousIndexPoint);
path->AddVertex(vertex);
}
static itk::PolyLineParametricPath<3>::Pointer CreatePathFromPoints(BaseGeometry* imageGeometry, const Point3D& startPoint, const Point3D& endPoint)
{
itk::PolyLineParametricPath<3>::Pointer path = itk::PolyLineParametricPath<3>::New();
AddPointToPath(imageGeometry, startPoint, path);
AddPointToPath(imageGeometry, endPoint, path);
return path;
}
IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, PlanarFigure::Pointer planarFigure)
{
return ::ComputeIntensityProfile(image, CreatePathFromPlanarFigure(image->GetGeometry(), planarFigure));
}
IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, PlanarLine::Pointer planarLine, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
{
return ::ComputeIntensityProfile(image, CreatePathFromPlanarFigure(image->GetGeometry(), planarLine.GetPointer()), numSamples, interpolator);
}
IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, const Point3D& startPoint, const Point3D& endPoint, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
{
return ::ComputeIntensityProfile(image, CreatePathFromPoints(image->GetGeometry(), startPoint, endPoint), numSamples, interpolator);
}
-IntensityProfile::InstanceIdentifier mitk::ComputeGlobalMaximum(IntensityProfile::Pointer intensityProfile)
+IntensityProfile::InstanceIdentifier mitk::ComputeGlobalMaximum(IntensityProfile::Pointer intensityProfile, IntensityProfile::MeasurementType &max)
{
- IntensityProfile::MeasurementType max = -vcl_numeric_limits<IntensityProfile::MeasurementType>::max();
+ max = -vcl_numeric_limits<IntensityProfile::MeasurementType>::min();
IntensityProfile::InstanceIdentifier maxIndex = 0;
IntensityProfile::ConstIterator end = intensityProfile->End();
IntensityProfile::MeasurementType measurement;
for (IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
{
measurement = it.GetMeasurementVector()[0];
if (measurement > max)
{
max = measurement;
maxIndex = it.GetInstanceIdentifier();
}
}
return maxIndex;
}
-IntensityProfile::InstanceIdentifier mitk::ComputeGlobalMinimum(IntensityProfile::Pointer intensityProfile)
+IntensityProfile::InstanceIdentifier mitk::ComputeGlobalMinimum(IntensityProfile::Pointer intensityProfile, IntensityProfile::MeasurementType &min)
{
- IntensityProfile::MeasurementType min = vcl_numeric_limits<IntensityProfile::MeasurementType>::max();
+ min = vcl_numeric_limits<IntensityProfile::MeasurementType>::max();
IntensityProfile::InstanceIdentifier minIndex = 0;
IntensityProfile::ConstIterator end = intensityProfile->End();
IntensityProfile::MeasurementType measurement;
for (IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
{
measurement = it.GetMeasurementVector()[0];
if (measurement < min)
{
min = measurement;
minIndex = it.GetInstanceIdentifier();
}
}
return minIndex;
}
IntensityProfile::InstanceIdentifier mitk::ComputeCenterOfMaximumArea(IntensityProfile::Pointer intensityProfile, IntensityProfile::InstanceIdentifier radius)
{
- const IntensityProfile::MeasurementType min = intensityProfile->GetMeasurementVector(ComputeGlobalMinimum(intensityProfile))[0];
+ //const IntensityProfile::MeasurementType min = intensityProfile->GetMeasurementVector(ComputeGlobalMinimum(intensityProfile))[0];
+ IntensityProfile::MeasurementType min;
+ ComputeGlobalMinimum(intensityProfile, min);
const IntensityProfile::InstanceIdentifier areaWidth = 1 + 2 * radius;
IntensityProfile::MeasurementType maxArea = 0;
for (IntensityProfile::InstanceIdentifier i = 0; i < areaWidth; ++i)
maxArea += intensityProfile->GetMeasurementVector(i)[0] - min;
const IntensityProfile::InstanceIdentifier lastIndex = intensityProfile->Size() - areaWidth;
IntensityProfile::InstanceIdentifier centerOfMaxArea = radius;
IntensityProfile::MeasurementType area = maxArea;
for (IntensityProfile::InstanceIdentifier i = 1; i <= lastIndex; ++i)
{
area += intensityProfile->GetMeasurementVector(i + areaWidth - 1)[0] - min;
area -= intensityProfile->GetMeasurementVector(i - 1)[0] - min;
if (area > maxArea)
{
maxArea = area;
centerOfMaxArea = i + radius; // TODO: If multiple areas in the neighborhood have the same intensity chose the middle one instead of the first one.
}
}
return centerOfMaxArea;
}
std::vector<IntensityProfile::MeasurementType> mitk::CreateVectorFromIntensityProfile(IntensityProfile::Pointer intensityProfile)
{
std::vector<IntensityProfile::MeasurementType> result;
result.reserve(intensityProfile->Size());
IntensityProfile::ConstIterator end = intensityProfile->End();
for (IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
result.push_back(it.GetMeasurementVector()[0]);
return result;
}
IntensityProfile::Pointer mitk::CreateIntensityProfileFromVector(const std::vector<IntensityProfile::MeasurementType>& vector)
{
const IntensityProfile::InstanceIdentifier size = vector.size();
IntensityProfile::Pointer result = IntensityProfile::New();
result->Resize(size);
for (IntensityProfile::InstanceIdentifier i = 0; i < size; ++i)
result->SetMeasurement(i, 0, vector[i]);
return result;
}
+
+void mitk::ComputeIntensityProfileStatistics(IntensityProfile::Pointer intensityProfile, ImageStatisticsCalculator::Statistics &stats)
+{
+ typedef std::vector<IntensityProfile::MeasurementType> StatsVecType;
+
+ StatsVecType statsVec = mitk::CreateVectorFromIntensityProfile( intensityProfile );
+
+ IntensityProfile::MeasurementType min;
+ IntensityProfile::MeasurementType max;
+ mitk::ComputeGlobalMinimum( intensityProfile, min );
+ mitk::ComputeGlobalMaximum( intensityProfile, max );
+ StatsVecType::size_type numSamples = statsVec.size();
+
+ double mean = 0.0;
+ double rms = 0.0;
+ for ( StatsVecType::const_iterator it = statsVec.begin(); it != statsVec.end(); ++it )
+ {
+ double val = *it;
+ mean += val;
+ rms += val*val;
+ }
+ mean /= numSamples;
+ rms /= numSamples;
+
+ double var = 0.0;
+ for ( StatsVecType::const_iterator it = statsVec.begin(); it != statsVec.end(); ++it )
+ {
+ double diff = *it - mean;
+ var += diff*diff;
+ }
+ var /= ( numSamples - 1 );
+
+ double stdDev = sqrt( var );
+ rms = sqrt( rms );
+
+ stats.SetMin( static_cast<double>( min ) );
+ stats.SetMax( static_cast<double>( max ) );
+ stats.SetN( numSamples );
+ stats.SetMean( mean );
+ stats.SetVariance( var );
+ stats.SetRMS( rms );
+}
diff --git a/Modules/ImageStatistics/mitkIntensityProfile.h b/Modules/ImageStatistics/mitkIntensityProfile.h
index acb4c7ba07..c0ba4bb96d 100644
--- a/Modules/ImageStatistics/mitkIntensityProfile.h
+++ b/Modules/ImageStatistics/mitkIntensityProfile.h
@@ -1,127 +1,137 @@
/*===================================================================
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 mitkIntensityProfile_h
#define mitkIntensityProfile_h
#include <itkListSample.h>
#include <mitkImage.h>
#include <mitkPlanarLine.h>
+#include <mitkImageStatisticsCalculator.h>
#include <MitkImageStatisticsExports.h>
namespace mitk
{
typedef itk::Statistics::ListSample<itk::Statistics::MeasurementVectorPixelTraits<ScalarType>::MeasurementVectorType> IntensityProfile;
/** \brief Compute intensity profile of an image for each pixel along the first PolyLine of a given planar figure.
*
* \param[in] image A two or three-dimensional image which consists of single component pixels.
* \param[in] planarFigure A planar figure from which the first PolyLine is used to evaluate the intensity profile.
*
* \return The computed intensity profile.
*/
MITKIMAGESTATISTICS_EXPORT IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, PlanarFigure::Pointer planarFigure);
namespace InterpolateImageFunction
{
enum Enum
{
NearestNeighbor,
Linear,
WindowedSinc_Blackman_3,
WindowedSinc_Blackman_4,
WindowedSinc_Blackman_5,
WindowedSinc_Cosine_3,
WindowedSinc_Cosine_4,
WindowedSinc_Cosine_5,
WindowedSinc_Hamming_3,
WindowedSinc_Hamming_4,
WindowedSinc_Hamming_5,
WindowedSinc_Lanczos_3,
WindowedSinc_Lanczos_4,
WindowedSinc_Lanczos_5,
WindowedSinc_Welch_3,
WindowedSinc_Welch_4,
WindowedSinc_Welch_5
};
}
/** \brief Compute intensity profile of an image for each sample along a planar line.
*
* \param[in] image A three-dimensional image which consists of single component pixels.
* \param[in] planarLine A planar line along which the intensity profile will be evaluated.
* \param[in] numSamples Number of samples along the planar line (must be at least 2).
* \param[in] interpolator Image interpolation function which is used to read each sample.
*
* \return The computed intensity profile.
*/
MITKIMAGESTATISTICS_EXPORT IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, PlanarLine::Pointer planarLine, unsigned int numSamples, InterpolateImageFunction::Enum interpolator = InterpolateImageFunction::NearestNeighbor);
/** \brief Compute intensity profile of an image for each sample between two points.
*
* \param[in] image A three-dimensional image which consists of single component pixels.
* \param[in] startPoint A point at which the first sample is to be read.
* \param[in] endPoint A point at which the last sample is to be read.
* \param[in] numSamples Number of samples between startPoint and endPoint (must be at least 2).
* \param[in] interpolator Image interpolation function which is used to read each sample.
*
* \return The computed intensity profile.
*/
MITKIMAGESTATISTICS_EXPORT IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, const Point3D& startPoint, const Point3D& endPoint, unsigned int numSamples, InterpolateImageFunction::Enum interpolator = InterpolateImageFunction::NearestNeighbor);
/** \brief Compute global maximum of an intensity profile.
*
* \param[in] intensityProfile An intensity profile.
*
* \return Index of the global maximum.
*/
- MITKIMAGESTATISTICS_EXPORT IntensityProfile::InstanceIdentifier ComputeGlobalMaximum(IntensityProfile::Pointer intensityProfile);
+ MITKIMAGESTATISTICS_EXPORT IntensityProfile::InstanceIdentifier ComputeGlobalMaximum(IntensityProfile::Pointer intensityProfile, IntensityProfile::MeasurementType &max);
/** \brief Compute global minimum of an intensity profile.
*
* \param[in] intensityProfile An intensity profile.
*
* \return Index of the global minimum.
*/
- MITKIMAGESTATISTICS_EXPORT IntensityProfile::InstanceIdentifier ComputeGlobalMinimum(IntensityProfile::Pointer intensityProfile);
+ MITKIMAGESTATISTICS_EXPORT IntensityProfile::InstanceIdentifier ComputeGlobalMinimum(IntensityProfile::Pointer intensityProfile, IntensityProfile::MeasurementType &min);
+
+ /** \brief Compute statistics of an intensity profile.
+ *
+ * \param[in] intensityProfile An intensity profile.
+ *
+ * \param[in] stats An ImageStatisticsCalculator::Statistics object to hold the calculated statistics.
+ *
+ */
+ MITKIMAGESTATISTICS_EXPORT void ComputeIntensityProfileStatistics(IntensityProfile::Pointer intensityProfile, ImageStatisticsCalculator::Statistics &stats);
/** \brief Compute center of maximum area under the curve of an intensity profile.
*
* \param[in] intensityProfile An intensity profile.
* \param[in] radius Radius of the area (width of area equals 1 + 2 * radius).
*
* \return Index of the maximum area center.
*/
MITKIMAGESTATISTICS_EXPORT IntensityProfile::InstanceIdentifier ComputeCenterOfMaximumArea(IntensityProfile::Pointer intensityProfile, IntensityProfile::InstanceIdentifier radius);
/** \brief Convert an intensity profile to a standard library vector.
*
* \param[in] intensityProfile An intensity profile.
*
* \return Standard library vector which contains the input intensity profile measurements.
*/
MITKIMAGESTATISTICS_EXPORT std::vector<IntensityProfile::MeasurementType> CreateVectorFromIntensityProfile(IntensityProfile::Pointer intensityProfile);
/** \brief Convert a standard library vector to an intensity profile.
*
* \param[in] vector An standard library vector which contains intensity profile measurements.
*
* \return An intensity profile.
*/
MITKIMAGESTATISTICS_EXPORT IntensityProfile::Pointer CreateIntensityProfileFromVector(const std::vector<IntensityProfile::MeasurementType>& vector);
}
#endif
diff --git a/Modules/QtWidgetsExt/include/QmitkHistogramJSWidget.h b/Modules/QtWidgetsExt/include/QmitkHistogramJSWidget.h
index bd295b41ce..10bbc449a3 100644
--- a/Modules/QtWidgetsExt/include/QmitkHistogramJSWidget.h
+++ b/Modules/QtWidgetsExt/include/QmitkHistogramJSWidget.h
@@ -1,278 +1,286 @@
/*===================================================================
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 <QWebView>
#include "MitkQtWidgetsExtExports.h"
#include <QVariant>
#include "mitkImage.h"
#include "mitkPlanarFigure.h"
#include <itkPolyLineParametricPath.h>
+#include <mitkImageStatisticsCalculator.h>
#include <QmitkWebPage.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 display an intensity profile for
* path elements, which lais over an image.
*/
class MITKQTWIDGETSEXT_EXPORT QmitkHistogramJSWidget : public QWebView
{
Q_OBJECT
/**
* \brief Measurement property.
*
* 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 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 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 intensity profile property.
*
* This property is used in JavaScript as member of the current object.
* It holds a boolean, which says whether to use an intensity 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 = nullptr);
~QmitkHistogramJSWidget();
/**
* \brief Event which notifies a change of the widget size.
*
* Reimplemented from QWebView::resizeEvent(),
* reloads the webframe
*/
void resizeEvent(QResizeEvent* resizeEvent) override;
/**
* \brief Calculates the histogram.
*
* 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.
* The SignalDataChanged is called, to update the information, which is displayed in the webframe.
*/
void ComputeHistogram(HistogramType* histogram);
/**
* \brief Calculates the intensityprofile.
*
* 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.
* The SignalDataChanged is called, to update the information, which is displayed in the webframe.
*/
- void ComputeIntensityProfile(unsigned int timeStep = 0);
+ void ComputeIntensityProfile(unsigned int timeStep = 0, bool computeStatistics = false );
/**
* \brief Clears the Histogram.
*
* This function clears the data and calls SignalDataChanged to update
* the displayed information in the webframe.
*/
void ClearHistogram();
/**
* \brief Getter for measurement.
*
* @return List of measurements.
*/
QList<QVariant> GetMeasurement();
/**
* \brief Getter for frequency.
*
* @return List of frequencies.
*/
QList<QVariant> GetFrequency();
/**
* \brief Getter for uselineGraph.
*
* @return True if a linegraph should be used.
*/
bool GetUseLineGraph();
/**
* \brief Getter for intensity profile.
*
* @return True if current histogram is an intensityprofile
*/
bool GetIntensityProfile();
+ mitk::ImageStatisticsCalculator::Statistics& GetStatistics()
+ {
+ return m_Statistics;
+ };
+
/**
* \brief Setter for reference image.
*
* @param image The corresponding image for an intensity profile.
*/
void SetImage(mitk::Image* image);
/**
* \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;
+ mitk::ImageStatisticsCalculator::Statistics m_Statistics;
+
/**
* \brief Reference image.
*
* Holds the image to calculate an intensity profile.
*/
mitk::Image::Pointer m_Image;
/**
* \brief Pathelement.
*
* Holds a not closed planar figure to calculate an intensity 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();
QmitkJSWebPage* m_Page;
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 intensity 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
diff --git a/Modules/QtWidgetsExt/src/QmitkHistogramJSWidget.cpp b/Modules/QtWidgetsExt/src/QmitkHistogramJSWidget.cpp
index a03468b6f3..7d8382bff8 100644
--- a/Modules/QtWidgetsExt/src/QmitkHistogramJSWidget.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkHistogramJSWidget.cpp
@@ -1,242 +1,247 @@
/*===================================================================
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 <mitkIntensityProfile.h>
#include "mitkRenderingManager.h"
#include "mitkBaseRenderer.h"
#include "mitkImageTimeSelector.h"
#include "mitkExtractSliceFilter.h"
#include <QWebFrame>
QmitkHistogramJSWidget::QmitkHistogramJSWidget(QWidget *parent) :
QWebView(parent)
{
// set histogram type to barchart in first instance
m_UseLineGraph = false;
m_Page = new QmitkJSWebPage(this);
setPage(m_Page);
// set html from source
connect(page()->mainFrame(), SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(AddJSObject()));
QUrl myUrl = QUrl("qrc:///QtWidgetsExt/Histogram.html");
setUrl(myUrl);
// 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, using QtWebkitBridge
void QmitkHistogramJSWidget::AddJSObject()
{
page()->mainFrame()->addToJavaScriptWindowObject(QString("histogramData"), this);
}
// 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);
// workaround for Qt Bug: https://bugs.webkit.org/show_bug.cgi?id=75984
page()->mainFrame()->evaluateJavaScript("disconnectSignals()");
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 = m_Histogram->Begin();
ClearData();
unsigned int i = 0;
bool firstValue = false;
// removes frequencies of 0, which are outside the first and last bin
for (; 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 = QVariant::fromValue(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()
{
if (m_UseLineGraph)
{
m_UseLineGraph = false;
this->SignalGraphChanged();
}
}
void QmitkHistogramJSWidget::OnLineRadioButtonSelected()
{
if (!m_UseLineGraph)
{
m_UseLineGraph = true;
this->SignalGraphChanged();
}
}
void QmitkHistogramJSWidget::SetImage(mitk::Image* image)
{
m_Image = image;
}
void QmitkHistogramJSWidget::SetPlanarFigure(const mitk::PlanarFigure* planarFigure)
{
m_PlanarFigure = planarFigure;
}
template <class PixelType>
void ReadPixel(mitk::PixelType, mitk::Image::Pointer image, itk::Index<3> 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)
+void QmitkHistogramJSWidget::ComputeIntensityProfile(unsigned int timeStep, bool computeStatistics)
{
this->ClearData();
m_ParametricPath->Initialize();
if (m_PlanarFigure.IsNull())
{
mitkThrow() << "PlanarFigure not set!";
}
if (m_Image.IsNull())
{
mitkThrow() << "Image not set!";
}
mitk::Image::Pointer image;
if (m_Image->GetDimension() == 4)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(m_Image);
timeSelector->SetTimeNr(timeStep);
timeSelector->Update();
image = timeSelector->GetOutput();
}
else
{
image = m_Image;
}
mitk::IntensityProfile::Pointer intensityProfile = mitk::ComputeIntensityProfile(image, const_cast<mitk::PlanarFigure*>(m_PlanarFigure.GetPointer()));
m_Frequency.clear();
m_Measurement.clear();
int i = -1;
mitk::IntensityProfile::ConstIterator end = intensityProfile->End();
for (mitk::IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
{
m_Frequency.push_back(it.GetMeasurementVector()[0]);
m_Measurement.push_back(++i);
}
+ if ( computeStatistics )
+ {
+ mitk::ComputeIntensityProfileStatistics( intensityProfile, m_Statistics );
+ }
+
m_IntensityProfile = true;
m_UseLineGraph = true;
this->SignalDataChanged();
}
bool QmitkHistogramJSWidget::GetIntensityProfile()
{
return m_IntensityProfile;
}
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 2cb326cee8..69fc1370fb 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,999 +1,1064 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkImageStatisticsView.h"
// Qt includes
#include <qclipboard.h>
#include <qscrollbar.h>
// berry includes
#include <berryIWorkbenchPage.h>
// mitk includes
#include "mitkNodePredicateDataType.h"
#include "mitkPlanarFigureInteractor.h"
// itk includes
#include "itksys/SystemTools.hxx"
#include <mitkILinkedRenderWindowPart.h>
#include <QmitkRenderWindow.h>
const std::string QmitkImageStatisticsView::VIEW_ID = "org.mitk.views.imagestatistics";
const int QmitkImageStatisticsView::STAT_TABLE_BASE_HEIGHT = 180;
QmitkImageStatisticsView::QmitkImageStatisticsView(QObject* /*parent*/, const char* /*name*/)
: m_Controls( NULL ),
m_TimeStepperAdapter( NULL ),
m_SelectedImage( NULL ),
m_SelectedImageMask( NULL ),
m_SelectedPlanarFigure( NULL ),
m_ImageObserverTag( -1 ),
m_ImageMaskObserverTag( -1 ),
m_PlanarFigureObserverTag( -1 ),
m_TimeObserverTag( -1 ),
m_CurrentStatisticsValid( false ),
m_StatisticsUpdatePending( false ),
m_DataNodeSelectionChanged ( false ),
m_Visible(false)
{
this->m_CalculationThread = new QmitkImageStatisticsCalculationThread;
}
QmitkImageStatisticsView::~QmitkImageStatisticsView()
{
if ( m_SelectedImage != NULL )
m_SelectedImage->RemoveObserver( m_ImageObserverTag );
if ( m_SelectedImageMask != NULL )
m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
if ( m_SelectedPlanarFigure != NULL )
m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
while(this->m_CalculationThread->isRunning()) // wait until thread has finished
{
itksys::SystemTools::Delay(100);
}
delete this->m_CalculationThread;
}
void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
{
if (m_Controls == NULL)
{
m_Controls = new Ui::QmitkImageStatisticsViewControls;
m_Controls->setupUi(parent);
CreateConnections();
m_Controls->m_ErrorMessageLabel->hide();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
m_Controls->m_BinSizeFrame->setVisible(false);
}
}
void QmitkImageStatisticsView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(this->m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardHistogramButtonClicked()) );
connect( (QObject*)(this->m_Controls->m_ButtonCopyStatisticsToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardStatisticsButtonClicked()) );
connect( (QObject*)(this->m_Controls->m_IgnoreZerosCheckbox), SIGNAL(clicked()),(QObject*) this, SLOT(OnIgnoreZerosCheckboxClicked()) );
connect( (QObject*) this->m_CalculationThread, SIGNAL(finished()),this, SLOT( OnThreadedStatisticsCalculationEnds()),Qt::QueuedConnection);
connect( (QObject*) this, SIGNAL(StatisticsUpdate()),this, SLOT( RequestStatisticsUpdate()), Qt::QueuedConnection);
connect( (QObject*) this->m_Controls->m_StatisticsTable, SIGNAL(cellDoubleClicked(int,int)),this, SLOT( JumpToCoordinates(int,int)) );
connect( (QObject*) (this->m_Controls->m_barRadioButton), SIGNAL(clicked()), (QObject*) (this->m_Controls->m_JSHistogram), SLOT(OnBarRadioButtonSelected()));
connect( (QObject*) (this->m_Controls->m_lineRadioButton), SIGNAL(clicked()), (QObject*) (this->m_Controls->m_JSHistogram), SLOT(OnLineRadioButtonSelected()));
connect( (QObject*) (this->m_Controls->m_HistogramBinSizeSpinbox), SIGNAL(editingFinished()), this, SLOT(OnHistogramBinSizeBoxValueChanged()));
connect( (QObject*)(this->m_Controls->m_UseDefaultBinSizeBox), SIGNAL(clicked()),(QObject*) this, SLOT(OnDefaultBinSizeBoxChanged()) );
}
}
void QmitkImageStatisticsView::OnDefaultBinSizeBoxChanged()
{
if (m_CalculationThread!=NULL)
m_Controls->m_HistogramBinSizeSpinbox->setValue(m_CalculationThread->GetHistogramBinSize());
if (m_Controls->m_UseDefaultBinSizeBox->isChecked())
m_Controls->m_BinSizeFrame->setVisible(false);
else
m_Controls->m_BinSizeFrame->setVisible(true);
}
void QmitkImageStatisticsView::PartClosed(const berry::IWorkbenchPartReference::Pointer& )
{
}
void QmitkImageStatisticsView::OnTimeChanged(const itk::EventObject& e)
{
if (this->m_SelectedDataNodes.isEmpty() || this->m_SelectedImage == NULL)
return;
const mitk::SliceNavigationController::GeometryTimeEvent* timeEvent =
dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent*>(&e);
assert(timeEvent != NULL);
unsigned int timestep = timeEvent->GetPos();
if (this->m_SelectedImage->GetTimeSteps() > 1)
{
for (unsigned int x = 0; x < this->m_Controls->m_StatisticsTable->columnCount(); x++)
{
for (unsigned int y = 0; y < this->m_Controls->m_StatisticsTable->rowCount(); y++)
{
QTableWidgetItem* item = this->m_Controls->m_StatisticsTable->item(y, x);
if (item == NULL)
break;
if (x == timestep)
{
item->setBackgroundColor(Qt::yellow);
}
else
{
if (y % 2 == 0)
item->setBackground(this->m_Controls->m_StatisticsTable->palette().base());
else
item->setBackground(this->m_Controls->m_StatisticsTable->palette().alternateBase());
}
}
}
this->m_Controls->m_StatisticsTable->viewport()->update();
}
if ((this->m_SelectedImage->GetTimeSteps() == 1 && timestep == 0) ||
this->m_SelectedImage->GetTimeSteps() > 1)
{
// display histogram for selected timestep
this->m_Controls->m_JSHistogram->ClearHistogram();
QmitkImageStatisticsCalculationThread::HistogramType::Pointer histogram =
this->m_CalculationThread->GetTimeStepHistogram(timestep);
if (histogram.IsNotNull())
{
- this->m_Controls->m_JSHistogram->ComputeHistogram(histogram.GetPointer());
+ bool closedFigure = this->m_CalculationThread->GetStatisticsUpdateSuccessFlag();
+
+ if ( closedFigure )
+ {
+ this->m_Controls->m_JSHistogram->ComputeHistogram(histogram.GetPointer());
+ }
+ //this->m_Controls->m_JSHistogram->ComputeHistogram(histogram.GetPointer());
+ /*else
+ {
+ m_Controls->m_JSHistogram->ComputeIntensityProfile(timestep, true);
+ }*/
+
// this->m_Controls->m_JSHistogram->SignalGraphChanged();
// hacky way to make sure the protected SignalGraphChanged() is called
if (this->m_Controls->m_JSHistogram->GetUseLineGraph())
{
this->m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
this->m_Controls->m_JSHistogram->OnLineRadioButtonSelected();
}
else
{
this->m_Controls->m_JSHistogram->OnLineRadioButtonSelected();
this->m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
}
}
}
}
void QmitkImageStatisticsView::JumpToCoordinates(int row ,int col)
{
if(m_SelectedDataNodes.isEmpty())
{
MITK_WARN("QmitkImageStatisticsView") << "No data node selected for statistics calculation." ;
return;
}
mitk::Point3D world;
if (row==4 && !m_WorldMinList.empty())
world = m_WorldMinList[col];
else if (row==3 && !m_WorldMaxList.empty())
world = m_WorldMaxList[col];
else
return;
mitk::IRenderWindowPart* part = this->GetRenderWindowPart();
if (part)
{
part->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(world);
part->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SelectSliceByPoint(world);
part->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SelectSliceByPoint(world);
mitk::SliceNavigationController::GeometryTimeEvent timeEvent(this->m_SelectedImage->GetTimeGeometry(), col);
part->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetGeometryTime(timeEvent);
}
}
void QmitkImageStatisticsView::OnIgnoreZerosCheckboxClicked()
{
emit StatisticsUpdate();
}
void QmitkImageStatisticsView::OnClipboardHistogramButtonClicked()
{
if ( m_CurrentStatisticsValid )
{
const unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
typedef mitk::ImageStatisticsCalculator::HistogramType HistogramType;
const HistogramType *histogram = this->m_CalculationThread->GetTimeStepHistogram(t).GetPointer();
QString clipboard( "Measurement \t Frequency\n" );
for ( HistogramType::ConstIterator it = histogram->Begin();
it != histogram->End();
++it )
{
if( m_Controls->m_HistogramBinSizeSpinbox->value() == 1.0)
{
clipboard = clipboard.append( "%L1 \t %L2\n" )
.arg( it.GetMeasurementVector()[0], 0, 'f', 0 )
.arg( it.GetFrequency() );
}
else
{
clipboard = clipboard.append( "%L1 \t %L2\n" )
.arg( it.GetMeasurementVector()[0], 0, 'f', 2 )
.arg( it.GetFrequency() );
}
}
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
}
void QmitkImageStatisticsView::OnClipboardStatisticsButtonClicked()
{
QLocale tempLocal;
QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
if ( this->m_CurrentStatisticsValid )
{
const std::vector<mitk::ImageStatisticsCalculator::Statistics> &statistics =
this->m_CalculationThread->GetStatisticsData();
const unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->
GetPos();
// Copy statistics to clipboard ("%Ln" will use the default locale for
// number formatting)
QString clipboard( "Mean \t StdDev \t RMS \t Max \t Min \t N \t V (mm³)\n" );
clipboard = clipboard.append("%L1 \t %L2 \t %L3 \t %L4 \t %L5 \t %L6 \t %L7")
.arg(statistics[t].GetMean(), 0, 'f', 10)
.arg(statistics[t].GetSigma(), 0, 'f', 10)
.arg(statistics[t].GetRMS(), 0, 'f', 10)
.arg(statistics[t].GetMax(), 0, 'f', 10)
.arg(statistics[t].GetMin(), 0, 'f', 10)
.arg(statistics[t].GetN())
.arg( m_Controls->m_StatisticsTable->item(6, 0)->data(Qt::DisplayRole).toDouble(), 0, 'f', 10);
QApplication::clipboard()->setText(
clipboard, QClipboard::Clipboard );
}
else
{
QApplication::clipboard()->clear();
}
QLocale::setDefault(tempLocal);
}
void QmitkImageStatisticsView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*part*/,
const QList<mitk::DataNode::Pointer> &selectedNodes )
{
if (this->m_Visible)
{
this->SelectionChanged( selectedNodes );
}
else
{
this->m_DataNodeSelectionChanged = true;
}
}
void QmitkImageStatisticsView::SelectionChanged(const QList<mitk::DataNode::Pointer> &selectedNodes)
{
if( this->m_StatisticsUpdatePending )
{
this->m_DataNodeSelectionChanged = true;
return; // not ready for new data now!
}
if (selectedNodes.size() == this->m_SelectedDataNodes.size())
{
int i = 0;
for (; i < selectedNodes.size(); ++i)
{
if (selectedNodes.at(i) != this->m_SelectedDataNodes.at(i))
{
break;
}
}
// node selection did not change
if (i == selectedNodes.size()) return;
}
//reset the feature image and image mask field
m_Controls->m_SelectedFeatureImageLabel->setText("None");
m_Controls->m_SelectedMaskLabel->setText("None");
this->ReinitData();
if (selectedNodes.isEmpty())
{
m_Controls->m_JSHistogram->ClearHistogram();
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
// m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
m_Controls->m_InfoLabel->setText(QString(""));
// m_Controls->horizontalLayout_3->setEnabled(false);
m_Controls->groupBox->setEnabled(false);
m_Controls->groupBox_3->setEnabled(false);
}
else
{
// m_Controls->horizontalLayout_3->setEnabled(true);
m_Controls->groupBox->setEnabled(true);
m_Controls->groupBox_3->setEnabled(true);
}
if(selectedNodes.size() == 1 || selectedNodes.size() == 2)
{
bool isBinary = false;
selectedNodes.value(0)->GetBoolProperty("binary",isBinary);
if(isBinary)
{
m_Controls->m_JSHistogram->ClearHistogram();
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
// m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
m_Controls->m_InfoLabel->setText(QString(""));
}
for (int i= 0; i< selectedNodes.size(); ++i)
{
this->m_SelectedDataNodes.push_back(selectedNodes.at(i));
}
this->m_DataNodeSelectionChanged = false;
this->m_Controls->m_ErrorMessageLabel->setText( "" );
this->m_Controls->m_ErrorMessageLabel->hide();
emit StatisticsUpdate();
}
else
{
this->m_DataNodeSelectionChanged = false;
}
}
void QmitkImageStatisticsView::ReinitData()
{
while( this->m_CalculationThread->isRunning()) // wait until thread has finished
{
itksys::SystemTools::Delay(100);
}
if(this->m_SelectedImage != NULL)
{
this->m_SelectedImage->RemoveObserver( this->m_ImageObserverTag);
this->m_SelectedImage = NULL;
}
if(this->m_SelectedImageMask != NULL)
{
this->m_SelectedImageMask->RemoveObserver( this->m_ImageMaskObserverTag);
this->m_SelectedImageMask = NULL;
}
if(this->m_SelectedPlanarFigure != NULL)
{
this->m_SelectedPlanarFigure->RemoveObserver( this->m_PlanarFigureObserverTag);
this->m_SelectedPlanarFigure = NULL;
}
this->m_SelectedDataNodes.clear();
this->m_StatisticsUpdatePending = false;
m_Controls->m_ErrorMessageLabel->setText( "" );
m_Controls->m_ErrorMessageLabel->hide();
this->InvalidateStatisticsTableView();
m_Controls->m_JSHistogram->ClearHistogram();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
}
void QmitkImageStatisticsView::OnThreadedStatisticsCalculationEnds()
{
std::stringstream message;
message << "";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->hide();
this->WriteStatisticsToGUI();
}
void QmitkImageStatisticsView::UpdateStatistics()
{
mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
if ( renderPart == NULL )
{
this->m_StatisticsUpdatePending = false;
return;
}
m_WorldMinList.clear();
m_WorldMaxList.clear();
// classify selected nodes
mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
std::string maskName = std::string();
std::string maskType = std::string();
std::string featureImageName = std::string();
unsigned int maskDimension = 0;
// reset data from last run
ITKCommandType::Pointer changeListener = ITKCommandType::New();
changeListener->SetCallbackFunction( this, &QmitkImageStatisticsView::SelectedDataModified );
mitk::DataNode::Pointer planarFigureNode;
for( int i= 0 ; i < this->m_SelectedDataNodes.size(); ++i)
{
mitk::PlanarFigure::Pointer planarFig = dynamic_cast<mitk::PlanarFigure*>(this->m_SelectedDataNodes.at(i)->GetData());
if( imagePredicate->CheckNode(this->m_SelectedDataNodes.at(i)) )
{
bool isMask = false;
this->m_SelectedDataNodes.at(i)->GetPropertyValue("binary", isMask);
if( this->m_SelectedImageMask == NULL && isMask)
{
this->m_SelectedImageMask = dynamic_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
this->m_ImageMaskObserverTag = this->m_SelectedImageMask->AddObserver(itk::ModifiedEvent(), changeListener);
maskName = this->m_SelectedDataNodes.at(i)->GetName();
maskType = m_SelectedImageMask->GetNameOfClass();
maskDimension = 3;
}
else if( !isMask )
{
if(this->m_SelectedImage == NULL)
{
this->m_SelectedImage = static_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
}
featureImageName = this->m_SelectedDataNodes.at(i)->GetName();
}
}
else if (planarFig.IsNotNull())
{
if(this->m_SelectedPlanarFigure == NULL)
{
this->m_SelectedPlanarFigure = planarFig;
this->m_PlanarFigureObserverTag =
this->m_SelectedPlanarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), changeListener);
maskName = this->m_SelectedDataNodes.at(i)->GetName();
maskType = this->m_SelectedPlanarFigure->GetNameOfClass();
maskDimension = 2;
planarFigureNode = m_SelectedDataNodes.at(i);
}
}
else
{
std::stringstream message;
message << "<font color='red'>" << "Invalid data node type!" << "</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
}
}
if(maskName == "")
{
maskName = "None";
maskType = "";
maskDimension = 0;
}
if(featureImageName == "")
{
featureImageName = "None";
}
if (m_SelectedPlanarFigure != NULL && m_SelectedImage == NULL)
{
mitk::DataStorage::SetOfObjects::ConstPointer parentSet = this->GetDataStorage()->GetSources(planarFigureNode);
for (int i=0; i<parentSet->Size(); i++)
{
mitk::DataNode::Pointer node = parentSet->ElementAt(i);
if( imagePredicate->CheckNode(node) )
{
bool isMask = false;
node->GetPropertyValue("binary", isMask);
if( !isMask )
{
if(this->m_SelectedImage == NULL)
{
this->m_SelectedImage = static_cast<mitk::Image*>(node->GetData());
this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
}
}
}
}
}
unsigned int timeStep = renderPart->GetTimeNavigationController()->GetTime()->GetPos();
if ( m_SelectedImage != NULL && m_SelectedImage->IsInitialized())
{
// Check if a the selected image is a multi-channel image. If yes, statistics
// cannot be calculated currently.
if ( m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
{
std::stringstream message;
message << "<font color='red'>Multi-component images not supported.</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
this->InvalidateStatisticsTableView();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
m_Controls->m_JSHistogram->ClearHistogram();
m_CurrentStatisticsValid = false;
this->m_StatisticsUpdatePending = false;
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
// m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
m_Controls->m_InfoLabel->setText(QString(""));
return;
}
std::stringstream maskLabel;
maskLabel << maskName;
if ( maskDimension > 0 )
{
maskLabel << " [" << maskDimension << "D " << maskType << "]";
}
m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
m_Controls->m_SelectedFeatureImageLabel->setText(featureImageName.c_str());
// check time step validity
if(m_SelectedImage->GetDimension() <= 3 && timeStep > m_SelectedImage->GetDimension(3)-1)
{
timeStep = m_SelectedImage->GetDimension(3)-1;
}
// Add the used mask time step to the mask label so the user knows which mask time step was used
// if the image time step is bigger than the total number of mask time steps (see
// ImageStatisticsCalculator::ExtractImageAndMask)
if (m_SelectedImageMask != NULL)
{
unsigned int maskTimeStep = timeStep;
if (maskTimeStep >= m_SelectedImageMask->GetTimeSteps())
{
maskTimeStep = m_SelectedImageMask->GetTimeSteps() - 1;
}
m_Controls->m_SelectedMaskLabel->setText(m_Controls->m_SelectedMaskLabel->text() +
QString(" (t=") +
QString::number(maskTimeStep) +
QString(")"));
}
//// initialize thread and trigger it
this->m_CalculationThread->SetIgnoreZeroValueVoxel( m_Controls->m_IgnoreZerosCheckbox->isChecked() );
this->m_CalculationThread->Initialize( m_SelectedImage, m_SelectedImageMask, m_SelectedPlanarFigure );
this->m_CalculationThread->SetTimeStep( timeStep );
this->m_CalculationThread->SetHistogramBinSize(m_Controls->m_HistogramBinSizeSpinbox->value());
std::stringstream message;
message << "<font color='red'>Calculating statistics...</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
try
{
// Compute statistics
this->m_CalculationThread->SetUseDefaultBinSize(m_Controls->m_UseDefaultBinSizeBox->isChecked());
this->m_CalculationThread->start();
}
catch ( const mitk::Exception& e)
{
std::stringstream message;
message << "<font color='red'>" << e.GetDescription() << "</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
this->m_StatisticsUpdatePending = false;
}
catch ( const std::runtime_error &e )
{
// In case of exception, print error message on GUI
std::stringstream message;
message << "<font color='red'>" << e.what() << "</font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
this->m_StatisticsUpdatePending = false;
}
catch ( const std::exception &e )
{
MITK_ERROR << "Caught exception: " << e.what();
// In case of exception, print error message on GUI
std::stringstream message;
message << "<font color='red'>Error! Unequal Dimensions of Image and Segmentation. No recompute possible </font>";
m_Controls->m_ErrorMessageLabel->setText( message.str().c_str() );
m_Controls->m_ErrorMessageLabel->show();
this->m_StatisticsUpdatePending = false;
}
}
else
{
this->m_StatisticsUpdatePending = false;
}
}
void QmitkImageStatisticsView::SelectedDataModified()
{
if( !m_StatisticsUpdatePending )
{
emit StatisticsUpdate();
}
}
void QmitkImageStatisticsView::NodeRemoved(const mitk::DataNode *node)
{
while(this->m_CalculationThread->isRunning()) // wait until thread has finished
{
itksys::SystemTools::Delay(100);
}
if (node->GetData() == m_SelectedImage)
{
m_SelectedImage = NULL;
}
}
void QmitkImageStatisticsView::RequestStatisticsUpdate()
{
if ( !m_StatisticsUpdatePending )
{
if(this->m_DataNodeSelectionChanged)
{
this->SelectionChanged(this->GetCurrentSelection());
}
else
{
this->m_StatisticsUpdatePending = true;
this->UpdateStatistics();
}
}
if (this->GetRenderWindowPart())
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkImageStatisticsView::OnHistogramBinSizeBoxValueChanged()
{
this->UpdateStatistics();
}
void QmitkImageStatisticsView::WriteStatisticsToGUI()
{
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
// m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
m_Controls->m_InfoLabel->setText(QString(""));
if(m_DataNodeSelectionChanged)
{
this->m_StatisticsUpdatePending = false;
this->RequestStatisticsUpdate();
return; // stop visualization of results and calculate statistics of new selection
}
if ( this->m_CalculationThread->GetStatisticsUpdateSuccessFlag())
{
if ( this->m_CalculationThread->GetStatisticsChangedFlag() )
{
// Do not show any error messages
m_Controls->m_ErrorMessageLabel->hide();
m_CurrentStatisticsValid = true;
}
if (m_Controls->m_barRadioButton->isChecked())
{
m_Controls->m_JSHistogram->OnBarRadioButtonSelected();
}
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
m_Controls->m_HistogramBinSizeSpinbox->setValue( this->m_CalculationThread->GetHistogramBinSize() );
//m_Controls->m_JSHistogram->ComputeHistogram( this->m_CalculationThread->GetTimeStepHistogram(this->m_CalculationThread->GetTimeStep()).GetPointer() );
this->FillStatisticsTableView( this->m_CalculationThread->GetStatisticsData(), this->m_CalculationThread->GetStatisticsImage());
}
else
{
m_Controls->m_SelectedMaskLabel->setText( "None" );
m_Controls->m_ErrorMessageLabel->setText( m_CalculationThread->GetLastErrorMessage().c_str() );
m_Controls->m_ErrorMessageLabel->show();
// Clear statistics and histogram
this->InvalidateStatisticsTableView();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
//m_Controls->m_JSHistogram->clearHistogram();
m_CurrentStatisticsValid = false;
// If a (non-closed) PlanarFigure is selected, display a line profile widget
if ( m_SelectedPlanarFigure != NULL )
{
// Check if the (closed) planar figure is out of bounds and so no image mask could be calculated--> Intensity Profile can not be calculated
bool outOfBounds = false;
if ( m_SelectedPlanarFigure->IsClosed() && m_SelectedImageMask == NULL)
{
outOfBounds = true;
std::stringstream message;
message << "<font color='red'>Planar figure is on a rotated image plane or outside the image bounds.</font>";
m_Controls->m_InfoLabel->setText(message.str().c_str());
}
// check whether PlanarFigure is initialized
const mitk::PlaneGeometry *planarFigurePlaneGeometry = m_SelectedPlanarFigure->GetPlaneGeometry();
if ( planarFigurePlaneGeometry == NULL || outOfBounds)
{
// Clear statistics, histogram, and GUI
this->InvalidateStatisticsTableView();
m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
m_Controls->m_JSHistogram->ClearHistogram();
m_CurrentStatisticsValid = false;
m_Controls->m_ErrorMessageLabel->hide();
m_Controls->m_SelectedMaskLabel->setText( "None" );
this->m_StatisticsUpdatePending = false;
m_Controls->m_lineRadioButton->setEnabled(true);
m_Controls->m_barRadioButton->setEnabled(true);
m_Controls->m_HistogramBinSizeSpinbox->setEnabled(true);
m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(true);
// m_Controls->m_HistogramBinSizeLabel->setEnabled(true);
if (!outOfBounds)
m_Controls->m_InfoLabel->setText(QString(""));
return;
}
unsigned int timeStep = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
m_Controls->m_JSHistogram->SetImage(this->m_CalculationThread->GetStatisticsImage());
m_Controls->m_JSHistogram->SetPlanarFigure(m_SelectedPlanarFigure);
- m_Controls->m_JSHistogram->ComputeIntensityProfile(timeStep);
+ m_Controls->m_JSHistogram->ComputeIntensityProfile(timeStep, true);
+ //m_Controls->m_JSHistogram->ComputeIntensityProfile(timeStep);
m_Controls->m_lineRadioButton->setEnabled(false);
m_Controls->m_barRadioButton->setEnabled(false);
m_Controls->m_HistogramBinSizeSpinbox->setEnabled(false);
m_Controls->m_HistogramBinSizeCaptionLabel->setEnabled(false);
// m_Controls->m_HistogramBinSizeLabel->setEnabled(false);
+
+ this->FillLinearProfileStatisticsTableView( this->m_CalculationThread->GetStatisticsImage() );
+
std::stringstream message;
message << "<font color='red'>Only linegraph available for an intensity profile!</font>";
m_Controls->m_InfoLabel->setText(message.str().c_str());
}
}
this->m_StatisticsUpdatePending = false;
}
void QmitkImageStatisticsView::FillStatisticsTableView(
const std::vector<mitk::ImageStatisticsCalculator::Statistics> &s,
const mitk::Image *image )
{
this->m_Controls->m_StatisticsTable->setColumnCount(image->GetTimeSteps());
this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(image->GetTimeSteps() > 1);
int decimals = 2;
mitk::PixelType doublePix = mitk::MakeScalarPixelType< double >();
mitk::PixelType floatPix = mitk::MakeScalarPixelType< float >();
if (image->GetPixelType()==doublePix || image->GetPixelType()==floatPix)
{
decimals = 5;
}
for (unsigned int t = 0; t < image->GetTimeSteps(); t++)
{
this->m_Controls->m_StatisticsTable->setHorizontalHeaderItem(t,
new QTableWidgetItem(QString::number(t)));
if (s[t].GetMaxIndex().size()==3)
{
mitk::Point3D index, max, min;
index[0] = s[t].GetMaxIndex()[0];
index[1] = s[t].GetMaxIndex()[1];
index[2] = s[t].GetMaxIndex()[2];
m_SelectedImage->GetGeometry()->IndexToWorld(index, max);
this->m_WorldMaxList.push_back(max);
index[0] = s[t].GetMinIndex()[0];
index[1] = s[t].GetMinIndex()[1];
index[2] = s[t].GetMinIndex()[2];
m_SelectedImage->GetGeometry()->IndexToWorld(index, min);
this->m_WorldMinList.push_back(min);
}
this->m_Controls->m_StatisticsTable->setItem( 0, t, new QTableWidgetItem(
QString("%1").arg(s[t].GetMean(), 0, 'f', decimals) ) );
this->m_Controls->m_StatisticsTable->setItem( 1, t, new QTableWidgetItem(
QString("%1").arg(s[t].GetSigma(), 0, 'f', decimals) ) );
this->m_Controls->m_StatisticsTable->setItem( 2, t, new QTableWidgetItem(
QString("%1").arg(s[t].GetRMS(), 0, 'f', decimals) ) );
QString max; max.append(QString("%1").arg(s[t].GetMax(), 0, 'f', decimals));
max += " (";
for (int i=0; i<s[t].GetMaxIndex().size(); i++)
{
max += QString::number(s[t].GetMaxIndex()[i]);
if (i<s[t].GetMaxIndex().size()-1)
max += ",";
}
max += ")";
this->m_Controls->m_StatisticsTable->setItem( 3, t, new QTableWidgetItem( max ) );
QString min; min.append(QString("%1").arg(s[t].GetMin(), 0, 'f', decimals));
min += " (";
for (int i=0; i<s[t].GetMinIndex().size(); i++)
{
min += QString::number(s[t].GetMinIndex()[i]);
if (i<s[t].GetMinIndex().size()-1)
min += ",";
}
min += ")";
this->m_Controls->m_StatisticsTable->setItem( 4, t, new QTableWidgetItem( min ) );
this->m_Controls->m_StatisticsTable->setItem( 5, t, new QTableWidgetItem(
QString("%1").arg(s[t].GetN()) ) );
const mitk::BaseGeometry *geometry = image->GetGeometry();
if ( geometry != NULL )
{
const mitk::Vector3D &spacing = image->GetGeometry()->GetSpacing();
double volume = spacing[0] * spacing[1] * spacing[2] * (double) s[t].GetN();
this->m_Controls->m_StatisticsTable->setItem( 6, t, new QTableWidgetItem(
QString("%1").arg(volume, 0, 'f', decimals) ) );
}
else
{
this->m_Controls->m_StatisticsTable->setItem( 6, t, new QTableWidgetItem(
"NA" ) );
}
}
this->m_Controls->m_StatisticsTable->resizeColumnsToContents();
int height = STAT_TABLE_BASE_HEIGHT;
if (this->m_Controls->m_StatisticsTable->horizontalHeader()->isVisible())
height += this->m_Controls->m_StatisticsTable->horizontalHeader()->height();
if (this->m_Controls->m_StatisticsTable->horizontalScrollBar()->isVisible())
height += this->m_Controls->m_StatisticsTable->horizontalScrollBar()->height();
this->m_Controls->m_StatisticsTable->setMinimumHeight(height);
// make sure the current timestep's column is highlighted (and the correct histogram is displayed)
unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->
GetPos();
mitk::SliceNavigationController::GeometryTimeEvent timeEvent(this->m_SelectedImage->GetTimeGeometry(),
t);
this->OnTimeChanged(timeEvent);
t = std::min(image->GetTimeSteps() - 1, t);
// See bug 18340
/*QString hotspotMean; hotspotMean.append(QString("%1").arg(s[t].GetHotspotStatistics().GetMean(), 0, 'f', decimals));
hotspotMean += " (";
for (int i=0; i<s[t].GetHotspotIndex().size(); i++)
{
hotspotMean += QString::number(s[t].GetHotspotIndex()[i]);
if (i<s[t].GetHotspotIndex().size()-1)
hotspotMean += ",";
}
hotspotMean += ")";
this->m_Controls->m_StatisticsTable->setItem( 7, t, new QTableWidgetItem( hotspotMean ) );
QString hotspotMax; hotspotMax.append(QString("%1").arg(s[t].GetHotspotStatistics().GetMax(), 0, 'f', decimals));
hotspotMax += " (";
for (int i=0; i<s[t].GetHotspotStatistics().GetMaxIndex().size(); i++)
{
hotspotMax += QString::number(s[t].GetHotspotStatistics().GetMaxIndex()[i]);
if (i<s[t].GetHotspotStatistics().GetMaxIndex().size()-1)
hotspotMax += ",";
}
hotspotMax += ")";
this->m_Controls->m_StatisticsTable->setItem( 8, t, new QTableWidgetItem( hotspotMax ) );
QString hotspotMin; hotspotMin.append(QString("%1").arg(s[t].GetHotspotStatistics().GetMin(), 0, 'f', decimals));
hotspotMin += " (";
for (int i=0; i<s[t].GetHotspotStatistics().GetMinIndex().size(); i++)
{
hotspotMin += QString::number(s[t].GetHotspotStatistics().GetMinIndex()[i]);
if (i<s[t].GetHotspotStatistics().GetMinIndex().size()-1)
hotspotMin += ",";
}
hotspotMin += ")";
this->m_Controls->m_StatisticsTable->setItem( 9, t, new QTableWidgetItem( hotspotMin ) );*/
}
+void QmitkImageStatisticsView::FillLinearProfileStatisticsTableView( const mitk::Image *image )
+{
+ this->m_Controls->m_StatisticsTable->setColumnCount(1);
+ this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(false);
+
+ int decimals = 2;
+
+ mitk::PixelType doublePix = mitk::MakeScalarPixelType< double >();
+ mitk::PixelType floatPix = mitk::MakeScalarPixelType< float >();
+ if (image->GetPixelType()==doublePix || image->GetPixelType()==floatPix)
+ {
+ decimals = 5;
+ }
+
+ mitk::ImageStatisticsCalculator::Statistics &stats = m_Controls->m_JSHistogram->GetStatistics();
+
+ this->m_Controls->m_StatisticsTable->setItem( 0, 0, new QTableWidgetItem(
+ QString("%1").arg(stats.GetMean(), 0, 'f', decimals) ) );
+
+ double stdDev = sqrt( stats.GetVariance() );
+ this->m_Controls->m_StatisticsTable->setItem( 1, 0, new QTableWidgetItem( QString("%1").arg( stdDev, 0, 'f', decimals) ) );
+
+ double rms = stats.GetRMS();
+ this->m_Controls->m_StatisticsTable->setItem( 2, 0, new QTableWidgetItem(
+ QString("%1").arg( rms, 0, 'f', decimals) ) );
+
+ QString max; max.append(QString("%1").arg(stats.GetMax(), 0, 'f', decimals));
+
+ this->m_Controls->m_StatisticsTable->setItem( 3, 0, new QTableWidgetItem( max ) );
+
+ QString min; min.append(QString("%1").arg(stats.GetMin(), 0, 'f', decimals));
+
+ this->m_Controls->m_StatisticsTable->setItem( 4, 0, new QTableWidgetItem( min ) );
+
+ this->m_Controls->m_StatisticsTable->setItem( 5, 0, new QTableWidgetItem( QString("%1").arg(stats.GetN()) ) );
+
+ this->m_Controls->m_StatisticsTable->setItem( 6, 0, new QTableWidgetItem( "NA" ) );
+
+ this->m_Controls->m_StatisticsTable->resizeColumnsToContents();
+ int height = STAT_TABLE_BASE_HEIGHT;
+
+ if (this->m_Controls->m_StatisticsTable->horizontalHeader()->isVisible())
+ height += this->m_Controls->m_StatisticsTable->horizontalHeader()->height();
+
+ if (this->m_Controls->m_StatisticsTable->horizontalScrollBar()->isVisible())
+ height += this->m_Controls->m_StatisticsTable->horizontalScrollBar()->height();
+
+ this->m_Controls->m_StatisticsTable->setMinimumHeight(height);
+ }
+
void QmitkImageStatisticsView::InvalidateStatisticsTableView()
{
this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(false);
this->m_Controls->m_StatisticsTable->setColumnCount(1);
for ( unsigned int i = 0; i < this->m_Controls->m_StatisticsTable->rowCount(); ++i )
{
{
this->m_Controls->m_StatisticsTable->setItem( i, 0, new QTableWidgetItem( "NA" ) );
}
}
this->m_Controls->m_StatisticsTable->setMinimumHeight(STAT_TABLE_BASE_HEIGHT);
}
void QmitkImageStatisticsView::Activated()
{
}
void QmitkImageStatisticsView::Deactivated()
{
}
void QmitkImageStatisticsView::Visible()
{
m_Visible = true;
mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
if (renderWindow)
{
itk::ReceptorMemberCommand<QmitkImageStatisticsView>::Pointer cmdTimeEvent =
itk::ReceptorMemberCommand<QmitkImageStatisticsView>::New();
cmdTimeEvent->SetCallbackFunction(this, &QmitkImageStatisticsView::OnTimeChanged);
// It is sufficient to add the observer to the axial render window since the GeometryTimeEvent
// is always triggered by all views.
m_TimeObserverTag = renderWindow->GetQmitkRenderWindow("axial")->
GetSliceNavigationController()->
AddObserver(mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), cmdTimeEvent);
}
if (m_DataNodeSelectionChanged)
{
if (this->IsCurrentSelectionValid())
{
this->SelectionChanged(this->GetCurrentSelection());
}
else
{
this->SelectionChanged(this->GetDataManagerSelection());
}
m_DataNodeSelectionChanged = false;
}
}
void QmitkImageStatisticsView::Hidden()
{
m_Visible = false;
// The slice navigation controller observer is removed here instead of in the destructor.
// If it was called in the destructor, the application would freeze because the view's
// destructor gets called after the render windows have been destructed.
if ( m_TimeObserverTag != NULL )
{
mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
if (renderWindow)
{
renderWindow->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->
RemoveObserver( m_TimeObserverTag );
}
m_TimeObserverTag = NULL;
}
}
void QmitkImageStatisticsView::SetFocus()
{
}