def init_window(self):
""" Method to initialize the main window.
"""
# First set some meta informations
self.setApplicationName(self._application_name)
self.setOrganizationName(self._organisation_name)
self.setApplicationVersion(self._version)
# Get the user interface description from capsul resources
ui_file = os.path.join(os.path.dirname(__file__),
"activation_inspector.ui")
#ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui")
# Create and show the activation/pipeline/controller windows
self.pipeline_window = PipelineDevelopperView(self.pipeline,
show_sub_pipelines=True)
self.controller_window = ScrollControllerWidget(self.pipeline,
live=True)
self.activation_window = ActivationInspector(
self.pipeline,
ui_file,
self.record_file,
developper_view=self.pipeline_window)
self.pipeline_window.show()
self.activation_window.show()
self.controller_window.show()
return True
def test_simple_run(self):
""" Method to test a simple 1 cpu call with the scheduler.
"""
# Configure the environment
study_config = StudyConfig(
modules=[],
use_smart_caching=True,
output_directory=self.outdir,
number_of_cpus=1,
generate_logging=True,
use_scheduler=True)
# Create pipeline
pipeline = get_process_instance(self.pipeline_name)
pipeline.date_in_filename = True
# Set pipeline input parameters
dicom_dataset = get_sample_data("dicom")
dcmfolder = os.path.join(self.outdir, "dicom")
if not os.path.isdir(dcmfolder):
os.makedirs(dcmfolder)
shutil.copy(dicom_dataset.barre, os.path.join(dcmfolder, "heart.dcm"))
pipeline.source_dir = dcmfolder
# View pipeline
if 0:
from capsul.qt_gui.widgets import PipelineDevelopperView
from PySide import QtGui
app = QtGui.QApplication(sys.argv)
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
# Execute the pipeline in the configured study
study_config.run(pipeline)
def run_spm_preprocessing(funcfile,
outdir,
repetition_time,
ref_slice,
slice_order,
template,
timings_corr_algo,
normalization,
spm_bin,
fsl_config,
enable_display=False):
"""
"""
print "Study_config init..."
study_config = StudyConfig(
modules=["MatlabConfig", "SPMConfig", "FSLConfig", "NipypeConfig"],
use_smart_caching=False,
fsl_config=fsl_config,
use_fsl=True,
use_matlab=False,
use_spm=True,
spm_exec=spm_bin,
spm_standalone=True,
use_nipype=True,
output_directory=outdir,
)
print " ... done."
# Processing definition: create the <clinfmri.preproc.FmriPreproc> that
# define the different step of the processings.
pipeline = get_process_instance(
"clinfmri.preproc.converted_fmri_preproc.xml")
# It is possible to display the pipeline.
if enable_display:
import sys
from PySide import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication(sys.argv)
view = PipelineDevelopperView(pipeline)
view.show()
app.exec_()
# Now to parametrize the pipeline pipeline.
pipeline.fmri_file = funcfile
pipeline.realign_register_to_mean = True
pipeline.select_slicer = timings_corr_algo
pipeline.select_normalization = normalization
pipeline.force_repetition_time = repetition_time
pipeline.force_slice_orders = slice_order
pipeline.realign_wrap = [0, 1, 0]
pipeline.realign_write_wrap = [0, 1, 0]
pipeline.ref_slice = ref_slice
if template is not None:
pipeline.template_file = template
# The pipeline is now ready to be executed.
study_config.run(pipeline, executer_qc_nodes=False, verbose=1)
def pilot_gdti_estimation():
"""
Generalized diffusion tensor estimation
=======================================
"""
# System import
import os
import sys
import datetime
import PySide.QtGui as QtGui
# CAPSUL import
from capsul.qt_gui.widgets import PipelineDevelopperView
from capsul.study_config.study_config import StudyConfig
from capsul.process.loader import get_process_instance
"""
Study configuration
-------------------
We first define the working directory and guarantee this folder exists on
the file system:
"""
working_dir = "/volatile/nsap/clindmri/gdti"
if not os.path.isdir(working_dir):
os.makedirs(working_dir)
"""
And then define the study configuration (here we activate the smart
caching module that will be able to remember which process has already been
processed):
"""
study_config = StudyConfig(modules=["SmartCachingConfig"],
use_smart_caching=True,
output_directory=working_dir)
# Create pipeline
start_time = datetime.datetime.now()
print "Start Pipeline Creation", start_time
pipeline = get_process_instance("clindmri.estimation.gdti.xml")
print "Done in {0} seconds.".format(datetime.datetime.now() - start_time)
# View pipeline
if 0:
app = QtGui.QApplication(sys.argv)
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
del view1
# Set pipeline input parameters
pipeline.dfile = "/volatile/imagen/dmritest/000000022453/DTI/000000022453s011a1001.nii.gz"
pipeline.bvalfile = "/volatile/imagen/dmritest/000000022453/DTI/000000022453s011a1001.bval"
pipeline.bvecfile = "/volatile/imagen/dmritest/000000022453/DTI/000000022453s011a1001.bvec"
pipeline.order = 2
pipeline.odf = False
print "Done in {0} seconds.".format(datetime.datetime.now() - start_time)
# Execute the pipeline in the configured study
study_config.run(pipeline, verbose=1)
class ActivationInspectorApp(Application):
""" ActiovationInspector Application.
"""
# Load some meta informations
from capsul.info import __version__ as _version
from capsul.info import NAME as _application_name
from capsul.info import ORGANISATION as _organisation_name
def __init__(self, pipeline_path, record_file=None, *args, **kwargs):
""" Method to initialize the ActivationInspectorApp class.
Parameters
----------
pipeline_path: str (mandatory)
the name of the pipeline we want to load.
record_file: str (optional)
a file where the pipeline activation steps are stored.
"""
# Inhetritance
super(ActivationInspectorApp, self).__init__(*args, **kwargs)
# Load the pipeline
self.pipeline = get_process_instance(pipeline_path)
# Initialize the application
self.record_file = record_file
self.window = None
self.init_window()
def init_window(self):
""" Method to initialize the main window.
"""
# First set some meta informations
self.setApplicationName(self._application_name)
self.setOrganizationName(self._organisation_name)
self.setApplicationVersion(self._version)
# Get the user interface description from capsul resources
ui_file = os.path.join(os.path.dirname(__file__),
"activation_inspector.ui")
#ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui")
# Create and show the activation/pipeline/controller windows
self.pipeline_window = PipelineDevelopperView(self.pipeline,
show_sub_pipelines=True)
self.controller_window = ScrollControllerWidget(self.pipeline,
live=True)
self.activation_window = ActivationInspector(
self.pipeline,
ui_file,
self.record_file,
developper_view=self.pipeline_window)
self.pipeline_window.show()
self.activation_window.show()
self.controller_window.show()
return True
class ActivationInspectorApp(Application):
""" ActivationInspector Application.
While developing a pipeline, nodes are connected through links. Nodes will be automatically activated or disabled depending on their connections (a mandatory link to a disabled node will disable the current one).
You will often wonder why a node will not be activated. This tool helps to determine when and why by "playing" activation rules sequences step-by-step and displaying nodes which activate or deactivate at each step.
"""
# Load some meta informations
from capsul.info import __version__ as _version
from capsul.info import NAME as _application_name
from capsul.info import ORGANISATION as _organisation_name
def __init__(self, pipeline_path, record_file=None, *args, **kwargs):
""" Method to initialize the ActivationInspectorApp class.
Parameters
----------
pipeline_path: str (mandatory)
the name of the pipeline we want to load.
record_file: str (optional)
a file where the pipeline activation steps are stored.
"""
# Inhetritance
super(ActivationInspectorApp, self).__init__(*args, **kwargs)
# Load the pipeline
self.pipeline = get_process_instance(pipeline_path)
# Initialize the application
self.record_file = record_file
self.window = None
self.init_window()
def init_window(self):
""" Method to initialize the main window.
"""
# First set some meta informations
self.setApplicationName(self._application_name)
self.setOrganizationName(self._organisation_name)
self.setApplicationVersion(self._version)
# Get the user interface description from capsul resources
ui_file = os.path.join(
os.path.dirname(__file__), "activation_inspector.ui")
#ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui")
# Create and show the activation/pipeline/controller windows
self.pipeline_window = PipelineDevelopperView(self.pipeline, show_sub_pipelines=True)
self.controller_window = ScrollControllerWidget(self.pipeline,live=True)
self.activation_window = ActivationInspector(
self.pipeline, ui_file, self.record_file,
developper_view=self.pipeline_window)
self.pipeline_window.show()
self.activation_window.show()
self.controller_window.show()
return True
class ActivationInspectorApp(Application):
""" ActiovationInspector Application.
"""
# Load some meta informations
from capsul.info import __version__ as _version
from capsul.info import NAME as _application_name
from capsul.info import ORGANISATION as _organisation_name
def __init__(self, pipeline_path, record_file=None, *args, **kwargs):
""" Method to initialize the ActivationInspectorApp class.
Parameters
----------
pipeline_path: str (mandatory)
the name of the pipeline we want to load.
record_file: str (optional)
a file where the pipeline activation steps are stored.
"""
# Inhetritance
super(ActivationInspectorApp, self).__init__(*args, **kwargs)
# Load the pipeline
self.pipeline = get_process_instance(pipeline_path)
# Initialize the application
self.record_file = record_file
self.window = None
self.init_window()
def init_window(self):
""" Method to initialize the main window.
"""
# First set some meta informations
self.setApplicationName(self._application_name)
self.setOrganizationName(self._organisation_name)
self.setApplicationVersion(self._version)
# Get the user interface description from capsul resources
ui_file = os.path.join(
os.path.dirname(__file__), "activation_inspector.ui")
#ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui")
# Create and show the activation/pipeline/controller windows
self.pipeline_window = PipelineDevelopperView(self.pipeline)
self.controller_window = ScrollControllerWidget(self.pipeline,live=True)
self.activation_window = ActivationInspector(
self.pipeline, ui_file, self.record_file,
developper_view=self.pipeline_window)
self.pipeline_window.show()
self.activation_window.show()
self.controller_window.show()
return True
def run_pipeline_io(self, filename):
pipeline = MyPipeline()
from capsul.pipeline import pipeline_tools
pipeline_tools.save_pipeline(pipeline, filename)
pipeline2 = get_process_instance(filename)
pipeline2.workflow_ordered_nodes()
if self.debug:
from soma.qt_gui.qt_backend import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
import sys
app = QtGui.QApplication.instance()
if not app:
app = QtGui.QApplication(sys.argv)
view1 = PipelineDevelopperView(pipeline,
allow_open_controller=True,
enable_edition=True,
show_sub_pipelines=True)
view2 = PipelineDevelopperView(pipeline2,
allow_open_controller=True,
enable_edition=True,
show_sub_pipelines=True)
view1.show()
view2.show()
app.exec_()
self.assertTrue(
pipeline2.workflow_repr
in ("constant->node1->node2", "node1->constant->node2"),
'%s not in ("constant->node1->node2", "node1->constant->node2")' %
pipeline2.workflow_repr)
d1 = pipeline_tools.dump_pipeline_state_as_dict(pipeline)
d2 = pipeline_tools.dump_pipeline_state_as_dict(pipeline2)
self.assertEqual(d1, d2)
def onChangeViewClicked(self):
""" Event to switch between simple and full pipeline views.
"""
# Check if a pipeline has been loaded
if self._is_active_pipeline_valid():
# Check the current display mode
# Case PipelineDevelopperView
if isinstance(self.ui.display.currentWidget(),
PipelineDevelopperView):
# Switch to PipelineUserView display mode
widget = PipelineUserView(self.pipeline)
self._insert_widget_in_tab(widget)
# Case PipelineUserView
else:
# Switch to PipelineDevelopperView display mode
widget = PipelineDevelopperView(self.pipeline)
self._insert_widget_in_tab(widget)
# No pipeline loaded error
else:
logger.error("No active pipeline selected. "
"Have you forgotten to click the load pipeline "
"button?")
def onLoadSubPipelineClicked(self, name, sub_pipeline, modifiers):
""" Event to load and display a sub pipeline.
"""
# Store the pipeline instance in class parameters
self.pipeline = self.pipeline.nodes[name].process
# Create the controller widget associated to the sub pipeline
# controller: if the sub pipeline is a ProcessIteration, disable
# the correspondind controller widget since this pipeline is generated
# on the fly an is not directly synchronized with the rest of the
# pipeline.
is_iterative_pipeline = False
if isinstance(self.pipeline, ProcessIteration):
is_iterative_pipeline = True
pipeline_widget = ScrollControllerWidget(
self.pipeline,
live=True,
select_controls="inputs",
disable_controller_widget=is_iterative_pipeline)
self.ui.dockWidgetParameters.setWidget(pipeline_widget)
# Store the sub pipeline instance
self.pipelines[self.pipeline.name] = (self.pipeline, pipeline_widget)
# Create the widget
widget = PipelineDevelopperView(self.pipeline)
self._insert_widget_in_tab(widget)
# Connect the subpipeline clicked signal to the
# onLoadSubPipelineClicked slot
widget.subpipeline_clicked.connect(self.onLoadSubPipelineClicked)
def onLoadClicked(self):
""" Event to load and display a pipeline.
"""
# Get the pipeline instance from its string description
item = self.ui.menu_treectrl.currentItem()
description_list = [
str(x) for x in [item.text(1), item.text(0)] if x != ""
]
process_description = ".".join(description_list)
self.pipeline = get_process_instance(process_description)
# Create the controller widget associated to the pipeline
# controller
pipeline_widget = ScrollControllerWidget(self.pipeline,
live=True,
select_controls="inputs")
self.ui.dockWidgetParameters.setWidget(pipeline_widget)
# Add observer to refresh the run button
controller_widget = pipeline_widget.controller_widget
for control_name, control \
in six.iteritems(controller_widget._controls):
# Unpack the control item
trait, control_class, control_instance, control_label = control
# Add the new callback
control_class.add_callback(self.onRunStatus, control_instance)
# Refresh manually the run button status the first time
self.onRunStatus()
# Store the pipeline documentation root path
self.path_to_pipeline_doc[self.pipeline.id] = item.text(2)
# Store the pipeline instance
self.pipelines[self.pipeline.name] = (self.pipeline, pipeline_widget)
# Create the widget
widget = PipelineDevelopperView(self.pipeline)
self._insert_widget_in_tab(widget)
# Connect the subpipeline clicked signal to the
# onLoadSubPipelineClicked slot
widget.subpipeline_clicked.connect(self.onLoadSubPipelineClicked)
def init_window(self):
""" Method to initialize the main window.
"""
# First set some meta informations
self.setApplicationName(self._application_name)
self.setOrganizationName(self._organisation_name)
self.setApplicationVersion(self._version)
# Get the user interface description from capsul resources
ui_file = os.path.join(
os.path.dirname(__file__), "activation_inspector.ui")
#ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui")
# Create and show the activation/pipeline/controller windows
self.pipeline_window = PipelineDevelopperView(self.pipeline)
self.controller_window = ScrollControllerWidget(self.pipeline,live=True)
self.activation_window = ActivationInspector(
self.pipeline, ui_file, self.record_file,
developper_view=self.pipeline_window)
self.pipeline_window.show()
self.activation_window.show()
self.controller_window.show()
return True
def pilot_bet(enable_display=False):
"""
BET
===
Brain extraction with FSL.
Start to import required modules:
"""
import os
from mmutils.toy_datasets import get_sample_data
from capsul.study_config import StudyConfig
from capsul.process import get_process_instance
"""
Study configuration
-------------------
We first define the working directory and guarantee this folder exists on
the file system:
"""
working_dir = "/volatile/nsap/catalogue/pclinfmri/fsl_bet"
if not os.path.isdir(working_dir):
os.makedirs(working_dir)
"""
And then define the study configuration:
"""
study_config = StudyConfig(
modules=["MatlabConfig", "SPMConfig", "FSLConfig", "NipypeConfig"],
use_smart_caching=False,
fsl_config="/etc/fsl/4.1/fsl.sh",
use_fsl=True,
output_directory=working_dir,
number_of_cpus=1,
generate_logging=True,
use_scheduler=True)
"""
Load the toy dataset
--------------------
To do so, we use the get_sample_data function to download the toy
dataset on the local file system (here localizer data):
"""
toy_dataset = get_sample_data("localizer")
"""
The toy_dataset is an Enum structure with some specific elements of
interest:
* fmri: the functional volume.
* anat: the structural volume.
* TR: the repetition time.
Processing definition
---------------------
First create the
:ref:`slice timing pipeline <clinfmri.preproc.FslBet>` that
define the different step of the processings:
"""
pipeline = get_process_instance("clinfmri.utils.fsl_bet.xml")
print pipeline.get_input_spec()
"""
It is possible to display the pipeline.
"""
if enable_display:
import sys
from PySide import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication(sys.argv)
view = PipelineDevelopperView(pipeline)
view.show()
app.exec_()
"""
Now we need now to parametrize this pipeline:
"""
pipeline.input_image_file = toy_dataset.anat
pipeline.generate_binary_mask = True
pipeline.bet_threshold = 0.5
"""
The pipeline is now ready to be run:
"""
study_config.run(pipeline, executer_qc_nodes=False, verbose=1)
"""
Results
-------
Finally, we print the pipeline outputs:
"""
print("\nOUTPUTS\n")
for trait_name, trait_value in pipeline.get_outputs().items():
print("{0}: {1}".format(trait_name, trait_value))
def pilot_new_segment(enable_display=False):
"""
New Segment
===========
Unifed SPM segmentation: segments, bias corrects and spatially normalises.
Start to import required modules:
"""
import os
from mmutils.toy_datasets import get_sample_data
from capsul.study_config import StudyConfig
from capsul.process import get_process_instance
"""
Study configuration
-------------------
We first define the working directory and guarantee this folder exists on
the file system:
"""
working_dir = "/volatile/nsap/catalogue/pclinfmri/spm_newsegment"
if not os.path.isdir(working_dir):
os.makedirs(working_dir)
"""
And then define the study configuration:
"""
study_config = StudyConfig(
modules=["MatlabConfig", "SPMConfig", "FSLConfig", "NipypeConfig"],
use_smart_caching=False,
matlab_exec="/neurospin/local/bin/matlab",
use_matlab=True,
spm_directory="/i2bm/local/spm8",
use_spm=True,
output_directory=working_dir,
number_of_cpus=1,
generate_logging=True,
use_scheduler=True)
"""
Load the toy dataset
--------------------
To do so, we use the get_sample_data function to download the toy
dataset on the local file system (here localizer data):
"""
toy_dataset = get_sample_data("localizer")
template_dataset = get_sample_data("mni_1mm")
"""
The toy_dataset is an Enum structure with some specific elements of
interest:
* fmri: the functional volume.
* anat: the structural volume.
* TR: the repetition time.
Processing definition
---------------------
First create the
:ref:`slice timing pipeline <clinfmri.utils.SpmNewSegment>`
that define the different step of the processings:
"""
pipeline = get_process_instance("clinfmri.utils.spm_new_segment.xml")
print pipeline.get_input_spec()
"""
It is possible to display the pipeline.
"""
if enable_display:
import sys
from PySide import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication(sys.argv)
view = PipelineDevelopperView(pipeline)
view.show()
app.exec_()
"""
Now we need now to parametrize this pipeline:
"""
pipeline.channel_files = [toy_dataset.mean]
pipeline.reference_volume = template_dataset.brain
"""
The pipeline is now ready to be run:
"""
study_config.run(pipeline, executer_qc_nodes=False, verbose=1)
"""
Results
-------
Finally, we print the pipeline outputs:
"""
print("\nOUTPUTS\n")
for trait_name, trait_value in pipeline.get_outputs().items():
print("{0}: {1}".format(trait_name, trait_value))
def pilot_qa_fmri():
"""
Imports
-------
This code needs 'capsul' and 'mmutils' package in order to instanciate and
execute the pipeline and to get a toy dataset.
These packages are available in the 'neurospin' source list or in pypi.
"""
# Capsul import
from capsul.study_config.study_config import StudyConfig
from capsul.process.loader import get_process_instance
# Mmutils import
from mmutils.toy_datasets import get_sample_data
"""
Parameters
----------
The 'pipeline_name' parameter contains the location of the pipeline XML
description that will perform the DICOMs conversion, and the 'outdir' the
location of the pipeline's results: in this case a temporary directory.
"""
pipeline_name = "mmqa.fmri.fmri_quality_assurance_bbox.xml"
outdir = tempfile.mkdtemp()
"""
Capsul configuration
--------------------
A 'StudyConfig' has to be instantiated in order to execute the pipeline
properly. It enables us to define the results directory through the
'output_directory' attribute, the number of CPUs to be used through the
'number_of_cpus' attributes, and to specify that we want a log of the
processing step through the 'generate_logging'. The 'use_scheduler'
must be set to True if more than 1 CPU is used.
"""
study_config = StudyConfig(number_of_cpus=1,
generate_logging=True,
use_scheduler=True,
output_directory=outdir)
"""
Get the toy dataset
-------------------
The toy dataset is composed of a functional image that is downloaded
if it is necessary throught the 'get_sample_data' function and exported
locally.
"""
localizer_dataset = get_sample_data("localizer_extra")
"""
Pipeline definition
-------------------
The pipeline XML description is first imported throught the
'get_process_instance' method, and the resulting pipeline instance is
parametrized: in this example we decided to set the date in the converted
file name and we set two DICOM directories to be converted in Nifti
format.
"""
pipeline = get_process_instance(pipeline_name)
pipeline.image_file = localizer_dataset.fmri
pipeline.repetition_time = 2.0
pipeline.exclude_volume = []
pipeline.roi_size = 21
pipeline.score_file = os.path.join(outdir, "scores.json")
"""
Pipeline representation
-----------------------
By executing this block of code, a pipeline representation can be
displayed. This representation is composed of boxes connected to each
other.
"""
if 0:
from capsul.qt_gui.widgets import PipelineDevelopperView
from PySide import QtGui
app = QtGui.QApplication(sys.argv)
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
"""
Pipeline execution
------------------
Finally the pipeline is eecuted in the defined 'study_config'.
"""
study_config.run(pipeline)
"""
Access the result
-----------------
Display the computed scores
"""
scores_file = pipeline.scores_file
with open(scores_file, "r") as _file:
scores = json.load(_file)
for key, value in scores.iteritems():
print "{0} = {1}".format(key, value)
if 0:
def write_state():
state_file_name = '/tmp/state.json'
json.dump(pipeline.pipeline_state(), open(state_file_name,'w'))
print 'Wrote', state_file_name
import sys
#from PySide import QtGui
from soma.qt_gui import qt_backend
qt_backend.set_qt_backend('PyQt4')
from soma.qt_gui.qt_backend import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
#from capsul.qt_gui.widgets import PipelineUserView
from capsul.process import get_process_instance
app = QtGui.QApplication(sys.argv)
pipeline = get_process_instance(MainTestPipeline)
pipeline.on_trait_change(write_state,'selection_changed')
view1 = PipelineDevelopperView(pipeline, show_sub_pipelines=True, allow_open_controller=True)
view1.add_embedded_subpipeline('switch_pipeline', scale=0.7)
view1.add_embedded_subpipeline('way1_1', scale=0.4)
view1.add_embedded_subpipeline('way2_1', scale=0.4)
view1.show()
#view2 = PipelineUserView(pipeline)
#view2.show()
app.exec_()
del view1
#del view2
suite = unittest.TestLoader().loadTestsFromTestCase(TestPipeline)
runtime = unittest.TextTestRunner(verbosity=2).run(suite)
return runtime.wasSuccessful()
if __name__ == "__main__":
test()
if 1:
from PySide import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication(sys.argv)
pipeline = MyPipeline()
pipeline.input_image = ["toto", "tutu", "titi"]
pipeline.dynamic_parameter = [3, 1, 4]
pipeline.other_input = 0
pipeline2 = pipeline.nodes["iterative"].process
pipeline2.scene_scale_factor = 0.5
pipeline.node_position = {'inputs': (50.0, 50.0),
'iterative': (267.0, 56.0),
'outputs': (1124.0, 96.0)}
view1 = PipelineDevelopperView(pipeline, show_sub_pipelines=True,
allow_open_controller=True)
view1.add_embedded_subpipeline('iterative')
view1.show()
app.exec_()
del view1
def pilot_preproc_spm_fmri(enable_display=False):
"""
FMRI preprocessings
===================
Preprocessing with the SPM slice timing and a normalization to a given
template.
Start to import required modules:
"""
import os
from mmutils.toy_datasets import get_sample_data
from capsul.study_config import StudyConfig
from capsul.api import get_process_instance
"""
Study configuration
-------------------
We first define the working directory and guarantee this folder exists on
the file system:
"""
working_dir = "/volatile/nsap/catalogue/pclinfmri/fmri_preproc_spm_fmri"
if not os.path.isdir(working_dir):
os.makedirs(working_dir)
"""
Then define the study configuration:
"""
study_config = StudyConfig(
modules=["MatlabConfig", "SPMConfig", "FSLConfig", "NipypeConfig"],
use_smart_caching=False,
fsl_config="/etc/fsl/4.1/fsl.sh",
use_fsl=True,
matlab_exec="/neurospin/local/bin/matlab",
use_matlab=True,
spm_directory="/i2bm/local/spm8",
use_spm=True,
output_directory=working_dir,
number_of_cpus=1,
generate_logging=True,
use_scheduler=True,)
"""
Load the toy dataset
--------------------
To do so, we use the get_sample_data function to download the toy
dataset on the local file system (here localizer data):
"""
toy_dataset = get_sample_data("localizer")
template_dataset = get_sample_data("mni_1mm")
"""
The toy_dataset is an Enum structure with some specific elements of
interest:
* fmri: the functional volume.
* anat: the structural volume.
* TR: the repetition time.
Processing definition
---------------------
First create the
:ref:`slice timing pipeline <clinfmri.preproc.FmriPreproc>` that
define the different step of the processings:
"""
pipeline = get_process_instance("clinfmri.preproc.converted_fmri_preproc")
print pipeline.get_input_spec()
"""
Now we need now to parametrize this pipeline:
"""
pipeline.fmri_file = toy_dataset.fmri
pipeline.structural_file = toy_dataset.anat
pipeline.realign_register_to_mean = True
pipeline.select_slicer = "spm"
pipeline.select_normalization = "fmri"
pipeline.template_file = template_dataset.brain
pipeline.force_repetition_time = toy_dataset.TR
pipeline.force_slice_orders = [index + 1 for index in range(40)]
"""
It is possible to display the pipeline.
"""
if enable_display:
import sys
from PySide import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication(sys.argv)
view = PipelineDevelopperView(pipeline)
view.show()
app.exec_()
"""
The pipeline is now ready to be run:
"""
study_config.run(pipeline, executer_qc_nodes=False, verbose=1)
"""
Results
-------
Finally, we print the pipeline outputs:
"""
print("\nOUTPUTS\n")
for trait_name, trait_value in pipeline.get_outputs().items():
print("{0}: {1}".format(trait_name, trait_value))
if __name__ == "__main__":
if '-d' in sys.argv[1:] or '--debug' in sys.argv[1:]:
debug = True
test()
if '-v' in sys.argv[1:] or '--verbose' in sys.argv[1:]:
from soma.qt_gui.qt_backend import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication.instance()
if not app:
app = QtGui.QApplication(sys.argv)
pipeline = MySmallPipeline()
pipeline.files_to_create = ["toto", "tutu", "titi"]
pipeline.output_image = ['toto_out', 'tutu_out', 'tata_out']
pipeline.dynamic_parameter = [3, 1, 4]
pipeline.other_output = [0, 0, 0]
pipeline.other_input = 0
pipeline2 = pipeline.nodes["iterative"].process
pipeline2.scene_scale_factor = 0.5
view1 = PipelineDevelopperView(pipeline, show_sub_pipelines=True,
allow_open_controller=True)
view1.add_embedded_subpipeline('iterative')
view1.auto_dot_node_positions()
view1.show()
app.exec_()
del view1
def pilot_fsl_preproc():
"""
FSL preprocessings
==================
"""
# System import
import os
import sys
import datetime
import PySide.QtGui as QtGui
# CAPSUL import
from capsul.qt_gui.widgets import PipelineDevelopperView
from capsul.study_config.study_config import StudyConfig
from capsul.process.loader import get_process_instance
"""
Study configuration
-------------------
We first define the working directory and guarantee this folder exists on
the file system:
"""
working_dir = "/volatile/nsap/clindmri/fslpreproc"
if not os.path.isdir(working_dir):
os.makedirs(working_dir)
"""
And then define the study configuration (here we activate the smart
caching module that will be able to remember which process has already been
processed):
"""
study_config = StudyConfig(
modules=["SmartCachingConfig", "FSLConfig", "MatlabConfig",
"SPMConfig", "NipypeConfig"],
use_smart_caching=True,
fsl_config="/etc/fsl/4.1/fsl.sh",
use_fsl=True,
output_directory=working_dir)
# Create pipeline
start_time = datetime.datetime.now()
print "Start Pipeline Creation", start_time
pipeline = get_process_instance("clindmri.preproc.fsl_preproc.xml")
print "Done in {0} seconds.".format(datetime.datetime.now() - start_time)
# View pipeline
if 0:
app = QtGui.QApplication(sys.argv)
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
del view1
# Set pipeline input parameters
pipeline.dfile = "/volatile/imagen/dmritest/000000022453/DTI/000000022453s011a1001.nii.gz"
pipeline.bvalfile = "/volatile/imagen/dmritest/000000022453/DTI/000000022453s011a1001.bval"
pipeline.bvecfile = "/volatile/imagen/dmritest/000000022453/DTI/000000022453s011a1001.bvec"
print "Done in {0} seconds.".format(datetime.datetime.now() - start_time)
#print pipeline.nodes["eddy"].process._nipype_interface.inputs
print pipeline.nodes["eddy"].process._nipype_interface.cmdline
# Execute the pipeline in the configured study
study_config.run(pipeline, verbose=1)
self.assertFalse(self.pipeline.nodes["way22"].activated)
self.pipeline.workflow_ordered_nodes()
self.assertEqual(self.pipeline.workflow_repr, "way11->way12")
def test():
""" Function to execute unitest
"""
suite = unittest.TestLoader().loadTestsFromTestCase(TestPipeline)
runtime = unittest.TextTestRunner(verbosity=2).run(suite)
return runtime.wasSuccessful()
if __name__ == "__main__":
print("RETURNCODE: ", test())
if 1:
import sys
from soma.qt_gui.qt_backend import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication.instance()
if not app:
app = QtGui.QApplication(sys.argv)
pipeline = MyPipeline()
setattr(pipeline.nodes_activation, "way11", False)
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
del view1
if len(sys.argv) > 1 and '-v' in sys.argv[1:] \
or '--verbose' in sys.argv[1:]:
import sys
from soma.qt_gui import qt_backend
qt_backend.set_qt_backend('PyQt4')
from soma.qt_gui.qt_backend import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
#app = QtGui.QApplication(sys.argv)
#pipeline = MyCompositePipeline()
#view1 = PipelineDevelopperView(pipeline, show_sub_pipelines=True)
#view1.show()
#app.exec_()
#del view1
from capsul.qt_gui.widgets import PipelineUserView
if QtGui.QApplication.instance() is not None:
has_qapp = True
app = QtGui.QApplication.instance()
else:
has_qapp = False
app = QtGui.QApplication(sys.argv)
pipeline = MyCompositePipeline()
view1 = PipelineDevelopperView(pipeline, show_sub_pipelines=True)
view1.show()
view2 = PipelineUserView(pipeline)
view2.show()
if not has_qapp:
app.exec_()
del view1
def pilot_bet(enable_display=False):
"""
Brain extractio Tool
====================
"""
import os
from mmutils.toy_datasets import get_sample_data
from capsul.study_config import StudyConfig
from capsul.api import get_process_instance
working_dir = "/volatile/nsap/catalogue/pclinfmri/fmri_bet"
if not os.path.isdir(working_dir):
os.makedirs(working_dir)
"""
Then define the study configuration:
"""
study_config = StudyConfig(
modules=["MatlabConfig", "SPMConfig", "FSLConfig", "NipypeConfig"],
use_smart_caching=False,
fsl_config="/etc/fsl/4.1/fsl.sh",
use_fsl=True,
matlab_exec="/neurospin/local/bin/matlab",
use_matlab=False,
spm_directory="/i2bm/local/spm8",
use_spm=False,
output_directory=working_dir)
"""
Load the toy dataset
--------------------
To do so, we use the get_sample_data function to download the toy
dataset on the local file system (here localizer data):
"""
template_dataset = get_sample_data("mni_1mm")
"""
Processing definition
---------------------
"""
pipeline = get_process_instance("clinfmri.utils.converted_fsl_bet")
print pipeline.get_input_spec()
"""
Now we need now to parametrize this pipeline:
"""
pipeline.input_image_file = template_dataset.brain
pipeline.generate_binary_mask = True
"""
It is possible to display the pipeline.
"""
if enable_display:
import sys
from PySide import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication(sys.argv)
view = PipelineDevelopperView(pipeline)
view.show()
app.exec_()
"""
The pipeline is now ready to be run:
"""
study_config.run(pipeline, executer_qc_nodes=False, verbose=1)
"""
Results
-------
Finally, we print the pipeline outputs:
"""
print("\nOUTPUTS\n")
for trait_name, trait_value in pipeline.get_outputs().items():
print("{0}: {1}".format(trait_name, trait_value))
def pilot_dcm2nii():
"""
Imports
-------
This code needs 'capsul' and 'mmutils' package in order to instanciate and
execute the pipeline and to get a toy dataset.
These packages are available in the 'neurospin' source list or in pypi.
"""
import os
import sys
import shutil
import tempfile
from capsul.study_config.study_config import StudyConfig
from capsul.process.loader import get_process_instance
from mmutils.toy_datasets import get_sample_data
"""
Parameters
----------
The 'pipeline_name' parameter contains the location of the pipeline XML
description that will perform the DICOMs conversion, and the 'outdir' the
location of the pipeline's results: in this case a temporary directory.
"""
pipeline_name = "dcmio.dcmconverter.dcm_to_nii.xml"
outdir = tempfile.mkdtemp()
"""
Capsul configuration
--------------------
A 'StudyConfig' has to be instantiated in order to execute the pipeline
properly. It enables us to define the results directory through the
'output_directory' attribute, the number of CPUs to be used through the
'number_of_cpus' attributes, and to specify that we want a log of the
processing step through the 'generate_logging'. The 'use_scheduler'
must be set to True if more than 1 CPU is used.
"""
study_config = StudyConfig(modules=[],
output_directory=outdir,
number_of_cpus=1,
generate_logging=True,
use_scheduler=True)
"""
Get the toy dataset
-------------------
The toy dataset is composed of a 3D heart dicom image that is downloaded
if it is necessary throught the 'get_sample_data' function and exported
locally in a 'heart.dcm' file.
"""
dicom_dataset = get_sample_data("dicom")
dcmfolder = os.path.join(outdir, "dicom")
if not os.path.isdir(dcmfolder):
os.makedirs(dcmfolder)
shutil.copy(dicom_dataset.barre, os.path.join(dcmfolder, "heart.dcm"))
"""
Pipeline definition
-------------------
The pipeline XML description is first imported throught the
'get_process_instance' method, and the resulting pipeline instance is
parametrized: in this example we decided to set the date in the converted
file name and we set two DICOM directories to be converted in Nifti
format.
"""
pipeline = get_process_instance(pipeline_name)
pipeline.date_in_filename = True
pipeline.dicom_directories = [dcmfolder, dcmfolder]
pipeline.additional_informations = [[("Provided by", "Neurospin@2015")],
[("Provided by", "Neurospin@2015"),
("TR", "1500")]]
pipeline.dcm_tags = [("TR", [("0x0018", "0x0080")]),
("TE", [("0x0018", "0x0081")])]
"""
Pipeline representation
-----------------------
By executing this block of code, a pipeline representation can be
displayed. This representation is composed of boxes connected to each
other.
"""
if 0:
from capsul.qt_gui.widgets import PipelineDevelopperView
from PySide import QtGui
app = QtGui.QApplication(sys.argv)
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
"""
Pipeline execution
------------------
Finally the pipeline is eecuted in the defined 'study_config'.
"""
study_config.run(pipeline)
"""
Access the result
-----------------
The 'nibabel' package is used to load the generated images. We display the
numpy array shape and the stored repetiton and echo times: in order
to load the 'descrip' image field we use the 'json' package.
"""
import json
import copy
import nibabel
generated_images = pipeline.filled_converted_files
for fnames in generated_images:
print(">>>", fnames, "...")
im = nibabel.load(fnames[0])
print("shape=", im.get_data().shape)
header = im.get_header()
a = str(header["descrip"])
a = a.strip()
description = json.loads(copy.deepcopy(a))
print("TE=", description["TE"])
print("TR=", description["TR"])
print("Provided by=", description["Provided by"])
def pilot_gdti_estimation():
"""
Generalized diffusion tensor estimation
=======================================
"""
# System import
import os
import sys
import datetime
import PySide.QtGui as QtGui
# CAPSUL import
from capsul.qt_gui.widgets import PipelineDevelopperView
from capsul.study_config.study_config import StudyConfig
from capsul.process.loader import get_process_instance
"""
Study configuration
-------------------
We first define the working directory and guarantee this folder exists on
the file system:
"""
working_dir = "/volatile/nsap/clindmri/gdti"
if not os.path.isdir(working_dir):
os.makedirs(working_dir)
"""
And then define the study configuration (here we activate the smart
caching module that will be able to remember which process has already been
processed):
"""
study_config = StudyConfig(
modules=["SmartCachingConfig"],
use_smart_caching=True,
output_directory=working_dir)
# Create pipeline
start_time = datetime.datetime.now()
print "Start Pipeline Creation", start_time
pipeline = get_process_instance("clindmri.estimation.gdti.xml")
print "Done in {0} seconds.".format(datetime.datetime.now() - start_time)
# View pipeline
if 0:
app = QtGui.QApplication(sys.argv)
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
del view1
# Set pipeline input parameters
pipeline.dfile = "/volatile/imagen/dmritest/000000022453/DTI/000000022453s011a1001.nii.gz"
pipeline.bvalfile = "/volatile/imagen/dmritest/000000022453/DTI/000000022453s011a1001.bval"
pipeline.bvecfile = "/volatile/imagen/dmritest/000000022453/DTI/000000022453s011a1001.bvec"
pipeline.order = 2
pipeline.odf = False
print "Done in {0} seconds.".format(datetime.datetime.now() - start_time)
# Execute the pipeline in the configured study
study_config.run(pipeline, verbose=1)
def pilot_qa_fmri():
"""
Imports
-------
This code needs 'capsul' and 'mmutils' package in order to instanciate and
execute the pipeline and to get a toy dataset.
These packages are available in the 'neurospin' source list or in pypi.
"""
# Capsul import
from capsul.study_config.study_config import StudyConfig
from capsul.process.loader import get_process_instance
# Mmutils import
from mmutils.toy_datasets import get_sample_data
"""
Parameters
----------
The 'pipeline_name' parameter contains the location of the pipeline XML
description that will perform the DICOMs conversion, and the 'outdir' the
location of the pipeline's results: in this case a temporary directory.
"""
pipeline_name = "mmqa.fmri.fmri_quality_assurance_bbox.xml"
outdir = tempfile.mkdtemp()
"""
Capsul configuration
--------------------
A 'StudyConfig' has to be instantiated in order to execute the pipeline
properly. It enables us to define the results directory through the
'output_directory' attribute, the number of CPUs to be used through the
'number_of_cpus' attributes, and to specify that we want a log of the
processing step through the 'generate_logging'. The 'use_scheduler'
must be set to True if more than 1 CPU is used.
"""
study_config = StudyConfig(
number_of_cpus=1,
generate_logging=True,
use_scheduler=True,
output_directory=outdir)
"""
Get the toy dataset
-------------------
The toy dataset is composed of a functional image that is downloaded
if it is necessary throught the 'get_sample_data' function and exported
locally.
"""
localizer_dataset = get_sample_data("localizer_extra")
"""
Pipeline definition
-------------------
The pipeline XML description is first imported throught the
'get_process_instance' method, and the resulting pipeline instance is
parametrized: in this example we decided to set the date in the converted
file name and we set two DICOM directories to be converted in Nifti
format.
"""
pipeline = get_process_instance(pipeline_name)
pipeline.image_file = localizer_dataset.fmri
pipeline.repetition_time = 2.0
pipeline.exclude_volume = []
pipeline.roi_size = 21
pipeline.score_file = os.path.join(outdir, "scores.json")
"""
Pipeline representation
-----------------------
By executing this block of code, a pipeline representation can be
displayed. This representation is composed of boxes connected to each
other.
"""
if 0:
from capsul.qt_gui.widgets import PipelineDevelopperView
from PySide import QtGui
app = QtGui.QApplication(sys.argv)
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
"""
Pipeline execution
------------------
Finally the pipeline is eecuted in the defined 'study_config'.
"""
study_config.run(pipeline)
"""
Access the result
-----------------
Display the computed scores
"""
scores_file = pipeline.scores_file
with open(scores_file, "r") as _file:
scores = json.load(_file)
for key, value in scores.iteritems():
print "{0} = {1}".format(key, value)
app = QtGui.QApplication.instance()
if not app:
app = QtGui.QApplication(sys.argv)
#pipeline = Pipeline1()
#pipeline.main_inputs = ['/dir/file%d' % i for i in range(4)]
#pipeline.left_out = pipeline.main_inputs[2]
#pipeline.subject = 'subject2'
#pipeline.output_directory = '/dir/out_dir'
#view1 = PipelineDevelopperView(pipeline, allow_open_controller=True,
#show_sub_pipelines=True,
#enable_edition=True)
#view1.show()
pipeline2 = PipelineLOO()
pipeline2.main_inputs = ['/dir/file%d' % i for i in range(4)]
pipeline2.left_out = pipeline2.main_inputs[2]
pipeline2.subjects = ['subject%d' % i for i in range(4)]
pipeline2.output_directory = '/dir/out_dir'
wf = pipeline_workflow.workflow_from_pipeline(pipeline2,
create_directories=False)
view2 = PipelineDevelopperView(pipeline2,
allow_open_controller=True,
show_sub_pipelines=True,
enable_edition=True)
view2.show()
app.exec_()
#del view1
del view2
def pilot_dcm2nii():
"""
Imports
-------
This code needs 'capsul' and 'mmutils' package in order to instanciate and
execute the pipeline and to get a toy dataset.
These packages are available in the 'neurospin' source list or in pypi.
"""
import os
import sys
import shutil
import tempfile
from capsul.study_config.study_config import StudyConfig
from capsul.process.loader import get_process_instance
from mmutils.toy_datasets import get_sample_data
"""
Parameters
----------
The 'pipeline_name' parameter contains the location of the pipeline XML
description that will perform the DICOMs conversion, and the 'outdir' the
location of the pipeline's results: in this case a temporary directory.
"""
pipeline_name = "dcmio.dcmconverter.dcm_to_nii.xml"
outdir = tempfile.mkdtemp()
"""
Capsul configuration
--------------------
A 'StudyConfig' has to be instantiated in order to execute the pipeline
properly. It enables us to define the results directory through the
'output_directory' attribute, the number of CPUs to be used through the
'number_of_cpus' attributes, and to specify that we want a log of the
processing step through the 'generate_logging'. The 'use_scheduler'
must be set to True if more than 1 CPU is used.
"""
study_config = StudyConfig(
modules=[],
output_directory=outdir,
number_of_cpus=1,
generate_logging=True,
use_scheduler=True)
"""
Get the toy dataset
-------------------
The toy dataset is composed of a 3D heart dicom image that is downloaded
if it is necessary throught the 'get_sample_data' function and exported
locally in a 'heart.dcm' file.
"""
dicom_dataset = get_sample_data("dicom")
dcmfolder = os.path.join(outdir, "dicom")
if not os.path.isdir(dcmfolder):
os.makedirs(dcmfolder)
shutil.copy(dicom_dataset.barre, os.path.join(dcmfolder, "heart.dcm"))
"""
Pipeline definition
-------------------
The pipeline XML description is first imported throught the
'get_process_instance' method, and the resulting pipeline instance is
parametrized: in this example we decided to set the date in the converted
file name and we set two DICOM directories to be converted in Nifti
format.
"""
pipeline = get_process_instance(pipeline_name)
pipeline.date_in_filename = True
pipeline.dicom_directories = [dcmfolder, dcmfolder]
pipeline.additional_informations = [[("Provided by", "Neurospin@2015")],
[("Provided by", "Neurospin@2015"),
("TR", "1500")]]
pipeline.dcm_tags = [("TR", [("0x0018", "0x0080")]),
("TE", [("0x0018", "0x0081")])]
"""
Pipeline representation
-----------------------
By executing this block of code, a pipeline representation can be
displayed. This representation is composed of boxes connected to each
other.
"""
if 0:
from capsul.qt_gui.widgets import PipelineDevelopperView
from PySide import QtGui
app = QtGui.QApplication(sys.argv)
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
"""
Pipeline execution
------------------
Finally the pipeline is eecuted in the defined 'study_config'.
"""
study_config.run(pipeline)
"""
Access the result
-----------------
The 'nibabel' package is used to load the generated images. We display the
numpy array shape and the stored repetiton and echo times: in order
to load the 'descrip' image field we use the 'json' package.
"""
import json
import copy
import nibabel
generated_images = pipeline.filled_converted_files
for fnames in generated_images:
print(">>>", fnames, "...")
im = nibabel.load(fnames[0])
print("shape=", im.get_data().shape)
header = im.get_header()
a = str(header["descrip"])
a = a.strip()
description = json.loads(copy.deepcopy(a))
print("TE=", description["TE"])
print("TR=", description["TR"])
print("Provided by=", description["Provided by"])
suite = unittest.TestLoader().loadTestsFromTestCase(TestTemporary)
runtime = unittest.TextTestRunner(verbosity=2).run(suite)
return runtime.wasSuccessful()
if __name__ == "__main__":
verbose = False
if len(sys.argv) >= 2 and sys.argv[1] in ('-v', '--verbose'):
verbose = True
print("RETURNCODE: ", test())
if verbose:
import sys
from soma.qt_gui import qt_backend
qt_backend.set_qt_backend('PyQt4')
from soma.qt_gui.qt_backend import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication(sys.argv)
pipeline = DummyPipeline()
pipeline.input = '/tmp/file_in.nii'
pipeline.output = '/tmp/file_out3.nii'
pipeline.nb_outputs = 3
view1 = PipelineDevelopperView(pipeline,
show_sub_pipelines=True,
allow_open_controller=True)
view1.show()
app.exec_()
del view1
"""
Processing definition: create the <clinfmri.preproc.FmriPreproc> that
define the different step of the processings.
"""
pipeline = get_process_instance("clinfmri.preproc.fmri_preproc.xml")
"""
It is possible to display the pipeline.
"""
if args.display:
import sys
from PySide import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication(sys.argv)
view = PipelineDevelopperView(pipeline)
view.show()
app.exec_()
"""
Now to parametrize the pipeline pipeline.
"""
pipeline.fmri_file = funcfile
pipeline.realign_register_to_mean = True
pipeline.select_slicer = args.timings
pipeline.select_normalization = args.normalization
pipeline.force_repetition_time = args.repetition_time
pipeline.force_slice_orders = args.slice_order
pipeline.realign_wrap = [0, 1, 0]
pipeline.realign_write_wrap = [0, 1, 0]
pipeline.ref_slice = args.ref_slice
except: pass
try:
os.unlink(output_name)
except: pass
def test():
""" Function to execute unitest
"""
suite = unittest.TestLoader().loadTestsFromTestCase(TestPipelineWithTemp)
runtime = unittest.TextTestRunner(verbosity=2).run(suite)
return runtime.wasSuccessful()
if __name__ == "__main__":
print "RETURNCODE: ", test()
if 1:
import sys
from soma.qt_gui.qt_backend import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
app = QtGui.QApplication(sys.argv)
pipeline = MyPipeline()
pipeline.input_image = '/data/file.txt'
pipeline.output_image = '/data/output_file.txt'
view1 = PipelineDevelopperView(pipeline)
view1.show()
app.exec_()
del view1
if 0:
def write_state():
state_file_name = '/tmp/state.json'
json.dump(pipeline.pipeline_state(), open(state_file_name,'w'))
print('Wrote', state_file_name)
import sys
#from PySide import QtGui
from soma.qt_gui import qt_backend
qt_backend.set_qt_backend('PyQt4')
from soma.qt_gui.qt_backend import QtGui
from capsul.qt_gui.widgets import PipelineDevelopperView
#from capsul.qt_gui.widgets import PipelineUserView
from capsul.process import get_process_instance
app = QtGui.QApplication(sys.argv)
pipeline = get_process_instance(MainTestPipeline)
pipeline.on_trait_change(write_state,'selection_changed')
view1 = PipelineDevelopperView(pipeline, show_sub_pipelines=True, allow_open_controller=True)
view1.add_embedded_subpipeline('switch_pipeline', scale=0.7)
view1.add_embedded_subpipeline('way1_1', scale=0.4)
view1.add_embedded_subpipeline('way2_1', scale=0.4)
view1.show()
#view2 = PipelineUserView(pipeline)
#view2.show()
app.exec_()
del view1
#del view2
