bool mitk::AffineDataInteractor3D::InitRotate(StateMachineAction*, InteractionEvent* interactionEvent)
{
InteractionPositionEvent* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if(positionEvent == NULL)
return false;
m_InitialPickedPoint = positionEvent->GetPositionInWorld();
m_InitialPickedDisplayPoint = positionEvent->GetPointerPositionOnScreen();
// Get the timestep to also support 3D+t
int timeStep = interactionEvent->GetSender()->GetTimeStep(this->GetDataNode()->GetData());
// Make deep copy of current Geometry3D of the plane
this->GetDataNode()->GetData()->UpdateOutputInformation(); // make sure that the Geometry is up-to-date
m_OriginalGeometry = static_cast<Geometry3D*>(this->GetDataNode()->GetData()->GetGeometry(timeStep)->Clone().GetPointer());
return true;
}
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));
}
bool mitk::PointSetDataInteractor::IsClosedContour(StateMachineAction*, InteractionEvent* interactionEvent)
{
InteractionPositionEvent* positionEvent = dynamic_cast<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
if (GetPointIndexByPosition(point, timeStep) != -1 && m_PointSet->GetSize(timeStep) >= 3)
{
InternalEvent::Pointer event = InternalEvent::New(NULL, this, "ClosedContour");
positionEvent->GetSender()->GetDispatcher()->QueueEvent(event.GetPointer());
return true;
}
}
return false;
}
void mitk::AffineImageCropperInteractor::TranslateObject (StateMachineAction*, InteractionEvent* interactionEvent)
{
InteractionPositionEvent* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if(positionEvent == NULL)
return;
Point3D currentPickedPoint = positionEvent->GetPositionInWorld();
Vector3D interactionMove;
interactionMove[0] = currentPickedPoint[0] - m_InitialPickedPoint[0];
interactionMove[1] = currentPickedPoint[1] - m_InitialPickedPoint[1];
interactionMove[2] = currentPickedPoint[2] - m_InitialPickedPoint[2];
mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*> (m_SelectedNode->GetData());
mitk::BaseGeometry::Pointer surGeo = surface->GetGeometry();
surGeo->SetOrigin(m_InitialOrigin);
surGeo->Translate(interactionMove);
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
bool mitk::PointSetDataInteractor::MovePoint(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent)
{
InteractionPositionEvent* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (positionEvent != NULL)
{
IsClosedContour(stateMachineAction, interactionEvent);
// Get time step from BaseRenderer
int timeStep = positionEvent->GetSender()->GetTimeStep();
mitk::Point3D point = positionEvent->GetPositionInWorld();
m_PointSet->SetPoint(m_SelectedPointIndex, point, timeStep);
GetDataNode()->SetData(m_PointSet);
GetDataNode()->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
IsClosedContour(stateMachineAction,interactionEvent);
return true;
}
else
{
return false;
}
}
void mitk::AffineBaseDataInteractor3D::TranslateObject (StateMachineAction*, InteractionEvent* interactionEvent)
{
InteractionPositionEvent* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if(positionEvent == NULL)
return;
Point3D currentPickedPoint = positionEvent->GetPositionInWorld();
Vector3D interactionMove;
interactionMove[0] = currentPickedPoint[0] - m_InitialPickedWorldPoint[0];
interactionMove[1] = currentPickedPoint[1] - m_InitialPickedWorldPoint[1];
interactionMove[2] = currentPickedPoint[2] - m_InitialPickedWorldPoint[2];
int timeStep = interactionEvent->GetSender()->GetTimeStep(this->GetDataNode()->GetData());
mitk::BaseGeometry::Pointer geometry = this->GetDataNode()->GetData()->GetUpdatedTimeGeometry()->GetGeometryForTimeStep(timeStep);
geometry->SetOrigin(m_OriginalGeometry->GetOrigin());
this->TranslateGeometry(interactionMove, this->GetUpdatedTimeGeometry(interactionEvent));
return;
}
bool mitk::PointSetDataInteractor::SelectPoint(StateMachineAction*, InteractionEvent* interactionEvent)
{
InteractionPositionEvent* positionEvent = dynamic_cast<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
if (GetPointIndexByPosition(point, timeStep) != -1)
{
//TODO FIXME is this safe ? can pointset and renderer have different sizes ?
m_SelectedPointIndex = GetPointIndexByPosition(point, timeStep);
GetDataNode()->SetProperty("contourcolor", ColorProperty::New(0.0, 0.0, 1.0));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
return false;
}
else
{
return false;
}
}
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();
}
}
}
void mitk::AffineBaseDataInteractor3D::RotateObject (StateMachineAction*, InteractionEvent* interactionEvent)
{
InteractionPositionEvent* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if(positionEvent == NULL)
return;
Point2D currentPickedDisplayPoint = positionEvent->GetPointerPositionOnScreen();
Point3D currentWorldPoint = positionEvent->GetPositionInWorld();
vtkCamera* camera = NULL;
vtkRenderer* currentVtkRenderer = NULL;
if ((interactionEvent->GetSender()) != NULL)
{
camera = interactionEvent->GetSender()->GetVtkRenderer()->GetActiveCamera();
currentVtkRenderer = interactionEvent->GetSender()->GetVtkRenderer();
}
if ( camera && currentVtkRenderer)
{
double vpn[3];
camera->GetViewPlaneNormal( vpn );
Vector3D viewPlaneNormal;
viewPlaneNormal[0] = vpn[0];
viewPlaneNormal[1] = vpn[1];
viewPlaneNormal[2] = vpn[2];
Vector3D interactionMove;
interactionMove[0] = currentWorldPoint[0] - m_InitialPickedWorldPoint[0];
interactionMove[1] = currentWorldPoint[1] - m_InitialPickedWorldPoint[1];
interactionMove[2] = currentWorldPoint[2] - m_InitialPickedWorldPoint[2];
if (interactionMove[0] == 0 && interactionMove[1] == 0 && interactionMove[2] == 0)
return;
Vector3D rotationAxis = itk::CrossProduct(viewPlaneNormal, interactionMove);
rotationAxis.Normalize();
int* size = currentVtkRenderer->GetSize();
double l2 =
(currentPickedDisplayPoint[0] - m_InitialPickedDisplayPoint[0]) *
(currentPickedDisplayPoint[0] - m_InitialPickedDisplayPoint[0]) +
(currentPickedDisplayPoint[1] - m_InitialPickedDisplayPoint[1]) *
(currentPickedDisplayPoint[1] - m_InitialPickedDisplayPoint[1]);
double rotationAngle = 360.0 * sqrt(l2 / (size[0] * size[0] + size[1] * size[1]));
// Use center of data bounding box as center of rotation
Point3D rotationCenter = m_OriginalGeometry->GetCenter();
int timeStep = 0;
if ((interactionEvent->GetSender()) != NULL)
timeStep = interactionEvent->GetSender()->GetTimeStep(this->GetDataNode()->GetData());
// Reset current Geometry3D to original state (pre-interaction) and
// apply rotation
RotationOperation op( OpROTATE, rotationCenter, rotationAxis, rotationAngle );
Geometry3D::Pointer newGeometry = static_cast<Geometry3D*>(m_OriginalGeometry->Clone().GetPointer());
newGeometry->ExecuteOperation( &op );
mitk::TimeGeometry::Pointer timeGeometry = this->GetDataNode()->GetData()->GetTimeGeometry();
if (timeGeometry.IsNotNull())
timeGeometry->SetTimeStepGeometry(newGeometry, timeStep);
interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
}
}
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
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());
}
}
}
