diff --git a/Modules/Core/include/mitkRenderingManager.h b/Modules/Core/include/mitkRenderingManager.h
index d013a62635..fdd2d9fe88 100644
--- a/Modules/Core/include/mitkRenderingManager.h
+++ b/Modules/Core/include/mitkRenderingManager.h
@@ -1,399 +1,415 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197
#define MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197
#include <MitkCoreExports.h>
#include <vtkCallbackCommand.h>
#include <itkObject.h>
#include <itkObjectFactory.h>
#include <string>
#include "mitkProperties.h"
#include "mitkPropertyList.h"
#include "mitkTimeGeometry.h"
+#include <itkMultiThreader.h>
+//class itk::MultiThreader;
class vtkRenderWindow;
class vtkObject;
+
namespace mitk
{
class RenderingManager;
class RenderingManagerFactory;
class BaseGeometry;
class SliceNavigationController;
class BaseRenderer;
class DataStorage;
-
+
/**
* \brief Manager for coordinating the rendering process.
*
* RenderingManager is a central instance retrieving and executing
* RenderWindow update requests. Its main purpose is to coordinate
* distributed requests which cannot be aware of each other - lacking the
* knowledge of whether they are really necessary or not. For example, two
* objects might determine that a specific RenderWindow needs to be updated.
* This would result in one unnecessary update, if both executed the update
* on their own.
*
* The RenderingManager addresses this by letting each such object
* <em>request</em> an update, and waiting for other objects to possibly
* issue the same request. The actual update will then only be executed at a
* well-defined point in the main event loop (this may be each time after
* event processing is done).
*
* Convinience methods for updating all RenderWindows which have been
* registered with the RenderingManager exist. If theses methods are not
* used, it is not required to register (add) RenderWindows prior to using
* the RenderingManager.
*
* The methods #ForceImmediateUpdate() and #ForceImmediateUpdateAll() can
* be used to force the RenderWindow update execution without any delay,
* bypassing the request functionality.
*
* The interface of RenderingManager is platform independent. Platform
* specific subclasses have to be implemented, though, to supply an
* appropriate event issueing for controlling the update execution process.
* See method documentation for a description of how this can be done.
*
* \sa TestingRenderingManager An "empty" RenderingManager implementation which
* can be used in tests etc.
*
*/
class MITKCORE_EXPORT RenderingManager : public itk::Object
{
public:
mitkClassMacroItkParent(RenderingManager, itk::Object);
typedef std::vector<vtkRenderWindow *> RenderWindowVector;
typedef std::vector<float> FloatVector;
typedef std::vector<bool> BoolVector;
typedef itk::SmartPointer<DataStorage> DataStoragePointer;
enum RequestType
{
REQUEST_UPDATE_ALL = 0,
REQUEST_UPDATE_2DWINDOWS,
REQUEST_UPDATE_3DWINDOWS
};
static Pointer New();
/** Set the object factory which produces the desired platform specific
* RenderingManager singleton instance. */
static void SetFactory(RenderingManagerFactory *factory);
/** Get the object factory which produces the platform specific
* RenderingManager instances. */
static const RenderingManagerFactory *GetFactory();
/** Returns true if a factory has already been set. */
static bool HasFactory();
/** Get the RenderingManager singleton instance. */
static RenderingManager *GetInstance();
/** Returns true if the singleton instance does already exist. */
static bool IsInstantiated();
/** Adds a RenderWindow. This is required if the methods #RequestUpdateAll
* or #ForceImmediateUpdate are to be used. */
void AddRenderWindow(vtkRenderWindow *renderWindow);
/** Removes a RenderWindow. */
void RemoveRenderWindow(vtkRenderWindow *renderWindow);
/** Get a list of all registered RenderWindows */
const RenderWindowVector &GetAllRegisteredRenderWindows();
/** Requests an update for the specified RenderWindow, to be executed as
* soon as the main loop is ready for rendering. */
void RequestUpdate(vtkRenderWindow *renderWindow);
/** Immediately executes an update of the specified RenderWindow. */
void ForceImmediateUpdate(vtkRenderWindow *renderWindow);
/** Requests all currently registered RenderWindows to be updated.
* If only 2D or 3D windows should be updated, this can be specified
* via the parameter requestType. */
void RequestUpdateAll(RequestType type = REQUEST_UPDATE_ALL);
/** Immediately executes an update of all registered RenderWindows.
* If only 2D or 3D windows should be updated, this can be specified
* via the parameter requestType. */
void ForceImmediateUpdateAll(RequestType type = REQUEST_UPDATE_ALL);
/** Initializes the windows specified by requestType to the geometry of the
* given DataStorage. */
// virtual bool InitializeViews( const DataStorage *storage, const DataNode* node = nullptr,
// RequestType type = REQUEST_UPDATE_ALL, bool preserveRoughOrientationInWorldSpace = false );
/** Initializes the windows specified by requestType to the given
* geometry. PLATFORM SPECIFIC. TODO: HOW IS THIS PLATFORM SPECIFIC?
* Throws an exception if bounding box has 0 extent due to exceeding
* double precision range. */
virtual bool InitializeViews(const BaseGeometry *geometry,
RequestType type = REQUEST_UPDATE_ALL,
bool preserveRoughOrientationInWorldSpace = false);
virtual bool InitializeViews(const TimeGeometry *geometry,
RequestType type = REQUEST_UPDATE_ALL,
bool preserveRoughOrientationInWorldSpace = false);
/** Initializes the windows to the default viewing direction
* (geomtry information is NOT changed). PLATFORM SPECIFIC. */
virtual bool InitializeViews(RequestType type = REQUEST_UPDATE_ALL);
/** Initializes the specified window to the geometry of the given
* DataNode. Set "initializeGlobalTimeSNC" to true in order to use this
* geometry as global TimeGeometry. PLATFORM SPECIFIC. */
// virtual bool InitializeView( vtkRenderWindow *renderWindow, const DataStorage* ds, const DataNode* node = nullptr,
// bool initializeGlobalTimeSNC = false );
/** Initializes the specified window to the given geometry. Set
* "initializeGlobalTimeSNC" to true in order to use this geometry as
* global TimeGeometry. PLATFORM SPECIFIC. */
virtual bool InitializeView(vtkRenderWindow *renderWindow,
const BaseGeometry *geometry,
bool initializeGlobalTimeSNC = false);
virtual bool InitializeView(vtkRenderWindow *renderWindow,
const TimeGeometry *geometry,
bool initializeGlobalTimeSNC = false);
/** Initializes the specified window to the default viewing direction
* (geomtry information is NOT changed). PLATFORM SPECIFIC. */
virtual bool InitializeView(vtkRenderWindow *renderWindow);
/**
* @brief Initializes the renderwindows by the aggregated geometry of
* all objects that are held in the data storage.
* This is basically a global reinit
* @param The data storage from which the bounding object can be retrieved
*/
virtual void InitializeViewsByBoundingObjects(const DataStorage *);
/** Gets the (global) SliceNavigationController responsible for
* time-slicing. */
const SliceNavigationController *GetTimeNavigationController() const;
/** Gets the (global) SliceNavigationController responsible for
* time-slicing. */
SliceNavigationController *GetTimeNavigationController();
~RenderingManager() override;
/** Executes all pending requests. This method has to be called by the
* system whenever a RenderingManager induced request event occurs in
* the system pipeline (see concrete RenderingManager implementations). */
virtual void ExecutePendingRequests();
bool IsRendering() const;
void AbortRendering();
/** En-/Disable LOD increase globally. */
itkSetMacro(LODIncreaseBlocked, bool);
/** En-/Disable LOD increase globally. */
itkGetMacro(LODIncreaseBlocked, bool);
/** En-/Disable LOD increase globally. */
itkBooleanMacro(LODIncreaseBlocked);
/** En-/Disable LOD abort mechanism. */
itkSetMacro(LODAbortMechanismEnabled, bool);
/** En-/Disable LOD abort mechanism. */
itkGetMacro(LODAbortMechanismEnabled, bool);
/** En-/Disable LOD abort mechanism. */
itkBooleanMacro(LODAbortMechanismEnabled);
/** Force a sub-class to start a timer for a pending hires-rendering request */
virtual void StartOrResetTimer(){};
/** To be called by a sub-class from a timer callback */
void ExecutePendingHighResRenderingRequest();
virtual void DoStartRendering(){};
virtual void DoMonitorRendering(){};
virtual void DoFinishAbortRendering(){};
int GetNextLOD(BaseRenderer *renderer);
/** Set current LOD (nullptr means all renderers)*/
void SetMaximumLOD(unsigned int max);
void SetShading(bool state, unsigned int lod);
bool GetShading(unsigned int lod);
void SetClippingPlaneStatus(bool status);
bool GetClippingPlaneStatus();
void SetShadingValues(float ambient, float diffuse, float specular, float specpower);
FloatVector &GetShadingValues();
/** Returns a property list */
PropertyList::Pointer GetPropertyList() const;
/** Returns a property from m_PropertyList */
BaseProperty *GetProperty(const char *propertyKey) const;
/** Sets or adds (if not present) a property in m_PropertyList */
void SetProperty(const char *propertyKey, BaseProperty *propertyValue);
/**
* \brief Setter / Getter for internal DataStorage
*
* Sets / returns the mitk::DataStorage that is used internally. This instance holds all mitk::DataNodes that are
* rendered by the registered BaseRenderers.
*
* If this DataStorage is changed at runtime by calling SetDataStorage(),
* all currently registered BaseRenderers are automatically given the correct instance.
* When a new BaseRenderer is added, it is automatically initialized with the currently active DataStorage.
*/
void SetDataStorage(mitk::DataStorage *storage);
/**
* \brief Setter / Getter for internal DataStorage
*
* Sets / returns the mitk::DataStorage that is used internally. This instance holds all mitk::DataNodes that are
* rendered by the registered BaseRenderers.
*
* If this DataStorage is changed at runtime by calling SetDataStorage(),
* all currently registered BaseRenderers are automatically given the correct instance.
* When a new BaseRenderer is added, it is automatically initialized with the currently active DataStorage.
*/
mitk::DataStorage *GetDataStorage();
/**
* @brief Sets a flag to the given renderwindow to indicated that it has the focus e.g. has been clicked recently.
* @param focusWindow
*/
void SetRenderWindowFocus(vtkRenderWindow *focusWindow);
+ /** @brief Starts continous updating of the render windows in a separate thread. */
+ void StartContinousUpdating(int FramesPerSecond = 20);
+
+ /** @brief Stops continous updating of the render windows if it is running. */
+ void StopContinousUpdating();
+
itkGetMacro(FocusedRenderWindow, vtkRenderWindow *)
itkSetMacro(ConstrainedPanningZooming, bool);
protected:
enum
{
RENDERING_INACTIVE = 0,
RENDERING_REQUESTED,
RENDERING_INPROGRESS
};
RenderingManager();
+ /** Members for thread for continous updating */
+ static ITK_THREAD_RETURN_TYPE ThreadStartContinousUpdate(void *data);
+ itk::MultiThreader::Pointer m_MultiThreader;
+ int m_ThreadID;
+ bool m_run;
+ void ContinousUpdate();
+
/** Abstract method for generating a system specific event for rendering
* request. This method is called whenever an update is requested */
virtual void GenerateRenderingRequestEvent() = 0;
virtual void InitializePropertyList();
bool m_UpdatePending;
typedef std::map<BaseRenderer *, unsigned int> RendererIntMap;
typedef std::map<BaseRenderer *, bool> RendererBoolMap;
RendererBoolMap m_RenderingAbortedMap;
RendererIntMap m_NextLODMap;
unsigned int m_MaxLOD;
bool m_LODIncreaseBlocked;
bool m_LODAbortMechanismEnabled;
BoolVector m_ShadingEnabled;
bool m_ClippingPlaneEnabled;
FloatVector m_ShadingValues;
static void RenderingStartCallback(vtkObject *caller, unsigned long eid, void *clientdata, void *calldata);
static void RenderingProgressCallback(vtkObject *caller, unsigned long eid, void *clientdata, void *calldata);
static void RenderingEndCallback(vtkObject *caller, unsigned long eid, void *clientdata, void *calldata);
typedef std::map<vtkRenderWindow *, int> RenderWindowList;
RenderWindowList m_RenderWindowList;
RenderWindowVector m_AllRenderWindows;
struct RenderWindowCallbacks
{
vtkCallbackCommand *commands[3u];
};
typedef std::map<vtkRenderWindow *, RenderWindowCallbacks> RenderWindowCallbacksList;
RenderWindowCallbacksList m_RenderWindowCallbacksList;
itk::SmartPointer<SliceNavigationController> m_TimeNavigationController;
static RenderingManager::Pointer s_Instance;
static RenderingManagerFactory *s_RenderingManagerFactory;
PropertyList::Pointer m_PropertyList;
DataStoragePointer m_DataStorage;
bool m_ConstrainedPanningZooming;
private:
void InternalViewInitialization(mitk::BaseRenderer *baseRenderer,
const mitk::TimeGeometry *geometry,
bool boundingBoxInitialized,
int mapperID);
vtkRenderWindow *m_FocusedRenderWindow;
};
#pragma GCC visibility push(default)
itkEventMacro(RenderingManagerEvent, itk::AnyEvent);
itkEventMacro(RenderingManagerViewsInitializedEvent, RenderingManagerEvent);
#pragma GCC visibility pop
itkEventMacroDeclaration(FocusChangedEvent, itk::AnyEvent)
/**
* Generic RenderingManager implementation for "non-rendering-plattform",
* e.g. for tests. Its factory (TestingRenderingManagerFactory) is
* automatically on start-up and is used by default if not other
* RenderingManagerFactory is instantiated explicitly thereafter.
* (see mitkRenderingManager.cpp)
*/
class MITKCORE_EXPORT TestingRenderingManager : public RenderingManager
{
public:
mitkClassMacro(TestingRenderingManager, RenderingManager);
itkFactorylessNewMacro(Self) itkCloneMacro(Self)
protected : void GenerateRenderingRequestEvent() override{
// ForceImmediateUpdateAll();
};
};
} // namespace mitk
#endif /* MITKRenderingManager_H_HEADER_INCLUDED_C135A197 */
diff --git a/Modules/Core/src/Controllers/mitkRenderingManager.cpp b/Modules/Core/src/Controllers/mitkRenderingManager.cpp
index a92142ac93..fc579ee6bc 100644
--- a/Modules/Core/src/Controllers/mitkRenderingManager.cpp
+++ b/Modules/Core/src/Controllers/mitkRenderingManager.cpp
@@ -1,744 +1,790 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
-#include "mitkRenderingManager.h"
#include "mitkBaseRenderer.h"
#include "mitkCameraController.h"
#include "mitkNodePredicateNot.h"
#include "mitkNodePredicateProperty.h"
#include "mitkProportionalTimeGeometry.h"
+#include "mitkRenderingManager.h"
#include "mitkRenderingManagerFactory.h"
#include <vtkRenderWindow.h>
#include "mitkNumericTypes.h"
#include <itkAffineGeometryFrame.h>
#include <itkCommand.h>
#include <itkScalableAffineTransform.h>
+#include <itkMultiThreader.h>
#include <mitkVtkPropRenderer.h>
#include <algorithm>
namespace mitk
{
itkEventMacroDefinition(FocusChangedEvent, itk::AnyEvent)
RenderingManager::Pointer RenderingManager::s_Instance = nullptr;
RenderingManagerFactory *RenderingManager::s_RenderingManagerFactory = nullptr;
RenderingManager::RenderingManager()
: m_UpdatePending(false),
m_MaxLOD(1),
m_LODIncreaseBlocked(false),
m_LODAbortMechanismEnabled(false),
m_ClippingPlaneEnabled(false),
m_TimeNavigationController(SliceNavigationController::New()),
m_DataStorage(nullptr),
m_ConstrainedPanningZooming(true),
- m_FocusedRenderWindow(nullptr)
+ m_FocusedRenderWindow(nullptr),
+ m_MultiThreader(itk::MultiThreader::New()),
+ m_ThreadID(0)
{
m_ShadingEnabled.assign(3, false);
m_ShadingValues.assign(4, 0.0);
InitializePropertyList();
}
RenderingManager::~RenderingManager()
{
// Decrease reference counts of all registered vtkRenderWindows for
// proper destruction
RenderWindowVector::iterator it;
for (it = m_AllRenderWindows.begin(); it != m_AllRenderWindows.end(); ++it)
{
(*it)->UnRegister(nullptr);
auto callbacks_it = this->m_RenderWindowCallbacksList.find(*it);
if (callbacks_it != this->m_RenderWindowCallbacksList.end())
{
(*it)->RemoveObserver(callbacks_it->second.commands[0u]);
(*it)->RemoveObserver(callbacks_it->second.commands[1u]);
(*it)->RemoveObserver(callbacks_it->second.commands[2u]);
}
}
}
void RenderingManager::SetFactory(RenderingManagerFactory *factory) { s_RenderingManagerFactory = factory; }
const RenderingManagerFactory *RenderingManager::GetFactory() { return s_RenderingManagerFactory; }
bool RenderingManager::HasFactory()
{
if (RenderingManager::s_RenderingManagerFactory)
{
return true;
}
else
{
return false;
}
}
RenderingManager::Pointer RenderingManager::New()
{
const RenderingManagerFactory *factory = GetFactory();
if (factory == nullptr)
return nullptr;
return factory->CreateRenderingManager();
}
RenderingManager *RenderingManager::GetInstance()
{
if (!RenderingManager::s_Instance)
{
if (s_RenderingManagerFactory)
{
s_Instance = s_RenderingManagerFactory->CreateRenderingManager();
}
}
return s_Instance;
}
bool RenderingManager::IsInstantiated()
{
if (RenderingManager::s_Instance)
return true;
else
return false;
}
void RenderingManager::AddRenderWindow(vtkRenderWindow *renderWindow)
{
if (renderWindow && (m_RenderWindowList.find(renderWindow) == m_RenderWindowList.end()))
{
m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
m_AllRenderWindows.push_back(renderWindow);
if (m_DataStorage.IsNotNull())
mitk::BaseRenderer::GetInstance(renderWindow)->SetDataStorage(m_DataStorage.GetPointer());
// Register vtkRenderWindow instance
renderWindow->Register(nullptr);
// Add callbacks for rendering abort mechanism
// BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
vtkCallbackCommand *startCallbackCommand = vtkCallbackCommand::New();
startCallbackCommand->SetCallback(RenderingManager::RenderingStartCallback);
renderWindow->AddObserver(vtkCommand::StartEvent, startCallbackCommand);
vtkCallbackCommand *progressCallbackCommand = vtkCallbackCommand::New();
progressCallbackCommand->SetCallback(RenderingManager::RenderingProgressCallback);
renderWindow->AddObserver(vtkCommand::AbortCheckEvent, progressCallbackCommand);
vtkCallbackCommand *endCallbackCommand = vtkCallbackCommand::New();
endCallbackCommand->SetCallback(RenderingManager::RenderingEndCallback);
renderWindow->AddObserver(vtkCommand::EndEvent, endCallbackCommand);
RenderWindowCallbacks callbacks;
callbacks.commands[0u] = startCallbackCommand;
callbacks.commands[1u] = progressCallbackCommand;
callbacks.commands[2u] = endCallbackCommand;
this->m_RenderWindowCallbacksList[renderWindow] = callbacks;
// Delete vtk variables correctly
startCallbackCommand->Delete();
progressCallbackCommand->Delete();
endCallbackCommand->Delete();
}
}
void RenderingManager::RemoveRenderWindow(vtkRenderWindow *renderWindow)
{
if (m_RenderWindowList.erase(renderWindow))
{
auto callbacks_it = this->m_RenderWindowCallbacksList.find(renderWindow);
if (callbacks_it != this->m_RenderWindowCallbacksList.end())
{
renderWindow->RemoveObserver(callbacks_it->second.commands[0u]);
renderWindow->RemoveObserver(callbacks_it->second.commands[1u]);
renderWindow->RemoveObserver(callbacks_it->second.commands[2u]);
this->m_RenderWindowCallbacksList.erase(callbacks_it);
}
- auto rw_it =
- std::find(m_AllRenderWindows.begin(), m_AllRenderWindows.end(), renderWindow);
+ auto rw_it = std::find(m_AllRenderWindows.begin(), m_AllRenderWindows.end(), renderWindow);
if (rw_it != m_AllRenderWindows.cend())
{
// Decrease reference count for proper destruction
(*rw_it)->UnRegister(nullptr);
m_AllRenderWindows.erase(rw_it);
}
}
}
const RenderingManager::RenderWindowVector &RenderingManager::GetAllRegisteredRenderWindows()
{
return m_AllRenderWindows;
}
void RenderingManager::RequestUpdate(vtkRenderWindow *renderWindow)
{
// If the renderWindow is not valid, we do not want to inadvertantly create
// an entry in the m_RenderWindowList map. It is possible if the user is
// regularly calling AddRenderer and RemoveRenderer for a rendering update
// to come into this method with a renderWindow pointer that is valid in the
// sense that the window does exist within the application, but that
// renderWindow has been temporarily removed from this RenderingManager for
// performance reasons.
if (m_RenderWindowList.find(renderWindow) == m_RenderWindowList.cend())
{
return;
}
m_RenderWindowList[renderWindow] = RENDERING_REQUESTED;
if (!m_UpdatePending)
{
m_UpdatePending = true;
this->GenerateRenderingRequestEvent();
}
}
void RenderingManager::ForceImmediateUpdate(vtkRenderWindow *renderWindow)
{
// If the renderWindow is not valid, we do not want to inadvertantly create
// an entry in the m_RenderWindowList map. It is possible if the user is
// regularly calling AddRenderer and RemoveRenderer for a rendering update
// to come into this method with a renderWindow pointer that is valid in the
// sense that the window does exist within the application, but that
// renderWindow has been temporarily removed from this RenderingManager for
// performance reasons.
if (m_RenderWindowList.find(renderWindow) == m_RenderWindowList.cend())
{
return;
}
// Erase potentially pending requests for this window
m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
m_UpdatePending = false;
// Immediately repaint this window (implementation platform specific)
// If the size is 0 it crashes
int *size = renderWindow->GetSize();
if (0 != size[0] && 0 != size[1])
{
// prepare the camera etc. before rendering
// Note: this is a very important step which should be called before the VTK render!
// If you modify the camera anywhere else or after the render call, the scene cannot be seen.
auto *vPR = dynamic_cast<mitk::VtkPropRenderer *>(mitk::BaseRenderer::GetInstance(renderWindow));
if (vPR)
vPR->PrepareRender();
// Execute rendering
renderWindow->Render();
}
}
void RenderingManager::RequestUpdateAll(RequestType type)
{
RenderWindowList::const_iterator it;
for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it)
{
int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
if ((type == REQUEST_UPDATE_ALL) || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1)) ||
((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))
{
this->RequestUpdate(it->first);
}
}
}
void RenderingManager::ForceImmediateUpdateAll(RequestType type)
{
RenderWindowList::const_iterator it;
for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it)
{
int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
if ((type == REQUEST_UPDATE_ALL) || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1)) ||
((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))
{
// Immediately repaint this window (implementation platform specific)
// If the size is 0, it crashes
this->ForceImmediateUpdate(it->first);
}
}
}
void RenderingManager::InitializeViewsByBoundingObjects(const DataStorage *ds)
{
if (!ds)
return;
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(
mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = ds->GetSubset(pred);
// calculate bounding geometry of these nodes
auto bounds = ds->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
this->InitializeViews(bounds);
}
// TODO_GOETZ
// Remove old function, so only this one is working.
bool RenderingManager::InitializeViews(const BaseGeometry *dataGeometry,
RequestType type,
bool preserveRoughOrientationInWorldSpace)
{
ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
propTimeGeometry->Initialize(dynamic_cast<BaseGeometry *>(dataGeometry->Clone().GetPointer()), 1);
return InitializeViews(propTimeGeometry, type, preserveRoughOrientationInWorldSpace);
}
bool RenderingManager::InitializeViews(const TimeGeometry *dataGeometry,
RequestType type,
bool /*preserveRoughOrientationInWorldSpace*/)
{
MITK_DEBUG << "initializing views";
bool boundingBoxInitialized = false;
TimeGeometry::ConstPointer timeGeometry = dataGeometry;
TimeGeometry::Pointer modifiedGeometry = nullptr;
if (dataGeometry != nullptr)
{
modifiedGeometry = dataGeometry->Clone();
}
int warningLevel = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
- if ((timeGeometry.IsNotNull()) &&
- (timeGeometry->GetBoundingBoxInWorld()->GetDiagonalLength2() > mitk::eps))
+ if ((timeGeometry.IsNotNull()) && (timeGeometry->GetBoundingBoxInWorld()->GetDiagonalLength2() > mitk::eps))
{
boundingBoxInitialized = true;
}
if (timeGeometry.IsNotNull())
{ // make sure bounding box has an extent bigger than zero in any direction
// clone the input geometry
// Old Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
assert(modifiedGeometry.IsNotNull());
for (TimeStepType step = 0; step < modifiedGeometry->CountTimeSteps(); ++step)
{
BaseGeometry::BoundsArrayType newBounds = modifiedGeometry->GetGeometryForTimeStep(step)->GetBounds();
for (unsigned int dimension = 0; (2 * dimension) < newBounds.Size(); dimension++)
{
// check for equality but for an epsilon
if (Equal(newBounds[2 * dimension], newBounds[2 * dimension + 1]))
{
newBounds[2 * dimension + 1] += 1;
if (Equal(
newBounds[2 * dimension],
newBounds[2 * dimension + 1])) // newBounds will still be equal if values are beyond double precision
{
mitkThrow() << "One dimension of object data has zero length, please make sure you're not using numbers "
"beyond double precision as coordinates.";
}
}
}
modifiedGeometry->GetGeometryForTimeStep(step)->SetBounds(newBounds);
}
}
timeGeometry = modifiedGeometry;
RenderWindowList::const_iterator it;
for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it)
{
mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance(it->first);
baseRenderer->SetConstrainZoomingAndPanning(m_ConstrainedPanningZooming);
int id = baseRenderer->GetMapperID();
if (((type == REQUEST_UPDATE_ALL) || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1)) ||
((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2))))
{
this->InternalViewInitialization(baseRenderer, timeGeometry, boundingBoxInitialized, id);
}
}
if (boundingBoxInitialized)
{
m_TimeNavigationController->SetInputWorldTimeGeometry(timeGeometry);
}
m_TimeNavigationController->Update();
this->RequestUpdateAll(type);
vtkObject::SetGlobalWarningDisplay(warningLevel);
// Inform listeners that views have been initialized
this->InvokeEvent(mitk::RenderingManagerViewsInitializedEvent());
return boundingBoxInitialized;
}
bool RenderingManager::InitializeViews(RequestType type)
{
RenderWindowList::const_iterator it;
for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it)
{
mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance(it->first);
int id = baseRenderer->GetMapperID();
if ((type == REQUEST_UPDATE_ALL) || ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1)) ||
((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))
{
mitk::SliceNavigationController *nc =
baseRenderer->GetSliceNavigationController();
// Re-initialize view direction
nc->SetViewDirectionToDefault();
// Update the SNC
nc->Update();
}
}
this->RequestUpdateAll(type);
return true;
}
bool RenderingManager::InitializeView(vtkRenderWindow *renderWindow,
const BaseGeometry *geometry,
bool initializeGlobalTimeSNC)
{
ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
propTimeGeometry->Initialize(dynamic_cast<BaseGeometry *>(geometry->Clone().GetPointer()), 1);
return InitializeView(renderWindow, propTimeGeometry, initializeGlobalTimeSNC);
}
bool RenderingManager::InitializeView(vtkRenderWindow *renderWindow,
const TimeGeometry *geometry,
bool initializeGlobalTimeSNC)
{
bool boundingBoxInitialized = false;
int warningLevel = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
- if ((geometry != nullptr) &&
- (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() > mitk::eps))
+ if ((geometry != nullptr) && (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() > mitk::eps))
{
boundingBoxInitialized = true;
}
mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow);
int id = baseRenderer->GetMapperID();
this->InternalViewInitialization(baseRenderer, geometry, boundingBoxInitialized, id);
if (boundingBoxInitialized && initializeGlobalTimeSNC)
{
m_TimeNavigationController->SetInputWorldTimeGeometry(geometry);
}
m_TimeNavigationController->Update();
this->RequestUpdate(renderWindow);
vtkObject::SetGlobalWarningDisplay(warningLevel);
return boundingBoxInitialized;
}
bool RenderingManager::InitializeView(vtkRenderWindow *renderWindow)
{
mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow);
mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController();
// Re-initialize view direction
nc->SetViewDirectionToDefault();
// Update the SNC
nc->Update();
this->RequestUpdate(renderWindow);
return true;
}
void RenderingManager::InternalViewInitialization(mitk::BaseRenderer *baseRenderer,
const mitk::TimeGeometry *geometry,
bool boundingBoxInitialized,
int mapperID)
{
mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController();
// Re-initialize view direction
nc->SetViewDirectionToDefault();
if (boundingBoxInitialized)
{
// Set geometry for NC
nc->SetInputWorldTimeGeometry(geometry);
nc->Update();
if (mapperID == BaseRenderer::Standard2D)
{
// For 2D SNCs, steppers are set so that the cross is centered
// in the image
nc->GetSlice()->SetPos(nc->GetSlice()->GetSteps() / 2);
}
baseRenderer->GetCameraController()->SetViewToAnterior();
baseRenderer->GetCameraController()->Fit();
}
else
{
nc->Update();
}
}
const SliceNavigationController *RenderingManager::GetTimeNavigationController() const
{
return m_TimeNavigationController.GetPointer();
}
SliceNavigationController *RenderingManager::GetTimeNavigationController()
{
return m_TimeNavigationController.GetPointer();
}
void RenderingManager::ExecutePendingRequests()
{
m_UpdatePending = false;
// Satisfy all pending update requests
RenderWindowList::const_iterator it;
int i = 0;
for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it, ++i)
{
if (it->second == RENDERING_REQUESTED)
{
this->ForceImmediateUpdate(it->first);
}
}
}
void RenderingManager::RenderingStartCallback(vtkObject *caller, unsigned long, void *, void *)
{
auto *renderWindow = dynamic_cast<vtkRenderWindow *>(caller);
mitk::RenderingManager *renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
RenderWindowList &renderWindowList = renman->m_RenderWindowList;
if (renderWindow)
{
renderWindowList[renderWindow] = RENDERING_INPROGRESS;
}
renman->m_UpdatePending = false;
}
void RenderingManager::RenderingProgressCallback(vtkObject *caller, unsigned long, void *, void *)
{
auto *renderWindow = dynamic_cast<vtkRenderWindow *>(caller);
mitk::RenderingManager *renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
if (renman->m_LODAbortMechanismEnabled)
{
auto *renderWindow = dynamic_cast<vtkRenderWindow *>(caller);
if (renderWindow)
{
BaseRenderer *renderer = BaseRenderer::GetInstance(renderWindow);
if (renderer && (renderer->GetNumberOfVisibleLODEnabledMappers() > 0))
{
renman->DoMonitorRendering();
}
}
}
}
void RenderingManager::RenderingEndCallback(vtkObject *caller, unsigned long, void *, void *)
{
auto *renderWindow = dynamic_cast<vtkRenderWindow *>(caller);
mitk::RenderingManager *renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
RenderWindowList &renderWindowList = renman->m_RenderWindowList;
RendererIntMap &nextLODMap = renman->m_NextLODMap;
if (renderWindow)
{
BaseRenderer *renderer = BaseRenderer::GetInstance(renderWindow);
if (renderer)
{
renderWindowList[renderer->GetRenderWindow()] = RENDERING_INACTIVE;
// Level-of-Detail handling
if (renderer->GetNumberOfVisibleLODEnabledMappers() > 0)
{
if (nextLODMap[renderer] == 0)
renman->StartOrResetTimer();
else
nextLODMap[renderer] = 0;
}
}
}
}
bool RenderingManager::IsRendering() const
{
RenderWindowList::const_iterator it;
for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it)
{
if (it->second == RENDERING_INPROGRESS)
{
return true;
}
}
return false;
}
void RenderingManager::AbortRendering()
{
RenderWindowList::const_iterator it;
for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it)
{
if (it->second == RENDERING_INPROGRESS)
{
it->first->SetAbortRender(true);
m_RenderingAbortedMap[BaseRenderer::GetInstance(it->first)] = true;
}
}
}
int RenderingManager::GetNextLOD(BaseRenderer *renderer)
{
if (renderer != nullptr)
{
return m_NextLODMap[renderer];
}
else
{
return 0;
}
}
void RenderingManager::ExecutePendingHighResRenderingRequest()
{
RenderWindowList::const_iterator it;
for (it = m_RenderWindowList.cbegin(); it != m_RenderWindowList.cend(); ++it)
{
BaseRenderer *renderer = BaseRenderer::GetInstance(it->first);
if (renderer->GetNumberOfVisibleLODEnabledMappers() > 0)
{
if (m_NextLODMap[renderer] == 0)
{
m_NextLODMap[renderer] = 1;
RequestUpdate(it->first);
}
}
}
}
void RenderingManager::SetMaximumLOD(unsigned int max) { m_MaxLOD = max; }
// enable/disable shading
void RenderingManager::SetShading(bool state, unsigned int lod)
{
if (lod > m_MaxLOD)
{
itkWarningMacro(<< "LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
return;
}
m_ShadingEnabled[lod] = state;
}
bool RenderingManager::GetShading(unsigned int lod)
{
if (lod > m_MaxLOD)
{
itkWarningMacro(<< "LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
return false;
}
return m_ShadingEnabled[lod];
}
// enable/disable the clipping plane
void RenderingManager::SetClippingPlaneStatus(bool status) { m_ClippingPlaneEnabled = status; }
bool RenderingManager::GetClippingPlaneStatus() { return m_ClippingPlaneEnabled; }
void RenderingManager::SetShadingValues(float ambient, float diffuse, float specular, float specpower)
{
m_ShadingValues[0] = ambient;
m_ShadingValues[1] = diffuse;
m_ShadingValues[2] = specular;
m_ShadingValues[3] = specpower;
}
RenderingManager::FloatVector &RenderingManager::GetShadingValues() { return m_ShadingValues; }
void RenderingManager::InitializePropertyList()
{
if (m_PropertyList.IsNull())
{
m_PropertyList = PropertyList::New();
}
this->SetProperty("coupled-zoom", BoolProperty::New(false));
this->SetProperty("coupled-plane-rotation", BoolProperty::New(false));
this->SetProperty("MIP-slice-rendering", BoolProperty::New(false));
}
PropertyList::Pointer RenderingManager::GetPropertyList() const { return m_PropertyList; }
BaseProperty *RenderingManager::GetProperty(const char *propertyKey) const
{
return m_PropertyList->GetProperty(propertyKey);
}
void RenderingManager::SetProperty(const char *propertyKey, BaseProperty *propertyValue)
{
m_PropertyList->SetProperty(propertyKey, propertyValue);
}
void RenderingManager::SetDataStorage(DataStorage *storage)
{
if (storage != nullptr)
{
m_DataStorage = storage;
RenderingManager::RenderWindowVector::const_iterator iter;
for (iter = m_AllRenderWindows.cbegin(); iter < m_AllRenderWindows.cend(); ++iter)
{
mitk::BaseRenderer::GetInstance((*iter))->SetDataStorage(m_DataStorage.GetPointer());
}
}
}
mitk::DataStorage *RenderingManager::GetDataStorage() { return m_DataStorage; }
void RenderingManager::SetRenderWindowFocus(vtkRenderWindow *focusWindow)
{
if (focusWindow != m_FocusedRenderWindow)
{
if (!focusWindow || (m_RenderWindowList.find(focusWindow) != m_RenderWindowList.cend()))
{
m_FocusedRenderWindow = focusWindow;
this->InvokeEvent(FocusChangedEvent());
return;
}
MITK_ERROR << "Tried to set a RenderWindow that does not exist.";
}
}
+ void RenderingManager::StartContinousUpdating(int FramesPerSecond)
+ {
+ if (m_ThreadID == 0)
+ {
+ m_ThreadID = m_MultiThreader->SpawnThread(this->ThreadStartContinousUpdate,
+ this); // start a new thread that executes the ContinousUpdate() method
+ }
+ }
+
+ void RenderingManager::StopContinousUpdating()
+ {
+ m_run = false;
+ m_ThreadID = 0;
+ }
+
+ void RenderingManager::ContinousUpdate()
+ {
+ m_run = true;
+ while (m_run)
+ {
+ Sleep(50);
+ this->RequestUpdateAll();
+ }
+ }
+
+ ITK_THREAD_RETURN_TYPE RenderingManager::ThreadStartContinousUpdate(void *pInfoStruct)
+ {
+ /* extract this pointer from Thread Info structure */
+ struct itk::MultiThreader::ThreadInfoStruct *pInfo = (struct itk::MultiThreader::ThreadInfoStruct *)pInfoStruct;
+ if (pInfo == nullptr)
+ {
+ return ITK_THREAD_RETURN_VALUE;
+ }
+ if (pInfo->UserData == nullptr)
+ {
+ return ITK_THREAD_RETURN_VALUE;
+ }
+
+ RenderingManager *renderingManager = (RenderingManager *)pInfo->UserData;
+
+ if (renderingManager != nullptr)
+ renderingManager->ContinousUpdate();
+
+ return ITK_THREAD_RETURN_VALUE;
+ }
+
// Create and register generic RenderingManagerFactory.
TestingRenderingManagerFactory renderingManagerFactory;
} // namespace
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index ea16dd96c0..45a3af5159 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,1426 +1,1428 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkMITKIGTTrackingToolboxView.h"
// Qt
#include <QMessageBox>
#include <QSettings>
#include <qfiledialog.h>
// MITK
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkTrackingVolumeGenerator.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNavigationToolStorageSerializer.h>
#include <mitkIOUtil.h>
#include <mitkLog.h>
#include <mitkTrackingDeviceTypeCollection.h>
#include <mitkUnspecifiedTrackingTypeInformation.h>
#include <mitkNeedleProjectionFilter.h>
//for exceptions
#include <mitkIGTException.h>
#include <mitkIGTIOException.h>
#include "mitkPluginActivator.h"
const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
: QmitkAbstractView()
, m_Controls(nullptr)
, m_DeviceTypeCollection(nullptr)
, m_ToolProjectionNode(nullptr)
{
m_TrackingLoggingTimer = new QTimer(this);
m_TrackingRenderTimer = new QTimer(this);
m_TimeoutTimer = new QTimer(this);
m_tracking = false;
m_connected = false;
m_logging = false;
m_ShowHideToolAxis = false;
m_loggedFrames = 0;
m_SimpleModeEnabled = false;
m_NeedleProjectionFilter = mitk::NeedleProjectionFilter::New();
//create filename for autosaving of tool storage
QString loggingPathWithoutFilename = QString(mitk::LoggingBackend::GetLogFile().c_str());
if (!loggingPathWithoutFilename.isEmpty()) //if there already is a path for the MITK logging file use this one
{
//extract path from path+filename (if someone knows a better way to do this feel free to change it)
int lengthOfFilename = QFileInfo(QString::fromStdString(mitk::LoggingBackend::GetLogFile())).fileName().size();
loggingPathWithoutFilename.resize(loggingPathWithoutFilename.size() - lengthOfFilename);
m_AutoSaveFilename = loggingPathWithoutFilename + "TrackingToolboxAutoSave.IGTToolStorage";
}
else //if not: use a temporary path from IOUtil
{
m_AutoSaveFilename = QString(mitk::IOUtil::GetTempPath().c_str()) + "TrackingToolboxAutoSave.IGTToolStorage";
}
MITK_INFO("IGT Tracking Toolbox") << "Filename for auto saving of IGT ToolStorages: " << m_AutoSaveFilename.toStdString();
//! [Thread 1]
//initialize worker thread
m_WorkerThread = new QThread();
m_Worker = new QmitkMITKIGTTrackingToolboxViewWorker();
//! [Thread 1]
ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
if (pluginContext)
{
QString interfaceName = QString::fromStdString(us_service_interface_iid<mitk::TrackingDeviceTypeCollection>());
QList<ctkServiceReference> serviceReference = pluginContext->getServiceReferences(interfaceName);
if (serviceReference.size() > 0)
{
m_DeviceTypeServiceReference = serviceReference.at(0);
const ctkServiceReference& r = serviceReference.at(0);
m_DeviceTypeCollection = pluginContext->getService<mitk::TrackingDeviceTypeCollection>(r);
}
else
{
MITK_INFO << "No Tracking Device Collection!";
}
}
}
QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
{
this->StoreUISettings();
m_TrackingLoggingTimer->stop();
m_TrackingRenderTimer->stop();
m_TimeoutTimer->stop();
delete m_TrackingLoggingTimer;
delete m_TrackingRenderTimer;
delete m_TimeoutTimer;
try
{
//! [Thread 2]
// wait for thread to finish
m_WorkerThread->terminate();
m_WorkerThread->wait();
//clean up worker thread
if (m_WorkerThread) { delete m_WorkerThread; }
if (m_Worker) { delete m_Worker; }
//! [Thread 2]
//remove the tracking volume
this->GetDataStorage()->Remove(m_TrackingVolumeNode);
//unregister microservices
if (m_toolStorage) { m_toolStorage->UnRegisterMicroservice(); }
if (m_IGTLMessageProvider.IsNotNull()){ m_IGTLMessageProvider->UnRegisterMicroservice(); }
}
catch (std::exception& e) { MITK_WARN << "Unexpected exception during clean up of tracking toolbox view: " << e.what(); }
catch (...) { MITK_WARN << "Unexpected unknown error during clean up of tracking toolbox view!"; }
//store tool storage and UI settings for persistence
this->AutoSaveToolStorage();
this->StoreUISettings();
m_DeviceTypeCollection = nullptr;
mitk::PluginActivator::GetContext()->ungetService(m_DeviceTypeServiceReference);
}
void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl(QWidget *parent)
{
// build up qt view, unless already done
if (!m_Controls)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
m_Controls->setupUi(parent);
//create connections
connect(m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()));
connect(m_Controls->m_ConnectDisconnectButton, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
connect(m_Controls->m_StartStopTrackingButton, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
connect(m_Controls->m_ConnectSimpleMode, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
connect(m_Controls->m_StartTrackingSimpleMode, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
connect(m_Controls->m_FreezeUnfreezeTrackingButton, SIGNAL(clicked()), this, SLOT(OnFreezeUnfreezeTracking()));
connect(m_TrackingLoggingTimer, SIGNAL(timeout()), this, SLOT(UpdateLoggingTrackingTimer()));
connect(m_TrackingRenderTimer, SIGNAL(timeout()), this, SLOT(UpdateRenderTrackingTimer()));
connect(m_TimeoutTimer, SIGNAL(timeout()), this, SLOT(OnTimeOut()));
connect(m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
connect(m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
connect(m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
connect(m_Controls->m_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
connect(m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
connect(m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
connect(m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
connect(m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
connect(m_Controls->m_CsvFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_XmlFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_UseDifferentUpdateRates, SIGNAL(clicked()), this, SLOT(OnToggleDifferentUpdateRates()));
connect(m_Controls->m_RenderUpdateRate, SIGNAL(valueChanged(int)), this, SLOT(OnChangeRenderUpdateRate()));
connect(m_Controls->m_DisableAllTimers, SIGNAL(stateChanged(int)), this, SLOT(EnableDisableTimerButtons(int)));
connect(m_Controls->m_advancedUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
connect(m_Controls->m_SimpleUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
connect(m_Controls->showHideToolProjectionCheckBox, SIGNAL(clicked()), this, SLOT(OnShowHideToolProjectionClicked()));
connect(m_Controls->showHideToolAxisCheckBox, SIGNAL(clicked()), this, SLOT(OnShowHideToolAxisClicked()));
connect(m_Controls->m_toolselector, SIGNAL(currentIndexChanged(int)), this, SLOT(SelectToolProjection(int)));
//connections for the tracking device configuration widget
connect(m_Controls->m_ConfigurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
//! [Thread 3]
//connect worker thread
connect(m_Worker, SIGNAL(AutoDetectToolsFinished(bool, QString)), this, SLOT(OnAutoDetectToolsFinished(bool, QString)));
connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), this, SLOT(OnConnectFinished(bool, QString)));
connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), this, SLOT(OnStartTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), this, SLOT(OnStopTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), this, SLOT(OnDisconnectFinished(bool, QString)));
connect(m_WorkerThread, SIGNAL(started()), m_Worker, SLOT(ThreadFunc()));
connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnConnected(bool)));
connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnDisconnected(bool)));
connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnStartTracking(bool)));
connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnStopTracking(bool)));
//Add Listener, so that we know when the toolStorage changed.
std::string m_Filter = "(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.NavigationToolStorage" + ")";
mitk::PluginActivator::GetContext()->connectServiceListener(this, "OnToolStorageChanged", QString(m_Filter.c_str()));
//move the worker to the thread
m_Worker->moveToThread(m_WorkerThread);
//! [Thread 3]
//initialize widgets
m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
m_Controls->m_simpleWidget->setVisible(false);
//initialize tracking volume node
m_TrackingVolumeNode = mitk::DataNode::New();
m_TrackingVolumeNode->SetName("TrackingVolume");
m_TrackingVolumeNode->SetBoolProperty("Backface Culling", true);
mitk::Color red;
red.SetRed(1);
m_TrackingVolumeNode->SetColor(red);
//initialize buttons
m_Controls->m_AutoDetectTools->setVisible(false); //only visible if supported by tracking device
m_Controls->m_StartStopTrackingButton->setEnabled(false);
m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//initialize warning labels
m_Controls->m_RenderWarningLabel->setVisible(false);
m_Controls->m_TrackingFrozenLabel->setVisible(false);
//Update List of available models for selected tool.
std::vector<mitk::TrackingDeviceData> Compatibles;
if ((m_Controls == nullptr) || //check all these stuff for NULL, latterly this causes crashes from time to time
(m_Controls->m_ConfigurationWidget == nullptr) ||
(m_Controls->m_ConfigurationWidget->GetTrackingDevice().IsNull()))
{
MITK_ERROR << "Couldn't get current tracking device or an object is nullptr, something went wrong!";
return;
}
else
{
Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(m_Controls->m_ConfigurationWidget->GetTrackingDevice()->GetType());
}
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
//initialize tool storage
m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
m_toolStorage->SetName("TrackingToolbox Default Storage");
m_toolStorage->RegisterAsMicroservice();
//set home directory as default path for logfile
m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(QDir::homePath()) + QDir::separator() + "logfile.csv");
//tracking device may be changed already by the persistence of the
//QmitkTrackingDeciveConfigurationWidget
this->OnTrackingDeviceChanged();
this->LoadUISettings();
//add tracking volume node only to data storage
this->GetDataStorage()->Add(m_TrackingVolumeNode);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
//Update List of available models for selected tool.
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
}
void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
{
//read in filename
QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
if (filename.isNull()) return;
//read tool storage from disk
std::string errorMessage = "";
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
// try-catch block for exceptions
try
{
this->ReplaceCurrentToolStorage(myDeserializer->Deserialize(filename.toStdString()), filename.toStdString());
}
catch (mitk::IGTException)
{
std::string errormessage = "Error during loading the tool storage file. Please only load tool storage files created with the NavigationToolManager view.";
QMessageBox::warning(nullptr, "Tool Storage Loading Error", errormessage.c_str());
return;
}
if (m_toolStorage->isEmpty())
{
errorMessage = myDeserializer->GetErrorMessage();
MessageBox(errorMessage);
return;
}
//update label
UpdateToolStorageLabel(filename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
//save filename for persistent storage
m_ToolStorageFilename = filename;
}
void QmitkMITKIGTTrackingToolboxView::OnResetTools()
{
//remove data nodes of surfaces from data storage to clean up
for (unsigned int i = 0; i < m_toolStorage->GetToolCount(); i++)
{
this->GetDataStorage()->Remove(m_toolStorage->GetTool(i)->GetDataNode());
}
this->ReplaceCurrentToolStorage(mitk::NavigationToolStorage::New(GetDataStorage()), "TrackingToolbox Default Storage");
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
QString toolLabel = QString("<none>");
m_Controls->m_ToolLabel->setText(toolLabel);
m_ToolStorageFilename = "";
RemoveAllToolProjections();
}
void QmitkMITKIGTTrackingToolboxView::OnStartStopTracking()
{
if (!m_connected)
{
MITK_WARN << "Can't start tracking if no device is connected. Aborting";
return;
}
if (m_tracking) { OnStopTracking(); }
else { OnStartTracking(); }
}
void QmitkMITKIGTTrackingToolboxView::OnFreezeUnfreezeTracking()
{
if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Freeze Tracking")
{
m_Worker->GetTrackingDeviceSource()->Freeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Unfreeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(true);
}
else if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Unfreeze Tracking")
{
m_Worker->GetTrackingDeviceSource()->UnFreeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
}
}
void QmitkMITKIGTTrackingToolboxView::ShowToolProjection(int index)
{
mitk::DataNode::Pointer toolnode = m_toolStorage->GetTool(index)->GetDataNode();
QString ToolProjectionName = "ToolProjection" + QString::number(index);
m_ToolProjectionNode = this->GetDataStorage()->GetNamedNode(ToolProjectionName.toStdString());
//If node does not exist, create the node for the Pointset
if (m_ToolProjectionNode.IsNull())
{
m_ToolProjectionNode = mitk::DataNode::New();
m_ToolProjectionNode->SetName(ToolProjectionName.toStdString());
if (index < static_cast<int>(m_NeedleProjectionFilter->GetNumberOfInputs()))
{
m_NeedleProjectionFilter->SelectInput(index);
m_NeedleProjectionFilter->Update();
m_ToolProjectionNode->SetData(m_NeedleProjectionFilter->GetProjection());
m_ToolProjectionNode->SetBoolProperty("show contour", true);
this->GetDataStorage()->Add(m_ToolProjectionNode, toolnode);
}
// this->FireNodeSelected(node);
}
else
{
m_ToolProjectionNode->SetBoolProperty("show contour", true);
}
}
void QmitkMITKIGTTrackingToolboxView::RemoveAllToolProjections()
{
for (size_t i = 0; i < m_toolStorage->GetToolCount(); i++)
{
QString toolProjectionName = "ToolProjection" + QString::number(i);
mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(toolProjectionName.toStdString());
//Deactivate and hide the tool projection
if (!node.IsNull())
{
this->GetDataStorage()->Remove(node);
}
}
}
void QmitkMITKIGTTrackingToolboxView::SelectToolProjection(int idx)
{
if (m_Controls->showHideToolProjectionCheckBox->isChecked())
{
//Deactivate and hide the tool projection
if (!m_ToolProjectionNode.IsNull())
{
this->GetDataStorage()->Remove(m_ToolProjectionNode);
}
if (m_NeedleProjectionFilter.IsNotNull())
{
m_NeedleProjectionFilter->Update();
}
//Refresh the view and the status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// Show the tool projection for the currently selected tool
ShowToolProjection(idx);
}
}
void QmitkMITKIGTTrackingToolboxView::OnShowHideToolProjectionClicked()
{
int index = m_Controls->m_toolselector->currentIndex();
//Activate and show the tool projection
if (m_Controls->showHideToolProjectionCheckBox->isChecked())
{
ShowToolProjection(index);
m_Controls->showHideToolAxisCheckBox->setEnabled(true);
}
else
{
RemoveAllToolProjections();
m_Controls->showHideToolAxisCheckBox->setEnabled(false);
}
if( m_NeedleProjectionFilter.IsNotNull() )
{
m_NeedleProjectionFilter->Update();
}
//Refresh the view and the status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnShowHideToolAxisClicked()
{
if( !m_ShowHideToolAxis )
{
//Activate and show the tool axis
m_NeedleProjectionFilter->ShowToolAxis(true);
m_ShowHideToolAxis = true;
}
else
{
//Deactivate and hide the tool axis
m_NeedleProjectionFilter->ShowToolAxis(false);
m_NeedleProjectionFilter->GetProjection()->RemovePointIfExists(2);
m_ShowHideToolAxis = false;
}
//Update the filter
if( m_NeedleProjectionFilter.IsNotNull() )
{
m_NeedleProjectionFilter->Update();
}
//Refresh the view and the status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnConnectDisconnect()
{
if (m_connected) { OnDisconnect(); }
else { OnConnect(); }
}
void QmitkMITKIGTTrackingToolboxView::OnConnect()
{
MITK_DEBUG << "Connect Clicked";
//check if everything is ready to start tracking
if (this->m_toolStorage.IsNull())
{
MessageBox("Error: No Tools Loaded Yet!");
return;
}
else if (this->m_toolStorage->GetToolCount() == 0)
{
MessageBox("Error: No Way To Track Without Tools!");
return;
}
//parse tracking device data
mitk::TrackingDeviceData data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
QString qstr = m_Controls->m_VolumeSelectionBox->currentText();
if ((!qstr.isNull()) || (!qstr.isEmpty())) {
std::string str = qstr.toStdString();
data = m_DeviceTypeCollection->GetDeviceDataByName(str); //Data will be set later, after device generation
}
//! [Thread 4]
//initialize worker thread
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eConnectDevice);
m_Worker->SetTrackingDevice(this->m_Controls->m_ConfigurationWidget->GetTrackingDevice());
m_Worker->SetInverseMode(m_Controls->m_InverseMode->isChecked());
m_Worker->SetNavigationToolStorage(this->m_toolStorage);
m_Worker->SetTrackingDeviceData(data);
//start worker thread
m_WorkerThread->start();
//! [Thread 4]
//disable buttons
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableDisableTimerButtons(int enable)
{
bool enableBool = enable;
m_Controls->m_UpdateRateOptionsGroupBox->setEnabled(!enableBool);
m_Controls->m_RenderWarningLabel->setVisible(enableBool);
}
void QmitkMITKIGTTrackingToolboxView::OnConnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
//enable buttons
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//! [Thread 6]
//get data from worker thread
m_TrackingDeviceData = m_Worker->GetTrackingDeviceData();
m_ToolVisualizationFilter = m_Worker->GetToolVisualizationFilter();
if( m_ToolVisualizationFilter.IsNotNull() )
{
//Connect the NeedleProjectionFilter to the ToolVisualizationFilter as third filter of the IGT pipeline
m_NeedleProjectionFilter->ConnectTo(m_ToolVisualizationFilter);
if (m_Controls->showHideToolProjectionCheckBox->isChecked())
{
ShowToolProjection(m_Controls->m_toolselector->currentIndex());
}
}
//! [Thread 6]
//enable/disable Buttons
DisableOptionsButtons();
DisableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: connected");
m_Controls->m_ConnectDisconnectButton->setText("Disconnect");
m_Controls->m_ConnectSimpleMode->setText("Disconnect");
m_Controls->m_StartStopTrackingButton->setEnabled(true);
m_Controls->m_StartTrackingSimpleMode->setEnabled(true);
m_connected = true;
//During connection, thi sourceID of the tool storage changed. However, Microservice can't be updated on a different thread.
//UpdateMicroservice is necessary to use filter to get the right storage belonging to a source.
//Don't do it before m_connected is true, as we don't want to call content of OnToolStorageChanged.
m_toolStorage->UpdateMicroservice();
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
{
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eDisconnectDevice);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//enable/disable Buttons
m_Controls->m_StartStopTrackingButton->setEnabled(false);
m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
EnableOptionsButtons();
EnableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
m_Controls->m_ConnectDisconnectButton->setText("Connect");
m_Controls->m_ConnectSimpleMode->setText("Connect");
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
m_connected = false;
}
void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
{
//show tracking volume
this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
//Reset the view to a defined start. Do it here and not in OnStartTrackingFinished, to give other tracking devices the chance to reset the view to a different direction.
this->GlobalReinit();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStartTracking);
m_WorkerThread->start();
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStartTrackingFinished(bool success, QString errorMessage)
{
//! [Thread 5]
m_WorkerThread->quit();
m_WorkerThread->wait();
//! [Thread 5]
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
-
+ mitk::RenderingManager::GetInstance()->StartContinousUpdating(m_Controls->m_RenderUpdateRate->value());
if (!(m_Controls->m_DisableAllTimers->isChecked()))
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() != 0)
m_TrackingRenderTimer->start(1000 / (m_Controls->m_RenderUpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_LogUpdateRate->value()));
}
else
{
m_TrackingRenderTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
}
}
m_Controls->m_TrackingControlLabel->setText("Status: tracking");
//connect the tool visualization widget
for (std::size_t i = 0; i < m_Worker->GetTrackingDeviceSource()->GetNumberOfOutputs(); i++)
{
m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_Worker->GetTrackingDeviceSource()->GetOutput(i));
}
m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
if (m_Controls->m_ShowToolQuaternions->isChecked()) { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true); }
else { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false); }
//if activated enable open IGT link microservice
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
//create convertion filter
m_IGTLConversionFilter = mitk::NavigationDataToIGTLMessageFilter::New();
m_IGTLConversionFilter->SetName("IGT Tracking Toolbox");
QString dataModeSelection = this->m_Controls->m_OpenIGTLinkDataFormat->currentText();
if (dataModeSelection == "TDATA")
{
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);
}
else if (dataModeSelection == "TRANSFORM")
{
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTransMsg);
}
else if (dataModeSelection == "QTDATA")
{
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTDataMsg);
}
else if (dataModeSelection == "POSITION")
{
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTransMsg);
}
m_IGTLConversionFilter->ConnectTo(m_ToolVisualizationFilter);
m_IGTLConversionFilter->RegisterAsMicroservice();
//create server and message provider
m_IGTLServer = mitk::IGTLServer::New(false);
m_IGTLServer->SetName("Tracking Toolbox IGTL Server");
m_IGTLMessageProvider = mitk::IGTLMessageProvider::New();
m_IGTLMessageProvider->SetIGTLDevice(m_IGTLServer);
m_IGTLMessageProvider->RegisterAsMicroservice();
}
m_tracking = true;
m_Controls->m_ConnectDisconnectButton->setEnabled(false);
m_Controls->m_StartStopTrackingButton->setText("Stop Tracking");
m_Controls->m_StartTrackingSimpleMode->setText("Stop\nTracking");
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
{
if (!m_tracking) return;
for (unsigned int i = 0; i < m_ToolVisualizationFilter->GetNumberOfIndexedOutputs(); i++)
{
mitk::NavigationData::Pointer currentTool = m_ToolVisualizationFilter->GetOutput(i);
if (currentTool->IsDataValid())
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_INVALID);
}
}
//refresh view and status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_TrackingRenderTimer->stop();
m_TrackingLoggingTimer->stop();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStopTracking);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTrackingFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
m_Controls->m_TrackingControlLabel->setText("Status: connected");
if (m_logging) StopLogging();
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_tracking = false;
m_Controls->m_StartStopTrackingButton->setText("Start Tracking");
m_Controls->m_StartTrackingSimpleMode->setText("Start\nTracking");
m_Controls->m_ConnectDisconnectButton->setEnabled(true);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//unregister open IGT link micro service
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
m_IGTLConversionFilter->UnRegisterMicroservice();
m_IGTLMessageProvider->UnRegisterMicroservice();
}
+
+ //mitk::RenderingManager::GetInstance()->StopContinousUpdating();
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
{
mitk::TrackingDeviceType Type;
if (m_Controls->m_ConfigurationWidget->GetTrackingDevice().IsNotNull())
{
Type = m_Controls->m_ConfigurationWidget->GetTrackingDevice()->GetType();
//enable controls because device is valid
m_Controls->m_TrackingToolsFrame->setEnabled(true);
m_Controls->m_TrackingControlsFrame->setEnabled(true);
}
else
{
Type = mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
MessageBox("Error: This tracking device is not included in this project. Please make sure that the device is installed and activated in your MITK build.");
m_Controls->m_TrackingToolsFrame->setEnabled(false);
m_Controls->m_TrackingControlsFrame->setEnabled(false);
return;
}
// Code to enable/disable device specific buttons
if (m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
{
m_Controls->m_AutoDetectTools->setVisible(true);
}
else
{
m_Controls->m_AutoDetectTools->setVisible(false);
}
m_Controls->m_AddSingleTool->setEnabled(this->m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AddSingleToolIsAvailable());
// Code to select appropriate tracking volume for current type
std::vector<mitk::TrackingDeviceData> Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(Type);
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
{
if (qstr.isNull()) return;
if (qstr.isEmpty()) return;
mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
std::string str = qstr.toStdString();
mitk::TrackingDeviceData data = m_DeviceTypeCollection->GetDeviceDataByName(str);
m_TrackingDeviceData = data;
volumeGenerator->SetTrackingDeviceData(data);
volumeGenerator->Update();
mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
m_TrackingVolumeNode->SetData(volumeSurface);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
{
if (m_Controls->m_ShowTrackingVolume->isChecked())
{
OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
m_TrackingVolumeNode->SetOpacity(0.25);
}
else
{
m_TrackingVolumeNode->SetOpacity(0.0);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
{
if (m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
{
DisableTrackingConfigurationButtons();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eAutoDetectTools);
m_Worker->SetTrackingDevice(m_Controls->m_ConfigurationWidget->GetTrackingDevice().GetPointer());
m_Worker->SetDataStorage(this->GetDataStorage());
m_WorkerThread->start();
m_TimeoutTimer->start(30000);
//disable controls until worker thread is finished
this->m_Controls->m_MainWidget->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectToolsFinished(bool success, QString errorMessage)
{
//Check, if the thread is running. There might have been a timeOut inbetween and this causes crashes...
if (m_WorkerThread->isRunning())
{
m_TimeoutTimer->stop();
m_WorkerThread->quit();
m_WorkerThread->wait();
}
//enable controls again
this->m_Controls->m_MainWidget->setEnabled(true);
EnableTrackingConfigurationButtons();
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
EnableTrackingConfigurationButtons();
return;
}
mitk::NavigationToolStorage::Pointer autoDetectedStorage = m_Worker->GetNavigationToolStorage();
//save detected tools
std::string _autoDetectText;
_autoDetectText = "Autodetected ";
_autoDetectText.append(this->m_TrackingDeviceData.Line); //This is the device name as string of the current TrackingDevice.
_autoDetectText.append(" Storage");
this->ReplaceCurrentToolStorage(autoDetectedStorage, _autoDetectText);
//auto save the new storage to hard disc (for persistence)
AutoSaveToolStorage();
//update label
QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
m_Controls->m_ToolLabel->setText(toolLabel);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
EnableTrackingConfigurationButtons();
//print a logging message about the detected tools
switch (m_toolStorage->GetToolCount())
{
case 0:
MITK_INFO("IGT Tracking Toolbox") << "Found no tools. Empty ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
case 1:
MITK_INFO("IGT Tracking Toolbox") << "Found one tool. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
default:
MITK_INFO("IGT Tracking Toolbox") << "Found " << m_toolStorage->GetToolCount() << " tools. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
}
}
void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkMITKIGTTrackingToolboxView::UpdateRenderTrackingTimer()
{
//update filter
m_ToolVisualizationFilter->Update();
MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
//update tool colors to show tool status
for (unsigned int i = 0; i < m_ToolVisualizationFilter->GetNumberOfIndexedOutputs(); i++)
{
mitk::NavigationData::Pointer currentTool = m_ToolVisualizationFilter->GetOutput(i);
if (currentTool->IsDataValid())
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_VALID);
}
else
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_WARNING);
}
}
//Update the NeedleProjectionFilter
if( m_NeedleProjectionFilter.IsNotNull() )
{
m_NeedleProjectionFilter->Update();
}
//refresh view and status widget
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::UpdateLoggingTrackingTimer()
{
//update logging
if (m_logging)
{
this->m_loggingFilter->Update();
m_loggedFrames = this->m_loggingFilter->GetNumberOfRecordedSteps();
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: " + QString::number(m_loggedFrames));
//check if logging stopped automatically
if ((m_loggedFrames > 1) && (!m_loggingFilter->GetRecording())){ StopLogging(); }
}
//refresh status widget
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
{
QDir currentPath = QFileInfo(m_Controls->m_LoggingFileName->text()).dir();
// if no path was selected (QDir would select current working dir then) or the
// selected path does not exist -> use home directory
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir(QDir::homePath());
}
QString filename = QFileDialog::getSaveFileName(nullptr, tr("Choose Logging File"), currentPath.absolutePath(), "*.*");
if (filename == "") return;
this->m_Controls->m_LoggingFileName->setText(filename);
this->OnToggleFileExtension();
}
// bug-16470: toggle file extension after clicking on radio button
void QmitkMITKIGTTrackingToolboxView::OnToggleFileExtension()
{
QString currentInputText = this->m_Controls->m_LoggingFileName->text();
QString currentFile = QFileInfo(currentInputText).baseName();
QDir currentPath = QFileInfo(currentInputText).dir();
if (currentFile.isEmpty())
{
currentFile = "logfile";
}
// Setting currentPath to default home path when currentPath is empty or it does not exist
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir::homePath();
}
// check if csv radio button is clicked
if (this->m_Controls->m_CsvFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".csv");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".csv");
}
}
// check if xml radio button is clicked
else if (this->m_Controls->m_XmlFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".xml");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".xml");
}
}
}
void QmitkMITKIGTTrackingToolboxView::OnToggleAdvancedSimpleMode()
{
if (m_SimpleModeEnabled)
{
m_Controls->m_simpleWidget->setVisible(false);
m_Controls->m_MainWidget->setVisible(true);
m_Controls->m_SimpleUI->setChecked(false);
m_SimpleModeEnabled = false;
}
else
{
m_Controls->m_simpleWidget->setVisible(true);
m_Controls->m_MainWidget->setVisible(false);
m_SimpleModeEnabled = true;
}
}
void QmitkMITKIGTTrackingToolboxView::OnToggleDifferentUpdateRates()
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_RenderWarningLabel->setVisible(true);
else
m_Controls->m_RenderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(true);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(true);
m_Controls->m_LogUpdateRate->setEnabled(true);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(true);
}
else
{
m_Controls->m_RenderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(true);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnChangeRenderUpdateRate()
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_RenderWarningLabel->setVisible(true);
else
m_Controls->m_RenderWarningLabel->setVisible(false);
}
void QmitkMITKIGTTrackingToolboxView::StartLogging()
{
if (m_ToolVisualizationFilter.IsNull())
{
MessageBox("Cannot activate logging without a connected device. Configure and connect a tracking device first.");
return;
}
if (!m_logging)
{
//initialize logging filter
m_loggingFilter = mitk::NavigationDataRecorder::New();
m_loggingFilter->SetRecordOnlyValidData(m_Controls->m_SkipInvalidData->isChecked());
m_loggingFilter->ConnectTo(m_ToolVisualizationFilter);
if (m_Controls->m_LoggingLimit->isChecked()){ m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value()); }
//start filter with try-catch block for exceptions
try
{
m_loggingFilter->StartRecording();
}
catch (mitk::IGTException)
{
std::string errormessage = "Error during start recording. Recorder already started recording?";
QMessageBox::warning(nullptr, "IGTPlayer: Error", errormessage.c_str());
m_loggingFilter->StopRecording();
return;
}
//update labels / logging variables
this->m_Controls->m_LoggingLabel->setText("Logging ON");
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
m_loggedFrames = 0;
m_logging = true;
DisableLoggingButtons();
}
}
void QmitkMITKIGTTrackingToolboxView::StopLogging()
{
if (m_logging)
{
//stop logging
m_loggingFilter->StopRecording();
m_logging = false;
//update GUI
this->m_Controls->m_LoggingLabel->setText("Logging OFF");
EnableLoggingButtons();
//write the results to a file
if (m_Controls->m_CsvFormat->isChecked())
{
mitk::IOUtil::Save(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
}
else if (m_Controls->m_XmlFormat->isChecked())
{
mitk::IOUtil::Save(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
}
}
}
void QmitkMITKIGTTrackingToolboxView::SetFocus()
{
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
{
QString Identifier = "Tool#";
QString Name = "NewTool";
if (m_toolStorage.IsNotNull()) {
Identifier += QString::number(m_toolStorage->GetToolCount());
Name += QString::number(m_toolStorage->GetToolCount());
}
else {
Identifier += "0";
Name += "0";
}
m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(), Identifier.toStdString(), Name.toStdString());
m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_ConfigurationWidget->GetTrackingDevice()->GetType(), false);
m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
//disable tracking volume during tool editing
lastTrackingVolumeState = m_Controls->m_ShowTrackingVolume->isChecked();
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
if (this->m_toolStorage.IsNull())
{
//this shouldn't happen!
MITK_WARN << "No ToolStorage available, cannot add tool, aborting!";
return;
}
m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_Controls->m_ToolLabel->setText("<manually added>");
//displya in tool selector
// m_Controls->m_toolselector->addItem(QString::fromStdString(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool()->GetToolName()));
//auto save current storage for persistence
MITK_INFO << "Auto saving manually added tools for persistence.";
AutoSaveToolStorage();
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
{
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
auto bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(false);
m_Controls->m_LoggingFileName->setEnabled(false);
m_Controls->m_ChooseFile->setEnabled(false);
m_Controls->m_LoggingLimit->setEnabled(false);
m_Controls->m_LoggedFramesLimit->setEnabled(false);
m_Controls->m_CsvFormat->setEnabled(false);
m_Controls->m_XmlFormat->setEnabled(false);
m_Controls->m_SkipInvalidData->setEnabled(false);
m_Controls->m_StopLogging->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(true);
m_Controls->m_LoggingFileName->setEnabled(true);
m_Controls->m_ChooseFile->setEnabled(true);
m_Controls->m_LoggingLimit->setEnabled(true);
m_Controls->m_LoggedFramesLimit->setEnabled(true);
m_Controls->m_CsvFormat->setEnabled(true);
m_Controls->m_XmlFormat->setEnabled(true);
m_Controls->m_SkipInvalidData->setEnabled(true);
m_Controls->m_StopLogging->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(false);
m_Controls->m_UseDifferentUpdateRates->setEnabled(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
m_Controls->m_DisableAllTimers->setEnabled(false);
m_Controls->m_OtherOptionsGroupBox->setEnabled(false);
m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(false);
m_Controls->m_OpenIGTLinkDataFormat->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(true);
m_Controls->m_UseDifferentUpdateRates->setEnabled(true);
m_Controls->m_DisableAllTimers->setEnabled(true);
m_Controls->m_OtherOptionsGroupBox->setEnabled(true);
m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(true);
m_Controls->m_OpenIGTLinkDataFormat->setEnabled(true);
OnToggleDifferentUpdateRates();
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingControls()
{
m_Controls->m_TrackingControlsFrame->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingControls()
{
m_Controls->m_TrackingControlsFrame->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(true);
m_Controls->m_AddSingleTool->setEnabled(this->m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AddSingleToolIsAvailable());
m_Controls->m_LoadTools->setEnabled(true);
m_Controls->m_ResetTools->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(false);
m_Controls->m_AddSingleTool->setEnabled(false);
m_Controls->m_LoadTools->setEnabled(false);
m_Controls->m_ResetTools->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName)
{
//first: get rid of the old one
//don't reset if there is no tool storage. BugFix #17793
if (m_toolStorage.IsNotNull()){
m_toolStorage->UnLockStorage(); //only to be sure...
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = nullptr;
}
//now: replace by the new one
m_toolStorage = newStorage;
m_toolStorage->SetName(newStorageName);
m_toolStorage->RegisterAsMicroservice();
}
void QmitkMITKIGTTrackingToolboxView::OnTimeOut()
{
MITK_WARN << "TimeOut. Quitting the thread...";
m_WorkerThread->quit();
//only if we can't quit use terminate.
if (!m_WorkerThread->wait(1000))
{
MITK_ERROR << "Can't quit the thread. Terminating... Might cause further problems, be careful!";
m_WorkerThread->terminate();
m_WorkerThread->wait();
}
m_TimeoutTimer->stop();
}
void QmitkMITKIGTTrackingToolboxView::OnToolStorageChanged(const ctkServiceEvent event)
{
//don't listen to any changes during connection, toolStorage is locked anyway, so this are only changes of e.g. sourceID which are not relevant for the widget.
if (!m_connected && (event.getType() == ctkServiceEvent::MODIFIED))
{
m_Controls->m_ConfigurationWidget->OnToolStorageChanged();
m_Controls->m_toolselector->clear();
for (size_t i = 0; i < m_toolStorage->GetToolCount(); i++)
{
m_Controls->m_toolselector->addItem(QString::fromStdString(m_toolStorage->GetTool(i)->GetToolName()));
}
}
}
//! [StoreUISettings]
void QmitkMITKIGTTrackingToolboxView::StoreUISettings()
{
// persistence service does not directly work in plugins for now
// -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
MITK_DEBUG << "Store UI settings";
// set the values of some widgets and attrbutes to the QSettings
settings.setValue("ShowTrackingVolume", QVariant(m_Controls->m_ShowTrackingVolume->isChecked()));
settings.setValue("toolStorageFilename", QVariant(m_ToolStorageFilename));
settings.setValue("VolumeSelectionBox", QVariant(m_Controls->m_VolumeSelectionBox->currentIndex()));
settings.setValue("SimpleModeEnabled", QVariant(m_SimpleModeEnabled));
settings.setValue("OpenIGTLinkDataFormat", QVariant(m_Controls->m_OpenIGTLinkDataFormat->currentIndex()));
settings.setValue("EnableOpenIGTLinkMicroService", QVariant(m_Controls->m_EnableOpenIGTLinkMicroService->isChecked()));
settings.endGroup();
}
//! [StoreUISettings]
//! [LoadUISettings]
void QmitkMITKIGTTrackingToolboxView::LoadUISettings()
{
// persistence service does not directly work in plugins for now -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
// set some widgets and attributes by the values from the QSettings
m_Controls->m_ShowTrackingVolume->setChecked(settings.value("ShowTrackingVolume", false).toBool());
m_Controls->m_EnableOpenIGTLinkMicroService->setChecked(settings.value("EnableOpenIGTLinkMicroService", true).toBool());
m_Controls->m_VolumeSelectionBox->setCurrentIndex(settings.value("VolumeSelectionBox", 0).toInt());
m_Controls->m_OpenIGTLinkDataFormat->setCurrentIndex(settings.value("OpenIGTLinkDataFormat", 0).toInt());
m_ToolStorageFilename = settings.value("toolStorageFilename", QVariant("")).toString();
if (settings.value("SimpleModeEnabled", false).toBool()) { this->OnToggleAdvancedSimpleMode(); }
settings.endGroup();
//! [LoadUISettings]
//! [LoadToolStorage]
// try to deserialize the tool storage from the given tool storage file name
if (!m_ToolStorageFilename.isEmpty())
{
// try-catch block for exceptions
try
{
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = myDeserializer->Deserialize(m_ToolStorageFilename.toStdString());
m_toolStorage->RegisterAsMicroservice();
//update label
UpdateToolStorageLabel(m_ToolStorageFilename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
}
catch (mitk::IGTException e)
{
MITK_WARN("QmitkMITKIGTTrackingToolBoxView") << "Error during restoring tools. Problems with file (" << m_ToolStorageFilename.toStdString() << "), please check the file? Error message: "<<e.GetDescription();
this->OnResetTools(); //if there where errors reset the tool storage to avoid problems later on
}
}
//! [LoadToolStorage]
}
void QmitkMITKIGTTrackingToolboxView::UpdateToolStorageLabel(QString pathOfLoadedStorage)
{
QFileInfo myPath(pathOfLoadedStorage); //use this to seperate filename from path
QString toolLabel = myPath.fileName();
if (toolLabel.size() > 45) //if the tool storage name is to long trimm the string
{
toolLabel.resize(40);
toolLabel += "[...]";
}
m_Controls->m_ToolLabel->setText(toolLabel);
}
void QmitkMITKIGTTrackingToolboxView::AutoSaveToolStorage()
{
m_ToolStorageFilename = m_AutoSaveFilename;
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
mySerializer->Serialize(m_ToolStorageFilename.toStdString(), m_toolStorage);
}
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/QmitkUltrasoundSupport.cpp b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/QmitkUltrasoundSupport.cpp
index 51f6110989..d7eec02f4d 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/QmitkUltrasoundSupport.cpp
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/QmitkUltrasoundSupport.cpp
@@ -1,533 +1,535 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
//Mitk
#include <mitkDataNode.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkIRenderingManager.h>
#include <mitkImageGenerator.h>
// Qmitk
#include "QmitkUltrasoundSupport.h"
// Qt
#include <QMessageBox>
#include <QSettings>
#include <QTimer>
// Ultrasound
#include "mitkUSDevice.h"
#include "QmitkUSAbstractCustomWidget.h"
#include <usModuleContext.h>
#include <usGetModuleContext.h>
#include "usServiceReference.h"
#include "internal/org_mitk_gui_qt_ultrasound_Activator.h"
const std::string QmitkUltrasoundSupport::VIEW_ID = "org.mitk.views.ultrasoundsupport";
QmitkUltrasoundSupport::QmitkUltrasoundSupport()
: m_Controls(nullptr), m_ControlCustomWidget(0), m_ControlBModeWidget(0),
m_ControlProbesWidget(0), m_ImageAlreadySetToNode(false),
m_CurrentImageWidth(0), m_CurrentImageHeight(0)
{
ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
if (pluginContext)
{
// to be notified about service event of an USDevice
pluginContext->connectServiceListener(this, "OnDeviceServiceEvent",
QString::fromStdString("(" + us::ServiceConstants::OBJECTCLASS() + "=" + us_service_interface_iid<mitk::USDevice>() + ")"));
}
}
QmitkUltrasoundSupport::~QmitkUltrasoundSupport()
{
try
{
StoreUISettings();
StopTimers();
// Get all active devicesand deactivate them to prevent freeze
std::vector<mitk::USDevice*> devices = this->m_Controls->m_ActiveVideoDevices->GetAllServices<mitk::USDevice>();
for (size_t i = 0; i < devices.size(); i++)
{
mitk::USDevice::Pointer device = devices[i];
if (device.IsNotNull() && device->GetIsActive())
{
device->Deactivate();
device->Disconnect();
}
}
}
catch (std::exception &e)
{
MITK_ERROR << "Exception during call of destructor! Message: " << e.what();
}
}
void QmitkUltrasoundSupport::SetFocus()
{
}
void QmitkUltrasoundSupport::CreateQtPartControl(QWidget *parent)
{
//initialize timers
m_UpdateTimer = new QTimer(this);
m_RenderingTimer2d = new QTimer(this);
m_RenderingTimer3d = new QTimer(this);
// build up qt view, unless already done
if (!m_Controls)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::UltrasoundSupportControls;
// create GUI widgets from the Qt Designer's .ui file
m_Controls->setupUi(parent);
//load persistence data before connecting slots (so no slots are called in this phase...)
LoadUISettings();
//connect signals and slots...
connect(m_Controls->m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this, SLOT(OnClickedAddNewDevice())); // Change Widget Visibilities
connect(m_Controls->m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this->m_Controls->m_NewVideoDeviceWidget, SLOT(CreateNewDevice())); // Init NewDeviceWidget
connect(m_Controls->m_ActiveVideoDevices, SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(OnChangedActiveDevice()));
connect(m_Controls->m_RunImageTimer, SIGNAL(clicked()), this, SLOT(OnChangedActiveDevice()));
connect(m_Controls->m_ShowImageStream, SIGNAL(clicked()), this, SLOT(OnChangedActiveDevice()));
connect(m_Controls->m_NewVideoDeviceWidget, SIGNAL(Finished()), this, SLOT(OnNewDeviceWidgetDone())); // After NewDeviceWidget finished editing
connect(m_Controls->m_FrameRatePipeline, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit()));
connect(m_Controls->m_FrameRate2d, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit()));
connect(m_Controls->m_FrameRate3d, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit()));
connect(m_Controls->m_FreezeButton, SIGNAL(clicked()), this, SLOT(OnClickedFreezeButton()));
connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(UpdateImage()));
connect(m_RenderingTimer2d, SIGNAL(timeout()), this, SLOT(RenderImage2d()));
connect(m_RenderingTimer3d, SIGNAL(timeout()), this, SLOT(RenderImage3d()));
connect(m_Controls->m_Update2DView, SIGNAL(clicked()), this, SLOT(StartTimers()));
connect(m_Controls->m_Update3DView, SIGNAL(clicked()), this, SLOT(StartTimers()));
connect(m_Controls->m_DeviceManagerWidget, SIGNAL(EditDeviceButtonClicked(mitk::USDevice::Pointer)), this, SLOT(OnClickedEditDevice())); //Change Widget Visibilities
connect(m_Controls->m_DeviceManagerWidget, SIGNAL(EditDeviceButtonClicked(mitk::USDevice::Pointer)), this->m_Controls->m_NewVideoDeviceWidget, SLOT(EditDevice(mitk::USDevice::Pointer)));
// Initializations
m_Controls->m_NewVideoDeviceWidget->setVisible(false);
std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "="
+ "org.mitk.services.UltrasoundDevice)("
+ mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISACTIVE + "=true))";
m_Controls->m_ActiveVideoDevices->Initialize<mitk::USDevice>(
mitk::USDevice::GetPropertyKeys().US_PROPKEY_LABEL, filter);
m_Controls->m_ActiveVideoDevices->SetAutomaticallySelectFirstEntry(true);
m_FrameCounterPipeline = 0;
m_FrameCounter2d = 0;
m_FrameCounter3d = 0;
m_Controls->tabWidget->setTabEnabled(1, false);
}
}
void QmitkUltrasoundSupport::OnClickedAddNewDevice()
{
m_Controls->m_NewVideoDeviceWidget->setVisible(true);
m_Controls->m_DeviceManagerWidget->setVisible(false);
m_Controls->m_Headline->setText("Add New Video Device:");
m_Controls->m_WidgetActiveDevices->setVisible(false);
}
void QmitkUltrasoundSupport::OnClickedEditDevice()
{
m_Controls->m_NewVideoDeviceWidget->setVisible(true);
m_Controls->m_DeviceManagerWidget->setVisible(false);
m_Controls->m_WidgetActiveDevices->setVisible(false);
m_Controls->m_Headline->setText("Edit Video Device:");
}
void QmitkUltrasoundSupport::UpdateImage()
{
//Update device
m_Device->Modified();
m_Device->Update();
//Only update the view if the image is shown
if (m_Controls->m_ShowImageStream->isChecked())
{
//Update data nodes
for (size_t i = 0; i < m_AmountOfOutputs; i++)
{
mitk::Image::Pointer curOutput = m_Device->GetOutput(i);
if (curOutput->IsEmpty())
{
m_Node.at(i)->SetName("No Data received yet ...");
//create a noise image for correct initialization of level window, etc.
mitk::Image::Pointer randomImage = mitk::ImageGenerator::GenerateRandomImage<float>(32, 32, 1, 1, 1, 1, 1, 255, 0);
m_Node.at(i)->SetData(randomImage);
curOutput->SetGeometry(randomImage->GetGeometry());
}
else
{
std::stringstream nodeName;
nodeName << "US Viewing Stream - Image " << i;
m_Node.at(i)->SetName(nodeName.str());
m_Node.at(i)->SetData(curOutput);
m_Node.at(i)->Modified();
}
// if the geometry changed: reinitialize the ultrasound image
if ((i==0) && (m_OldGeometry.IsNotNull()) &&
(curOutput->GetGeometry() != NULL) &&
(!mitk::Equal(*(m_OldGeometry.GetPointer()), *(curOutput->GetGeometry()), 0.0001, false))
)
{
mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
if ((renderWindow != NULL) && (curOutput->GetTimeGeometry()->IsValid()) && (m_Controls->m_ShowImageStream->isChecked()))
{
renderWindow->GetRenderingManager()->InitializeViews(
curOutput->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
- renderWindow->GetRenderingManager()->RequestUpdateAll();
+ //renderWindow->GetRenderingManager()->RequestUpdateAll();
}
m_CurrentImageWidth = curOutput->GetDimension(0);
m_CurrentImageHeight = curOutput->GetDimension(1);
m_OldGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(curOutput->GetGeometry());
}
}
}
//Update frame counter
m_FrameCounterPipeline++;
if (m_FrameCounterPipeline >0)
{
//compute framerate of pipeline update
int nMilliseconds = m_Clock.restart();
int fps = 1000.0 / nMilliseconds;
m_FPSPipeline = fps;
m_FrameCounterPipeline = 0;
//display lowest framerate in UI
int lowestFPS = m_FPSPipeline;
if (m_Controls->m_Update2DView->isChecked() && (m_FPS2d < lowestFPS)) { lowestFPS = m_FPS2d; }
if (m_Controls->m_Update3DView->isChecked() && (m_FPS3d < lowestFPS)) { lowestFPS = m_FPS3d; }
m_Controls->m_FramerateLabel->setText("Current Framerate: " + QString::number(lowestFPS) + " FPS");
}
}
void QmitkUltrasoundSupport::RenderImage2d()
{
if (!m_Controls->m_Update2DView->isChecked())
return;
- this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
+ //this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
m_FrameCounter2d++;
if (m_FrameCounter2d >0)
{
//compute framerate of 2d render window update
int nMilliseconds = m_Clock2d.restart();
int fps = 1000.0f / (nMilliseconds);
m_FPS2d = fps;
m_FrameCounter2d = 0;
}
}
void QmitkUltrasoundSupport::RenderImage3d()
{
if (!m_Controls->m_Update3DView->isChecked())
return;
- this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
+ //this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
m_FrameCounter3d++;
if (m_FrameCounter3d >0)
{
//compute framerate of 2d render window update
int nMilliseconds = m_Clock3d.restart();
int fps = 1000.0f / (nMilliseconds);
m_FPS3d = fps;
m_FrameCounter3d = 0;
}
}
void QmitkUltrasoundSupport::OnChangedFramerateLimit()
{
StopTimers();
int intervalPipeline = (1000 / m_Controls->m_FrameRatePipeline->value());
int interval2D = (1000 / m_Controls->m_FrameRate2d->value());
int interval3D = (1000 / m_Controls->m_FrameRate3d->value());
SetTimerIntervals(intervalPipeline, interval2D, interval3D);
StartTimers();
}
void QmitkUltrasoundSupport::OnClickedFreezeButton()
{
if (m_Device.IsNull())
{
MITK_WARN("UltrasoundSupport") << "Freeze button clicked though no device is selected.";
return;
}
if (m_Device->GetIsFreezed())
{
m_Device->SetIsFreezed(false);
m_Controls->m_FreezeButton->setText("Freeze");
}
else
{
m_Device->SetIsFreezed(true);
m_Controls->m_FreezeButton->setText("Start Viewing Again");
}
}
void QmitkUltrasoundSupport::OnChangedActiveDevice()
{
+ /*
if (m_Controls->m_RunImageTimer->isChecked() == false)
{
StopTimers();
return;
- }
+ }*/
//clean up and stop timer
StopTimers();
this->RemoveControlWidgets();
for (size_t j = 0; j < m_Node.size(); j++)
{
this->GetDataStorage()->Remove(m_Node.at(j));
m_Node.at(j)->ReleaseData();
}
m_Node.clear();
//get current device, abort if it is invalid
m_Device = m_Controls->m_ActiveVideoDevices->GetSelectedService<mitk::USDevice>();
if (m_Device.IsNull())
{
m_Controls->tabWidget->setTabEnabled(1, false);
return;
}
m_AmountOfOutputs = m_Device->GetNumberOfIndexedOutputs();
// clear data storage, create new nodes and add
for (size_t i = 0; i < m_AmountOfOutputs; i++)
{
mitk::DataNode::Pointer currentNode = mitk::DataNode::New();
std::stringstream nodeName;
nodeName << "US Viewing Stream - Image " << i;
currentNode->SetName(nodeName.str());
//create a dummy image (gray values 0..255) for correct initialization of level window, etc.
mitk::Image::Pointer dummyImage = mitk::ImageGenerator::GenerateRandomImage<float>(100, 100, 1, 1, 1, 1, 1, 255, 0);
currentNode->SetData(dummyImage);
m_OldGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(dummyImage->GetGeometry());
m_Node.push_back(currentNode);
//show node if the option is enabled
if (m_Controls->m_ShowImageStream->isChecked())
{
this->GetDataStorage()->Add(m_Node.at(i));
}
}
//create the widgets for this device and enable the widget tab
this->CreateControlWidgets();
m_Controls->tabWidget->setTabEnabled(1, true);
//start timer
if (m_Controls->m_RunImageTimer->isChecked())
{
int intervalPipeline = (1000 / m_Controls->m_FrameRatePipeline->value());
int interval2D = (1000 / m_Controls->m_FrameRate2d->value());
int interval3D = (1000 / m_Controls->m_FrameRate3d->value());
SetTimerIntervals(intervalPipeline, interval2D, interval3D);
StartTimers();
m_Controls->m_TimerWidget->setEnabled(true);
}
else
{
m_Controls->m_TimerWidget->setEnabled(false);
}
}
void QmitkUltrasoundSupport::OnNewDeviceWidgetDone()
{
m_Controls->m_NewVideoDeviceWidget->setVisible(false);
m_Controls->m_DeviceManagerWidget->setVisible(true);
m_Controls->m_Headline->setText("Ultrasound Devices:");
m_Controls->m_WidgetActiveDevices->setVisible(true);
}
void QmitkUltrasoundSupport::CreateControlWidgets()
{
m_ControlProbesWidget = new QmitkUSControlsProbesWidget(m_Device->GetControlInterfaceProbes(), m_Controls->m_ToolBoxControlWidgets);
m_Controls->probesWidgetContainer->addWidget(m_ControlProbesWidget);
// create b mode widget for current device
m_ControlBModeWidget = new QmitkUSControlsBModeWidget(m_Device->GetControlInterfaceBMode(), m_Controls->m_ToolBoxControlWidgets);
m_Controls->m_ToolBoxControlWidgets->addItem(m_ControlBModeWidget, "B Mode Controls");
if (!m_Device->GetControlInterfaceBMode())
{
m_Controls->m_ToolBoxControlWidgets->setItemEnabled(m_Controls->m_ToolBoxControlWidgets->count() - 1, false);
}
// create doppler widget for current device
m_ControlDopplerWidget = new QmitkUSControlsDopplerWidget(m_Device->GetControlInterfaceDoppler(), m_Controls->m_ToolBoxControlWidgets);
m_Controls->m_ToolBoxControlWidgets->addItem(m_ControlDopplerWidget, "Doppler Controls");
if (!m_Device->GetControlInterfaceDoppler())
{
m_Controls->m_ToolBoxControlWidgets->setItemEnabled(m_Controls->m_ToolBoxControlWidgets->count() - 1, false);
}
ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
if (pluginContext)
{
std::string filter = "(org.mitk.services.UltrasoundCustomWidget.deviceClass=" + m_Device->GetDeviceClass() + ")";
QString interfaceName = QString::fromStdString(us_service_interface_iid<QmitkUSAbstractCustomWidget>());
m_CustomWidgetServiceReference = pluginContext->getServiceReferences(interfaceName, QString::fromStdString(filter));
if (m_CustomWidgetServiceReference.size() > 0)
{
m_ControlCustomWidget = pluginContext->getService<QmitkUSAbstractCustomWidget>
(m_CustomWidgetServiceReference.at(0))->CloneForQt(m_Controls->tab2);
m_ControlCustomWidget->SetDevice(m_Device);
m_Controls->m_ToolBoxControlWidgets->addItem(m_ControlCustomWidget, "Custom Controls");
}
else
{
m_Controls->m_ToolBoxControlWidgets->addItem(new QWidget(m_Controls->m_ToolBoxControlWidgets), "Custom Controls");
m_Controls->m_ToolBoxControlWidgets->setItemEnabled(m_Controls->m_ToolBoxControlWidgets->count() - 1, false);
}
}
// select first enabled control widget
for (int n = 0; n < m_Controls->m_ToolBoxControlWidgets->count(); ++n)
{
if (m_Controls->m_ToolBoxControlWidgets->isItemEnabled(n))
{
m_Controls->m_ToolBoxControlWidgets->setCurrentIndex(n);
break;
}
}
}
void QmitkUltrasoundSupport::RemoveControlWidgets()
{
if (!m_ControlProbesWidget) { return; } //widgets do not exist... nothing to do
// remove all control widgets from the tool box widget
while (m_Controls->m_ToolBoxControlWidgets->count() > 0)
{
m_Controls->m_ToolBoxControlWidgets->removeItem(0);
}
// remove probes widget (which is not part of the tool box widget)
m_Controls->probesWidgetContainer->removeWidget(m_ControlProbesWidget);
delete m_ControlProbesWidget;
m_ControlProbesWidget = 0;
delete m_ControlBModeWidget;
m_ControlBModeWidget = 0;
delete m_ControlDopplerWidget;
m_ControlDopplerWidget = 0;
// delete custom widget if it is present
if (m_ControlCustomWidget)
{
ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
delete m_ControlCustomWidget; m_ControlCustomWidget = 0;
if (m_CustomWidgetServiceReference.size() > 0)
{
pluginContext->ungetService(m_CustomWidgetServiceReference.at(0));
}
}
}
void QmitkUltrasoundSupport::OnDeviceServiceEvent(const ctkServiceEvent event)
{
if (m_Device.IsNull() || event.getType() != ctkServiceEvent::MODIFIED)
{
return;
}
ctkServiceReference service = event.getServiceReference();
if (m_Device->GetManufacturer() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_MANUFACTURER)).toString().toStdString()
&& m_Device->GetName() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_NAME)).toString().toStdString())
{
return;
}
if (!m_Device->GetIsActive() && m_UpdateTimer->isActive())
{
StopTimers();
}
if (m_CurrentDynamicRange != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble())
{
m_CurrentDynamicRange = service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble();
// update level window for the current dynamic range
mitk::LevelWindow levelWindow;
m_Node.at(0)->GetLevelWindow(levelWindow);
levelWindow.SetAuto(m_curOutput.at(0), true, true);
m_Node.at(0)->SetLevelWindow(levelWindow);
}
}
void QmitkUltrasoundSupport::StoreUISettings()
{
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
settings.setValue("DisplayImage", QVariant(m_Controls->m_ShowImageStream->isChecked()));
settings.setValue("RunImageTimer", QVariant(m_Controls->m_RunImageTimer->isChecked()));
settings.setValue("Update2DView", QVariant(m_Controls->m_Update2DView->isChecked()));
settings.setValue("Update3DView", QVariant(m_Controls->m_Update3DView->isChecked()));
settings.setValue("UpdateRatePipeline", QVariant(m_Controls->m_FrameRatePipeline->value()));
settings.setValue("UpdateRate2d", QVariant(m_Controls->m_FrameRate2d->value()));
settings.setValue("UpdateRate3d", QVariant(m_Controls->m_FrameRate3d->value()));
settings.endGroup();
}
void QmitkUltrasoundSupport::LoadUISettings()
{
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
m_Controls->m_ShowImageStream->setChecked(settings.value("DisplayImage", true).toBool());
m_Controls->m_RunImageTimer->setChecked(settings.value("RunImageTimer", true).toBool());
m_Controls->m_Update2DView->setChecked(settings.value("Update2DView", true).toBool());
m_Controls->m_Update3DView->setChecked(settings.value("Update3DView", true).toBool());
m_Controls->m_FrameRatePipeline->setValue(settings.value("UpdateRatePipeline", 50).toInt());
m_Controls->m_FrameRate2d->setValue(settings.value("UpdateRate2d", 20).toInt());
m_Controls->m_FrameRate3d->setValue(settings.value("UpdateRate3d", 5).toInt());
settings.endGroup();
}
void QmitkUltrasoundSupport::StartTimers()
{
m_Clock.start();
m_UpdateTimer->start();
if (m_Controls->m_Update2DView->isChecked()) { m_RenderingTimer2d->start(); }
if (m_Controls->m_Update3DView->isChecked()) { m_RenderingTimer3d->start(); }
+ mitk::RenderingManager::GetInstance()->StartContinousUpdating();
}
void QmitkUltrasoundSupport::StopTimers()
{
m_UpdateTimer->stop();
m_RenderingTimer2d->stop();
m_RenderingTimer3d->stop();
}
void QmitkUltrasoundSupport::SetTimerIntervals(int intervalPipeline, int interval2D, int interval3D)
{
m_UpdateTimer->setInterval(intervalPipeline);
m_RenderingTimer2d->setInterval(interval2D);
m_RenderingTimer3d->setInterval(interval3D);
}