Subclass of QmitkStdMultiWidget to provide MIDAS specific functionality by having convenient methods to control geometry, background, cursors on/off etc. via calling methods in the base class QmitkStdMultiWidget. More...

Inheritance diagram for niftk::MultiWindowWidget:

[legend]

Collaboration diagram for niftk::MultiWindowWidget:

[legend]

Signals
void	WindowLayoutChanged (WindowLayout windowLayout)
	Emitted when the window layout has changed. More...

void	SelectedPositionChanged (const mitk::Point3D &selectedPosition)
	Emitted when the selected slice has changed in a render window. More...

void	TimeStepChanged (int timeStep)
	Emitted when the selected time step has changed in the rendering manager. Note that the time navigation controller is unique for the rendering manager, not only for this viewer. More...

void	CursorPositionChanged (int windowIndex, const mitk::Vector2D &cursorPosition)
	Emitted when the cursor position has changed in a render window. More...

void	ScaleFactorChanged (int windowIndex, double scaleFactor)
	Emitted when the scale factor has changed. More...

void	CursorPositionBindingChanged ()
	Emitted when the cursor position binding has changed. More...

void	ScaleFactorBindingChanged ()
	Emitted when the scale factor binding has changed. More...

Public Member Functions
	MultiWindowWidget (QWidget parent=0, Qt::WindowFlags f=0, mitk::RenderingManager renderingManager=0, mitk::BaseRenderer::RenderingMode::Type renderingMode=mitk::BaseRenderer::RenderingMode::Standard, const QString &name="DnD-Viewer")
	Constructor. More...

virtual	~MultiWindowWidget ()
	Destructor. More...

bool	IsEnabled () const
	Return whether this widget is considered 'enabled'. More...

void	SetEnabled (bool enabled)
	There are several things we turn off/on depending on whether the widget is visible or considered active, so we group them all under this Enabled(true/false) flag. More...

bool	IsCursorVisible () const
	Get the flag controlling the 2D cursors visibility (renderer specific properties). More...

void	SetCursorVisible (bool visible)
	Turn the 2D cursors visible/invisible for this viewer (renderer specific properties). More...

bool	AreDirectionAnnotationsVisible () const
	Tells if the direction annotations are visible. More...

void	SetDirectionAnnotationsVisible (bool visible)
	Sets the visibility of the direction annotations. More...

bool	IsIntensityAnnotationVisible () const
	Tells if the intensity annotation is visible. More...

void	SetIntensityAnnotationVisible (bool visible)
	Sets the visibility of the intensity annotation. More...

bool	GetShow3DWindowIn2x2WindowLayout () const
	Returns the flag indicating if nodes will be visible in 3D window when in 2x2 window layout. In 3D window layout, always visible. More...

void	SetShow3DWindowIn2x2WindowLayout (bool visible)
	If true, then nodes will be visible in 3D window when in 2x2 window layout. In 3D window layout, always visible. More...

void	SetTimeGeometry (const mitk::TimeGeometry *timeGeometry)
	Initialises the geometry in the QmitkStdMultiWidget base class. This has been a difficult method to get to work properly. Developers should look at the code comments. More...

void	SetWindowLayout (WindowLayout windowLayout)
	Switches the window layout, i.e. the set and the arrangement of the render windows. More...

WindowLayout	GetWindowLayout () const
	Gets the window layout, i.e. the set and the arrangement of the render windows. More...

void	SetBackgroundColour (QColor color)
	Set the background color, applied to 2D and 3D windows, and currently we don't do gradients. More...

QColor	GetBackgroundColour () const
	Get the background color, applied to 2D and 3D windows, and currently we don't do gradients. More...

bool	IsFocused () const
	Tells if the selected render window of this widget has the focus. The focused render window receives the keyboard and mouse events and has a coloured border. More...

void	SetFocused ()
	Sets the focus to the selected render window of this widget. The focused render window receives the keyboard and mouse events and has a coloured border. More...

bool	IsLinkedNavigationEnabled () const
	Gets the flag that controls whether we are listening to the navigation controller events. More...

