diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
index 9a3ff2d024..d7296bd69c 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
@@ -1,252 +1,257 @@
/*============================================================================
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 "QmitkAbstractMultiWidgetEditor.h"
// mitk qt widgets module
#include <QmitkAbstractMultiWidget.h>
#include <QmitkRenderWindowWidget.h>
// mitk gui qt common plugin
#include "QmitkMultiWidgetDecorationManager.h"
// berry
#include <berryIWorkbenchPartConstants.h>
const QString QmitkAbstractMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.abstractmultiwidget";
struct QmitkAbstractMultiWidgetEditor::Impl final
{
Impl();
~Impl() = default;
QmitkAbstractMultiWidget* m_MultiWidget;
std::unique_ptr<QmitkMultiWidgetDecorationManager> m_MultiWidgetDecorationManager;
};
QmitkAbstractMultiWidgetEditor::Impl::Impl()
: m_MultiWidget(nullptr)
{
// nothing here
}
QmitkAbstractMultiWidgetEditor::QmitkAbstractMultiWidgetEditor()
: m_Impl(std::make_unique<Impl>())
{
// nothing here
}
QmitkAbstractMultiWidgetEditor::~QmitkAbstractMultiWidgetEditor() {}
QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetActiveQmitkRenderWindow() const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
auto activeRenderWindowWidget = multiWidget->GetActiveRenderWindowWidget();
if (nullptr != activeRenderWindowWidget)
{
return activeRenderWindowWidget->GetRenderWindow();
}
}
return nullptr;
}
QHash<QString, QmitkRenderWindow*> QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindows() const
{
QHash<QString, QmitkRenderWindow*> result;
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return result;
}
result = multiWidget->GetRenderWindows();
return result;
}
QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindow(const QString& id) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return nullptr;
}
return multiWidget->GetRenderWindow(id);
}
QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return nullptr;
}
return multiWidget->GetRenderWindow(orientation);
}
void QmitkAbstractMultiWidgetEditor::InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera)
{
const auto& multiWidget = this->GetMultiWidget();
if (nullptr == multiWidget)
{
return;
}
multiWidget->InitializeViews(geometry, resetCamera);
}
void QmitkAbstractMultiWidgetEditor::SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry)
{
const auto& multiWidget = this->GetMultiWidget();
if (nullptr == multiWidget)
{
return;
}
multiWidget->SetInteractionReferenceGeometry(referenceGeometry);
}
bool QmitkAbstractMultiWidgetEditor::HasCoupledRenderWindows() const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return false;
}
return multiWidget->HasCoupledRenderWindows();
}
mitk::Point3D QmitkAbstractMultiWidgetEditor::GetSelectedPosition(const QString& id/* = QString()*/) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return mitk::Point3D();
}
return multiWidget->GetSelectedPosition(id);
}
void QmitkAbstractMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D& pos, const QString& id/* = QString()*/)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
return multiWidget->SetSelectedPosition(pos, id);
}
}
void QmitkAbstractMultiWidgetEditor::EnableDecorations(bool enable, const QStringList& decorations)
{
m_Impl->m_MultiWidgetDecorationManager->ShowDecorations(enable, decorations);
}
bool QmitkAbstractMultiWidgetEditor::IsDecorationEnabled(const QString& decoration) const
{
return m_Impl->m_MultiWidgetDecorationManager->IsDecorationVisible(decoration);
}
QStringList QmitkAbstractMultiWidgetEditor::GetDecorations() const
{
return m_Impl->m_MultiWidgetDecorationManager->GetDecorations();
}
QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindowByIndex(int index) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return nullptr;
}
QString renderWindowName = multiWidget->GetNameFromIndex(index);
return multiWidget->GetRenderWindow(renderWindowName);
}
QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindowByIndex(int row, int column) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return nullptr;
}
QString renderWindowName = multiWidget->GetNameFromIndex(row, column);
return multiWidget->GetRenderWindow(renderWindowName);
}
void QmitkAbstractMultiWidgetEditor::SetMultiWidget(QmitkAbstractMultiWidget* multiWidget)
{
m_Impl->m_MultiWidget = multiWidget;
m_Impl->m_MultiWidgetDecorationManager.reset(new QmitkMultiWidgetDecorationManager(multiWidget));
}
QmitkAbstractMultiWidget* QmitkAbstractMultiWidgetEditor::GetMultiWidget() const
{
return m_Impl->m_MultiWidget;
}
int QmitkAbstractMultiWidgetEditor::GetRowCount() const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return 0;
}
return multiWidget->GetRowCount();
}
int QmitkAbstractMultiWidgetEditor::GetColumnCount() const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return 0;
}
return multiWidget->GetColumnCount();
}
void QmitkAbstractMultiWidgetEditor::OnLayoutSet(int row, int column)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
multiWidget->SetLayout(row, column);
FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
}
}
void QmitkAbstractMultiWidgetEditor::OnSynchronize(bool synchronized)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
multiWidget->Synchronize(synchronized);
}
}
void QmitkAbstractMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
multiWidget->SetInteractionScheme(scheme);
}
}
+
+ QmitkMultiWidgetDecorationManager* QmitkAbstractMultiWidgetEditor::GetDecorationManager() const
+ {
+ return m_Impl->m_MultiWidgetDecorationManager.get();
+ }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
index 4485beaf66..f997b527a0 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
@@ -1,139 +1,143 @@
/*============================================================================
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.
============================================================================*/
#ifndef QmitkAbstractMultiWidgetEditor_h
#define QmitkAbstractMultiWidgetEditor_h
#include <org_mitk_gui_qt_common_Export.h>
// org mitk gui qt common plugin
#include <QmitkAbstractRenderEditor.h>
// mitk core
#include <mitkInteractionSchemeSwitcher.h>
// berry
#include <berryIPartListener.h>
// c++
#include <memory>
class QmitkAbstractMultiWidget;
class QmitkLevelWindowWidget;
+class QmitkMultiWidgetDecorationManager;
class MITK_QT_COMMON QmitkAbstractMultiWidgetEditor : public QmitkAbstractRenderEditor, public berry::IPartListener
{
Q_OBJECT
public:
berryObjectMacro(QmitkAbstractMultiWidgetEditor, QmitkAbstractRenderEditor, IPartListener);
static const QString EDITOR_ID;
QmitkAbstractMultiWidgetEditor();
virtual ~QmitkAbstractMultiWidgetEditor() override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual QmitkRenderWindow* GetActiveQmitkRenderWindow() const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual QHash<QString, QmitkRenderWindow*> GetQmitkRenderWindows() const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
void InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera) override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
void SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry) override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
bool HasCoupledRenderWindows() const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual mitk::Point3D GetSelectedPosition(const QString& id = QString()) const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual bool IsDecorationEnabled(const QString& decoration) const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual QStringList GetDecorations() const override;
/**
* @brief Retrieve a QmitkRenderWindow by its index.
*/
virtual QmitkRenderWindow* GetQmitkRenderWindowByIndex(int index) const;
/**
* @brief Retrieve a QmitkRenderWindow by the row and column position.
*/
virtual QmitkRenderWindow* GetQmitkRenderWindowByIndex(int row, int column) const;
/**
* @brief Set the current multi widget of this editor.
*/
virtual void SetMultiWidget(QmitkAbstractMultiWidget* multiWidget);
/**
* @brief Return the current multi widget of this editor.
*/
virtual QmitkAbstractMultiWidget* GetMultiWidget() const;
/**
* @brief Return the number of rows of the underlying multi widget.
*/
virtual int GetRowCount() const;
/**
* @brief Return the number of columns of the underlying multi widget.
*/
virtual int GetColumnCount() const;
virtual QmitkLevelWindowWidget* GetLevelWindowWidget() const = 0;
public Q_SLOTS:
/**
* @brief A slot that can be called if the layout has been changed.
* This function will call the function 'SetLayout' of the multi widget where
* custom behavior can be implemented.
* Finally 'FirePropertyChange' is called to inform the workbench about an input change.
*/
virtual void OnLayoutSet(int row, int column);
virtual void OnSynchronize(bool synchronized);
virtual void OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
+protected:
+ QmitkMultiWidgetDecorationManager* GetDecorationManager() const;
+
private:
struct Impl;
std::unique_ptr<Impl> m_Impl;
};
#endif
diff --git a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
index 81fdc308ee..b10c469f8d 100644
--- a/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
+++ b/Plugins/org.mitk.gui.qt.moviemaker/src/internal/QmitkScreenshotMaker.cpp
@@ -1,512 +1,508 @@
/*============================================================================
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 "QmitkScreenshotMaker.h"
//#include "QmitkMovieMakerControls.h"
#include "QmitkStepperAdapter.h"
#include "mitkVtkPropRenderer.h"
#include <QmitkRenderWindow.h>
#include <QmitkRenderWindowWidget.h>
#include <iostream>
#include <vtkRenderer.h>
#include <vtkCamera.h>
#include <QAction>
#include <QFileDialog>
#include <QTimer>
#include <QDateTime>
#include <QSpinBox>
#include <QComboBox>
#include <QColor>
#include <QColorDialog>
#include <QApplication>
#include "vtkImageWriter.h"
#include "vtkJPEGWriter.h"
#include "vtkPNGWriter.h"
#include "vtkRenderLargeImage.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRenderer.h"
#include "vtkTestUtilities.h"
#include <vtkActor.h>
#include "vtkMitkRenderProp.h"
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include "vtkRenderWindowInteractor.h"
#include <qradiobutton.h>
#include "mitkSliceNavigationController.h"
#include "mitkPlanarFigure.h"
#include <mitkWorkbenchUtil.h>
#include <mitkImage.h>
#include <itksys/SystemTools.hxx>
QmitkScreenshotMaker::QmitkScreenshotMaker(QObject *parent, const char * /*name*/)
: QmitkAbstractView(),
m_Controls(nullptr),
m_BackgroundColor(QColor(0,0,0)),
m_SelectedNode(nullptr)
{
parentWidget = parent;
}
QmitkScreenshotMaker::~QmitkScreenshotMaker()
{
}
void QmitkScreenshotMaker::CreateConnections()
{
if (m_Controls)
{
connect((QObject*) m_Controls->m_AllViews, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateMultiplanar3DHighresScreenshot()));
connect((QObject*) m_Controls->m_Shot, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateMultiplanarScreenshots()));
connect((QObject*) m_Controls->m_BackgroundColor, SIGNAL(clicked()), (QObject*) this, SLOT(SelectBackgroundColor()));
connect((QObject*) m_Controls->btnScreenshot, SIGNAL(clicked()), this, SLOT(GenerateScreenshot()));
connect((QObject*) m_Controls->m_HRScreenshot, SIGNAL(clicked()), this, SLOT(Generate3DHighresScreenshot()));
QString styleSheet = "background-color:rgb(0,0,0)";
m_Controls->m_BackgroundColor->setStyleSheet(styleSheet);
}
}
mitk::DataNode::Pointer QmitkScreenshotMaker::GetTopLayerNode()
{
mitk::DataNode::Pointer out = nullptr;
int layer = -1;
auto nodes = GetDataStorage()->GetAll();
for (auto node = nodes->begin(); node!=nodes->end(); ++node)
{
if (!(*node)->IsVisible(nullptr))
continue;
int current_layer;
(*node)->GetIntProperty("layer", current_layer);
if (current_layer>layer)
{
out = (*node);
layer = current_layer;
}
}
return out;
}
void QmitkScreenshotMaker::MultichannelScreenshot(mitk::VtkPropRenderer* renderer, QString fileName, QString filter)
{
auto node = GetTopLayerNode();
if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
{
auto image = dynamic_cast<mitk::Image*>(node->GetData());
std::string fname = itksys::SystemTools::GetFilenamePath(fileName.toStdString()) + "/" + itksys::SystemTools::GetFilenameWithoutExtension(fileName.toStdString());
std::string ext = itksys::SystemTools::GetFilenameExtension(fileName.toStdString());
mitk::PixelType chPixelType = image->GetImageDescriptor()->GetChannelTypeById(0);
if (image->GetDimension() == 4)
{
MITK_INFO << "LOOPING THROUGH FOURTH DIMENSION IS NOT IMPLEMENTED";
}
else if (chPixelType.GetNumberOfComponents()>1)
{
for(int unsigned c=0; c<chPixelType.GetNumberOfComponents(); ++c)
{
node->SetProperty("Image.Displayed Component", mitk::IntProperty::New(c));
this->TakeScreenshot(renderer->GetVtkRenderer(), 1, QString(fname.c_str()) + "_" + QString::number(c) + QString(ext.c_str()), filter);
}
}
else
this->TakeScreenshot(renderer->GetVtkRenderer(), 1, fileName, filter);
}
else
this->TakeScreenshot(renderer->GetVtkRenderer(), 1, fileName, filter);
}
void QmitkScreenshotMaker::GenerateScreenshot()
{
if (m_LastFile.size()==0)
m_LastFile = QDir::currentPath()+"/screenshot.png";
QString filter;
QString fileName = QFileDialog::getSaveFileName(nullptr, "Save screenshot to...", m_LastFile, m_PNGExtension + ";;" + m_JPGExtension, &filter);
if (fileName.size()>0)
m_LastFile = fileName;
auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
auto* renderer = renderWindowPart->GetQmitkRenderWindow(m_Controls->m_DirectionBox->currentText())->GetRenderer();
if (renderer == nullptr)
return;
if (m_Controls->m_AllChannelsBox->isChecked())
MultichannelScreenshot(renderer, fileName, filter);
else
this->TakeScreenshot(renderer->GetVtkRenderer(), 1, fileName, filter);
}
void QmitkScreenshotMaker::GenerateMultiplanarScreenshots()
{
if (m_LastPath.size()==0)
m_LastPath = QDir::currentPath();
QString filePath = QFileDialog::getExistingDirectory(nullptr, "Save screenshots to...", m_LastPath);
if (filePath.size()>0)
m_LastPath = filePath;
if( filePath.isEmpty() )
{
return;
}
//emit StartBlockControls();
auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
renderWindowPart->EnableDecorations(false, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
auto windowCount = m_Controls->m_DirectionBox->count();
for (int i = 0; i < windowCount; ++i)
{
auto windowName = m_Controls->m_DirectionBox->itemText(i);
QString fileName = QDir::separator() + windowName + QString::fromStdString(".png");
int c = 1;
while (QFile::exists(filePath + fileName))
{
fileName = QDir::separator() + windowName + QString::fromStdString("_");
fileName += QString::number(c);
fileName += ".png";
c++;
}
vtkRenderer* renderer = renderWindowPart->GetQmitkRenderWindow(windowName)->GetRenderer()->GetVtkRenderer();
if (renderer != nullptr)
{
if (m_Controls->m_AllChannelsBox->isChecked())
MultichannelScreenshot(renderWindowPart->GetQmitkRenderWindow(windowName)->GetRenderer(), filePath + fileName, m_PNGExtension);
else
this->TakeScreenshot(renderer, 1, filePath + fileName);
}
}
/// TODO I do not find a simple way of doing this through the render window part API,
/// however, I am also not convinced that this code is needed at all. The colour
/// of the crosshair planes is never set to any colour other than these.
/// I suggest a new 'mitk::DataNode* mitk::ILinkedRendererPart::GetSlicingPlane(const std::string& name) const'
/// function to introduce that could return the individual ("axial", "sagittal" or
/// "coronal" crosshair planes.
// mitk::DataNode* n = renderWindowPart->GetSlicingPlane("axial");
// if (n)
// {
// n->SetProperty( "color", mitk::ColorProperty::New( 1,0,0 ) );
// }
//
// n = renderWindowPart->GetSlicingPlane("sagittal");
// if (n)
// {
// n->SetProperty( "color", mitk::ColorProperty::New( 0,1,0 ) );
// }
//
// n = renderWindowPart->GetSlicingPlane("coronal");
// if (n)
// {
// n->SetProperty( "color", mitk::ColorProperty::New( 0,0,1 ) );
// }
renderWindowPart->EnableDecorations(true, QStringList{mitk::IRenderWindowPart::DECORATION_CORNER_ANNOTATION});
}
void QmitkScreenshotMaker::Generate3DHighresScreenshot()
{
if (m_LastFile.size()==0)
m_LastFile = QDir::currentPath()+"/3D_screenshot.png";
QString filter;
QString fileName = QFileDialog::getSaveFileName(nullptr, "Save screenshot to...", m_LastFile, m_PNGExtension + ";;" + m_JPGExtension, &filter);
if (fileName.size()>0)
m_LastFile = fileName;
GenerateHR3DAtlasScreenshots(fileName, filter);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkScreenshotMaker::GenerateMultiplanar3DHighresScreenshot()
{
if (m_LastPath.size()==0)
m_LastPath = QDir::currentPath();
QString filePath = QFileDialog::getExistingDirectory( nullptr, "Save screenshots to...", m_LastPath);
if (filePath.size()>0)
m_LastPath = filePath;
if( filePath.isEmpty() )
{
return;
}
QString fileName = "/3D_View1.png";
int c = 1;
while (QFile::exists(filePath+fileName))
{
fileName = QString("/3D_View1_");
fileName += QString::number(c);
fileName += ".png";
c++;
}
GetCam()->Azimuth( -7.5 );
GetCam()->Roll(-4);
GenerateHR3DAtlasScreenshots(filePath+fileName);
GetCam()->Roll(4);
fileName = "/3D_View2.png";
c = 1;
while (QFile::exists(filePath+fileName))
{
fileName = QString("/3D_View2_");
fileName += QString::number(c);
fileName += ".png";
c++;
}
GetCam()->Azimuth( 90 );
GetCam()->Elevation( 4 );
GenerateHR3DAtlasScreenshots(filePath+fileName);
fileName = "/3D_View3.png";
c = 1;
while (QFile::exists(filePath+fileName))
{
fileName = QString("/3D_View3_");
fileName += QString::number(c);
fileName += ".png";
c++;
}
GetCam()->Elevation( 90 );
GetCam()->Roll( -2.5 );
GenerateHR3DAtlasScreenshots(filePath+fileName);
GetCam()->Roll( 2.5 );
// not negative because direction of elevation has flipped
GetCam()->Elevation( 94 );
GetCam()->Azimuth( -82.5 );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkScreenshotMaker::GenerateHR3DAtlasScreenshots(QString fileName, QString filter)
{
// only works correctly for 3D RenderWindow
auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
auto* renderer = renderWindowPart->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer();
if (nullptr != renderer)
- {
- renderWindowPart->EnableDecorations(false);
this->TakeScreenshot(renderer, this->m_Controls->m_MagFactor->text().toFloat(), fileName, filter);
- renderWindowPart->EnableDecorations(true);
- }
}
vtkCamera* QmitkScreenshotMaker::GetCam()
{
auto* renderer = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("3d")->GetRenderer();
vtkCamera* cam = nullptr;
const mitk::VtkPropRenderer *propRenderer = dynamic_cast<const mitk::VtkPropRenderer * >( renderer );
if (propRenderer)
{
// get vtk renderer
vtkRenderer* vtkrenderer = propRenderer->GetVtkRenderer();
if (vtkrenderer)
{
// get vtk camera
vtkCamera* vtkcam = vtkrenderer->GetActiveCamera();
if (vtkcam)
{
// vtk smart pointer handling
cam = vtkcam;
cam->Register( nullptr );
}
}
}
return cam;
}
void QmitkScreenshotMaker::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
{
if(nodes.size())
m_SelectedNode = nodes[0];
}
void QmitkScreenshotMaker::UpdateDirectionBox(mitk::IRenderWindowPart* renderWindowPart)
{
m_Controls->m_DirectionBox->clear();
auto renderWindows = renderWindowPart->GetQmitkRenderWindows();
bool has3DWindow = false;
for (auto name : renderWindows.keys())
{
auto window = renderWindows[name];
if (window->GetRenderer()->GetMapperID() == mitk::BaseRenderer::Standard3D)
{
has3DWindow = true;
}
else
{
auto windowName = name;
auto renderWindowWidget = dynamic_cast<QmitkRenderWindowWidget*>(window->parentWidget());
if (renderWindowWidget)
{
windowName = QString::fromStdString(renderWindowWidget->GetCornerAnnotationText());
}
m_Controls->m_DirectionBox->insertItem(m_Controls->m_DirectionBox->count() + 1, windowName);
}
}
renderWindows = renderWindowPart->GetQmitkRenderWindows();
m_Controls->groupBox->setEnabled(has3DWindow);
}
void QmitkScreenshotMaker::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
m_Parent = parent;
m_Controls = new Ui::QmitkScreenshotMakerControls;
m_Controls->setupUi(parent);
auto renderWindowPart = this->GetRenderWindowPart();
if (renderWindowPart)
{
this->UpdateDirectionBox(renderWindowPart);
}
// Initialize "Selected Window" combo box
const mitk::RenderingManager::RenderWindowVector rwv =
mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
}
this->CreateConnections();
}
void QmitkScreenshotMaker::SetFocus()
{
m_Controls->btnScreenshot->setFocus();
}
void QmitkScreenshotMaker::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
{
m_Parent->setEnabled(true);
this->UpdateDirectionBox(renderWindowPart);
}
void QmitkScreenshotMaker::RenderWindowPartInputChanged(mitk::IRenderWindowPart* renderWindowPart)
{
this->UpdateDirectionBox(renderWindowPart);
}
void QmitkScreenshotMaker::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
{
m_Parent->setEnabled(false);
m_Controls->m_DirectionBox->clear();
}
void QmitkScreenshotMaker::TakeScreenshot(vtkRenderer* renderer, unsigned int magnificationFactor, QString fileName, QString filter)
{
if ((renderer == nullptr) ||(magnificationFactor < 1) || fileName.isEmpty())
return;
bool doubleBuffering( renderer->GetRenderWindow()->GetDoubleBuffer() );
renderer->GetRenderWindow()->DoubleBufferOff();
vtkImageWriter* fileWriter = nullptr;
QFileInfo fi(fileName);
QString suffix = fi.suffix().toLower();
if (suffix.isEmpty() || (suffix != "png" && suffix != "jpg" && suffix != "jpeg"))
{
if (filter == m_PNGExtension)
{
suffix = "png";
}
else if (filter == m_JPGExtension)
{
suffix = "jpg";
}
fileName += "." + suffix;
}
if (suffix.compare("jpg", Qt::CaseInsensitive) == 0 || suffix.compare("jpeg", Qt::CaseInsensitive) == 0)
{
vtkJPEGWriter* w = vtkJPEGWriter::New();
w->SetQuality(100);
w->ProgressiveOff();
fileWriter = w;
}
else //default is png
{
fileWriter = vtkPNGWriter::New();
}
vtkRenderLargeImage* magnifier = vtkRenderLargeImage::New();
magnifier->SetInput(renderer);
magnifier->SetMagnification(magnificationFactor);
//magnifier->Update();
fileWriter->SetInputConnection(magnifier->GetOutputPort());
fileWriter->SetFileName(fileName.toLatin1());
// vtkRenderLargeImage has problems with different layers, therefore we have to
// temporarily deactivate all other layers.
// we set the background to white, because it is nicer than black...
double oldBackground[3];
renderer->GetBackground(oldBackground);
// QColor color = QColorDialog::getColor();
double bgcolor[] = {m_BackgroundColor.red()/255.0, m_BackgroundColor.green()/255.0, m_BackgroundColor.blue()/255.0};
renderer->SetBackground(bgcolor);
mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
renderWindowPart->EnableDecorations(false);
fileWriter->Write();
fileWriter->Delete();
renderWindowPart->EnableDecorations(true);
renderer->SetBackground(oldBackground);
renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering);
}
void QmitkScreenshotMaker::SelectBackgroundColor()
{
m_BackgroundColor = QColorDialog::getColor();
m_Controls->m_BackgroundColor->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(m_BackgroundColor.red()));
styleSheet.append(",");
styleSheet.append(QString::number(m_BackgroundColor.green()));
styleSheet.append(",");
styleSheet.append(QString::number(m_BackgroundColor.blue()));
styleSheet.append(")");
m_Controls->m_BackgroundColor->setStyleSheet(styleSheet);
}
diff --git a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
index ae9296d22f..2f6219a446 100644
--- a/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.stdmultiwidgeteditor/src/QmitkStdMultiWidgetEditor.cpp
@@ -1,398 +1,394 @@
/*============================================================================
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 "QmitkStdMultiWidgetEditor.h"
#include <berryUIException.h>
#include <berryIWorkbenchPage.h>
#include <mitkCoreServices.h>
#include <mitkIPreferencesService.h>
#include <mitkIPreferences.h>
#include <mitkColorProperty.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkDataStorageEditorInput.h>
#include <mitkIDataStorageService.h>
// mitk qt widgets module
#include <QmitkInteractionSchemeToolBar.h>
#include <QmitkLevelWindowWidget.h>
#include <QmitkRenderWindowWidget.h>
#include <QmitkStdMultiWidget.h>
// mitk gui qt common plugin
#include <QmitkMultiWidgetDecorationManager.h>
const QString QmitkStdMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.stdmultiwidget";
struct QmitkStdMultiWidgetEditor::Impl final
{
Impl();
~Impl() = default;
QmitkInteractionSchemeToolBar* m_InteractionSchemeToolBar;
QmitkLevelWindowWidget* m_LevelWindowWidget;
-
- std::unique_ptr<QmitkMultiWidgetDecorationManager> m_MultiWidgetDecorationManager;
};
QmitkStdMultiWidgetEditor::Impl::Impl()
: m_InteractionSchemeToolBar(nullptr)
, m_LevelWindowWidget(nullptr)
{
// nothing here
}
//////////////////////////////////////////////////////////////////////////
// QmitkStdMultiWidgetEditor
//////////////////////////////////////////////////////////////////////////
QmitkStdMultiWidgetEditor::QmitkStdMultiWidgetEditor()
: QmitkAbstractMultiWidgetEditor()
, m_Impl(std::make_unique<Impl>())
{
// nothing here
}
QmitkStdMultiWidgetEditor::~QmitkStdMultiWidgetEditor()
{
GetSite()->GetPage()->RemovePartListener(this);
}
berry::IPartListener::Events::Types QmitkStdMultiWidgetEditor::GetPartEventTypes() const
{
return Events::CLOSED | Events::OPENED | Events::HIDDEN | Events::VISIBLE;
}
void QmitkStdMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->RemovePlanesFromDataStorage();
multiWidget->ActivateMenuWidget(false);
}
}
}
void QmitkStdMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->AddPlanesToDataStorage();
multiWidget->ActivateMenuWidget(true);
}
}
}
void QmitkStdMultiWidgetEditor::PartHidden(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->ActivateMenuWidget(false);
}
}
}
void QmitkStdMultiWidgetEditor::PartVisible(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkStdMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->ActivateMenuWidget(true);
}
}
}
QmitkLevelWindowWidget* QmitkStdMultiWidgetEditor::GetLevelWindowWidget() const
{
return m_Impl->m_LevelWindowWidget;
}
void QmitkStdMultiWidgetEditor::EnableSlicingPlanes(bool enable)
{
const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
if (nullptr == multiWidget)
{
return;
}
multiWidget->SetWidgetPlanesVisibility(enable);
}
bool QmitkStdMultiWidgetEditor::IsSlicingPlanesEnabled() const
{
const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
if (nullptr == multiWidget)
{
return false;
}
mitk::DataNode::Pointer node = multiWidget->GetWidgetPlane1();
if (node.IsNotNull())
{
bool visible = false;
node->GetVisibility(visible, nullptr);
return visible;
}
else
{
return false;
}
}
void QmitkStdMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return;
}
if (mitk::InteractionSchemeSwitcher::PACSStandard == scheme)
{
m_Impl->m_InteractionSchemeToolBar->setVisible(true);
}
else
{
m_Impl->m_InteractionSchemeToolBar->setVisible(false);
}
QmitkAbstractMultiWidgetEditor::OnInteractionSchemeChanged(scheme);
}
void QmitkStdMultiWidgetEditor::ShowLevelWindowWidget(bool show)
{
if (show)
{
m_Impl->m_LevelWindowWidget->disconnect(this);
m_Impl->m_LevelWindowWidget->SetDataStorage(GetDataStorage());
m_Impl->m_LevelWindowWidget->show();
}
else
{
m_Impl->m_LevelWindowWidget->disconnect(this);
m_Impl->m_LevelWindowWidget->hide();
}
}
void QmitkStdMultiWidgetEditor::SetFocus()
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
multiWidget->setFocus();
}
}
void QmitkStdMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
{
QHBoxLayout* layout = new QHBoxLayout(parent);
layout->setContentsMargins(0, 0, 0, 0);
auto* preferences = this->GetPreferences();
auto multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
multiWidget = new QmitkStdMultiWidget(parent);
// create left toolbar: interaction scheme toolbar to switch how the render window navigation behaves (in PACS mode)
if (nullptr == m_Impl->m_InteractionSchemeToolBar)
{
m_Impl->m_InteractionSchemeToolBar = new QmitkInteractionSchemeToolBar(parent);
layout->addWidget(m_Impl->m_InteractionSchemeToolBar);
}
m_Impl->m_InteractionSchemeToolBar->SetInteractionEventHandler(multiWidget->GetInteractionEventHandler());
multiWidget->SetDataStorage(GetDataStorage());
multiWidget->InitializeMultiWidget();
SetMultiWidget(multiWidget);
}
layout->addWidget(multiWidget);
// create level window slider on the right side
if (nullptr == m_Impl->m_LevelWindowWidget)
{
m_Impl->m_LevelWindowWidget = new QmitkLevelWindowWidget(parent);
m_Impl->m_LevelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
sizePolicy.setHorizontalStretch(0);
sizePolicy.setVerticalStretch(0);
sizePolicy.setHeightForWidth(m_Impl->m_LevelWindowWidget->sizePolicy().hasHeightForWidth());
m_Impl->m_LevelWindowWidget->setSizePolicy(sizePolicy);
m_Impl->m_LevelWindowWidget->setMaximumWidth(50);
}
layout->addWidget(m_Impl->m_LevelWindowWidget);
- m_Impl->m_MultiWidgetDecorationManager = std::make_unique<QmitkMultiWidgetDecorationManager>(multiWidget);
-
GetSite()->GetPage()->AddPartListener(this);
InitializePreferences(preferences);
OnPreferencesChanged(preferences);
}
void QmitkStdMultiWidgetEditor::OnPreferencesChanged(const mitk::IPreferences* preferences)
{
const auto& multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
if (nullptr == multiWidget)
{
return;
}
// change and apply decoration preferences
GetPreferenceDecorations(preferences);
- m_Impl->m_MultiWidgetDecorationManager->DecorationPreferencesChanged(preferences);
+ this->GetDecorationManager()->DecorationPreferencesChanged(preferences);
QmitkAbstractMultiWidget::RenderWindowWidgetMap renderWindowWidgets = multiWidget->GetRenderWindowWidgets();
int i = 0;
for (const auto& renderWindowWidget : renderWindowWidgets)
{
auto decorationColor = renderWindowWidget.second->GetDecorationColor();
multiWidget->SetDecorationColor(i, decorationColor);
++i;
}
int crosshairGapSize = preferences->GetInt("crosshair gap size", 32);
multiWidget->SetCrosshairGap(crosshairGapSize);
// zooming and panning preferences
bool constrainedZooming = preferences->GetBool("Use constrained zooming and panning", true);
mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
// mouse modes switcher toolbar
bool PACSInteractionScheme = preferences->GetBool("PACS like mouse interaction", false);
OnInteractionSchemeChanged(PACSInteractionScheme ?
mitk::InteractionSchemeSwitcher::PACSStandard :
mitk::InteractionSchemeSwitcher::MITKStandard);
// level window setting
bool showLevelWindowWidget = preferences->GetBool("Show level/window widget", true);
ShowLevelWindowWidget(showLevelWindowWidget);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkStdMultiWidgetEditor::InitializePreferences(mitk::IPreferences * preferences)
{
auto multiWidget = this->GetMultiWidget();
if (nullptr == multiWidget)
return;
this->GetPreferenceDecorations(preferences); // Override if preferences are defined
for (const auto& renderWindowWidget : multiWidget->GetRenderWindowWidgets())
{
auto widgetName = renderWindowWidget.second->GetWidgetName().toStdString();
auto gradientBackgroundColors = renderWindowWidget.second->GetGradientBackgroundColors();
preferences->Put(widgetName + " first background color", this->MitkColorToHex(gradientBackgroundColors.first));
preferences->Put(widgetName + " second background color", this->MitkColorToHex(gradientBackgroundColors.second));
auto decorationColor = renderWindowWidget.second->GetDecorationColor();
preferences->Put(widgetName + " decoration color", this->MitkColorToHex(decorationColor));
auto cornerAnnotation = renderWindowWidget.second->GetCornerAnnotationText();
preferences->Put(widgetName + " corner annotation", cornerAnnotation);
}
}
void QmitkStdMultiWidgetEditor::GetPreferenceDecorations(const mitk::IPreferences * preferences)
{
auto multiWidget = dynamic_cast<QmitkStdMultiWidget*>(GetMultiWidget());
if (nullptr == multiWidget)
return;
auto hexBlack = "#000000";
auto gradientBlack = "#191919";
auto gradientGray = "#7F7F7F";
auto renderWindowWidgets = multiWidget->GetRenderWindowWidgets();
int i = 0;
for (const auto& renderWindowWidget : renderWindowWidgets)
{
auto widgetName = renderWindowWidget.second->GetWidgetName().toStdString();
if (mitk::BaseRenderer::Standard3D == mitk::BaseRenderer::GetInstance(renderWindowWidget.second->GetRenderWindow()->GetVtkRenderWindow())->GetMapperID())
{
auto upper = preferences->Get(widgetName + " first background color", gradientBlack);
auto lower = preferences->Get(widgetName + " second background color", gradientGray);
renderWindowWidget.second->SetGradientBackgroundColors(HexColorToMitkColor(upper), HexColorToMitkColor(lower));
}
else
{
auto upper = preferences->Get(widgetName + " first background color", hexBlack);
auto lower = preferences->Get(widgetName + " second background color", hexBlack);
renderWindowWidget.second->SetGradientBackgroundColors(HexColorToMitkColor(upper), HexColorToMitkColor(lower));
}
auto defaultDecorationColor = multiWidget->GetDecorationColor(i);
auto decorationColor = preferences->Get(widgetName + " decoration color", MitkColorToHex(defaultDecorationColor));
renderWindowWidget.second->SetDecorationColor(HexColorToMitkColor(decorationColor));
auto defaultCornerAnnotation = renderWindowWidget.second->GetCornerAnnotationText();
auto cornerAnnotation = preferences->Get(widgetName + " corner annotation", defaultCornerAnnotation);
renderWindowWidget.second->SetCornerAnnotationText(cornerAnnotation);
++i;
}
}
mitk::Color QmitkStdMultiWidgetEditor::HexColorToMitkColor(const std::string& hexColor)
{
QColor qColor(hexColor.c_str());
mitk::Color returnColor;
float colorMax = 255.0f;
if (hexColor.empty()) // default value
{
returnColor[0] = 1.0;
returnColor[1] = 1.0;
returnColor[2] = 1.0;
MITK_ERROR << "Using default color for unknown hex color " << hexColor;
}
else
{
returnColor[0] = qColor.red() / colorMax;
returnColor[1] = qColor.green() / colorMax;
returnColor[2] = qColor.blue() / colorMax;
}
return returnColor;
}
std::string QmitkStdMultiWidgetEditor::MitkColorToHex(const mitk::Color& color)
{
QColor returnColor;
float colorMax = 255.0f;
returnColor.setRed(static_cast<int>(color[0] * colorMax + 0.5));
returnColor.setGreen(static_cast<int>(color[1] * colorMax + 0.5));
returnColor.setBlue(static_cast<int>(color[2] * colorMax + 0.5));
return returnColor.name().toStdString();
}