Slicer Wiki - User contributions [en]

Documentation/Nightly/Developers/FAQ/Python Scripting

2019-08-21T15:23:21Z

Arankin: Adding information about different decorator types and adding links to code source

<noinclude>{{documentation/versioncheck}}</noinclude>
<noinclude>__TOC__
={{#titleparts: {{PAGENAME}} | | -1 }}=</noinclude><includeonly>
='''Developer FAQ: {{{1}}}'''=
</includeonly>

== How to run pip ? ==

The pip executable is not distributed, instead the following command should be used:
* from build tree: <tt>/path/to/Slicer-SuperBuild/python-install/bin/PythonSlicer -m pip ...</tt>
* from install tree:
* Linux/MacOS: <tt>/path/to/Slicer-X.Y.Z-plat-arch/bin/PythonSlicer -m pip ...</tt>
* Windows: <tt>"c:\Program Files\Slicer 4.10.0\bin\PythonSlicer.exe" -m pip ...</tt>

See this discussion for more details and background: https://discourse.slicer.org/t/slicer-python-packages-use-and-install/984/29.

== How to access a scripted module from python scripts ==

All slicer modules are accessible in the <code>slicer.modules</code> namespace. For example, ''sampledata'' module can be accessed as <code>slicer.modules.sampledata</code>.

To access a module's widget, use <code>widgetRepresentation()</code> method to get the C++ base class and its <code>self()</code> method to get the Python class. For example, <code>slicer.modules.sampledata.widgetRepresentation().self()</code> returns the Python widget object of ''sampledata'' module.

== How to systematically execute custom python code at startup ? ==

Each time Slicer starts, it will look up for a startup script file named <code>.slicerrc.py</code> in your [[Documentation/{{documentation/version}}/FAQ/General#What_is_my_HOME_folder_.3F|HOME folder]]. Content of this file is executed automatically at each startup of Slicer.

You can find the path to the startup script in Slicer by opening in the menu: Edit / Application Settings. ''Application startup script'' path is shown in the ''General'' section.

The default name and location of the file can be overridden by setting an environment variable named <code>SLICERRC</code> that contains full path of a Python file.

== How to save an image/volume using python ? ==

The module <code>slicer.util</code> provides methods allowing to save either a node or an entire scene:
* saveNode
* saveScene

For more details see:
* https://github.com/Slicer/Slicer/blob/master/Base/Python/slicer/util.py#L229-267
* https://github.com/Slicer/Slicer/blob/master/Base/Python/slicer/tests/test_slicer_util_save.py

=== Enable or disable compression while saving a volume ===

While volumes can be accessed in Slicer Python modules as vtkMRMLVolumeNode, compression preference (or any other property for that matter) should be passed to slicer.util.saveNode function. The property will be passed to Slicer's storage node. For compression set the <code>useCompression</code> to 0 or 1. Example script:
<pre>
properties = {'useCompression': 0}; #do not compress
file_path = os.path.join(case_dir, file_name)
slicer.util.saveNode(node, file_path, properties)
</pre>

== How to assign a volume to a Slice view ? ==

Assuming the <code>MRHead</code> sample data has been loaded, you could do the following:

<pre>
red_logic = slicer.app.layoutManager().sliceWidget("Red").sliceLogic()
red_cn = red_logic.GetSliceCompositeNode()
red_logic.GetSliceCompositeNode().SetBackgroundVolumeID(slicer.util.getNode('MRHead').GetID())
</pre>

Discussion: http://slicer-devel.65872.n3.nabble.com/Assign-volumes-to-views-tt4028694.html

== How to access vtkRenderer in Slicer 3D view ? ==

<pre>
renderer = slicer.app.layoutManager().threeDWidget(0).threeDView().renderWindow().GetRenderers().GetFirstRenderer()
</pre>

== How to get VTK rendering backend ? ==

<pre>
backend = slicer.app.layoutManager().threeDWidget(0).threeDView().renderWindow().GetRenderingBackend()
</pre>

== How to access displayable manager associated with a Slicer 2D or 3D view ? ==

As originally explained [http://slicer-devel.65872.n3.nabble.com/How-to-get-the-point-of-a-3D-model-based-on-the-fiducial-position-td4031760.html#a4031762 here], you could use the method <code>getDisplayableManagers()</code> available in any [{{doxygen-class-url|qMRMLThreeDView}} qMRMLThreeDView] and [{{doxygen-class-url|qMRMLSliceView}} qMRMLSliceView].

<pre>
lm = slicer.app.layoutManager()
for v in range(lm.threeDViewCount):
td = lm.threeDWidget(v)
ms = vtk.vtkCollection()
td.getDisplayableManagers(ms)
for i in range(ms.GetNumberOfItems()):
m = ms.GetItemAsObject(i)
if m.GetClassName() == "vtkMRMLModelDisplayableManager":
print(m)
</pre>

== How to center the 3D view on the scene ? ==

<pre>
layoutManager = slicer.app.layoutManager()
threeDWidget = layoutManager.threeDWidget(0)
threeDView = threeDWidget.threeDView()
threeDView.resetFocalPoint()
</pre>

== Should I use 'old style' or 'new style' python classes in my scripted module ? ==

When python classes have no superclass specified they are 'old style' as described here [http://docs.python.org/2/reference/datamodel.html#new-style-and-classic-classes].

In general it doesn't matter for the classes in a scripted module, since they won't be subclassed either old or new style should be the same.

For other python code in slicer where you might be subclassing, it's better to use new style classes. See the class hierarchies in the [https://github.com/Slicer/Slicer/tree/master/Modules/Scripted/EditorLib EditorLib] and the [https://github.com/Slicer/Slicer/tree/master/Modules/Scripted/DICOM/DICOMLib DICOMLib] for examples.

== How to harden a transform ? ==

<pre>
>>> n = getNode('Bone')
>>> logic = slicer.vtkSlicerTransformLogic()
>>> logic.hardenTransform(n)
</pre>

Discussion: http://slicer-devel.65872.n3.nabble.com/Scripting-hardened-transforms-tt4029456.html

== Where can I find example scripts? ==

Have a look at [[Documentation/{{documentation/version}}/ScriptRepository]].

== How can I use a visual debugger for step-by-step debugging ==

===Debugging using PyCharm or PyDev===
Visual debugging (setting breakpoints, execute code step-by-step, view variables, stack, etc.) of Python scripted module is possible by using [https://www.jetbrains.com/pycharm/ PyCharm] or [http://pydev.org/ PyDev] by using the ''Python debugger'' module [[Documentation/{{documentation/version}}/Extensions/DebuggingTools|Debugging tools]] extension.

'''See detailed instructions at the [[Documentation/{{documentation/version}}/Extensions/DebuggingTools|Debugging tools extension page]].'''
[[File:PyDevRemoteDebugSlicer.png|800px|thumb|center|Visual debugging of Python modules in Slicer]]

===Debugging using Visual Studio===
On Windows, [https://github.com/Microsoft/PTVS Python Tools for Visual Studio] (PTVS) enables debugging Python inside Visual Studio. Its remote debugging capability allows attaching the debugger to Slicer's embedded Python environment.

See [[Documentation/{{documentation/version}}/Developers/Tutorials/Debugging_Python_in_Visual_Studio | Debugging Python in Visual Studio]] for details.

===Debugging using remote-pdb===

A command line debugging session with a [https://docs.python.org/3/library/pdb.html pdb] interface can be achieved with [https://github.com/ionelmc/python-remote-pdb python-remote-pdb].

Install python-remote-pdb into Slicer's Python:

git clone https://github.com/ionelmc/python-remote-pdb.git
cd python-remote-pdb
/path/to/Slicer-build/Slicer-build/Slicer ./setup.py install

Then, call ''set_trace()'' where you want to start the debugger.

from remote_pdb import set_trace; set_trace()

In the console where Slicer was started, a message like the following will be printed:

RemotePdb session open at 127.0.0.1:1234, waiting for connection

In another terminal, connect with telnet:

telnet 127.0.0.1 1234

or socat (has history, readline support):

socat readline tcp:127.0.0.1:1234

== Why can't I access my C++ Qt class from python ==
* Python wrapping of a Qt class requires a Qt style constructor with QObject as argument (it can be defaulted to null though), which is public. If one of these are missing, python wrapping will fail for that class
* You cannot access your custom C++ Qt classes from python outside of the scope of your instantiated python class. These will not work:
<pre>
BarIDRole = slicer.qFooItemDelegate.LastRole + 1

class BarTableWidget(qt.QTableWidget, VTKObservationMixin):

def __init__(self, *args, **kwargs):
[...]
</pre>

<pre>
class BarTableWidget(qt.QTableWidget, VTKObservationMixin):

BarIDRole = slicer.qFooItemDelegate.LastRole + 1

def __init__(self, *args, **kwargs):
[...]
</pre>

Instead, do:

<pre>
class BarTableWidget(qt.QTableWidget, VTKObservationMixin):

def __init__(self, *args, **kwargs):
self.BarIDRole = slicer.qFooItemDelegate.LastRole + 1
[...]
</pre>

* [Other reasons go here]

== Can I use factory method like CreateNodeByClass or GetNodesByClass ? ==

See [[Documentation/{{documentation/version}}/Developers/Tutorials/MemoryManagement#Factory_methods]]

== How can I access callData argument in a VTK object observer callback function ==

To get notification about an event emitted by a VTK object you can simply use the AddObserver method, for example:
<pre>
def sceneModifiedCallback(caller, eventId):
print("Scene modified")
print("There are {0} nodes in the scene". format(slicer.mrmlScene.GetNumberOfNodes()))

sceneModifiedObserverTag = slicer.mrmlScene.AddObserver(vtk.vtkCommand.ModifiedEvent, sceneModifiedCallback)
</pre>

If an event also contains additional information as CallData then the type of this argument has to be specified as well, for example:

<pre>
@vtk.calldata_type(vtk.VTK_OBJECT)
def nodeAddedCallback(caller, eventId, callData):
print("Node added")
print("New node: {0}".format(callData.GetName()))

nodeAddedModifiedObserverTag = slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.NodeAddedEvent, nodeAddedCallback)
</pre>

'''Note''': @vtk.calldata_type is a Python decorator, which modifies properties of a function that is declared right after the decorator. The decorator is defined in VTK (in [https://github.com/Kitware/VTK/blob/master/Wrapping/Python/vtkmodules/util/misc.py Wrapping\Python\vtk\util\misc.py]).

'''Note''': The available types are listed in [https://github.com/Kitware/VTK/blob/master/Wrapping/Python/vtkmodules/util/vtkConstants.py Wrapping\Python\vtkmodules\util\vtkConstants.py].

Usage from a class requires an extra step of creating the callback in the class __init__ function, as Python2 by default does some extra wrapping (http://stackoverflow.com/questions/9523370/adding-attributes-to-instance-methods-in-python):
<pre>
class MyClass:
def __init__(self):
from functools import partial
def nodeAddedCallback(self, caller, eventId, callData):
print("Node added")
print("New node: {0}".format(callData.GetName()))
self.nodeAddedCallback = partial(nodeAddedCallback, self)
self.nodeAddedCallback.CallDataType = vtk.VTK_OBJECT
def registerCallbacks(self):
self.nodeAddedModifiedObserverTag = slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.NodeAddedEvent, self.nodeAddedCallback)
def unregisterCallbacks(self):
slicer.mrmlScene.RemoveObserver(self.nodeAddedModifiedObserverTag)

myObject = MyClass()
myObject.registerCallbacks()
</pre>

Allowed CallDataType values: VTK_STRING, VTK_OBJECT, VTK_INT, VTK_LONG, VTK_DOUBLE, VTK_FLOAT, "string0". See more information here:
https://github.com/Kitware/VTK/blob/master/Wrapping/PythonCore/vtkPythonCommand.cxx

For a simplified syntax, see [[#How_to_manage_VTK_object_connections_.3F]]

== How to manage VTK object connections ? ==

The <tt>VTKObservationMixin</tt> is a Python mix-in that allows adding a set of methods to a class by inheritance.
It includes the following methods defined in [https://github.com/Slicer/Slicer/blob/master/Base/Python/slicer/util.py#L995 Base/Python/slicer/util.py]:
* <tt>addObserver</tt>
* <tt>hasObserver</tt>
* <tt>observer</tt>
* <tt>removeObserver</tt>
* <tt>removeObservers</tt>

The following illustrates how to observe the <tt>slicer.vtkMRMLScene.NodeAddedEvent</tt>:

<pre>
from slicer.util import VTKObservationMixin

class MyClass(VTKObservationMixin):
def __init__(self):
VTKObservationMixin.__init__(self)
self.addObserver(slicer.mrmlScene, slicer.vtkMRMLScene.NodeAddedEvent, self.nodeAddedCallback)

@vtk.calldata_type(vtk.VTK_OBJECT)
def nodeAddedCallback(self, caller, eventId, callData):
print("Node added")
print("New node: {0}".format(callData.GetName()))

myObject = MyClass()
</pre>

For additional examples of usage, see [https://github.com/Slicer/Slicer/blob/master/Base/Python/slicer/tests/test_slicer_util_VTKObservationMixin.py test_slicer_util_VTKObservationMixin.py]

== Slicer crashes if I try to access a non-existing item in an array ==

For example, this code makes Slicer crash:

<pre>
s = vtk.vtkStringArray()
s.GetValue(0)
</pre>

This behavior is expected, as all VTK objects are implemented in C++ that offers much faster operation but developers have to take care of addressing only valid array elements, for example by checking the number of elements in the array:
<pre>
if itemIndex < 0 or itemIndex >= s.GetNumberOfValues()
raise IndexError("index out of bounds")
</pre>

== How to run CLI module from Python? ==

See [[Documentation/{{documentation/version}}/Developers/Python_scripting#Running_a_CLI_from_Python|here]].

== How can I run slicer operations from a batch script? ==

<pre>
Slicer --no-main-window --python-script /tmp/test.py
</pre>

Contents of /tmp/test.py

<pre>
# use a slicer scripted module logic
from SampleData import SampleDataLogic
SampleDataLogic().downloadMRHead()
head = slicer.util.getNode('MRHead')

# use a vtk class
threshold = vtk.vtkImageThreshold()
threshold.SetInputData(head.GetImageData())
threshold.ThresholdBetween(100, 200)
threshold.SetInValue(255)
threshold.SetOutValue(0)

# use a slicer-specific C++ class
erode = slicer.vtkImageErode()
erode.SetInputConnection(threshold.GetOutputPort())
erode.SetNeighborTo4()
erode.Update()

head.SetAndObserveImageData(erode.GetOutputDataObject(0))

slicer.util.saveNode(head, "/tmp/eroded.nrrd")

exit()
</pre>

== How can I run Slicer on a headless compute node? ==

Many cluster nodes are installed with minimal linux systems that don't include X servers. X servers, particularly those with hardware acceleration traditionally needed to be installed with root privileges, making it impossible to run applications that rendered using X or OpenGL.

But there is a workaround which allows everything in slicer to work normally so you could even do headless rendering.

You can use a modern version of X that supports running a dummy framebuffer. This can be installed in user mode so you don't even need to have root on the system.

See [https://www.xpra.org/trac/wiki/Xdummy] for details.

There's a thread here with more discussion: [http://massmail.spl.harvard.edu/public-archives/slicer-devel/2015/017317.html]

Here is a working example of the approach running on a headless compute node running CTK tests (which also use Qt and VTK)

[https://github.com/pieper/CTK/blob/master/.travis.yml]

== How to save user's selection of parameters and nodes in the scene? ==

It is preferable to save all the parameter values and nodes selections that the user made on the user interface into the MRML scene. This allows the user to load a scene and continue from where he left off. These information can be saved in a ''slicer.vtkMRMLScriptedModuleNode()'' node.

For example:

<pre>
parameterNode=slicer.vtkMRMLScriptedModuleNode()

# Save parameter values and node references to parameter node

alpha = 5.0
beta = "abc"
inputNode = slicer.util.getNode("InputNode")

parameterNode.SetParameter("Alpha",str(alpha))
parameterNode.SetParameter("Beta", beta)
parameterNode.SetNodeReferenceID("InputNode", inputNode.GetID())

# Retrieve parameter values and node references from parameter node

alpha = float(parameterNode.GetParameter("Alpha"))
beta = parameterNode.GetParameter("Beta")
inputNode = parameterNode.GetNodeReference("InputNode")
</pre>

Scripted module's logic class have a helper function, ''getParameterNode'', which returns a parameter node that is unique for a specific module. The function creates the parameter node if it has not been created yet. By default, the parameter node is a singleton node, which means that there is only a single instance of the node in the scene. If it is preferable to allow multiple instances of the parameter node, set ''isSingletonParameterNode'' member of the logic object to ''False''.

== How to load a UI file ? ==

See [[Documentation/Nightly/Developers/Tutorials/PythonAndUIFile]]

== How to update progress bar in scripted (Python, or other) CLI modules ==

As detailed in the [https://www.slicer.org/wiki/Documentation/Nightly/Developers/SlicerExecutionModel#Showing_Progress_in_an_Application|Slicer Execution Model documentation], Slicer parses specifically-formatted XML commands printed on stdout, to allow any out-of-process CLI program to report progress back to the main Slicer application (which will causing the progress bar to update). However, it is very important to note that the output must be flushed after each print statement, or else Slicer will not parse the progress sections until the process ends. See the calls to <pre>sys.stdout.flush()</pre> in the example Python CLI shown below:

<pre>
#!/usr/bin/env python-real

if __name__ == '__main__':
import time
import sys

print("""<filter-start><filter-name>TestFilter</filter-name><filter-comment>ibid</filter-comment></filter-start>""")
sys.stdout.flush()

for i in range(0,10):
print("""<filter-progress>{}</filter-progress>""".format(i/10.0))
sys.stdout.flush()
time.sleep(0.5)

print("""<filter-end><filter-name>TestFilter</filter-name><filter-time>10</filter-time></filter-end>""")
sys.stdout.flush()
</pre>

== How to run Python script using a non-Slicer Python environment ==

If you need to run Python scripts using not Slicer's embedded interpreter but using a different environment (Python3, Anaconda, etc.) then you need to run the Python executable using a default startup environment. Starting from Slicer's environment would cause loading of Slicer's Python libraries, which are expected to be binary incompatible with the external environment and therefore would make the external application crash.

Example of running python code using system Python3 in Linux from Slicer:

<pre>
command_line = ["/usr/bin/python3", "-c", "print('hola')"]
from subprocess import check_output
command_result = check_output(command_line, env=slicer.util.startupEnvironment())
print(command_result)
</pre>

This example script just prints 'hola' and exits, but the code can be replaced by more complex instructions or launching of a Python script.

Example of running python code using Anaconda using environment named 'workspace-gpu' on Windows from Slicer:

<pre>
command_line = [r"c:\Users\msliv\Miniconda3\envs\workspace-gpu\python.exe", "-c", "print('hola')"]
from subprocess import check_output
command_result = check_output(command_line, env=slicer.util.startupEnvironment())
print(command_result)
</pre>

Documentation/Nightly/Developers/IO

2018-08-01T13:54:00Z

Arankin: /* Example */ Updating Links

<noinclude>{{documentation/versioncheck}}</noinclude>
=Read=
[[Image:IOOverview.png|600px|center]]
== Main classes ==
* <code>vtkSlicerXYZNode</code> is a [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLStorableNode.h?view=markup storable node] that represents the data from file (e.g. [[http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLModelNode.h?view=markup vtkMRMLModelNode])
* <code>vtkSlicerXYZStorageNode</code> is the file reader. It populates the storable node using the method <code>vtkMRMLXYZStorageNode::ReadData(vtkMRMLStorableNode*,bool)</code>.
* <code>vtkSlicerXYZsLogic</code> is the MRML logic of the <code>XYZ</code> module. It exposes a convenient method <code>AddXYZ(const char* fileName, const char* nodeName=0);</code> that creates a MRML XYZ node (<code>vtkMRMLXYZNode</code>)and its associated storage node (<code>vtkMRMLXYZStorageNode</code>), add them into the scene, and call <code>vtkMRMLXYZStorageNode::ReadData(vtkMRMLStorableNode*,bool);</code> on the storage node to load the file. If the loading fails, it removes the previously created nodes from the scene.
* <code>qSlicerXYZsReaderPlugin</code> is a plugin that is registered by modules into the <code>qSlicerCoreIOManager</code>. It is the interface between Qt and MRML logics. It internally calls <code>vtkSlicerXYZsLogic::AddXYZ</code>().
* <code>qSlicerXYZsOptionsWidget</code> is a widget that sets loading options that gets passed to the logic.
* <code>qSlicerCoreIOManager</code> is the central class where any IO operation must go through. qSlicerIOs can be registered using <code>qSlicerCoreIOManager::registerIO(qSlicerIO*)</code> and nodes can be loaded using <code>qSlicerCoreIOManager::loadNodes(...)</code>. It exposes a set of convenient methods such as "what reader must be used for what file".
* <code>qSlicerDataDialog</code> is the dialog that allows the user to select the files to load.

==How to add support for reading a new file format ?==
# Write method <code>vtkMRMLXYZStorageNode::ReadDataInternal(vtkMRMLStorableNode*, bool temporary);</code>
# Write method <code>vtkMRMLXYZsLogic::AddXYZ(const char* fileName, const char nodeName =0);</code>
# Write class <code>qSlicerXYZsReaderPlugin</code>
# Optional: Write class <code>qSlicerXYZsOptionsWidget</code> if you want the user to optionally specify loading options.
# In <code>qSlicerXYZsModule::setup()</code>, instantiate and register <code>qSlicerXYZsIO</code> to <code>qSlicerCoreIOManager</code>
# Add file format to [Documentation/{{documentation/version}}/SlicerApplication/SupportedDataFormat|SupportedDataFormat] wiki page

== ModifiedSinceRead ==
In order to inform the user what data has been changed since it was last read, a ModifiedSinceRead mechanism is in place to track when was the file last read and when was the data last modified. If a modification happened , the storable node <code>vtkMRMLStorableNode::GetModifiedSinceRead()</code> must return true. If the data in the node is the same as in the file, then <code>vtkMRMLStorableNode::GetModifiedSinceRead()</code> must return false.

<code>vtkMRMLStorageNode</code> keeps track of when a file was last read or written (<code>vtkTimeStamp* vtkMRMLStorageNode::StoredTime</code>). <code>vtkMRMLStorableNode</code> keeps track of when the data was last modified (<code>vtkTimeStamp vtkMRMLStorableNode::StorableModifiedTime</code>). Anytime a <code>vtkMRMLStorableNode</code> property that is saved in file is modified, the <code>StorableModifiedTime</code> time stamp must be modified.

At exit time (<code>qSlicerMainWindow::closeEvent()</code>), <code>vtkMRMLStorableNode::GetModifiedSinceRead()</code> is called to check if the data in the node is the same as in the file or if it has been modified after the file was last read or written. It internally checks <code>vtkTimeStamp* vtkMRMLStorageNode::StoredTime</code> and <code>vtkTimeStamp vtkMRMLStorableNode::StorableModifiedTime</code>. If the data is more recent, then a message dialog is shown to the user telling him that some data is different from file; leaving without saving will lose the changes.

== Example ==
* Models
** [https://github.com/Slicer/Slicer/blob/master/Libs/MRML/Core/vtkMRMLModelNode.h Libs/MRML/Core/vtkMRMLModelNode]
** [https://github.com/Slicer/Slicer/blob/master/Libs/MRML/Core/vtkMRMLModelStorageNode.h Libs/MRML/Core/vtkMRMLModelStorageNode]
** [https://github.com/Slicer/Slicer/blob/master/Modules/Loadable/Models/Logic/vtkSlicerModelsLogic.h Modules/Loadable/Models/Logic/vtkSlicerModelsLogic]
** [https://github.com/Slicer/Slicer/blob/master/Modules/Loadable/Models/qSlicerModelsReader.h Modules/Loadable/Models/qSlicerModelsReader]
** [https://github.com/Slicer/Slicer/blob/master/Modules/Loadable/Models/qSlicerModelsModule.h Modules/Loadable/Models/qSlicerModelsModule]
* VffFileReader
** [https://github.com/SlicerRt/SlicerRT/tree/master/VffFileReader VffFileReader]

== How to load files programmatically ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
[http://slicer.org/doc/html/classqSlicerCoreIOManager.html qSlicerCoreIOManager]* coreIOManager = qSlicerCoreApplication::application()->coreIOManager();
qSlicerIO::IOProperties fileParameters;
fileParameters["fileName"] = "/path/of/file.ext";
vtkMRMLNode* volumeNode = coreIOManager->[http://slicer.org/doc/html/classqSlicerCoreIOManager.html#a36a78dba553b52f395f997fe11aaff23 loadNodesAndGetFirst]("VolumeFile", fileParameters);
Works also with "ModelFile", "TransformFile", "SceneFile"...
| valign="top" |
>>> volumeNode = slicer.util.loadVolume('/path/of/file.ext')
It works also with loadModel, loadTransform, loadScene...
|}
Note that [[#IO_Dialogs|IO dialogs]] should be used as often as possible.

=Write=
The mechanism is similar to '''Read'''. <code>vtkMRMLXYZStorageNode::WriteDataInternal(...)</code> and <code>qSlicerXYZWriter</code> must implemented.

== How to save files programmatically ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
[http://slicer.org/doc/html/classqSlicerCoreIOManager.html qSlicerCoreIOManager]* coreIOManager = qSlicerCoreApplication::application()->coreIOManager();
qSlicerIO::IOProperties fileParameters;
fileParameters["nodeID"] = volumeNode->GetID();
fileParameters["fileName"] = "/path/of/file.ext";
coreIOManager->[http://slicer.org/doc/html/classqSlicerCoreIOManager.html#a1cd29140ded984afdd0f667064d38845 saveNodes]("VolumeFile", fileParameters);
Works also with "ModelFile", "TransformFile", "SceneFile"...
| valign="top" |
>>> slicer.util.saveNode(volumeNode, '/path/of/file.ext')
|}
Note that [[#IO_Dialogs|IO dialogs]] should be used as often as possible.

=IO Dialogs=
* <code>[http://slicer.org/doc/html/classqSlicerFileDialog.html qSlicerFileDialog]</code> is the base class to override a custom dialog.
* <code>[http://slicer.org/doc/html/classqSlicerStandardFileDialog.html qSlicerStandardFileDialog]</code> is a multi-purpose file dialog.
* <code>[http://slicer.org/doc/html/classqSlicerDataDialog.html qSlicerDataDialog.h]</code> is the default dialog to load files.
* <code>[http://slicer.org/doc/html/classqSlicerSaveDataDialog.html qSlicerSaveDataDialog]</code> is the default dialog to save files.

By default, all the IOs must be done through <code>qSlicerDataDialog</code> for reading files and <code>qSlicerSaveDataDialog</code> for writing files. However, due to historical reasons, it is possible to have custom dialogs for each node types.

It can be useful to create your own IO dialog to add custom behavior to the Slicer drag&drop default behavior.
== How to register a dialog ? ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
Register dialogs in qSlicerXYZModule::[http://slicer.org/doc/html/classqSlicerAbstractCoreModule.html#a9ad37e756338e7226f157b4eb54b9bcd setup()]:
[http://slicer.org/doc/html/classqSlicerIOManager.html qSlicerIOManager]* ioManager = qSlicerApplication::application()->ioManager();
ioManager->[http://slicer.org/doc/html/classqSlicerIOManager.html#ae47e9cf27f230335b865bce84a56e156 registerDialog](new qSlicerXYZDialog(this));
ioManager->[http://slicer.org/doc/html/classqSlicerIOManager.html#ae47e9cf27f230335b865bce84a56e156 registerDialog](new qSlicerSaveXYZDialog(this));
| valign="top" |
Declare an XYZFileDialog in your XYZ.py module file. It will be automatically registered. For example:
class XYZFileDialog:
def __init__(self, parent):
self.parent = parent
parent.fileType = 'XYZFile'
parent.description = 'XYZ'
parent.action = slicer.qSlicerFileDialog.Read
def isMimeDataAccepted(self):
accept = self.parent.mimeData().hasFormat("text/uri-list")
self.parent.acceptMimeData(accept)
def dropEvent(self):
self.parent.dropEvent().accept()
def execDialog(self):
print 'exec'
|}

== How to open a registered a dialog ? ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
[http://slicer.org/doc/html/classqSlicerIOManager.html qSlicerIOManager]* ioManager = qSlicerApplication::application()->ioManager();
ioManager->openDialog("VolumeFile", qSlicerFileDialog::Read, qSlicerIO::IOProperties());
| valign="top" |
io = slicer.app.ioManager()
params = {}
io.openDialog("VolumeFile", slicer.qSlicerFileDialog.Read, params)
And the special case for standard data file types:
slicer.util.openAddVolumeDialog()
|}

== How to order the list of drag&drop dialogs ?==
By controlling the order of module initialization. This is done by adding module dependencies. Make your module dependent of of the "Data" would make it initialize after the Data module that registers the "Any Data" dialogs:
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
QStringList qSlicerXYZModule::dependencies() const
{
QStringList moduleDependencies;
moduleDependencies << "Data";
return moduleDependencies;
}
| valign="top" |
def __init__(self, parent):
...
parent.dependencies = ["Data"] class XYZFileDialog:
...
|}

Documentation/Nightly/Developers/IO

2018-08-01T13:46:26Z

Arankin: /* How to add support for reading a new file format ? */

<noinclude>{{documentation/versioncheck}}</noinclude>
=Read=
[[Image:IOOverview.png|600px|center]]
== Main classes ==
* <code>vtkSlicerXYZNode</code> is a [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLStorableNode.h?view=markup storable node] that represents the data from file (e.g. [[http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLModelNode.h?view=markup vtkMRMLModelNode])
* <code>vtkSlicerXYZStorageNode</code> is the file reader. It populates the storable node using the method <code>vtkMRMLXYZStorageNode::ReadData(vtkMRMLStorableNode*,bool)</code>.
* <code>vtkSlicerXYZsLogic</code> is the MRML logic of the <code>XYZ</code> module. It exposes a convenient method <code>AddXYZ(const char* fileName, const char* nodeName=0);</code> that creates a MRML XYZ node (<code>vtkMRMLXYZNode</code>)and its associated storage node (<code>vtkMRMLXYZStorageNode</code>), add them into the scene, and call <code>vtkMRMLXYZStorageNode::ReadData(vtkMRMLStorableNode*,bool);</code> on the storage node to load the file. If the loading fails, it removes the previously created nodes from the scene.
* <code>qSlicerXYZsReaderPlugin</code> is a plugin that is registered by modules into the <code>qSlicerCoreIOManager</code>. It is the interface between Qt and MRML logics. It internally calls <code>vtkSlicerXYZsLogic::AddXYZ</code>().
* <code>qSlicerXYZsOptionsWidget</code> is a widget that sets loading options that gets passed to the logic.
* <code>qSlicerCoreIOManager</code> is the central class where any IO operation must go through. qSlicerIOs can be registered using <code>qSlicerCoreIOManager::registerIO(qSlicerIO*)</code> and nodes can be loaded using <code>qSlicerCoreIOManager::loadNodes(...)</code>. It exposes a set of convenient methods such as "what reader must be used for what file".
* <code>qSlicerDataDialog</code> is the dialog that allows the user to select the files to load.

==How to add support for reading a new file format ?==
# Write method <code>vtkMRMLXYZStorageNode::ReadDataInternal(vtkMRMLStorableNode*, bool temporary);</code>
# Write method <code>vtkMRMLXYZsLogic::AddXYZ(const char* fileName, const char nodeName =0);</code>
# Write class <code>qSlicerXYZsReaderPlugin</code>
# Optional: Write class <code>qSlicerXYZsOptionsWidget</code> if you want the user to optionally specify loading options.
# In <code>qSlicerXYZsModule::setup()</code>, instantiate and register <code>qSlicerXYZsIO</code> to <code>qSlicerCoreIOManager</code>
# Add file format to [Documentation/{{documentation/version}}/SlicerApplication/SupportedDataFormat|SupportedDataFormat] wiki page

== ModifiedSinceRead ==
In order to inform the user what data has been changed since it was last read, a ModifiedSinceRead mechanism is in place to track when was the file last read and when was the data last modified. If a modification happened , the storable node <code>vtkMRMLStorableNode::GetModifiedSinceRead()</code> must return true. If the data in the node is the same as in the file, then <code>vtkMRMLStorableNode::GetModifiedSinceRead()</code> must return false.

<code>vtkMRMLStorageNode</code> keeps track of when a file was last read or written (<code>vtkTimeStamp* vtkMRMLStorageNode::StoredTime</code>). <code>vtkMRMLStorableNode</code> keeps track of when the data was last modified (<code>vtkTimeStamp vtkMRMLStorableNode::StorableModifiedTime</code>). Anytime a <code>vtkMRMLStorableNode</code> property that is saved in file is modified, the <code>StorableModifiedTime</code> time stamp must be modified.

At exit time (<code>qSlicerMainWindow::closeEvent()</code>), <code>vtkMRMLStorableNode::GetModifiedSinceRead()</code> is called to check if the data in the node is the same as in the file or if it has been modified after the file was last read or written. It internally checks <code>vtkTimeStamp* vtkMRMLStorageNode::StoredTime</code> and <code>vtkTimeStamp vtkMRMLStorableNode::StorableModifiedTime</code>. If the data is more recent, then a message dialog is shown to the user telling him that some data is different from file; leaving without saving will lose the changes.

== Example ==
* Models
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLModelNode.h?view=markup Libs/MRML/Core/vtkMRMLModelNode]
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLModelStorageNode.h?view=markup Libs/MRML/Core/vtkMRMLModelStorageNode]
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Modules/Loadable/Models/Logic/vtkSlicerModelsLogic.h?view=markup Modules/Loadable/Models/Logic/vtkSlicerModelsLogic]
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Modules/Loadable/Models/qSlicerModelsIO.h?view=markup Modules/Loadable/Models/qSlicerModelsIO]
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Modules/Loadable/Models/qSlicerModelsModule.h?view=markup Modules/Loadable/Models/qSlicerModelsModule]

== How to load files programmatically ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
[http://slicer.org/doc/html/classqSlicerCoreIOManager.html qSlicerCoreIOManager]* coreIOManager = qSlicerCoreApplication::application()->coreIOManager();
qSlicerIO::IOProperties fileParameters;
fileParameters["fileName"] = "/path/of/file.ext";
vtkMRMLNode* volumeNode = coreIOManager->[http://slicer.org/doc/html/classqSlicerCoreIOManager.html#a36a78dba553b52f395f997fe11aaff23 loadNodesAndGetFirst]("VolumeFile", fileParameters);
Works also with "ModelFile", "TransformFile", "SceneFile"...
| valign="top" |
>>> volumeNode = slicer.util.loadVolume('/path/of/file.ext')
It works also with loadModel, loadTransform, loadScene...
|}
Note that [[#IO_Dialogs|IO dialogs]] should be used as often as possible.

=Write=
The mechanism is similar to '''Read'''. <code>vtkMRMLXYZStorageNode::WriteDataInternal(...)</code> and <code>qSlicerXYZWriter</code> must implemented.

== How to save files programmatically ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
[http://slicer.org/doc/html/classqSlicerCoreIOManager.html qSlicerCoreIOManager]* coreIOManager = qSlicerCoreApplication::application()->coreIOManager();
qSlicerIO::IOProperties fileParameters;
fileParameters["nodeID"] = volumeNode->GetID();
fileParameters["fileName"] = "/path/of/file.ext";
coreIOManager->[http://slicer.org/doc/html/classqSlicerCoreIOManager.html#a1cd29140ded984afdd0f667064d38845 saveNodes]("VolumeFile", fileParameters);
Works also with "ModelFile", "TransformFile", "SceneFile"...
| valign="top" |
>>> slicer.util.saveNode(volumeNode, '/path/of/file.ext')
|}
Note that [[#IO_Dialogs|IO dialogs]] should be used as often as possible.

=IO Dialogs=
* <code>[http://slicer.org/doc/html/classqSlicerFileDialog.html qSlicerFileDialog]</code> is the base class to override a custom dialog.
* <code>[http://slicer.org/doc/html/classqSlicerStandardFileDialog.html qSlicerStandardFileDialog]</code> is a multi-purpose file dialog.
* <code>[http://slicer.org/doc/html/classqSlicerDataDialog.html qSlicerDataDialog.h]</code> is the default dialog to load files.
* <code>[http://slicer.org/doc/html/classqSlicerSaveDataDialog.html qSlicerSaveDataDialog]</code> is the default dialog to save files.

By default, all the IOs must be done through <code>qSlicerDataDialog</code> for reading files and <code>qSlicerSaveDataDialog</code> for writing files. However, due to historical reasons, it is possible to have custom dialogs for each node types.

It can be useful to create your own IO dialog to add custom behavior to the Slicer drag&drop default behavior.
== How to register a dialog ? ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
Register dialogs in qSlicerXYZModule::[http://slicer.org/doc/html/classqSlicerAbstractCoreModule.html#a9ad37e756338e7226f157b4eb54b9bcd setup()]:
[http://slicer.org/doc/html/classqSlicerIOManager.html qSlicerIOManager]* ioManager = qSlicerApplication::application()->ioManager();
ioManager->[http://slicer.org/doc/html/classqSlicerIOManager.html#ae47e9cf27f230335b865bce84a56e156 registerDialog](new qSlicerXYZDialog(this));
ioManager->[http://slicer.org/doc/html/classqSlicerIOManager.html#ae47e9cf27f230335b865bce84a56e156 registerDialog](new qSlicerSaveXYZDialog(this));
| valign="top" |
Declare an XYZFileDialog in your XYZ.py module file. It will be automatically registered. For example:
class XYZFileDialog:
def __init__(self, parent):
self.parent = parent
parent.fileType = 'XYZFile'
parent.description = 'XYZ'
parent.action = slicer.qSlicerFileDialog.Read
def isMimeDataAccepted(self):
accept = self.parent.mimeData().hasFormat("text/uri-list")
self.parent.acceptMimeData(accept)
def dropEvent(self):
self.parent.dropEvent().accept()
def execDialog(self):
print 'exec'
|}

== How to open a registered a dialog ? ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
[http://slicer.org/doc/html/classqSlicerIOManager.html qSlicerIOManager]* ioManager = qSlicerApplication::application()->ioManager();
ioManager->openDialog("VolumeFile", qSlicerFileDialog::Read, qSlicerIO::IOProperties());
| valign="top" |
io = slicer.app.ioManager()
params = {}
io.openDialog("VolumeFile", slicer.qSlicerFileDialog.Read, params)
And the special case for standard data file types:
slicer.util.openAddVolumeDialog()
|}

== How to order the list of drag&drop dialogs ?==
By controlling the order of module initialization. This is done by adding module dependencies. Make your module dependent of of the "Data" would make it initialize after the Data module that registers the "Any Data" dialogs:
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
QStringList qSlicerXYZModule::dependencies() const
{
QStringList moduleDependencies;
moduleDependencies << "Data";
return moduleDependencies;
}
| valign="top" |
def __init__(self, parent):
...
parent.dependencies = ["Data"] class XYZFileDialog:
...
|}

Documentation/Nightly/Developers/IO

2018-08-01T13:46:06Z

Arankin: /* Main classes */ Updating class names to match current naming scheme

<noinclude>{{documentation/versioncheck}}</noinclude>
=Read=
[[Image:IOOverview.png|600px|center]]
== Main classes ==
* <code>vtkSlicerXYZNode</code> is a [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLStorableNode.h?view=markup storable node] that represents the data from file (e.g. [[http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLModelNode.h?view=markup vtkMRMLModelNode])
* <code>vtkSlicerXYZStorageNode</code> is the file reader. It populates the storable node using the method <code>vtkMRMLXYZStorageNode::ReadData(vtkMRMLStorableNode*,bool)</code>.
* <code>vtkSlicerXYZsLogic</code> is the MRML logic of the <code>XYZ</code> module. It exposes a convenient method <code>AddXYZ(const char* fileName, const char* nodeName=0);</code> that creates a MRML XYZ node (<code>vtkMRMLXYZNode</code>)and its associated storage node (<code>vtkMRMLXYZStorageNode</code>), add them into the scene, and call <code>vtkMRMLXYZStorageNode::ReadData(vtkMRMLStorableNode*,bool);</code> on the storage node to load the file. If the loading fails, it removes the previously created nodes from the scene.
* <code>qSlicerXYZsReaderPlugin</code> is a plugin that is registered by modules into the <code>qSlicerCoreIOManager</code>. It is the interface between Qt and MRML logics. It internally calls <code>vtkSlicerXYZsLogic::AddXYZ</code>().
* <code>qSlicerXYZsOptionsWidget</code> is a widget that sets loading options that gets passed to the logic.
* <code>qSlicerCoreIOManager</code> is the central class where any IO operation must go through. qSlicerIOs can be registered using <code>qSlicerCoreIOManager::registerIO(qSlicerIO*)</code> and nodes can be loaded using <code>qSlicerCoreIOManager::loadNodes(...)</code>. It exposes a set of convenient methods such as "what reader must be used for what file".
* <code>qSlicerDataDialog</code> is the dialog that allows the user to select the files to load.

==How to add support for reading a new file format ?==
# Write method <code>vtkMRMLXYZStorageNode::ReadDataInternal(vtkMRMLStorableNode*, bool temporary);</code>
# Write method <code>vtkMRMLXYZsLogic::AddXYZ(const char* fileName, const char nodeName =0);</code>
# Write class <code>qSlicerXYZsIO</code>
# Optional: Write class <code>qSlicerXYZsIOOptionsWidget</code> if you want the user to optionally specify loading options.
# In <code>qSlicerXYZsModule::setup()</code>, instantiate and register <code>qSlicerXYZsIO</code> to <code>qSlicerCoreIOManager</code>
# Add file format to [Documentation/{{documentation/version}}/SlicerApplication/SupportedDataFormat|SupportedDataFormat] wiki page

== ModifiedSinceRead ==
In order to inform the user what data has been changed since it was last read, a ModifiedSinceRead mechanism is in place to track when was the file last read and when was the data last modified. If a modification happened , the storable node <code>vtkMRMLStorableNode::GetModifiedSinceRead()</code> must return true. If the data in the node is the same as in the file, then <code>vtkMRMLStorableNode::GetModifiedSinceRead()</code> must return false.

<code>vtkMRMLStorageNode</code> keeps track of when a file was last read or written (<code>vtkTimeStamp* vtkMRMLStorageNode::StoredTime</code>). <code>vtkMRMLStorableNode</code> keeps track of when the data was last modified (<code>vtkTimeStamp vtkMRMLStorableNode::StorableModifiedTime</code>). Anytime a <code>vtkMRMLStorableNode</code> property that is saved in file is modified, the <code>StorableModifiedTime</code> time stamp must be modified.

At exit time (<code>qSlicerMainWindow::closeEvent()</code>), <code>vtkMRMLStorableNode::GetModifiedSinceRead()</code> is called to check if the data in the node is the same as in the file or if it has been modified after the file was last read or written. It internally checks <code>vtkTimeStamp* vtkMRMLStorageNode::StoredTime</code> and <code>vtkTimeStamp vtkMRMLStorableNode::StorableModifiedTime</code>. If the data is more recent, then a message dialog is shown to the user telling him that some data is different from file; leaving without saving will lose the changes.

== Example ==
* Models
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLModelNode.h?view=markup Libs/MRML/Core/vtkMRMLModelNode]
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Libs/MRML/Core/vtkMRMLModelStorageNode.h?view=markup Libs/MRML/Core/vtkMRMLModelStorageNode]
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Modules/Loadable/Models/Logic/vtkSlicerModelsLogic.h?view=markup Modules/Loadable/Models/Logic/vtkSlicerModelsLogic]
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Modules/Loadable/Models/qSlicerModelsIO.h?view=markup Modules/Loadable/Models/qSlicerModelsIO]
** [http://viewvc.slicer.org/viewvc.cgi/Slicer4/trunk/Modules/Loadable/Models/qSlicerModelsModule.h?view=markup Modules/Loadable/Models/qSlicerModelsModule]

== How to load files programmatically ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
[http://slicer.org/doc/html/classqSlicerCoreIOManager.html qSlicerCoreIOManager]* coreIOManager = qSlicerCoreApplication::application()->coreIOManager();
qSlicerIO::IOProperties fileParameters;
fileParameters["fileName"] = "/path/of/file.ext";
vtkMRMLNode* volumeNode = coreIOManager->[http://slicer.org/doc/html/classqSlicerCoreIOManager.html#a36a78dba553b52f395f997fe11aaff23 loadNodesAndGetFirst]("VolumeFile", fileParameters);
Works also with "ModelFile", "TransformFile", "SceneFile"...
| valign="top" |
>>> volumeNode = slicer.util.loadVolume('/path/of/file.ext')
It works also with loadModel, loadTransform, loadScene...
|}
Note that [[#IO_Dialogs|IO dialogs]] should be used as often as possible.

=Write=
The mechanism is similar to '''Read'''. <code>vtkMRMLXYZStorageNode::WriteDataInternal(...)</code> and <code>qSlicerXYZWriter</code> must implemented.

== How to save files programmatically ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
[http://slicer.org/doc/html/classqSlicerCoreIOManager.html qSlicerCoreIOManager]* coreIOManager = qSlicerCoreApplication::application()->coreIOManager();
qSlicerIO::IOProperties fileParameters;
fileParameters["nodeID"] = volumeNode->GetID();
fileParameters["fileName"] = "/path/of/file.ext";
coreIOManager->[http://slicer.org/doc/html/classqSlicerCoreIOManager.html#a1cd29140ded984afdd0f667064d38845 saveNodes]("VolumeFile", fileParameters);
Works also with "ModelFile", "TransformFile", "SceneFile"...
| valign="top" |
>>> slicer.util.saveNode(volumeNode, '/path/of/file.ext')
|}
Note that [[#IO_Dialogs|IO dialogs]] should be used as often as possible.

=IO Dialogs=
* <code>[http://slicer.org/doc/html/classqSlicerFileDialog.html qSlicerFileDialog]</code> is the base class to override a custom dialog.
* <code>[http://slicer.org/doc/html/classqSlicerStandardFileDialog.html qSlicerStandardFileDialog]</code> is a multi-purpose file dialog.
* <code>[http://slicer.org/doc/html/classqSlicerDataDialog.html qSlicerDataDialog.h]</code> is the default dialog to load files.
* <code>[http://slicer.org/doc/html/classqSlicerSaveDataDialog.html qSlicerSaveDataDialog]</code> is the default dialog to save files.

By default, all the IOs must be done through <code>qSlicerDataDialog</code> for reading files and <code>qSlicerSaveDataDialog</code> for writing files. However, due to historical reasons, it is possible to have custom dialogs for each node types.

It can be useful to create your own IO dialog to add custom behavior to the Slicer drag&drop default behavior.
== How to register a dialog ? ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
Register dialogs in qSlicerXYZModule::[http://slicer.org/doc/html/classqSlicerAbstractCoreModule.html#a9ad37e756338e7226f157b4eb54b9bcd setup()]:
[http://slicer.org/doc/html/classqSlicerIOManager.html qSlicerIOManager]* ioManager = qSlicerApplication::application()->ioManager();
ioManager->[http://slicer.org/doc/html/classqSlicerIOManager.html#ae47e9cf27f230335b865bce84a56e156 registerDialog](new qSlicerXYZDialog(this));
ioManager->[http://slicer.org/doc/html/classqSlicerIOManager.html#ae47e9cf27f230335b865bce84a56e156 registerDialog](new qSlicerSaveXYZDialog(this));
| valign="top" |
Declare an XYZFileDialog in your XYZ.py module file. It will be automatically registered. For example:
class XYZFileDialog:
def __init__(self, parent):
self.parent = parent
parent.fileType = 'XYZFile'
parent.description = 'XYZ'
parent.action = slicer.qSlicerFileDialog.Read
def isMimeDataAccepted(self):
accept = self.parent.mimeData().hasFormat("text/uri-list")
self.parent.acceptMimeData(accept)
def dropEvent(self):
self.parent.dropEvent().accept()
def execDialog(self):
print 'exec'
|}

== How to open a registered a dialog ? ==
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
[http://slicer.org/doc/html/classqSlicerIOManager.html qSlicerIOManager]* ioManager = qSlicerApplication::application()->ioManager();
ioManager->openDialog("VolumeFile", qSlicerFileDialog::Read, qSlicerIO::IOProperties());
| valign="top" |
io = slicer.app.ioManager()
params = {}
io.openDialog("VolumeFile", slicer.qSlicerFileDialog.Read, params)
And the special case for standard data file types:
slicer.util.openAddVolumeDialog()
|}

== How to order the list of drag&drop dialogs ?==
By controlling the order of module initialization. This is done by adding module dependencies. Make your module dependent of of the "Data" would make it initialize after the Data module that registers the "Any Data" dialogs:
{|width = "100%"
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|C++
! style="border-bottom: 1px solid darkgrey;font-size: 75%;"|Python
|-
| valign="top" |
QStringList qSlicerXYZModule::dependencies() const
{
QStringList moduleDependencies;
moduleDependencies << "Data";
return moduleDependencies;
}
| valign="top" |
def __init__(self, parent):
...
parent.dependencies = ["Data"] class XYZFileDialog:
...
|}

Documentation/Nightly/ScriptRepository

2018-03-19T20:08:57Z

Arankin: Adding slice viewer examples

<noinclude>{{documentation/versioncheck}}</noinclude>
__TOC__

=Community-contributed modules=

The examples in this section are [[Documentation/{{documentation/version}}/Developers/Modules#Scripted_Modules| Scripted Modules]] that provide a user interface in the module panel along with specialized implementation logic.

Usage: save the .py file to a directory, add the directory to the additional module paths in the Slicer application settings (choose in the menu: Edit / Application settings, click Modules, click >> next to Additional module paths, click Add, and choose the .py file's location).

==Filters==
* [https://raw.github.com/pieper/VolumeMasker/master/VolumeMasker.py VolumeMasker.py]: Update a target volume with the results of setting all input volume voxels to 0 except for those that correspond to a selected label value in an input label map (Used for example in the volume rendering in [https://www.youtube.com/watch?v=dfu2gugHLHs this video).

==DICOM==
* [https://gist.github.com/pieper/6186477 dicom header browser] to easily scroll through dicom files using dcmdump.
* [https://github.com/SlicerRt/SlicerRT/tree/master/BatchProcessing SlicerRT batch processing] to batch convert RT structure sets to labelmap NRRD files.

==Informatics==
* [https://gist.github.com/lassoan/bf0954d93cacc8cbe27cd4a3ad503f2f MarkupsInfo.py]: Compute the total length between all the points of a markup list.
* [https://gist.github.com/lassoan/0e7acfbec36e4577f8b7b0e07ad53a2a LineProfile.py]: Compute intensity profile in a volume along a line.

=Community-contributed examples=

Usage: Copy-paste the shown code lines or linked .py file contents into Python console in Slicer. Or save them to a file and run them using execfile.

==Capture==
* Capture the full Slicer screen and save it into a file
img = qt.QPixmap.grabWidget(slicer.util.mainWindow()).toImage()
img.save('c:/tmp/test.png')
* Capture all the views save it into a file:
<pre>
import ScreenCapture
cap = ScreenCapture.ScreenCaptureLogic()
cap.showViewControllers(False)
cap.captureImageFromView(None,'c:/tmp/test.png')
cap.showViewControllers(True)
</pre>
* Capture a single view:
<pre>
viewNodeID = 'vtkMRMLViewNode1'
import ScreenCapture
cap = ScreenCapture.ScreenCaptureLogic()
view = cap.viewFromNode(slicer.mrmlScene.GetNodeByID(viewNodeID))
cap.captureImageFromView(view,'c:/tmp/test.png')
</pre>
Common values for viewNodeID: vtkMRMLSliceNodeRed, vtkMRMLSliceNodeYellow, vtkMRMLSliceNodeGreen, vtkMRMLViewNode1, vtkMRMLViewNode2.
The ScreenCapture module can also create video animations of rotating views, slice sweeps, etc.
* Capture 3D view into PNG file with transparent background
<pre>
renderWindow = slicer.app.layoutManager().threeDWidget(0).threeDView().renderWindow()
renderWindow.SetAlphaBitPlanes(1)
wti = vtk.vtkWindowToImageFilter()
wti.SetInputBufferTypeToRGBA()
wti.SetInput(renderWindow)
writer = vtk.vtkPNGWriter()
writer.SetFileName("c:/tmp/screenshot.png")
writer.SetInputConnection(wti.GetOutputPort())
writer.Write()
</pre>

==Launching Slicer==
* How to open an .mrb file with Slicer at the command line?
Slicer.exe --python-code "slicer.util.loadScene( 'f:/2013-08-23-Scene.mrb' )"
* How to run a script in the Slicer environment in batch mode (without showing any graphical user interface)?
Slicer.exe --python-code "doSomething; doSomethingElse; etc." --testing --no-splash --no-main-window

==Load volume from file==
When loading a volume from file, it is recommended to set returnNode=True to retrieve the loaded volume node.
<pre>
[success, loadedVolumeNode] = slicer.util.loadVolume('c:/Users/abc/Documents/MRHead.nrrd', returnNode=True)
</pre>

* Get a MRML node in the scene based on the node name and call methods of that object. For the MRHead sample data:
vol=slicer.util.getNode('MR*')
vol.GetImageData().GetDimensions()

==DICOM==
=== How to access tags of DICOM images imported into Slicer? For example, to print the first patient's first study's first series' "0020,0032" field:===
db=slicer.dicomDatabase
patientList=db.patients()
studyList=db.studiesForPatient(patientList[0])
seriesList=db.seriesForStudy(studyList[0])
fileList=db.filesForSeries(seriesList[0])
print db.fileValue(fileList[0],'0020,0032')

=== How to access tag of a volume loaded from DICOM? For example, get the patient position stored in a volume:===
volumeName='2: ENT IMRT'
n=slicer.util.getNode(volumeName)
instUids=n.GetAttribute('DICOM.instanceUIDs').split()
filename=slicer.dicomDatabase.fileForInstance(instUids[0])
print slicer.dicomDatabase.fileValue(filename,'0018,5100')

=== How to access tag of an item in the Subject Hierachy tree? For example, get the content time tag of a structure set:===
rtStructName = '3: RTSTRUCT: PROS'
rtStructNode = slicer.util.getNode(rtStructName)
shNode = slicer.vtkMRMLSubjectHierarchyNode.GetSubjectHierarchyNode(slicer.mrmlScene)
rtStructShItemID = shNode.GetItemByDataNode(rtStructNode)
ctSliceInstanceUids = shNode.GetItemAttribute(rtStructShItemID, 'DICOM.ReferencedInstanceUIDs').split()
filename = slicer.dicomDatabase.fileForInstance(ctSliceInstanceUids[0])
print slicer.dicomDatabase.fileValue(filename,'0008,0033')

=== How to get path and filename of a loaded DICOM volume?===
def pathFromNode(node):
storageNode=node.GetStorageNode()
if storageNode is not None: # loaded via drag-drop
filepath=storageNode.GetFullNameFromFileName()
else: # loaded via DICOM browser
instanceUIDs=node.GetAttribute('DICOM.instanceUIDs').split()
filepath=slicer.dicomDatabase.fileForInstance(instUids[0])
return filepath

# example:
node=slicer.util.getNode('volume1')
path=self.pathFromNode(node)
print("DICOM path=%s" % path)

=== How can I convert DICOM to NRRD on the command line?===

/Applications/Slicer-4.6.2.app/Contents/MacOS/Slicer --no-main-window --python-code "node=slicer.util.loadVolume('/tmp/series/im0.dcm', returnNode=True)[1]; slicer.util.saveNode(node, '/tmp/output.nrrd'); exit()"

The same can be done on windows by using the top level Slicer.exe. Be sure to use forward slashes in the pathnames within quotes on the command line.

==Toolbar functions==
* How to turn on slice intersections in the crosshair menu on the toolbar:
viewNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLSliceCompositeNode')
viewNodes.UnRegister(slicer.mrmlScene)
viewNodes.InitTraversal()
viewNode = viewNodes.GetNextItemAsObject()
while viewNode:
viewNode.SetSliceIntersectionVisibility(1)
viewNode = viewNodes.GetNextItemAsObject()

How to find similar functions? For this one I searched for "slice intersections" text in the whole slicer source code, found that the function is implemented in Base\QTGUI\qSlicerViewersToolBar.cxx, then translated the qSlicerViewersToolBarPrivate::setSliceIntersectionVisible(bool visible) method to Python.

==Manipulating objects in the slice viewer==
* How to define/edit a circular region of interest in a slice viewer?

Drop two markup points on a slice view and copy-paste the code below into the Python console. After this, as you move the markups you’ll see a circle following the markups.

<pre>
# Update the sphere from the fiducial points
def UpdateSphere(param1, param2):
import math
centerPointCoord = [0.0, 0.0, 0.0]
markups.GetNthFiducialPosition(0,centerPointCoord)
circumferencePointCoord = [0.0, 0.0, 0.0]
markups.GetNthFiducialPosition(1,circumferencePointCoord)
sphere.SetCenter(centerPointCoord)
radius=math.sqrt((centerPointCoord[0]-circumferencePointCoord[0])**2+(centerPointCoord[1]-circumferencePointCoord[1])**2+(centerPointCoord[2]-circumferencePointCoord[2])**2)
sphere.SetRadius(radius)
sphere.SetPhiResolution(30)
sphere.SetThetaResolution(30)
sphere.Update()

# Get markup node from scene
markups=slicer.util.getNode('F')
sphere = vtk.vtkSphereSource()
UpdateSphere(0,0)

# Create model node and add to scene
modelsLogic = slicer.modules.models.logic()
model = modelsLogic.AddModel(sphere.GetOutput())
model.GetDisplayNode().SetSliceIntersectionVisibility(True)
model.GetDisplayNode().SetSliceIntersectionThickness(3)
model.GetDisplayNode().SetColor(1,1,0)

# Call UpdateSphere whenever the fiducials are changed
markups.AddObserver("ModifiedEvent", UpdateSphere, 2)
</pre>

== Switching to markup fiducial placement mode ==

To activate a fiducial placement mode, both interaction mode has to be set and a fiducial node has to be selected:

<pre>
interactionNode = slicer.app.applicationLogic().GetInteractionNode()
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActivePlaceNodeClassName("vtkMRMLMarkupsFiducialNode")
fiducialNode = slicer.vtkMRMLMarkupsFiducialNode()
slicer.mrmlScene.AddNode(fiducialNode)
fiducialNode.CreateDefaultDisplayNodes()
selectionNode.SetActivePlaceNodeID(fiducialNode.GetID())
interactionNode.SetCurrentInteractionMode(interactionNode.Place)
</pre>

== Show a context menu when a markup point is clicked in a slice or 3D view ==

<pre>

# Example actions to perform

def action1():
print('Action1 on markup '+str(slicer.clickedMarkupIndex))

def action2():
print('Action2 on markup '+str(slicer.clickedMarkupIndex))

def action3():
print('Action3 on markup '+str(slicer.clickedMarkupIndex))

# Clicked markup index is saved here to let the action
# know which markup needs to be manipulated.
slicer.clickedMarkupIndex = -1

# Create a simple menu

menu = qt.QMenu()
a1 = qt.QAction("Test", slicer.util.mainWindow())
a1.connect('triggered()', action1)
menu.addAction(a1)
a2 = qt.QAction("Action", slicer.util.mainWindow())
a2.connect('triggered()', action1)
menu.addAction(a2)
a3 = qt.QAction("Here", slicer.util.mainWindow())
a3.connect('triggered()', action1)
menu.addAction(a3)

# Add observer to a markup fiducial list

@vtk.calldata_type(vtk.VTK_INT)
def markupClickedCallback(caller, eventId, callData):
slicer.clickedMarkupIndex = callData
print('Open menu on markup '+str(slicer.clickedMarkupIndex))
menu.move(qt.QCursor.pos())
menu.show()

markupsNode = getNode('F')
observerTag = markupsNode.AddObserver(slicer.vtkMRMLMarkupsNode.PointClickedEvent, markupClickedCallback)

</pre>

== Add a texture mapped plane to the scene as a model ==
Note that model textures are not exposed in the GUI and are not saved in the scene
<pre>
# use dummy image data here
e = vtk.vtkImageEllipsoidSource()

scene = slicer.mrmlScene

# Create model node
model = slicer.vtkMRMLModelNode()
model.SetScene(scene)
model.SetName(scene.GenerateUniqueName("2DImageModel"))

planeSource = vtk.vtkPlaneSource()
model.SetAndObservePolyData(planeSource.GetOutput())

# Create display node
modelDisplay = slicer.vtkMRMLModelDisplayNode()
modelDisplay.SetColor(1,1,0) # yellow
modelDisplay.SetBackfaceCulling(0)
modelDisplay.SetScene(scene)
scene.AddNode(modelDisplay)
model.SetAndObserveDisplayNodeID(modelDisplay.GetID())

# Add to scene
modelDisplay.SetAndObserveTextureImageData(e.GetOutput())
scene.AddNode(model)

transform = slicer.vtkMRMLLinearTransformNode()
scene.AddNode(transform)
model.SetAndObserveTransformNodeID(transform.GetID())

vTransform = vtk.vtkTransform()
vTransform.Scale(50,50,50)
vTransform.RotateX(30)
transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix())
</pre>

== Export entire scene as VRML ==

Save all surface meshes displayed in the scene (models, markups, etc). Solid colors and coloring by scalar is preserved. Textures are not supported.

<pre>
exporter = vtk.vtkVRMLExporter()
exporter.SetRenderWindow(slicer.app.layoutManager().threeDWidget(0).threeDView().renderWindow())
exporter.SetFileName('C:/tmp/something.wrl')
exporter.Write()
</pre>

== Export model to Blender, including color by scalar ==

<pre>
modelNode = getNode("Model")
plyFilePath = "c:/tmp/model.ply"

modelDisplayNode = modelNode.GetDisplayNode()
triangles = vtk.vtkTriangleFilter()
triangles.SetInputConnection(modelDisplayNode.GetOutputPolyDataConnection())

plyWriter = vtk.vtkPLYWriter()
plyWriter.SetInputConnection(triangles.GetOutputPort())
lut = vtk.vtkLookupTable()
lut.DeepCopy(modelDisplayNode.GetColorNode().GetLookupTable())
lut.SetRange(modelDisplayNode.GetScalarRange())
plyWriter.SetLookupTable(lut)
plyWriter.SetArrayName(modelDisplayNode.GetActiveScalarName())

plyWriter.SetFileName(plyFilePath)
plyWriter.Write()
</pre>

== Export a fiber tracts to Blender, including color ==

<pre>
lineDisplayNode = getNode("*LineDisplay*")
plyFilePath = "/tmp/fibers.ply"

tuber = vtk.vtkTubeFilter()
tuber.SetInputData(lineDisplayNode.GetOutputPolyData())
tuber.Update()
tubes = tuber.GetOutputDataObject(0)
scalars = tubes.GetPointData().GetArray(0)
scalars.SetName("scalars")

triangles = vtk.vtkTriangleFilter()
triangles.SetInputData(tubes)
triangles.Update()

colorNode = lineDisplayNode.GetColorNode()
lookupTable = vtk.vtkLookupTable()
lookupTable.DeepCopy(colorNode.GetLookupTable())
lookupTable.SetTableRange(0,1)

plyWriter = vtk.vtkPLYWriter()
plyWriter.SetInputData(triangles.GetOutput())
plyWriter.SetLookupTable(lookupTable)
plyWriter.SetArrayName("scalars")

plyWriter.SetFileName(plyFilePath)
plyWriter.Write()
</pre>

== Clone a volume ==
This example shows how to clone the MRHead sample volume, including its pixel data and display settings.
<pre>
sourceVolumeNode = slicer.util.getNode('MRHead')
volumesLogic = slicer.modules.volumes.logic()
clonedVolumeNode = volumesLogic.CloneVolume(slicer.mrmlScene, sourceVolumeNode, 'Cloned volume')
</pre>

== Create a new volume ==
This example shows how to create a new empty volume.
<pre>
nodeName = "MyNewVolume"
imageSize = [512, 512, 512]
voxelType=vtk.VTK_UNSIGNED_CHAR
imageOrigin = [0.0, 0.0, 0.0]
imageSpacing = [1.0, 1.0, 1.0]
imageDirections = [[1,0,0], [0,1,0], [0,0,1]]
fillVoxelValue = 0

# Create an empty image volume, filled with fillVoxelValue
imageData = vtk.vtkImageData()
imageData.SetDimensions(imageSize)
imageData.AllocateScalars(voxelType, 1)
thresholder = vtk.vtkImageThreshold()
thresholder.SetInputData(imageData)
thresholder.SetInValue(fillVoxelValue)
thresholder.SetOutValue(fillVoxelValue)
thresholder.Update()
# Create volume node
volumeNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLScalarVolumeNode", nodeName)
volumeNode.SetOrigin(imageOrigin)
volumeNode.SetSpacing(imageSpacing)
volumeNode.SetIJKToRASDirections(imageDirections)
volumeNode.SetAndObserveImageData(thresholder.GetOutput())
volumeNode.CreateDefaultDisplayNodes()
volumeNode.CreateDefaultStorageNode()
</pre>

== Modify voxels in a volume ==

Typically the fastest and simplest way of modifying voxels is by using numpy operators. Voxels can be retrieved in a numpy array using the `array` method and modified using standard numpy methods. For example, threshold a volume:

<pre>
nodeName = 'MRHead'
thresholdValue = 100
voxelArray = array(nodeName) # get voxels as numpy array
voxelArray[voxelArray < thresholdValue] = 0 # modify voxel values
getNode(nodeName).Modified() # at the end of all processing, notify Slicer that the image modification is completed
</pre>

This example shows how to change voxels values of the MRHead sample volume.
The values will be computed by function f(r,a,s,) = (r-10)*(r-10)+(a+15)*(a+15)+s*s.
<pre>
volumeNode=slicer.util.getNode('MRHead')
ijkToRas = vtk.vtkMatrix4x4()
volumeNode.GetIJKToRASMatrix(ijkToRas)
imageData=volumeNode.GetImageData()
extent = imageData.GetExtent()
for k in xrange(extent[4], extent[5]+1):
for j in xrange(extent[2], extent[3]+1):
for i in xrange(extent[0], extent[1]+1):
position_Ijk=[i, j, k, 1]
position_Ras=ijkToRas.MultiplyPoint(position_Ijk)
r=position_Ras[0]
a=position_Ras[1]
s=position_Ras[2]
functionValue=(r-10)*(r-10)+(a+15)*(a+15)+s*s
imageData.SetScalarComponentFromDouble(i,j,k,0,functionValue)
imageData.SetScalarComponentFromFloat(distortionVectorPosition_Ijk[0], distortionVectorPosition_Ijk[1], distortionVectorPosition_Ijk[2], 0, fillValue)
imageData.Modified()
</pre>

== Get the values of all voxels for a label value ==

If you have a background image called ‘Volume’ and a mask called ‘Volume-label’ created with the Editor you could do something like this:

<pre>

import numpy
volume = array(‘Volume’)
label = array(‘Volume-label’)
points = numpy.where( label == 1 ) # or use another label number depending on what you segmented
values = volume[points] # this will be a list of the label values
values.mean() # should match the mean value of LabelStatistics calculation as a double-check
numpy.savetxt(‘values.txt’, values)
</pre>

== Access values in a DTI tensor volume ==
This example shows how to access individual tensors at the voxel level.

First load your DWI volume and estimate tensors to produce a DTI volume called ‘Output DTI Volume’

Then open the python window: View->Python interactor

Use this command to access tensors through numpy:

<pre>
tensors = array('Output DTI Volume')
</pre>

Type the following code into the Python window to access all tensor components using vtk commands:

<pre>
volumeNode=slicer.util.getNode('Output DTI Volume')
imageData=volumeNode.GetImageData()
tensors = imageData.GetPointData().GetTensors()
extent = imageData.GetExtent()
idx = 0
for k in xrange(extent[4], extent[5]+1):
for j in xrange(extent[2], extent[3]+1):
for i in xrange(extent[0], extent[1]+1):
tensors.GetTuple9(idx)
idx += 1
</pre>

== Change window/level (brightness/contrast) or colormap of a volume ==
This example shows how to change window/level of the MRHead sample volume.
<pre>
volumeNode = getNode('MRHead')
displayNode = volumeNode.GetDisplayNode()
displayNode.AutoWindowLevelOff()
displayNode.SetWindow(50)
displayNode.SetLevel(100)
</pre>

Change color mapping from grayscale to rainbow:
<pre>
displayNode.SetAndObserveColorNodeID('vtkMRMLColorTableNodeRainbow')
</pre>

== Manipulate a Slice View ==

=== Change the slice offset ===
<pre>
lm = slicer.app.layoutManager()
red = lm.sliceWidget('Red')
redLogic = red.sliceLogic()
# Print current slice offset position
print redLogic.GetSliceOffset()
# Change slice position
redLogic.SetSliceOffset(20)
</pre>

=== Iterate over current visible slice views, and modify 3D visibility ===
<pre>
for sliceViewName in layoutManager.sliceViewNames():
sliceWidget = layoutManager.sliceWidget(sliceViewName)

controller = sliceWidget.sliceController()
controller.setSliceVisible(True)
</pre>

=== Iterate over current visible slice views, and set foreground and background images ===
<pre>
for sliceViewName in layoutManager.sliceViewNames():
sliceWidget = layoutManager.sliceWidget(sliceViewName)

# setup background volume
compositeNode.SetBackgroundVolumeID(MRVolume.GetID())
# setup foreground volume
compositeNode.SetForegroundVolumeID(CTVolume.GetID())
# change opacity
compositeNode.SetForegroundOpacity(0.3)
</pre>

== Fit slice plane to markup fiducials ==

<pre>
sliceNode = slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeRed")
markupsNode = slicer.mrmlScene.GetFirstNodeByName("F")
# Get markup point positions as numpy arrays
import numpy as np
p1 = np.array([0,0,0])
p2 = np.array([0,0,0])
p3 = np.array([0,0,0])
markupsNode.GetNthFiducialPosition(0, p1)
markupsNode.GetNthFiducialPosition(1, p2)
markupsNode.GetNthFiducialPosition(2, p3)
# Get plane axis directions
n = np.cross(p2-p1, p2-p3) # plane normal direction
n = n/np.linalg.norm(n)
t = np.cross([0, 0, 1], n) # plane transverse direction
t = t/np.linalg.norm(t)
# Set slice plane orientation and position
sliceNode.SetSliceToRASByNTP(n[0], n[1], n[2], t[0], t[1], t[2], p1[0], p1[1], p1[2], 0)
</pre>

== Save a series of images from a Slice View ==

You can use ScreenCapture module to capture series of images. To do it programmatically, save the following into a file such as '/tmp/record.py' and then in the slicer python console type "execfile('/tmp/record.py')"

<pre>
layoutName = 'Green'
imagePathPattern = '/tmp/image-%03d.png'
steps = 10

widget = slicer.app.layoutManager().sliceWidget(layoutName)
view = widget.sliceView()
logic = widget.sliceLogic()
bounds = [0,]*6
logic.GetSliceBounds(bounds)

for step in range(steps):
offset = bounds[4] + step/(1.*steps) * (bounds[5]-bounds[4])
logic.SetSliceOffset(offset)
view.forceRender()
image = qt.QPixmap.grabWidget(view).toImage()
image.save(imagePathPattern % step)
</pre>

== Save the scene into a new directory ==

<pre>
# Create a new directory where the scene will be saved into
import time
sceneSaveDirectory = slicer.app.temporaryPath + "/saved-scene-" + time.strftime("%Y%m%d-%H%M%S")
if not os.access(sceneSaveDirectory, os.F_OK):
os.makedirs(sceneSaveDirectory)

# Save the scene
if slicer.app.applicationLogic().SaveSceneToSlicerDataBundleDirectory(sceneSaveDirectory, None):
logging.info("Scene saved to: {0}".format(sceneSaveDirectory))
else:
logging.error("Scene saving failed")
</pre>

== Save the scene into a single MRB file ==
<pre>
# Generate file name
import time
sceneSaveFilename = slicer.app.temporaryPath + "/saved-scene-" + time.strftime("%Y%m%d-%H%M%S") + ".mrb"

# Save scene
if slicer.util.saveScene(sceneSaveFilename):
logging.info("Scene saved to: {0}".format(sceneSaveFilename))
else:
logging.error("Scene saving failed")
</pre>

== Show a volume in the Slice Views ==

<pre>
volumeNode = slicer.util.getNode('YourVolumeNode')
applicationLogic = slicer.app.applicationLogic()
selectionNode = applicationLogic.GetSelectionNode()
selectionNode.SetSecondaryVolumeID(volumeNode.GetID())
applicationLogic.PropagateForegroundVolumeSelection(0)
</pre>

or

<pre>
n = slicer.util.getNode('YourVolumeNode')
for color in ['Red', 'Yellow', 'Green']:
slicer.app.layoutManager().sliceWidget(color).sliceLogic().GetSliceCompositeNode().SetForegroundVolumeID(n.GetID())
</pre>

== Change opacity of foreground volume in the Slice Views ==

<pre>
lm = slicer.app.layoutManager()
sliceLogic = lm.sliceWidget('Red').sliceLogic()
compositeNode = sliceLogic.GetSliceCompositeNode()
compositeNode.SetForegroundOpacity(0.4)
</pre>

== Center the 3D View on the Scene ==
<pre>
layoutManager = slicer.app.layoutManager()
threeDWidget = layoutManager.threeDWidget(0)
threeDView = threeDWidget.threeDView()
threeDView.resetFocalPoint()
</pre>

==Rotate the 3D View==

<pre>
layoutManager = slicer.app.layoutManager()
threeDWidget = layoutManager.threeDWidget(0)
threeDView = threeDWidget.threeDView()
threeDView.yaw()
</pre>

== Display text in a 3D view or slice view ==

The easiest way to show information overlaid on a viewer is to use corner annotations.

<pre>
view=slicer.app.layoutManager().threeDWidget(0).threeDView()
# Set text to "Something"
view.cornerAnnotation().SetText(vtk.vtkCornerAnnotation.UpperRight,"Something")
# Set color to red
view.cornerAnnotation().GetTextProperty().SetColor(1,0,0)
# Update the view
view.forceRender()
</pre>

== Hide slice view annotations (DataProbe) ==

<pre>
# Disable slice annotations immediately
slicer.modules.DataProbeInstance.infoWidget.sliceAnnotations.sliceViewAnnotationsEnabled=False
slicer.modules.DataProbeInstance.infoWidget.sliceAnnotations.updateSliceViewFromGUI()
# Disable slice annotations persistently (after Slicer restarts)
settings = qt.QSettings()
settings.setValue('DataProbe/sliceViewAnnotations.enabled', 0)
</pre>

== Turning off interpolation ==

You can turn off interpolation for newly loaded volumes with this script from Steve Pieper.

<pre>
def NoInterpolate(caller,event):
for node in slicer.util.getNodes('*').values():
if node.IsA('vtkMRMLScalarVolumeDisplayNode'):
node.SetInterpolate(0)

slicer.mrmlScene.AddObserver(slicer.mrmlScene.NodeAddedEvent, NoInterpolate)
</pre>

The below link explains how to put this in your startup script.

http://www.na-mic.org/Wiki/index.php/AHM2012-Slicer-Python#Refining_the_code_and_UI_with_slicerrc

== Customize viewer layout ==

Show a custom layout of a 3D view on top of the red slice view:

<pre>
customLayout = ("<layout type=\"vertical\" split=\"true\" >"
" <item>"
" <view class=\"vtkMRMLViewNode\" singletontag=\"1\">"
" <property name=\"viewlabel\" action=\"default\">1</property>"
" </view>"
" </item>"
" <item>"
" <view class=\"vtkMRMLSliceNode\" singletontag=\"Red\">"
" <property name=\"orientation\" action=\"default\">Axial</property>"
" <property name=\"viewlabel\" action=\"default\">R</property>"
" <property name=\"viewcolor\" action=\"default\">#F34A33</property>"
" </view>"
" </item>"
"</layout>")

customLayoutId=501

layoutManager = slicer.app.layoutManager()
layoutManager.layoutLogic().GetLayoutNode().AddLayoutDescription(customLayoutId, customLayout)
layoutManager.setLayout(customLayoutId)
</pre>

See description of standard layouts (that can be used as examples) here:
https://github.com/Slicer/Slicer/blob/master/Libs/MRML/Logic/vtkMRMLLayoutLogic.cxx

== Disable certain user interactions in slice views ==

For example, disable slice browsing using mouse wheel and keyboard shortcuts in the red slice viewer:

<pre>
interactorStyle = slicer.app.layoutManager().sliceWidget('Red').sliceView().sliceViewInteractorStyle()
interactorStyle.SetActionEnabled(interactorStyle.BrowseSlice, False)
</pre>

Hide all slice view controllers:
<pre>
lm = slicer.app.layoutManager()
for sliceViewName in lm.sliceViewNames():
lm.sliceWidget(sliceViewName).sliceController().setVisible(False)
</pre>

Hide all 3D view controllers:
<pre>
lm = slicer.app.layoutManager()
for viewIndex in range(slicer.app.layoutManager().threeDViewCount):
lm.threeDWidget(0).threeDController().setVisible(False)
</pre>

== Set up custom units in slice view ruler ==

For microscopy or micro-CT images you may want to switch unit to micrometer instead of the default mm. To do that, 1. change the unit in Application settings / Units and 2. update ruler display settings using the script below (it can be copied to your Application startup script):

<pre>
lm = slicer.app.layoutManager()
for sliceViewName in lm.sliceViewNames():
sliceView = lm.sliceWidget(sliceViewName).sliceView()
displayableManagerCollection = vtk.vtkCollection()
sliceView.getDisplayableManagers(displayableManagerCollection)
for dmIndex in xrange(displayableManagerCollection.GetNumberOfItems()):
displayableManager = displayableManagerCollection.GetItemAsObject(dmIndex)
if not displayableManager.IsA("vtkMRMLRulerDisplayableManager"):
continue
displayableManager.RemoveAllRulerScalePresets()
displayableManager.AddRulerScalePreset( 0.001, 5, 2, "nm", 1000.0)
displayableManager.AddRulerScalePreset( 0.010, 5, 2, "nm", 1000.0)
displayableManager.AddRulerScalePreset( 0.100, 5, 2, "nm", 1000.0)
displayableManager.AddRulerScalePreset( 0.500, 5, 1, "nm", 1000.0)
displayableManager.AddRulerScalePreset( 1.0, 5, 2, "um", 1.0)
displayableManager.AddRulerScalePreset( 5.0, 5, 1, "um", 1.0)
displayableManager.AddRulerScalePreset( 10.0, 5, 2, "um", 1.0)
displayableManager.AddRulerScalePreset( 50.0, 5, 1, "um", 1.0)
displayableManager.AddRulerScalePreset( 100.0, 5, 2, "um", 1.0)
displayableManager.AddRulerScalePreset( 500.0, 5, 1, "um", 1.0)
displayableManager.AddRulerScalePreset(1000.0, 5, 2, "mm", 0.001)
</pre>

== Show a slice view outside the view layout ==

<pre>
sliceLayoutName = "TestSlice"
sliceLayoutLabel = "T"
# ownerNode manages this view instead of the layout manager (it can be any node in the scene)
viewOwnerNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLScriptedModuleNode")

# Create MRML nodes
sliceNode = slicer.vtkMRMLSliceNode()
sliceNode.SetName(sliceLayoutName)
sliceNode.SetLayoutName(sliceLayoutName)
sliceNode.SetLayoutLabel(sliceLayoutLabel)
sliceNode.SetLayoutColor(1, 1, 0)
sliceNode.SetAndObserveParentLayoutNodeID(viewOwnerNode.GetID())
sliceNode = slicer.mrmlScene.AddNode(sliceNode)
sliceCompositeNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLSliceCompositeNode")
sliceCompositeNode.SetLayoutName(sliceLayoutName)

# Create widget
sliceWidget = slicer.qMRMLSliceWidget()
sliceWidget.sliceViewName = sliceLayoutName
sliceWidget.sliceViewLabel = sliceLayoutLabel
c = sliceNode.GetLayoutColor()
sliceWidget.sliceViewColor = qt.QColor.fromRgbF(c[0],c[1],c[2])
sliceWidget.setMRMLScene(slicer.mrmlScene)
sliceWidget.setMRMLSliceNode(sliceNode)
sliceWidget.show()
</pre>

== Running an ITK filter in Python using SimpleITK ==
Open the "Sample Data" module and download "MR Head", then paste the following snippet in Python interactor:
<pre>
import SimpleITK as sitk
import sitkUtils
inputImage = sitkUtils.PullFromSlicer('MRHead')
filter = sitk.SignedMaurerDistanceMapImageFilter()
outputImage = filter.Execute(inputImage)
sitkUtils.PushToSlicer(outputImage,'outputImage')
</pre>

More information:
* See the SimpleITK documentation for SimpleITK examples: http://www.itk.org/SimpleITKDoxygen/html/examples.html
* sitkUtils in Slicer is used for pushing and pulling images from Slicer to SimpleITK: https://github.com/Slicer/Slicer/blob/master/Base/Python/sitkUtils.py

== Get current mouse coordinates in a slice view ==

You can get 3D (RAS) coordinates of the current mouse cursor from the crosshair singleton node as shown in the example below:

<pre>
def onMouseMoved(observer,eventid):
ras=[0,0,0]
crosshairNode.GetCursorPositionRAS(ras)
print(ras)

crosshairNode=slicer.util.getNode('Crosshair')
crosshairNode.AddObserver(slicer.vtkMRMLCrosshairNode.CursorPositionModifiedEvent, onMouseMoved)
</pre>

== Get DataProbe text ==

You can get the mouse location in pixel coordinates along with the pixel value at the mouse by hitting the '.' (period) key in a slice view after pasting in the following code.

<pre>
def printDataProbe():
infoWidget = slicer.modules.DataProbeInstance.infoWidget
for layer in ('B', 'F', 'L'):
print(infoWidget.layerNames[layer].text, infoWidget.layerIJKs[layer].text, infoWidget.layerValues[layer].text)

s = qt.QShortcut(qt.QKeySequence('.'), mainWindow())
s.connect('activated()', printDataProbe)
</pre>

== Thick slab reconstruction and maximum/minimum intensity volume projections ==

Set up 'red' slice viewer to show thick slab reconstructed from 3 slices:
<pre>
sliceNode = slicer.mrmlScene.GetNodeByID('vtkMRMLSliceNodeRed')
appLogic = slicer.app.applicationLogic()
sliceLogic = appLogic.GetSliceLogic(sliceNode)
sliceLayerLogic = sliceLogic.GetBackgroundLayer()
reslice = sliceLayerLogic.GetReslice()
reslice.SetSlabModeToMean()
reslice.SetSlabNumberOfSlices(10) # mean of 10 slices will computed
reslice.SetSlabSliceSpacingFraction(0.3) # spacing between each slice is 0.3 pixel (total 10 * 0.3 = 3 pixel neighborhood)
sliceNode.Modified()
</pre>

Set up 'red' slice viewer to show maximum intensity projection (MIP):
<pre>
sliceNode = slicer.mrmlScene.GetNodeByID('vtkMRMLSliceNodeRed')
appLogic = slicer.app.applicationLogic()
sliceLogic = appLogic.GetSliceLogic(sliceNode)
sliceLayerLogic = sliceLogic.GetBackgroundLayer()
reslice = sliceLayerLogic.GetReslice()
reslice.SetSlabModeToMax()
reslice.SetSlabNumberOfSlices(600) # use a large number of slices (600) to cover the entire volume
reslice.SetSlabSliceSpacingFraction(0.5) # spacing between slices are 0.5 pixel (supersampling is useful to reduce interpolation artifacts)
sliceNode.Modified()
</pre>

The projected image is available in a ''vtkImageData'' object by calling ''reslice.GetOutput()''.

== Change default file type for nodes (that have never been saved yet) ==
Default node can be specified that will be used as a basis of all new storage nodes. This can be used for setting default file extension. For example, change file format to STL for model nodes:
<pre>
defaultModelStorageNode = slicer.vtkMRMLModelStorageNode()
defaultModelStorageNode.SetDefaultWriteFileExtension('stl')
slicer.mrmlScene.AddDefaultNode(defaultModelStorageNode)
</pre>

To permanently change default file extension on your computer, copy-paste the code above into your application startup script (you can find its location in menu: Edit / Application settings / General / Application startup script).

== Change file type for saving for all volumes (with already existing storage nodes) ==

If it is not necessary to preserve file paths then the simplest is to configure default storage node (as shown in the example above), then delete all existing storage nodes. When save dialog is opened, default storage nodes will be recreated.

<pre>
# Delete existing model storage nodes so that they will be recreated with default settings
existingModelStorageNodes = slicer.util.getNodesByClass('vtkMRMLModelStorageNode')
for modelStorageNode in existingModelStorageNodes:
slicer.mrmlScene.RemoveNode(modelStorageNode)
</pre>

To update existing storage nodes to use new file extension (but keep all other parameters unchanged) you can use this approach (example is for volume storage):

<pre>
requiredFileExtension = '.nia'
originalFileExtension = '.nrrd'
volumeNodes = slicer.util.getNodesByClass('vtkMRMLScalarVolumeNode')
for volumeNode in volumeNodes:
volumeStorageNode = volumeNode.GetStorageNode()
if not volumeStorageNode:
volumeNode.AddDefaultStorageNode()
volumeStorageNode = volumeNode.GetStorageNode()
volumeStorageNode.SetFileName(volumeNode.GetName()+requiredFileExtension)
else:
volumeStorageNode.SetFileName(volumeStorageNode.GetFileName().replace(originalFileExtension, requiredFileExtension))
</pre>

== Segmentations ==

=== Create a segmentation from a labelmap volume and display in 3D ===

<pre>
labelmapVolumeNode = getNode('label')
seg = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode')
slicer.modules.segmentations.logic().ImportLabelmapToSegmentationNode(labelmapVolumeNode, seg)
seg.CreateClosedSurfaceRepresentation()
slicer.mrmlScene.RemoveNode(labelmapVolumeNode)
</pre>

The last line is optional. It removes the original labelmap volume so that the same information is not shown twice.

=== Export labelmap node from segmentation node ===

<pre>
seg = getNode('Segmentation')
labelmapVolumeNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLLabelMapVolumeNode')
slicer.modules.segmentations.logic().ExportAllSegmentsToLabelmapNode(seg, labelmapVolumeNode)
</pre>

=== Show a segmentation in 3D ===
Segmentation can only be shown in 3D if closed surface representation (or other 3D-displayable representation) is available. To create closed surface representation:
<pre>
segmentation.CreateClosedSurfaceRepresentation()
</pre>

=== Get a representation of a segment ===
Access binary labelmap stored in a segmentation node (without exporting it to a volume node) - if it does not exist, it will return None:
<pre>
image = segmentationNode.GetBinaryLabelmapRepresentation(segmentID)
</pre>
Get closed surface, if it does not exist, it will return None:
<pre>
polydata = segmentationNode.GetClosedSurfaceRepresentation(segmentID)
</pre>
Get binary labelmap representation. If it does not exist then it will be created for that single segment. Applies parent transforms by default (if not desired, another argument needs to be added to the end: false):
<pre>
import vtkSegmentationCorePython as vtkSegmentationCore
outputOrientedImageData = vtkSegmentationCore.vtkOrientedImageData()
slicer.vtkSlicerSegmentationsModuleLogic.GetSegmentBinaryLabelmapRepresentation(segmentationNode, segmentID, outputOrientedImageData)
</pre>
Same as above, for closed surface representation:
<pre>
outputPolyData = vtk.vtkPolyData()
slicer.vtkSlicerSegmentationsModuleLogic.GetSegmentClosedSurfaceRepresentation(segmentationNode, segmentID, outputPolyData)
</pre>

=== Convert all segments using default path and conversion parameters ===
<pre>
segmentationNode.CreateBinaryLabelmapRepresentation()
</pre>

=== Convert all segments using custom path or conversion parameters ===
Change reference image geometry parameter based on an existing referenceImageData image:
<pre>
import vtkSegmentationCorePython as vtkSegmentationCore
referenceGeometry = vtkSegmentationCore.vtkSegmentationConverter.SerializeImageGeometry(referenceImageData)
segmentation.SetConversionParameter(vtkSegmentationCore.vtkSegmentationConverter.GetReferenceImageGeometryParameterName(), referenceGeometry)
</pre>

=== Re-convert using a modified conversion parameter ===
Changing smoothing factor for closed surface generation:
<pre>
import vtkSegmentationCorePython as vtkSegmentationCore
segmentation = getNode('Segmentation').GetSegmentation()

# Turn of surface smoothing
segmentation.SetConversionParameter('Smoothing factor','0.0')

# Recreate representation using modified parameters (and default conversion path)
segmentation.RemoveRepresentation(vtkSegmentationCore.vtkSegmentationConverter.GetSegmentationClosedSurfaceRepresentationName())
segmentation.CreateRepresentation(vtkSegmentationCore.vtkSegmentationConverter.GetSegmentationClosedSurfaceRepresentationName())
</pre>

=== How to run segment editor effects from a script ===

Editor effects are complex because they need to handle changing master volumes, undo/redo, masking operations, etc. Therefore, instead of using a segment editor effect, it is simpler to run the underlying filters directly from script.

This example demonstrates how to use Segment editor effects (without GUI, using qMRMLSegmentEditorWidget):

* [https://gist.github.com/lassoan/2d5a5b73645f65a5eb6f8d5f97abf31b brain tumor segmentation using grow from seeds effect]
* [https://gist.github.com/lassoan/1673b25d8e7913cbc245b4f09ed853f9 skin surface extraction using thresholding and smoothing]
* [https://gist.github.com/lassoan/2f5071c562108dac8efe277c78f2620f mask a volume with segments and compute histogram for each region]

This example shows how to perform operations on segmentations using VTK filters:
* [https://gist.github.com/lassoan/7c94c334653010696b2bf96abc0ac8e7 brain tumor segmentation using grow from seeds effect]

== Accessing views, renderers, and cameras ==

Iterate through all 3D views in current layout:

<pre>
layoutManager = slicer.app.layoutManager()
for threeDViewIndex in range(layoutManager.threeDViewCount) :
view = layoutManager.threeDWidget(threeDViewIndex).threeDView()
threeDViewNode = view.mrmlViewNode()
cameraNode = slicer.modules.cameras.logic().GetViewActiveCameraNode(threeDViewNode)
print('View node for 3D widget ' + str(threeDViewIndex))
print(' Name: ' + threeDViewNode .GetName())
print(' ID: ' + threeDViewNode .GetID())
print(' Camera ID: ' + cameraNode.GetID())
</pre>

Iterate through all slice views in current layout:

<pre>
layoutManager = slicer.app.layoutManager()
for sliceViewName in layoutManager.sliceViewNames():
view = layoutManager.sliceWidget(sliceViewName).sliceView()
sliceNode = view.mrmlSliceNode()
sliceLogic = slicer.app.applicationLogic().GetSliceLogic(sliceNode)
compositeNode = sliceLogic.GetSliceCompositeNode()
print('Slice view ' + str(sliceViewName))
print(' Name: ' + sliceNode.GetName())
print(' ID: ' + sliceNode.GetID())
print(' Background volume: {0}'.format(compositeNode.GetBackgroundVolumeID()))
print(' Foreground volume: {0} (opacity: {1})'.format(compositeNode.GetForegroundVolumeID(), compositeNode.GetForegroundOpacity()))
print(' Label volume: {0} (opacity: {1})'.format(compositeNode.GetLabelVolumeID(), compositeNode.GetLabelOpacity()))
</pre>

For low-level manipulation of views, it is possible to access VTK render windows, renderers and cameras of views in the current layout.
<pre>
renderWindow = view.renderWindow()
renderers = renderWindow.GetRenderers()
renderer = renderers.GetItemAsObject(0)
camera = cameraNode.GetCamera()
</pre>

== Change 3D view background color ==

<pre>
renderWindow = slicer.app.layoutManager().threeDWidget(0).threeDView().renderWindow()
renderer = renderWindow.GetRenderers().GetFirstRenderer()
renderer.SetBackground(1,0,0)
renderer.SetBackground2(1,0,0)
renderWindow.Render()
</pre>

== Subject hierarchy ==
==== Get the pseudo-singleton subject hierarchy node ====
It manages the whole hierarchy and provides functions to access and manipulate
shNode = slicer.vtkMRMLSubjectHierarchyNode.GetSubjectHierarchyNode(slicer.mrmlScene)

==== Create subject hierarchy item ====
# If it is for a data node, it is automatically created, but the create function can be used to set parent:
shNode.CreateItem(parentItemID, dataNode)
# If it is a hierarchy item without a data node, then the create function must be used:
shNode.CreateSubjectItem(parentItemID, name)
shNode.CreateFolderItem(parentItemID, name)
shNode.CreateHierarchyItem(parentItemID, name, level) # Advanced method to set level attribute manually (usually subject, study, or folder, but it can be a virtual branch for example)

==== Get subject hierarchy item ====
Items in subject hierarchy are uniquely identified by integer IDs
# Get scene item ID first because it is the root item:
sceneItemID = shNode.GetSceneItemID()
# Get direct child by name
subjectItemID = shNode.GetItemChildWithName(sceneItemID, 'Subject_1')
# Get item for data node
itemID = shNode.GetItemByDataNode(dataNode)
# Get item by UID (such as DICOM)
itemID = shNode.GetItemByUID(slicer.vtkMRMLSubjectHierarchyConstants.GetDICOMUIDName(), seriesInstanceUid)
itemID = shNode.GetItemByUIDList(slicer.vtkMRMLSubjectHierarchyConstants.GetDICOMInstanceUIDName(), instanceUID)
# Invalid item ID for checking validity of a given ID (most functions return the invalid ID when item is not found)
invalidItemID = slicer.vtkMRMLSubjectHierarchyNode.GetInvalidItemID()

==== Traverse children of a subject hierarchy item ====
children = vtk.vtkIdList()
shNode.GetItemChildren(parent, children)
for i in xrange(children.GetNumberOfIds()):
child = children.GetId(i)
...

==== Manipulate subject hierarchy item ====
Instead of node operations on the individual subject hierarchy nodes, item operations are performed on the one subject hierarchy node.
# Set item name
shNode.SetItemName(itemID, 'NewName')
# Set item parent (reparent)
shNode.SetItemParent(itemID, newParentItemID)
# Set visibility of data nodes associated to items in a branch (or a leaf item)
shNode.SetDisplayVisibilityForBranch(itemID, 1)

==== Filter items in TreeView or ComboBox ====
Displayed items can be filtered using ''setAttributeFilter'' method. An example of the usage can be found in the [https://github.com/Slicer/Slicer/blob/e66e3b08e35384526528e6ae678e9ec9f079f286/Applications/SlicerApp/Testing/Python/SubjectHierarchyGenericSelfTest.py#L352-L360 unit test]. Modified version here:
print shTreeView.displayedItemCount() # 5
shTreeView.setAttributeFilter('DICOM.Modality') # Nodes must have this attribute
print shTreeView.displayedItemCount() # 3
shTreeView.setAttributeFilter('DICOM.Modality','CT') # Have attribute and equal 'CT'
print shTreeView.displayedItemCount() # 1
shTreeView.removeAttributeFilter()
print shTreeView.displayedItemCount() # 5

== Plotting ==

=== Create histogram plot of a volume ===

<pre>
# Get a volume from SampleData
import SampleData
volumeNode = SampleData.SampleDataLogic().downloadMRHead()

# Compute histogram values
import numpy as np
histogram = np.histogram(arrayFromVolume(volumeNode), bins=50)

# Save results to a new table node
tableNode=slicer.mrmlScene.AddNewNodeByClass("vtkMRMLTableNode")
updateTableFromArray(tableNode, histogram)
tableNode.GetTable().GetColumn(0).SetName("Count")
tableNode.GetTable().GetColumn(1).SetName("Intensity")

# Create plot
plotSeriesNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLPlotSeriesNode", volumeNode.GetName() + ' histogram')
plotSeriesNode.SetAndObserveTableNodeID(tableNode.GetID())
plotSeriesNode.SetXColumnName("Intensity")
plotSeriesNode.SetYColumnName("Count")
plotSeriesNode.SetPlotType(plotSeriesNode.PlotTypeScatterBar)
plotSeriesNode.SetColor(0, 0.6, 1.0)

# Create chart and add plot
plotChartNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLPlotChartNode")
plotChartNode.AddAndObservePlotSeriesNodeID(plotSeriesNode.GetID())
plotChartNode.YAxisRangeAutoOff()
plotChartNode.SetYAxisRange(0, 500000)

# Show plot in layout
slicer.modules.plots.logic().ShowChartInLayout(plotChartNode)

</pre>

Documentation/Nightly/Developers/Tutorials/QtDesigner

2018-01-23T01:12:16Z

Arankin:

<noinclude>{{documentation/versioncheck}}</noinclude>
=Using custom widgets in Qt Designer=
==Straight to the point==
*Windows
**Compile Slicer in Release mode OR build Qt in Debug
*All
<pre>
cd Slicer-build;
./Slicer --designer
</pre>

If the option <code>--designer</code> is not available, you should consider using QtCreator. See [[Documentation/{{documentation/version}}/Developers/Tutorials/QtCreator|here]] for more details.

==Qt Designer requirements==
In order to have the CTK and MRML widgets in Qt Designer, Qt Designer offers 2 options:
*the first (not detailed here) is to copy (or symlink) the CTK and MRML plugin libraries into %QT_DIR%/plugins/designer,
*the second is to set the environment variable <code>QT_PLUGIN_PATH</code> to the directory Slicer-build/bin containing the subdirectory designer with the plugin libraries. 

'''Note:''' Qt requires that the directory containing the designer plugins is named "designer".

Consider reading the [http://doc.qt.nokia.com/{{documentation/{{documentation/version}}/qtversion}}/designer-manual.html Qt Designer documentation].
If the widgets do not appear in Qt Designer, then open the "Help -> About Plugin" dialog and report the error associated to the plugin dll.

=== Windows notes ===
On Windows, Qt Designer can only load plugins that have been compiled in the same build mode than Qt Designer. For example, if Qt is built in Debug mode, the plugins must also be built in Debug mode to be loaded by Qt Designer. 
If Qt is configured to build in both debug and release modes, Qt Designer is built in release mode only. If that case, it is necessary to ensure that plugins are also built in release mode. Otherwise, you can open the solution file for Qt, and recompile Designer in debug mode.

==Running Qt Designer with the correct environment variables==
*On Windows, compile Slicer in the same build mode than Qt. If Qt is in Debug mode, compile Slicer in Debug mode, if it's in Release or Debug&Release mode, compile Slicer in Release mode.
*run Qt Designer via Slicer launcher located in Slicer-build.
{| style="border: 1px solid darkgray;"
!align=left style="border-bottom: 1px solid grey;"|Mac Os X
!align=left style="border-bottom: 1px solid grey;"|Linux
!align=left style="border-bottom: 1px solid grey;"|Windows
|-
|colspan="2"|
$ cd Slicer-build
$ ./Slicer --designer
|
> cd Slicer-build
> .\Slicer.exe --designer
|}
If the option <code>--designer</code> is not available, you should consider using QtCreator. See [[Documentation/{{documentation/version}}/Developers/Tutorials/QtCreator|here]] for more details.

{|
|[[Image:Screenshot-Qt Designer.png|thumb|300px|Qt Desginer loaded with CTKWidgets and qMRMLWidgets]]

|}

==Build Slicer==
* Once you are satisfied with UI, save the file, quit Designer and build Slicer to take the changes into account.
{| style="border: 1px solid darkgray;"
!align=left style="border-bottom: 1px solid grey;"|Mac Os X
!align=left style="border-bottom: 1px solid grey;"|Linux
!align=left style="border-bottom: 1px solid grey;"|Windows
|-
|colspan="2"|
$ make -j4
or just build the related project
$ make -j4 qSlicerMY_MODULE_NAMEModuleWidget
| Open the inner solution file ''...Slicer-Superbuild\Slicer-build\Slicer.sln'' and build the solution (F7) or build project <code>qSlicerMY_MODULE_NAMEModuleWidgets</code>
|}
It generates a ''ui_qSlicerMY_MODULE_NAMEModule.h'' file in ''...Slicer-Superbuild/Slicer-buildModules/Loadable/MY_MODULE_NAME/''.

That file is used by ''...Slicer4/Modules/Loadable/MY_MODULE_NAME/qSlicerMY_MODULE_NAMEModuleWidget.cxx''.

Note: The <code>objectName</code>s of each widget in the UI correspond (see the Property editor) to the variable names in C++. From your code, you can access the widgets by their objectName.
* And launch Slicer to see the result
{| style="border: 1px solid darkgray;"
!align=left style="border-bottom: 1px solid grey;"|Mac Os X
!align=left style="border-bottom: 1px solid grey;"|Linux
!align=left style="border-bottom: 1px solid grey;"|Windows
|-
|colspan="2"|<pre>$ ./Slicer</pre>
| <pre>> .\Slicer.exe</pre>
|}
== Frequently Asked Questions ==
* My [http://slicer.org/doc/html/classqMRMLNodeComboBox.html qMRMLNodeComboBox] widget is always disabled (gray) in my module.
To be enabled, qMRMLNodeComboBox needs a MRML scene. You can set a MRML scene to the combobox programmatically or directly from Qt Designer. Doing it in Qt Designer is the recommended way, to do so you need to be in [http://doc.qt.io/qt-5/designer-connection-mode.html Connection mode] and connect the signal [http://slicer.org/doc/html/classqSlicerWidget.html#a9c28318f7810ccce517ea7a1b0051da4 mrmlSceneChanged(vtkMRMLScene*)] of the module panel (of type [http://slicer.org/doc/html/classqSlicerWidget.html qSlicerWidget]) with the slot [http://slicer.org/doc/html/classqMRMLNodeComboBox.html#a2249be3ccec4783b592f738f1ef7bea3 setMRMLScene(vtkMRMLScene*)].
The programmatic connection can be done in the <code>setup()</code> method of the module widget (or <code>init()</code> of the module widget pimpl):
void qSlicerDataModuleWidget::setup()
{
...
connect(this, SIGNAL(mrmlSceneChanged(vtkMRMLScene*)),
myWidget, SLOT(setMRMLScene(vtkMRMLScene*)));
...
}

Documentation/Nightly/Developers/Tutorials/QtDesigner

2018-01-23T01:11:41Z

Arankin: Updating link to connection mode documentation for Qt

<noinclude>{{documentation/versioncheck}}</noinclude>
=Using custom widgets in Qt Designer=
==Straight to the point==
*Windows
**Compile Slicer in Release mode OR build Qt in Debug
*All
<pre>
cd Slicer-build;
./Slicer --designer
</pre>

If the option <code>--designer</code> is not available, you should consider using QtCreator. See [[Documentation/{{documentation/version}}/Developers/Tutorials/QtCreator|here]] for more details.

==Qt Designer requirements==
In order to have the CTK and MRML widgets in Qt Designer, Qt Designer offers 2 options:
*the first (not detailed here) is to copy (or symlink) the CTK and MRML plugin libraries into %QT_DIR%/plugins/designer,
*the second is to set the environment variable <code>QT_PLUGIN_PATH</code> to the directory Slicer-build/bin containing the subdirectory designer with the plugin libraries. 

'''Note:''' Qt requires that the directory containing the designer plugins is named "designer".

Consider reading the [http://doc.qt.nokia.com/{{documentation/{{documentation/version}}/qtversion}}/designer-manual.html Qt Designer documentation].
If the widgets do not appear in Qt Designer, then open the "Help -> About Plugin" dialog and report the error associated to the plugin dll.

=== Windows notes ===
On Windows, Qt Designer can only load plugins that have been compiled in the same build mode than Qt Designer. For example, if Qt is built in Debug mode, the plugins must also be built in Debug mode to be loaded by Qt Designer. 
If Qt is configured to build in both debug and release modes, Qt Designer is built in release mode only. If that case, it is necessary to ensure that plugins are also built in release mode. Otherwise, you can open the solution file for Qt, and recompile Designer in debug mode.

==Running Qt Designer with the correct environment variables==
*On Windows, compile Slicer in the same build mode than Qt. If Qt is in Debug mode, compile Slicer in Debug mode, if it's in Release or Debug&Release mode, compile Slicer in Release mode.
*run Qt Designer via Slicer launcher located in Slicer-build.
{| style="border: 1px solid darkgray;"
!align=left style="border-bottom: 1px solid grey;"|Mac Os X
!align=left style="border-bottom: 1px solid grey;"|Linux
!align=left style="border-bottom: 1px solid grey;"|Windows
|-
|colspan="2"|
$ cd Slicer-build
$ ./Slicer --designer
|
> cd Slicer-build
> .\Slicer.exe --designer
|}
If the option <code>--designer</code> is not available, you should consider using QtCreator. See [[Documentation/{{documentation/version}}/Developers/Tutorials/QtCreator|here]] for more details.

{|
|[[Image:Screenshot-Qt Designer.png|thumb|300px|Qt Desginer loaded with CTKWidgets and qMRMLWidgets]]

|}

==Build Slicer==
* Once you are satisfied with UI, save the file, quit Designer and build Slicer to take the changes into account.
{| style="border: 1px solid darkgray;"
!align=left style="border-bottom: 1px solid grey;"|Mac Os X
!align=left style="border-bottom: 1px solid grey;"|Linux
!align=left style="border-bottom: 1px solid grey;"|Windows
|-
|colspan="2"|
$ make -j4
or just build the related project
$ make -j4 qSlicerMY_MODULE_NAMEModuleWidget
| Open the inner solution file ''...Slicer-Superbuild\Slicer-build\Slicer.sln'' and build the solution (F7) or build project <code>qSlicerMY_MODULE_NAMEModuleWidgets</code>
|}
It generates a ''ui_qSlicerMY_MODULE_NAMEModule.h'' file in ''...Slicer-Superbuild/Slicer-buildModules/Loadable/MY_MODULE_NAME/''.

That file is used by ''...Slicer4/Modules/Loadable/MY_MODULE_NAME/qSlicerMY_MODULE_NAMEModuleWidget.cxx''.

Note: The <code>objectName</code>s of each widget in the UI correspond (see the Property editor) to the variable names in C++. From your code, you can access the widgets by their objectName.
* And launch Slicer to see the result
{| style="border: 1px solid darkgray;"
!align=left style="border-bottom: 1px solid grey;"|Mac Os X
!align=left style="border-bottom: 1px solid grey;"|Linux
!align=left style="border-bottom: 1px solid grey;"|Windows
|-
|colspan="2"|<pre>$ ./Slicer</pre>
| <pre>> .\Slicer.exe</pre>
|}
== Frequently Asked Questions ==
* My [http://slicer.org/doc/html/classqMRMLNodeComboBox.html qMRMLNodeComboBox] widget is always disabled (gray) in my module.
To be enabled, qMRMLNodeComboBox needs a MRML scene. You can set a MRML scene to the combobox programmatically or directly from Qt Designer. Doing it in Qt Designer is the recommended way, to do so you need to be in [http://doc.qt.io/archives/qt-4.8/designer-connection-mode.html Connection mode] and connect the signal [http://slicer.org/doc/html/classqSlicerWidget.html#a9c28318f7810ccce517ea7a1b0051da4 mrmlSceneChanged(vtkMRMLScene*)] of the module panel (of type [http://slicer.org/doc/html/classqSlicerWidget.html qSlicerWidget]) with the slot [http://slicer.org/doc/html/classqMRMLNodeComboBox.html#a2249be3ccec4783b592f738f1ef7bea3 setMRMLScene(vtkMRMLScene*)].
The programmatic connection can be done in the <code>setup()</code> method of the module widget (or <code>init()</code> of the module widget pimpl):
void qSlicerDataModuleWidget::setup()
{
...
connect(this, SIGNAL(mrmlSceneChanged(vtkMRMLScene*)),
myWidget, SLOT(setMRMLScene(vtkMRMLScene*)));
...
}