void	SetLinkedNavigationEnabled (bool linkedNavigationEnabled)
	Sets the flag that controls whether we are listening to the navigation controller events. More...

QmitkRenderWindow *	GetSelectedRenderWindow () const
	Returns the selected render window. The selected render window is one of the visible render windows. If this widget has the focus then the selected render window is the focused render window. Otherwise, it is is the render window that was focused last time, if it is currently visible. If no window is focused and the last focused widget is not visible now then the selected window is the top-left window of the current window layout. The selected render window does not necessarily have a coloured border, only if it is focused. This function always returns one of the four render windows, never 0. More...

void	SetSelectedRenderWindow (QmitkRenderWindow *renderWindow)
	Sets the selected render window. If this widget has the focus then the focuse is transferred to the given render window and it gets the coloured border. If the specified render window is not visible or it is not in this widget, the function does not do anything. More...

int	GetSelectedWindowIndex () const
	Returns the index of the selected window. More...

void	SetSelectedWindowIndex (int selectedWindowIndex)
	Sets the selected render window by its index. More...

std::vector< QmitkRenderWindow * >	GetVisibleRenderWindows () const
	Returns the specifically selected render window, which may be 1 if the viewer is showing a single axial, coronal or sagittal plane, or may be up to 4 if the viewer is displaying the 2x2 window layout. More...

const std::vector < QmitkRenderWindow * > &	GetRenderWindows () const
	Returns the list of all QmitkRenderWindow contained herein. More...

bool	ContainsRenderWindow (QmitkRenderWindow *renderWindow) const
	Returns true if this widget contains the provided window and false otherwise. More...

int	GetMaxSlice (int windowIndex) const
	Returns the maximum allowed slice index for a given orientation. More...

int	GetMaxTimeStep () const
	Returns the maximum allowed time step. More...

int	GetSelectedSlice (int windowIndex) const
	Get the current slice index. More...

void	SetSelectedSlice (int windowIndex, int selectedSlice)
	Set the current slice index. More...

void	MoveSlice (int windowIndex, int delta, bool restart=false)
	Move n slices towards or opposite of the up direction. If delta is positive, the direction is the up direction. More...

int	GetTimeStep () const
	Get the current time step. More...

void	SetTimeStep (int timeStep)
	Set the current time step. More...

const mitk::Point3D &	GetSelectedPosition () const
	Gets the selected point in the world coordinate system (mm). More...

void	SetSelectedPosition (const mitk::Point3D &selectedPosition)
	Sets the selected position in the world coordinate system (mm). More...

const mitk::Vector2D &	GetCursorPosition (int windowIndex) const
	Gets the cursor position normalised with the render window size. More...

void	SetCursorPosition (int windowIndex, const mitk::Vector2D &cursorPosition)
	Sets the cursor position normalised with the render window size. More...

const std::vector < mitk::Vector2D > &	GetCursorPositions () const
	Gets the positions of the cursor in the 2D render windows normalised with the render window size. More...

void	SetCursorPositions (const std::vector< mitk::Vector2D > &cursorPositions)
	Sets the positions of the cursor in the 2D render windows normalised with the render window size. More...

double	GetScaleFactor (int windowIndex) const
	Gets the scale factor of the given render window. (mm/px) More...

void	SetScaleFactor (int windowIndex, double scaleFactor)
	Sets the scale factor of the render window to the given value (mm/px) and moves the image so that the position of the focus remains the same. If the zooming is bound across the windows then this will set the scaling of the other windows as well. More...

const std::vector< double > &	GetScaleFactors () const
	Gets the scale factors of the 2D render windows. More...

void	SetScaleFactors (const std::vector< double > &scaleFactors)
	Sets the scale factor of the render windows to the given values. More...

const mitk::Vector3D &	GetVoxelSize () const
	Gets the voxel size (mm/vx). More...

double	GetMagnification (int windowIndex) const
	Computes the magnification of a render window. More...

void	SetMagnification (int windowIndex, double magnification)
	Sets the magnification of a render window to the given value. More...

