void
RenderingManager
::RenderingEndCallback( vtkObject *caller, unsigned long , void *, void * )
{
vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
RenderWindowList &renderWindowList = renman->m_RenderWindowList;
RendererIntMap &nextLODMap = renman->m_NextLODMap;
if ( renderWindow )
{
BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
if ( renderer )
{
renderWindowList[renderer->GetRenderWindow()] = RENDERING_INACTIVE;
// Level-of-Detail handling
if ( renderer->GetNumberOfVisibleLODEnabledMappers() > 0 )
{
if(nextLODMap[renderer]==0)
renman->StartOrResetTimer();
else
nextLODMap[renderer] = 0;
}
}
}
}
mitk::StdFunctionCommand::ActionFunction mitk::DisplayActionEventFunctions::ZoomCameraSynchronizedAction()
{
auto actionFunction = [](const itk::EventObject& displayInteractorEvent)
{
if (DisplayZoomEvent().CheckEvent(&displayInteractorEvent))
{
const DisplayZoomEvent* displayActionEvent = dynamic_cast<const DisplayZoomEvent*>(&displayInteractorEvent);
const BaseRenderer::Pointer sendingRenderer = displayActionEvent->GetSender();
if (nullptr == sendingRenderer)
{
return;
}
if (1.0 != displayActionEvent->GetZoomFactor())
{
auto allRenderWindows = sendingRenderer->GetRenderingManager()->GetAllRegisteredRenderWindows();
for (auto renderWindow : allRenderWindows)
{
if (BaseRenderer::GetInstance(renderWindow)->GetMapperID() == BaseRenderer::Standard2D)
{
BaseRenderer* currentRenderer = BaseRenderer::GetInstance(renderWindow);
currentRenderer->GetCameraController()->Zoom(displayActionEvent->GetZoomFactor(), displayActionEvent->GetStartCoordinate());
currentRenderer->GetRenderingManager()->RequestUpdate(currentRenderer->GetRenderWindow());
}
}
}
}
};
return actionFunction;
}
bool mitk::DisplayInteractor::Init(StateMachineAction*, InteractionEvent* interactionEvent)
{
BaseRenderer* sender = interactionEvent->GetSender();
InteractionPositionEvent* positionEvent = static_cast<InteractionPositionEvent*>(interactionEvent);
Vector2D origin = sender->GetDisplayGeometry()->GetOriginInMM();
double scaleFactorMMPerDisplayUnit = sender->GetDisplayGeometry()->GetScaleFactorMMPerDisplayUnit();
m_StartDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
m_StartCoordinateInMM = mitk::Point2D(
(origin + m_StartDisplayCoordinate.GetVectorFromOrigin() * scaleFactorMMPerDisplayUnit).GetDataPointer());
return true;
}
bool mitk::DisplayInteractor::Move(StateMachineAction*, InteractionEvent* interactionEvent)
{
BaseRenderer* sender = interactionEvent->GetSender();
InteractionPositionEvent* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (positionEvent == NULL)
{
MITK_WARN<< "DisplayVectorInteractor: cannot process the event in Move action: " << interactionEvent->GetNameOfClass();
return false;
}
// perform translation
sender->GetDisplayGeometry()->MoveBy((positionEvent->GetPointerPositionOnScreen() - m_LastDisplayCoordinate) * (-1.0));
sender->GetRenderingManager()->RequestUpdate(sender->GetRenderWindow());
m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
return true;
}
bool mitk::DisplayInteractor::Move(StateMachineAction*, InteractionEvent* interactionEvent)
{
BaseRenderer* sender = interactionEvent->GetSender();
InteractionPositionEvent* positionEvent = static_cast<InteractionPositionEvent*>(interactionEvent);
float invertModifier = -1.0;
if ( m_InvertMoveDirection )
{
invertModifier = 1.0;
}
// perform translation
sender->GetDisplayGeometry()->MoveBy( (positionEvent->GetPointerPositionOnScreen() - m_LastDisplayCoordinate) * invertModifier );
sender->GetRenderingManager()->RequestUpdate(sender->GetRenderWindow());
m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
return true;
}
void
RenderingManager
::ExecutePendingHighResRenderingRequest()
{
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
BaseRenderer *renderer = BaseRenderer::GetInstance( it->first );
if(renderer->GetNumberOfVisibleLODEnabledMappers()>0)
{
if(m_NextLODMap[renderer]==0)
{
m_NextLODMap[renderer]=1;
RequestUpdate( it->first );
}
}
}
}
bool mitk::DisplayInteractor::Init(StateMachineAction*, InteractionEvent* interactionEvent)
{
BaseRenderer* sender = interactionEvent->GetSender();
InteractionPositionEvent* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (positionEvent == NULL)
{
MITK_WARN<< "DisplayVectorInteractor cannot process the event: " << interactionEvent->GetNameOfClass();
return false;
}
Vector2D origin = sender->GetDisplayGeometry()->GetOriginInMM();
double scaleFactorMMPerDisplayUnit = sender->GetDisplayGeometry()->GetScaleFactorMMPerDisplayUnit();
m_StartDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
m_StartCoordinateInMM = mitk::Point2D(
(origin + m_StartDisplayCoordinate.GetVectorFromOrigin() * scaleFactorMMPerDisplayUnit).GetDataPointer());
return true;
}
void
RenderingManager
::RenderingProgressCallback( vtkObject *caller, unsigned long , void *, void * )
{
vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
if ( renman->m_LODAbortMechanismEnabled )
{
vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
if ( renderWindow )
{
BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
if ( renderer && (renderer->GetNumberOfVisibleLODEnabledMappers() > 0) )
{
renman->DoMonitorRendering();
}
}
}
}
bool
mitk::PlanarFigureInteractor::IsMousePositionAcceptableAsNewControlPoint(
mitk::StateEvent const * stateEvent,
const PlanarFigure* planarFigure )
{
assert(stateEvent && planarFigure);
BaseRenderer* renderer = stateEvent->GetEvent()->GetSender();
assert(renderer);
// Get the timestep to support 3D+t
int timeStep( renderer->GetTimeStep( planarFigure ) );
// Get current display position of the mouse
//Point2D currentDisplayPosition = positionEvent->GetDisplayPosition();
// Check if a previous point has been set
bool tooClose = false;
const Geometry2D *renderingPlane = renderer->GetCurrentWorldGeometry2D();
mitk::Geometry2D *planarFigureGeometry =
dynamic_cast< mitk::Geometry2D * >( planarFigure->GetGeometry( timeStep ) );
Point2D point2D, correctedPoint;
// Get the point2D from the positionEvent
if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D,
planarFigureGeometry ) )
{
return false;
}
// apply the controlPoint constraints of the planarFigure to get the
// coordinates that would actually be used.
correctedPoint = const_cast<PlanarFigure*>( planarFigure )->ApplyControlPointConstraints( 0, point2D );
// map the 2D coordinates of the new point to world-coordinates
// and transform those to display-coordinates
mitk::Point3D newPoint3D;
planarFigureGeometry->Map( correctedPoint, newPoint3D );
mitk::Point2D newDisplayPosition;
renderingPlane->Map( newPoint3D, newDisplayPosition );
renderer->GetDisplayGeometry()->WorldToDisplay( newDisplayPosition, newDisplayPosition );
for( int i=0; i < (int)planarFigure->GetNumberOfControlPoints(); i++ )
{
if ( i != planarFigure->GetSelectedControlPoint() )
{
// Try to convert previous point to current display coordinates
mitk::Point3D previousPoint3D;
// map the 2D coordinates of the control-point to world-coordinates
planarFigureGeometry->Map( planarFigure->GetControlPoint( i ), previousPoint3D );
if ( renderer->GetDisplayGeometry()->Distance( previousPoint3D ) < 0.1 ) // ugly, but assert makes this work
{
mitk::Point2D previousDisplayPosition;
// transform the world-coordinates into display-coordinates
renderingPlane->Map( previousPoint3D, previousDisplayPosition );
renderer->GetDisplayGeometry()->WorldToDisplay( previousDisplayPosition, previousDisplayPosition );
//Calculate the distance. We use display-coordinates here to make
// the check independent of the zoom-level of the rendering scene.
double a = newDisplayPosition[0] - previousDisplayPosition[0];
double b = newDisplayPosition[1] - previousDisplayPosition[1];
// If point is to close, do not set a new point
tooClose = (a * a + b * b < m_MinimumPointDistance );
}
if ( tooClose )
return false; // abort loop early
}
}
return !tooClose; // default
}
bool AffineInteractor3D
::ExecuteAction( Action *action, StateEvent const *stateEvent )
{
bool ok = false;
// Get data object
BaseData *data = m_DataNode->GetData();
if ( data == NULL )
{
MITK_ERROR << "No data object present!";
return ok;
}
// Get Event and extract renderer
const Event *event = stateEvent->GetEvent();
BaseRenderer *renderer = NULL;
vtkRenderWindow *renderWindow = NULL;
vtkRenderWindowInteractor *renderWindowInteractor = NULL;
vtkRenderer *currentVtkRenderer = NULL;
vtkCamera *camera = NULL;
if ( event != NULL )
{
renderer = event->GetSender();
if ( renderer != NULL )
{
renderWindow = renderer->GetRenderWindow();
if ( renderWindow != NULL )
{
renderWindowInteractor = renderWindow->GetInteractor();
if ( renderWindowInteractor != NULL )
{
currentVtkRenderer = renderWindowInteractor
->GetInteractorStyle()->GetCurrentRenderer();
if ( currentVtkRenderer != NULL )
{
camera = currentVtkRenderer->GetActiveCamera();
}
}
}
}
}
// Check if we have a DisplayPositionEvent
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( dpe != NULL )
{
m_CurrentPickedPoint = dpe->GetWorldPosition();
m_CurrentPickedDisplayPoint = dpe->GetDisplayPosition();
}
// Get the timestep to also support 3D+t
int timeStep = 0;
ScalarType timeInMS = 0.0;
if ( renderer != NULL )
{
timeStep = renderer->GetTimeStep( data );
timeInMS = renderer->GetTime();
}
// If data is an mitk::Surface, extract it
Surface *surface = dynamic_cast< Surface * >( data );
vtkPolyData *polyData = NULL;
if ( surface != NULL )
{
polyData = surface->GetVtkPolyData( timeStep );
// Extract surface normal from surface (if existent, otherwise use default)
vtkPointData *pointData = polyData->GetPointData();
if ( pointData != NULL )
{
vtkDataArray *normal = polyData->GetPointData()->GetVectors( "planeNormal" );
if ( normal != NULL )
{
m_ObjectNormal[0] = normal->GetComponent( 0, 0 );
m_ObjectNormal[1] = normal->GetComponent( 0, 1 );
m_ObjectNormal[2] = normal->GetComponent( 0, 2 );
}
}
}
// Get geometry object
m_Geometry = data->GetGeometry( timeStep );
// Make sure that the data (if time-resolved) has enough entries;
// if not, create the required extra ones (empty)
data->Expand( timeStep+1 );
switch (action->GetActionId())
{
case AcDONOTHING:
ok = true;
break;
case AcCHECKOBJECT:
{
// Re-enable VTK interactor (may have been disabled previously)
if ( renderWindowInteractor != NULL )
{
renderWindowInteractor->Enable();
}
// Check if we have a DisplayPositionEvent
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( dpe == NULL )
{
ok = true;
break;
}
// Check if an object is present at the current mouse position
DataNode *pickedNode = dpe->GetPickedObjectNode();
StateEvent *newStateEvent;
if ( pickedNode == m_DataNode )
{
// Yes: object will be selected
newStateEvent = new StateEvent( EIDYES );
}
else
{
// No: back to start state
newStateEvent = new StateEvent( EIDNO );
}
this->HandleEvent( newStateEvent );
ok = true;
break;
}
case AcDESELECTOBJECT:
{
// Color object white
m_DataNode->SetColor( 1.0, 1.0, 1.0 );
RenderingManager::GetInstance()->RequestUpdateAll();
// Colorize surface / wireframe as inactive
this->ColorizeSurface( polyData,
m_CurrentPickedPoint, -1.0 );
ok = true;
break;
}
case AcSELECTPICKEDOBJECT:
{
// Color object red
m_DataNode->SetColor( 1.0, 0.0, 0.0 );
RenderingManager::GetInstance()->RequestUpdateAll();
// Colorize surface / wireframe dependend on distance from picked point
this->ColorizeSurface( polyData,
m_CurrentPickedPoint, 0.0 );
ok = true;
break;
}
case AcINITMOVE:
{
// Disable VTK interactor until MITK interaction has been completed
if ( renderWindowInteractor != NULL )
{
renderWindowInteractor->Disable();
}
// Check if we have a DisplayPositionEvent
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( dpe == NULL )
{
ok = true;
break;
}
//DataNode *pickedNode = dpe->GetPickedObjectNode();
m_InitialPickedPoint = m_CurrentPickedPoint;
m_InitialPickedDisplayPoint = m_CurrentPickedDisplayPoint;
if ( currentVtkRenderer != NULL )
{
vtkInteractorObserver::ComputeDisplayToWorld(
currentVtkRenderer,
m_InitialPickedDisplayPoint[0],
m_InitialPickedDisplayPoint[1],
0.0, //m_InitialInteractionPickedPoint[2],
m_InitialPickedPointWorld );
}
// Make deep copy of current Geometry3D of the plane
data->UpdateOutputInformation(); // make sure that the Geometry is up-to-date
m_OriginalGeometry = static_cast< Geometry3D * >(
data->GetGeometry( timeStep )->Clone().GetPointer() );
ok = true;
break;
}
case AcMOVE:
{
// Check if we have a DisplayPositionEvent
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( dpe == NULL )
{
ok = true;
break;
}
if ( currentVtkRenderer != NULL )
{
vtkInteractorObserver::ComputeDisplayToWorld(
currentVtkRenderer,
m_CurrentPickedDisplayPoint[0],
m_CurrentPickedDisplayPoint[1],
0.0, //m_InitialInteractionPickedPoint[2],
m_CurrentPickedPointWorld );
}
Vector3D interactionMove;
interactionMove[0] = m_CurrentPickedPointWorld[0] - m_InitialPickedPointWorld[0];
interactionMove[1] = m_CurrentPickedPointWorld[1] - m_InitialPickedPointWorld[1];
interactionMove[2] = m_CurrentPickedPointWorld[2] - m_InitialPickedPointWorld[2];
if ( m_InteractionMode == INTERACTION_MODE_TRANSLATION )
{
Point3D origin = m_OriginalGeometry->GetOrigin();
Vector3D transformedObjectNormal;
data->GetGeometry( timeStep )->IndexToWorld(
m_ObjectNormal, transformedObjectNormal );
data->GetGeometry( timeStep )->SetOrigin(
origin + transformedObjectNormal * (interactionMove * transformedObjectNormal) );
}
else if ( m_InteractionMode == INTERACTION_MODE_ROTATION )
{
if ( camera )
{
double vpn[3];
camera->GetViewPlaneNormal( vpn );
Vector3D viewPlaneNormal;
viewPlaneNormal[0] = vpn[0];
viewPlaneNormal[1] = vpn[1];
viewPlaneNormal[2] = vpn[2];
Vector3D rotationAxis =
itk::CrossProduct( viewPlaneNormal, interactionMove );
rotationAxis.Normalize();
int *size = currentVtkRenderer->GetSize();
double l2 =
(m_CurrentPickedDisplayPoint[0] - m_InitialPickedDisplayPoint[0]) *
(m_CurrentPickedDisplayPoint[0] - m_InitialPickedDisplayPoint[0]) +
(m_CurrentPickedDisplayPoint[1] - m_InitialPickedDisplayPoint[1]) *
(m_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();;
// 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 );
data->SetClonedGeometry(newGeometry, timeStep);
}
}
RenderingManager::GetInstance()->RequestUpdateAll();
ok = true;
break;
}
default:
return Superclass::ExecuteAction( action, stateEvent );
}
return ok;
}
// Relict from the old times, when automous decisions were accepted
// behavior. Remains in here, because some RenderWindows do exist outside
// of StdMultiWidgets.
bool
SliceNavigationController
::ExecuteAction( Action* action, StateEvent const* stateEvent )
{
bool ok = false;
const PositionEvent* posEvent = dynamic_cast< const PositionEvent * >(
stateEvent->GetEvent() );
if ( posEvent != NULL )
{
if ( m_CreatedWorldGeometry.IsNull() )
{
return true;
}
switch (action->GetActionId())
{
case AcMOVE:
{
BaseRenderer *baseRenderer = posEvent->GetSender();
if ( !baseRenderer )
{
baseRenderer = const_cast<BaseRenderer *>(
GlobalInteraction::GetInstance()->GetFocus() );
}
if ( baseRenderer )
if ( baseRenderer->GetMapperID() == 1 )
{
PointOperation* doOp = new mitk::PointOperation(OpMOVE, posEvent->GetWorldPosition());
if (m_UndoEnabled)
{
m_OldPos = this->GetSlice()->GetPos();
// m_OldPos holds the old slice position. For the undo controller this old position will be stored as index in mitk::PointOperation
PointOperation* undoOp = new mitk::PointOperation(OpMOVE, posEvent->GetWorldPosition(), m_OldPos);
OperationEvent *operationEvent = new mitk::OperationEvent(this, doOp, undoOp, "Move slices");
m_UndoController->SetOperationEvent(operationEvent);
}
this->ExecuteOperation( doOp );
// If click was performed in this render window than we have to update the status bar information about position and pixel value.
if(baseRenderer == m_Renderer)
{
{
std::string statusText;
TNodePredicateDataType<mitk::Image>::Pointer isImageData = TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer nodes = baseRenderer->GetDataStorage()->GetSubset(isImageData).GetPointer();
mitk::Point3D worldposition = posEvent->GetWorldPosition();
int maxlayer = -32768;
mitk::Image::Pointer image3D;
// find image with largest layer, that is the image shown on top in the render window
for (unsigned int x = 0; x < nodes->size(); x++)
{
//Just consider image data that is no helper object. E.g. do not consider nodes created for the slice interpolation
bool isHelper (false);
nodes->at(x)->GetBoolProperty("helper object", isHelper);
if(nodes->at(x)->GetData()->GetGeometry()->IsInside(worldposition) && isHelper == false)
{
int layer = 0;
if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
if(layer > maxlayer)
{
if(static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(m_Renderer))
{
image3D = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
maxlayer = layer;
}
}
}
}
std::stringstream stream;
stream.imbue(std::locale::classic());
// get the position and gray value from the image and build up status bar text
if(image3D.IsNotNull())
{
Index3D p;
image3D->GetGeometry()->WorldToIndex(worldposition, p);
stream.precision(2);
stream<<"Position: <" << std::fixed <<worldposition[0] << ", " << std::fixed << worldposition[1] << ", " << std::fixed << worldposition[2] << "> mm";
stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
mitk::ScalarType pixelValue = image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep());
if (fabs(pixelValue)>1000000)
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<std::scientific<<image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep())<<" ";
}
else
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<<image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep())<<" ";
}
}
else
{
stream << "No image information at this position!";
}
statusText = stream.str();
mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
}
}
ok = true;
break;
}
}
default:
ok = true;
break;
}
return ok;
}
const DisplayPositionEvent *displPosEvent =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( displPosEvent != NULL )
{
return true;
}
return false;
}
bool mitk::FiberBundleInteractor::ExecuteAction( Action* action, mitk::StateEvent const* stateEvent )
{
bool ok = false;//for return type bool
//checking corresponding Data; has to be a PointSet or a subclass
mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_DataNode->GetData());
if (bundle == NULL)
return false;
// Get Event and extract renderer
const Event *event = stateEvent->GetEvent();
BaseRenderer *renderer = NULL;
vtkRenderWindow *renderWindow = NULL;
vtkRenderWindowInteractor *renderWindowInteractor = NULL;
vtkRenderer *currentVtkRenderer = NULL;
vtkCamera *camera = NULL;
if ( event != NULL )
{
renderer = event->GetSender();
if ( renderer != NULL )
{
renderWindow = renderer->GetRenderWindow();
if ( renderWindow != NULL )
{
renderWindowInteractor = renderWindow->GetInteractor();
if ( renderWindowInteractor != NULL )
{
currentVtkRenderer = renderWindowInteractor
->GetInteractorStyle()->GetCurrentRenderer();
if ( currentVtkRenderer != NULL )
{
camera = currentVtkRenderer->GetActiveCamera();
}
}
}
}
}
/*Each case must watch the type of the event!*/
switch (action->GetActionId())
{
case AcCHECKHOVERING:
{
QApplication::restoreOverrideCursor();
// Re-enable VTK interactor (may have been disabled previously)
if ( renderWindowInteractor != NULL )
{
renderWindowInteractor->Enable();
}
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
// Check if we have a DisplayPositionEvent
if ( dpe != NULL )
{
// Check if an object is present at the current mouse position
DataNode *pickedNode = dpe->GetPickedObjectNode();
if ( pickedNode != m_DataNode )
{
// if(pickedNode == 0)
// MITK_INFO << "picked node is NULL, no hovering";
// else
// MITK_INFO << "wrong node: " << pickedNode;
this->HandleEvent( new StateEvent( EIDNOFIGUREHOVER ) );
ok = true;
break;
}
m_CurrentPickedPoint = dpe->GetWorldPosition();
m_CurrentPickedDisplayPoint = dpe->GetDisplayPosition();
QApplication::setOverrideCursor(Qt::UpArrowCursor);
this->HandleEvent( new StateEvent( EIDFIGUREHOVER ) );
}
ok = true;
break;
}
break;
// case AcSELECTPICKEDOBJECT:
// MITK_INFO << "FiberBundleInteractor AcSELECTPICKEDOBJECT";
// break;
// case AcDESELECTALL:
// MITK_INFO << "FiberBundleInteractor AcDESELECTALL";
// break;
case AcREMOVE:
{
MITK_INFO << "picking fiber at " << m_CurrentPickedPoint;
// QmitkStdMultiWidgetEditor::Pointer multiWidgetEditor;
// multiWidgetEditor->GetStdMultiWidget()->GetRenderWindow1()->GetRenderer()->GetSliceNavigationController()->SelectSliceByPoint(
// m_CurrentPickedPoint);
BaseRenderer* renderer = mitk::BaseRenderer::GetByName("stdmulti.widget1");
renderer->GetSliceNavigationController()->SelectSliceByPoint(
m_CurrentPickedPoint);
renderer = mitk::BaseRenderer::GetByName("stdmulti.widget2");
renderer->GetSliceNavigationController()->SelectSliceByPoint(
m_CurrentPickedPoint);
renderer = mitk::BaseRenderer::GetByName("stdmulti.widget3");
renderer->GetSliceNavigationController()->SelectSliceByPoint(
m_CurrentPickedPoint);
// mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
break;
default:
return Superclass::ExecuteAction( action, stateEvent );
}
return ok;
}
// Relict from the old times, when automous decisions were accepted
// behavior. Remains in here, because some RenderWindows do exist outside
// of StdMultiWidgets.
bool
SliceNavigationController
::ExecuteAction( Action* action, StateEvent const* stateEvent )
{
bool ok = false;
const PositionEvent* posEvent = dynamic_cast< const PositionEvent * >(
stateEvent->GetEvent() );
if ( posEvent != NULL )
{
if ( m_CreatedWorldGeometry.IsNull() )
{
return true;
}
switch (action->GetActionId())
{
case AcMOVE:
{
BaseRenderer *baseRenderer = posEvent->GetSender();
if ( !baseRenderer )
{
baseRenderer = const_cast<BaseRenderer *>(
GlobalInteraction::GetInstance()->GetFocus() );
}
if ( baseRenderer )
if ( baseRenderer->GetMapperID() == 1 )
{
PointOperation doOp(OpMOVE, posEvent->GetWorldPosition());
this->ExecuteOperation( &doOp );
// If click was performed in this render window than we have to update the status bar information about position and pixel value.
if(baseRenderer == m_Renderer)
{
{
std::string statusText;
TNodePredicateDataType<mitk::Image>::Pointer isImageData = TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer nodes = baseRenderer->GetDataStorage()->GetSubset(isImageData).GetPointer();
mitk::Point3D worldposition = posEvent->GetWorldPosition();
//int maxlayer = -32768;
mitk::Image::Pointer image3D;
mitk::DataNode::Pointer node;
mitk::DataNode::Pointer topSourceNode;
bool isBinary (false);
node = this->GetTopLayerNode(nodes,worldposition);
if(node.IsNotNull())
{
node->GetBoolProperty("binary", isBinary);
if(isBinary)
{
mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = baseRenderer->GetDataStorage()->GetSources(node, NULL, true);
if(!sourcenodes->empty())
{
topSourceNode = this->GetTopLayerNode(sourcenodes,worldposition);
}
if(topSourceNode.IsNotNull())
{
image3D = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
}
else
{
image3D = dynamic_cast<mitk::Image*>(node->GetData());
}
}
else
{
image3D = dynamic_cast<mitk::Image*>(node->GetData());
}
}
std::stringstream stream;
stream.imbue(std::locale::classic());
// get the position and gray value from the image and build up status bar text
if(image3D.IsNotNull())
{
Index3D p;
image3D->GetGeometry()->WorldToIndex(worldposition, p);
stream.precision(2);
stream<<"Position: <" << std::fixed <<worldposition[0] << ", " << std::fixed << worldposition[1] << ", " << std::fixed << worldposition[2] << "> mm";
stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
mitk::ScalarType pixelValue = image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep());
if (fabs(pixelValue)>1000000 || fabs(pixelValue) < 0.01)
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific<< pixelValue <<" ";
}
else
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< pixelValue <<" ";
}
}
else
{
stream << "No image information at this position!";
}
statusText = stream.str();
mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
}
}
ok = true;
break;
}
}
default:
ok = true;
break;
}
return ok;
}
const DisplayPositionEvent *displPosEvent =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( displPosEvent != NULL )
{
return true;
}
return false;
}
void SlicesRotator::RotateToPoint( SliceNavigationController *rotationPlaneSNC,
SliceNavigationController *rotatedPlaneSNC,
const Point3D &point, bool linked )
{
MITK_WARN << "Deprecated function! Use SliceNavigationController::ReorientSlices() instead";
SliceNavigationController *thirdSNC = NULL;
SNCVector::iterator iter;
for ( iter = m_RotatableSNCs.begin(); iter != m_RotatableSNCs.end(); ++iter )
{
if ( ((*iter) != rotationPlaneSNC)
&& ((*iter) != rotatedPlaneSNC) )
{
thirdSNC = *iter;
break;
}
}
if ( thirdSNC == NULL )
{
return;
}
const PlaneGeometry *rotationPlane = rotationPlaneSNC->GetCurrentPlaneGeometry();
const PlaneGeometry *rotatedPlane = rotatedPlaneSNC->GetCurrentPlaneGeometry();
const PlaneGeometry *thirdPlane = thirdSNC->GetCurrentPlaneGeometry();
if ( (rotationPlane == NULL) || (rotatedPlane == NULL)
|| (thirdPlane == NULL) )
{
return;
}
if ( rotatedPlane->DistanceFromPlane( point ) < 0.001 )
{
// Skip irrelevant rotations
return;
}
Point3D projectedPoint;
Line3D intersection;
Point3D rotationCenter;
if ( !rotationPlane->Project( point, projectedPoint )
|| !rotationPlane->IntersectionLine( rotatedPlane, intersection )
|| !thirdPlane->IntersectionPoint( intersection, rotationCenter ) )
{
return;
}
// All pre-requirements are met; execute the rotation
Point3D referencePoint = intersection.Project( projectedPoint );
Vector3D toProjected = referencePoint - rotationCenter;
Vector3D toCursor = projectedPoint - rotationCenter;
// cross product: | A x B | = |A| * |B| * sin(angle)
Vector3D axisOfRotation;
vnl_vector_fixed< ScalarType, 3 > vnlDirection =
vnl_cross_3d( toCursor.GetVnlVector(), toProjected.GetVnlVector() );
axisOfRotation.SetVnlVector( vnlDirection );
// scalar product: A * B = |A| * |B| * cos(angle)
// tan = sin / cos
ScalarType angle = - atan2(
(double)(axisOfRotation.GetNorm()),
(double)(toCursor * toProjected) );
angle *= 180.0 / vnl_math::pi;
// create RotationOperation and apply to all SNCs that should be rotated
RotationOperation op(OpROTATE, rotationCenter, axisOfRotation, angle);
if ( !linked )
{
BaseRenderer *renderer = rotatedPlaneSNC->GetRenderer();
if ( renderer == NULL )
{
return;
}
DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
Point2D point2DWorld, point2DDisplayPre, point2DDisplayPost;
displayGeometry->Map( rotationCenter, point2DWorld );
displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPre );
TimeGeometry *timeGeometry= rotatedPlaneSNC->GetCreatedWorldGeometry();
if ( !timeGeometry )
{
return;
}
timeGeometry->ExecuteOperation( &op );
displayGeometry->Map( rotationCenter, point2DWorld );
displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPost );
Vector2D vector2DDisplayDiff = point2DDisplayPost - point2DDisplayPre;
//Vector2D origin = displayGeometry->GetOriginInMM();
displayGeometry->MoveBy( vector2DDisplayDiff );
rotatedPlaneSNC->SendCreatedWorldGeometryUpdate();
}
else
{
SNCVector::iterator iter;
for ( iter = m_RotatableSNCs.begin(); iter != m_RotatableSNCs.end(); ++iter )
{
BaseRenderer *renderer = (*iter)->GetRenderer();
if ( renderer == NULL )
{
continue;
}
DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
Point2D point2DWorld, point2DDisplayPre, point2DDisplayPost;
displayGeometry->Map( rotationCenter, point2DWorld );
displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPre );
TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
if ( !timeGeometry )
{
continue;
}
timeGeometry->ExecuteOperation( &op );
displayGeometry->Map( rotationCenter, point2DWorld );
displayGeometry->WorldToDisplay( point2DWorld, point2DDisplayPost );
Vector2D vector2DDisplayDiff = point2DDisplayPost - point2DDisplayPre;
//Vector2D origin = displayGeometry->GetOriginInMM();
displayGeometry->MoveBy( vector2DDisplayDiff );
(*iter)->SendCreatedWorldGeometryUpdate();
}
}
} // end RotateToPoint
bool SlicesRotator::DoRotationStep(Action*, const StateEvent* e)
{
const DisplayPositionEvent* posEvent = dynamic_cast<const DisplayPositionEvent*>(e->GetEvent());
if (!posEvent) return false;
Point3D cursor = posEvent->GetWorldPosition();
Vector3D toProjected = m_LastCursorPosition - m_CenterOfRotation;
Vector3D toCursor = cursor - m_CenterOfRotation;
// cross product: | A x B | = |A| * |B| * sin(angle)
Vector3D axisOfRotation;
vnl_vector_fixed< ScalarType, 3 > vnlDirection = vnl_cross_3d( toCursor.GetVnlVector(), toProjected.GetVnlVector() );
axisOfRotation.SetVnlVector(vnlDirection);
// scalar product: A * B = |A| * |B| * cos(angle)
// tan = sin / cos
ScalarType angle = - atan2( (double)(axisOfRotation.GetNorm()), (double)(toCursor * toProjected) );
angle *= 180.0 / vnl_math::pi;
m_LastCursorPosition = cursor;
// create RotationOperation and apply to all SNCs that should be rotated
RotationOperation rotationOperation(OpROTATE, m_CenterOfRotation, axisOfRotation, angle);
// iterate the OTHER slice navigation controllers: these are filled in DoDecideBetweenRotationAndSliceSelection
for (SNCVector::iterator iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
{
// - remember the center of rotation on the 2D display BEFORE rotation
// - execute rotation
// - calculate new center of rotation on 2D display
// - move display IF the center of rotation has moved slightly before and after rotation
// DM 2012-10: this must probably be due to rounding errors only, right?
// We don't have documentation on if/why this code is needed
BaseRenderer *renderer = (*iter)->GetRenderer();
if ( !renderer ) continue;
DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
Point2D rotationCenter2DWorld, point2DDisplayPreRotation, point2DDisplayPostRotation;
displayGeometry->Map( m_CenterOfRotation, rotationCenter2DWorld );
displayGeometry->WorldToDisplay( rotationCenter2DWorld, point2DDisplayPreRotation );
TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
if (!timeGeometry) continue;
timeGeometry->ExecuteOperation(&rotationOperation);
displayGeometry->Map( m_CenterOfRotation, rotationCenter2DWorld );
displayGeometry->WorldToDisplay( rotationCenter2DWorld, point2DDisplayPostRotation );
Vector2D vector2DDisplayDiff = point2DDisplayPostRotation - point2DDisplayPreRotation;
displayGeometry->MoveBy( vector2DDisplayDiff );
(*iter)->SendCreatedWorldGeometryUpdate();
}
RenderingManager::GetInstance()->RequestUpdateAll();
this->InvokeEvent( SliceRotationEvent() ); // notify listeners
return true;
}
bool SlicesRotator::DoDecideBetweenRotationAndSliceSelection(Action*, const StateEvent* e)
{
// Decide between moving and rotation slices.
// For basic decision logic see class documentation.
/*
Detail logic:
1. Find the SliceNavigationController that has sent the event: this one defines our rendering plane and will NOT be rotated. Needs not even be counted or checked.
2. Inspect every other SliceNavigationController
- calculate the line intersection of this SliceNavigationController's plane with our rendering plane
- if there is NO interesection, ignore and continue
- IF there is an intersection
- check the mouse cursor's distance from that line.
0. if the line is NOT near the cursor, remember the plane as "one of the other planes" (which can be rotated in "locked" mode)
1. on first line near the cursor, just remember this intersection line as THE other plane that we want to rotate
2. on every consecutive line near the cursor, check if the line is geometrically identical to the line that we want to rotate
- if yes, we just push this line to the "other" lines and rotate it along
- if no, then we have a situation where the mouse is near two other lines (e.g. crossing point) and don't want to rotate
*/
const DisplayPositionEvent* posEvent = dynamic_cast<const DisplayPositionEvent*>(e->GetEvent());
if (!posEvent) return false;
BaseRenderer* clickedRenderer = e->GetEvent()->GetSender();
const PlaneGeometry* ourViewportGeometry = dynamic_cast<const PlaneGeometry*>( clickedRenderer->GetCurrentWorldPlaneGeometry() );
// These sanity checks were introduced with bug 17877, since plane geometries are now a shared base class of several geometries
// They may ultimately be unecessary
const mitk::AbstractTransformGeometry* abstractGeometry = dynamic_cast< const AbstractTransformGeometry * > (ourViewportGeometry);
if (abstractGeometry != NULL) MITK_WARN << "SliceRotator recieved an AbstractTransformGeometry, expecting a simple PlainGeometry, behaviour should be verified.";
const mitk::DisplayGeometry* displayGeometry = dynamic_cast< const DisplayGeometry * > (ourViewportGeometry);
if (displayGeometry != NULL) MITK_WARN << "SliceRotator recieved a DisplayGeometry, expecting a simple PlainGeometry, behaviour should be verified.";
// End sanity checks
if (!ourViewportGeometry) return false;
DisplayGeometry* clickedDisplayGeometry = clickedRenderer->GetDisplayGeometry();
if (!clickedDisplayGeometry) return false;
MITK_DEBUG << "=============================================";
MITK_DEBUG << "Renderer under cursor is " << clickedRenderer->GetName();
Point3D cursorPosition = posEvent->GetWorldPosition();
const PlaneGeometry* geometryToBeRotated = NULL; // this one is under the mouse cursor
const PlaneGeometry* anyOtherGeometry = NULL; // this is also visible (for calculation of intersection ONLY)
Line3D intersectionLineWithGeometryToBeRotated;
bool hitMultipleLines(false);
m_SNCsToBeRotated.clear();
const double threshholdDistancePixels = 12.0;
for (SNCVector::iterator iter = m_RotatableSNCs.begin(); iter != m_RotatableSNCs.end(); ++iter)
{
// If the mouse cursor is in 3D Renderwindow, do not check for intersecting planes.
if (clickedRenderer->GetMapperID() == BaseRenderer::Standard3D)
break;
const PlaneGeometry* otherRenderersRenderPlane = (*iter)->GetCurrentPlaneGeometry();
if (otherRenderersRenderPlane == NULL) continue; // ignore, we don't see a plane
MITK_DEBUG << " Checking plane of renderer " << (*iter)->GetRenderer()->GetName();
// check if there is an intersection
Line3D intersectionLine; // between rendered/clicked geometry and the one being analyzed
if (!ourViewportGeometry->IntersectionLine( otherRenderersRenderPlane, intersectionLine ))
{
continue; // we ignore this plane, it's parallel to our plane
}
// check distance from intersection line
double distanceFromIntersectionLine = intersectionLine.Distance( cursorPosition );
ScalarType distancePixels = distanceFromIntersectionLine / clickedDisplayGeometry->GetScaleFactorMMPerDisplayUnit();
MITK_DEBUG << " Distance of plane from cursor " << distanceFromIntersectionLine << " mm, which is around " << distancePixels << " px" ;
// far away line, only remember for linked rotation if necessary
if (distanceFromIntersectionLine > threshholdDistancePixels)
{
MITK_DEBUG << " Plane is too far away --> remember as otherRenderersRenderPlane";
anyOtherGeometry = otherRenderersRenderPlane; // we just take the last one, so overwrite each iteration (we just need some crossing point)
// TODO what about multiple crossings? NOW we have undefined behavior / random crossing point is used
if (m_LinkPlanes)
{
m_SNCsToBeRotated.push_back(*iter);
}
}
else // close to cursor
{
MITK_DEBUG << " Plane is close enough to cursor...";
if ( geometryToBeRotated == NULL ) // first one close to the cursor
{
MITK_DEBUG << " It is the first close enough geometry, remember as geometryToBeRotated";
geometryToBeRotated = otherRenderersRenderPlane;
intersectionLineWithGeometryToBeRotated = intersectionLine;
m_SNCsToBeRotated.push_back(*iter);
}
else
{
MITK_DEBUG << " Second or later close enough geometry";
// compare to the line defined by geometryToBeRotated: if identical, just rotate this otherRenderersRenderPlane together with the primary one
// if different, DON'T rotate
if ( intersectionLine.IsParallel( intersectionLineWithGeometryToBeRotated )
&& intersectionLine.Distance( intersectionLineWithGeometryToBeRotated.GetPoint1() ) < mitk::eps )
{
MITK_DEBUG << " This line is the same as intersectionLineWithGeometryToBeRotated which we already know";
m_SNCsToBeRotated.push_back(*iter);
}
else
{
MITK_DEBUG << " This line is NOT the same as intersectionLineWithGeometryToBeRotated which we already know";
hitMultipleLines = true;
}
}
}
}
bool moveSlices(true);
if ( geometryToBeRotated && anyOtherGeometry && ourViewportGeometry && !hitMultipleLines )
{
// assure all three are valid, so calculation of center of rotation can be done
moveSlices = false;
}
MITK_DEBUG << "geometryToBeRotated: " << (void*)geometryToBeRotated;
MITK_DEBUG << "anyOtherGeometry: " << (void*)anyOtherGeometry;
MITK_DEBUG << "ourViewportGeometry: " << (void*)ourViewportGeometry;
MITK_DEBUG << "hitMultipleLines? " << hitMultipleLines;
MITK_DEBUG << "moveSlices? " << moveSlices;
std::auto_ptr<StateEvent> decidedEvent;
// question in state machine is: "rotate?"
if (moveSlices) // i.e. NOT rotate
{
// move all planes to posEvent->GetWorldPosition()
decidedEvent.reset( new StateEvent(EIDNO, e->GetEvent()) );
MITK_DEBUG << "Rotation not possible, not enough information (other planes crossing rendering plane) ";
}
else
{ // we DO have enough information for rotation
m_LastCursorPosition = intersectionLineWithGeometryToBeRotated.Project(cursorPosition); // remember where the last cursor position ON THE LINE has been observed
if (anyOtherGeometry->IntersectionPoint(intersectionLineWithGeometryToBeRotated, m_CenterOfRotation)) // find center of rotation by intersection with any of the OTHER lines
{
decidedEvent.reset( new StateEvent(EIDYES, e->GetEvent()) );
MITK_DEBUG << "Rotation possible";
}
else
{
MITK_DEBUG << "Rotation not possible, cannot determine the center of rotation!?";
decidedEvent.reset( new StateEvent(EIDNO, e->GetEvent()) );
}
}
this->HandleEvent( decidedEvent.get() );
return true;
}
