diff --git a/Modules/QtOverlays/QmitkTextOverlay.cpp b/Modules/QtOverlays/QmitkTextOverlay.cpp
index ebdd4d7005..512e849693 100644
--- a/Modules/QtOverlays/QmitkTextOverlay.cpp
+++ b/Modules/QtOverlays/QmitkTextOverlay.cpp
@@ -1,159 +1,159 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkTextOverlay.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkPropertyList.h"
#include <itkCommand.h>
QmitkTextOverlay::QmitkTextOverlay(const char *id) : QmitkOverlay(id), m_ObservedProperty(nullptr), m_ObserverTag(0)
{
m_Widget = m_Label = new QLabel();
QmitkOverlay::AddDropShadow(m_Widget);
}
QmitkTextOverlay::~QmitkTextOverlay()
{
m_PropertyList->GetProperty(m_Id)->RemoveObserver(m_ObserverTag);
}
void QmitkTextOverlay::GenerateData(mitk::PropertyList::Pointer pl)
{
if (pl.IsNull())
return;
m_PropertyList = pl;
if (m_PropertyList.IsNotNull())
{
this->SetupCallback(m_PropertyList->GetProperty(m_Id));
this->UpdateFontProperties(pl);
this->UpdateDisplayedTextFromProperties();
}
else
{
MITK_ERROR << "invalid propList";
}
}
void QmitkTextOverlay::UpdateDisplayedTextFromProperties()
{
std::string text;
if (m_PropertyList.IsNull() || !m_PropertyList->GetStringProperty(m_Id, text))
{
MITK_DEBUG << "Property " << m_Id << " could not be found";
}
if (text != m_Label->text().toStdString())
{
m_Label->setText(text.c_str());
m_Label->repaint();
}
}
void QmitkTextOverlay::UpdateFontProperties(mitk::PropertyList::Pointer pl)
{
if (pl.IsNull())
return;
mitk::PropertyList::Pointer propertyList = pl;
QPalette palette = QPalette();
QFont font = QFont();
// get the desired color of the textOverlays
mitk::ColorProperty::Pointer colorProp =
dynamic_cast<mitk::ColorProperty *>(propertyList->GetProperty("overlay.color"));
if (colorProp.IsNull())
{
colorProp = mitk::ColorProperty::New(127.0, 196.0, 232.0);
}
mitk::Color color = colorProp->GetColor();
- palette.setColor(QPalette::Foreground, QColor(color[0], color[1], color[2], 255));
+ palette.setColor(QPalette::WindowText, QColor(color[0], color[1], color[2], 255));
palette.setColor(QPalette::Window, Qt::transparent);
m_Label->setPalette(palette);
// get the desired opacity of the overlays
// mitk::FloatProperty::Pointer opacityProperty =
// dynamic_cast<mitk::FloatProperty*>( propertyList->GetProperty( "overlay.opacity" ) );
// if ( opacityProperty.IsNull() )
//{
// m_Label->setWindowOpacity( 1 );
//}
// else
//{
// m_Label->setWindowOpacity( opacityProperty->GetValue() );
//}
// set the desired font-size of the overlays
int fontSize = 0;
if (!propertyList->GetIntProperty("overlay.fontSize", fontSize))
{
fontSize = 9;
}
font.setPointSize(fontSize);
bool useKerning = false;
if (!propertyList->GetBoolProperty("overlay.kerning", useKerning))
{
useKerning = true;
}
font.setKerning(useKerning);
std::string fontFamily = "";
if (!propertyList->GetStringProperty("overlay.fontFamily", fontFamily))
{
fontFamily = "Verdana";
}
font.setFamily(QString(fontFamily.c_str()));
m_Label->setFont(font);
}
void QmitkTextOverlay::SetupCallback(mitk::BaseProperty::Pointer prop)
{
if (m_ObservedProperty != prop && m_ObserverTag == 0)
{
if (prop.IsNotNull())
{
if (m_ObservedProperty.IsNotNull())
{
m_ObservedProperty->RemoveObserver(m_ObserverTag);
}
typedef itk::SimpleMemberCommand<QmitkTextOverlay> MemberCommandType;
MemberCommandType::Pointer propModifiedCommand;
propModifiedCommand = MemberCommandType::New();
propModifiedCommand->SetCallbackFunction(this, &QmitkTextOverlay::UpdateDisplayedTextFromProperties);
m_ObserverTag = prop->AddObserver(itk::ModifiedEvent(), propModifiedCommand);
}
m_ObservedProperty = prop;
}
else
{
MITK_DEBUG << "invalid property";
}
}
QSize QmitkTextOverlay::GetNeededSize()
{
QFont font = m_Label->font();
QFontMetrics fm(font);
return fm.size(Qt::TextSingleLine, m_Label->text());
}
diff --git a/Modules/QtWidgets/src/QmitkSliderLevelWindowWidget.cpp b/Modules/QtWidgets/src/QmitkSliderLevelWindowWidget.cpp
index ef8fb9e4d0..61eaf48f09 100644
--- a/Modules/QtWidgets/src/QmitkSliderLevelWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkSliderLevelWindowWidget.cpp
@@ -1,550 +1,550 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <QmitkSliderLevelWindowWidget.h>
// mitk core
#include <mitkRenderingManager.h>
// mitk qt widgets
#include <QmitkLevelWindowWidgetContextMenu.h>
// qt
#include <QCursor>
#include <QMouseEvent>
#include <QPainter>
#include <QToolTip>
// itk
#include <itkCommand.h>
// c++
#include <cmath>
QmitkSliderLevelWindowWidget::QmitkSliderLevelWindowWidget(QWidget *parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Manager = mitk::LevelWindowManager::New();
itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::Pointer command =
itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::New();
command->SetCallbackFunction(this, &QmitkSliderLevelWindowWidget::OnPropertyModified);
m_ObserverTag = m_Manager->AddObserver(itk::ModifiedEvent(), command);
m_IsObserverTagSet = true;
setMouseTracking(true);
m_Resize = false;
m_Bottom = false;
m_CtrlPressed = false;
m_MouseDown = false;
m_Font.setPointSize(6);
m_MoveHeight = height() - 25;
m_ScaleVisible = true;
m_Contextmenu = new QmitkLevelWindowWidgetContextMenu(this);
this->hide();
Update();
}
QmitkSliderLevelWindowWidget::~QmitkSliderLevelWindowWidget()
{
if (m_IsObserverTagSet)
{
m_Manager->RemoveObserver(m_ObserverTag);
m_IsObserverTagSet = false;
}
}
void QmitkSliderLevelWindowWidget::SetLevelWindowManager(mitk::LevelWindowManager *levelWindowManager)
{
if (m_IsObserverTagSet)
{
m_Manager->RemoveObserver(m_ObserverTag);
m_IsObserverTagSet = false;
}
m_Manager = levelWindowManager;
if (m_Manager.IsNotNull())
{
itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::Pointer command =
itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::New();
command->SetCallbackFunction(this, &QmitkSliderLevelWindowWidget::OnPropertyModified);
m_ObserverTag = m_Manager->AddObserver(itk::ModifiedEvent(), command);
m_IsObserverTagSet = true;
}
}
void QmitkSliderLevelWindowWidget::OnPropertyModified(const itk::EventObject &)
{
try
{
m_LevelWindow = m_Manager->GetLevelWindow();
this->show();
Update();
}
catch (...)
{
try
{
this->hide();
}
catch (...)
{
}
}
}
void QmitkSliderLevelWindowWidget::paintEvent(QPaintEvent *itkNotUsed(e))
{
QPixmap pm(width(), height());
pm.fill(this->palette().color(this->backgroundRole()));
QPainter painter(&pm);
painter.setFont(m_Font);
painter.setPen(this->palette().color(this->foregroundRole()));
QColor c(51, 153, 204);
- QColor cl = c.light();
- QColor cd = c.dark();
+ QColor cl = c.lighter();
+ QColor cd = c.darker();
painter.setBrush(c);
painter.drawRect(m_Rect);
mitk::ScalarType mr = m_LevelWindow.GetRange();
float smallestLevelableValue = 1e-9;
//This check is needed as safe guard. LevelWindow is refactored to only deduce finite ranges
//from images, but old scene serialization may contain infinite ranges that overwrite the new
//business logic. This roots in two many "jobs" LevelWindow" is used for; see also T24962.
//Until LevelWindow and this widget is refactored the check was the minimal invasive fix.
if (!std::isfinite(mr))
{
mr = m_LevelWindow.GetWindow();
}
// avoiding a division by 0 while still enabling small level windows
if (mr < smallestLevelableValue)
mr = smallestLevelableValue;
mitk::ScalarType fact = m_MoveHeight / mr;
// begin draw scale
if (m_ScaleVisible)
{
mitk::ScalarType minRange = m_LevelWindow.GetRangeMin();
mitk::ScalarType maxRange = m_LevelWindow.GetRangeMax();
//This check is needed as safe guard. LevelWindow is refactored to only deduce finite ranges
//from images, but old scene serialization may contain infinite ranges that overwrite the new
//business logic. This roots in two many "jobs" LevelWindow" is used for; see also T24962.
//Until LevelWindow and this widget is refactored the check was the minimal invasive fix.
if (!std::isfinite(minRange))
{
minRange = m_LevelWindow.GetLowerWindowBound();
}
//This check is needed as safe guard. LevelWindow is refactored to only deduce finite ranges
//from images, but old scene serialization may contain infinite ranges that overwrite the new
//business logic. This roots in two many "jobs" LevelWindow" is used for; see also T24962.
//Until LevelWindow and this widget is refactored the check was the minimal invasive fix.
if (!std::isfinite(maxRange))
{
maxRange = m_LevelWindow.GetUpperWindowBound();
}
int yValue = m_MoveHeight + static_cast<int>(minRange * fact);
QString s = " 0";
if (minRange < 0 && maxRange > 0)
{
painter.drawLine(5, yValue, 15, yValue);
painter.drawText(21, yValue + 3, s);
}
int count = 1;
int k = 5;
bool enoughSpace = false;
bool enoughSpace2 = false;
double dStepSize = pow(10, floor(log10(mr / 100)) + 1);
for (int i = m_MoveHeight + static_cast<int>(minRange * fact); i < m_MoveHeight;) // negative
{
if (-count * dStepSize < minRange)
{
break;
}
yValue = m_MoveHeight + static_cast<int>((minRange + count * dStepSize) * fact);
s = QString::number(-count * dStepSize);
if (count % k && ((dStepSize * fact) > 2.5))
{
painter.drawLine(8, yValue, 12, yValue);
enoughSpace = true;
}
else if (!(count % k))
{
if ((k * dStepSize * fact) > 7)
{
painter.drawLine(5, yValue, 15, yValue);
painter.drawText(21, yValue + 3, s);
enoughSpace2 = true;
}
else
{
k += 5;
}
}
if (enoughSpace)
{
i = yValue;
count++;
}
else if (enoughSpace2)
{
i = yValue;
count += k;
}
else
{
i = yValue;
count = k;
}
}
count = 1;
k = 5;
enoughSpace = false;
enoughSpace2 = false;
for (int i = m_MoveHeight + static_cast<int>(minRange * fact); i >= 0;)
{
if (count * dStepSize > maxRange)
{
break;
}
yValue = m_MoveHeight + static_cast<int>((minRange - count * dStepSize) * fact);
s = QString::number(count * dStepSize);
if (count % k && ((dStepSize * fact) > 2.5))
{
if (!(minRange > 0 && (count * dStepSize) < minRange))
painter.drawLine(8, yValue, 12, yValue);
enoughSpace = true;
}
else if (!(count % k))
{
if ((k * dStepSize * fact) > 7)
{
if (!(minRange > 0 && (count * dStepSize) < minRange))
{
painter.drawLine(5, yValue, 15, yValue);
painter.drawText(21, yValue + 3, s);
}
enoughSpace2 = true;
}
else
{
k += 5;
}
}
if (enoughSpace)
{
i = yValue;
count++;
}
else if (enoughSpace2)
{
i = yValue;
count += k;
}
else
{
i = yValue;
count = k;
}
}
}
// end draw scale
painter.setPen(cl);
painter.drawLine(m_Rect.topLeft(), m_Rect.topRight());
painter.drawLine(m_Rect.topLeft(), m_Rect.bottomLeft());
painter.setPen(cd);
painter.drawLine(m_Rect.topRight(), m_Rect.bottomRight());
painter.drawLine(m_Rect.bottomRight(), m_Rect.bottomLeft());
painter.end();
QPainter p(this);
p.drawPixmap(0, 0, pm);
}
void QmitkSliderLevelWindowWidget::mouseMoveEvent(QMouseEvent *mouseEvent)
{
if (!mouseEvent)
return;
if (m_LevelWindow.IsFixed())
return;
if (!m_MouseDown)
{
if (mouseEvent->pos().y() >= 0 && mouseEvent->pos().y() <= (m_Rect.topLeft().y() + 3))
{
setCursor(Qt::SizeVerCursor);
m_UpperBound.setRect(m_Rect.topLeft().x(), m_Rect.topLeft().y() - 3, 17, 7);
this->setToolTip("Ctrl + left click to change only upper bound");
m_Resize = true;
}
else if (mouseEvent->pos().y() >= (m_Rect.bottomLeft().y() - 3))
{
setCursor(Qt::SizeVerCursor);
m_LowerBound.setRect(m_Rect.bottomLeft().x(), m_Rect.bottomLeft().y() - 3, 17, 7);
this->setToolTip("Ctrl + left click to change only lower bound");
m_Resize = true;
m_Bottom = true;
}
else
{
setCursor(Qt::ArrowCursor);
this->setToolTip("Left click and mouse move to adjust the slider");
m_Resize = false;
m_Bottom = false;
}
}
else
{
mitk::ScalarType fact = m_MoveHeight / m_LevelWindow.GetRange();
if (m_Leftbutton)
{
if (m_Resize && !m_CtrlPressed)
{
mitk::ScalarType diff = (mouseEvent->pos().y()) / fact;
diff -= (m_StartPos.y()) / fact;
m_StartPos = mouseEvent->pos();
if (diff == 0)
return;
mitk::ScalarType value;
if (m_Bottom)
value = m_LevelWindow.GetWindow() + ((2 * diff));
else
value = m_LevelWindow.GetWindow() - ((2 * diff));
if (value < 0)
value = 0;
m_LevelWindow.SetLevelWindow(m_LevelWindow.GetLevel(), value);
}
else if (m_Resize && m_CtrlPressed)
{
if (!m_Bottom)
{
mitk::ScalarType diff = (mouseEvent->pos().y()) / fact;
diff -= (m_StartPos.y()) / fact;
m_StartPos = mouseEvent->pos();
if (diff == 0)
return;
mitk::ScalarType value;
value = m_LevelWindow.GetWindow() - ((diff));
if (value < 0)
value = 0;
mitk::ScalarType oldWindow;
mitk::ScalarType oldLevel;
mitk::ScalarType newLevel;
oldWindow = m_LevelWindow.GetWindow();
oldLevel = m_LevelWindow.GetLevel();
newLevel = oldLevel + (value - oldWindow) / 2;
if (!((newLevel + value / 2) > m_LevelWindow.GetRangeMax()))
m_LevelWindow.SetLevelWindow(newLevel, value);
}
else
{
mitk::ScalarType diff = (mouseEvent->pos().y()) / fact;
diff -= (m_StartPos.y()) / fact;
m_StartPos = mouseEvent->pos();
if (diff == 0)
return;
mitk::ScalarType value;
value = m_LevelWindow.GetWindow() + ((diff));
if (value < 0)
value = 0;
mitk::ScalarType oldWindow;
mitk::ScalarType oldLevel;
mitk::ScalarType newLevel;
oldWindow = m_LevelWindow.GetWindow();
oldLevel = m_LevelWindow.GetLevel();
newLevel = oldLevel - (value - oldWindow) / 2;
if (!((newLevel - value / 2) < m_LevelWindow.GetRangeMin()))
m_LevelWindow.SetLevelWindow(newLevel, value);
}
}
else
{
const mitk::ScalarType minv = m_LevelWindow.GetRangeMin();
const mitk::ScalarType level = (m_MoveHeight - mouseEvent->pos().y()) / fact + minv;
mitk::ScalarType diff = (mouseEvent->pos().x()) / fact;
diff -= (m_StartPos.x()) / fact;
m_StartPos = mouseEvent->pos();
mitk::ScalarType window;
if (m_Bottom)
window = m_LevelWindow.GetWindow() + ((2 * diff));
else
window = m_LevelWindow.GetWindow() - ((2 * diff));
if (window < 0)
window = 0;
m_LevelWindow.SetLevelWindow(level, window);
}
m_Manager->SetLevelWindow(m_LevelWindow);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void QmitkSliderLevelWindowWidget::enterEvent(QEvent * /*event*/)
{
QPoint p = QCursor::pos();
p = this->mapFromGlobal(p);
QMouseEvent ev(QEvent::MouseMove, p, Qt::NoButton, Qt::NoButton, Qt::NoModifier);
this->mouseMoveEvent(&ev);
}
void QmitkSliderLevelWindowWidget::mousePressEvent(QMouseEvent *mouseEvent)
{
if (m_LevelWindow.IsFixed())
return;
m_MouseDown = true;
m_StartPos = mouseEvent->pos();
if (mouseEvent->button() == Qt::LeftButton)
{
if (mouseEvent->modifiers() == Qt::ControlModifier || mouseEvent->modifiers() == Qt::ShiftModifier)
{
m_CtrlPressed = true;
}
else
{
m_CtrlPressed = false;
}
m_Leftbutton = true;
}
else
m_Leftbutton = false;
mouseMoveEvent(mouseEvent);
}
void QmitkSliderLevelWindowWidget::resizeEvent(QResizeEvent *event)
{
m_MoveHeight = event->size().height() - 25;
Update();
}
void QmitkSliderLevelWindowWidget::mouseReleaseEvent(QMouseEvent *)
{
if (m_LevelWindow.IsFixed())
return;
m_MouseDown = false;
}
void QmitkSliderLevelWindowWidget::Update()
{
int rectWidth;
if (m_ScaleVisible)
{
rectWidth = 17;
setMinimumSize(QSize(50, 50));
setMaximumSize(QSize(50, 2000));
setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding));
}
else
{
rectWidth = 26;
setMinimumSize(QSize(40, 50));
setMaximumSize(QSize(50, 2000));
setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding));
}
mitk::ScalarType mr = m_LevelWindow.GetRange();
if (mr < 1e-9)
mr = 1e-9;
mitk::ScalarType fact = m_MoveHeight / mr;
mitk::ScalarType rectHeight = m_LevelWindow.GetWindow() * fact;
if (rectHeight < 15)
rectHeight = 15;
if (m_LevelWindow.GetLowerWindowBound() < 0)
m_Rect.setRect(2,
static_cast<int>(m_MoveHeight - (m_LevelWindow.GetUpperWindowBound() - m_LevelWindow.GetRangeMin()) * fact),
rectWidth,
static_cast<int>(rectHeight));
else
m_Rect.setRect(2,
static_cast<int>(m_MoveHeight - (m_LevelWindow.GetUpperWindowBound() - m_LevelWindow.GetRangeMin()) * fact),
rectWidth,
static_cast<int>(rectHeight));
QWidget::repaint();
}
void QmitkSliderLevelWindowWidget::contextMenuEvent(QContextMenuEvent *)
{
m_Contextmenu->SetLevelWindowManager(m_Manager.GetPointer());
auto contextMenu = new QMenu(this);
Q_CHECK_PTR(contextMenu);
if (m_ScaleVisible)
contextMenu->addAction(tr("Hide Scale"), this, SLOT(HideScale()));
else
contextMenu->addAction(tr("Show Scale"), this, SLOT(ShowScale()));
contextMenu->addSeparator();
m_Contextmenu->GetContextMenu(contextMenu);
// Fix: Bug #13327 we need to reset the m_MouseDown value
// otherwise the cursor is not correctly restored afterwards
m_MouseDown = false;
}
void QmitkSliderLevelWindowWidget::HideScale()
{
m_ScaleVisible = false;
Update();
}
void QmitkSliderLevelWindowWidget::ShowScale()
{
m_ScaleVisible = true;
Update();
}
void QmitkSliderLevelWindowWidget::SetDataStorage(mitk::DataStorage *ds)
{
m_Manager->SetDataStorage(ds);
}
mitk::LevelWindowManager *QmitkSliderLevelWindowWidget::GetManager()
{
return m_Manager.GetPointer();
}
diff --git a/Modules/QtWidgetsExt/src/QmitkColorPropertyView.cpp b/Modules/QtWidgetsExt/src/QmitkColorPropertyView.cpp
index 95789bc8e4..62407ef96a 100644
--- a/Modules/QtWidgetsExt/src/QmitkColorPropertyView.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkColorPropertyView.cpp
@@ -1,51 +1,51 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkColorPropertyView.h"
#include <QPixmap>
#define ROUND_P(x) ((int)((x) + 0.5))
QmitkColorPropertyView::QmitkColorPropertyView(const mitk::ColorProperty *property, QWidget *parent)
: QLabel(parent), PropertyView(property), m_ColorProperty(property)
{
setText(" "); // two spaces for some minimun height
setMinimumSize(15, 15);
PropertyChanged();
m_WidgetPalette = QWidget::palette();
QWidget::setPalette(m_WidgetPalette);
QWidget::setAutoFillBackground(true);
}
QmitkColorPropertyView::~QmitkColorPropertyView()
{
}
void QmitkColorPropertyView::PropertyChanged()
{
if (m_Property)
DisplayColor();
}
void QmitkColorPropertyView::PropertyRemoved()
{
m_Property = nullptr;
m_ColorProperty = nullptr;
}
void QmitkColorPropertyView::DisplayColor()
{
const mitk::Color &tmp_col(m_ColorProperty->GetColor());
QColor color(ROUND_P(tmp_col[0] * 255.0), ROUND_P(tmp_col[1] * 255.0), ROUND_P(tmp_col[2] * 255.0));
- m_WidgetPalette.setColor(QPalette::Background, color);
+ m_WidgetPalette.setColor(QPalette::Window, color);
}
diff --git a/Modules/QtWidgetsExt/src/QmitkHistogram.cpp b/Modules/QtWidgetsExt/src/QmitkHistogram.cpp
index c2a7db8f5b..be0e9bfc8b 100644
--- a/Modules/QtWidgetsExt/src/QmitkHistogram.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkHistogram.cpp
@@ -1,179 +1,179 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <qpainter.h>
#include <qwt_painter.h>
#include <qwt_plot.h>
#include <qwt_scale_map.h>
#include "QmitkHistogram.h"
class QmitkHistogram::HistogramData
{
public:
QwtIntervalSeriesData data;
QColor color;
double reference;
};
QmitkHistogram::QmitkHistogram(const QwtText &title) : QwtPlotItem(title)
{
init();
}
QmitkHistogram::QmitkHistogram(const QString &title) : QwtPlotItem(QwtText(title))
{
init();
}
QmitkHistogram::~QmitkHistogram()
{
delete m_Data;
}
void QmitkHistogram::init()
{
m_Data = new HistogramData();
m_Data->reference = 0.0;
setItemAttribute(QwtPlotItem::AutoScale, true);
setItemAttribute(QwtPlotItem::Legend, true);
setZ(20.0);
}
void QmitkHistogram::setBaseline(double reference)
{
if (m_Data->reference != reference)
{
m_Data->reference = reference;
itemChanged();
}
}
double QmitkHistogram::baseline() const
{
return m_Data->reference;
}
void QmitkHistogram::setData(const QwtIntervalSeriesData &data)
{
m_Data->data.setSamples(data.samples());
itemChanged();
}
const QwtIntervalSeriesData &QmitkHistogram::data() const
{
return m_Data->data;
}
void QmitkHistogram::setColor(const QColor &color)
{
if (m_Data->color != color)
{
m_Data->color = color;
itemChanged();
}
}
QColor QmitkHistogram::color() const
{
return m_Data->color;
}
QRectF QmitkHistogram::boundingRect() const
{
QRectF rect = m_Data->data.boundingRect();
if (!rect.isValid())
return rect;
if (rect.bottom() < m_Data->reference)
rect.setBottom(m_Data->reference);
else if (rect.top() > m_Data->reference)
rect.setTop(m_Data->reference);
return rect;
}
void QmitkHistogram::draw(QPainter *painter, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRectF &) const
{
const QwtIntervalSeriesData &iData = m_Data->data;
painter->setPen(QPen(m_Data->color));
const int y0 = yMap.transform(baseline());
for (int i = 0; i < (int)iData.size(); i++)
{
const int y2 = yMap.transform(iData.sample(i).value);
if (y2 == y0)
continue;
int x1 = xMap.transform(iData.sample(i).interval.minValue());
int x2 = xMap.transform(iData.sample(i).interval.maxValue());
if (x1 > x2)
qSwap(x1, x2);
if (i < (int)iData.size() - 2)
{
const int xx1 = xMap.transform(iData.sample(i + 1).interval.minValue());
const int xx2 = xMap.transform(iData.sample(i + 1).interval.maxValue());
if (x2 == qMin(xx1, xx2))
{
const int yy2 = yMap.transform(iData.sample(i + 1).value);
if (yy2 != y0 && ((yy2 < y0 && y2 < y0) || (yy2 > y0 && y2 > y0)))
{
// One pixel distance between neighbored bars
x2--;
}
}
}
drawBar(painter, Qt::Vertical, QRect(x1, y0, x2 - x1, y2 - y0));
}
}
void QmitkHistogram::drawBar(QPainter *painter, Qt::Orientation, const QRect &rect) const
{
painter->save();
const QColor color(painter->pen().color());
const QRect r = rect.normalized();
const int factor = 125;
- const QColor light(color.light(factor));
- const QColor dark(color.dark(factor));
+ const QColor light(color.lighter(factor));
+ const QColor dark(color.darker(factor));
painter->setBrush(color);
painter->setPen(Qt::NoPen);
QwtPainter::drawRect(painter, r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2);
painter->setBrush(Qt::NoBrush);
painter->setPen(QPen(light, 2));
QwtPainter::drawLine(painter, r.left() + 1, r.top() + 2, r.right() + 1, r.top() + 2);
painter->setPen(QPen(dark, 2));
QwtPainter::drawLine(painter, r.left() + 1, r.bottom(), r.right() + 1, r.bottom());
painter->setPen(QPen(light, 1));
QwtPainter::drawLine(painter, r.left(), r.top() + 1, r.left(), r.bottom());
QwtPainter::drawLine(painter, r.left() + 1, r.top() + 2, r.left() + 1, r.bottom() - 1);
painter->setPen(QPen(dark, 1));
QwtPainter::drawLine(painter, r.right() + 1, r.top() + 1, r.right() + 1, r.bottom());
QwtPainter::drawLine(painter, r.right(), r.top() + 2, r.right(), r.bottom() - 1);
painter->restore();
}
diff --git a/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp b/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
index fddbc1637d..b554ebd685 100644
--- a/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkLesionTreeModel.cpp
@@ -1,298 +1,298 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// semantic relations UI module
#include "QmitkLesionTreeModel.h"
// semantic relations module
#include <mitkControlPointManager.h>
#include <mitkLesionManager.h>
#include <mitkNodePredicates.h>
#include <mitkSemanticRelationException.h>
#include <mitkSemanticRelationsInference.h>
#include <mitkRelationStorage.h>
// qt
#include <QColor>
QmitkLesionTreeModel::QmitkLesionTreeModel(QObject* parent/* = nullptr*/)
: QmitkAbstractSemanticRelationsStorageModel(parent)
, m_LastSegmentation(nullptr)
, m_RootItem(std::make_shared<QmitkLesionTreeItem>(mitk::LesionData()))
{
// nothing here
}
//////////////////////////////////////////////////////////////////////////
// overridden virtual functions from QAbstractItemModel
//////////////////////////////////////////////////////////////////////////
QModelIndex QmitkLesionTreeModel::index(int row, int column, const QModelIndex& itemIndex) const
{
if (!hasIndex(row, column, itemIndex))
{
return QModelIndex();
}
auto childItem = GetItemByIndex(itemIndex)->GetChildInRow(row);
if (nullptr == childItem)
{
return QModelIndex();
}
return createIndex(row, column, childItem.get());
}
QModelIndex QmitkLesionTreeModel::parent(const QModelIndex& itemIndex) const
{
if (!itemIndex.isValid())
{
return QModelIndex();
}
auto parentItem = GetItemByIndex(itemIndex)->GetParent();
if (parentItem.expired())
{
return QModelIndex();
}
auto sharedParent = parentItem.lock();
if (sharedParent == m_RootItem)
{
return QModelIndex();
}
return createIndex(sharedParent->GetRow(), 0, sharedParent.get());
}
int QmitkLesionTreeModel::rowCount(const QModelIndex& itemIndex/* = QModelIndex()*/) const
{
return GetItemByIndex(itemIndex)->ChildCount();
}
int QmitkLesionTreeModel::columnCount(const QModelIndex&/* itemIndex = QModelIndex() */) const
{
if (0 == m_RootItem->ChildCount())
{
// no lesion items stored, no need to display columns
return 0;
}
return m_ControlPoints.size() + 1;
}
QVariant QmitkLesionTreeModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid())
{
return QVariant();
}
if (index.column() < 0 || index.column() > static_cast<int>(m_ControlPoints.size()))
{
return QVariant();
}
QmitkLesionTreeItem* currentItem = GetItemByIndex(index);
if (Qt::DisplayRole == role)
{
if (currentItem->GetParent().expired())
{
return QVariant();
}
auto parentItem = currentItem->GetParent().lock();
// parent exists and is the root item -> 1. item of a lesion entry
if (m_RootItem == parentItem)
{
// display role fills the first columns with the lesion UID / name
if (0 == index.column())
{
std::string itemString = currentItem->GetData().GetLesionName();
if (itemString.empty())
{
itemString = currentItem->GetData().GetLesionUID();
}
return QString::fromStdString(itemString);
}
else
{
// display role fills other columns with the lesion presence info
const auto lesionPresence = currentItem->GetData().GetLesionPresence();
if (index.column() - 1 > static_cast<int>(lesionPresence.size()))
{
return "N/A";
}
if (lesionPresence.at(index.column() - 1))
{
return QString::fromStdString("present");
}
return QString::fromStdString("not present");
}
}
}
- if (Qt::BackgroundColorRole == role)
+ if (Qt::BackgroundRole == role)
{
auto it = m_DataNodePresence.find(currentItem->GetData().GetLesion().UID);
if (it != m_DataNodePresence.end())
{
return it->second ? QVariant(QColor(Qt::darkGreen)) : QVariant(QColor(Qt::transparent));
}
return QVariant(QColor(Qt::transparent));
}
if (Qt::UserRole == role)
{
return QVariant::fromValue(currentItem);
}
return QVariant();
}
QVariant QmitkLesionTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (0 == m_RootItem->ChildCount())
{
// no lesion items stored, no need to display the header
return QVariant();
}
if (Qt::Horizontal == orientation && Qt::DisplayRole == role)
{
if (0 == section)
{
return QVariant("Lesion");
}
if (static_cast<int>(m_ControlPoints.size()) >= section)
{
mitk::SemanticTypes::ControlPoint currentControlPoint = m_ControlPoints.at(section-1);
return QVariant(QString::fromStdString(currentControlPoint.ToString()));
}
}
return QVariant();
}
const mitk::DataNode* QmitkLesionTreeModel::GetLastSegmentation() const
{
return m_LastSegmentation;
}
void QmitkLesionTreeModel::NodeAdded(const mitk::DataNode* dataNode)
{
if (mitk::NodePredicates::GetSegmentationPredicate()->CheckNode(dataNode))
{
m_LastSegmentation = dataNode;
}
}
void QmitkLesionTreeModel::SetData()
{
m_RootItem = std::make_shared<QmitkLesionTreeItem>(mitk::LesionData());
// get all control points of current case
m_ControlPoints = mitk::RelationStorage::GetAllControlPointsOfCase(m_CaseID);
// sort the vector of control points for the timeline
std::sort(m_ControlPoints.begin(), m_ControlPoints.end());
SetLesionData();
SetSelectedDataNodesPresence();
}
void QmitkLesionTreeModel::SetLesionData()
{
m_CurrentLesions = mitk::RelationStorage::GetAllLesionsOfCase(m_CaseID);
for (auto& lesion : m_CurrentLesions)
{
AddLesion(lesion);
}
}
void QmitkLesionTreeModel::AddLesion(const mitk::SemanticTypes::Lesion& lesion)
{
auto dataStorage = m_DataStorage.Lock();
if (dataStorage.IsNull())
{
return;
}
// create new lesion tree item data and modify it according to the control point data
mitk::LesionData lesionData(lesion);
mitk::ComputeLesionPresence(lesionData, m_CaseID);
// add the top-level lesion item to the root item
std::shared_ptr<QmitkLesionTreeItem> newLesionTreeItem = std::make_shared<QmitkLesionTreeItem>(lesionData);
m_RootItem->AddChild(newLesionTreeItem);
}
void QmitkLesionTreeModel::SetSelectedDataNodesPresence()
{
m_DataNodePresence.clear();
for (const auto& dataNode : qAsConst(m_SelectedDataNodes))
{
if (!mitk::SemanticRelationsInference::InstanceExists(dataNode))
{
continue;
}
for (const auto& lesion : m_CurrentLesions)
{
if (!mitk::SemanticRelationsInference::InstanceExists(m_CaseID, lesion))
{
continue;
}
try
{
// set the lesion presence for the current node
bool dataNodePresence = mitk::SemanticRelationsInference::IsLesionPresent(lesion, dataNode);
SetDataNodePresenceOfLesion(&lesion, dataNodePresence);
}
catch (const mitk::SemanticRelationException&)
{
continue;
}
}
}
}
void QmitkLesionTreeModel::SetDataNodePresenceOfLesion(const mitk::SemanticTypes::Lesion* lesion, bool dataNodePresence)
{
std::map<mitk::SemanticTypes::ID, bool>::iterator iter = m_DataNodePresence.find(lesion->UID);
if (iter != m_DataNodePresence.end())
{
// key already existing, overwrite already stored bool value
iter->second = dataNodePresence;
}
else
{
m_DataNodePresence.insert(std::make_pair(lesion->UID, dataNodePresence));
}
}
QmitkLesionTreeItem* QmitkLesionTreeModel::GetItemByIndex(const QModelIndex& index) const
{
if (index.isValid())
{
auto item = static_cast<QmitkLesionTreeItem*>(index.internalPointer());
if (nullptr != item)
{
return item;
}
}
return m_RootItem.get();
}
diff --git a/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp b/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp
index c60140b1c6..ff9e330c38 100644
--- a/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp
+++ b/Modules/SemanticRelationsUI/src/QmitkPatientTableModel.cpp
@@ -1,346 +1,346 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// semantic relations UI module
#include "QmitkPatientTableModel.h"
#include "QmitkPatientTableHeaderView.h"
#include "QmitkSemanticRelationsUIHelper.h"
// semantic relations module
#include <mitkControlPointManager.h>
#include <mitkNodePredicates.h>
#include <mitkSemanticRelationException.h>
#include <mitkSemanticRelationsInference.h>
#include <mitkRelationStorage.h>
#include <QmitkCustomVariants.h>
#include <QmitkEnums.h>
// qt
#include <QColor>
// c++
#include <iostream>
#include <string>
QmitkPatientTableModel::QmitkPatientTableModel(QObject* parent /*= nullptr*/)
: QmitkAbstractSemanticRelationsStorageModel(parent)
, m_SelectedNodeType("Image")
{
m_HeaderModel = new QStandardItemModel(this);
}
QmitkPatientTableModel::~QmitkPatientTableModel()
{
// nothing here
}
QModelIndex QmitkPatientTableModel::index(int row, int column, const QModelIndex& parent/* = QModelIndex()*/) const
{
if (hasIndex(row, column, parent))
{
return createIndex(row, column);
}
return QModelIndex();
}
QModelIndex QmitkPatientTableModel::parent(const QModelIndex& /*child*/) const
{
return QModelIndex();
}
int QmitkPatientTableModel::rowCount(const QModelIndex& parent/* = QModelIndex()*/) const
{
if (parent.isValid())
{
return 0;
}
return m_InformationTypes.size();
}
int QmitkPatientTableModel::columnCount(const QModelIndex& parent/* = QModelIndex()*/) const
{
if (parent.isValid())
{
return 0;
}
return m_ExaminationPeriods.size();
}
QVariant QmitkPatientTableModel::data(const QModelIndex& index, int role/* = Qt::DisplayRole*/) const
{
// special role for returning the horizontal header
if (QmitkPatientTableHeaderView::HorizontalHeaderDataRole == role)
{
return QVariant::fromValue<QStandardItemModel*>(m_HeaderModel);
}
if (!index.isValid())
{
return QVariant();
}
if (index.row() < 0 || index.row() >= static_cast<int>(m_InformationTypes.size())
|| index.column() < 0 || index.column() >= static_cast<int>(m_ExaminationPeriods.size()))
{
return QVariant();
}
mitk::DataNode* dataNode = GetCurrentDataNode(index);
if (Qt::DecorationRole == role)
{
auto it = m_PixmapMap.find(dataNode);
if (it != m_PixmapMap.end())
{
return QVariant(it->second);
}
auto emptyPixmap = QPixmap(120, 120);
emptyPixmap.fill(Qt::transparent);
return emptyPixmap;
}
- if (Qt::BackgroundColorRole == role)
+ if (Qt::BackgroundRole == role)
{
auto it = m_LesionPresence.find(dataNode);
if (it != m_LesionPresence.end())
{
return it->second ? QVariant(QColor(Qt::darkGreen)) : QVariant(QColor(Qt::transparent));
}
return QVariant(QColor(Qt::transparent));
}
if (QmitkDataNodeRole == role)
{
return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
}
if (QmitkDataNodeRawPointerRole == role)
{
return QVariant::fromValue<mitk::DataNode*>(dataNode);
}
return QVariant();
}
QVariant QmitkPatientTableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (Qt::Vertical == orientation && Qt::DisplayRole == role)
{
if (static_cast<int>(m_InformationTypes.size()) > section)
{
mitk::SemanticTypes::InformationType currentInformationType = m_InformationTypes.at(section);
return QVariant(QString::fromStdString(currentInformationType));
}
}
return QVariant();
}
Qt::ItemFlags QmitkPatientTableModel::flags(const QModelIndex& index) const
{
Qt::ItemFlags flags;
mitk::DataNode* dataNode = GetCurrentDataNode(index);
if (nullptr != dataNode)
{
flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
return flags;
}
void QmitkPatientTableModel::SetNodeType(const std::string& nodeType)
{
m_SelectedNodeType = nodeType;
UpdateModelData();
}
void QmitkPatientTableModel::NodePredicateChanged()
{
UpdateModelData();
}
void QmitkPatientTableModel::SetData()
{
// get all examination periods of current case
m_ExaminationPeriods = mitk::RelationStorage::GetAllExaminationPeriodsOfCase(m_CaseID);
// sort all examination periods for the timeline
mitk::SortAllExaminationPeriods(m_CaseID, m_ExaminationPeriods);
// rename examination periods according to their new order
std::string examinationPeriodName = "Baseline";
for (size_t i = 0; i < m_ExaminationPeriods.size(); ++i)
{
auto& examinationPeriod = m_ExaminationPeriods.at(i);
examinationPeriod.name = examinationPeriodName;
mitk::RelationStorage::RenameExaminationPeriod(m_CaseID, examinationPeriod);
examinationPeriodName = "Follow-up " + std::to_string(i);
}
// get all information types points of current case
m_InformationTypes = mitk::RelationStorage::GetAllInformationTypesOfCase(m_CaseID);
if ("Image" == m_SelectedNodeType)
{
m_CurrentDataNodes = m_SemanticRelationsDataStorageAccess->GetAllImagesOfCase(m_CaseID);
}
else if ("Segmentation" == m_SelectedNodeType)
{
m_CurrentDataNodes = m_SemanticRelationsDataStorageAccess->GetAllSegmentationsOfCase(m_CaseID);
}
SetHeaderModel();
SetPixmaps();
SetLesionPresences();
}
void QmitkPatientTableModel::SetHeaderModel()
{
m_HeaderModel->clear();
QStandardItem* rootItem = new QStandardItem("Timeline");
QList<QStandardItem*> standardItems;
for (const auto& examinationPeriod : m_ExaminationPeriods)
{
QStandardItem* examinationPeriodItem = new QStandardItem(QString::fromStdString(examinationPeriod.name));
standardItems.push_back(examinationPeriodItem);
rootItem->appendColumn(standardItems);
standardItems.clear();
}
m_HeaderModel->setItem(0, 0, rootItem);
}
void QmitkPatientTableModel::SetPixmaps()
{
m_PixmapMap.clear();
for (const auto& dataNode : m_CurrentDataNodes)
{
// set the pixmap for the current node
QPixmap pixmapFromImage = QmitkSemanticRelationsUIHelper::GetPixmapFromImageNode(dataNode);
SetPixmapOfNode(dataNode, &pixmapFromImage);
}
}
void QmitkPatientTableModel::SetPixmapOfNode(const mitk::DataNode* dataNode, QPixmap* pixmapFromImage)
{
if (nullptr == dataNode)
{
return;
}
std::map<mitk::DataNode::ConstPointer, QPixmap>::iterator iter = m_PixmapMap.find(dataNode);
if (iter != m_PixmapMap.end())
{
// key already existing
if (nullptr != pixmapFromImage)
{
// overwrite already stored pixmap
iter->second = pixmapFromImage->scaled(120, 120, Qt::IgnoreAspectRatio);
}
else
{
// remove key if no pixmap is given
m_PixmapMap.erase(iter);
}
}
else
{
m_PixmapMap.insert(std::make_pair(dataNode, pixmapFromImage->scaled(120, 120, Qt::IgnoreAspectRatio)));
}
}
void QmitkPatientTableModel::SetLesionPresences()
{
m_LesionPresence.clear();
if (!mitk::SemanticRelationsInference::InstanceExists(m_CaseID, m_Lesion))
{
return;
}
for (const auto& dataNode : m_CurrentDataNodes)
{
if (!mitk::SemanticRelationsInference::InstanceExists(dataNode))
{
continue;
}
// set the lesion presence for the current node
bool lesionPresence = mitk::SemanticRelationsInference::IsLesionPresent(m_Lesion, dataNode);
SetLesionPresenceOfNode(dataNode, lesionPresence);
}
}
void QmitkPatientTableModel::SetLesionPresenceOfNode(const mitk::DataNode* dataNode, bool lesionPresence)
{
std::map<mitk::DataNode::ConstPointer, bool>::iterator iter = m_LesionPresence.find(dataNode);
if (iter != m_LesionPresence.end())
{
// key already existing, overwrite already stored bool value
iter->second = lesionPresence;
}
else
{
m_LesionPresence.insert(std::make_pair(dataNode, lesionPresence));
}
}
mitk::DataNode* QmitkPatientTableModel::GetCurrentDataNode(const QModelIndex& index) const
{
if (!index.isValid())
{
return nullptr;
}
auto examinationPeriod = m_ExaminationPeriods.at(index.column());
auto currentInformationType = m_InformationTypes.at(index.row());
auto controlPointsOfExaminationPeriod = examinationPeriod.controlPointUIDs;
for (const auto& controlPointUID : controlPointsOfExaminationPeriod)
{
auto currentControlPoint = mitk::GetControlPointByUID(m_CaseID, controlPointUID);
try
{
std::vector<mitk::DataNode::Pointer> filteredDataNodes;
if ("Image" == m_SelectedNodeType)
{
filteredDataNodes = m_SemanticRelationsDataStorageAccess->GetAllSpecificImages(m_CaseID, currentControlPoint, currentInformationType);
}
else if ("Segmentation" == m_SelectedNodeType)
{
filteredDataNodes = m_SemanticRelationsDataStorageAccess->GetAllSpecificSegmentations(m_CaseID, currentControlPoint, currentInformationType);
}
if (filteredDataNodes.empty())
{
// try next control point
continue;
}
else
{
// found a specific image
return filteredDataNodes.front();
}
}
catch (const mitk::SemanticRelationException&)
{
return nullptr;
}
}
// could not find a specif image
return nullptr;
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryQtTracker.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryQtTracker.cpp
index 456b947984..2241519b18 100755
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryQtTracker.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryQtTracker.cpp
@@ -1,328 +1,327 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryTweaklets.h"
#include "berryQtTracker.h"
#include "berryConstants.h"
#include "berryIDropTarget.h"
#include "berryDragUtil.h"
#include "berryGuiWidgetsTweaklet.h"
#include <QEvent>
#include <QKeyEvent>
#include <QApplication>
#include <QRubberBand>
#include <QPixmap>
namespace berry
{
CursorType QtDragManager::PositionToCursorType(int positionConstant)
{
if (positionConstant == Constants::LEFT)
return CURSOR_LEFT;
if (positionConstant == Constants::RIGHT)
return CURSOR_RIGHT;
if (positionConstant == Constants::TOP)
return CURSOR_TOP;
if (positionConstant == Constants::BOTTOM)
return CURSOR_BOTTOM;
if (positionConstant == Constants::CENTER)
return CURSOR_CENTER;
return CURSOR_INVALID;
}
int QtDragManager::CursorTypeToPosition(CursorType dragCursorId)
{
switch (dragCursorId)
{
case CURSOR_LEFT:
return Constants::LEFT;
case CURSOR_RIGHT:
return Constants::RIGHT;
case CURSOR_TOP:
return Constants::TOP;
case CURSOR_BOTTOM:
return Constants::BOTTOM;
case CURSOR_CENTER:
return Constants::CENTER;
default:
return Constants::DEFAULT;
}
}
bool QtDragManager::eventFilter(QObject* o, QEvent* e)
{
if (beingCancelled)
{
if (e->type() == QEvent::KeyRelease && ((QKeyEvent*) e)->key()
== Qt::Key_Escape)
{
QApplication::instance()->removeEventFilter(this);
beingCancelled = false;
eventLoop->exit();
return true; // block the key release
}
return false;
}
if (!o->isWidgetType())
return false;
if (e->type() == QEvent::MouseMove)
{
QMouseEvent* me = (QMouseEvent *) e;
this->Move(me->globalPos());
return true;
}
else if (e->type() == QEvent::MouseButtonRelease)
{
//DEBUG("pre drop");
QApplication::instance()->removeEventFilter(this);
beingCancelled = false;
eventLoop->exit();
return true;
}
if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease)
{
QKeyEvent *ke = ((QKeyEvent*) e);
if (ke->key() == Qt::Key_Escape && e->type() == QEvent::KeyPress)
{
this->Cancel();
QApplication::instance()->removeEventFilter(this);
//beingCancelled = false;
eventLoop->exit();
}
else
{
// move(QCursor::pos());
}
return true; // Eat all key events
}
// ### We bind modality to widgets, so we have to do this
// ### "manually".
// DnD is modal - eat all other interactive events
switch (e->type())
{
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
case QEvent::MouseMove:
case QEvent::KeyPress:
case QEvent::KeyRelease:
case QEvent::Wheel:
case QEvent::ShortcutOverride:
#ifdef QT3_SUPPORT
case QEvent::Accel:
case QEvent::AccelAvailable:
#endif
return true;
default:
return false;
}
}
void QtDragManager::Cancel()
{
beingCancelled = true;
}
void QtDragManager::Move(const QPoint& globalPos)
{
emit tracker->Moved(tracker, globalPos);
}
bool QtDragManager::Drag(QtTracker* tracker)
{
if (tracker == nullptr)
return false;
this->tracker = tracker;
beingCancelled = false;
QApplication::instance()->installEventFilter(this);
// if (!QWidget::mouseGrabber())
// rubberBand->grabMouse();
eventLoop = new QEventLoop;
eventLoop->exec();
delete eventLoop;
eventLoop = nullptr;
return !beingCancelled;
}
QtTracker::QtTracker() :
rubberBand(nullptr), dragManager(nullptr), cursorOverride(0)
{
rubberBand = new QRubberBand(QRubberBand::Rectangle);
QPalette rubberPalette(rubberBand->palette());
//rubberPalette.setColor(QPalette::Button, QColor(Qt::darkRed));
- rubberPalette.setBrush(QPalette::Foreground, QBrush(Qt::darkRed));
+ rubberPalette.setBrush(QPalette::WindowText, QBrush(Qt::darkRed));
rubberPalette.setBrush(QPalette::Window, QBrush(Qt::darkRed));
- rubberPalette.setBrush(QPalette::Background, QBrush(Qt::darkRed));
rubberPalette.setBrush(QPalette::Base, QBrush(Qt::darkRed));
rubberPalette.setBrush(QPalette::Text, QBrush(Qt::darkRed));
rubberBand->setPalette(rubberPalette);
rubberBand->ensurePolished();
QPixmap pixCursorTop(":/org.blueberry.ui.qt/cursor_top.xpm");
auto cursorTop = new QCursor(pixCursorTop, 15, 8);
cursorMap.insert(CURSOR_TOP, cursorTop);
QPixmap pixCursorRight(":/org.blueberry.ui.qt/cursor_right.xpm");
auto cursorRight = new QCursor(pixCursorRight, 23, 15);
cursorMap.insert(CURSOR_RIGHT, cursorRight);
QPixmap pixCursorBottom(":/org.blueberry.ui.qt/cursor_bottom.xpm");
auto cursorBottom = new QCursor(pixCursorBottom, 16, 23);
cursorMap.insert(CURSOR_BOTTOM, cursorBottom);
QPixmap pixCursorLeft(":/org.blueberry.ui.qt/cursor_left.xpm");
auto cursorLeft = new QCursor(pixCursorLeft, 8, 15);
cursorMap.insert(CURSOR_LEFT, cursorLeft);
QPixmap pixCursorCenter(":/org.blueberry.ui.qt/cursor_center.xpm");
auto cursorCenter = new QCursor(pixCursorCenter, 15, 15);
cursorMap.insert(CURSOR_CENTER, cursorCenter);
QPixmap pixCursorOffscreen(":/org.blueberry.ui.qt/cursor_offscreen.xpm");
auto cursorOffscreen = new QCursor(pixCursorOffscreen, 15, 15);
cursorMap.insert(CURSOR_OFFSCREEN, cursorOffscreen);
auto cursorInvalid = new QCursor(Qt::ForbiddenCursor);
cursorMap.insert(CURSOR_INVALID, cursorInvalid);
}
QtTracker::~QtTracker()
{
delete rubberBand;
for (QHash<CursorType, QCursor*>::iterator iter = cursorMap.begin();
iter != cursorMap.end(); ++iter)
{
delete iter.value();
}
}
QRect QtTracker::GetRectangle() const
{
return rubberBand->geometry();
}
void QtTracker::SetRectangle(const QRect& rectangle)
{
rubberBand->setGeometry(rectangle);
}
void QtTracker::SetCursor(CursorType cursorType)
{
QCursor* cursor = cursorMap[cursorType];
if (!cursor) return;
if (cursorOverride > 0)
{
QApplication::changeOverrideCursor(*cursor);
}
else
{
++cursorOverride;
QApplication::setOverrideCursor(*cursor);
}
}
bool QtTracker::Open()
{
rubberBand->show();
dragManager = new QtDragManager();
bool result = dragManager->Drag(this);
delete dragManager;
rubberBand->hide();
while (cursorOverride > 0)
{
QApplication::restoreOverrideCursor();
--cursorOverride;
}
return result;
}
QtTrackerMoveListener::QtTrackerMoveListener(Object::Pointer draggedItem,
const QRect& sourceBounds,
const QPoint& initialLocation,
bool allowSnapping)
: allowSnapping(allowSnapping)
, draggedItem(draggedItem)
, sourceBounds(sourceBounds)
, initialLocation(initialLocation)
{
}
void QtTrackerMoveListener::Moved(QtTracker* tracker, const QPoint& location)
{
// Select a drop target; use the global one by default
IDropTarget::Pointer target;
QWidget* targetControl = Tweaklets::Get(GuiWidgetsTweaklet::KEY)->GetCursorControl();
// Get the drop target for this location
target = DragUtil::GetDropTarget(targetControl, draggedItem, location,
tracker->GetRectangle());
// Set up the tracker feedback based on the target
QRect snapTarget;
if (target != 0)
{
snapTarget = target->GetSnapRectangle();
tracker->SetCursor(target->GetCursor());
}
else
{
tracker->SetCursor(CURSOR_INVALID);
}
// If snapping then reset the tracker's rectangle based on the current drop target
if (allowSnapping)
{
if (snapTarget.width() <= 0 || snapTarget.height() <= 0)
{
snapTarget = QRect(sourceBounds.x() + location.x() - initialLocation.x(),
sourceBounds.y() + location.y() - initialLocation.y(), sourceBounds.width(),
sourceBounds.height());
}
// Try to prevent flicker: don't change the rectangles if they're already in
// the right location
QRect currentRectangle = tracker->GetRectangle();
if (!(currentRectangle == snapTarget))
{
tracker->SetRectangle(snapTarget);
}
}
}
}
diff --git a/Plugins/org.mitk.gui.qt.deformableclippingplane/src/internal/QmitkDeformableClippingPlaneView.cpp b/Plugins/org.mitk.gui.qt.deformableclippingplane/src/internal/QmitkDeformableClippingPlaneView.cpp
index 2d2ffa0a09..6f72a2c5df 100644
--- a/Plugins/org.mitk.gui.qt.deformableclippingplane/src/internal/QmitkDeformableClippingPlaneView.cpp
+++ b/Plugins/org.mitk.gui.qt.deformableclippingplane/src/internal/QmitkDeformableClippingPlaneView.cpp
@@ -1,584 +1,584 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkDeformableClippingPlaneView.h"
#include <usModuleRegistry.h>
// mitk core
#include <mitkImageToSurfaceFilter.h>
#include <mitkInteractionConst.h>
#include <mitkLevelWindowProperty.h>
#include <mitkLookupTableProperty.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateNot.h>
#include <mitkRenderingModeProperty.h>
#include <mitkRotationOperation.h>
#include <mitkSurfaceVtkMapper3D.h>
#include <mitkVtkRepresentationProperty.h>
#include <mitkVtkResliceInterpolationProperty.h>
#include <mitkHeightFieldSurfaceClipImageFilter.h>
#include <mitkClippingPlaneInteractor3D.h>
#include <mitkLabeledImageLookupTable.h>
#include <mitkLabeledImageVolumeCalculator.h>
#include <mitkSurfaceDeformationDataInteractor3D.h>
#include <vtkFloatArray.h>
#include <vtkPointData.h>
#include <vtkPlaneSource.h>
#include <vtkProperty.h>
#include <mitkILinkedRenderWindowPart.h>
#include <array>
const std::string QmitkDeformableClippingPlaneView::VIEW_ID = "org.mitk.views.deformableclippingplane";
QmitkDeformableClippingPlaneView::QmitkDeformableClippingPlaneView()
: QmitkAbstractView()
, m_Controls(new Ui::QmitkDeformableClippingPlaneViewControls)
, m_WorkingNode(nullptr)
{
auto isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
auto isNotHelperObject = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
m_IsImagePredicate = mitk::NodePredicateAnd::New(isImage, isNotHelperObject);
m_IsClippingPlanePredicate = mitk::NodePredicateProperty::New("clippingPlane", mitk::BoolProperty::New(true));
}
QmitkDeformableClippingPlaneView::~QmitkDeformableClippingPlaneView()
{
if (m_WorkingNode.IsNotNull())
m_WorkingNode->SetDataInteractor(nullptr);
}
void QmitkDeformableClippingPlaneView::SetFocus()
{
m_Controls->createNewPlanePushButton->setFocus();
}
void QmitkDeformableClippingPlaneView::CreateQtPartControl(QWidget *parent)
{
m_Controls->setupUi(parent);
m_Controls->imageSelectionWidget->SetDataStorage(GetDataStorage());
m_Controls->imageSelectionWidget->SetNodePredicate(m_IsImagePredicate);
m_Controls->imageSelectionWidget->SetSelectionIsOptional(false);
m_Controls->imageSelectionWidget->SetInvalidInfo("Select an image or segmentation.");
m_Controls->imageSelectionWidget->SetPopUpTitel("Select an image or segmentation.");
m_Controls->clippingPlaneSelector->SetDataStorage(this->GetDataStorage());
m_Controls->clippingPlaneSelector->SetPredicate(m_IsClippingPlanePredicate);
m_Controls->volumeGroupBox->setEnabled(false);
m_Controls->interactionSelectionBox->setEnabled(false);
m_Controls->planesWarningLabel->hide();
this->CreateConnections();
m_Controls->imageSelectionWidget->SetAutoSelectNewNodes(true);
}
void QmitkDeformableClippingPlaneView::OnCurrentSelectionChanged(const QList<mitk::DataNode::Pointer>& /*nodes*/)
{
this->UpdateView();
}
void QmitkDeformableClippingPlaneView::OnComboBoxSelectionChanged(const mitk::DataNode* node)
{
this->DeactivateInteractionButtons();
auto selectedNode = const_cast<mitk::DataNode*>(node);
if(nullptr != selectedNode)
{
if(m_WorkingNode.IsNotNull())
selectedNode->SetDataInteractor(m_WorkingNode->GetDataInteractor());
m_WorkingNode = selectedNode;
}
this->UpdateView();
}
void QmitkDeformableClippingPlaneView::OnCreateNewClippingPlane()
{
this->DeactivateInteractionButtons();
auto plane = mitk::Surface::New();
auto planeSource = vtkSmartPointer<vtkPlaneSource>::New();
planeSource->SetOrigin(-32.0, -32.0, 0.0);
planeSource->SetPoint1(32.0, -32.0, 0.0);
planeSource->SetPoint2(-32.0, 32.0, 0.0);
planeSource->SetResolution(128, 128);
planeSource->Update();
plane->SetVtkPolyData(planeSource->GetOutput());
mitk::ScalarType imageDiagonal = 200.0;
auto selectedNode = m_Controls->imageSelectionWidget->GetSelectedNode();
if (selectedNode.IsNotNull())
{
auto selectedImage = dynamic_cast<mitk::Image*>(selectedNode->GetData());
if (nullptr != selectedImage)
{
// check if user wants a surface model
if (m_Controls->surfaceModelCheckBox->isChecked())
{
//Check if there is a surface node from the image. If not, create one
bool createSurfaceFromImage = true;
auto isSurface = mitk::NodePredicateDataType::New("Surface");
auto childNodes = GetDataStorage()->GetDerivations(selectedNode, isSurface, true);
for (mitk::DataStorage::SetOfObjects::ConstIterator it = childNodes->Begin();
it != childNodes->End(); it++)
{
if (it.Value().IsNotNull() && it->Value()->GetName() == selectedNode->GetName())
{
createSurfaceFromImage = false;
it.Value()->SetVisibility(true);
}
}
if (createSurfaceFromImage)
{
//Lsg 2: Surface for the 3D-perspective
auto surfaceFilter = mitk::ImageToSurfaceFilter::New();
surfaceFilter->SetInput(selectedImage);
surfaceFilter->SetThreshold(1);
surfaceFilter->SetSmooth(true);
//Downsampling
surfaceFilter->SetDecimate(mitk::ImageToSurfaceFilter::DecimatePro);
auto surfaceNode = mitk::DataNode::New();
surfaceNode->SetData(surfaceFilter->GetOutput());
surfaceNode->SetProperty("color", selectedNode->GetProperty("color"));
surfaceNode->SetOpacity(0.5);
surfaceNode->SetName(selectedNode->GetName());
this->GetDataStorage()->Add(surfaceNode, selectedNode);
}
}
//If an image is selected trim the plane to this.
imageDiagonal = selectedImage->GetGeometry()->GetDiagonalLength();
plane->SetOrigin(selectedImage->GetGeometry()->GetCenter());
// Rotate plane
mitk::Vector3D rotationAxis;
mitk::FillVector3D(rotationAxis, 0.0, 1.0, 0.0);
mitk::RotationOperation op(mitk::OpROTATE, selectedImage->GetGeometry()->GetCenter(), rotationAxis, 90.0);
plane->GetGeometry()->ExecuteOperation(&op);
}
}
// equivalent to the extent and resolution function of the clipping plane
const auto x = imageDiagonal * 0.9;
planeSource->SetOrigin(-x / 2.0, -x / 2.0, 0.0);
planeSource->SetPoint1(x / 2.0, -x / 2.0, 0.0);
planeSource->SetPoint2(-x / 2.0, x / 2.0, 0.0);
planeSource->SetResolution(64, 64);
planeSource->Update();
plane->SetVtkPolyData(planeSource->GetOutput());
// Set scalars (for colorization of plane)
vtkFloatArray *scalars = vtkFloatArray::New();
scalars->SetName("Distance");
scalars->SetNumberOfComponents(1);
const auto numerOfPoints = plane->GetVtkPolyData(0)->GetNumberOfPoints();
for (std::remove_const_t<decltype(numerOfPoints)> i = 0; i < plane->GetVtkPolyData(0)->GetNumberOfPoints(); ++i)
{
scalars->InsertNextValue(-1.0);
}
plane->GetVtkPolyData(0)->GetPointData()->SetScalars(scalars);
plane->GetVtkPolyData(0)->GetPointData()->Update();
auto planeNode = mitk::DataNode::New();
planeNode->SetData(plane);
std::stringstream planeName;
planeName << "ClippingPlane ";
planeName << this->GetAllClippingPlanes()->Size() + 1;
planeNode->SetName(planeName.str());
planeNode->AddProperty("clippingPlane", mitk::BoolProperty::New(true));
// Make plane pickable
planeNode->SetBoolProperty("pickable", true);
mitk::SurfaceVtkMapper3D::SetDefaultProperties(planeNode);
// Don't include plane in bounding box!
planeNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
// Set lookup table for plane surface visualization
auto lookupTablevtk = vtkSmartPointer<vtkLookupTable>::New();
lookupTablevtk->SetHueRange(0.6, 0.0);
lookupTablevtk->SetSaturationRange(1.0, 1.0);
lookupTablevtk->SetValueRange(1.0, 1.0);
lookupTablevtk->SetTableRange(-1.0, 1.0);
lookupTablevtk->Build();
auto lookupTable = mitk::LookupTable::New();
lookupTable->SetVtkLookupTable(lookupTablevtk);
auto prop = mitk::LookupTableProperty::New(lookupTable);
planeNode->SetProperty("LookupTable", prop);
planeNode->SetBoolProperty("scalar visibility", true);
planeNode->SetBoolProperty("color mode", true);
planeNode->SetFloatProperty("ScalarsRangeMinimum", -1.0);
planeNode->SetFloatProperty("ScalarsRangeMaximum", 1.0);
// Configure material so that only scalar colors are shown
planeNode->SetColor(0.0f, 0.0f, 0.0f);
planeNode->SetOpacity(1.0f);
planeNode->SetFloatProperty("material.wireframeLineWidth", 2.0f);
//Set view of plane to wireframe
planeNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New(VTK_WIREFRAME));
//Add the plane to data storage
this->GetDataStorage()->Add(planeNode);
//Change the index of the selector to the new generated node
m_Controls->clippingPlaneSelector->setCurrentIndex(m_Controls->clippingPlaneSelector->Find(planeNode));
m_Controls->interactionSelectionBox->setEnabled(true);
if (auto renderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
{
renderWindowPart->EnableSlicingPlanes(false);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkDeformableClippingPlaneView::OnCalculateClippingVolume()
{
auto selectedNode = m_Controls->imageSelectionWidget->GetSelectedNode();
if (selectedNode.IsNull())
{
MITK_ERROR << "No segmentation selected! Can't calculate volume";
return;
}
bool isSegmentation = false;
selectedNode->GetBoolProperty("binary", isSegmentation);
if (!isSegmentation)
{
MITK_ERROR << "No segmentation selected! Can't calculate volume";
return;
}
std::vector<mitk::Surface*> clippingPlanes;
mitk::DataStorage::SetOfObjects::ConstPointer allClippingPlanes = this->GetAllClippingPlanes();
for (mitk::DataStorage::SetOfObjects::ConstIterator itPlanes = allClippingPlanes->Begin(); itPlanes != allClippingPlanes->End(); itPlanes++)
{
bool isVisible = false;
itPlanes.Value()->GetBoolProperty("visible", isVisible);
auto plane = dynamic_cast<mitk::Surface*>(itPlanes.Value()->GetData());
if (isVisible && nullptr != plane)
clippingPlanes.push_back(plane);
}
if (clippingPlanes.empty())
{
MITK_ERROR << "No clipping plane selected! Can't calculate volume";
return;
}
// deactivate Tools
this->DeactivateInteractionButtons();
//Clear the list of volumes, before calculating the new values
m_Controls->volumeList->clear();
selectedNode->SetBoolProperty("visible", false);
//set some properties for clipping the image-->Output: labeled Image
mitk::HeightFieldSurfaceClipImageFilter::Pointer surfaceClipFilter = mitk::HeightFieldSurfaceClipImageFilter::New();
surfaceClipFilter->SetInput(dynamic_cast<mitk::Image*>(selectedNode->GetData()));
surfaceClipFilter->SetClippingModeToMultiPlaneValue();
surfaceClipFilter->SetClippingSurfaces(clippingPlanes);
surfaceClipFilter->Update();
//delete the old clipped image node
mitk::DataStorage::SetOfObjects::ConstPointer oldClippedNode = this->GetDataStorage()->GetSubset(mitk::NodePredicateProperty::New("name", mitk::StringProperty::New("Clipped Image")));
if (oldClippedNode.IsNotNull())
this->GetDataStorage()->Remove(oldClippedNode);
//add the new clipped image node
auto clippedNode = mitk::DataNode::New();
mitk::Image::Pointer clippedImage = surfaceClipFilter->GetOutput();
clippedImage->DisconnectPipeline();
clippedNode->SetData(clippedImage);
clippedNode->SetName("Clipped Image");
clippedNode->SetColor(1.0, 1.0, 1.0); // color property will not be used, labeled image lookuptable will be used instead
clippedNode->SetProperty("use color", mitk::BoolProperty::New(false));
clippedNode->SetProperty("reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_NEAREST));
clippedNode->SetOpacity(0.4);
this->GetDataStorage()->Add(clippedNode);
auto volumeCalculator = mitk::LabeledImageVolumeCalculator::New();
volumeCalculator->SetImage(clippedImage);
volumeCalculator->Calculate();
auto volumes = volumeCalculator->GetVolumes();
auto lookupTable = mitk::LabeledImageLookupTable::New();
int lablesWithVolume = 0;
const auto numberOfVolumes = volumes.size();
for (std::remove_const_t<decltype(numberOfVolumes)> i = 1; i < numberOfVolumes; ++i)
{
if (0 != volumes[0])
{
lablesWithVolume++;
mitk::Color color(GetLabelColor(lablesWithVolume));
lookupTable->SetColorForLabel(i, color.GetRed(), color.GetGreen(), color.GetBlue(), 1.0);
QColor qcolor;
qcolor.setRgbF(color.GetRed(), color.GetGreen(), color.GetBlue(), 0.7);
//output volume as string "x.xx ml"
std::stringstream stream;
stream << std::fixed << std::setprecision(2) << 0.001 * volumes[i] << " ml";
stream << " ml";
auto item = new QListWidgetItem();
item->setText(QString::fromStdString(stream.str()));
- item->setBackgroundColor(qcolor);
+ item->setBackground(qcolor);
m_Controls->volumeList->addItem(item);
}
}
//set the rendering mode to use the lookup table and level window
clippedNode->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR));
mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New(lookupTable.GetPointer());
clippedNode->SetProperty("LookupTable", lutProp);
// it is absolutely important, to use the LevelWindow settings provided by
// the LUT generator, otherwise, it is not guaranteed, that colors show
// up correctly.
clippedNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(lookupTable->GetLevelWindow()));
}
void QmitkDeformableClippingPlaneView::OnTranslationMode(bool check)
{
if (check)
{ //uncheck all other buttons
m_Controls->rotationPushButton->setChecked(false);
m_Controls->deformationPushButton->setChecked(false);
mitk::ClippingPlaneInteractor3D::Pointer affineDataInteractor = mitk::ClippingPlaneInteractor3D::New();
affineDataInteractor->LoadStateMachine("ClippingPlaneInteraction3D.xml", us::ModuleRegistry::GetModule("MitkDataTypesExt"));
affineDataInteractor->SetEventConfig("ClippingPlaneTranslationConfig.xml", us::ModuleRegistry::GetModule("MitkDataTypesExt"));
affineDataInteractor->SetDataNode(m_WorkingNode);
}
else
m_WorkingNode->SetDataInteractor(nullptr);
}
void QmitkDeformableClippingPlaneView::OnRotationMode(bool check)
{
if (check)
{ //uncheck all other buttons
m_Controls->translationPushButton->setChecked(false);
m_Controls->deformationPushButton->setChecked(false);
mitk::ClippingPlaneInteractor3D::Pointer affineDataInteractor = mitk::ClippingPlaneInteractor3D::New();
affineDataInteractor->LoadStateMachine("ClippingPlaneInteraction3D.xml", us::ModuleRegistry::GetModule("MitkDataTypesExt"));
affineDataInteractor->SetEventConfig("ClippingPlaneRotationConfig.xml", us::ModuleRegistry::GetModule("MitkDataTypesExt"));
affineDataInteractor->SetDataNode(m_WorkingNode);
}
else
m_WorkingNode->SetDataInteractor(nullptr);
}
void QmitkDeformableClippingPlaneView::OnDeformationMode(bool check)
{
if (check)
{ //uncheck all other buttons
m_Controls->translationPushButton->setChecked(false);
m_Controls->rotationPushButton->setChecked(false);
mitk::SurfaceDeformationDataInteractor3D::Pointer surfaceDataInteractor = mitk::SurfaceDeformationDataInteractor3D::New();
surfaceDataInteractor->LoadStateMachine("ClippingPlaneInteraction3D.xml", us::ModuleRegistry::GetModule("MitkDataTypesExt"));
surfaceDataInteractor->SetEventConfig("ClippingPlaneDeformationConfig.xml", us::ModuleRegistry::GetModule("MitkDataTypesExt"));
surfaceDataInteractor->SetDataNode(m_WorkingNode);
}
else
m_WorkingNode->SetDataInteractor(nullptr);
}
void QmitkDeformableClippingPlaneView::CreateConnections()
{
connect(m_Controls->imageSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
this, &QmitkDeformableClippingPlaneView::OnCurrentSelectionChanged);
connect(m_Controls->translationPushButton, &QPushButton::toggled,
this, &QmitkDeformableClippingPlaneView::OnTranslationMode);
connect(m_Controls->rotationPushButton, &QPushButton::toggled,
this, &QmitkDeformableClippingPlaneView::OnRotationMode);
connect(m_Controls->deformationPushButton, &QPushButton::toggled,
this, &QmitkDeformableClippingPlaneView::OnDeformationMode);
connect(m_Controls->createNewPlanePushButton, &QPushButton::clicked,
this, &QmitkDeformableClippingPlaneView::OnCreateNewClippingPlane);
connect(m_Controls->updateVolumePushButton, &QPushButton::clicked,
this, &QmitkDeformableClippingPlaneView::OnCalculateClippingVolume);
connect(m_Controls->clippingPlaneSelector, &QmitkDataStorageComboBox::OnSelectionChanged,
this, &QmitkDeformableClippingPlaneView::OnComboBoxSelectionChanged);
}
void QmitkDeformableClippingPlaneView::NodeRemoved(const mitk::DataNode* node)
{
if (m_IsClippingPlanePredicate->CheckNode(node))
{
if (this->GetAllClippingPlanes()->Size() <= 1)
{
m_WorkingNode = nullptr;
this->UpdateView();
}
}
}
void::QmitkDeformableClippingPlaneView::NodeChanged(const mitk::DataNode*)
{
this->UpdateView();
}
void QmitkDeformableClippingPlaneView::UpdateView()
{
auto selectedNode = m_Controls->imageSelectionWidget->GetSelectedNode();
if (selectedNode.IsNotNull())
{
m_Controls->selectedReferenceImageLabel->setText(QString::fromUtf8(selectedNode->GetName().c_str()));
if (m_WorkingNode.IsNotNull())
{
bool isSegmentation = false;
selectedNode->GetBoolProperty("binary", isSegmentation);
m_Controls->interactionSelectionBox->setEnabled(true);
m_Controls->volumeGroupBox->setEnabled(isSegmentation);
//clear list --> than search for all shown clipping plans (max 7 planes)
m_Controls->selectedClippingPlanesLabel->setText("");
m_Controls->planesWarningLabel->hide();
int volumePlanes = 0;
auto allClippingPlanes = this->GetAllClippingPlanes();
for (mitk::DataStorage::SetOfObjects::ConstIterator itPlanes = allClippingPlanes->Begin(); itPlanes != allClippingPlanes->End(); itPlanes++)
{
bool isVisible = false;
itPlanes.Value()->GetBoolProperty("visible", isVisible);
if (isVisible)
{
if (volumePlanes < 7)
{
++volumePlanes;
m_Controls->selectedClippingPlanesLabel->setText(m_Controls->selectedClippingPlanesLabel->text().append(QString::fromStdString(itPlanes.Value()->GetName()+"\n")));
}
else
{
m_Controls->planesWarningLabel->show();
return;
}
}
}
}
else
{
m_Controls->volumeGroupBox->setEnabled(false);
m_Controls->interactionSelectionBox->setEnabled(false);
m_Controls->selectedClippingPlanesLabel->setText("");
m_Controls->volumeList->clear();
}
}
else
{
m_Controls->volumeGroupBox->setEnabled(false);
m_Controls->selectedReferenceImageLabel->setText("");
m_Controls->selectedClippingPlanesLabel->setText("");
m_Controls->planesWarningLabel->hide();
m_Controls->interactionSelectionBox->setEnabled(m_WorkingNode.IsNotNull());
}
}
mitk::DataStorage::SetOfObjects::ConstPointer QmitkDeformableClippingPlaneView::GetAllClippingPlanes()
{
auto allPlanes = GetDataStorage()->GetSubset(m_IsClippingPlanePredicate);
return allPlanes;
}
mitk::Color QmitkDeformableClippingPlaneView::GetLabelColor(int label)
{
std::array<float, 3> color = { 0.0f, 0.0f, 0.0f };
switch (label % 6)
{
case 0: // red
color[0] = 1.0f;
break;
case 1: // green
color[1] = 1.0f;
break;
case 2: // blue
color[2] = 1.0f;
break;
case 3: // yellow
color[0] = 1.0f;
color[1] = 1.0f;
break;
case 4: // magenta
color[0] = 1.0f;
color[2] = 1.0f;
break;
case 5: // cyan
color[1] = 1.0f;
color[2] = 1.0f;
default: // black
break;
}
int outerCycleNr = label / 6;
int cycleSize = std::min(1, static_cast<int>(std::pow(2.0, std::log(outerCycleNr) / std::log(2.0))));
int insideCycleCounter = outerCycleNr % cycleSize;
float factor;
if (0 == outerCycleNr)
{
factor = 255.0f;
}
else
{
factor = 256.0f / (2.0f * cycleSize) + insideCycleCounter * (256.0f / cycleSize);
}
color = {
std::min(1.0f, color[0] / 256.0f * factor),
std::min(1.0f, color[1] / 256.0f * factor),
std::min(1.0f, color[2] / 256.0f * factor)
};
return mitk::Color(color.data());
}
void QmitkDeformableClippingPlaneView::DeactivateInteractionButtons()
{
m_Controls->translationPushButton->setChecked(false);
m_Controls->rotationPushButton->setChecked(false);
m_Controls->deformationPushButton->setChecked(false);
}
diff --git a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.cpp b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.cpp
index bb5465eb1b..b7351fe0f3 100644
--- a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.cpp
+++ b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.cpp
@@ -1,918 +1,918 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "ModelFitInspectorView.h"
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
#include <berryIWorkbenchPage.h>
// mitk
#include <QmitkRenderWindow.h>
// Qt
#include <QMessageBox>
#include <QFileDialog>
#include <QTableWidget>
#include <qwt_plot_marker.h>
#include <QmitkPlotWidget.h>
#include <mitkNodePredicateFunction.h>
#include <mitkScalarListLookupTableProperty.h>
#include <mitkModelFitConstants.h>
#include <mitkExtractTimeGrid.h>
#include <mitkModelGenerator.h>
#include <mitkModelFitException.h>
#include <mitkModelFitParameterValueExtraction.h>
#include <mitkModelFitResultRelationRule.h>
#include <mitkModelFitPlotDataHelper.h>
#include <mitkTimeGridHelper.h>
#include <mitkTimeNavigationController.h>
const std::string ModelFitInspectorView::VIEW_ID = "org.mitk.views.fit.inspector";
const unsigned int ModelFitInspectorView::INTERPOLATION_STEPS = 10;
const std::string DEFAULT_X_AXIS = "Time [s]";
ModelFitInspectorView::ModelFitInspectorView() :
m_renderWindowPart(nullptr),
m_internalUpdateFlag(false),
m_currentFit(nullptr),
m_currentModelParameterizer(nullptr),
m_currentModelProviderService(nullptr),
m_currentSelectedTimeStep(0),
m_currentSelectedNode(nullptr)
{
m_currentSelectedPosition.Fill(0.0);
m_modelfitList.clear();
}
ModelFitInspectorView::~ModelFitInspectorView()
{
}
void ModelFitInspectorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
{
if (m_renderWindowPart != renderWindowPart)
{
m_renderWindowPart = renderWindowPart;
}
this->m_SliceChangeListener.RenderWindowPartActivated(renderWindowPart);
}
void ModelFitInspectorView::RenderWindowPartDeactivated(
mitk::IRenderWindowPart* renderWindowPart)
{
m_renderWindowPart = nullptr;
this->m_SliceChangeListener.RenderWindowPartDeactivated(renderWindowPart);
}
void ModelFitInspectorView::CreateQtPartControl(QWidget* parent)
{
m_Controls.setupUi(parent);
m_SelectionServiceConnector = std::make_unique<QmitkSelectionServiceConnector>();
m_SelectionServiceConnector->AddPostSelectionListener(this->GetSite()->GetWorkbenchWindow()->GetSelectionService());
m_Controls.inputNodeSelector->SetDataStorage(GetDataStorage());
m_Controls.inputNodeSelector->SetEmptyInfo(QString("Please select input data to be viewed."));
m_Controls.inputNodeSelector->SetInvalidInfo(QString("<b><font color=\"red\">No input data is selected</font></b>"));
m_Controls.inputNodeSelector->SetPopUpTitel(QString("Choose 3D+t input data that should be viewed!"));
m_Controls.inputNodeSelector->SetSelectionIsOptional(false);
m_Controls.inputNodeSelector->SetSelectOnlyVisibleNodes(true);
auto predicate = mitk::NodePredicateFunction::New([](const mitk::DataNode *node) {
bool isModelFitNode = node->GetData() && node->GetData()->GetProperty(mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str()).IsNotNull();
return isModelFitNode || (node && node->GetData() && node->GetData()->GetTimeSteps() > 1);
});
m_Controls.inputNodeSelector->SetNodePredicate(predicate);
connect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.inputNodeSelector, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
connect(m_Controls.inputNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &ModelFitInspectorView::OnInputChanged);
this->m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
connect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
connect(m_Controls.cmbFit, SIGNAL(currentIndexChanged(int)), this,
SLOT(OnFitSelectionChanged(int)));
connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.sbFixMin,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.sbFixMax,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.labelFixMin,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.labelFixMax,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.btnScaleToData,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), this, SLOT(OnScaleFixedYChecked(bool)));
connect(m_Controls.btnScaleToData, SIGNAL(clicked()), this, SLOT(OnScaleToDataYClicked()));
connect(m_Controls.sbFixMax, SIGNAL(valueChanged(double)), this,
SLOT(OnFixedScalingYChanged(double)));
connect(m_Controls.sbFixMin, SIGNAL(valueChanged(double)), this,
SLOT(OnFixedScalingYChanged(double)));
connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.sbFixMin_x,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.sbFixMax_x,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.labelFixMin_x,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.labelFixMax_x,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.btnScaleToData_x,
SLOT(setEnabled(bool)));
connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), this, SLOT(OnScaleFixedXChecked(bool)));
connect(m_Controls.btnScaleToData_x, SIGNAL(clicked()), this, SLOT(OnScaleToDataXClicked()));
connect(m_Controls.sbFixMax_x, SIGNAL(valueChanged(double)), this,
SLOT(OnFixedScalingXChanged(double)));
connect(m_Controls.sbFixMin_x, SIGNAL(valueChanged(double)), this,
SLOT(OnFixedScalingXChanged(double)));
connect(m_Controls.btnFullPlot, SIGNAL(clicked(bool)), this, SLOT(OnFullPlotClicked(bool)));
this->EnsureBookmarkPointSet();
m_Controls.inspectionPositionWidget->SetPositionBookmarkNode(m_PositionBookmarksNode.Lock());
connect(m_Controls.inspectionPositionWidget, SIGNAL(PositionBookmarksChanged()), this, SLOT(OnPositionBookmarksChanged()));
// For some reason this needs to be called to set the plot widget's minimum width to an
// acceptable level (since Qwt 6).
// Otherwise it tries to keep both axes equal in length, resulting in a minimum width of
// 400-500px which is way too much.
m_Controls.widgetPlot->GetPlot()->updateAxes();
m_Controls.cmbFit->clear();
mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart();
RenderWindowPartActivated(renderWindowPart);
}
void ModelFitInspectorView::SetFocus()
{
}
void ModelFitInspectorView::NodeRemoved(const mitk::DataNode* node)
{
if (node == this->m_currentSelectedNode)
{
QmitkSingleNodeSelectionWidget::NodeList emptylist;
this->m_Controls.inputNodeSelector->SetCurrentSelection(emptylist);
}
}
void ModelFitInspectorView::OnScaleFixedYChecked(bool checked)
{
m_Controls.widgetPlot->GetPlot()->setAxisAutoScale(QwtPlot::yLeft, !checked);
if (checked)
{
OnScaleToDataYClicked();
}
m_Controls.widgetPlot->GetPlot()->replot();
};
void ModelFitInspectorView::OnScaleFixedXChecked(bool checked)
{
m_Controls.widgetPlot->GetPlot()->setAxisAutoScale(QwtPlot::xBottom, !checked);
if (checked)
{
OnScaleToDataXClicked();
}
m_Controls.widgetPlot->GetPlot()->replot();
};
void ModelFitInspectorView::OnScaleToDataYClicked()
{
auto minmax = this->m_PlotCurves.GetYMinMax();
auto min = minmax.first - std::abs(minmax.first) * 0.01;
auto max = minmax.second + std::abs(minmax.second) * 0.01;
m_Controls.sbFixMin->setValue(min);
m_Controls.sbFixMax->setValue(max);
};
void ModelFitInspectorView::OnScaleToDataXClicked()
{
auto minmax = this->m_PlotCurves.GetXMinMax();
auto min = minmax.first - std::abs(minmax.first) * 0.01;
auto max = minmax.second + std::abs(minmax.second) * 0.01;
m_Controls.sbFixMin_x->setValue(min);
m_Controls.sbFixMax_x->setValue(max);
};
void ModelFitInspectorView::OnFixedScalingYChanged(double /*value*/)
{
m_Controls.widgetPlot->GetPlot()->setAxisScale(QwtPlot::yLeft, m_Controls.sbFixMin->value(),
m_Controls.sbFixMax->value());
m_Controls.widgetPlot->GetPlot()->replot();
};
void ModelFitInspectorView::OnFixedScalingXChanged(double /*value*/)
{
m_Controls.widgetPlot->GetPlot()->setAxisScale(QwtPlot::xBottom, m_Controls.sbFixMin_x->value(),
m_Controls.sbFixMax_x->value());
m_Controls.widgetPlot->GetPlot()->replot();
};
void ModelFitInspectorView::OnFullPlotClicked(bool checked)
{
m_Controls.tabWidget->setVisible(!checked);
};
int ModelFitInspectorView::ActualizeFitSelectionWidget()
{
mitk::modelFit::ModelFitInfo::UIDType selectedFitUD = "";
bool isModelFitNode = false;
if (this->m_Controls.inputNodeSelector->GetSelectedNode().IsNotNull())
{
isModelFitNode = this->m_Controls.inputNodeSelector->GetSelectedNode()->GetData()->GetPropertyList()->GetStringProperty(
mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), selectedFitUD);
}
mitk::DataStorage::Pointer storage = this->GetDataStorage();
mitk::modelFit::NodeUIDSetType fitUIDs = mitk::modelFit::GetFitUIDsOfNode(
this->m_currentSelectedNode, storage);
this->m_modelfitList.clear();
this->m_Controls.cmbFit->clear();
for (const auto & fitUID : fitUIDs)
{
mitk::modelFit::ModelFitInfo::ConstPointer info = mitk::modelFit::CreateFitInfoFromNode(fitUID,
storage).GetPointer();
if (info.IsNotNull())
{
this->m_modelfitList.insert(std::make_pair(info->uid, info));
std::ostringstream nameStrm;
if (info->fitName.empty())
{
nameStrm << info->uid;
}
else
{
nameStrm << info->fitName;
}
nameStrm << " (" << info->modelName << ")";
QVariant data(info->uid.c_str());
m_Controls.cmbFit->addItem(QString::fromStdString(nameStrm.str()), data);
}
else
{
MITK_ERROR <<
"Was not able to extract model fit information from storage. Node properties in storage may be invalid. Failed fit UID:"
<< fitUID;
}
}
int cmbIndex = 0;
if (m_modelfitList.empty())
{
cmbIndex = -1;
};
if (isModelFitNode)
{
//model was selected, thus select this one in combobox
QVariant data(selectedFitUD.c_str());
cmbIndex = m_Controls.cmbFit->findData(data);
if (cmbIndex == -1)
{
MITK_WARN <<
"Model fit Inspector in invalid state. Selected fit seems to be not available in plugin selection. Failed fit UID:"
<< selectedFitUD;
}
};
m_Controls.cmbFit->setCurrentIndex(cmbIndex);
return cmbIndex;
}
void ModelFitInspectorView::OnInputChanged(const QList<mitk::DataNode::Pointer>& nodes)
{
if (nodes.size() > 0)
{
if (nodes.front() != this->m_currentSelectedNode)
{
m_internalUpdateFlag = true;
this->m_currentSelectedNode = nodes.front();
mitk::modelFit::ModelFitInfo::UIDType selectedFitUD = "";
bool isModelFitNode = this->m_currentSelectedNode->GetData()->GetPropertyList()->GetStringProperty(
mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), selectedFitUD);
if (isModelFitNode)
{
this->m_currentSelectedNode = this->GetInputNode(this->m_currentSelectedNode);
if (this->m_currentSelectedNode.IsNull())
{
MITK_WARN <<
"Model fit Inspector in invalid state. Input image for selected fit cannot be found in data storage. Failed fit UID:"
<< selectedFitUD;
}
}
auto cmbIndex = ActualizeFitSelectionWidget();
m_internalUpdateFlag = false;
m_selectedNodeTime.Modified();
if (cmbIndex == -1)
{
//only raw 4D data selected. Just update plots for current position
m_currentFit = nullptr;
m_currentFitTime.Modified();
OnSliceChanged();
m_Controls.plotDataWidget->SetXName(DEFAULT_X_AXIS);
}
else
{
//refresh fit selection (and implicitly update plots)
OnFitSelectionChanged(cmbIndex);
}
}
}
else
{
if (this->m_currentSelectedNode.IsNotNull())
{
m_internalUpdateFlag = true;
this->m_currentSelectedNode = nullptr;
this->m_currentFit = nullptr;
this->m_modelfitList.clear();
this->m_Controls.cmbFit->clear();
m_internalUpdateFlag = false;
m_selectedNodeTime.Modified();
OnFitSelectionChanged(0);
RefreshPlotData();
m_Controls.plotDataWidget->SetPlotData(&(this->m_PlotCurves));
m_Controls.fitParametersWidget->setFits(QmitkFitParameterModel::FitVectorType());
RenderPlot();
}
}
}
mitk::DataNode::ConstPointer
ModelFitInspectorView::GetInputNode(mitk::DataNode::ConstPointer node)
{
if (node.IsNotNull())
{
std::string selectedFitUD = "";
auto rule = mitk::ModelFitResultRelationRule::New();
auto predicate = rule->GetDestinationsDetector(node);
mitk::DataStorage::SetOfObjects::ConstPointer parentNodeList =
GetDataStorage()->GetSubset(predicate);
if (parentNodeList->size() > 0)
{
return parentNodeList->front().GetPointer();
}
}
return mitk::DataNode::ConstPointer();
}
void ModelFitInspectorView::ValidateAndSetCurrentPosition()
{
const mitk::Point3D currentSelectedPosition = GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetSelectedPosition(nullptr);
const unsigned int currentSelectedTimestep = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimeStep();
if (m_currentSelectedPosition != currentSelectedPosition
|| m_currentSelectedTimeStep != currentSelectedTimestep
|| m_selectedNodeTime > m_currentPositionTime)
{
//the current position has been changed or the selected node has been changed since the last position validation -> check position
m_currentSelectedPosition = currentSelectedPosition;
m_currentSelectedTimeStep = currentSelectedTimestep;
m_currentPositionTime.Modified();
m_validSelectedPosition = false;
auto inputImage = this->GetCurrentInputImage();
if (inputImage.IsNull())
{
return;
}
mitk::BaseGeometry::ConstPointer geometry = inputImage->GetTimeGeometry()->GetGeometryForTimeStep(
m_currentSelectedTimeStep).GetPointer();
// check for invalid time step
if (geometry.IsNull())
{
geometry = inputImage->GetTimeGeometry()->GetGeometryForTimeStep(0);
}
if (geometry.IsNull())
{
return;
}
m_validSelectedPosition = geometry->IsInside(m_currentSelectedPosition);
}
}
mitk::Image::ConstPointer ModelFitInspectorView::GetCurrentInputImage() const
{
mitk::Image::ConstPointer result = nullptr;
if (this->m_currentFit.IsNotNull())
{
result = m_currentFit->inputImage;
}
else if (this->m_currentSelectedNode.IsNotNull())
{
result = dynamic_cast<mitk::Image*>(this->m_currentSelectedNode->GetData());
if (result.IsNotNull() && result->GetTimeSteps() <= 1)
{
//if the image is not dynamic, we can't use it.
result = nullptr;
}
}
return result;
};
const mitk::ModelBase::TimeGridType ModelFitInspectorView::GetCurrentTimeGrid() const
{
if (m_currentModelProviderService && m_currentFit.IsNotNull())
{
return m_currentModelProviderService->GetVariableGrid(m_currentFit);
}
else
{ //fall back if there is no model provider we assume to use the normal time grid.
return ExtractTimeGrid(GetCurrentInputImage());
}
};
void ModelFitInspectorView::OnSliceChanged()
{
ValidateAndSetCurrentPosition();
m_Controls.widgetPlot->setEnabled(m_validSelectedPosition);
if (m_currentSelectedNode.IsNotNull())
{
m_Controls.inspectionPositionWidget->SetCurrentPosition(m_currentSelectedPosition);
if (RefreshPlotData())
{
RenderPlot();
m_Controls.plotDataWidget->SetPlotData(&m_PlotCurves);
RenderFitInfo();
}
}
}
void ModelFitInspectorView::OnPositionBookmarksChanged()
{
if (RefreshPlotData())
{
RenderPlot();
m_Controls.plotDataWidget->SetPlotData(&m_PlotCurves);
RenderFitInfo();
}
}
void ModelFitInspectorView::OnFitSelectionChanged(int index)
{
if (!m_internalUpdateFlag)
{
MITK_DEBUG << "selected fit index: " << index;
std::string uid = "";
if (m_Controls.cmbFit->count() > index)
{
uid = m_Controls.cmbFit->itemData(index).toString().toStdString();
}
mitk::modelFit::ModelFitInfo::ConstPointer newFit = nullptr;
ModelFitInfoListType::iterator finding = m_modelfitList.find(uid);
if (finding != m_modelfitList.end())
{
newFit = finding->second;
}
if (m_currentFit != newFit)
{
m_currentModelParameterizer = nullptr;
m_currentModelProviderService = nullptr;
if (newFit.IsNotNull())
{
m_currentModelParameterizer = mitk::ModelGenerator::GenerateModelParameterizer(*newFit);
m_currentModelProviderService = mitk::ModelGenerator::GetProviderService(newFit->functionClassID);
}
m_currentFit = newFit;
m_currentFitTime.Modified();
auto name = m_currentFit->xAxisName;
if (!m_currentFit->xAxisUnit.empty())
{
name += " [" + m_currentFit->xAxisUnit + "]";
}
m_Controls.plotDataWidget->SetXName(name);
OnSliceChanged();
}
}
}
mitk::PlotDataCurveCollection::Pointer ModelFitInspectorView::RefreshPlotDataCurveCollection(const mitk::Point3D& position,
const mitk::Image* input, const mitk::modelFit::ModelFitInfo* fitInfo,
const mitk::ModelBase::TimeGridType& timeGrid, mitk::ModelParameterizerBase* parameterizer)
{
mitk::PlotDataCurveCollection::Pointer result = mitk::PlotDataCurveCollection::New();
//sample curve
if (input)
{
result->InsertElement(mitk::MODEL_FIT_PLOT_SAMPLE_NAME(), GenerateImageSamplePlotData(position, input, timeGrid));
}
//model signal curve
if (fitInfo)
{
// Interpolate time grid (x values) so the curve looks smooth
const mitk::ModelBase::TimeGridType interpolatedTimeGrid = mitk::GenerateSupersampledTimeGrid(timeGrid, INTERPOLATION_STEPS);
auto hires_curve = mitk::GenerateModelSignalPlotData(position, fitInfo, interpolatedTimeGrid, parameterizer);
result->InsertElement(mitk::MODEL_FIT_PLOT_INTERPOLATED_SIGNAL_NAME(), hires_curve);
auto curve = mitk::GenerateModelSignalPlotData(position, fitInfo, timeGrid, parameterizer);
result->InsertElement(mitk::MODEL_FIT_PLOT_SIGNAL_NAME(), curve);
}
return result;
};
bool ModelFitInspectorView::RefreshPlotData()
{
bool changed = false;
if (m_currentSelectedNode.IsNull())
{
this->m_PlotCurves = mitk::ModelFitPlotData();
changed = m_selectedNodeTime > m_lastRefreshTime;
m_lastRefreshTime.Modified();
}
else
{
assert(GetRenderWindowPart() != NULL);
const mitk::Image* input = GetCurrentInputImage();
const mitk::ModelBase::TimeGridType timeGrid = GetCurrentTimeGrid();
if (m_currentFitTime > m_lastRefreshTime || m_currentPositionTime > m_lastRefreshTime)
{
if (m_validSelectedPosition)
{
m_PlotCurves.currentPositionPlots = RefreshPlotDataCurveCollection(m_currentSelectedPosition,input,m_currentFit, timeGrid, m_currentModelParameterizer);
}
else
{
m_PlotCurves.currentPositionPlots = mitk::PlotDataCurveCollection::New();
}
changed = true;
}
auto bookmarks = m_PositionBookmarks.Lock();
if (bookmarks.IsNotNull())
{
if (m_currentFitTime > m_lastRefreshTime || bookmarks->GetMTime() > m_lastRefreshTime)
{
m_PlotCurves.positionalPlots.clear();
auto endIter = bookmarks->End();
for (auto iter = bookmarks->Begin(); iter != endIter; iter++)
{
auto collection = RefreshPlotDataCurveCollection(iter.Value(), input, m_currentFit, timeGrid, m_currentModelParameterizer);
m_PlotCurves.positionalPlots.emplace(iter.Index(), std::make_pair(iter.Value(), collection));
}
changed = true;
}
}
else
{
m_PlotCurves.positionalPlots.clear();
}
// input data curve
if (m_currentFitTime > m_lastRefreshTime)
{
m_PlotCurves.staticPlots->clear();
if (m_currentFit.IsNotNull())
{
m_PlotCurves.staticPlots = GenerateAdditionalModelFitPlotData(m_currentSelectedPosition, m_currentFit, timeGrid);
}
changed = true;
}
m_lastRefreshTime.Modified();
}
return changed;
}
void ModelFitInspectorView::RenderFitInfo()
{
assert(m_renderWindowPart != nullptr);
// configure fit information
if (m_currentFit.IsNull())
{
m_Controls.lFitType->setText("");
m_Controls.lFitUID->setText("");
m_Controls.lModelName->setText("");
m_Controls.lModelType->setText("");
}
else
{
m_Controls.lFitType->setText(QString::fromStdString(m_currentFit->fitType));
m_Controls.lFitUID->setText(QString::fromStdString(m_currentFit->uid));
m_Controls.lModelName->setText(QString::fromStdString(m_currentFit->modelName));
m_Controls.lModelType->setText(QString::fromStdString(m_currentFit->modelType));
}
// print results
std::stringstream infoOutput;
m_Controls.fitParametersWidget->setVisible(false);
m_Controls.groupSettings->setVisible(false);
if (m_currentFit.IsNull())
{
infoOutput << "No fit selected. Only raw image data is plotted.";
}
else if (!m_validSelectedPosition)
{
infoOutput <<
"Current position is outside of the input image of the selected fit.\nInspector is deactivated.";
}
else
{
m_Controls.fitParametersWidget->setVisible(true);
m_Controls.fitParametersWidget->setFits({ m_currentFit });
m_Controls.fitParametersWidget->setPositionBookmarks(m_PositionBookmarks.Lock());
m_Controls.fitParametersWidget->setCurrentPosition(m_currentSelectedPosition);
}
// configure data table
m_Controls.tableInputData->clearContents();
if (m_currentFit.IsNull())
{
infoOutput << "No fit selected. Only raw image data is plotted.";
}
else
{
m_Controls.groupSettings->setVisible(true);
m_Controls.tableInputData->setRowCount(m_PlotCurves.staticPlots->size());
unsigned int rowIndex = 0;
for (mitk::PlotDataCurveCollection::const_iterator pos = m_PlotCurves.staticPlots->begin();
pos != m_PlotCurves.staticPlots->end(); ++pos, ++rowIndex)
{
QColor dataColor;
if (pos->first == "ROI")
{
dataColor = QColor(0, 190, 0);
}
else
{
//Use HSV schema of QColor to calculate a different color depending on the
//number of already existing free iso lines.
dataColor.setHsv(((rowIndex + 1) * 85) % 360, 255, 255);
}
QTableWidgetItem* newItem = new QTableWidgetItem(QString::fromStdString(pos->first));
m_Controls.tableInputData->setItem(rowIndex, 0, newItem);
newItem = new QTableWidgetItem();
- newItem->setBackgroundColor(dataColor);
+ newItem->setBackground(dataColor);
m_Controls.tableInputData->setItem(rowIndex, 1, newItem);
}
}
m_Controls.lInfo->setText(QString::fromStdString(infoOutput.str()));
}
void ModelFitInspectorView::RenderPlotCurve(const mitk::PlotDataCurveCollection* curveCollection, const QColor& sampleColor, const QColor& signalColor, const std::string& posString)
{
auto sampleCurve = mitk::ModelFitPlotData::GetSamplePlot(curveCollection);
if (sampleCurve)
{
std::string name = mitk::MODEL_FIT_PLOT_SAMPLE_NAME() + posString;
unsigned int curveId = m_Controls.widgetPlot->InsertCurve(name.c_str());
m_Controls.widgetPlot->SetCurveData(curveId, sampleCurve->GetValues());
m_Controls.widgetPlot->SetCurvePen(curveId, QPen(Qt::NoPen));
// QwtSymbol needs to passed as a real pointer from MITK v2013.09.0 on
// (QwtPlotCurve deletes it on destruction and assignment).
QwtSymbol* dataSymbol = new QwtSymbol(QwtSymbol::Diamond, sampleColor, sampleColor, QSize(8, 8));
m_Controls.widgetPlot->SetCurveSymbol(curveId, dataSymbol);
// Again, there is no way to set a curve's legend attributes via QmitkPlotWidget so this
// gets unnecessarily complicated.
QwtPlotCurve* measurementCurve = dynamic_cast<QwtPlotCurve*>(m_Controls.widgetPlot->
GetPlot()->itemList(QwtPlotItem::Rtti_PlotCurve).back());
measurementCurve->setLegendAttribute(QwtPlotCurve::LegendShowSymbol);
measurementCurve->setLegendIconSize(QSize(8, 8));
}
//draw model curve
auto signalCurve = mitk::ModelFitPlotData::GetInterpolatedSignalPlot(curveCollection);
if (signalCurve)
{
std::string name = mitk::MODEL_FIT_PLOT_SIGNAL_NAME() + posString;
QPen pen;
pen.setColor(signalColor);
pen.setWidth(2);
unsigned int curveId = m_Controls.widgetPlot->InsertCurve(name.c_str());
m_Controls.widgetPlot->SetCurveData(curveId, signalCurve->GetValues());
m_Controls.widgetPlot->SetCurvePen(curveId, pen);
// Manually set the legend attribute to use the symbol as the legend icon and alter its
// size. Otherwise it would revert to default which is drawing a square which is the color
// of the curve's pen, so in this case none which defaults to black.
// Unfortunately, QmitkPlotWidget offers no way to set the legend attribute and icon size so
// this looks a bit hacky.
QwtPlotCurve* fitCurve = dynamic_cast<QwtPlotCurve*>(m_Controls.widgetPlot->GetPlot()->
itemList(QwtPlotItem::Rtti_PlotCurve).back());
fitCurve->setLegendAttribute(QwtPlotCurve::LegendShowLine);
}
}
void ModelFitInspectorView::RenderPlot()
{
m_Controls.widgetPlot->Clear();
std::string xAxis = DEFAULT_X_AXIS;
std::string yAxis = "Intensity";
std::string plotTitle = "Raw data plot: no data";
if (m_currentSelectedNode.IsNotNull())
{
plotTitle = "Raw data plot: " + m_currentSelectedNode->GetName();
}
if (m_currentFit.IsNotNull())
{
plotTitle = m_currentFit->modelName.c_str();
xAxis = m_currentFit->xAxisName;
if (!m_currentFit->xAxisUnit.empty())
{
xAxis += " [" + m_currentFit->xAxisUnit + "]";
}
yAxis = m_currentFit->yAxisName;
if (!m_currentFit->yAxisUnit.empty())
{
yAxis += " [" + m_currentFit->yAxisUnit + "]";
}
}
m_Controls.widgetPlot->SetAxisTitle(QwtPlot::xBottom, xAxis.c_str());
m_Controls.widgetPlot->SetAxisTitle(QwtPlot::yLeft, yAxis.c_str());
m_Controls.widgetPlot->SetPlotTitle(plotTitle.c_str());
// Draw static curves
unsigned int colorIndex = 0;
for (mitk::PlotDataCurveCollection::const_iterator pos = m_PlotCurves.staticPlots->begin();
pos != m_PlotCurves.staticPlots->end(); ++pos)
{
QColor dataColor;
unsigned int curveId = m_Controls.widgetPlot->InsertCurve(pos->first.c_str());
m_Controls.widgetPlot->SetCurveData(curveId, pos->second->GetValues());
if (pos->first == "ROI")
{
dataColor = QColor(0, 190, 0);
QPen pen;
pen.setColor(dataColor);
pen.setStyle(Qt::SolidLine);
m_Controls.widgetPlot->SetCurvePen(curveId, pen);
}
else
{
//Use HSV schema of QColor to calculate a different color depending on the
//number of already existing curves.
dataColor.setHsv((++colorIndex * 85) % 360, 255, 150);
m_Controls.widgetPlot->SetCurvePen(curveId, QPen(Qt::NoPen));
}
// QwtSymbol needs to passed as a real pointer from MITK v2013.09.0 on
// (QwtPlotCurve deletes it on destruction and assignment).
QwtSymbol* dataSymbol = new QwtSymbol(QwtSymbol::Triangle, dataColor, dataColor,
QSize(8, 8));
m_Controls.widgetPlot->SetCurveSymbol(curveId, dataSymbol);
// Again, there is no way to set a curve's legend attributes via QmitkPlotWidget so this
// gets unnecessarily complicated.
QwtPlotCurve* measurementCurve = dynamic_cast<QwtPlotCurve*>(m_Controls.widgetPlot->
GetPlot()->itemList(QwtPlotItem::Rtti_PlotCurve).back());
measurementCurve->setLegendAttribute(QwtPlotCurve::LegendShowSymbol);
measurementCurve->setLegendIconSize(QSize(8, 8));
}
// Draw positional curves
for (const auto& posIter : this->m_PlotCurves.positionalPlots)
{
QColor dataColor;
dataColor.setHsv((++colorIndex * 85) % 360, 255, 150);
this->RenderPlotCurve(posIter.second.second, dataColor, dataColor, " @ "+mitk::ModelFitPlotData::GetPositionalCollectionName(posIter));
}
// Draw current pos curve
this->RenderPlotCurve(m_PlotCurves.currentPositionPlots, QColor(Qt::red), QColor(Qt::black), "");
QwtLegend* legend = new QwtLegend();
legend->setFrameShape(QFrame::Box);
legend->setFrameShadow(QFrame::Sunken);
legend->setLineWidth(1);
m_Controls.widgetPlot->SetLegend(legend, QwtPlot::BottomLegend);
m_Controls.widgetPlot->Replot();
}
void ModelFitInspectorView::EnsureBookmarkPointSet()
{
if (m_PositionBookmarks.IsExpired() || m_PositionBookmarksNode.IsExpired())
{
const char* nodeName = "org.mitk.gui.qt.fit.inspector.positions";
mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
if (!node)
{
node = mitk::DataNode::New();
node->SetName(nodeName);
node->SetBoolProperty("helper object", true);
this->GetDataStorage()->Add(node);
}
m_PositionBookmarksNode = node;
mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
if (pointSet.IsNull())
{
pointSet = mitk::PointSet::New();
node->SetData(pointSet);
}
m_PositionBookmarks = pointSet;
}
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationsDataModel.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationsDataModel.cpp
index 9e6f972eef..ac12f4f207 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationsDataModel.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSNavigationCalibrationsDataModel.cpp
@@ -1,244 +1,244 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkUSNavigationCalibrationsDataModel.h"
#include <mitkUSCombinedModality.h>
#include <mitkUSControlInterfaceBMode.h>
#include <QBrush>
#include <QColor>
#include <QIcon>
#include <QFont>
QmitkUSNavigationCalibrationsDataModel::QmitkUSNavigationCalibrationsDataModel(QObject *parent)
: QAbstractTableModel(parent),
m_ListenerDeviceChanged(this, &QmitkUSNavigationCalibrationsDataModel::OnDeviceChanged)
{
}
QmitkUSNavigationCalibrationsDataModel::~QmitkUSNavigationCalibrationsDataModel()
{
if ( m_CombinedModality.IsNotNull() )
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
}
void QmitkUSNavigationCalibrationsDataModel::SetCombinedModality(mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality)
{
if ( m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull() )
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
m_CombinedModality = combinedModality;
if ( m_CombinedModality.IsNotNull() )
{
m_ControlInterfaceBMode = m_CombinedModality->GetControlInterfaceBMode();
// make sure that the combined modality is active as this may be
// necessary to get the available depths
if ( m_CombinedModality->GetUltrasoundDevice()->GetDeviceState() < mitk::USDevice::State_Connected ) { m_CombinedModality->GetUltrasoundDevice()->Connect(); }
if ( m_CombinedModality->GetUltrasoundDevice()->GetDeviceState() == mitk::USDevice::State_Connected ) { m_CombinedModality->GetUltrasoundDevice()->Activate(); }
if ( m_CombinedModality->GetUltrasoundDevice().IsNotNull() )
{
m_CombinedModality->GetUltrasoundDevice()->AddPropertyChangedListener(m_ListenerDeviceChanged);
}
}
// as the combined modality was changed, an old table model
// would not be valid anymore
this->beginResetModel();
this->endResetModel();
}
void QmitkUSNavigationCalibrationsDataModel::OnDeviceChanged(const std::string&, const std::string&)
{
this->beginResetModel();
this->endResetModel();
}
/** \brief Return number of rows of the model. */
int QmitkUSNavigationCalibrationsDataModel::rowCount ( const QModelIndex & ) const
{
if ( m_ControlInterfaceBMode.IsNull() )
{
return 1; // only one default depth can be assumed
}
else
{
return m_ControlInterfaceBMode->GetScanningDepthValues().size();
}
}
/** \brief Return number of columns (3) of the model. */
int QmitkUSNavigationCalibrationsDataModel::columnCount ( const QModelIndex & ) const
{
return 3;
}
/** \brief Return names for the columns, numbers for the rows and invalid for DisplayRole. */
QVariant QmitkUSNavigationCalibrationsDataModel::headerData ( int section, Qt::Orientation orientation, int role ) const
{
if ( role != Qt::DisplayRole ) { return QVariant(QVariant::Invalid); }
if ( orientation == Qt::Horizontal )
{
switch ( section )
{
case 0: return QVariant("Depth");
case 1: return QVariant("Calibrated");
case 2: return QVariant("");
}
}
return QVariant(QVariant::Invalid);
}
/** \brief Return selectable and enabled for column 1 (size); selectable, enabled and editable for every other column. */
Qt::ItemFlags QmitkUSNavigationCalibrationsDataModel::flags ( const QModelIndex & ) const
{
return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
}
/** \brief Return model data of the selected cell. */
QVariant QmitkUSNavigationCalibrationsDataModel::data ( const QModelIndex & index, int role ) const
{
if ( m_CombinedModality.IsNull() ) { return QVariant(QVariant::Invalid); }
std::vector<double> scanningDepthValues = m_ControlInterfaceBMode.IsNull() ?
std::vector<double>(1,0) : m_ControlInterfaceBMode->GetScanningDepthValues();
// make sure that row and column index fit data borders
if (index.row() >= this->rowCount()
|| index.column() >= this->columnCount())
{
return QVariant(QVariant::Invalid);
}
double currentDepth = 0;
if ( m_ControlInterfaceBMode.IsNotNull() ) { currentDepth = m_ControlInterfaceBMode->GetScanningDepth(); }
bool isCalibratedForCurrentDepth =
m_CombinedModality->GetCalibration(QString::number(scanningDepthValues.at(index.row())).toStdString()).IsNotNull();
switch (role)
{
- case Qt::BackgroundColorRole:
+ case Qt::BackgroundRole:
{
if ( isCalibratedForCurrentDepth )
{
return QVariant(QBrush(QColor(125, 255, 125)));
}
else
{
return QVariant(QBrush(QColor(255, 125, 125)));
}
}
case Qt::FontRole:
{
if ( scanningDepthValues.at(index.row()) == currentDepth )
{
QFont qFont;
qFont.setBold(true);
return qFont;
}
else
{
return QVariant::Invalid;
}
}
case Qt::DecorationRole:
{
if ( index.column() == 2 )
{
if ( isCalibratedForCurrentDepth )
{
return QIcon(":/USNavigation/process-stop.png");
}
}
break;
}
case Qt::EditRole:
case Qt::DisplayRole:
{
switch ( index.column() )
{
case 0:
{
return QVariant::fromValue<double>(scanningDepthValues.at(index.row()));
}
case 1:
{
if ( m_ControlInterfaceBMode.IsNull() )
{
// use the current zoom level (which is assumed to be the only one),
// when no b mode controls are available
return QVariant(m_CombinedModality->GetCalibration().IsNotNull());
}
else
{
return QVariant(isCalibratedForCurrentDepth);
}
}
case 2:
{
return QVariant("");
}
}
break;
}
case Qt::ToolTipRole:
{
if ( index.column() == 2 && isCalibratedForCurrentDepth )
{
return QVariant(QString("Remove calibration for depth ") + QString::number(scanningDepthValues.at(index.row())) + " on mouse click.");
}
break;
}
}
return QVariant(QVariant::Invalid);
}
/** \brief Set model data for the selected cell. */
bool QmitkUSNavigationCalibrationsDataModel::setData ( const QModelIndex & index, const QVariant & value, int )
{
if ( m_CombinedModality.IsNull() || index.column() != 2 || value != false )
return false;
if ( m_ControlInterfaceBMode.IsNull() )
{
m_CombinedModality->RemoveCalibration();
}
else
{
m_CombinedModality->RemoveCalibration(QString::number(m_ControlInterfaceBMode->GetScanningDepthValues().at(index.row())).toStdString());
}
emit dataChanged(this->index(index.row(), 0), this->index(index.row(), 1));
return true;
}
/** \brief Remove given rows from the model.
* \param removeFromDataStorage zone nodes are removed from the data storage too, if this is set to true
*/
bool QmitkUSNavigationCalibrationsDataModel::removeRows ( int, int, const QModelIndex&, bool )
{
return false;
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.cpp
index 9b75e10e90..0427f253f8 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/QmitkUSZonesDataModel.cpp
@@ -1,327 +1,327 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkUSZonesDataModel.h"
#include <QBrush>
#include "mitkMessage.h"
#include "mitkProperties.h"
#include "mitkRenderingManager.h"
#include "Interactors/mitkUSZonesInteractor.h"
QmitkUSZonesDataModel::QmitkUSZonesDataModel(QObject *parent) :
QAbstractTableModel(parent),
m_ListenerAddNode(this, &QmitkUSZonesDataModel::AddNode),
m_ListenerChangeNode(this, &QmitkUSZonesDataModel::ChangeNode),
m_ListenerRemoveNode(this, &QmitkUSZonesDataModel::RemoveNode)
{
}
QmitkUSZonesDataModel::~QmitkUSZonesDataModel()
{
if ( m_DataStorage.IsNotNull() )
{
m_DataStorage->AddNodeEvent.RemoveListener(m_ListenerAddNode);
m_DataStorage->ChangedNodeEvent.RemoveListener(m_ListenerChangeNode);
m_DataStorage->InteractorChangedNodeEvent.RemoveListener(m_ListenerChangeNode);
m_DataStorage->RemoveNodeEvent.RemoveListener(m_ListenerRemoveNode);
}
}
void QmitkUSZonesDataModel::SetDataStorage(mitk::DataStorage::Pointer dataStorage, mitk::DataNode::Pointer baseNode)
{
m_DataStorage = dataStorage;
m_BaseNode = baseNode;
if ( m_DataStorage.IsNotNull() )
{
m_DataStorage->AddNodeEvent.AddListener(m_ListenerAddNode);
m_DataStorage->RemoveNodeEvent.AddListener(m_ListenerRemoveNode);
m_DataStorage->ChangedNodeEvent.AddListener(m_ListenerChangeNode);
m_DataStorage->InteractorChangedNodeEvent.AddListener(m_ListenerChangeNode);
}
}
void QmitkUSZonesDataModel::AddNode(const mitk::DataNode* node)
{
if ( m_DataStorage.IsNull() )
{
MITK_ERROR << "DataStorage has to be set before adding the first zone node.";
mitkThrow() << "DataStorage has to be set before adding the first zone node.";
}
// do not add nodes, which aren't fully created yet
bool boolValue;
if ( ! (node->GetBoolProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_CREATED, boolValue) && boolValue) )
{
return;
}
// get source node of given node and test if m_BaseNode is a source node
mitk::DataStorage::SetOfObjects::ConstPointer sourceNodes = m_DataStorage->GetSources(node);
mitk::DataStorage::SetOfObjects::ConstIterator baseNodeIt = sourceNodes->Begin();
while ( baseNodeIt != sourceNodes->End() && baseNodeIt->Value() != m_BaseNode ) { ++baseNodeIt; }
// only nodes below m_BaseNode should be added to the model
if ( baseNodeIt == sourceNodes->End() ) { return; }
int newRowIndex = this->rowCount();
this->insertRow(newRowIndex);
m_ZoneNodes.at(newRowIndex) = const_cast<mitk::DataNode*>(node);
// get row of the changed node and emit signal that the data of this row changed
emit dataChanged(this->index(newRowIndex, 0), this->index(newRowIndex, this->columnCount()));
}
void QmitkUSZonesDataModel::RemoveNode(const mitk::DataNode* node)
{
// find index of the given node in the nodes vector
unsigned int index = 0;
DataNodeVector::iterator current = m_ZoneNodes.begin();
while (current != m_ZoneNodes.end())
{
if ( *current == node ) { break; }
++index;
++current;
}
// remove node from model if it was found
if ( current != m_ZoneNodes.end() )
{
// remove node from the model and make sure that there will be no
// recursive removing calls (as removing node from data storage inside
// removeRows function will lead into another call of RemoveNode).
this->removeRows(index, 1, QModelIndex(), false);
}
}
void QmitkUSZonesDataModel::ChangeNode(const mitk::DataNode* node)
{
if ( static_cast<itk::SmartPointer<const mitk::DataNode> >(node).IsNull() ) { return; }
DataNodeVector::iterator oldNodeIt = find (m_ZoneNodes.begin(), m_ZoneNodes.end(), node);
if (oldNodeIt == m_ZoneNodes.end())
{
// if node was not added yet, but it's creation is finished -> add it now
bool boolValue;
if ( node->GetBoolProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_CREATED, boolValue) && boolValue )
{
this->AddNode(node);
}
return;
}
// get row of the changed node and emit signal that the data of this row changed
unsigned int row = oldNodeIt - m_ZoneNodes.begin();
emit dataChanged(this->index(row, 0), this->index(row, this->columnCount()));
}
int QmitkUSZonesDataModel::rowCount ( const QModelIndex& /*parent*/ ) const
{
return m_ZoneNodes.size();
}
int QmitkUSZonesDataModel::columnCount ( const QModelIndex& /*parent*/ ) const
{
return 3;
}
QVariant QmitkUSZonesDataModel::headerData ( int section, Qt::Orientation orientation, int role ) const
{
if ( role != Qt::DisplayRole ) { return QVariant(QVariant::Invalid); }
if ( orientation == Qt::Horizontal )
{
switch ( section )
{
case 0: return QVariant("Name");
case 1: return QVariant("Size");
case 2: return QVariant("Color");
}
}
else
{
return QVariant(section+1);
}
return QVariant(QVariant::Invalid);
}
Qt::ItemFlags QmitkUSZonesDataModel::flags ( const QModelIndex& index ) const
{
if (index.column() == 1 || index.column() == 2) { return Qt::ItemIsSelectable | Qt::ItemIsEnabled; }
return Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled;
}
QVariant QmitkUSZonesDataModel::data ( const QModelIndex& index, int role ) const
{
// make sure that row and column index fit data borders
if (static_cast<unsigned int>(index.row()) >= m_ZoneNodes.size()
|| index.column() >= this->columnCount())
{
return QVariant(QVariant::Invalid);
}
mitk::DataNode::Pointer curNode = m_ZoneNodes.at(index.row());
switch (role)
{
- case Qt::BackgroundColorRole:
+ case Qt::BackgroundRole:
{
float color[3];
if ( curNode->GetColor(color) )
{
QColor qColor(color[0] * 255, color[1] * 255, color[2] * 255);
if (qColor.isValid()) { return QVariant(QBrush(qColor)); }
}
break;
}
case Qt::EditRole:
case Qt::DisplayRole:
{
switch ( index.column() )
{
case 0:
{
return QString::fromStdString(curNode->GetName());
}
case 1:
{
float floatValue;
if ( curNode->GetFloatProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_SIZE, floatValue) )
{
return static_cast<int>(floatValue);
}
else
{
return QVariant(QVariant::Invalid);
}
}
case 2:
{
float color[3];
if ( curNode->GetColor(color) )
{
QColor qColor(color[0] * 255, color[1] * 255, color[2] * 255);
if (qColor == Qt::darkGreen) { return QVariant("Green"); }
else if (qColor == Qt::red) { return QVariant("Red"); }
else if (qColor == Qt::blue) { return QVariant("Blue"); }
else if (qColor == Qt::yellow) { return QVariant("Yellow"); }
else { return QVariant(qColor.name()); }
}
else { return QVariant(QVariant::Invalid); }
}
}
break;
}
}
return QVariant(QVariant::Invalid);
}
bool QmitkUSZonesDataModel::setData ( const QModelIndex & index, const QVariant & value, int role )
{
if (role == Qt::EditRole)
{
if (static_cast<unsigned int>(index.row()) >= m_ZoneNodes.size()
|| index.column() >= this->columnCount())
{
return false;
}
mitk::DataNode::Pointer curNode = m_ZoneNodes.at(index.row());
switch ( index.column() )
{
case 0:
{
curNode->SetName(value.toString().toStdString());
break;
}
case 1:
{
curNode->SetFloatProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_SIZE, value.toFloat());
if (curNode->GetData() != nullptr)
{
curNode->SetFloatProperty(mitk::USZonesInteractor::DATANODE_PROPERTY_SIZE, value.toFloat());
mitk::USZonesInteractor::UpdateSurface(curNode);
}
break;
}
case 2:
{
QColor color(value.toString());
curNode->SetColor(color.redF(), color.greenF(), color.blueF());
break;
}
default:
return false;
}
emit dataChanged(index, index);
}
// update the RenderWindow to show new points
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
bool QmitkUSZonesDataModel::insertRows ( int row, int count, const QModelIndex & parent )
{
this->beginInsertRows(parent, row, row+count-1);
for ( int n = 0; n < count; ++n )
{
m_ZoneNodes.insert(m_ZoneNodes.begin()+row, mitk::DataNode::New());
}
this->endInsertRows();
return true;
}
bool QmitkUSZonesDataModel::removeRows ( int row, int count, const QModelIndex & parent )
{
return this->removeRows(row, count, parent, true);
}
bool QmitkUSZonesDataModel::removeRows ( int row, int count, const QModelIndex & parent, bool removeFromDataStorage )
{
if ( static_cast<unsigned int>(row+count) > m_ZoneNodes.size() ) { return false; }
this->beginRemoveRows(parent, row, row+count-1);
for ( int n = count-1; n >= 0; --n )
{
DataNodeVector::iterator it = m_ZoneNodes.begin()+row+n;
mitk::DataNode::Pointer curNode = *it;
m_ZoneNodes.erase(it);
if ( removeFromDataStorage && m_DataStorage.IsNotNull() )
{
m_DataStorage->Remove(curNode);
}
}
this->endRemoveRows();
return true;
}