void	FitRenderWindows (double scaleFactor=0.0)
	Moves the displayed regions to the centre of the 2D render windows and scales them, optionally. If no scale factor is given or the specified value is 0.0 then the maximal zooming is applied, using which each region fits into their window, also considering whether the scale factors are bound across the windows. If a positive scale factor is given then the scale factor of each render window is set to the specified value. If the specified scale factor is -1.0 then no scaling is applied. The regions are moved to the middle of the render windows in each cases. More...

void	FitRenderWindow (int windowIndex, double scaleFactor=0.0)
	Moves the displayed region to the centre of the 2D render window and scales it, optionally. If no scale factor is given or the specified value is 0.0 then the region is scaled to the maximum size that fits into the render window. If a positive scale factor is given then the region is scaled to the specified value. If the specified scale factor is -1.0 then no scaling is applied. The region is moved to the middle of the render window in each cases. The function c. More...

void	SetVisibility (std::vector< mitk::DataNode * > nodes, bool visibility)
	Sets the visible flag for all the nodes, and all the renderers in the QmitkStdMultiWidget base class. More...

void	RequestUpdate ()
	Only request an update for screens that are visible and enabled. More...

int	GetSliceUpDirection (WindowOrientation orientation) const
	According to the currently set geometry will return +1, or -1 for the direction to increment the slice number to move "up". More...

bool	GetCursorPositionBinding () const
	Gets the flag that controls whether the cursor position is bound between the 2D render windows. More...

void	SetCursorPositionBinding (bool cursorPositionBinding)
	Sets the flag that controls whether the cursor position is bound between the 2D render windows. More...

bool	GetScaleFactorBinding () const
	Gets the flag controls whether the scale factors are bound across the 2D render windows. More...

void	SetScaleFactorBinding (bool scaleFactorBinding)
	Sets the flag that controls whether the scale factors are bound across the 2D render windows. More...

bool	BlockUpdate (bool blocked)
	Blocks the update of the widget. More...

bool	BlockDisplayEvents (bool blocked)

Friends
class	SingleViewerWidget

class	DisplayGeometryModificationCommand

Detailed Description

Subclass of QmitkStdMultiWidget to provide MIDAS specific functionality by having convenient methods to control geometry, background, cursors on/off etc. via calling methods in the base class QmitkStdMultiWidget.

In MIDAS terms, the widget will nearly always be in Axial, Coronal or Sagittal mode, but we subclass QmitkStdMultiWidget so that we can optionally have 3D views, ortho-views etc.

Please do NOT expose this class to the rest of the NiftyView code-base, or else dependency management becomes a bit of an issue. The class SingleViewerWidget wraps this one, and the rest of our application should only deal with SingleViewerWidget.

Note: The requirements specification for MIDAS style zoom basically says:

magnification   : actual pixels per voxel.
on MIDAS widget :
2               : 3
1               : 2
0               : 1 (i.e. no magnification).
-1              : 0.5 (i.e. 1 pixel covers 2 voxels).
-2              : 0.33 (i.e. 1 pixel covers 3 voxels).
etc.

In contrast with the original MIDAS, in NiftyMIDAS the zooming is continuous, so the rule above is extended to real numbers as well. If the image has anisotropic pixels then the size of the longer side of the voxels is used for the calculation for each orientation.

See also: QmitkStdMultiWidget; SingleViewerWidget; MultiViewerWidget

Constructor & Destructor Documentation

niftk::MultiWindowWidget::MultiWindowWidget	(	QWidget *	parent = `0`,
		Qt::WindowFlags	f = `0`,
		mitk::RenderingManager *	renderingManager = `0`,
		mitk::BaseRenderer::RenderingMode::Type	renderingMode = `mitk::BaseRenderer::RenderingMode::Standard`,
		const QString &	name = `"DnD-Viewer"`
	)

Constructor.

Note: The rendering manager is surely not null. If NULL is specified then the superclass constructor initialised it with the default one.

This call requires MITK modification. Currently, the displayed region is rescaled around the centre of the render window when the window is resized. This is not good for us, because we want to rescale the region around the cursor. Setting the 'KeepDisplayedRegion' property to false would disable the behaviour of MITK, so we can apply the rescaling in our way. This line is commented out until this feature is added to our MITK fork.

