diff --git a/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp b/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp
index f28fd4cd94..3374dcfea6 100644
--- a/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp
+++ b/Modules/Core/src/Interactions/mitkPointSetDataInteractor.cpp
@@ -1,622 +1,622 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetDataInteractor.h"
#include "mitkMouseMoveEvent.h"
#include "mitkInteractionConst.h" // TODO: refactor file
#include "mitkInternalEvent.h"
#include "mitkOperationEvent.h"
#include "mitkRenderingManager.h"
#include <mitkPointOperation.h>
//
#include "mitkBaseRenderer.h"
#include "mitkDispatcher.h"
#include "mitkUndoController.h"
void mitk::PointSetDataInteractor::ConnectActionsAndFunctions()
{
// Condition which is evaluated before transition is taken
// following actions in the statemachine are only executed if it returns TRUE
CONNECT_CONDITION("isoverpoint", CheckSelection);
CONNECT_FUNCTION("addpoint", AddPoint);
CONNECT_FUNCTION("selectpoint", SelectPoint);
CONNECT_FUNCTION("unselect", UnSelectPointAtPosition);
CONNECT_FUNCTION("unselectAll", UnSelectAll);
CONNECT_FUNCTION("initMove", InitMove);
CONNECT_FUNCTION("movePoint", MovePoint);
CONNECT_FUNCTION("finishMovement", FinishMove);
CONNECT_FUNCTION("removePoint", RemovePoint);
}
void mitk::PointSetDataInteractor::AddPoint(StateMachineAction *stateMachineAction, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
// disallow adding of new points if maximum number of points is reached
if (m_MaxNumberOfPoints > 1 && m_PointSet->GetSize(timeStep) >= m_MaxNumberOfPoints)
{
return;
}
// To add a point the minimal information is the position, this method accepts all InteractionsPositionEvents
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
mitk::Point3D itkPoint = positionEvent->GetPositionInWorld();
this->UnselectAll(timeStep, timeInMs);
int lastPosition = 0;
mitk::PointSet::PointsIterator it, end;
it = m_PointSet->Begin(timeStep);
end = m_PointSet->End(timeStep);
while (it != end)
{
if (!m_PointSet->IndexExists(lastPosition, timeStep))
break;
++it;
++lastPosition;
}
// Insert a Point to the PointSet
// 2) Create the Operation inserting the point
-
+ if (m_PointSet->IsEmpty()) { lastPosition = 0; }
PointOperation *doOp = new mitk::PointOperation(OpINSERT, timeInMs, itkPoint, lastPosition);
// 3) If Undo is enabled, also create the inverse Operation
if (m_UndoEnabled)
{
PointOperation *undoOp = new mitk::PointOperation(OpREMOVE, timeInMs, itkPoint, lastPosition);
// 4) Do and Undo Operations are combined in an Operation event which also contains the target of the operations
// (here m_PointSet)
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Add point");
// 5) Store the Operation in the UndoController
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}
// 6) Execute the Operation performs the actual insertion of the point into the PointSet
m_PointSet->ExecuteOperation(doOp);
// 7) If Undo is not enabled the Do-Operation is to be dropped to prevent memory leaks.
if (!m_UndoEnabled)
delete doOp;
// Request update
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
// Check if points form a closed contour now, if so fire an InternalEvent
IsClosedContour(stateMachineAction, interactionEvent);
if (m_MaxNumberOfPoints > 0 && m_PointSet->GetSize(timeStep) >= m_MaxNumberOfPoints)
{
// Signal that DataNode is fully filled
this->NotifyResultReady();
// Send internal event that can be used by StateMachines to switch in a different state
InternalEvent::Pointer event = InternalEvent::New(NULL, this, "MaximalNumberOfPoints");
positionEvent->GetSender()->GetDispatcher()->QueueEvent(event.GetPointer());
}
}
}
void mitk::PointSetDataInteractor::SelectPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
Point3D point = positionEvent->GetPositionInWorld();
// iterate over point set and check if it contains a point close enough to the pointer to be selected
int index = GetPointIndexByPosition(point, timeStep);
if (index != -1)
{
// first deselect the other points
// undoable deselect of all points in the DataList
this->UnselectAll(timeStep, timeInMs);
PointOperation *doOp = new mitk::PointOperation(OpSELECTPOINT, timeInMs, point, index);
/*if (m_UndoEnabled)
{
PointOperation* undoOp = new mitk::PointOperation(OpDESELECTPOINT,timeInMs,point, index);
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Select Point");
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}*/
// execute the Operation
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
}
}
mitk::PointSetDataInteractor::PointSetDataInteractor() : m_MaxNumberOfPoints(0), m_SelectionAccuracy(3.5)
{
}
mitk::PointSetDataInteractor::~PointSetDataInteractor()
{
}
void mitk::PointSetDataInteractor::RemovePoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
mitk::Point3D itkPoint = positionEvent->GetPositionInWorld();
// search the point in the list
int position = m_PointSet->SearchPoint(itkPoint, m_SelectionAccuracy, timeStep);
if (position >= 0) // found a point
{
PointSet::PointType pt = m_PointSet->GetPoint(position, timeStep);
itkPoint[0] = pt[0];
itkPoint[1] = pt[1];
itkPoint[2] = pt[2];
PointOperation *doOp = new mitk::PointOperation(OpREMOVE, timeInMs, itkPoint, position);
if (m_UndoEnabled) // write to UndoMechanism
{
PointOperation *undoOp = new mitk::PointOperation(OpINSERT, timeInMs, itkPoint, position);
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Remove point");
mitk::OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}
// execute the Operation
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
/*now select the point "position-1",
and if it is the first in list,
then continue at the last in list*/
// only then a select of a point is possible!
if (m_PointSet->GetSize(timeStep) > 0)
{
this->SelectPoint(m_PointSet->Begin(timeStep)->Index(), timeStep, timeInMs);
}
}
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
}
void mitk::PointSetDataInteractor::IsClosedContour(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
Point3D point = positionEvent->GetPositionInWorld();
// iterate over point set and check if it contains a point close enough to the pointer to be selected
if (GetPointIndexByPosition(point, timeStep) != -1 && m_PointSet->GetSize(timeStep) >= 3)
{
InternalEvent::Pointer event = InternalEvent::New(NULL, this, "ClosedContour");
positionEvent->GetSender()->GetDispatcher()->QueueEvent(event.GetPointer());
}
}
}
void mitk::PointSetDataInteractor::MovePoint(StateMachineAction *stateMachineAction, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
IsClosedContour(stateMachineAction, interactionEvent);
mitk::Point3D newPoint, resultPoint;
newPoint = positionEvent->GetPositionInWorld();
// search the elements in the list that are selected then calculate the
// vector, because only with the vector we can move several elements in
// the same direction
// newPoint - lastPoint = vector
// then move all selected and set the lastPoint = newPoint.
// then add all vectors to a summeryVector (to be able to calculate the
// startpoint for undoOperation)
mitk::Vector3D dirVector = newPoint - m_LastPoint;
// sum up all Movement for Undo in FinishMovement
m_SumVec = m_SumVec + dirVector;
mitk::PointSet::PointsIterator it, end;
it = m_PointSet->Begin(timeStep);
end = m_PointSet->End(timeStep);
while (it != end)
{
int position = it->Index();
if (m_PointSet->GetSelectInfo(position, timeStep)) // if selected
{
PointSet::PointType pt = m_PointSet->GetPoint(position, timeStep);
mitk::Point3D sumVec;
sumVec[0] = pt[0];
sumVec[1] = pt[1];
sumVec[2] = pt[2];
resultPoint = sumVec + dirVector;
PointOperation *doOp = new mitk::PointOperation(OpMOVE, timeInMs, resultPoint, position);
// execute the Operation
// here no undo is stored, because the movement-steps aren't interesting.
// only the start and the end is interisting to store for undo.
m_PointSet->ExecuteOperation(doOp);
delete doOp;
}
++it;
}
m_LastPoint = newPoint; // for calculation of the direction vector
// Update the display
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
IsClosedContour(stateMachineAction, interactionEvent);
}
}
void mitk::PointSetDataInteractor::UnSelectPointAtPosition(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
Point3D point = positionEvent->GetPositionInWorld();
// iterate over point set and check if it contains a point close enough to the pointer to be selected
int index = GetPointIndexByPosition(point, timeStep);
// here it is ensured that we don't switch from one point being selected to another one being selected,
// without accepting the unselect of the current point
if (index != -1)
{
PointOperation *doOp = new mitk::PointOperation(OpDESELECTPOINT, timeInMs, point, index);
/*if (m_UndoEnabled)
{
PointOperation* undoOp = new mitk::PointOperation(OpSELECTPOINT,timeInMs, point, index);
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Unselect Point");
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}*/
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
}
}
void mitk::PointSetDataInteractor::UnSelectAll(mitk::StateMachineAction *, mitk::InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
Point3D positioninWorld = positionEvent->GetPositionInWorld();
PointSet::PointsContainer::Iterator it, end;
PointSet::DataType *itkPointSet = m_PointSet->GetPointSet(timeStep);
end = itkPointSet->GetPoints()->End();
for (it = itkPointSet->GetPoints()->Begin(); it != end; it++)
{
int position = it->Index();
// then declare an operation which unselects this point;
// UndoOperation as well!
if (m_PointSet->GetSelectInfo(position, timeStep))
{
float distance = sqrt(positioninWorld.SquaredEuclideanDistanceTo(m_PointSet->GetPoint(position, timeStep)));
if (distance > m_SelectionAccuracy)
{
mitk::Point3D noPoint;
noPoint.Fill(0);
mitk::PointOperation *doOp = new mitk::PointOperation(OpDESELECTPOINT, timeInMs, noPoint, position);
/*if ( m_UndoEnabled )
{
mitk::PointOperation* undoOp = new mitk::PointOperation(OpSELECTPOINT, timeInMs, noPoint, position);
OperationEvent *operationEvent = new OperationEvent( m_PointSet, doOp, undoOp, "Unselect Point" );
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent( operationEvent );
}*/
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
}
}
}
else
{
this->UnselectAll(timeStep, timeInMs);
}
}
void mitk::PointSetDataInteractor::UpdatePointSet(mitk::StateMachineAction *, mitk::InteractionEvent *)
{
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(this->GetDataNode()->GetData());
if (pointSet == NULL)
{
MITK_ERROR << "PointSetDataInteractor:: No valid point set .";
return;
}
m_PointSet = pointSet;
}
void mitk::PointSetDataInteractor::Abort(StateMachineAction *, InteractionEvent *interactionEvent)
{
InternalEvent::Pointer event = InternalEvent::New(NULL, this, IntDeactivateMe);
interactionEvent->GetSender()->GetDispatcher()->QueueEvent(event.GetPointer());
}
/*
* Check whether the DataNode contains a pointset, if not create one and add it.
*/
void mitk::PointSetDataInteractor::DataNodeChanged()
{
if (GetDataNode() != nullptr)
{
PointSet *points = dynamic_cast<PointSet *>(GetDataNode()->GetData());
if (points == NULL)
{
m_PointSet = PointSet::New();
GetDataNode()->SetData(m_PointSet);
}
else
{
m_PointSet = points;
}
// load config file parameter: maximal number of points
mitk::PropertyList::Pointer properties = GetAttributes();
std::string strNumber;
if (properties->GetStringProperty("MaxPoints", strNumber))
{
m_MaxNumberOfPoints = atoi(strNumber.c_str());
}
}
}
void mitk::PointSetDataInteractor::InitMove(StateMachineAction *, InteractionEvent *interactionEvent)
{
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent == NULL)
return;
// start of the Movement is stored to calculate the undoKoordinate
// in FinishMovement
m_LastPoint = positionEvent->GetPositionInWorld();
// initialize a value to calculate the movement through all
// MouseMoveEvents from MouseClick to MouseRelease
m_SumVec.Fill(0);
GetDataNode()->SetProperty("contourcolor", ColorProperty::New(1.0, 1.0, 1.0));
}
void mitk::PointSetDataInteractor::FinishMove(StateMachineAction *, InteractionEvent *interactionEvent)
{
unsigned int timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
ScalarType timeInMs = interactionEvent->GetSender()->GetTime();
InteractionPositionEvent *positionEvent = dynamic_cast<InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
// finish the movement:
// the final point is m_LastPoint
// m_SumVec stores the movement in a vector
// the operation would not be necessary, but we need it for the undo Operation.
// m_LastPoint is for the Operation
// the point for undoOperation calculates from all selected
// elements (point) - m_SumVec
// search all selected elements and move them with undo-functionality.
mitk::PointSet::PointsIterator it, end;
it = m_PointSet->Begin(timeStep);
end = m_PointSet->End(timeStep);
while (it != end)
{
int position = it->Index();
if (m_PointSet->GetSelectInfo(position, timeStep)) // if selected
{
PointSet::PointType pt = m_PointSet->GetPoint(position, timeStep);
Point3D itkPoint;
itkPoint[0] = pt[0];
itkPoint[1] = pt[1];
itkPoint[2] = pt[2];
PointOperation *doOp = new mitk::PointOperation(OpMOVE, timeInMs, itkPoint, position);
if (m_UndoEnabled) //&& (posEvent->GetType() == mitk::Type_MouseButtonRelease)
{
// set the undo-operation, so the final position is undo-able
// calculate the old Position from the already moved position - m_SumVec
mitk::Point3D undoPoint = (itkPoint - m_SumVec);
PointOperation *undoOp = new mitk::PointOperation(OpMOVE, timeInMs, undoPoint, position);
OperationEvent *operationEvent = new OperationEvent(m_PointSet, doOp, undoOp, "Move point");
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}
// execute the Operation
m_PointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
++it;
}
// Update the display
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
else
{
return;
}
this->NotifyResultReady();
}
void mitk::PointSetDataInteractor::SetAccuracy(float accuracy)
{
m_SelectionAccuracy = accuracy;
}
void mitk::PointSetDataInteractor::SetMaxPoints(unsigned int maxNumber)
{
m_MaxNumberOfPoints = maxNumber;
}
int mitk::PointSetDataInteractor::GetPointIndexByPosition(Point3D position, unsigned int time, float accuracy)
{
// iterate over point set and check if it contains a point close enough to the pointer to be selected
PointSet *points = dynamic_cast<PointSet *>(GetDataNode()->GetData());
int index = -1;
if (points == NULL)
{
return index;
}
if (points->GetPointSet(time) == nullptr)
return -1;
PointSet::PointsContainer *pointsContainer = points->GetPointSet(time)->GetPoints();
float minDistance = m_SelectionAccuracy;
if (accuracy != -1)
minDistance = accuracy;
for (PointSet::PointsIterator it = pointsContainer->Begin(); it != pointsContainer->End(); it++)
{
float distance = sqrt(position.SquaredEuclideanDistanceTo(points->GetPoint(it->Index(), time)));
if (distance <
minDistance) // if several points fall within the margin, choose the one with minimal distance to position
{
index = it->Index();
}
}
return index;
}
bool mitk::PointSetDataInteractor::CheckSelection(const mitk::InteractionEvent *interactionEvent)
{
const InteractionPositionEvent *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (positionEvent != NULL)
{
int timeStep = positionEvent->GetSender()->GetTimeStep();
Point3D point = positionEvent->GetPositionInWorld();
// iterate over point set and check if it contains a point close enough to the pointer to be selected
int index = GetPointIndexByPosition(point, timeStep);
if (index != -1)
return true;
}
return false;
}
void mitk::PointSetDataInteractor::UnselectAll(unsigned int timeStep, ScalarType timeInMs)
{
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(GetDataNode()->GetData());
if (pointSet == NULL)
{
return;
}
mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet(timeStep);
if (itkPointSet == NULL)
{
return;
}
mitk::PointSet::PointsContainer::Iterator it, end;
end = itkPointSet->GetPoints()->End();
for (it = itkPointSet->GetPoints()->Begin(); it != end; it++)
{
int position = it->Index();
PointSet::PointDataType pointData = {0, false, PTUNDEFINED};
itkPointSet->GetPointData(position, &pointData);
// then declare an operation which unselects this point;
// UndoOperation as well!
if (pointData.selected)
{
mitk::Point3D noPoint;
noPoint.Fill(0);
mitk::PointOperation *doOp = new mitk::PointOperation(OpDESELECTPOINT, timeInMs, noPoint, position);
/*if ( m_UndoEnabled )
{
mitk::PointOperation *undoOp =
new mitk::PointOperation(OpSELECTPOINT, timeInMs, noPoint, position);
OperationEvent *operationEvent = new OperationEvent( pointSet, doOp, undoOp, "Unselect Point" );
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent( operationEvent );
}*/
pointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
}
}
void mitk::PointSetDataInteractor::SelectPoint(int position, unsigned int timeStep, ScalarType timeInMS)
{
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(this->GetDataNode()->GetData());
// if List is empty, then no selection of a point can be done!
if ((pointSet == NULL) || (pointSet->GetSize(timeStep) <= 0))
{
return;
}
// dummyPoint... not needed anyway
mitk::Point3D noPoint;
noPoint.Fill(0);
mitk::PointOperation *doOp = new mitk::PointOperation(OpSELECTPOINT, timeInMS, noPoint, position);
/*if ( m_UndoEnabled )
{
mitk::PointOperation* undoOp = new mitk::PointOperation(OpDESELECTPOINT,timeInMS, noPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp, "Select Point");
OperationEvent::IncCurrObjectEventId();
m_UndoController->SetOperationEvent(operationEvent);
}*/
pointSet->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
}
diff --git a/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp b/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp
index f67ca89f7b..8675d21500 100644
--- a/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkPointListWidget.cpp
@@ -1,500 +1,508 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkPointListWidget.h"
#include <QDir>
#include <QFileDialog>
#include <QHBoxLayout>
#include <QMessageBox>
#include <mitkIOUtil.h>
#include <QmitkEditPointDialog.h>
#include <mitkPointSetDataInteractor.h>
#include <mitkDataInteractor.h>
QmitkPointListWidget::QmitkPointListWidget(QWidget *parent, int orientation)
: QWidget(parent),
m_PointListView(NULL),
m_MultiWidget(NULL),
m_PointSetNode(NULL),
m_Orientation(0),
m_MovePointUpBtn(NULL),
m_MovePointDownBtn(NULL),
m_RemovePointBtn(NULL),
m_SavePointsBtn(NULL),
m_LoadPointsBtn(NULL),
m_ToggleAddPoint(NULL),
m_AddPoint(NULL),
m_Snc1(NULL),
m_Snc2(NULL),
m_Snc3(NULL),
m_DataInteractor(NULL),
m_TimeStep(0),
m_EditAllowed(true),
m_NodeObserverTag(0)
{
m_PointListView = new QmitkPointListView();
if (orientation != 0)
m_Orientation = orientation;
SetupUi();
SetupConnections();
ObserveNewNode(NULL);
}
QmitkPointListWidget::~QmitkPointListWidget()
{
m_DataInteractor = NULL;
if (m_PointSetNode && m_NodeObserverTag)
{
m_PointSetNode->RemoveObserver(m_NodeObserverTag);
m_NodeObserverTag = 0;
}
m_MultiWidget = NULL;
delete m_PointListView;
}
void QmitkPointListWidget::SetupConnections()
{
connect(this->m_LoadPointsBtn, SIGNAL(clicked()), this, SLOT(OnBtnLoadPoints()));
connect(this->m_SavePointsBtn, SIGNAL(clicked()), this, SLOT(OnBtnSavePoints()));
connect(this->m_MovePointUpBtn, SIGNAL(clicked()), this, SLOT(MoveSelectedPointUp()));
connect(this->m_MovePointDownBtn, SIGNAL(clicked()), this, SLOT(MoveSelectedPointDown()));
connect(this->m_RemovePointBtn, SIGNAL(clicked()), this, SLOT(RemoveSelectedPoint()));
connect(this->m_ToggleAddPoint, SIGNAL(toggled(bool)), this, SLOT(OnBtnAddPoint(bool)));
connect(this->m_AddPoint, SIGNAL(clicked()), this, SLOT(OnBtnAddPointManually()));
connect(this->m_PointListView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(OnListDoubleClick()));
connect(this->m_PointListView, SIGNAL(SignalPointSelectionChanged()), this, SLOT(OnPointSelectionChanged()));
}
void QmitkPointListWidget::SetupUi()
{
// Setup the buttons
m_ToggleAddPoint = new QPushButton();
m_ToggleAddPoint->setMaximumSize(25, 25);
m_ToggleAddPoint->setCheckable(true);
m_ToggleAddPoint->setToolTip("Toggle point editing (use SHIFT + Left Mouse Button to add Points)");
QIcon iconAdd(":/QtWidgetsExt/btnSetPoints.xpm");
m_ToggleAddPoint->setIcon(iconAdd);
m_AddPoint = new QPushButton();
m_AddPoint->setMaximumSize(25, 25);
m_AddPoint->setToolTip("Manually add point");
QIcon iconAddManually(":/QtWidgetsExt/btnSetPointsManually.xpm");
m_AddPoint->setIcon(iconAddManually);
m_RemovePointBtn = new QPushButton();
m_RemovePointBtn->setMaximumSize(25, 25);
const QIcon iconDel(":/QtWidgetsExt/btnClear.xpm");
m_RemovePointBtn->setIcon(iconDel);
m_RemovePointBtn->setToolTip("Erase one point from list (Hotkey: DEL)");
m_MovePointUpBtn = new QPushButton();
m_MovePointUpBtn->setMaximumSize(25, 25);
const QIcon iconUp(":/QtWidgetsExt/btnUp.xpm");
m_MovePointUpBtn->setIcon(iconUp);
m_MovePointUpBtn->setToolTip("Swap selected point upwards (Hotkey: F2)");
m_MovePointDownBtn = new QPushButton();
m_MovePointDownBtn->setMaximumSize(25, 25);
const QIcon iconDown(":/QtWidgetsExt/btnDown.xpm");
m_MovePointDownBtn->setIcon(iconDown);
m_MovePointDownBtn->setToolTip("Swap selected point downwards (Hotkey: F3)");
m_SavePointsBtn = new QPushButton();
m_SavePointsBtn->setMaximumSize(25, 25);
QIcon iconSave(":/QtWidgetsExt/btnSave.xpm");
m_SavePointsBtn->setIcon(iconSave);
m_SavePointsBtn->setToolTip("Save points to file");
m_LoadPointsBtn = new QPushButton();
m_LoadPointsBtn->setMaximumSize(25, 25);
QIcon iconLoad(":/QtWidgetsExt/btnLoad.xpm");
m_LoadPointsBtn->setIcon(iconLoad);
m_LoadPointsBtn->setToolTip("Load list of points from file (REPLACES current content)");
int i;
QBoxLayout *lay1;
QBoxLayout *lay2;
switch (m_Orientation)
{
case 0:
lay1 = new QVBoxLayout(this);
lay2 = new QHBoxLayout();
i = 0;
break;
case 1:
lay1 = new QHBoxLayout(this);
lay2 = new QVBoxLayout();
i = -1;
break;
case 2:
lay1 = new QHBoxLayout(this);
lay2 = new QVBoxLayout();
i = 0;
break;
default:
lay1 = new QVBoxLayout(this);
lay2 = new QHBoxLayout();
i = -1;
break;
}
// setup Layouts
this->setLayout(lay1);
lay1->addLayout(lay2);
lay2->stretch(true);
lay2->addWidget(m_ToggleAddPoint);
lay2->addWidget(m_AddPoint);
lay2->addWidget(m_RemovePointBtn);
lay2->addWidget(m_MovePointUpBtn);
lay2->addWidget(m_MovePointDownBtn);
lay2->addWidget(m_SavePointsBtn);
lay2->addWidget(m_LoadPointsBtn);
lay1->insertWidget(i, m_PointListView);
this->setLayout(lay1);
}
void QmitkPointListWidget::SetPointSet(mitk::PointSet *newPs)
{
if (newPs == NULL)
return;
this->m_PointSetNode->SetData(newPs);
dynamic_cast<QmitkPointListModel *>(this->m_PointListView->model())->SetPointSetNode(m_PointSetNode);
ObserveNewNode(m_PointSetNode);
}
void QmitkPointListWidget::SetPointSetNode(mitk::DataNode *newNode)
{
if (m_DataInteractor.IsNotNull())
m_DataInteractor->SetDataNode(newNode);
ObserveNewNode(newNode);
dynamic_cast<QmitkPointListModel *>(this->m_PointListView->model())->SetPointSetNode(newNode);
}
void QmitkPointListWidget::OnBtnSavePoints()
{
if ((dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData())) == NULL)
return; // don't write empty point sets. If application logic requires something else then do something else.
if ((dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData()))->GetSize() == 0)
return;
// take the previously defined name of node as proposal for filename
std::string nodeName = m_PointSetNode->GetName();
nodeName = "/" + nodeName + ".mps";
QString fileNameProposal = QString();
fileNameProposal.append(nodeName.c_str());
QString aFilename = QFileDialog::getSaveFileName(
NULL, "Save point set", QDir::currentPath() + fileNameProposal, "MITK Pointset (*.mps)");
if (aFilename.isEmpty())
return;
try
{
mitk::IOUtil::Save(m_PointSetNode->GetData(), aFilename.toStdString());
}
catch (...)
{
QMessageBox::warning(this,
"Save point set",
QString("File writer reported problems writing %1\n\n"
"PLEASE CHECK output file!")
.arg(aFilename));
}
}
void QmitkPointListWidget::OnBtnLoadPoints()
{
// get the name of the file to load
QString filename = QFileDialog::getOpenFileName(NULL, "Open MITK Pointset", "", "MITK Point Sets (*.mps)");
if (filename.isEmpty())
return;
// attempt to load file
try
{
mitk::PointSet::Pointer pointSet = mitk::IOUtil::LoadPointSet(filename.toStdString());
if (pointSet.IsNull())
{
QMessageBox::warning(this, "Load point set", QString("File reader could not read %1").arg(filename));
return;
}
// loading successful
this->SetPointSet(pointSet);
}
catch (...)
{
QMessageBox::warning(this, "Load point set", QString("File reader collapsed while reading %1").arg(filename));
}
emit PointListChanged();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
mitk::PointSet *QmitkPointListWidget::GetPointSet()
{
return dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
}
mitk::DataNode *QmitkPointListWidget::GetPointSetNode()
{
return m_PointSetNode;
}
void QmitkPointListWidget::SetMultiWidget(QmitkStdMultiWidget *multiWidget)
{
this->m_MultiWidget = multiWidget;
m_PointListView->SetMultiWidget(multiWidget);
}
void QmitkPointListWidget::RemoveSelectedPoint()
{
if (!m_PointSetNode)
return;
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
if (!pointSet)
return;
if (pointSet->GetSize() == 0)
return;
QmitkPointListModel *pointListModel = dynamic_cast<QmitkPointListModel *>(m_PointListView->model());
pointListModel->RemoveSelectedPoint();
emit PointListChanged();
}
void QmitkPointListWidget::MoveSelectedPointDown()
{
if (!m_PointSetNode)
return;
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
if (!pointSet)
return;
if (pointSet->GetSize() == 0)
return;
QmitkPointListModel *pointListModel = dynamic_cast<QmitkPointListModel *>(m_PointListView->model());
pointListModel->MoveSelectedPointDown();
emit PointListChanged();
}
void QmitkPointListWidget::MoveSelectedPointUp()
{
if (!m_PointSetNode)
return;
mitk::PointSet *pointSet = dynamic_cast<mitk::PointSet *>(m_PointSetNode->GetData());
if (!pointSet)
return;
if (pointSet->GetSize() == 0)
return;
QmitkPointListModel *pointListModel = dynamic_cast<QmitkPointListModel *>(m_PointListView->model());
pointListModel->MoveSelectedPointUp();
emit PointListChanged();
}
void QmitkPointListWidget::OnBtnAddPoint(bool checked)
{
if (m_PointSetNode.IsNotNull())
{
if (checked)
{
m_DataInteractor = m_PointSetNode->GetDataInteractor();
// If no data Interactor is present create a new one
if (m_DataInteractor.IsNull())
{
// Create PointSetData Interactor
m_DataInteractor = mitk::PointSetDataInteractor::New();
// Load the according state machine for regular point set interaction
m_DataInteractor->LoadStateMachine("PointSet.xml");
// Set the configuration file that defines the triggers for the transitions
m_DataInteractor->SetEventConfig("PointSetConfig.xml");
// set the DataNode (which already is added to the DataStorage
m_DataInteractor->SetDataNode(m_PointSetNode);
}
}
else
{
m_PointSetNode->SetDataInteractor(NULL);
m_DataInteractor = NULL;
}
emit EditPointSets(checked);
}
}
void QmitkPointListWidget::OnBtnAddPointManually()
{
mitk::PointSet *pointSet = this->GetPointSet();
+ QmitkEditPointDialog editPointDialog(this);
- mitk::PointSet::PointsIterator maxIt = pointSet->GetMaxId();
- mitk::PointSet::PointIdentifier maxId = maxIt->Index();
+ if (this->GetPointSet()->IsEmpty())
+ {
+ editPointDialog.SetPoint(pointSet, 0, m_TimeStep);
+ }
+
+ else
+ {
+ mitk::PointSet::PointsIterator maxIt = pointSet->GetMaxId();
+ mitk::PointSet::PointIdentifier maxId = maxIt->Index();
+ editPointDialog.SetPoint(pointSet, maxId + 1, m_TimeStep);
+ }
- QmitkEditPointDialog editPointDialog(this);
- editPointDialog.SetPoint(pointSet, maxId + 1, m_TimeStep);
editPointDialog.exec();
}
void QmitkPointListWidget::OnListDoubleClick()
{
}
void QmitkPointListWidget::OnPointSelectionChanged()
{
emit this->PointSelectionChanged();
}
void QmitkPointListWidget::DeactivateInteractor(bool)
{
}
void QmitkPointListWidget::EnableEditButton(bool enabled)
{
m_EditAllowed = enabled;
if (enabled == false)
m_ToggleAddPoint->setEnabled(false);
else
m_ToggleAddPoint->setEnabled(true);
OnBtnAddPoint(enabled);
}
void QmitkPointListWidget::ObserveNewNode(mitk::DataNode *node)
{
if (m_DataInteractor.IsNotNull())
m_DataInteractor->SetDataNode(node);
// remove old observer
if (m_PointSetNode)
{
if (m_DataInteractor)
{
m_DataInteractor = NULL;
m_ToggleAddPoint->setChecked(false);
}
m_PointSetNode->RemoveObserver(m_NodeObserverTag);
m_NodeObserverTag = 0;
}
m_PointSetNode = node;
// add new observer if necessary
if (m_PointSetNode)
{
itk::ReceptorMemberCommand<QmitkPointListWidget>::Pointer command =
itk::ReceptorMemberCommand<QmitkPointListWidget>::New();
command->SetCallbackFunction(this, &QmitkPointListWidget::OnNodeDeleted);
m_NodeObserverTag = m_PointSetNode->AddObserver(itk::DeleteEvent(), command);
}
else
{
m_NodeObserverTag = 0;
}
if (m_EditAllowed == true)
m_ToggleAddPoint->setEnabled(m_PointSetNode);
else
m_ToggleAddPoint->setEnabled(false);
m_RemovePointBtn->setEnabled(m_PointSetNode);
m_LoadPointsBtn->setEnabled(m_PointSetNode);
m_SavePointsBtn->setEnabled(m_PointSetNode);
m_AddPoint->setEnabled(m_PointSetNode);
}
void QmitkPointListWidget::OnNodeDeleted(const itk::EventObject &)
{
if (m_PointSetNode.IsNotNull() && !m_NodeObserverTag)
m_PointSetNode->RemoveObserver(m_NodeObserverTag);
m_NodeObserverTag = 0;
m_PointSetNode = NULL;
m_PointListView->SetPointSetNode(NULL);
m_ToggleAddPoint->setEnabled(false);
m_RemovePointBtn->setEnabled(false);
m_LoadPointsBtn->setEnabled(false);
m_SavePointsBtn->setEnabled(false);
m_AddPoint->setEnabled(false);
}
void QmitkPointListWidget::SetSnc1(mitk::SliceNavigationController *snc)
{
if (snc == NULL)
{
m_PointListView->RemoveSliceNavigationController(m_Snc1);
}
else
{
m_PointListView->AddSliceNavigationController(snc);
}
m_Snc1 = snc;
}
void QmitkPointListWidget::SetSnc2(mitk::SliceNavigationController *snc)
{
if (snc == NULL)
{
m_PointListView->RemoveSliceNavigationController(m_Snc2);
}
else
{
m_PointListView->AddSliceNavigationController(snc);
}
m_Snc2 = snc;
}
void QmitkPointListWidget::SetSnc3(mitk::SliceNavigationController *snc)
{
if (snc == NULL)
{
m_PointListView->RemoveSliceNavigationController(m_Snc3);
}
else
{
m_PointListView->AddSliceNavigationController(snc);
}
m_Snc3 = snc;
}
void QmitkPointListWidget::AddSliceNavigationController(mitk::SliceNavigationController *snc)
{
m_PointListView->AddSliceNavigationController(snc);
}
void QmitkPointListWidget::RemoveSliceNavigationController(mitk::SliceNavigationController *snc)
{
m_PointListView->RemoveSliceNavigationController(snc);
}
void QmitkPointListWidget::UnselectEditButton()
{
m_ToggleAddPoint->setChecked(false);
}