diff --git a/Modules/Core/include/mitkBaseController.h b/Modules/Core/include/mitkBaseController.h
index f928e6ab75..e3ba5e89c8 100644
--- a/Modules/Core/include/mitkBaseController.h
+++ b/Modules/Core/include/mitkBaseController.h
@@ -1,80 +1,77 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef BASECONTROLLER_H_HEADER_INCLUDED_C1E745A3
#define BASECONTROLLER_H_HEADER_INCLUDED_C1E745A3
#include "mitkEventStateMachine.h"
#include "mitkOperationActor.h"
#include "mitkStepper.h"
#include <MitkCoreExports.h>
#include <itkObjectFactory.h>
namespace mitk
{
class BaseRenderer;
//##Documentation
//## @brief Baseclass for renderer slice-/camera-control
//##
//## Tells the render (subclass of BaseRenderer) which slice (subclass
//## SliceNavigationController) or from which direction (subclass
//## CameraController) it has to render. Contains two Stepper for stepping
//## through the slices or through different camera views (e.g., for the
//## creation of a movie around the data), respectively, and through time, if
//## there is 3D+t data.
//## @note not yet implemented
//## @ingroup NavigationControl
- class MITKCORE_EXPORT BaseController : public mitk::OperationActor, public itk::Object
+ class MITKCORE_EXPORT BaseController : public OperationActor, public itk::Object
{
public:
/** Standard class typedefs. */
- mitkClassMacroItkParent(BaseController, mitk::OperationActor);
+ mitkClassMacroItkParent(BaseController, OperationActor);
itkFactorylessNewMacro(Self);
- /** Method for creation through ::New */
- // mitkNewMacro(Self);
-
- //##Documentation
- //## @brief Get the Stepper through the slices
- mitk::Stepper *GetSlice();
- const mitk::Stepper* GetSlice() const;
+ //##Documentation
+ //## @brief Get the Stepper through the slices
+ Stepper *GetSlice();
+ const Stepper* GetSlice() const;
//##Documentation
//## @brief Get the Stepper through the time
- mitk::Stepper *GetTime();
- const mitk::Stepper* GetTime() const;
+ Stepper *GetTime();
+ const Stepper* GetTime() const;
protected:
/**
* @brief Default Constructor
**/
BaseController();
/**
* @brief Default Destructor
**/
~BaseController() override;
void ExecuteOperation(Operation *) override;
//## @brief Stepper through the time
Stepper::Pointer m_Time;
//## @brief Stepper through the slices
Stepper::Pointer m_Slice;
unsigned long m_LastUpdateTime;
};
} // namespace mitk
#endif /* BASECONTROLLER_H_HEADER_INCLUDED_C1E745A3 */
diff --git a/Modules/Core/include/mitkSliceNavigationController.h b/Modules/Core/include/mitkSliceNavigationController.h
index ad0555773e..0401c83ff6 100644
--- a/Modules/Core/include/mitkSliceNavigationController.h
+++ b/Modules/Core/include/mitkSliceNavigationController.h
@@ -1,476 +1,476 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F
#define SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F
#include "mitkBaseController.h"
#include "mitkMessage.h"
#include "mitkRenderingManager.h"
#include "mitkTimeGeometry.h"
#include <MitkCoreExports.h>
#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop
#include "mitkDataStorage.h"
#include "mitkRestorePlanePositionOperation.h"
#include <itkCommand.h>
#include <sstream>
namespace mitk
{
#define mitkTimeGeometryEventMacro(classname, super) \
class MITKCORE_EXPORT classname : public super \
{ \
public: \
typedef classname Self; \
typedef super Superclass; \
classname(TimeGeometry *aTimeGeometry, unsigned int aPos) : Superclass(aTimeGeometry, aPos) {} \
virtual ~classname() {} \
virtual const char *GetEventName() const { return #classname; } \
virtual bool CheckEvent(const ::itk::EventObject *e) const { return dynamic_cast<const Self *>(e); } \
virtual ::itk::EventObject *MakeObject() const { return new Self(GetTimeGeometry(), GetPos()); } \
private: \
void operator=(const Self &); \
}
class PlaneGeometry;
class BaseGeometry;
class BaseRenderer;
/**
* \brief Controls the selection of the slice the associated BaseRenderer
* will display
*
* A SliceNavigationController takes a BaseGeometry or a TimeGeometry as input world geometry
* (TODO what are the exact requirements?) and generates a TimeGeometry
* as output. The TimeGeometry holds a number of SlicedGeometry3Ds and
* these in turn hold a series of PlaneGeometries. One of these PlaneGeometries is
* selected as world geometry for the BaseRenderers associated to 2D views.
*
* The SliceNavigationController holds has Steppers (one for the slice, a
* second for the time step), which control the selection of a single
* PlaneGeometry from the TimeGeometry. SliceNavigationController generates
* ITK events to tell observers, like a BaseRenderer, when the selected slice
* or timestep changes.
*
* Example:
* \code
* // Initialization
* sliceCtrl = mitk::SliceNavigationController::New();
*
* // Tell the navigator the geometry to be sliced (with geometry a
* // BaseGeometry::ConstPointer)
* sliceCtrl->SetInputWorldGeometry3D(geometry.GetPointer());
*
* // Tell the navigator in which direction it shall slice the data
* sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial);
*
* // Connect one or more BaseRenderer to this navigator, i.e.: events sent
* // by the navigator when stepping through the slices (e.g. by
* // sliceCtrl->GetSlice()->Next()) will be received by the BaseRenderer
* // (in this example only slice-changes, see also ConnectGeometryTimeEvent
* // and ConnectGeometryEvents.)
* sliceCtrl->ConnectGeometrySliceEvent(renderer.GetPointer());
*
* //create a world geometry and send the information to the connected renderer(s)
* sliceCtrl->Update();
* \endcode
*
*
* You can connect visible navigators to a SliceNavigationController, e.g., a
* QmitkSliderNavigator (for Qt):
*
* \code
* // Create the visible navigator (a slider with a spin-box)
* QmitkSliderNavigator* navigator =
* new QmitkSliderNavigator(parent, "slidernavigator");
*
* // Connect the navigator to the slice-stepper of the
* // SliceNavigationController. For initialization (position, mininal and
* // maximal values) the values of the SliceNavigationController are used.
* // Thus, accessing methods of a navigator is normally not necessary, since
* // everything can be set via the (Qt-independent) SliceNavigationController.
* // The QmitkStepperAdapter converts the Qt-signals to Qt-independent
* // itk-events.
* new QmitkStepperAdapter(navigator, sliceCtrl->GetSlice(), "navigatoradaptor");
* \endcode
*
* If you do not want that all renderwindows are updated when a new slice is
* selected, you can use a specific RenderingManager, which updates only those
* renderwindows that should be updated. This is sometimes useful when a 3D view
* does not need to be updated when the slices in some 2D views are changed.
* QmitkSliderNavigator (for Qt):
*
* \code
* // create a specific RenderingManager
* mitk::RenderingManager::Pointer myManager = mitk::RenderingManager::New();
*
* // tell the RenderingManager to update only renderwindow1 and renderwindow2
* myManager->AddRenderWindow(renderwindow1);
* myManager->AddRenderWindow(renderwindow2);
*
* // tell the SliceNavigationController of renderwindow1 and renderwindow2
* // to use the specific RenderingManager instead of the global one
* renderwindow1->GetSliceNavigationController()->SetRenderingManager(myManager);
* renderwindow2->GetSliceNavigationController()->SetRenderingManager(myManager);
* \endcode
*
* \todo implement for non-evenly-timed geometry!
* \ingroup NavigationControl
*/
class MITKCORE_EXPORT SliceNavigationController : public BaseController
{
public:
mitkClassMacro(SliceNavigationController, BaseController);
// itkFactorylessNewMacro(Self)
// mitkNewMacro1Param(Self, const char *);
itkNewMacro(Self);
// itkCloneMacro(Self)
/**
* \brief Possible view directions, \a Original will uses
* the PlaneGeometry instances in a SlicedGeometry3D provided
* as input world geometry (by SetInputWorldGeometry3D).
*/
enum ViewDirection
{
Axial,
Sagittal,
Frontal,
Original
};
/**
* \brief Set the input world geometry3D out of which the
* geometries for slicing will be created.
*
* Any previous previous set input geometry (3D or Time) will
* be ignored in future.
*/
void SetInputWorldGeometry3D(const mitk::BaseGeometry *geometry);
itkGetConstObjectMacro(InputWorldGeometry3D, mitk::BaseGeometry);
void SetInputWorldTimeGeometry(const mitk::TimeGeometry *geometry);
itkGetConstObjectMacro(InputWorldTimeGeometry, mitk::TimeGeometry);
/**
* \brief Access the created geometry
*/
itkGetConstObjectMacro(CreatedWorldGeometry, mitk::TimeGeometry);
/**
* \brief Set the desired view directions
*
* \sa ViewDirection
* \sa Update(ViewDirection viewDirection, bool top = true,
* bool frontside = true, bool rotated = false)
*/
itkSetEnumMacro(ViewDirection, ViewDirection);
itkGetEnumMacro(ViewDirection, ViewDirection);
/**
* \brief Set the default view direction
*
* This is used to re-initialize the view direction of the SNC to the
* default value with SetViewDirectionToDefault()
*
* \sa ViewDirection
* \sa Update(ViewDirection viewDirection, bool top = true,
* bool frontside = true, bool rotated = false)
*/
itkSetEnumMacro(DefaultViewDirection, ViewDirection);
itkGetEnumMacro(DefaultViewDirection, ViewDirection);
const char *GetViewDirectionAsString() const;
virtual void SetViewDirectionToDefault();
/**
* \brief Do the actual creation and send it to the connected
* observers (renderers)
*
*/
virtual void Update();
/**
* \brief Extended version of Update, additionally allowing to
* specify the direction/orientation of the created geometry.
*
*/
virtual void Update(ViewDirection viewDirection, bool top = true, bool frontside = true, bool rotated = false);
/**
* \brief Send the created geometry to the connected
* observers (renderers)
*
* Called by Update().
*/
virtual void SendCreatedWorldGeometry();
/**
* \brief Tell observers to re-read the currently selected 2D geometry
*
*/
virtual void SendCreatedWorldGeometryUpdate();
/**
* \brief Send the currently selected slice to the connected
* observers (renderers)
*
* Called by Update().
*/
virtual void SendSlice();
/**
* \brief Send the currently selected time to the connected
* observers (renderers)
*
* Called by Update().
*/
virtual void SendTime();
#pragma GCC visibility push(default)
itkEventMacro(UpdateEvent, itk::AnyEvent);
#pragma GCC visibility pop
class MITKCORE_EXPORT TimeGeometryEvent : public itk::AnyEvent
{
public:
typedef TimeGeometryEvent Self;
typedef itk::AnyEvent Superclass;
TimeGeometryEvent(TimeGeometry *aTimeGeometry, unsigned int aPos) : m_TimeGeometry(aTimeGeometry), m_Pos(aPos) {}
~TimeGeometryEvent() override {}
const char *GetEventName() const override { return "TimeGeometryEvent"; }
bool CheckEvent(const ::itk::EventObject *e) const override { return dynamic_cast<const Self *>(e); }
::itk::EventObject *MakeObject() const override { return new Self(m_TimeGeometry, m_Pos); }
TimeGeometry *GetTimeGeometry() const { return m_TimeGeometry; }
unsigned int GetPos() const { return m_Pos; }
private:
TimeGeometry::Pointer m_TimeGeometry;
unsigned int m_Pos;
// TimeGeometryEvent(const Self&);
void operator=(const Self &); // just hide
};
mitkTimeGeometryEventMacro(GeometrySendEvent, TimeGeometryEvent);
mitkTimeGeometryEventMacro(GeometryUpdateEvent, TimeGeometryEvent);
mitkTimeGeometryEventMacro(GeometryTimeEvent, TimeGeometryEvent);
mitkTimeGeometryEventMacro(GeometrySliceEvent, TimeGeometryEvent);
template <typename T>
void ConnectGeometrySendEvent(T *receiver)
{
typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometry);
unsigned long tag = AddObserver(GeometrySendEvent(nullptr, 0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
}
template <typename T>
void ConnectGeometryUpdateEvent(T *receiver)
{
typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::UpdateGeometry);
unsigned long tag = AddObserver(GeometryUpdateEvent(nullptr, 0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
}
template <typename T>
void ConnectGeometrySliceEvent(T *receiver, bool connectSendEvent = true)
{
typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometrySlice);
unsigned long tag = AddObserver(GeometrySliceEvent(nullptr, 0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
if (connectSendEvent)
ConnectGeometrySendEvent(receiver);
}
template <typename T>
void ConnectGeometryTimeEvent(T *receiver, bool connectSendEvent = true)
{
typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometryTime);
unsigned long tag = AddObserver(GeometryTimeEvent(nullptr, 0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
if (connectSendEvent)
ConnectGeometrySendEvent(receiver);
}
template <typename T>
void ConnectGeometryEvents(T *receiver)
{
// connect sendEvent only once
ConnectGeometrySliceEvent(receiver, false);
ConnectGeometryTimeEvent(receiver);
}
// use a templated method to get the right offset when casting to void*
template <typename T>
void Disconnect(T *receiver)
{
auto i = m_ReceiverToObserverTagsMap.find(static_cast<void *>(receiver));
if (i == m_ReceiverToObserverTagsMap.end())
return;
const std::list<unsigned long> &tags = i->second;
for (auto tagIter = tags.begin(); tagIter != tags.end(); ++tagIter)
{
RemoveObserver(*tagIter);
}
m_ReceiverToObserverTagsMap.erase(i);
}
Message1<mitk::Point3D> SetCrosshairEvent;
/**
* \brief To connect multiple SliceNavigationController, we can
* act as an observer ourselves: implemented interface
* \warning not implemented
*/
virtual void SetGeometry(const itk::EventObject &geometrySliceEvent);
/**
* \brief To connect multiple SliceNavigationController, we can
* act as an observer ourselves: implemented interface
*/
virtual void SetGeometrySlice(const itk::EventObject &geometrySliceEvent);
/**
* \brief To connect multiple SliceNavigationController, we can
* act as an observer ourselves: implemented interface
*/
virtual void SetGeometryTime(const itk::EventObject &geometryTimeEvent);
/** \brief Positions the SNC according to the specified point */
void SelectSliceByPoint(const mitk::Point3D &point);
/** \brief Returns the TimeGeometry created by the SNC. */
mitk::TimeGeometry *GetCreatedWorldGeometry();
/** \brief Returns the BaseGeometry of the currently selected time step. */
const mitk::BaseGeometry *GetCurrentGeometry3D();
/** \brief Returns the currently selected Plane in the current
* BaseGeometry (if existent).
*/
const mitk::PlaneGeometry *GetCurrentPlaneGeometry();
/** \brief Sets the BaseRenderer associated with this SNC (if any). While
* the BaseRenderer is not directly used by SNC, this is a convenience
* method to enable BaseRenderer access via the SNC. */
void SetRenderer(BaseRenderer *renderer);
/** \brief Gets the BaseRenderer associated with this SNC (if any). While
* the BaseRenderer is not directly used by SNC, this is a convenience
* method to enable BaseRenderer access via the SNC. Returns nullptr if no
* BaseRenderer has been specified*/
BaseRenderer *GetRenderer() const;
/** \brief Re-orients the slice stack. All slices will be oriented to the given normal vector.
The given point (world coordinates) defines the selected slice.
Careful: The resulting axis vectors are not clearly defined this way. If you want to define them clearly, use
ReorientSlices (const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1).
*/
void ReorientSlices(const mitk::Point3D &point, const mitk::Vector3D &normal);
/** \brief Re-orients the slice stack so that all planes are oriented according to the
* given axis vectors. The given Point eventually defines selected slice.
*/
void ReorientSlices(const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1);
void ExecuteOperation(Operation *operation) override;
/**
* \brief Feature option to lock planes during mouse interaction.
* This option flag disables the mouse event which causes the center
* cross to move near by.
*/
itkSetMacro(SliceLocked, bool);
itkGetMacro(SliceLocked, bool);
itkBooleanMacro(SliceLocked);
/**
* \brief Feature option to lock slice rotation.
*
* This option flag disables separately the rotation of a slice which is
* implemented in mitkSliceRotator.
*/
itkSetMacro(SliceRotationLocked, bool);
itkGetMacro(SliceRotationLocked, bool);
itkBooleanMacro(SliceRotationLocked);
/**
* \brief Adjusts the numerical range of the slice stepper according to
* the current geometry orientation of this SNC's SlicedGeometry.
*/
void AdjustSliceStepperRange();
- /** \brief Convinience method that returns the time step currently selected by the controller.*/
+ /** \brief Convenience method that returns the time step currently selected by the controller.*/
TimeStepType GetSelectedTimeStep() const;
- /** \brief Convinience method that returns the time point that corresponds to the selected
- *time step. The conversion is done using the time geometry of the SliceNavigationControler.*/
+ /** \brief Convenience method that returns the time point that corresponds to the selected
+ *time step. The conversion is done using the time geometry of the SliceNavigationController.*/
TimePointType GetSelectedTimePoint() const;
protected:
SliceNavigationController();
~SliceNavigationController() override;
mitk::BaseGeometry::ConstPointer m_InputWorldGeometry3D;
mitk::TimeGeometry::ConstPointer m_InputWorldTimeGeometry;
mitk::TimeGeometry::Pointer m_CreatedWorldGeometry;
ViewDirection m_ViewDirection;
ViewDirection m_DefaultViewDirection;
mitk::RenderingManager::Pointer m_RenderingManager;
mitk::BaseRenderer *m_Renderer;
itkSetMacro(Top, bool);
itkGetMacro(Top, bool);
itkBooleanMacro(Top);
itkSetMacro(FrontSide, bool);
itkGetMacro(FrontSide, bool);
itkBooleanMacro(FrontSide);
itkSetMacro(Rotated, bool);
itkGetMacro(Rotated, bool);
itkBooleanMacro(Rotated);
bool m_Top;
bool m_FrontSide;
bool m_Rotated;
bool m_BlockUpdate;
bool m_SliceLocked;
bool m_SliceRotationLocked;
unsigned int m_OldPos;
typedef std::map<void *, std::list<unsigned long>> ObserverTagsMapType;
ObserverTagsMapType m_ReceiverToObserverTagsMap;
};
} // namespace mitk
#endif /* SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F */
diff --git a/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp b/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
index be9f3aefba..a3a25ec0ae 100644
--- a/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
+++ b/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
@@ -1,658 +1,655 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkSliceNavigationController.h"
#include "mitkAction.h"
#include "mitkBaseRenderer.h"
#include "mitkCrosshairPositionEvent.h"
#include "mitkInteractionConst.h"
#include "mitkOperation.h"
#include "mitkOperationActor.h"
#include "mitkPlaneGeometry.h"
#include "mitkProportionalTimeGeometry.h"
#include "mitkArbitraryTimeGeometry.h"
#include "mitkRenderingManager.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkVtkPropRenderer.h"
#include "mitkImage.h"
#include "mitkImagePixelReadAccessor.h"
#include "mitkInteractionConst.h"
#include "mitkNodePredicateDataType.h"
#include "mitkOperationEvent.h"
#include "mitkPixelTypeMultiplex.h"
#include "mitkPlaneOperation.h"
#include "mitkPointOperation.h"
#include "mitkStatusBar.h"
#include "mitkUndoController.h"
#include "mitkApplyTransformMatrixOperation.h"
#include "mitkMemoryUtilities.h"
#include <itkCommand.h>
namespace mitk
{
SliceNavigationController::SliceNavigationController()
: BaseController(),
m_InputWorldGeometry3D( mitk::BaseGeometry::ConstPointer() ),
m_InputWorldTimeGeometry( mitk::TimeGeometry::ConstPointer() ),
m_CreatedWorldGeometry( mitk::TimeGeometry::Pointer() ),
m_ViewDirection(Axial),
m_DefaultViewDirection(Axial),
m_RenderingManager( mitk::RenderingManager::Pointer() ),
m_Renderer( nullptr ),
m_Top(false),
m_FrontSide(false),
m_Rotated(false),
m_BlockUpdate(false),
m_SliceLocked(false),
m_SliceRotationLocked(false),
m_OldPos(0)
{
typedef itk::SimpleMemberCommand<SliceNavigationController> SNCCommandType;
SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
sliceStepperChangedCommand = SNCCommandType::New();
timeStepperChangedCommand = SNCCommandType::New();
sliceStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendSlice);
timeStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendTime);
m_Slice->AddObserver(itk::ModifiedEvent(), sliceStepperChangedCommand);
m_Time->AddObserver(itk::ModifiedEvent(), timeStepperChangedCommand);
m_Slice->SetUnitName("mm");
m_Time->SetUnitName("ms");
m_Top = false;
m_FrontSide = false;
m_Rotated = false;
}
SliceNavigationController::~SliceNavigationController() {}
void SliceNavigationController::SetInputWorldGeometry3D(const BaseGeometry *geometry)
{
if ( geometry != nullptr )
{
if (geometry->GetBoundingBox()->GetDiagonalLength2() < eps)
{
itkWarningMacro("setting an empty bounding-box");
geometry = nullptr;
}
}
if (m_InputWorldGeometry3D != geometry)
{
m_InputWorldGeometry3D = geometry;
m_InputWorldTimeGeometry = mitk::TimeGeometry::ConstPointer();
this->Modified();
}
}
void SliceNavigationController::SetInputWorldTimeGeometry(const TimeGeometry *geometry)
{
if ( geometry != nullptr )
{
if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() < eps)
{
itkWarningMacro("setting an empty bounding-box");
geometry = nullptr;
}
}
if (m_InputWorldTimeGeometry != geometry)
{
m_InputWorldTimeGeometry = geometry;
m_InputWorldGeometry3D = mitk::BaseGeometry::ConstPointer();
this->Modified();
}
}
void SliceNavigationController::SetViewDirectionToDefault() { m_ViewDirection = m_DefaultViewDirection; }
const char *SliceNavigationController::GetViewDirectionAsString() const
{
const char *viewDirectionString;
switch (m_ViewDirection)
{
case SliceNavigationController::Axial:
viewDirectionString = "Axial";
break;
case SliceNavigationController::Sagittal:
viewDirectionString = "Sagittal";
break;
case SliceNavigationController::Frontal:
viewDirectionString = "Coronal";
break;
case SliceNavigationController::Original:
viewDirectionString = "Original";
break;
default:
viewDirectionString = "No View Direction Available";
break;
}
return viewDirectionString;
}
void SliceNavigationController::Update()
{
if (!m_BlockUpdate)
{
if (m_ViewDirection == Sagittal)
{
this->Update(Sagittal, true, true, false);
}
else if (m_ViewDirection == Frontal)
{
this->Update(Frontal, false, true, false);
}
else if (m_ViewDirection == Axial)
{
this->Update(Axial, false, false, true);
}
else
{
this->Update(m_ViewDirection);
}
}
}
void SliceNavigationController::Update(SliceNavigationController::ViewDirection viewDirection,
bool top,
bool frontside,
bool rotated)
{
TimeGeometry::ConstPointer worldTimeGeometry = m_InputWorldTimeGeometry;
if (m_BlockUpdate || (m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull()) ||
((worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->CountTimeSteps() == 0)))
{
return;
}
m_BlockUpdate = true;
if (m_InputWorldTimeGeometry.IsNotNull() && m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime())
{
Modified();
}
if (m_InputWorldGeometry3D.IsNotNull() && m_LastUpdateTime < m_InputWorldGeometry3D->GetMTime())
{
Modified();
}
this->SetViewDirection(viewDirection);
this->SetTop(top);
this->SetFrontSide(frontside);
this->SetRotated(rotated);
if (m_LastUpdateTime < GetMTime())
{
m_LastUpdateTime = GetMTime();
// initialize the viewplane
SlicedGeometry3D::Pointer slicedWorldGeometry = SlicedGeometry3D::Pointer();
BaseGeometry::ConstPointer currentGeometry = BaseGeometry::ConstPointer();
if (m_InputWorldTimeGeometry.IsNotNull())
if (m_InputWorldTimeGeometry->IsValidTimeStep(GetTime()->GetPos()))
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(GetTime()->GetPos());
else
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
else
currentGeometry = m_InputWorldGeometry3D;
m_CreatedWorldGeometry = mitk::TimeGeometry::Pointer();
switch (viewDirection)
{
case Original:
if (worldTimeGeometry.IsNotNull())
{
m_CreatedWorldGeometry = worldTimeGeometry->Clone();
worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(
m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos()).GetPointer());
if (slicedWorldGeometry.IsNotNull())
{
break;
}
}
else
{
const auto *worldSlicedGeometry =
dynamic_cast<const SlicedGeometry3D *>(currentGeometry.GetPointer());
if ( worldSlicedGeometry != nullptr )
{
slicedWorldGeometry = static_cast<SlicedGeometry3D *>(currentGeometry->Clone().GetPointer());
break;
}
}
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::None, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
case Axial:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Axial, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
case Frontal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Frontal, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
case Sagittal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Sagittal, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
break;
default:
itkExceptionMacro("unknown ViewDirection");
}
m_Slice->SetPos(0);
m_Slice->SetSteps((int)slicedWorldGeometry->GetSlices());
if ( worldTimeGeometry.IsNull() )
{
auto createdTimeGeometry = ProportionalTimeGeometry::New();
createdTimeGeometry->Initialize( slicedWorldGeometry, 1 );
m_CreatedWorldGeometry = createdTimeGeometry;
m_Time->SetSteps(0);
m_Time->SetPos(0);
m_Time->InvalidateRange();
}
else
{
m_BlockUpdate = true;
m_Time->SetSteps(worldTimeGeometry->CountTimeSteps());
m_Time->SetPos(0);
const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
m_Time->SetRange(timeBounds[0], timeBounds[1]);
m_BlockUpdate = false;
const auto currentTemporalPosition = this->GetTime()->GetPos();
assert( worldTimeGeometry->GetGeometryForTimeStep( currentTemporalPosition ).IsNotNull() );
if ( dynamic_cast<const mitk::ProportionalTimeGeometry*>( worldTimeGeometry.GetPointer() ) != nullptr )
{
const TimePointType minimumTimePoint =
worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition );
const TimePointType stepDuration =
worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition + 1 ) - minimumTimePoint;
auto createdTimeGeometry = ProportionalTimeGeometry::New();
createdTimeGeometry->Initialize( slicedWorldGeometry, worldTimeGeometry->CountTimeSteps() );
createdTimeGeometry->SetFirstTimePoint( minimumTimePoint );
createdTimeGeometry->SetStepDuration( stepDuration );
m_CreatedWorldGeometry = createdTimeGeometry;
}
else
{
auto createdTimeGeometry = mitk::ArbitraryTimeGeometry::New();
const TimeStepType numberOfTimeSteps = worldTimeGeometry->CountTimeSteps();
createdTimeGeometry->ReserveSpaceForGeometries( numberOfTimeSteps );
for ( TimeStepType i = 0; i < numberOfTimeSteps; ++i )
{
const BaseGeometry::Pointer clonedGeometry = slicedWorldGeometry->Clone().GetPointer();
const auto bounds = worldTimeGeometry->GetTimeBounds( i );
createdTimeGeometry->AppendNewTimeStep( clonedGeometry,
bounds[0], bounds[1]);
}
createdTimeGeometry->Update();
m_CreatedWorldGeometry = createdTimeGeometry;
}
}
}
// unblock update; we may do this now, because if m_BlockUpdate was already
// true before this method was entered, then we will never come here.
m_BlockUpdate = false;
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry and time/slice data.
this->SendCreatedWorldGeometry();
this->SendSlice();
this->SendTime();
// Adjust the stepper range of slice stepper according to geometry
this->AdjustSliceStepperRange();
}
void SliceNavigationController::SendCreatedWorldGeometry()
{
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry.
if (!m_BlockUpdate)
{
this->InvokeEvent(GeometrySendEvent(m_CreatedWorldGeometry, 0));
}
}
void SliceNavigationController::SendCreatedWorldGeometryUpdate()
{
if (!m_BlockUpdate)
{
this->InvokeEvent(GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
}
}
void SliceNavigationController::SendSlice()
{
if (!m_BlockUpdate)
{
if (m_CreatedWorldGeometry.IsNotNull())
{
this->InvokeEvent(GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void SliceNavigationController::SendTime()
{
if (!m_BlockUpdate)
{
if (m_CreatedWorldGeometry.IsNotNull())
{
this->InvokeEvent(GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()));
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void SliceNavigationController::SetGeometry(const itk::EventObject &) {}
void SliceNavigationController::SetGeometryTime(const itk::EventObject &geometryTimeEvent)
{
if (m_CreatedWorldGeometry.IsNull())
{
return;
}
const auto *timeEvent =
dynamic_cast< const SliceNavigationController::GeometryTimeEvent * >(&geometryTimeEvent);
assert( timeEvent != nullptr );
TimeGeometry *timeGeometry = timeEvent->GetTimeGeometry();
assert( timeGeometry != nullptr );
auto timeStep = (int)timeEvent->GetPos();
ScalarType timeInMS;
timeInMS = timeGeometry->TimeStepToTimePoint(timeStep);
timeStep = m_CreatedWorldGeometry->TimePointToTimeStep(timeInMS);
this->GetTime()->SetPos(timeStep);
}
void SliceNavigationController::SetGeometrySlice(const itk::EventObject &geometrySliceEvent)
{
const auto *sliceEvent =
dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
assert(sliceEvent!=nullptr);
this->GetSlice()->SetPos(sliceEvent->GetPos());
}
void SliceNavigationController::SelectSliceByPoint(const Point3D &point)
{
if (m_CreatedWorldGeometry.IsNull())
{
return;
}
//@todo add time to PositionEvent and use here!!
SlicedGeometry3D *slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(
m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos()).GetPointer());
if (slicedWorldGeometry)
{
int bestSlice = -1;
double bestDistance = itk::NumericTraits<double>::max();
int s, slices;
slices = slicedWorldGeometry->GetSlices();
if (slicedWorldGeometry->GetEvenlySpaced())
{
mitk::PlaneGeometry *plane = slicedWorldGeometry->GetPlaneGeometry(0);
const Vector3D &direction = slicedWorldGeometry->GetDirectionVector();
Point3D projectedPoint;
plane->Project(point, projectedPoint);
// Check whether the point is somewhere within the slice stack volume;
// otherwise, the default slice (0) will be selected
if (direction[0] * (point[0] - projectedPoint[0]) + direction[1] * (point[1] - projectedPoint[1]) +
direction[2] * (point[2] - projectedPoint[2]) >=
0)
{
bestSlice = (int)(plane->Distance(point) / slicedWorldGeometry->GetSpacing()[2] + 0.5);
}
}
else
{
Point3D projectedPoint;
for (s = 0; s < slices; ++s)
{
slicedWorldGeometry->GetPlaneGeometry(s)->Project(point, projectedPoint);
const Vector3D distance = projectedPoint - point;
ScalarType currentDistance = distance.GetSquaredNorm();
if (currentDistance < bestDistance)
{
bestDistance = currentDistance;
bestSlice = s;
}
}
}
if (bestSlice >= 0)
{
this->GetSlice()->SetPos(bestSlice);
}
else
{
this->GetSlice()->SetPos(0);
}
this->SendCreatedWorldGeometryUpdate();
// send crosshair event
SetCrosshairEvent.Send(point);
}
}
void SliceNavigationController::ReorientSlices(const Point3D &point, const Vector3D &normal)
{
if (m_CreatedWorldGeometry.IsNull())
{
return;
}
PlaneOperation op(OpORIENT, point, normal);
m_CreatedWorldGeometry->ExecuteOperation(&op);
this->SendCreatedWorldGeometryUpdate();
}
void SliceNavigationController::ReorientSlices(const mitk::Point3D &point,
const mitk::Vector3D &axisVec0,
const mitk::Vector3D &axisVec1)
{
if (m_CreatedWorldGeometry)
{
PlaneOperation op(OpORIENT, point, axisVec0, axisVec1);
m_CreatedWorldGeometry->ExecuteOperation(&op);
this->SendCreatedWorldGeometryUpdate();
}
}
mitk::TimeGeometry *SliceNavigationController::GetCreatedWorldGeometry() { return m_CreatedWorldGeometry; }
const mitk::BaseGeometry *SliceNavigationController::GetCurrentGeometry3D()
{
if (m_CreatedWorldGeometry.IsNotNull())
{
return m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos());
}
else
{
return nullptr;
}
}
const mitk::PlaneGeometry *SliceNavigationController::GetCurrentPlaneGeometry()
{
const auto *slicedGeometry =
dynamic_cast<const mitk::SlicedGeometry3D *>(this->GetCurrentGeometry3D());
if (slicedGeometry)
{
const mitk::PlaneGeometry *planeGeometry = (slicedGeometry->GetPlaneGeometry(this->GetSlice()->GetPos()));
return planeGeometry;
}
else
{
return nullptr;
}
}
void SliceNavigationController::SetRenderer(BaseRenderer *renderer) { m_Renderer = renderer; }
BaseRenderer *SliceNavigationController::GetRenderer() const { return m_Renderer; }
void SliceNavigationController::AdjustSliceStepperRange()
{
const auto *slicedGeometry =
dynamic_cast<const mitk::SlicedGeometry3D *>(this->GetCurrentGeometry3D());
const Vector3D &direction = slicedGeometry->GetDirectionVector();
int c = 0;
int i, k = 0;
for (i = 0; i < 3; ++i)
{
if (fabs(direction[i]) < 0.000000001)
{
++c;
}
else
{
k = i;
}
}
if (c == 2)
{
ScalarType min = slicedGeometry->GetOrigin()[k];
ScalarType max = min + slicedGeometry->GetExtentInMM(k);
m_Slice->SetRange(min, max);
}
else
{
m_Slice->InvalidateRange();
}
}
void SliceNavigationController::ExecuteOperation(Operation *operation)
{
// switch on type
// - select best slice for a given point
// - rotate created world geometry according to Operation->SomeInfo()
if (!operation || m_CreatedWorldGeometry.IsNull())
{
return;
}
switch (operation->GetOperationType())
{
case OpMOVE: // should be a point operation
{
if (!m_SliceLocked) // do not move the cross position
{
// select a slice
auto *po = dynamic_cast<PointOperation *>(operation);
if (po && po->GetIndex() == -1)
{
this->SelectSliceByPoint(po->GetPoint());
}
else if (po &&
po->GetIndex() != -1) // undo case because index != -1, index holds the old position of this slice
{
this->GetSlice()->SetPos(po->GetIndex());
}
}
break;
}
case OpRESTOREPLANEPOSITION:
{
m_CreatedWorldGeometry->ExecuteOperation(operation);
this->SendCreatedWorldGeometryUpdate();
break;
}
case OpAPPLYTRANSFORMMATRIX:
{
m_CreatedWorldGeometry->ExecuteOperation(operation);
this->SendCreatedWorldGeometryUpdate();
break;
}
default:
{
// do nothing
break;
}
}
}
- /** \brief Convinience method that returns the time step currently selected by the controller.*/
TimeStepType SliceNavigationController::GetSelectedTimeStep() const
{
return this->GetTime()->GetPos();
}
- /** \brief Convinience method that returns the time point that corresponds to the selected
- *time step. The conversion is done using the time geometry of the SliceNavigationControler.*/
TimePointType SliceNavigationController::GetSelectedTimePoint() const
{
auto timeStep = this->GetSelectedTimeStep();
if (m_CreatedWorldGeometry.IsNull())
{
- mitkThrow() << "SliceNavigationController is in an invalid state as m_CreatedWorldGeometry is invalid.";
+ mitkThrow() << "SliceNavigationController is in an invalid state as internal world geometry is invalid.";
}
if (!m_CreatedWorldGeometry->IsValidTimeStep(timeStep))
{
mitkThrow() << "SliceNavigationController is in an invalid state. It has a time step"
<< "selected that is not covered by its time geometry. Selected time step: "
<< timeStep << "; TimeGeometry steps count: " << m_CreatedWorldGeometry->CountTimeSteps();
}
return m_CreatedWorldGeometry->TimeStepToTimePoint(timeStep);
}
} // namespace
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.cpp b/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
index 3e5196dfaf..81080382e7 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
@@ -1,710 +1,710 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkSliceBasedInterpolatorWidget.h"
#include <mitkColorProperty.h>
#include <mitkDiffSliceOperation.h>
#include <mitkDiffSliceOperationApplier.h>
#include <mitkExtractSliceFilter.h>
#include <mitkImageAccessByItk.h>
#include <mitkImageCast.h>
#include <mitkImageTimeSelector.h>
#include <mitkLabelSetImage.h>
#include <mitkOperationEvent.h>
#include <mitkProgressBar.h>
#include <mitkProperties.h>
#include <mitkRenderingManager.h>
#include <mitkSegTool2D.h>
#include <mitkSliceNavigationController.h>
#include <mitkToolManager.h>
#include <mitkToolManagerProvider.h>
#include <mitkUndoController.h>
#include <mitkVtkImageOverwrite.h>
#include "QmitkStdMultiWidget.h"
#include <itkCommand.h>
#include <QApplication>
#include <QCursor>
#include <QMenu>
#include <QMessageBox>
QmitkSliceBasedInterpolatorWidget::QmitkSliceBasedInterpolatorWidget(QWidget *parent, const char * /*name*/)
: QWidget(parent),
m_SliceInterpolatorController(mitk::SliceBasedInterpolationController::New()),
m_ToolManager(nullptr),
m_Activated(false),
m_DataStorage(nullptr),
m_LastSNC(nullptr),
m_LastSliceIndex(0)
{
m_Controls.setupUi(this);
m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkSliceBasedInterpolatorWidget>(
this, &QmitkSliceBasedInterpolatorWidget::OnToolManagerWorkingDataModified);
connect(m_Controls.m_btStart, SIGNAL(toggled(bool)), this, SLOT(OnToggleWidgetActivation(bool)));
connect(m_Controls.m_btApplyForCurrentSlice, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()));
connect(m_Controls.m_btApplyForAllSlices, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()));
itk::ReceptorMemberCommand<QmitkSliceBasedInterpolatorWidget>::Pointer command =
itk::ReceptorMemberCommand<QmitkSliceBasedInterpolatorWidget>::New();
command->SetCallbackFunction(this, &QmitkSliceBasedInterpolatorWidget::OnSliceInterpolationInfoChanged);
m_InterpolationInfoChangedObserverTag = m_SliceInterpolatorController->AddObserver(itk::ModifiedEvent(), command);
// feedback node and its visualization properties
m_PreviewNode = mitk::DataNode::New();
m_PreviewNode->SetName("3D tool preview");
m_PreviewNode->SetProperty("texture interpolation", mitk::BoolProperty::New(false));
m_PreviewNode->SetProperty("layer", mitk::IntProperty::New(100));
m_PreviewNode->SetProperty("binary", mitk::BoolProperty::New(true));
m_PreviewNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
m_PreviewNode->SetProperty("outline binary shadow", mitk::BoolProperty::New(true));
m_PreviewNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PreviewNode->SetOpacity(1.0);
m_PreviewNode->SetColor(0.0, 1.0, 0.0);
m_Controls.m_btApplyForCurrentSlice->setEnabled(false);
m_Controls.m_btApplyForAllSlices->setEnabled(false);
this->setEnabled(false);
}
QmitkSliceBasedInterpolatorWidget::~QmitkSliceBasedInterpolatorWidget()
{
m_ToolManager->WorkingDataChanged -= mitk::MessageDelegate<QmitkSliceBasedInterpolatorWidget>(
this, &QmitkSliceBasedInterpolatorWidget::OnToolManagerWorkingDataModified);
foreach (mitk::SliceNavigationController *slicer, m_ControllerToSliceObserverTag.keys())
{
slicer->RemoveObserver(m_ControllerToDeleteObserverTag.take(slicer));
slicer->RemoveObserver(m_ControllerToTimeObserverTag.take(slicer));
slicer->RemoveObserver(m_ControllerToSliceObserverTag.take(slicer));
}
m_ActionToSliceDimensionMap.clear();
// remove observer
m_SliceInterpolatorController->RemoveObserver(m_InterpolationInfoChangedObserverTag);
}
const QmitkSliceBasedInterpolatorWidget::ActionToSliceDimensionMapType
QmitkSliceBasedInterpolatorWidget::CreateActionToSliceDimension()
{
ActionToSliceDimensionMapType actionToSliceDimension;
foreach (mitk::SliceNavigationController *slicer, m_ControllerToDeleteObserverTag.keys())
{
std::string name = slicer->GetRenderer()->GetName();
if (name == "stdmulti.widget0")
name = "Axial (red window)";
else if (name == "stdmulti.widget1")
name = "Sagittal (green window)";
else if (name == "stdmulti.widget2")
name = "Coronal (blue window)";
actionToSliceDimension[new QAction(QString::fromStdString(name), nullptr)] = slicer;
}
return actionToSliceDimension;
}
void QmitkSliceBasedInterpolatorWidget::SetDataStorage(mitk::DataStorage &storage)
{
m_DataStorage = &storage;
}
void QmitkSliceBasedInterpolatorWidget::SetSliceNavigationControllers(
const QList<mitk::SliceNavigationController *> &controllers)
{
Q_ASSERT(!controllers.empty());
// connect to the slice navigation controller. after each change, call the interpolator
foreach (mitk::SliceNavigationController *slicer, controllers)
{
// Has to be initialized
m_LastSNC = slicer;
m_TimePoints.insert(slicer, slicer->GetSelectedTimePoint());
itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::Pointer deleteCommand =
itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::New();
deleteCommand->SetCallbackFunction(this, &QmitkSliceBasedInterpolatorWidget::OnSliceNavigationControllerDeleted);
m_ControllerToDeleteObserverTag.insert(slicer, slicer->AddObserver(itk::DeleteEvent(), deleteCommand));
itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::Pointer timeChangedCommand =
itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::New();
timeChangedCommand->SetCallbackFunction(this, &QmitkSliceBasedInterpolatorWidget::OnTimeChanged);
m_ControllerToTimeObserverTag.insert(
slicer,
slicer->AddObserver(mitk::SliceNavigationController::TimeGeometryEvent(nullptr, 0), timeChangedCommand));
itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::Pointer sliceChangedCommand =
itk::MemberCommand<QmitkSliceBasedInterpolatorWidget>::New();
sliceChangedCommand->SetCallbackFunction(this, &QmitkSliceBasedInterpolatorWidget::OnSliceChanged);
m_ControllerToSliceObserverTag.insert(
slicer, slicer->AddObserver(mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), sliceChangedCommand));
}
m_ActionToSliceDimensionMap = this->CreateActionToSliceDimension();
}
void QmitkSliceBasedInterpolatorWidget::OnToolManagerWorkingDataModified()
{
mitk::DataNode *workingNode = this->m_ToolManager->GetWorkingData(0);
if (!workingNode)
{
this->setEnabled(false);
return;
}
mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
// TODO adapt tool manager so that this check is done there, e.g. convenience function
// Q_ASSERT(workingImage);
if (!workingImage)
{
this->setEnabled(false);
return;
}
if (workingImage->GetDimension() > 4 || workingImage->GetDimension() < 3)
{
this->setEnabled(false);
return;
}
m_WorkingImage = workingImage;
this->setEnabled(true);
}
void QmitkSliceBasedInterpolatorWidget::OnTimeChanged(itk::Object *sender, const itk::EventObject &e)
{
// Check if we really have a GeometryTimeEvent
if (!dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent *>(&e))
return;
mitk::SliceNavigationController *slicer = dynamic_cast<mitk::SliceNavigationController *>(sender);
Q_ASSERT(slicer);
m_TimePoints[slicer] = slicer->GetSelectedTimePoint();
// TODO Macht das hier wirklich Sinn????
if (m_LastSNC == slicer)
{
slicer->SendSlice(); // will trigger a new interpolation
}
}
void QmitkSliceBasedInterpolatorWidget::OnSliceChanged(itk::Object *sender, const itk::EventObject &e)
{
if (m_Activated && m_WorkingImage.IsNotNull())
{
// Check whether we really have a GeometrySliceEvent
if (!dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent *>(&e))
return;
mitk::SliceNavigationController *slicer = dynamic_cast<mitk::SliceNavigationController *>(sender);
if (slicer)
{
this->TranslateAndInterpolateChangedSlice(e, slicer);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// slicer->GetRenderer()->RequestUpdate();
}
}
}
void QmitkSliceBasedInterpolatorWidget::TranslateAndInterpolateChangedSlice(const itk::EventObject &e,
mitk::SliceNavigationController *slicer)
{
if (m_Activated && m_WorkingImage.IsNotNull())
{
const mitk::SliceNavigationController::GeometrySliceEvent &geometrySliceEvent =
dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent &>(e);
mitk::TimeGeometry *timeGeometry = geometrySliceEvent.GetTimeGeometry();
if (timeGeometry && m_TimePoints.contains(slicer) && timeGeometry->IsValidTimePoint(m_TimePoints[slicer]))
{
mitk::SlicedGeometry3D *slicedGeometry =
dynamic_cast<mitk::SlicedGeometry3D *>(timeGeometry->GetGeometryForTimePoint(m_TimePoints[slicer]).GetPointer());
if (slicedGeometry)
{
mitk::PlaneGeometry *plane = slicedGeometry->GetPlaneGeometry(geometrySliceEvent.GetPos());
if (plane)
{
m_LastSNC = slicer;
this->Interpolate(plane, m_TimePoints[slicer], slicer);
}
}
}
}
}
void QmitkSliceBasedInterpolatorWidget::Interpolate(mitk::PlaneGeometry *plane,
mitk::TimePointType timePoint,
mitk::SliceNavigationController *slicer)
{
int clickedSliceDimension(-1);
int clickedSliceIndex(-1);
if (!m_WorkingImage->GetTimeGeometry()->IsValidTimePoint(timePoint))
{
MITK_WARN << "Cannot interpolate WorkingImage. Passed time point is not within the time bounds of WorkingImage. Time point: " << timePoint;
return;
}
const auto timeStep = m_WorkingImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
// calculate real slice position, i.e. slice of the image and not slice of the TimeSlicedGeometry
// see if timestep is needed here
mitk::SegTool2D::DetermineAffectedImageSlice(m_WorkingImage, plane, clickedSliceDimension, clickedSliceIndex);
mitk::Image::Pointer interpolation =
m_SliceInterpolatorController->Interpolate(clickedSliceDimension, clickedSliceIndex, plane, timeStep);
m_PreviewNode->SetData(interpolation);
const mitk::Color &color = m_WorkingImage->GetActiveLabel()->GetColor();
m_PreviewNode->SetColor(color);
m_LastSNC = slicer;
m_LastSliceIndex = clickedSliceIndex;
}
mitk::Image::Pointer QmitkSliceBasedInterpolatorWidget::GetWorkingSlice(const mitk::PlaneGeometry *planeGeometry)
{
const auto timePoint = m_LastSNC->GetSelectedTimePoint();
if (!m_WorkingImage->GetTimeGeometry()->IsValidTimePoint(timePoint))
{
- MITK_WARN << "Cannot get slice of WorkingImage. Time point selected by SliceNavigationControl is not within the time bounds of WorkingImage. Time point: " << timePoint;
+ MITK_WARN << "Cannot get slice of WorkingImage. Time point selected by SliceNavigationController is not within the time bounds of WorkingImage. Time point: " << timePoint;
return nullptr;
}
// Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
// reslicer
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
// set to false to extract a slice
reslice->SetOverwriteMode(false);
reslice->Modified();
// use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
extractor->SetInput(m_WorkingImage);
const auto timeStep = m_WorkingImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
extractor->SetTimeStep(timeStep);
extractor->SetWorldGeometry(planeGeometry);
extractor->SetVtkOutputRequest(false);
extractor->SetResliceTransformByGeometry(m_WorkingImage->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
extractor->Modified();
try
{
extractor->Update();
}
catch (itk::ExceptionObject &excep)
{
MITK_ERROR << "Exception caught: " << excep.GetDescription();
return nullptr;
}
mitk::Image::Pointer slice = extractor->GetOutput();
// specify the undo operation with the non edited slice
// MLI TODO added code starts here
mitk::SlicedGeometry3D *sliceGeometry = dynamic_cast<mitk::SlicedGeometry3D *>(slice->GetGeometry());
// m_undoOperation = new mitk::DiffSliceOperation(m_WorkingImage, extractor->GetVtkOutput(), slice->GetGeometry(),
// timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
// added code ends here
m_undoOperation = new mitk::DiffSliceOperation(
m_WorkingImage, extractor->GetOutput(), sliceGeometry, timeStep, const_cast<mitk::PlaneGeometry *>(planeGeometry));
slice->DisconnectPipeline();
return slice;
}
void QmitkSliceBasedInterpolatorWidget::OnToggleWidgetActivation(bool enabled)
{
Q_ASSERT(m_ToolManager);
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
if (!workingNode)
return;
m_Controls.m_btApplyForCurrentSlice->setEnabled(enabled);
m_Controls.m_btApplyForAllSlices->setEnabled(enabled);
if (enabled)
m_Controls.m_btStart->setText("Stop");
else
m_Controls.m_btStart->setText("Start");
unsigned int numberOfExistingTools = m_ToolManager->GetTools().size();
for (unsigned int i = 0; i < numberOfExistingTools; i++)
{
// mitk::SegTool2D* tool = dynamic_cast<mitk::SegTool2D*>(m_ToolManager->GetToolById(i));
// MLI TODO
// if (tool) tool->SetEnable2DInterpolation( enabled );
}
if (enabled)
{
if (!m_DataStorage->Exists(m_PreviewNode))
{
m_DataStorage->Add(m_PreviewNode);
}
m_SliceInterpolatorController->SetWorkingImage(m_WorkingImage);
this->UpdateVisibleSuggestion();
}
else
{
if (m_DataStorage->Exists(m_PreviewNode))
{
m_DataStorage->Remove(m_PreviewNode);
}
mitk::UndoController::GetCurrentUndoModel()->Clear();
}
m_Activated = enabled;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
template <typename TPixel, unsigned int VImageDimension>
void QmitkSliceBasedInterpolatorWidget::WritePreviewOnWorkingImage(itk::Image<TPixel, VImageDimension> *targetSlice,
const mitk::Image *sourceSlice,
int overwritevalue)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typename ImageType::Pointer sourceSliceITK;
mitk::CastToItkImage(sourceSlice, sourceSliceITK);
// now the original slice and the ipSegmentation-painted slice are in the same format, and we can just copy all pixels
// that are non-zero
typedef itk::ImageRegionIterator<ImageType> OutputIteratorType;
typedef itk::ImageRegionConstIterator<ImageType> InputIteratorType;
InputIteratorType inputIterator(sourceSliceITK, sourceSliceITK->GetLargestPossibleRegion());
OutputIteratorType outputIterator(targetSlice, targetSlice->GetLargestPossibleRegion());
outputIterator.GoToBegin();
inputIterator.GoToBegin();
int activePixelValue = m_WorkingImage->GetActiveLabel()->GetValue();
if (activePixelValue == 0) // if exterior is the active label
{
while (!outputIterator.IsAtEnd())
{
if (inputIterator.Get() != 0)
{
outputIterator.Set(overwritevalue);
}
++outputIterator;
++inputIterator;
}
}
else if (overwritevalue != 0) // if we are not erasing
{
while (!outputIterator.IsAtEnd())
{
int targetValue = static_cast<int>(outputIterator.Get());
if (inputIterator.Get() != 0)
{
if (!m_WorkingImage->GetLabel(targetValue)->GetLocked())
outputIterator.Set(overwritevalue);
}
++outputIterator;
++inputIterator;
}
}
else // if we are erasing
{
while (!outputIterator.IsAtEnd())
{
const int targetValue = outputIterator.Get();
if (inputIterator.Get() != 0)
{
if (targetValue == activePixelValue)
outputIterator.Set(overwritevalue);
}
++outputIterator;
++inputIterator;
}
}
}
void QmitkSliceBasedInterpolatorWidget::OnAcceptInterpolationClicked()
{
if (m_WorkingImage.IsNotNull() && m_PreviewNode->GetData())
{
const mitk::PlaneGeometry *planeGeometry = m_LastSNC->GetCurrentPlaneGeometry();
if (!planeGeometry)
return;
mitk::Image::Pointer sliceImage = this->GetWorkingSlice(planeGeometry);
if (sliceImage.IsNull())
return;
mitk::Image::Pointer previewSlice = dynamic_cast<mitk::Image *>(m_PreviewNode->GetData());
AccessFixedDimensionByItk_2(
sliceImage, WritePreviewOnWorkingImage, 2, previewSlice, m_WorkingImage->GetActiveLabel()->GetValue());
// Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
// reslicer
vtkSmartPointer<mitkVtkImageOverwrite> overwrite = vtkSmartPointer<mitkVtkImageOverwrite>::New();
overwrite->SetInputSlice(sliceImage->GetVtkImageData());
// set overwrite mode to true to write back to the image volume
overwrite->SetOverwriteMode(true);
overwrite->Modified();
const auto timePoint = m_LastSNC->GetSelectedTimePoint();
if (!m_WorkingImage->GetTimeGeometry()->IsValidTimePoint(timePoint))
{
- MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationControl is not within the time bounds of WorkingImage. Time point: " << timePoint;
+ MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationController is not within the time bounds of WorkingImage. Time point: " << timePoint;
return;
}
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(overwrite);
extractor->SetInput(m_WorkingImage);
const auto timeStep = m_WorkingImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
extractor->SetTimeStep(timeStep);
extractor->SetWorldGeometry(planeGeometry);
extractor->SetVtkOutputRequest(false);
extractor->SetResliceTransformByGeometry(m_WorkingImage->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
extractor->Modified();
try
{
extractor->Update();
}
catch (itk::ExceptionObject &excep)
{
MITK_ERROR << "Exception caught: " << excep.GetDescription();
return;
}
// the image was modified within the pipeline, but not marked so
m_WorkingImage->Modified();
int clickedSliceDimension(-1);
int clickedSliceIndex(-1);
mitk::SegTool2D::DetermineAffectedImageSlice(
m_WorkingImage, planeGeometry, clickedSliceDimension, clickedSliceIndex);
m_SliceInterpolatorController->SetChangedSlice(sliceImage, clickedSliceDimension, clickedSliceIndex, timeStep);
// specify the undo operation with the edited slice
// MLI TODO added code starts here
mitk::SlicedGeometry3D *sliceGeometry = dynamic_cast<mitk::SlicedGeometry3D *>(sliceImage->GetGeometry());
// m_undoOperation = new mitk::DiffSliceOperation(m_WorkingImage, extractor->GetVtkOutput(), slice->GetGeometry(),
// timeStep, const_cast<mitk::PlaneGeometry*>(planeGeometry));
// added code ends here
m_doOperation = new mitk::DiffSliceOperation(m_WorkingImage,
extractor->GetOutput(),
sliceGeometry,
timeStep,
const_cast<mitk::PlaneGeometry *>(planeGeometry));
// create an operation event for the undo stack
mitk::OperationEvent *undoStackItem = new mitk::OperationEvent(
mitk::DiffSliceOperationApplier::GetInstance(), m_doOperation, m_undoOperation, "Slice Interpolation");
// add it to the undo controller
mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
// clear the pointers as the operation are stored in the undo controller and also deleted from there
m_undoOperation = nullptr;
m_doOperation = nullptr;
m_PreviewNode->SetData(nullptr);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSliceBasedInterpolatorWidget::AcceptAllInterpolations(mitk::SliceNavigationController *slicer)
{
// Since we need to shift the plane it must be clone so that the original plane isn't altered
mitk::PlaneGeometry::Pointer reslicePlane = slicer->GetCurrentPlaneGeometry()->Clone();
const auto timePoint = slicer->GetSelectedTimePoint();
if (!m_WorkingImage->GetTimeGeometry()->IsValidTimePoint(timePoint))
{
- MITK_WARN << "Cannot accept all interpolations. Time point selected by SliceNavigationControl is not within the time bounds of WorkingImage. Time point: " << timePoint;
+ MITK_WARN << "Cannot accept all interpolations. Time point selected by SliceNavigationController is not within the time bounds of WorkingImage. Time point: " << timePoint;
return;
}
const auto timeStep = m_WorkingImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
int sliceDimension(-1);
int sliceIndex(-1);
mitk::SegTool2D::DetermineAffectedImageSlice(m_WorkingImage, reslicePlane, sliceDimension, sliceIndex);
unsigned int zslices = m_WorkingImage->GetDimension(sliceDimension);
mitk::ProgressBar::GetInstance()->Reset();
mitk::ProgressBar::GetInstance()->AddStepsToDo(zslices);
mitk::Point3D origin = reslicePlane->GetOrigin();
for (unsigned int idx = 0; idx < zslices; ++idx)
{
// Transforming the current origin of the reslice plane
// so that it matches the one of the next slice
m_WorkingImage->GetSlicedGeometry()->WorldToIndex(origin, origin);
origin[sliceDimension] = idx;
m_WorkingImage->GetSlicedGeometry()->IndexToWorld(origin, origin);
reslicePlane->SetOrigin(origin);
mitk::Image::Pointer interpolation =
m_SliceInterpolatorController->Interpolate(sliceDimension, idx, reslicePlane, timeStep);
if (interpolation.IsNotNull())
{
m_PreviewNode->SetData(interpolation);
mitk::Image::Pointer sliceImage = this->GetWorkingSlice(reslicePlane);
if (sliceImage.IsNull())
return;
AccessFixedDimensionByItk_2(
sliceImage, WritePreviewOnWorkingImage, 2, interpolation, m_WorkingImage->GetActiveLabel()->GetValue());
// Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
// reslicer
vtkSmartPointer<mitkVtkImageOverwrite> overwrite = vtkSmartPointer<mitkVtkImageOverwrite>::New();
overwrite->SetInputSlice(sliceImage->GetVtkImageData());
// set overwrite mode to true to write back to the image volume
overwrite->SetOverwriteMode(true);
overwrite->Modified();
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(overwrite);
extractor->SetInput(m_WorkingImage);
extractor->SetTimeStep(timeStep);
extractor->SetWorldGeometry(reslicePlane);
extractor->SetVtkOutputRequest(true);
extractor->SetResliceTransformByGeometry(m_WorkingImage->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
extractor->Modified();
try
{
extractor->Update();
}
catch (itk::ExceptionObject &excep)
{
MITK_ERROR << "Exception caught: " << excep.GetDescription();
return;
}
m_WorkingImage->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
}
mitk::ProgressBar::GetInstance()->Progress();
}
m_SliceInterpolatorController->SetWorkingImage(m_WorkingImage);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSliceBasedInterpolatorWidget::OnAcceptAllInterpolationsClicked()
{
QMenu orientationPopup(this);
std::map<QAction *, mitk::SliceNavigationController *>::const_iterator it;
for (it = m_ActionToSliceDimensionMap.begin(); it != m_ActionToSliceDimensionMap.end(); it++)
orientationPopup.addAction(it->first);
connect(&orientationPopup, SIGNAL(triggered(QAction *)), this, SLOT(OnAcceptAllPopupActivated(QAction *)));
orientationPopup.exec(QCursor::pos());
}
void QmitkSliceBasedInterpolatorWidget::OnAcceptAllPopupActivated(QAction *action)
{
ActionToSliceDimensionMapType::const_iterator iter = m_ActionToSliceDimensionMap.find(action);
if (iter != m_ActionToSliceDimensionMap.end())
{
mitk::SliceNavigationController *slicer = iter->second;
this->AcceptAllInterpolations(slicer);
}
}
void QmitkSliceBasedInterpolatorWidget::UpdateVisibleSuggestion()
{
if (m_Activated && m_LastSNC)
{
// determine which one is the current view, try to do an initial interpolation
mitk::BaseRenderer *renderer = m_LastSNC->GetRenderer();
if (renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
{
const mitk::TimeGeometry *timeGeometry =
dynamic_cast<const mitk::TimeGeometry *>(renderer->GetWorldTimeGeometry());
if (timeGeometry)
{
mitk::SliceNavigationController::GeometrySliceEvent event(const_cast<mitk::TimeGeometry *>(timeGeometry),
renderer->GetSlice());
this->TranslateAndInterpolateChangedSlice(event, m_LastSNC);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
}
void QmitkSliceBasedInterpolatorWidget::OnSliceInterpolationInfoChanged(const itk::EventObject & /*e*/)
{
// something (e.g. undo) changed the interpolation info, we should refresh our display
this->UpdateVisibleSuggestion();
}
void QmitkSliceBasedInterpolatorWidget::OnSliceNavigationControllerDeleted(const itk::Object *sender,
const itk::EventObject & /*e*/)
{
// Don't know how to avoid const_cast here?!
mitk::SliceNavigationController *slicer =
dynamic_cast<mitk::SliceNavigationController *>(const_cast<itk::Object *>(sender));
if (slicer)
{
m_ControllerToTimeObserverTag.remove(slicer);
m_ControllerToSliceObserverTag.remove(slicer);
m_ControllerToDeleteObserverTag.remove(slicer);
}
}
void QmitkSliceBasedInterpolatorWidget::WaitCursorOn()
{
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
}
void QmitkSliceBasedInterpolatorWidget::WaitCursorOff()
{
this->RestoreOverrideCursor();
}
void QmitkSliceBasedInterpolatorWidget::RestoreOverrideCursor()
{
QApplication::restoreOverrideCursor();
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
index 36e57640c4..a469617da8 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
@@ -1,1384 +1,1384 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkSlicesInterpolator.h"
#include "QmitkSelectableGLWidget.h"
#include "QmitkStdMultiWidget.h"
#include "mitkApplyDiffImageOperation.h"
#include "mitkColorProperty.h"
#include "mitkCoreObjectFactory.h"
#include "mitkDiffImageApplier.h"
#include "mitkInteractionConst.h"
#include "mitkLevelWindowProperty.h"
#include "mitkOperationEvent.h"
#include "mitkOverwriteSliceImageFilter.h"
#include "mitkProgressBar.h"
#include "mitkProperties.h"
#include "mitkRenderingManager.h"
#include "mitkSegTool2D.h"
#include "mitkSliceNavigationController.h"
#include "mitkSurfaceToImageFilter.h"
#include "mitkToolManager.h"
#include "mitkUndoController.h"
#include <mitkExtractSliceFilter.h>
#include <mitkImageReadAccessor.h>
#include <mitkImageTimeSelector.h>
#include <mitkImageWriteAccessor.h>
#include <mitkPlaneProposer.h>
#include <mitkUnstructuredGridClusteringFilter.h>
#include <mitkVtkImageOverwrite.h>
#include <itkCommand.h>
#include <QCheckBox>
#include <QCursor>
#include <QMenu>
#include <QMessageBox>
#include <QPushButton>
#include <QVBoxLayout>
#include <vtkPolyVertex.h>
#include <vtkUnstructuredGrid.h>
//#define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
float SURFACE_COLOR_RGB[3] = {0.49f, 1.0f, 0.16f};
const std::map<QAction *, mitk::SliceNavigationController *> QmitkSlicesInterpolator::createActionToSliceDimension()
{
std::map<QAction *, mitk::SliceNavigationController *> actionToSliceDimension;
foreach (mitk::SliceNavigationController *slicer, m_ControllerToDeleteObserverTag.keys())
{
actionToSliceDimension[new QAction(QString::fromStdString(slicer->GetViewDirectionAsString()), nullptr)] = slicer;
}
return actionToSliceDimension;
}
QmitkSlicesInterpolator::QmitkSlicesInterpolator(QWidget *parent, const char * /*name*/)
: QWidget(parent),
// ACTION_TO_SLICEDIMENSION( createActionToSliceDimension() ),
m_Interpolator(mitk::SegmentationInterpolationController::New()),
m_SurfaceInterpolator(mitk::SurfaceInterpolationController::GetInstance()),
m_ToolManager(nullptr),
m_Initialized(false),
m_LastSNC(nullptr),
m_LastSliceIndex(0),
m_2DInterpolationEnabled(false),
m_3DInterpolationEnabled(false),
m_FirstRun(true)
{
m_GroupBoxEnableExclusiveInterpolationMode = new QGroupBox("Interpolation", this);
QVBoxLayout *vboxLayout = new QVBoxLayout(m_GroupBoxEnableExclusiveInterpolationMode);
m_EdgeDetector = mitk::FeatureBasedEdgeDetectionFilter::New();
m_PointScorer = mitk::PointCloudScoringFilter::New();
m_CmbInterpolation = new QComboBox(m_GroupBoxEnableExclusiveInterpolationMode);
m_CmbInterpolation->addItem("Disabled");
m_CmbInterpolation->addItem("2-Dimensional");
m_CmbInterpolation->addItem("3-Dimensional");
vboxLayout->addWidget(m_CmbInterpolation);
m_BtnApply2D = new QPushButton("Confirm for single slice", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_BtnApply2D);
m_BtnApplyForAllSlices2D = new QPushButton("Confirm for all slices", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_BtnApplyForAllSlices2D);
m_BtnApply3D = new QPushButton("Confirm", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_BtnApply3D);
m_BtnSuggestPlane = new QPushButton("Suggest a plane", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_BtnSuggestPlane);
m_BtnReinit3DInterpolation = new QPushButton("Reinit Interpolation", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_BtnReinit3DInterpolation);
m_ChkShowPositionNodes = new QCheckBox("Show Position Nodes", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_ChkShowPositionNodes);
this->HideAllInterpolationControls();
connect(m_CmbInterpolation, SIGNAL(currentIndexChanged(int)), this, SLOT(OnInterpolationMethodChanged(int)));
connect(m_BtnApply2D, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()));
connect(m_BtnApplyForAllSlices2D, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()));
connect(m_BtnApply3D, SIGNAL(clicked()), this, SLOT(OnAccept3DInterpolationClicked()));
connect(m_BtnSuggestPlane, SIGNAL(clicked()), this, SLOT(OnSuggestPlaneClicked()));
connect(m_BtnReinit3DInterpolation, SIGNAL(clicked()), this, SLOT(OnReinit3DInterpolation()));
connect(m_ChkShowPositionNodes, SIGNAL(toggled(bool)), this, SLOT(OnShowMarkers(bool)));
connect(m_ChkShowPositionNodes, SIGNAL(toggled(bool)), this, SIGNAL(SignalShowMarkerNodes(bool)));
QHBoxLayout *layout = new QHBoxLayout(this);
layout->addWidget(m_GroupBoxEnableExclusiveInterpolationMode);
this->setLayout(layout);
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command =
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnInterpolationInfoChanged);
InterpolationInfoChangedObserverTag = m_Interpolator->AddObserver(itk::ModifiedEvent(), command);
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command2 =
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command2->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged);
SurfaceInterpolationInfoChangedObserverTag = m_SurfaceInterpolator->AddObserver(itk::ModifiedEvent(), command2);
// feedback node and its visualization properties
m_FeedbackNode = mitk::DataNode::New();
mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(m_FeedbackNode);
m_FeedbackNode->SetProperty("binary", mitk::BoolProperty::New(true));
m_FeedbackNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
m_FeedbackNode->SetProperty("color", mitk::ColorProperty::New(255.0, 255.0, 0.0));
m_FeedbackNode->SetProperty("texture interpolation", mitk::BoolProperty::New(false));
m_FeedbackNode->SetProperty("layer", mitk::IntProperty::New(20));
m_FeedbackNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
m_FeedbackNode->SetProperty("name", mitk::StringProperty::New("Interpolation feedback"));
m_FeedbackNode->SetProperty("opacity", mitk::FloatProperty::New(0.8));
m_FeedbackNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_InterpolatedSurfaceNode = mitk::DataNode::New();
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(SURFACE_COLOR_RGB));
m_InterpolatedSurfaceNode->SetProperty("name", mitk::StringProperty::New("Surface Interpolation feedback"));
m_InterpolatedSurfaceNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
m_InterpolatedSurfaceNode->SetProperty("line width", mitk::FloatProperty::New(4.0f));
m_InterpolatedSurfaceNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_InterpolatedSurfaceNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_InterpolatedSurfaceNode->SetVisibility(false);
m_3DContourNode = mitk::DataNode::New();
m_3DContourNode->SetProperty("color", mitk::ColorProperty::New(0.0, 0.0, 0.0));
m_3DContourNode->SetProperty("hidden object", mitk::BoolProperty::New(true));
m_3DContourNode->SetProperty("name", mitk::StringProperty::New("Drawn Contours"));
m_3DContourNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New(VTK_WIREFRAME));
m_3DContourNode->SetProperty("material.wireframeLineWidth", mitk::FloatProperty::New(2.0f));
m_3DContourNode->SetProperty("3DContourContainer", mitk::BoolProperty::New(true));
m_3DContourNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_3DContourNode->SetVisibility(
false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0")));
m_3DContourNode->SetVisibility(
false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
m_3DContourNode->SetVisibility(
false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")));
m_3DContourNode->SetVisibility(
false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
QWidget::setContentsMargins(0, 0, 0, 0);
if (QWidget::layout() != nullptr)
{
QWidget::layout()->setContentsMargins(0, 0, 0, 0);
}
// For running 3D Interpolation in background
// create a QFuture and a QFutureWatcher
connect(&m_Watcher, SIGNAL(started()), this, SLOT(StartUpdateInterpolationTimer()));
connect(&m_Watcher, SIGNAL(finished()), this, SLOT(OnSurfaceInterpolationFinished()));
connect(&m_Watcher, SIGNAL(finished()), this, SLOT(StopUpdateInterpolationTimer()));
m_Timer = new QTimer(this);
connect(m_Timer, SIGNAL(timeout()), this, SLOT(ChangeSurfaceColor()));
}
void QmitkSlicesInterpolator::SetDataStorage(mitk::DataStorage::Pointer storage)
{
if (m_DataStorage == storage)
{
return;
}
if (m_DataStorage.IsNotNull())
{
m_DataStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkSlicesInterpolator, const mitk::DataNode*>(this, &QmitkSlicesInterpolator::NodeRemoved)
);
}
m_DataStorage = storage;
m_SurfaceInterpolator->SetDataStorage(storage);
if (m_DataStorage.IsNotNull())
{
m_DataStorage->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkSlicesInterpolator, const mitk::DataNode*>(this, &QmitkSlicesInterpolator::NodeRemoved)
);
}
}
mitk::DataStorage *QmitkSlicesInterpolator::GetDataStorage()
{
if (m_DataStorage.IsNotNull())
{
return m_DataStorage;
}
else
{
return nullptr;
}
}
void QmitkSlicesInterpolator::Initialize(mitk::ToolManager *toolManager,
const QList<mitk::SliceNavigationController *> &controllers)
{
Q_ASSERT(!controllers.empty());
if (m_Initialized)
{
// remove old observers
Uninitialize();
}
m_ToolManager = toolManager;
if (m_ToolManager)
{
// set enabled only if a segmentation is selected
mitk::DataNode *node = m_ToolManager->GetWorkingData(0);
QWidget::setEnabled(node != nullptr);
// react whenever the set of selected segmentation changes
m_ToolManager->WorkingDataChanged +=
mitk::MessageDelegate<QmitkSlicesInterpolator>(this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified);
m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>(
this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified);
// connect to the slice navigation controller. after each change, call the interpolator
foreach (mitk::SliceNavigationController *slicer, controllers)
{
// Has to be initialized
m_LastSNC = slicer;
m_TimePoints.insert(slicer, slicer->GetSelectedTimePoint());
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer deleteCommand =
itk::MemberCommand<QmitkSlicesInterpolator>::New();
deleteCommand->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnSliceNavigationControllerDeleted);
m_ControllerToDeleteObserverTag.insert(slicer, slicer->AddObserver(itk::DeleteEvent(), deleteCommand));
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer timeChangedCommand =
itk::MemberCommand<QmitkSlicesInterpolator>::New();
timeChangedCommand->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnTimeChanged);
m_ControllerToTimeObserverTag.insert(
slicer, slicer->AddObserver(mitk::SliceNavigationController::TimeGeometryEvent(nullptr, 0), timeChangedCommand));
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer sliceChangedCommand =
itk::MemberCommand<QmitkSlicesInterpolator>::New();
sliceChangedCommand->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnSliceChanged);
m_ControllerToSliceObserverTag.insert(
slicer, slicer->AddObserver(mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), sliceChangedCommand));
}
ACTION_TO_SLICEDIMENSION = createActionToSliceDimension();
}
m_Initialized = true;
}
void QmitkSlicesInterpolator::Uninitialize()
{
if (m_ToolManager.IsNotNull())
{
m_ToolManager->WorkingDataChanged -=
mitk::MessageDelegate<QmitkSlicesInterpolator>(this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified);
m_ToolManager->ReferenceDataChanged -= mitk::MessageDelegate<QmitkSlicesInterpolator>(
this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified);
}
foreach (mitk::SliceNavigationController *slicer, m_ControllerToSliceObserverTag.keys())
{
slicer->RemoveObserver(m_ControllerToDeleteObserverTag.take(slicer));
slicer->RemoveObserver(m_ControllerToTimeObserverTag.take(slicer));
slicer->RemoveObserver(m_ControllerToSliceObserverTag.take(slicer));
}
ACTION_TO_SLICEDIMENSION.clear();
m_ToolManager = nullptr;
m_Initialized = false;
}
QmitkSlicesInterpolator::~QmitkSlicesInterpolator()
{
if (m_Initialized)
{
// remove old observers
Uninitialize();
}
WaitForFutures();
if (m_DataStorage.IsNotNull())
{
m_DataStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkSlicesInterpolator, const mitk::DataNode*>(this, &QmitkSlicesInterpolator::NodeRemoved)
);
if (m_DataStorage->Exists(m_3DContourNode))
m_DataStorage->Remove(m_3DContourNode);
if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
m_DataStorage->Remove(m_InterpolatedSurfaceNode);
}
// remove observer
m_Interpolator->RemoveObserver(InterpolationInfoChangedObserverTag);
m_SurfaceInterpolator->RemoveObserver(SurfaceInterpolationInfoChangedObserverTag);
delete m_Timer;
}
/**
External enableization...
*/
void QmitkSlicesInterpolator::setEnabled(bool enable)
{
QWidget::setEnabled(enable);
// Set the gui elements of the different interpolation modi enabled
if (enable)
{
if (m_2DInterpolationEnabled)
{
this->Show2DInterpolationControls(true);
m_Interpolator->Activate2DInterpolation(true);
}
else if (m_3DInterpolationEnabled)
{
this->Show3DInterpolationControls(true);
this->Show3DInterpolationResult(true);
}
}
// Set all gui elements of the interpolation disabled
else
{
this->HideAllInterpolationControls();
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::On2DInterpolationEnabled(bool status)
{
OnInterpolationActivated(status);
m_Interpolator->Activate2DInterpolation(status);
}
void QmitkSlicesInterpolator::On3DInterpolationEnabled(bool status)
{
On3DInterpolationActivated(status);
}
void QmitkSlicesInterpolator::OnInterpolationDisabled(bool status)
{
if (status)
{
OnInterpolationActivated(!status);
On3DInterpolationActivated(!status);
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::HideAllInterpolationControls()
{
this->Show2DInterpolationControls(false);
this->Show3DInterpolationControls(false);
}
void QmitkSlicesInterpolator::Show2DInterpolationControls(bool show)
{
m_BtnApply2D->setVisible(show);
m_BtnApplyForAllSlices2D->setVisible(show);
}
void QmitkSlicesInterpolator::Show3DInterpolationControls(bool show)
{
m_BtnApply3D->setVisible(show);
m_BtnSuggestPlane->setVisible(show);
m_ChkShowPositionNodes->setVisible(show);
m_BtnReinit3DInterpolation->setVisible(show);
}
void QmitkSlicesInterpolator::OnInterpolationMethodChanged(int index)
{
switch (index)
{
case 0: // Disabled
m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation");
this->HideAllInterpolationControls();
this->OnInterpolationActivated(false);
this->On3DInterpolationActivated(false);
this->Show3DInterpolationResult(false);
m_Interpolator->Activate2DInterpolation(false);
break;
case 1: // 2D
m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation (Enabled)");
this->HideAllInterpolationControls();
this->Show2DInterpolationControls(true);
this->OnInterpolationActivated(true);
this->On3DInterpolationActivated(false);
m_Interpolator->Activate2DInterpolation(true);
break;
case 2: // 3D
m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation (Enabled)");
this->HideAllInterpolationControls();
this->Show3DInterpolationControls(true);
this->OnInterpolationActivated(false);
this->On3DInterpolationActivated(true);
m_Interpolator->Activate2DInterpolation(false);
break;
default:
MITK_ERROR << "Unknown interpolation method!";
m_CmbInterpolation->setCurrentIndex(0);
break;
}
}
void QmitkSlicesInterpolator::OnShowMarkers(bool state)
{
mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers =
m_DataStorage->GetSubset(mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End();
++it)
{
it->Value()->SetProperty("helper object", mitk::BoolProperty::New(!state));
}
}
void QmitkSlicesInterpolator::OnToolManagerWorkingDataModified()
{
if (m_ToolManager->GetWorkingData(0) != nullptr)
{
m_Segmentation = dynamic_cast<mitk::Image *>(m_ToolManager->GetWorkingData(0)->GetData());
m_BtnReinit3DInterpolation->setEnabled(true);
}
else
{
// If no workingdata is set, remove the interpolation feedback
this->GetDataStorage()->Remove(m_FeedbackNode);
m_FeedbackNode->SetData(nullptr);
this->GetDataStorage()->Remove(m_3DContourNode);
m_3DContourNode->SetData(nullptr);
this->GetDataStorage()->Remove(m_InterpolatedSurfaceNode);
m_InterpolatedSurfaceNode->SetData(nullptr);
m_BtnReinit3DInterpolation->setEnabled(false);
return;
}
// Updating the current selected segmentation for the 3D interpolation
SetCurrentContourListID();
if (m_2DInterpolationEnabled)
{
OnInterpolationActivated(true); // re-initialize if needed
}
this->CheckSupportedImageDimension();
}
void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
{
}
void QmitkSlicesInterpolator::OnTimeChanged(itk::Object *sender, const itk::EventObject &e)
{
// Check if we really have a GeometryTimeEvent
if (!dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent *>(&e))
return;
mitk::SliceNavigationController *slicer = dynamic_cast<mitk::SliceNavigationController *>(sender);
Q_ASSERT(slicer);
const auto timePoint = slicer->GetSelectedTimePoint();
m_TimePoints[slicer] = timePoint;
m_SurfaceInterpolator->SetCurrentTimePoint(timePoint);
if (m_LastSNC == slicer)
{
slicer->SendSlice(); // will trigger a new interpolation
}
}
void QmitkSlicesInterpolator::OnSliceChanged(itk::Object *sender, const itk::EventObject &e)
{
// Check whether we really have a GeometrySliceEvent
if (!dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent *>(&e))
return;
mitk::SliceNavigationController *slicer = dynamic_cast<mitk::SliceNavigationController *>(sender);
if (TranslateAndInterpolateChangedSlice(e, slicer))
{
slicer->GetRenderer()->RequestUpdate();
}
}
bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const itk::EventObject &e,
mitk::SliceNavigationController *slicer)
{
if (!m_2DInterpolationEnabled)
return false;
try
{
const mitk::SliceNavigationController::GeometrySliceEvent &event =
dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent &>(e);
mitk::TimeGeometry *tsg = event.GetTimeGeometry();
if (tsg && m_TimePoints.contains(slicer) && tsg->IsValidTimePoint(m_TimePoints[slicer]))
{
mitk::SlicedGeometry3D *slicedGeometry =
dynamic_cast<mitk::SlicedGeometry3D *>(tsg->GetGeometryForTimePoint(m_TimePoints[slicer]).GetPointer());
if (slicedGeometry)
{
m_LastSNC = slicer;
mitk::PlaneGeometry *plane =
dynamic_cast<mitk::PlaneGeometry *>(slicedGeometry->GetPlaneGeometry(event.GetPos()));
if (plane)
Interpolate(plane, m_TimePoints[slicer], slicer);
return true;
}
}
}
catch (const std::bad_cast &)
{
return false; // so what
}
return false;
}
void QmitkSlicesInterpolator::Interpolate(mitk::PlaneGeometry *plane,
mitk::TimePointType timePoint,
mitk::SliceNavigationController *slicer)
{
if (m_ToolManager)
{
mitk::DataNode *node = m_ToolManager->GetWorkingData(0);
if (node)
{
m_Segmentation = dynamic_cast<mitk::Image *>(node->GetData());
if (m_Segmentation)
{
if (!m_Segmentation->GetTimeGeometry()->IsValidTimePoint(timePoint))
{
MITK_WARN << "Cannot interpolate segmentation. Passed time point is not within the time bounds of WorkingImage. Time point: " << timePoint;
return;
}
const auto timeStep = m_Segmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
int clickedSliceDimension(-1);
int clickedSliceIndex(-1);
// calculate real slice position, i.e. slice of the image and not slice of the TimeSlicedGeometry
mitk::SegTool2D::DetermineAffectedImageSlice(m_Segmentation, plane, clickedSliceDimension, clickedSliceIndex);
mitk::Image::Pointer interpolation =
m_Interpolator->Interpolate(clickedSliceDimension, clickedSliceIndex, plane, timeStep);
m_FeedbackNode->SetData(interpolation);
m_LastSNC = slicer;
m_LastSliceIndex = clickedSliceIndex;
}
}
}
}
void QmitkSlicesInterpolator::OnSurfaceInterpolationFinished()
{
mitk::Surface::Pointer interpolatedSurface = m_SurfaceInterpolator->GetInterpolationResult();
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
if (interpolatedSurface.IsNotNull() && workingNode &&
workingNode->IsVisible(
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2"))))
{
m_BtnApply3D->setEnabled(true);
m_BtnSuggestPlane->setEnabled(true);
m_InterpolatedSurfaceNode->SetData(interpolatedSurface);
m_3DContourNode->SetData(m_SurfaceInterpolator->GetContoursAsSurface());
this->Show3DInterpolationResult(true);
if (!m_DataStorage->Exists(m_InterpolatedSurfaceNode))
{
m_DataStorage->Add(m_InterpolatedSurfaceNode);
}
if (!m_DataStorage->Exists(m_3DContourNode))
{
m_DataStorage->Add(m_3DContourNode, workingNode);
}
}
else if (interpolatedSurface.IsNull())
{
m_BtnApply3D->setEnabled(false);
m_BtnSuggestPlane->setEnabled(false);
if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
{
this->Show3DInterpolationResult(false);
}
}
m_BtnReinit3DInterpolation->setEnabled(true);
foreach (mitk::SliceNavigationController *slicer, m_ControllerToTimeObserverTag.keys())
{
slicer->GetRenderer()->RequestUpdate();
}
}
void QmitkSlicesInterpolator::OnAcceptInterpolationClicked()
{
if (m_Segmentation && m_FeedbackNode->GetData())
{
// Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
// reslicer
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
// Set slice as input
mitk::Image::Pointer slice = dynamic_cast<mitk::Image *>(m_FeedbackNode->GetData());
reslice->SetInputSlice(slice->GetSliceData()->GetVtkImageAccessor(slice)->GetVtkImageData());
// set overwrite mode to true to write back to the image volume
reslice->SetOverwriteMode(true);
reslice->Modified();
const auto timePoint = m_LastSNC->GetSelectedTimePoint();
if (!m_Segmentation->GetTimeGeometry()->IsValidTimePoint(timePoint))
{
- MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationControl is not within the time bounds of segmentation. Time point: " << timePoint;
+ MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationController is not within the time bounds of segmentation. Time point: " << timePoint;
return;
}
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
extractor->SetInput(m_Segmentation);
const auto timeStep = m_Segmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
extractor->SetTimeStep(timeStep);
extractor->SetWorldGeometry(m_LastSNC->GetCurrentPlaneGeometry());
extractor->SetVtkOutputRequest(true);
extractor->SetResliceTransformByGeometry(m_Segmentation->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
extractor->Modified();
extractor->Update();
// the image was modified within the pipeline, but not marked so
m_Segmentation->Modified();
m_Segmentation->GetVtkImageData()->Modified();
m_FeedbackNode->SetData(nullptr);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSlicesInterpolator::AcceptAllInterpolations(mitk::SliceNavigationController *slicer)
{
/*
* What exactly is done here:
* 1. We create an empty diff image for the current segmentation
* 2. All interpolated slices are written into the diff image
* 3. Then the diffimage is applied to the original segmentation
*/
if (m_Segmentation)
{
mitk::Image::Pointer image3D = m_Segmentation;
unsigned int timeStep(0);
const auto timePoint = slicer->GetSelectedTimePoint();
if (m_Segmentation->GetDimension() == 4)
{
if (!m_Segmentation->GetTimeGeometry()->IsValidTimePoint(timePoint))
{
- MITK_WARN << "Cannot accept all interpolations. Time point selected by passed SliceNavigationControl is not within the time bounds of segmentation. Time point: " << timePoint;
+ MITK_WARN << "Cannot accept all interpolations. Time point selected by passed SliceNavigationController is not within the time bounds of segmentation. Time point: " << timePoint;
return;
}
timeStep = m_Segmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(m_Segmentation);
timeSelector->SetTimeNr(timeStep);
timeSelector->Update();
image3D = timeSelector->GetOutput();
}
// create a empty diff image for the undo operation
mitk::Image::Pointer diffImage = mitk::Image::New();
diffImage->Initialize(image3D);
// Create scope for ImageWriteAccessor so that the accessor is destroyed
// after the image is initialized. Otherwise later image access will lead to an error
{
mitk::ImageWriteAccessor imAccess(diffImage);
// Set all pixels to zero
mitk::PixelType pixelType(mitk::MakeScalarPixelType<mitk::Tool::DefaultSegmentationDataType>());
// For legacy purpose support former pixel type of segmentations (before multilabel)
if (m_Segmentation->GetImageDescriptor()->GetChannelDescriptor().GetPixelType().GetComponentType() ==
itk::ImageIOBase::UCHAR)
{
pixelType = mitk::MakeScalarPixelType<unsigned char>();
}
memset(imAccess.GetData(),
0,
(pixelType.GetBpe() >> 3) * diffImage->GetDimension(0) * diffImage->GetDimension(1) *
diffImage->GetDimension(2));
}
// Since we need to shift the plane it must be clone so that the original plane isn't altered
mitk::PlaneGeometry::Pointer reslicePlane = slicer->GetCurrentPlaneGeometry()->Clone();
int sliceDimension(-1);
int sliceIndex(-1);
mitk::SegTool2D::DetermineAffectedImageSlice(m_Segmentation, reslicePlane, sliceDimension, sliceIndex);
unsigned int zslices = m_Segmentation->GetDimension(sliceDimension);
mitk::ProgressBar::GetInstance()->AddStepsToDo(zslices);
mitk::Point3D origin = reslicePlane->GetOrigin();
unsigned int totalChangedSlices(0);
for (unsigned int sliceIndex = 0; sliceIndex < zslices; ++sliceIndex)
{
// Transforming the current origin of the reslice plane
// so that it matches the one of the next slice
m_Segmentation->GetSlicedGeometry()->WorldToIndex(origin, origin);
origin[sliceDimension] = sliceIndex;
m_Segmentation->GetSlicedGeometry()->IndexToWorld(origin, origin);
reslicePlane->SetOrigin(origin);
// Set the slice as 'input'
mitk::Image::Pointer interpolation =
m_Interpolator->Interpolate(sliceDimension, sliceIndex, reslicePlane, timeStep);
if (interpolation.IsNotNull()) // we don't check if interpolation is necessary/sensible - but m_Interpolator does
{
// Setting up the reslicing pipeline which allows us to write the interpolation results back into
// the image volume
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
// set overwrite mode to true to write back to the image volume
reslice->SetInputSlice(interpolation->GetSliceData()->GetVtkImageAccessor(interpolation)->GetVtkImageData());
reslice->SetOverwriteMode(true);
reslice->Modified();
mitk::ExtractSliceFilter::Pointer diffslicewriter = mitk::ExtractSliceFilter::New(reslice);
diffslicewriter->SetInput(diffImage);
diffslicewriter->SetTimeStep(0);
diffslicewriter->SetWorldGeometry(reslicePlane);
diffslicewriter->SetVtkOutputRequest(true);
diffslicewriter->SetResliceTransformByGeometry(diffImage->GetTimeGeometry()->GetGeometryForTimeStep(0));
diffslicewriter->Modified();
diffslicewriter->Update();
++totalChangedSlices;
}
mitk::ProgressBar::GetInstance()->Progress();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
if (totalChangedSlices > 0)
{
// store undo stack items
if (true)
{
// create do/undo operations
mitk::ApplyDiffImageOperation *doOp =
new mitk::ApplyDiffImageOperation(mitk::OpTEST, m_Segmentation, diffImage, timeStep);
mitk::ApplyDiffImageOperation *undoOp =
new mitk::ApplyDiffImageOperation(mitk::OpTEST, m_Segmentation, diffImage, timeStep);
undoOp->SetFactor(-1.0);
std::stringstream comment;
comment << "Confirm all interpolations (" << totalChangedSlices << ")";
mitk::OperationEvent *undoStackItem =
new mitk::OperationEvent(mitk::DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, comment.str());
mitk::OperationEvent::IncCurrGroupEventId();
mitk::OperationEvent::IncCurrObjectEventId();
mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
// acutally apply the changes here to the original image
mitk::DiffImageApplier::GetInstanceForUndo()->ExecuteOperation(doOp);
}
}
m_FeedbackNode->SetData(nullptr);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSlicesInterpolator::FinishInterpolation(mitk::SliceNavigationController *slicer)
{
// this redirect is for calling from outside
if (slicer == nullptr)
OnAcceptAllInterpolationsClicked();
else
AcceptAllInterpolations(slicer);
}
void QmitkSlicesInterpolator::OnAcceptAllInterpolationsClicked()
{
QMenu orientationPopup(this);
std::map<QAction *, mitk::SliceNavigationController *>::const_iterator it;
for (it = ACTION_TO_SLICEDIMENSION.begin(); it != ACTION_TO_SLICEDIMENSION.end(); it++)
orientationPopup.addAction(it->first);
connect(&orientationPopup, SIGNAL(triggered(QAction *)), this, SLOT(OnAcceptAllPopupActivated(QAction *)));
orientationPopup.exec(QCursor::pos());
}
void QmitkSlicesInterpolator::OnAccept3DInterpolationClicked()
{
if (m_InterpolatedSurfaceNode.IsNotNull() && m_InterpolatedSurfaceNode->GetData())
{
mitk::DataNode *segmentationNode = m_ToolManager->GetWorkingData(0);
mitk::Image *currSeg = dynamic_cast<mitk::Image *>(segmentationNode->GetData());
mitk::SurfaceToImageFilter::Pointer s2iFilter = mitk::SurfaceToImageFilter::New();
s2iFilter->MakeOutputBinaryOn();
if (currSeg->GetPixelType().GetComponentType() == itk::ImageIOBase::USHORT)
s2iFilter->SetUShortBinaryPixelType(true);
s2iFilter->SetInput(dynamic_cast<mitk::Surface *>(m_InterpolatedSurfaceNode->GetData()));
// check if ToolManager holds valid ReferenceData
if (m_ToolManager->GetReferenceData(0) == nullptr || m_ToolManager->GetWorkingData(0) == nullptr)
{
return;
}
s2iFilter->SetImage(dynamic_cast<mitk::Image *>(m_ToolManager->GetReferenceData(0)->GetData()));
s2iFilter->Update();
mitk::Image::Pointer newSeg = s2iFilter->GetOutput();
const auto timePoint = m_LastSNC->GetSelectedTimePoint();
if (!m_ToolManager->GetReferenceData(0)->GetData()->GetTimeGeometry()->IsValidTimePoint(timePoint) ||
!m_ToolManager->GetWorkingData(0)->GetData()->GetTimeGeometry()->IsValidTimePoint(timePoint))
{
- MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationControl is not within the time bounds of reference or working image. Time point: " << timePoint;
+ MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationController is not within the time bounds of reference or working image. Time point: " << timePoint;
return;
}
const auto newTimeStep = newSeg->GetTimeGeometry()->TimePointToTimeStep(timePoint);
mitk::ImageReadAccessor readAccess(newSeg, newSeg->GetVolumeData(newTimeStep));
const void *cPointer = readAccess.GetData();
if (currSeg && cPointer)
{
const auto curTimeStep = currSeg->GetTimeGeometry()->TimePointToTimeStep(timePoint);
currSeg->SetVolume(cPointer, curTimeStep, 0);
}
else
{
return;
}
m_CmbInterpolation->setCurrentIndex(0);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
mitk::DataNode::Pointer segSurface = mitk::DataNode::New();
float rgb[3];
segmentationNode->GetColor(rgb);
segSurface->SetColor(rgb);
segSurface->SetData(m_InterpolatedSurfaceNode->GetData());
std::stringstream stream;
stream << segmentationNode->GetName();
stream << "_";
stream << "3D-interpolation";
segSurface->SetName(stream.str());
segSurface->SetProperty("opacity", mitk::FloatProperty::New(0.7));
segSurface->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(true));
segSurface->SetProperty("3DInterpolationResult", mitk::BoolProperty::New(true));
segSurface->SetVisibility(false);
m_DataStorage->Add(segSurface, segmentationNode);
this->Show3DInterpolationResult(false);
}
}
void ::QmitkSlicesInterpolator::OnSuggestPlaneClicked()
{
if (m_PlaneWatcher.isRunning())
m_PlaneWatcher.waitForFinished();
m_PlaneFuture = QtConcurrent::run(this, &QmitkSlicesInterpolator::RunPlaneSuggestion);
m_PlaneWatcher.setFuture(m_PlaneFuture);
}
void ::QmitkSlicesInterpolator::RunPlaneSuggestion()
{
if (m_FirstRun)
mitk::ProgressBar::GetInstance()->AddStepsToDo(7);
else
mitk::ProgressBar::GetInstance()->AddStepsToDo(3);
m_EdgeDetector->SetSegmentationMask(m_Segmentation);
m_EdgeDetector->SetInput(dynamic_cast<mitk::Image *>(m_ToolManager->GetReferenceData(0)->GetData()));
m_EdgeDetector->Update();
mitk::UnstructuredGrid::Pointer uGrid = mitk::UnstructuredGrid::New();
uGrid->SetVtkUnstructuredGrid(m_EdgeDetector->GetOutput()->GetVtkUnstructuredGrid());
mitk::ProgressBar::GetInstance()->Progress();
mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface *>(m_InterpolatedSurfaceNode->GetData());
vtkSmartPointer<vtkPolyData> vtkpoly = surface->GetVtkPolyData();
vtkSmartPointer<vtkPoints> vtkpoints = vtkpoly->GetPoints();
vtkSmartPointer<vtkUnstructuredGrid> vGrid = vtkSmartPointer<vtkUnstructuredGrid>::New();
vtkSmartPointer<vtkPolyVertex> verts = vtkSmartPointer<vtkPolyVertex>::New();
verts->GetPointIds()->SetNumberOfIds(vtkpoints->GetNumberOfPoints());
for (int i = 0; i < vtkpoints->GetNumberOfPoints(); i++)
{
verts->GetPointIds()->SetId(i, i);
}
vGrid->Allocate(1);
vGrid->InsertNextCell(verts->GetCellType(), verts->GetPointIds());
vGrid->SetPoints(vtkpoints);
mitk::UnstructuredGrid::Pointer interpolationGrid = mitk::UnstructuredGrid::New();
interpolationGrid->SetVtkUnstructuredGrid(vGrid);
m_PointScorer->SetInput(0, uGrid);
m_PointScorer->SetInput(1, interpolationGrid);
m_PointScorer->Update();
mitk::UnstructuredGrid::Pointer scoredGrid = mitk::UnstructuredGrid::New();
scoredGrid = m_PointScorer->GetOutput();
mitk::ProgressBar::GetInstance()->Progress();
double spacing = mitk::SurfaceInterpolationController::GetInstance()->GetDistanceImageSpacing();
mitk::UnstructuredGridClusteringFilter::Pointer clusterFilter = mitk::UnstructuredGridClusteringFilter::New();
clusterFilter->SetInput(scoredGrid);
clusterFilter->SetMeshing(false);
clusterFilter->SetMinPts(4);
clusterFilter->Seteps(spacing);
clusterFilter->Update();
mitk::ProgressBar::GetInstance()->Progress();
// Create plane suggestion
mitk::BaseRenderer::Pointer br =
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0"));
mitk::PlaneProposer planeProposer;
std::vector<mitk::UnstructuredGrid::Pointer> grids = clusterFilter->GetAllClusters();
planeProposer.SetUnstructuredGrids(grids);
mitk::SliceNavigationController::Pointer snc = br->GetSliceNavigationController();
planeProposer.SetSliceNavigationController(snc);
planeProposer.SetUseDistances(true);
try
{
planeProposer.CreatePlaneInfo();
}
catch (const mitk::Exception &e)
{
MITK_ERROR << e.what();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_FirstRun = false;
}
void QmitkSlicesInterpolator::OnReinit3DInterpolation()
{
mitk::NodePredicateProperty::Pointer pred =
mitk::NodePredicateProperty::New("3DContourContainer", mitk::BoolProperty::New(true));
mitk::DataStorage::SetOfObjects::ConstPointer contourNodes =
m_DataStorage->GetDerivations(m_ToolManager->GetWorkingData(0), pred);
if (contourNodes->Size() != 0)
{
m_BtnApply3D->setEnabled(true);
m_3DContourNode = contourNodes->at(0);
mitk::Surface::Pointer contours = dynamic_cast<mitk::Surface *>(m_3DContourNode->GetData());
if (contours)
mitk::SurfaceInterpolationController::GetInstance()->ReinitializeInterpolation(contours);
m_BtnReinit3DInterpolation->setEnabled(false);
}
else
{
m_BtnApply3D->setEnabled(false);
QMessageBox errorInfo;
errorInfo.setWindowTitle("Reinitialize surface interpolation");
errorInfo.setIcon(QMessageBox::Information);
errorInfo.setText("No contours available for the selected segmentation!");
errorInfo.exec();
}
}
void QmitkSlicesInterpolator::OnAcceptAllPopupActivated(QAction *action)
{
try
{
std::map<QAction *, mitk::SliceNavigationController *>::const_iterator iter = ACTION_TO_SLICEDIMENSION.find(action);
if (iter != ACTION_TO_SLICEDIMENSION.end())
{
mitk::SliceNavigationController *slicer = iter->second;
AcceptAllInterpolations(slicer);
}
}
catch (...)
{
/* Showing message box with possible memory error */
QMessageBox errorInfo;
errorInfo.setWindowTitle("Interpolation Process");
errorInfo.setIcon(QMessageBox::Critical);
errorInfo.setText("An error occurred during interpolation. Possible cause: Not enough memory!");
errorInfo.exec();
// additional error message on std::cerr
std::cerr << "Ill construction in " __FILE__ " l. " << __LINE__ << std::endl;
}
}
void QmitkSlicesInterpolator::OnInterpolationActivated(bool on)
{
m_2DInterpolationEnabled = on;
try
{
if (m_DataStorage.IsNotNull())
{
if (on && !m_DataStorage->Exists(m_FeedbackNode))
{
m_DataStorage->Add(m_FeedbackNode);
}
}
}
catch (...)
{
// don't care (double add/remove)
}
if (m_ToolManager)
{
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
mitk::DataNode *referenceNode = m_ToolManager->GetReferenceData(0);
QWidget::setEnabled(workingNode != nullptr);
m_BtnApply2D->setEnabled(on);
m_FeedbackNode->SetVisibility(on);
if (!on)
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
if (workingNode)
{
mitk::Image *segmentation = dynamic_cast<mitk::Image *>(workingNode->GetData());
if (segmentation)
{
m_Interpolator->SetSegmentationVolume(segmentation);
if (referenceNode)
{
mitk::Image *referenceImage = dynamic_cast<mitk::Image *>(referenceNode->GetData());
m_Interpolator->SetReferenceVolume(referenceImage); // may be nullptr
}
}
}
}
UpdateVisibleSuggestion();
}
void QmitkSlicesInterpolator::Run3DInterpolation()
{
m_SurfaceInterpolator->Interpolate();
}
void QmitkSlicesInterpolator::StartUpdateInterpolationTimer()
{
m_Timer->start(500);
}
void QmitkSlicesInterpolator::StopUpdateInterpolationTimer()
{
m_Timer->stop();
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(SURFACE_COLOR_RGB));
mitk::RenderingManager::GetInstance()->RequestUpdate(
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3"))->GetRenderWindow());
}
void QmitkSlicesInterpolator::ChangeSurfaceColor()
{
float currentColor[3];
m_InterpolatedSurfaceNode->GetColor(currentColor);
if (currentColor[2] == SURFACE_COLOR_RGB[2])
{
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 1.0f));
}
else
{
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(SURFACE_COLOR_RGB));
}
m_InterpolatedSurfaceNode->Update();
mitk::RenderingManager::GetInstance()->RequestUpdate(
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3"))->GetRenderWindow());
}
void QmitkSlicesInterpolator::On3DInterpolationActivated(bool on)
{
m_3DInterpolationEnabled = on;
this->CheckSupportedImageDimension();
try
{
if (m_DataStorage.IsNotNull() && m_ToolManager && m_3DInterpolationEnabled)
{
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode)
{
bool isInterpolationResult(false);
workingNode->GetBoolProperty("3DInterpolationResult", isInterpolationResult);
mitk::NodePredicateAnd::Pointer pred = mitk::NodePredicateAnd::New(
mitk::NodePredicateProperty::New("3DInterpolationResult", mitk::BoolProperty::New(true)),
mitk::NodePredicateDataType::New("Surface"));
mitk::DataStorage::SetOfObjects::ConstPointer interpolationResults =
m_DataStorage->GetDerivations(workingNode, pred);
for (unsigned int i = 0; i < interpolationResults->Size(); ++i)
{
mitk::DataNode::Pointer currNode = interpolationResults->at(i);
if (currNode.IsNotNull())
m_DataStorage->Remove(currNode);
}
if ((workingNode->IsVisible(
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")))) &&
!isInterpolationResult && m_3DInterpolationEnabled)
{
int ret = QMessageBox::Yes;
if (m_SurfaceInterpolator->EstimatePortionOfNeededMemory() > 0.5)
{
QMessageBox msgBox;
msgBox.setText("Due to short handed system memory the 3D interpolation may be very slow!");
msgBox.setInformativeText("Are you sure you want to activate the 3D interpolation?");
msgBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
ret = msgBox.exec();
}
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
if (ret == QMessageBox::Yes)
{
m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
m_Watcher.setFuture(m_Future);
}
else
{
m_CmbInterpolation->setCurrentIndex(0);
}
}
else if (!m_3DInterpolationEnabled)
{
this->Show3DInterpolationResult(false);
m_BtnApply3D->setEnabled(m_3DInterpolationEnabled);
m_BtnSuggestPlane->setEnabled(m_3DInterpolationEnabled);
}
}
else
{
QWidget::setEnabled(false);
m_ChkShowPositionNodes->setEnabled(m_3DInterpolationEnabled);
}
}
if (!m_3DInterpolationEnabled)
{
this->Show3DInterpolationResult(false);
m_BtnApply3D->setEnabled(m_3DInterpolationEnabled);
m_BtnSuggestPlane->setEnabled(m_3DInterpolationEnabled);
}
}
catch (...)
{
MITK_ERROR << "Error with 3D surface interpolation!";
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::EnableInterpolation(bool on)
{
// only to be called from the outside world
// just a redirection to OnInterpolationActivated
OnInterpolationActivated(on);
}
void QmitkSlicesInterpolator::Enable3DInterpolation(bool on)
{
// only to be called from the outside world
// just a redirection to OnInterpolationActivated
On3DInterpolationActivated(on);
}
void QmitkSlicesInterpolator::UpdateVisibleSuggestion()
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::OnInterpolationInfoChanged(const itk::EventObject & /*e*/)
{
// something (e.g. undo) changed the interpolation info, we should refresh our display
UpdateVisibleSuggestion();
}
void QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged(const itk::EventObject & /*e*/)
{
if (m_3DInterpolationEnabled)
{
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
m_Watcher.setFuture(m_Future);
}
}
void QmitkSlicesInterpolator::SetCurrentContourListID()
{
// New ContourList = hide current interpolation
Show3DInterpolationResult(false);
if (m_DataStorage.IsNotNull() && m_ToolManager && m_LastSNC)
{
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode)
{
bool isInterpolationResult(false);
workingNode->GetBoolProperty("3DInterpolationResult", isInterpolationResult);
if (!isInterpolationResult)
{
QWidget::setEnabled(true);
const auto timePoint = m_LastSNC->GetSelectedTimePoint();
// In case the time is not valid use 0 to access the time geometry of the working node
unsigned int time_position = 0;
if (!workingNode->GetData()->GetTimeGeometry()->IsValidTimePoint(timePoint))
{
- MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationControl is not within the time bounds of WorkingImage. Time point: " << timePoint;
+ MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationController is not within the time bounds of WorkingImage. Time point: " << timePoint;
}
time_position = workingNode->GetData()->GetTimeGeometry()->TimePointToTimeStep(timePoint);
mitk::Vector3D spacing = workingNode->GetData()->GetGeometry(time_position)->GetSpacing();
double minSpacing(100);
double maxSpacing(0);
for (int i = 0; i < 3; i++)
{
if (spacing[i] < minSpacing)
{
minSpacing = spacing[i];
}
if (spacing[i] > maxSpacing)
{
maxSpacing = spacing[i];
}
}
m_SurfaceInterpolator->SetMaxSpacing(maxSpacing);
m_SurfaceInterpolator->SetMinSpacing(minSpacing);
m_SurfaceInterpolator->SetDistanceImageVolume(50000);
mitk::Image *segmentationImage = dynamic_cast<mitk::Image *>(workingNode->GetData());
m_SurfaceInterpolator->SetCurrentInterpolationSession(segmentationImage);
m_SurfaceInterpolator->SetCurrentTimePoint(timePoint);
if (m_3DInterpolationEnabled)
{
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
m_Watcher.setFuture(m_Future);
}
}
}
else
{
QWidget::setEnabled(false);
}
}
}
void QmitkSlicesInterpolator::Show3DInterpolationResult(bool status)
{
if (m_InterpolatedSurfaceNode.IsNotNull())
m_InterpolatedSurfaceNode->SetVisibility(status);
if (m_3DContourNode.IsNotNull())
m_3DContourNode->SetVisibility(
status, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::CheckSupportedImageDimension()
{
if (m_ToolManager->GetWorkingData(0))
m_Segmentation = dynamic_cast<mitk::Image *>(m_ToolManager->GetWorkingData(0)->GetData());
/*if (m_3DInterpolationEnabled && m_Segmentation && m_Segmentation->GetDimension() != 3)
{
QMessageBox info;
info.setWindowTitle("3D Interpolation Process");
info.setIcon(QMessageBox::Information);
info.setText("3D Interpolation is only supported for 3D images at the moment!");
info.exec();
m_CmbInterpolation->setCurrentIndex(0);
}*/
}
void QmitkSlicesInterpolator::OnSliceNavigationControllerDeleted(const itk::Object *sender,
const itk::EventObject & /*e*/)
{
// Don't know how to avoid const_cast here?!
mitk::SliceNavigationController *slicer =
dynamic_cast<mitk::SliceNavigationController *>(const_cast<itk::Object *>(sender));
if (slicer)
{
m_ControllerToTimeObserverTag.remove(slicer);
m_ControllerToSliceObserverTag.remove(slicer);
m_ControllerToDeleteObserverTag.remove(slicer);
}
}
void QmitkSlicesInterpolator::WaitForFutures()
{
if (m_Watcher.isRunning())
{
m_Watcher.waitForFinished();
}
if (m_PlaneWatcher.isRunning())
{
m_PlaneWatcher.waitForFinished();
}
}
void QmitkSlicesInterpolator::NodeRemoved(const mitk::DataNode* node)
{
if ((m_ToolManager && m_ToolManager->GetWorkingData(0) == node) ||
node == m_3DContourNode ||
node == m_FeedbackNode ||
node == m_InterpolatedSurfaceNode)
{
WaitForFutures();
}
}
diff --git a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
index ae68ebd753..c5de38bbee 100644
--- a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
+++ b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
@@ -1,719 +1,719 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkSurfaceInterpolationController.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkMemoryUtilities.h"
#include "mitkImageToSurfaceFilter.h"
//#include "vtkXMLPolyDataWriter.h"
#include "vtkPolyDataWriter.h"
// Check whether the given contours are coplanar
bool ContoursCoplanar(mitk::SurfaceInterpolationController::ContourPositionInformation leftHandSide,
mitk::SurfaceInterpolationController::ContourPositionInformation rightHandSide)
{
// Here we check two things:
// 1. Whether the normals of both contours are at least parallel
// 2. Whether both contours lie in the same plane
// Check for coplanarity:
// a. Span a vector between two points one from each contour
// b. Calculate dot product for the vector and one of the normals
// c. If the dot is zero the two vectors are orthogonal and the contours are coplanar
double vec[3];
vec[0] = leftHandSide.contourPoint[0] - rightHandSide.contourPoint[0];
vec[1] = leftHandSide.contourPoint[1] - rightHandSide.contourPoint[1];
vec[2] = leftHandSide.contourPoint[2] - rightHandSide.contourPoint[2];
double n[3];
n[0] = rightHandSide.contourNormal[0];
n[1] = rightHandSide.contourNormal[1];
n[2] = rightHandSide.contourNormal[2];
double dot = vtkMath::Dot(n, vec);
double n2[3];
n2[0] = leftHandSide.contourNormal[0];
n2[1] = leftHandSide.contourNormal[1];
n2[2] = leftHandSide.contourNormal[2];
// The normals of both contours have to be parallel but not of the same orientation
double lengthLHS = leftHandSide.contourNormal.GetNorm();
double lengthRHS = rightHandSide.contourNormal.GetNorm();
double dot2 = vtkMath::Dot(n, n2);
bool contoursParallel = mitk::Equal(fabs(lengthLHS * lengthRHS), fabs(dot2), 0.001);
if (mitk::Equal(dot, 0.0, 0.001) && contoursParallel)
return true;
else
return false;
}
mitk::SurfaceInterpolationController::ContourPositionInformation CreateContourPositionInformation(
mitk::Surface::Pointer contour)
{
mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
contourInfo.contour = contour;
double n[3];
double p[3];
contour->GetVtkPolyData()->GetPoints()->GetPoint(0, p);
vtkPolygon::ComputeNormal(contour->GetVtkPolyData()->GetPoints(), n);
contourInfo.contourNormal = n;
contourInfo.contourPoint = p;
return contourInfo;
}
mitk::SurfaceInterpolationController::SurfaceInterpolationController()
: m_SelectedSegmentation(nullptr), m_CurrentTimePoint(0.)
{
m_DistanceImageSpacing = 0.0;
m_ReduceFilter = ReduceContourSetFilter::New();
m_NormalsFilter = ComputeContourSetNormalsFilter::New();
m_InterpolateSurfaceFilter = CreateDistanceImageFromSurfaceFilter::New();
// m_TimeSelector = ImageTimeSelector::New();
m_ReduceFilter->SetUseProgressBar(false);
// m_ReduceFilter->SetProgressStepSize(1);
m_NormalsFilter->SetUseProgressBar(true);
m_NormalsFilter->SetProgressStepSize(1);
m_InterpolateSurfaceFilter->SetUseProgressBar(true);
m_InterpolateSurfaceFilter->SetProgressStepSize(7);
m_Contours = Surface::New();
m_PolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
m_PolyData->SetPoints(points);
m_InterpolationResult = nullptr;
m_CurrentNumberOfReducedContours = 0;
}
mitk::SurfaceInterpolationController::~SurfaceInterpolationController()
{
// Removing all observers
auto dataIter = m_SegmentationObserverTags.begin();
for (; dataIter != m_SegmentationObserverTags.end(); ++dataIter)
{
(*dataIter).first->RemoveObserver((*dataIter).second);
}
m_SegmentationObserverTags.clear();
}
mitk::SurfaceInterpolationController *mitk::SurfaceInterpolationController::GetInstance()
{
static mitk::SurfaceInterpolationController::Pointer m_Instance;
if (m_Instance.IsNull())
{
m_Instance = SurfaceInterpolationController::New();
}
return m_Instance;
}
void mitk::SurfaceInterpolationController::AddNewContour(mitk::Surface::Pointer newContour)
{
if (newContour->GetVtkPolyData()->GetNumberOfPoints() > 0)
{
ContourPositionInformation contourInfo = CreateContourPositionInformation(newContour);
this->AddToInterpolationPipeline(contourInfo);
this->Modified();
}
}
void mitk::SurfaceInterpolationController::AddNewContours(std::vector<mitk::Surface::Pointer> newContours)
{
for (unsigned int i = 0; i < newContours.size(); ++i)
{
if (newContours.at(i)->GetVtkPolyData()->GetNumberOfPoints() > 0)
{
ContourPositionInformation contourInfo = CreateContourPositionInformation(newContours.at(i));
this->AddToInterpolationPipeline(contourInfo);
}
}
this->Modified();
}
void mitk::SurfaceInterpolationController::AddToInterpolationPipeline(ContourPositionInformation contourInfo)
{
if (!m_SelectedSegmentation)
{
return;
}
int pos(-1);
if (!m_SelectedSegmentation->GetTimeGeometry()->IsValidTimePoint(m_CurrentTimePoint))
{
MITK_ERROR << "Invalid time point requested for interpolation pipeline.";
return;
}
const auto currentTimeStep = m_SelectedSegmentation->GetTimeGeometry()->TimePointToTimeStep(m_CurrentTimePoint);
ContourPositionInformationVec2D currentContours = m_ListOfInterpolationSessions[m_SelectedSegmentation];
ContourPositionInformationList currentContourList = currentContours[currentTimeStep];
mitk::Surface *newContour = contourInfo.contour;
for (unsigned int i = 0; i < currentContourList.size(); i++)
{
ContourPositionInformation contourFromList = currentContourList.at(i);
if (ContoursCoplanar(contourInfo, contourFromList))
{
pos = i;
break;
}
}
// Don't save a new empty contour
if (pos == -1 && newContour->GetVtkPolyData()->GetNumberOfPoints() > 0)
{
m_ReduceFilter->SetInput(m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].size(),
newContour);
m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].push_back(contourInfo);
}
else if (pos != -1 && newContour->GetVtkPolyData()->GetNumberOfPoints() > 0)
{
m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].at(pos) = contourInfo;
m_ReduceFilter->SetInput(pos, newContour);
}
else if (newContour->GetVtkPolyData()->GetNumberOfPoints() == 0)
{
this->RemoveContour(contourInfo);
}
}
bool mitk::SurfaceInterpolationController::RemoveContour(ContourPositionInformation contourInfo)
{
if (!m_SelectedSegmentation)
{
return false;
}
if (!m_SelectedSegmentation->GetTimeGeometry()->IsValidTimePoint(m_CurrentTimePoint))
{
return false;
}
const auto currentTimeStep = m_SelectedSegmentation->GetTimeGeometry()->TimePointToTimeStep(m_CurrentTimePoint);
auto it = m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].begin();
while (it != m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].end())
{
ContourPositionInformation currentContour = (*it);
if (ContoursCoplanar(currentContour, contourInfo))
{
m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].erase(it);
this->ReinitializeInterpolation();
return true;
}
++it;
}
return false;
}
const mitk::Surface *mitk::SurfaceInterpolationController::GetContour(ContourPositionInformation contourInfo)
{
if (!m_SelectedSegmentation)
{
return nullptr;
}
if (!m_SelectedSegmentation->GetTimeGeometry()->IsValidTimePoint(m_CurrentTimePoint))
{
return nullptr;
}
const auto currentTimeStep = m_SelectedSegmentation->GetTimeGeometry()->TimePointToTimeStep(m_CurrentTimePoint);
ContourPositionInformationList contourList = m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep];
for (unsigned int i = 0; i < contourList.size(); ++i)
{
ContourPositionInformation currentContour = contourList.at(i);
if (ContoursCoplanar(contourInfo, currentContour))
return currentContour.contour;
}
return nullptr;
}
unsigned int mitk::SurfaceInterpolationController::GetNumberOfContours()
{
if (!m_SelectedSegmentation)
{
return -1;
}
if (!m_SelectedSegmentation->GetTimeGeometry()->IsValidTimePoint(m_CurrentTimePoint))
{
return -1;
}
const auto currentTimeStep = m_SelectedSegmentation->GetTimeGeometry()->TimePointToTimeStep(m_CurrentTimePoint);
return m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].size();
}
void mitk::SurfaceInterpolationController::Interpolate()
{
if (!m_SelectedSegmentation->GetTimeGeometry()->IsValidTimePoint(m_CurrentTimePoint))
{
- MITK_WARN << "No interpolation possible, currently selected timepoint is not in the time bounds of currently selecte segmentation. Time point: " << m_CurrentTimePoint;
+ MITK_WARN << "No interpolation possible, currently selected timepoint is not in the time bounds of currently selected segmentation. Time point: " << m_CurrentTimePoint;
m_InterpolationResult = nullptr;
return;
}
const auto currentTimeStep = m_SelectedSegmentation->GetTimeGeometry()->TimePointToTimeStep(m_CurrentTimePoint);
m_ReduceFilter->Update();
m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
if (m_CurrentNumberOfReducedContours == 1)
{
vtkPolyData *tmp = m_ReduceFilter->GetOutput(0)->GetVtkPolyData();
if (tmp == nullptr)
{
m_CurrentNumberOfReducedContours = 0;
}
}
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(m_SelectedSegmentation);
timeSelector->SetTimeNr(currentTimeStep);
timeSelector->SetChannelNr(0);
timeSelector->Update();
mitk::Image::Pointer refSegImage = timeSelector->GetOutput();
m_NormalsFilter->SetSegmentationBinaryImage(refSegImage);
for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
{
mitk::Surface::Pointer reducedContour = m_ReduceFilter->GetOutput(i);
reducedContour->DisconnectPipeline();
m_NormalsFilter->SetInput(i, reducedContour);
m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
}
if (m_CurrentNumberOfReducedContours < 2)
{
// If no interpolation is possible reset the interpolation result
m_InterpolationResult = nullptr;
return;
}
// Setting up progress bar
mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
// create a surface from the distance-image
mitk::ImageToSurfaceFilter::Pointer imageToSurfaceFilter = mitk::ImageToSurfaceFilter::New();
imageToSurfaceFilter->SetInput(m_InterpolateSurfaceFilter->GetOutput());
imageToSurfaceFilter->SetThreshold(0);
imageToSurfaceFilter->SetSmooth(true);
imageToSurfaceFilter->SetSmoothIteration(20);
imageToSurfaceFilter->Update();
mitk::Surface::Pointer interpolationResult = mitk::Surface::New();
interpolationResult->SetVtkPolyData(imageToSurfaceFilter->GetOutput()->GetVtkPolyData(), currentTimeStep);
m_InterpolationResult = interpolationResult;
m_DistanceImageSpacing = m_InterpolateSurfaceFilter->GetDistanceImageSpacing();
vtkSmartPointer<vtkAppendPolyData> polyDataAppender = vtkSmartPointer<vtkAppendPolyData>::New();
for (unsigned int i = 0; i < m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].size(); i++)
{
polyDataAppender->AddInputData(
m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].at(i).contour->GetVtkPolyData());
}
polyDataAppender->Update();
m_Contours->SetVtkPolyData(polyDataAppender->GetOutput());
// Last progress step
mitk::ProgressBar::GetInstance()->Progress(20);
m_InterpolationResult->DisconnectPipeline();
}
mitk::Surface::Pointer mitk::SurfaceInterpolationController::GetInterpolationResult()
{
return m_InterpolationResult;
}
mitk::Surface *mitk::SurfaceInterpolationController::GetContoursAsSurface()
{
return m_Contours;
}
void mitk::SurfaceInterpolationController::SetDataStorage(DataStorage::Pointer ds)
{
m_DataStorage = ds;
}
void mitk::SurfaceInterpolationController::SetMinSpacing(double minSpacing)
{
m_ReduceFilter->SetMinSpacing(minSpacing);
}
void mitk::SurfaceInterpolationController::SetMaxSpacing(double maxSpacing)
{
m_ReduceFilter->SetMaxSpacing(maxSpacing);
m_NormalsFilter->SetMaxSpacing(maxSpacing);
}
void mitk::SurfaceInterpolationController::SetDistanceImageVolume(unsigned int distImgVolume)
{
m_InterpolateSurfaceFilter->SetDistanceImageVolume(distImgVolume);
}
mitk::Image::Pointer mitk::SurfaceInterpolationController::GetCurrentSegmentation()
{
return m_SelectedSegmentation;
}
mitk::Image *mitk::SurfaceInterpolationController::GetImage()
{
return m_InterpolateSurfaceFilter->GetOutput();
}
double mitk::SurfaceInterpolationController::EstimatePortionOfNeededMemory()
{
double numberOfPointsAfterReduction = m_ReduceFilter->GetNumberOfPointsAfterReduction() * 3;
double sizeOfPoints = pow(numberOfPointsAfterReduction, 2) * sizeof(double);
double totalMem = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
double percentage = sizeOfPoints / totalMem;
return percentage;
}
unsigned int mitk::SurfaceInterpolationController::GetNumberOfInterpolationSessions()
{
return m_ListOfInterpolationSessions.size();
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::SurfaceInterpolationController::GetImageBase(itk::Image<TPixel, VImageDimension> *input,
itk::ImageBase<3>::Pointer &result)
{
result->Graft(input);
}
void mitk::SurfaceInterpolationController::SetCurrentSegmentationInterpolationList(mitk::Image::Pointer segmentation)
{
this->SetCurrentInterpolationSession(segmentation);
}
void mitk::SurfaceInterpolationController::SetCurrentInterpolationSession(mitk::Image::Pointer currentSegmentationImage)
{
if (currentSegmentationImage.GetPointer() == m_SelectedSegmentation)
return;
if (currentSegmentationImage.IsNull())
{
m_SelectedSegmentation = nullptr;
return;
}
m_SelectedSegmentation = currentSegmentationImage.GetPointer();
auto it = m_ListOfInterpolationSessions.find(currentSegmentationImage.GetPointer());
// If the session does not exist yet create a new ContourPositionPairList otherwise reinitialize the interpolation
// pipeline
if (it == m_ListOfInterpolationSessions.end())
{
ContourPositionInformationVec2D newList;
m_ListOfInterpolationSessions.insert(
std::pair<mitk::Image *, ContourPositionInformationVec2D>(m_SelectedSegmentation, newList));
m_InterpolationResult = nullptr;
m_CurrentNumberOfReducedContours = 0;
itk::MemberCommand<SurfaceInterpolationController>::Pointer command =
itk::MemberCommand<SurfaceInterpolationController>::New();
command->SetCallbackFunction(this, &SurfaceInterpolationController::OnSegmentationDeleted);
m_SegmentationObserverTags.insert(std::pair<mitk::Image *, unsigned long>(
m_SelectedSegmentation, m_SelectedSegmentation->AddObserver(itk::DeleteEvent(), command)));
}
this->ReinitializeInterpolation();
}
bool mitk::SurfaceInterpolationController::ReplaceInterpolationSession(mitk::Image::Pointer oldSession,
mitk::Image::Pointer newSession)
{
if (oldSession.IsNull() || newSession.IsNull())
return false;
if (oldSession.GetPointer() == newSession.GetPointer())
return false;
if (!mitk::Equal(*(oldSession->GetGeometry()), *(newSession->GetGeometry()), mitk::eps, false))
return false;
auto it = m_ListOfInterpolationSessions.find(oldSession.GetPointer());
if (it == m_ListOfInterpolationSessions.end())
return false;
if (!newSession->GetTimeGeometry()->IsValidTimePoint(m_CurrentTimePoint))
{
MITK_WARN << "Interpolation session cannot be replaced. Currently selected timepoint is not in the time bounds of the new session. Time point: " << m_CurrentTimePoint;
return false;
}
ContourPositionInformationVec2D oldList = (*it).second;
m_ListOfInterpolationSessions.insert(
std::pair<mitk::Image *, ContourPositionInformationVec2D>(newSession.GetPointer(), oldList));
itk::MemberCommand<SurfaceInterpolationController>::Pointer command =
itk::MemberCommand<SurfaceInterpolationController>::New();
command->SetCallbackFunction(this, &SurfaceInterpolationController::OnSegmentationDeleted);
m_SegmentationObserverTags.insert(
std::pair<mitk::Image *, unsigned long>(newSession, newSession->AddObserver(itk::DeleteEvent(), command)));
if (m_SelectedSegmentation == oldSession)
m_SelectedSegmentation = newSession;
const auto currentTimeStep = m_SelectedSegmentation->GetTimeGeometry()->TimePointToTimeStep(m_CurrentTimePoint);
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(m_SelectedSegmentation);
timeSelector->SetTimeNr(currentTimeStep);
timeSelector->SetChannelNr(0);
timeSelector->Update();
mitk::Image::Pointer refSegImage = timeSelector->GetOutput();
m_NormalsFilter->SetSegmentationBinaryImage(refSegImage);
this->RemoveInterpolationSession(oldSession);
return true;
}
void mitk::SurfaceInterpolationController::RemoveSegmentationFromContourList(mitk::Image *segmentation)
{
this->RemoveInterpolationSession(segmentation);
}
void mitk::SurfaceInterpolationController::RemoveInterpolationSession(mitk::Image::Pointer segmentationImage)
{
if (segmentationImage)
{
if (m_SelectedSegmentation == segmentationImage)
{
m_NormalsFilter->SetSegmentationBinaryImage(nullptr);
m_SelectedSegmentation = nullptr;
}
m_ListOfInterpolationSessions.erase(segmentationImage);
// Remove observer
auto pos = m_SegmentationObserverTags.find(segmentationImage);
if (pos != m_SegmentationObserverTags.end())
{
segmentationImage->RemoveObserver((*pos).second);
m_SegmentationObserverTags.erase(pos);
}
}
}
void mitk::SurfaceInterpolationController::RemoveAllInterpolationSessions()
{
// Removing all observers
auto dataIter = m_SegmentationObserverTags.begin();
while (dataIter != m_SegmentationObserverTags.end())
{
mitk::Image *image = (*dataIter).first;
image->RemoveObserver((*dataIter).second);
++dataIter;
}
m_SegmentationObserverTags.clear();
m_SelectedSegmentation = nullptr;
m_ListOfInterpolationSessions.clear();
}
void mitk::SurfaceInterpolationController::ReinitializeInterpolation(mitk::Surface::Pointer contours)
{
// 1. detect coplanar contours
// 2. merge coplanar contours into a single surface
// 4. add contour to pipeline
// Split the surface into separate polygons
vtkSmartPointer<vtkCellArray> existingPolys;
vtkSmartPointer<vtkPoints> existingPoints;
existingPolys = contours->GetVtkPolyData()->GetPolys();
existingPoints = contours->GetVtkPolyData()->GetPoints();
existingPolys->InitTraversal();
vtkSmartPointer<vtkIdList> ids = vtkSmartPointer<vtkIdList>::New();
typedef std::pair<mitk::Vector3D, mitk::Point3D> PointNormalPair;
std::vector<ContourPositionInformation> list;
std::vector<vtkSmartPointer<vtkPoints>> pointsList;
int count(0);
for (existingPolys->InitTraversal(); existingPolys->GetNextCell(ids);)
{
// Get the points
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
existingPoints->GetPoints(ids, points);
++count;
pointsList.push_back(points);
PointNormalPair p_n;
double n[3];
vtkPolygon::ComputeNormal(points, n);
p_n.first = n;
double p[3];
existingPoints->GetPoint(ids->GetId(0), p);
p_n.second = p;
ContourPositionInformation p_info;
p_info.contourNormal = n;
p_info.contourPoint = p;
list.push_back(p_info);
continue;
}
// Detect and sort coplanar polygons
auto outer = list.begin();
std::vector<std::vector<vtkSmartPointer<vtkPoints>>> relatedPoints;
while (outer != list.end())
{
auto inner = outer;
++inner;
std::vector<vtkSmartPointer<vtkPoints>> rel;
auto pointsIter = pointsList.begin();
rel.push_back((*pointsIter));
pointsIter = pointsList.erase(pointsIter);
while (inner != list.end())
{
if (ContoursCoplanar((*outer), (*inner)))
{
inner = list.erase(inner);
rel.push_back((*pointsIter));
pointsIter = pointsList.erase(pointsIter);
}
else
{
++inner;
++pointsIter;
}
}
relatedPoints.push_back(rel);
++outer;
}
// Build the separate surfaces again
std::vector<mitk::Surface::Pointer> finalSurfaces;
for (unsigned int i = 0; i < relatedPoints.size(); ++i)
{
vtkSmartPointer<vtkPolyData> contourSurface = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> polygons = vtkSmartPointer<vtkCellArray>::New();
unsigned int pointId(0);
for (unsigned int j = 0; j < relatedPoints.at(i).size(); ++j)
{
unsigned int numPoints = relatedPoints.at(i).at(j)->GetNumberOfPoints();
vtkSmartPointer<vtkPolygon> polygon = vtkSmartPointer<vtkPolygon>::New();
polygon->GetPointIds()->SetNumberOfIds(numPoints);
polygon->GetPoints()->SetNumberOfPoints(numPoints);
vtkSmartPointer<vtkPoints> currentPoints = relatedPoints.at(i).at(j);
for (unsigned k = 0; k < numPoints; ++k)
{
points->InsertPoint(pointId, currentPoints->GetPoint(k));
polygon->GetPointIds()->SetId(k, pointId);
++pointId;
}
polygons->InsertNextCell(polygon);
}
contourSurface->SetPoints(points);
contourSurface->SetPolys(polygons);
contourSurface->BuildLinks();
mitk::Surface::Pointer surface = mitk::Surface::New();
surface->SetVtkPolyData(contourSurface);
finalSurfaces.push_back(surface);
}
// Add detected contours to interpolation pipeline
this->AddNewContours(finalSurfaces);
}
void mitk::SurfaceInterpolationController::OnSegmentationDeleted(const itk::Object *caller,
const itk::EventObject & /*event*/)
{
auto *tempImage = dynamic_cast<mitk::Image *>(const_cast<itk::Object *>(caller));
if (tempImage)
{
if (m_SelectedSegmentation == tempImage)
{
m_NormalsFilter->SetSegmentationBinaryImage(nullptr);
m_SelectedSegmentation = nullptr;
}
m_SegmentationObserverTags.erase(tempImage);
m_ListOfInterpolationSessions.erase(tempImage);
}
}
void mitk::SurfaceInterpolationController::ReinitializeInterpolation()
{
// If session has changed reset the pipeline
m_ReduceFilter->Reset();
m_NormalsFilter->Reset();
m_InterpolateSurfaceFilter->Reset();
itk::ImageBase<3>::Pointer itkImage = itk::ImageBase<3>::New();
if (m_SelectedSegmentation)
{
if (!m_SelectedSegmentation->GetTimeGeometry()->IsValidTimePoint(m_CurrentTimePoint))
{
MITK_WARN << "Interpolation cannot be reinitialized. Currently selected timepoint is not in the time bounds of the currently selected segmentation. Time point: " << m_CurrentTimePoint;
return;
}
const auto currentTimeStep = m_SelectedSegmentation->GetTimeGeometry()->TimePointToTimeStep(m_CurrentTimePoint);
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(m_SelectedSegmentation);
timeSelector->SetTimeNr(currentTimeStep);
timeSelector->SetChannelNr(0);
timeSelector->Update();
mitk::Image::Pointer refSegImage = timeSelector->GetOutput();
AccessFixedDimensionByItk_1(refSegImage, GetImageBase, 3, itkImage);
m_InterpolateSurfaceFilter->SetReferenceImage(itkImage.GetPointer());
unsigned int numTimeSteps = m_SelectedSegmentation->GetTimeSteps();
unsigned int size = m_ListOfInterpolationSessions[m_SelectedSegmentation].size();
if (size != numTimeSteps)
{
m_ListOfInterpolationSessions[m_SelectedSegmentation].resize(numTimeSteps);
}
if (currentTimeStep < numTimeSteps)
{
unsigned int numContours = m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep].size();
for (unsigned int c = 0; c < numContours; ++c)
{
m_ReduceFilter->SetInput(c,
m_ListOfInterpolationSessions[m_SelectedSegmentation][currentTimeStep][c].contour);
}
m_ReduceFilter->Update();
m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
if (m_CurrentNumberOfReducedContours == 1)
{
vtkPolyData *tmp = m_ReduceFilter->GetOutput(0)->GetVtkPolyData();
if (tmp == nullptr)
{
m_CurrentNumberOfReducedContours = 0;
}
}
for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
{
m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
}
}
Modified();
}
}
diff --git a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h
index 8026122d02..55d0bce56e 100644
--- a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h
+++ b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h
@@ -1,249 +1,250 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkSurfaceInterpolationController_h_Included
#define mitkSurfaceInterpolationController_h_Included
#include "mitkColorProperty.h"
#include "mitkCommon.h"
#include "mitkInteractionConst.h"
#include "mitkProperties.h"
#include "mitkRestorePlanePositionOperation.h"
#include "mitkSurface.h"
#include <MitkSurfaceInterpolationExports.h>
#include "mitkComputeContourSetNormalsFilter.h"
#include "mitkCreateDistanceImageFromSurfaceFilter.h"
#include "mitkReduceContourSetFilter.h"
#include "mitkDataNode.h"
#include "mitkDataStorage.h"
#include "vtkAppendPolyData.h"
#include "vtkCellArray.h"
#include "vtkPoints.h"
#include "vtkPolyData.h"
#include "vtkPolygon.h"
#include "vtkSmartPointer.h"
#include "mitkImageTimeSelector.h"
#include "mitkVtkRepresentationProperty.h"
#include "vtkImageData.h"
#include "vtkMarchingCubes.h"
#include "vtkProperty.h"
#include "mitkProgressBar.h"
namespace mitk
{
class MITKSURFACEINTERPOLATION_EXPORT SurfaceInterpolationController : public itk::Object
{
public:
mitkClassMacroItkParent(SurfaceInterpolationController, itk::Object);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
itkGetMacro(DistanceImageSpacing, double);
struct ContourPositionInformation
{
Surface::Pointer contour;
Vector3D contourNormal;
Point3D contourPoint;
};
typedef std::vector<ContourPositionInformation> ContourPositionInformationList;
typedef std::vector<ContourPositionInformationList> ContourPositionInformationVec2D;
typedef std::map<mitk::Image *, ContourPositionInformationVec2D> ContourListMap;
static SurfaceInterpolationController *GetInstance();
void SetCurrentTimePoint(TimePointType tp)
{
if (m_CurrentTimePoint != tp)
{
m_CurrentTimePoint = tp;
if (m_SelectedSegmentation)
{
this->ReinitializeInterpolation();
}
}
};
- unsigned int GetCurrentTimePoint() { return m_CurrentTimePoint; };
+ TimePointType GetCurrentTimePoint() const { return m_CurrentTimePoint; };
+
/**
* @brief Adds a new extracted contour to the list
* @param newContour the contour to be added. If a contour at that position
* already exists the related contour will be updated
*/
void AddNewContour(Surface::Pointer newContour);
/**
* @brief Removes the contour for a given plane for the current selected segmenation
* @param contourInfo the contour which should be removed
* @return true if a contour was found and removed, false if no contour was found
*/
bool RemoveContour(ContourPositionInformation contourInfo);
/**
* @brief Adds new extracted contours to the list. If one or more contours at a given position
* already exist they will be updated respectively
* @param newContours the list of the contours
*/
void AddNewContours(std::vector<Surface::Pointer> newContours);
/**
* @brief Returns the contour for a given plane for the current selected segmenation
* @param ontourInfo the contour which should be returned
* @return the contour as an mitk::Surface. If no contour is available at the give position nullptr is returned
*/
const mitk::Surface *GetContour(ContourPositionInformation contourInfo);
/**
* @brief Returns the number of available contours for the current selected segmentation
* @return the number of contours
*/
unsigned int GetNumberOfContours();
/**
* Interpolates the 3D surface from the given extracted contours
*/
void Interpolate();
mitk::Surface::Pointer GetInterpolationResult();
/**
* Sets the minimum spacing of the current selected segmentation
* This is needed since the contour points we reduced before they are used to interpolate the surface
*/
void SetMinSpacing(double minSpacing);
/**
* Sets the minimum spacing of the current selected segmentation
* This is needed since the contour points we reduced before they are used to interpolate the surface
*/
void SetMaxSpacing(double maxSpacing);
/**
* Sets the volume i.e. the number of pixels that the distance image should have
* By evaluation we found out that 50.000 pixel delivers a good result
*/
void SetDistanceImageVolume(unsigned int distImageVolume);
/**
* @brief Get the current selected segmentation for which the interpolation is performed
* @return the current segmentation image
*/
mitk::Image::Pointer GetCurrentSegmentation();
Surface *GetContoursAsSurface();
void SetDataStorage(DataStorage::Pointer ds);
/**
* Sets the current list of contourpoints which is used for the surface interpolation
* @param segmentation The current selected segmentation
* \deprecatedSince{2014_03}
*/
DEPRECATED(void SetCurrentSegmentationInterpolationList(mitk::Image::Pointer segmentation));
/**
* Sets the current list of contourpoints which is used for the surface interpolation
* @param segmentation The current selected segmentation
*/
void SetCurrentInterpolationSession(mitk::Image::Pointer currentSegmentationImage);
/**
* Removes the segmentation and all its contours from the list
* @param segmentation The segmentation to be removed
* \deprecatedSince{2014_03}
*/
DEPRECATED(void RemoveSegmentationFromContourList(mitk::Image *segmentation));
/**
* @brief Remove interpolation session
* @param segmentationImage the session to be removed
*/
void RemoveInterpolationSession(mitk::Image::Pointer segmentationImage);
/**
* Replaces the current interpolation session with a new one. All contours form the old
* session will be applied to the new session. This only works if the two images have the
* geometry
* @param oldSession the session which should be replaced
* @param newSession the new session which replaces the old one
* @return true it the the replacement was successful, false if not (e.g. the image's geometry differs)
*/
bool ReplaceInterpolationSession(mitk::Image::Pointer oldSession, mitk::Image::Pointer newSession);
/**
* @brief Removes all sessions
*/
void RemoveAllInterpolationSessions();
/**
* @brief Reinitializes the interpolation using the provided contour data
* @param contours a mitk::Surface which contains the contours as polys in the vtkPolyData
*/
void ReinitializeInterpolation(mitk::Surface::Pointer contours);
mitk::Image *GetImage();
/**
* Estimates the memory which is needed to build up the equationsystem for the interpolation.
* \returns The percentage of the real memory which will be used by the interpolation
*/
double EstimatePortionOfNeededMemory();
unsigned int GetNumberOfInterpolationSessions();
protected:
SurfaceInterpolationController();
~SurfaceInterpolationController() override;
template <typename TPixel, unsigned int VImageDimension>
void GetImageBase(itk::Image<TPixel, VImageDimension> *input, itk::ImageBase<3>::Pointer &result);
private:
void ReinitializeInterpolation();
void OnSegmentationDeleted(const itk::Object *caller, const itk::EventObject &event);
void AddToInterpolationPipeline(ContourPositionInformation contourInfo);
ReduceContourSetFilter::Pointer m_ReduceFilter;
ComputeContourSetNormalsFilter::Pointer m_NormalsFilter;
CreateDistanceImageFromSurfaceFilter::Pointer m_InterpolateSurfaceFilter;
Surface::Pointer m_Contours;
double m_DistanceImageSpacing;
vtkSmartPointer<vtkPolyData> m_PolyData;
mitk::DataStorage::Pointer m_DataStorage;
ContourListMap m_ListOfInterpolationSessions;
mitk::Surface::Pointer m_InterpolationResult;
unsigned int m_CurrentNumberOfReducedContours;
mitk::Image *m_SelectedSegmentation;
std::map<mitk::Image *, unsigned long> m_SegmentationObserverTags;
mitk::TimePointType m_CurrentTimePoint;
};
}
#endif