niftk::MultiWindowWidget::~MultiWindowWidget ( )

virtual

Destructor.

Member Function Documentation

bool niftk::MultiWindowWidget::AreDirectionAnnotationsVisible ( ) const

Tells if the direction annotations are visible.

bool niftk::MultiWindowWidget::BlockDisplayEvents ( bool blocked )

bool niftk::MultiWindowWidget::BlockUpdate ( bool blocked )

Blocks the update of the widget.

Returns true if the update was already blocked, otherwise false. While the update is blocked, the state changes are recorded but the render windows are not updated and no signals are sent out. The render windows are updated and the "pending" signals are sent out when the update is unblocked. The purpose of this function is to avoid unnecessary updates and signals when a serious of operations needs to be performed on the viewer as a single atomic unit, e.g. changing layout and setting positions. After the required state of the viewer is set, the previous blocking state should be restored.

Pattern of usage:

bool updateWasBlocked = multiWidget->BlockUpdate(true);
... set the required state ...
multiWidget->BlockUpdate(updateWasBlocked);

Updating state according to the recorded changes.

Note: A viewer has a border iff it has the focus and it has a valid geometry. Therefore, the borders should be updated at the first time when m_Geometry is assigned a valid geometry.

Updating render windows where necessary.

Sending events and signals.

bool niftk::MultiWindowWidget::ContainsRenderWindow ( QmitkRenderWindow * renderWindow ) const

Returns true if this widget contains the provided window and false otherwise.

void niftk::MultiWindowWidget::CursorPositionBindingChanged ( )

signal

Emitted when the cursor position binding has changed.

void niftk::MultiWindowWidget::CursorPositionChanged	(	int	windowIndex,
		const mitk::Vector2D &	cursorPosition
	)

signal

Emitted when the cursor position has changed in a render window.

void niftk::MultiWindowWidget::FitRenderWindow	(	int	windowIndex,
		double	scaleFactor = `0.0`
	)

Moves the displayed region to the centre of the 2D render window and scales it, optionally. If no scale factor is given or the specified value is 0.0 then the region is scaled to the maximum size that fits into the render window. If a positive scale factor is given then the region is scaled to the specified value. If the specified scale factor is -1.0 then no scaling is applied. The region is moved to the middle of the render window in each cases. The function c.

TODO The condition is commented out so that the unit tests pass. The condition is good, though, the unit tests should be corrected.

void niftk::MultiWindowWidget::FitRenderWindows ( double scaleFactor = 0.0 )

Moves the displayed regions to the centre of the 2D render windows and scales them, optionally. If no scale factor is given or the specified value is 0.0 then the maximal zooming is applied, using which each region fits into their window, also considering whether the scale factors are bound across the windows. If a positive scale factor is given then the scale factor of each render window is set to the specified value. If the specified scale factor is -1.0 then no scaling is applied. The regions are moved to the middle of the render windows in each cases.

If neither the cursor positions nor the scale factors are not bound, we simply fit each displayed region into their window.

If the cursor positions are bound but the scale factors are not, first we fit the selected window then synchronise the positions in the other windows to it.

If the scale factors are bound then after moving the regions to the center the cursors will be aligned. Therefore we do not need to handle differently if the cursors are bound or not.

If the scale factors are bound and no scale factor is given then we need to find the window that requires the largest scaling.

Finally, we apply the same scale factor to every render window.

QColor niftk::MultiWindowWidget::GetBackgroundColour ( ) const

Get the background color, applied to 2D and 3D windows, and currently we don't do gradients.

const mitk::Vector2D & niftk::MultiWindowWidget::GetCursorPosition ( int windowIndex ) const

Gets the cursor position normalised with the render window size.

The values are in the [0.0, 1.0] range and represent the position inside the render window:

pixel coordinate / render window size

bool niftk::MultiWindowWidget::GetCursorPositionBinding ( ) const

Gets the flag that controls whether the cursor position is bound between the 2D render windows.

const std::vector< mitk::Vector2D > & niftk::MultiWindowWidget::GetCursorPositions ( ) const

Gets the positions of the cursor in the 2D render windows normalised with the render window size.

The values are in the [0.0, 1.0] range and represent the position inside the render windows:

pixel coordinate / render window size

The vector contains the cursor positions in the following order: axial, sagittal, coronal. The values that correspond to a currently not visible window are undefined.

double niftk::MultiWindowWidget::GetMagnification ( int windowIndex ) const

Computes the magnification of a render window.

int niftk::MultiWindowWidget::GetMaxSlice ( int windowIndex ) const

Returns the maximum allowed slice index for a given orientation.

int niftk::MultiWindowWidget::GetMaxTimeStep ( ) const

Returns the maximum allowed time step.

const std::vector< QmitkRenderWindow * > & niftk::MultiWindowWidget::GetRenderWindows ( ) const

Returns the list of all QmitkRenderWindow contained herein.

double niftk::MultiWindowWidget::GetScaleFactor ( int windowIndex ) const

Gets the scale factor of the given render window. (mm/px)

bool niftk::MultiWindowWidget::GetScaleFactorBinding ( ) const

Gets the flag controls whether the scale factors are bound across the 2D render windows.

const std::vector< double > & niftk::MultiWindowWidget::GetScaleFactors ( ) const

Gets the scale factors of the 2D render windows.

The vector contains the scale factors in the following order: axial, sagittal, coronal. The values that correspond to a currently not visible window are undefined.

const mitk::Point3D & niftk::MultiWindowWidget::GetSelectedPosition ( ) const

Gets the selected point in the world coordinate system (mm).

QmitkRenderWindow * niftk::MultiWindowWidget::GetSelectedRenderWindow ( ) const

Returns the selected render window. The selected render window is one of the visible render windows. If this widget has the focus then the selected render window is the focused render window. Otherwise, it is is the render window that was focused last time, if it is currently visible. If no window is focused and the last focused widget is not visible now then the selected window is the top-left window of the current window layout. The selected render window does not necessarily have a coloured border, only if it is focused. This function always returns one of the four render windows, never 0.

int niftk::MultiWindowWidget::GetSelectedSlice ( int windowIndex ) const

Get the current slice index.

Round it to the closest integer.

int niftk::MultiWindowWidget::GetSelectedWindowIndex ( ) const

Returns the index of the selected window.

bool niftk::MultiWindowWidget::GetShow3DWindowIn2x2WindowLayout ( ) const

Returns the flag indicating if nodes will be visible in 3D window when in 2x2 window layout. In 3D window layout, always visible.

int niftk::MultiWindowWidget::GetSliceUpDirection ( WindowOrientation orientation ) const

According to the currently set geometry will return +1, or -1 for the direction to increment the slice number to move "up".

int niftk::MultiWindowWidget::GetTimeStep ( ) const

Get the current time step.

std::vector< QmitkRenderWindow * > niftk::MultiWindowWidget::GetVisibleRenderWindows ( ) const

Returns the specifically selected render window, which may be 1 if the viewer is showing a single axial, coronal or sagittal plane, or may be up to 4 if the viewer is displaying the 2x2 window layout.

const mitk::Vector3D& niftk::MultiWindowWidget::GetVoxelSize ( ) const

Gets the voxel size (mm/vx).

WindowLayout niftk::MultiWindowWidget::GetWindowLayout ( ) const

Gets the window layout, i.e. the set and the arrangement of the render windows.

bool niftk::MultiWindowWidget::IsCursorVisible ( ) const

Get the flag controlling the 2D cursors visibility (renderer specific properties).

bool niftk::MultiWindowWidget::IsEnabled ( ) const

Return whether this widget is considered 'enabled'.

bool niftk::MultiWindowWidget::IsFocused ( ) const

Tells if the selected render window of this widget has the focus. The focused render window receives the keyboard and mouse events and has a coloured border.

bool niftk::MultiWindowWidget::IsIntensityAnnotationVisible ( ) const

Tells if the intensity annotation is visible.

bool niftk::MultiWindowWidget::IsLinkedNavigationEnabled ( ) const

Gets the flag that controls whether we are listening to the navigation controller events.

void niftk::MultiWindowWidget::MoveSlice	(	int	windowIndex,
		int	delta,
		bool	restart = `false`
	)

Move n slices towards or opposite of the up direction. If delta is positive, the direction is the up direction.

Parameters

windowIndex	the index of the 2D window that determines the orientation (axial = 0, sagittal = 1, coronal = 2)
delta	tells how many slices to move. Negative value means moving backwards. i.e. against the up direction.
loop	tells if the next slice should be taken from the beginning if the last slice has been reached or vice versa.

Note. As a request and for MIDAS compatibility, all the slice have to be forcibly rendered when scrolling through them by keeping the 'a' or 'z' key pressed. Otherwise, issues on the scan or in the segmentation may be not seen.

TODO: In spite of the comment above, it is not right to do any render window update here. The forced immediate update should be done in the BlockUpdate() function.

void niftk::MultiWindowWidget::RequestUpdate ( )

Only request an update for screens that are visible and enabled.

void niftk::MultiWindowWidget::ScaleFactorBindingChanged ( )

signal

Emitted when the scale factor binding has changed.

void niftk::MultiWindowWidget::ScaleFactorChanged	(	int	windowIndex,
		double	scaleFactor
	)

signal

Emitted when the scale factor has changed.

void niftk::MultiWindowWidget::SelectedPositionChanged ( const mitk::Point3D & selectedPosition )

signal

Emitted when the selected slice has changed in a render window.

void niftk::MultiWindowWidget::SetBackgroundColour ( QColor color )

Set the background color, applied to 2D and 3D windows, and currently we don't do gradients.

void niftk::MultiWindowWidget::SetCursorPosition	(	int	windowIndex,
		const mitk::Vector2D &	cursorPosition
	)

Sets the cursor position normalised with the render window size.

The values are in the [0.0, 1.0] range and represent the position inside the render window:

pixel coordinate / render window size

This function does not change the selected point in world but moves the image in the given render window so that the cursor (aka. crosshair) gets to the specified position in the render window.

void niftk::MultiWindowWidget::SetCursorPositionBinding ( bool cursorPositionBinding )

Sets the flag that controls whether the cursor position is bound between the 2D render windows.

We raise the event in the coronal window so that the cursors are in sync along the third axis, too.

void niftk::MultiWindowWidget::SetCursorPositions ( const std::vector< mitk::Vector2D > & cursorPositions )

Sets the positions of the cursor in the 2D render windows normalised with the render window size.

The values are in the [0.0, 1.0] range and represent the position inside the render windows:

pixel coordinate / render window size

The vector should contain the cursor positions in the following order: axial, sagittal, coronal. The values that correspond to a currently not visible window are not used by this function.

void niftk::MultiWindowWidget::SetCursorVisible ( bool visible )

Turn the 2D cursors visible/invisible for this viewer (renderer specific properties).

void niftk::MultiWindowWidget::SetDirectionAnnotationsVisible ( bool visible )

Sets the visibility of the direction annotations.

void niftk::MultiWindowWidget::SetEnabled ( bool enabled )

There are several things we turn off/on depending on whether the widget is visible or considered active, so we group them all under this Enabled(true/false) flag.

void niftk::MultiWindowWidget::SetFocused ( )

Sets the focus to the selected render window of this widget. The focused render window receives the keyboard and mouse events and has a coloured border.

void niftk::MultiWindowWidget::SetIntensityAnnotationVisible ( bool visible )

Sets the visibility of the intensity annotation.

void niftk::MultiWindowWidget::SetLinkedNavigationEnabled ( bool linkedNavigationEnabled )

Sets the flag that controls whether we are listening to the navigation controller events.

void niftk::MultiWindowWidget::SetMagnification	(	int	windowIndex,
		double	magnification
	)

Sets the magnification of a render window to the given value.

void niftk::MultiWindowWidget::SetScaleFactor	(	int	windowIndex,
		double	scaleFactor
	)

Sets the scale factor of the render window to the given value (mm/px) and moves the image so that the position of the focus remains the same. If the zooming is bound across the windows then this will set the scaling of the other windows as well.

void niftk::MultiWindowWidget::SetScaleFactorBinding ( bool scaleFactorBinding )

Sets the flag that controls whether the scale factors are bound across the 2D render windows.

void niftk::MultiWindowWidget::SetScaleFactors ( const std::vector< double > & scaleFactors )

Sets the scale factor of the render windows to the given values.

The vector should contain the scale factors in the following order: axial, sagittal, coronal. The values that correspond to a currently not visible window are not used by this function.

void niftk::MultiWindowWidget::SetSelectedPosition ( const mitk::Point3D & selectedPosition )

Sets the selected position in the world coordinate system (mm).

The selected position will be at the centre of the voxel that contains the given coordinate.

This function will not move the displayed region in the selected render window. If multiple windows are shown and the cursor position is bound across them then the region will be moved in the other windows so that cursors are aligned.

Work out a window so that if the cursor positions are bound then we can synchronise the other 2D render windows to it.

void niftk::MultiWindowWidget::SetSelectedRenderWindow ( QmitkRenderWindow * renderWindow )

Sets the selected render window. If this widget has the focus then the focuse is transferred to the given render window and it gets the coloured border. If the specified render window is not visible or it is not in this widget, the function does not do anything.

void niftk::MultiWindowWidget::SetSelectedSlice	(	int	windowIndex,
		int	selectedSlice
	)

Set the current slice index.

void niftk::MultiWindowWidget::SetSelectedWindowIndex ( int selectedWindowIndex )

Sets the selected render window by its index.

void niftk::MultiWindowWidget::SetShow3DWindowIn2x2WindowLayout ( bool visible )

If true, then nodes will be visible in 3D window when in 2x2 window layout. In 3D window layout, always visible.

void niftk::MultiWindowWidget::SetTimeGeometry ( const mitk::TimeGeometry * timeGeometry )

Initialises the geometry in the QmitkStdMultiWidget base class. This has been a difficult method to get to work properly. Developers should look at the code comments.

The place of the direction annotations on the render window:

+-—0-—+ | | 3 1 | | +-—2-—+

Coronal:

Axial:

TODO The function has been removed in MITK 2014.09.

Note: The renderers are listening to the GeometrySendEvents of their slice navigation controller, and they update their world geometry to the one of their SNC whenever it changes. However, the SNC signals are blocked when the update of this viewer is blocked, and the SNC GeometrySendEvents are sent out only when BlockUpdate(false) is called for this widget. The renderers would update their world geometry right after this. However, the focus change signals are sent out before the SNC signals. As a result, if somebody is listening to the focus change signals, will find the old world geometry in the renderer. Therefore, here we manually set the new geometry to the renderers, even if they would get it later. Note also that the SNCs' Update function clones the input world geometry, therefore here we should not use the reference to 'createdTimeGeometry' but have to get it from the SNC.

void niftk::MultiWindowWidget::SetTimeStep ( int timeStep )

Set the current time step.

void niftk::MultiWindowWidget::SetVisibility	(	std::vector< mitk::DataNode * >	nodes,
		bool	visibility
	)

Sets the visible flag for all the nodes, and all the renderers in the QmitkStdMultiWidget base class.

void niftk::MultiWindowWidget::SetWindowLayout ( WindowLayout windowLayout )

Switches the window layout, i.e. the set and the arrangement of the render windows.

The viewer is not correctly initialised if this check is enabled.

void niftk::MultiWindowWidget::TimeStepChanged ( int timeStep )

signal

Emitted when the selected time step has changed in the rendering manager. Note that the time navigation controller is unique for the rendering manager, not only for this viewer.

void niftk::MultiWindowWidget::WindowLayoutChanged ( WindowLayout windowLayout )

signal

Emitted when the window layout has changed.

Friends And Related Function Documentation

friend class DisplayGeometryModificationCommand

friend

friend class SingleViewerWidget

friend

The documentation for this class was generated from the following files:

Signals

Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation