def set_analysis_parameters(self):
subjectname = "sujet02"
groupname = "group1"
test_dir = os.environ.get("BRAINVISA_TESTS_DIR")
if not test_dir:
raise RuntimeError("BRAINVISA_TESTS_DIR is not set")
test_dir = os.path.join(test_dir, "tmp_tests_brainvisa")
filename = os.path.join(test_dir, "data_unprocessed", subjectname, "anatomy", subjectname + ".ima")
subject = Subject(subjectname, groupname, filename)
self.analysis.set_parameters(subject=subject)
from capsul.process import get_process_instance
import_step = get_process_instance("morphologist.capsul.import_t1_mri.ImportT1Mri")
import_step.input = subject.filename
import_step.output = self.analysis.pipeline.process.t1mri
import_step.referential = (
self.analysis.pipeline.process.PrepareSubject_TalairachFromNormalization_source_referential
)
pipeline_tools.create_output_directories(import_step)
self.analysis.clear_results()
def build_pipeline(self):
pipeline = get_process_instance(
'capsul.pipeline.test.test_pipeline.MyPipeline')
pipeline.add_pipeline_step('step1', ['constant'])
pipeline.add_pipeline_step('step2', ['node1'])
pipeline.add_pipeline_step('step3', ['node2'])
return pipeline
def import_data(self, subject):
from capsul.process import get_process_instance
import_step = get_process_instance(
'morphologist.capsul.import_t1_mri.ImportT1Mri')
import_step.input = subject.filename
import_step.output \
= self.pipeline.process.t1mri
import_step.referential = self.pipeline.process. \
PrepareSubject_TalairachFromNormalization_source_referential
pipeline_tools.create_output_directories(import_step)
import_step() # run
return import_step.output
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 controller_widget._controls.iteritems():
# 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__(self, process, iterative_parameters):
super(ProcessIteration, self).__init__()
self.process = get_process_instance(process)
self.regular_parameters = set()
self.iterative_parameters = set(iterative_parameters)
# Check that all iterative parameters are valid process parameters
user_traits = self.process.user_traits()
for parameter in self.iterative_parameters:
if parameter not in user_traits:
raise ValueError('Cannot iterate on parameter %s that is not a parameter of process %s' % (parameter, self.process.id))
# Create iterative process parameters by copying process parameter
# and changing iterative parameters to list
for name, trait in user_traits.iteritems():
if name in iterative_parameters:
self.add_trait(name, List(trait, output=trait.output, optional=trait.optional))
else:
self.regular_parameters.add(name)
self.add_trait(name, trait)
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 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))
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
def morphologist_all(t1file, sid, outdir, study="morphologist", waittime=10,
somaworkflow=False,
spmexec="/i2bm/local/spm8-standalone/run_spm8.sh",
spmdir="/i2bm/local/spm8-standalone"):
""" Performs all the Morphologist steps.
Steps:
1- Ensure image orientation and reorient it if needed (Prepare Subject for
Anatomical Pipeline).
2- Computation of a brain mask (Brain Mask Segmentation).
3- Computation of a mask for each hemisphere (Split Brain Mask).
4- A grey/white classification of each hemisphere to perform "Voxel Based
Morphometry" (Grey White Classification) and spherical triangulation of
cortical hemispheres (Grey White Surface).
5- Spherical triangulation of the external interface of the cortex of one
or two hemispheres (Get Spherical Hemi Surface).
6- Computation of a graph representing the cortical fold topography
(Cortical Fold Graph).
7- Automatic identification of the cortical sulci (Automatic Sulci
Recognition), located in the "sulci" toolbox.
The execution is performed with soma_workflow that has to be installed in
the bv_env environment.
To check the worklow submission, use the 'soma_workflow_gui' command.
If the input 't1file' has no the expected extension, an Exception will
be raised.
If the $outdir/$study/$sid has already been created, an Exception will
be raised.
Parameters
----------
t1file: str (mandatory)
the path to a ".nii.gz" anatomical T1 weighted file.
sid: str (mandatory)
a subject identifier.
outdir: str (mandatory)
the morphologist output files will be written in $outdir/$study/$sid.
study: str (mandatory)
the name of the study.
waittime: float (optional, default 10)
a delay (in seconds) used to check the worflow status.
somaworkflow: bool (optional, default False)
if True use somaworkflow for the execution.
spmexec: str (optional)
the path to the standalone SPM execution file.
spmdir: str (optional)
the standalone SPM directory.
Returns
-------
wffile: str
a file containing the submitted workflow.
wfid: int
the submitted workflow identifier.
wfstatus: str
the submited worflow status afer 'waittime' seconds.
"""
# Check roughly the input file extension
if not t1file.endswith(".nii.gz"):
raise Exception("'{0}' is not a COMPRESSED NIFTI file.".format(t1file))
# Create a configuration for the morphologist study
study_config = StudyConfig(
modules=StudyConfig.default_modules + ["FomConfig", "BrainVISAConfig"])
study_dict = {
"name": "morphologist_fom",
"input_directory": outdir,
"output_directory": outdir,
"input_fom": "morphologist-auto-nonoverlap-1.0",
"output_fom": "morphologist-auto-nonoverlap-1.0",
"shared_fom": "shared-brainvisa-1.0",
"spm_directory": spmdir,
"use_soma_workflow": True,
"use_fom": True,
"spm_standalone": True,
"use_matlab": False,
"volumes_format": "NIFTI gz",
"meshes_format": "GIFTI",
"use_spm": True,
"spm_exec": spmexec,
"study_config.somaworkflow_computing_resource": "localhost",
"somaworkflow_computing_resources_config": {
"localhost": {
}
}
}
study_config.set_study_configuration(study_dict)
# Create the morphologist pipeline
pipeline = get_process_instance(
"morphologist.capsul.morphologist.Morphologist")
morphologist_pipeline = process_with_fom.ProcessWithFom(
pipeline, study_config)
morphologist_pipeline.attributes = dict(
(trait_name, getattr(morphologist_pipeline, trait_name))
for trait_name in morphologist_pipeline.user_traits())
morphologist_pipeline.attributes["center"] = "morphologist"
morphologist_pipeline.attributes["subject"] = sid
morphologist_pipeline.create_completion()
# Create morphologist expected tree
# ToDo: use ImportT1 from axon
subjectdir = os.path.join(outdir, study, sid)
if os.path.isdir(subjectdir):
raise Exception("Folder '{0}' already created.".format(subjectdir))
os.makedirs(os.path.join(
subjectdir, "t1mri", "default_acquisition",
"default_analysis", "folds", "3.1", "default_session_auto"))
os.makedirs(os.path.join(
subjectdir, "t1mri", "default_acquisition",
"registration"))
os.makedirs(os.path.join(
subjectdir, "t1mri", "default_acquisition",
"segmentation", "mesh"))
os.makedirs(os.path.join(
subjectdir, "t1mri", "default_acquisition",
"tmp"))
# Copy T1 file in the morphologist expected location
destfile = os.path.join(subjectdir, "t1mri",
"default_acquisition", sid + ".nii.gz")
shutil.copy(t1file, destfile)
# Create source_referential morphologist expected file
source_referential = {"uuid": str(soma.uuid.Uuid())}
referential_file = os.path.join(
subjectdir, "t1mri", "default_acquisition", "registration",
"RawT1-{0}_default_acquisition.referential".format(sid))
attributes = "attributes = {0}".format(json.dumps(source_referential))
with open(referential_file, "w") as openfile:
openfile.write(attributes)
# Create a worflow from the morphologist pipeline
workflow = Workflow(name="{0} {1}".format(study, sid),
jobs=[])
workflow.root_group = []
# Create the workflow
wf = pipeline_workflow.workflow_from_pipeline(
morphologist_pipeline.process, study_config=study_config)
workflow.add_workflow(wf, as_group="{0}_{1}".format(study, sid))
wffile = os.path.join(subjectdir, "{0}.wf".format(study))
pickle.dump(workflow, open(wffile, "w"))
# Execute the workflow with somaworkflow
if somaworkflow:
controller = WorkflowController()
wfid = controller.submit_workflow(
workflow=workflow, name="{0}_{1}".format(study, sid))
# Return the worflow status after execution
while True:
time.sleep(waittime)
wfstatus = controller.workflow_status(wfid)
if wfstatus not in [
"worklflow_not_started", "workflow_in_progress"]:
break
# Execute the workflow with subprocess
else:
# -> construct the ordered list of commands to be executed
workflow_repr = workflow.to_dict()
graph = Graph()
for job in workflow_repr["jobs"]:
graph.add_node(GraphNode(job, None))
for link in workflow_repr["dependencies"]:
graph.add_link(link[0], link[1])
ordered_nodes = [str(node[0]) for node in graph.topological_sort()]
commands = []
jobs = workflow_repr["serialized_jobs"]
temporaries = workflow_repr["serialized_temporary_paths"]
barriers = workflow_repr["serialized_barriers"]
for index in ordered_nodes:
if index in jobs:
commands.append(jobs[index]["command"])
elif index in barriers:
continue
else:
raise Exception("Unexpected node in workflow.")
# -> Go through all commands
tmpmap = {}
for cmd in commands:
# -> deal with temporary files
for index, item in enumerate(cmd):
if not isinstance(item, basestring):
if str(item) not in tmpmap:
if str(item) in temporaries:
struct = temporaries[str(item)]
name = cmd[2].split(";")[1].split()[-1]
tmppath = os.path.join(
subjectdir, "t1mri", "default_acquisition",
"tmp", str(item) + name + struct["suffix"])
tmpmap[str(item)] = tmppath
else:
raise MorphologistError(
"Can't complete command '{0}'.".format(
cmd))
cmd[index] = tmpmap[str(item)]
# -> execute the command
worker = MorphologistWrapper(cmd)
worker()
if worker.exitcode != 0:
raise MorphologistRuntimeError(
" ".join(worker.cmd), worker.stderr)
wfstatus = "Done"
wfid = "subprocess"
return wffile, wfid, wfstatus
for module_name, module_pipelines in sorted_pipelines.items():
# this docwriter is juste used to manage short names
docwriter = PipelineHelpWriter([], short_names=short_names)
# Where the documentation will be written: a relative path from the
# makefile
short_name = docwriter.get_short_name(module_name)
outdir = os.path.join(base_outdir, short_name, "schema")
if not os.path.isdir(outdir):
os.makedirs(outdir)
# Go through all pipeline
for module_pipeline in module_pipelines:
# Get pipeline instance
pipeline_instance = get_process_instance(module_pipeline)
# Get output files
short_pipeline = docwriter.get_short_name(module_pipeline)
image_name = os.path.join(outdir, short_pipeline + ".png")
pipeline_tools.save_dot_image(
pipeline_instance, image_name, nodesep=0.1, include_io=False,
rankdir='TB')
logger.info("Pipeline '{0}' representation has been written at "
"location '{1}'.".format(module_pipeline,
os.path.abspath(image_name)))
# Just print a summary
logger.info("Summary: '{0}' files written for module '{1}'.".format(
len(module_pipelines), module_name))
use_matlab=False,
use_spm=False,
spm_exec=args.spmbin,
spm_standalone=True,
use_nipype=True,
output_directory=tmp_capsul,
number_of_cpus=1,
generate_logging=True,
use_scheduler=True,
)
"""
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_()
"""
def pilot_preproc():
"""
FMRI preprocessings
===================
"""
# Pilot imports
import os
from caps.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/fmri_preproc"
if not os.path.isdir(working_dir):
os.makedirs(working_dir)
"""
Now we get the pipeline from its definition (xml file)
"""
pipeline = get_process_instance(
"clinfmri.preproc.pipeline.fmri_preproc.xml")
"""
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", "MatlabConfig", "SPMConfig",
"FSLConfig",
"NipypeConfig"],
use_smart_caching=True,
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)
"""
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:
* **??**: ??.
Processing definition
---------------------
First create the
:ref:`slice timing pipeline <pclinfmri.preproc.pipeline.SliceTiming>` that
define the different step of the processings:
"""
pipeline = get_process_instance("pclinfmri.preproc.fmri_preproc.xml")
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 = "none"
pipeline.select_registration = "template"
pipeline.template_file = template_dataset.brain
pipeline.force_repetition_time = toy_dataset.TR
pipeline.force_slice_orders = [index + 1 for index in range(40)]
"""
The pipeline is now ready to be run:
"""
study_config.run(pipeline, executer_qc_nodes=True, 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_smoothing():
"""
Smoothing
=========
"""
# Pilot imports
import os
from caps.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/pclinfmri/spmsmoothing"
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", "MatlabConfig", "SPMConfig",
"NipypeConfig"],
use_smart_caching=True,
matlab_exec="/neurospin/local/bin/matlab",
use_matlab=True,
spm_directory="/i2bm/local/spm8",
use_spm=True,
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):
"""
toy_dataset = get_sample_data("localizer")
"""
The toy_dataset is an Enum structure with some specific elements of
interest:
* **??**: ??.
Processing definition
---------------------
First create the
:ref:`slice timing pipeline <pclinfmri.preproc.pipeline.SliceTiming>` that
define the different step of the processings:
"""
pipeline = get_process_instance("pclinfmri.utils.spm_smoothing.xml")
print pipeline.get_input_spec()
"""
Now we need now to parametrize this pipeline:
"""
pipeline.image_file = toy_dataset.fmri
"""
The pipeline is now ready to be run:
"""
study_config.run(pipeline, executer_qc_nodes=True, 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_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.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/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.fmri_preproc.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.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)]
"""
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 generate_api_doc(self, pipeline, schema):
""" Make autodoc documentation for a pipeline python module
Parameters
----------
pipeline : string
python location of pipeline - e.g 'caps.fmri.PIPELINE'
schema : string
path to the pipeline representation image
Returns
-------
ad : string
contents of API doc
title : string
the fist line of the docstring
"""
# Fiest get the pipeline instance from its string description
pipeline_instance = get_process_instance(pipeline)
# Get the header, ie. the first line of the docstring
# Default title is ''
header = pipeline_instance.__doc__
title = ""
if header:
title = pipeline_instance.__doc__.splitlines()[0]
# Add header to tell us that this documentation must not be edited
ad = ".. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n"
# Generate the page title: name of the pipeline
ad += ":orphan:\n\n"
chap_title = pipeline
ad += (chap_title + "\n" +
self.rst_section_levels[1] * len(chap_title) + "\n\n")
# Generate a bookmark (for cross references)
pipeline_name = pipeline_instance.__class__.__name__
label = pipeline + ":"
ad += "\n.. _{0}\n\n".format(label)
# ad += "\n.. index:: {0}\n\n".format(pipeline_name)
# Add a subtitle
ad += (pipeline_name + "\n" +
self.rst_section_levels[2] * len(pipeline_name) + "\n\n")
# Set the current module
currentmodule = ".".join(pipeline_instance.id.split(".")[:-1])
ad += ".. currentmodule:: {0}\n\n".format(currentmodule)
# Then add the trait description
# It will generate two sections: input and output
ad += pipeline_instance.get_help(returnhelp=True)
# Add schema if generated
if schema:
schama_title = "Pipeline schema"
ad += ("\n" + schama_title + "\n" +
"~" * len(schama_title) + "\n\n")
ad += ".. image:: {0}\n".format(schema)
ad += " :height: 400px\n"
ad += " :align: center\n\n"
return ad, title
# Test the cache mechanism
proxy_process(f=2.5, i=__file__, l=[__file__])
copied_file = os.path.join(self.workspace_dir,
os.path.basename(__file__))
self.assertEqual(
proxy_process.s,
"{{'i': '{0}', 'l': ['{0}'], 'f': 2.5}}".format(copied_file))
if 0:
# Configure the environment
study_config = StudyConfig(modules=["FSLConfig"],
fsl_config="/etc/fsl/4.1/fsl.sh")
# Create a process instance
ifname = "/home/ag239446/.local/share/nsap/t1_localizer.nii.gz"
instance = get_process_instance("nipype.interfaces.fsl.Merge")
# Create a decorated instance
dec_instance = mem.cache(instance)
print dec_instance
print dec_instance.__doc__
# Set parameters
dec_instance.in_files = [ifname, ifname]
dec_instance.dimension = "t"
dec_instance.output_type = "NIFTI_GZ"
dec_instance.set_output_directory("/home/ag239446/tmp/")
# Test the cache mechanism
result = dec_instance()
print dec_instance._merged_file
# this docwriter is juste used to manage short names
docwriter = PipelineHelpWriter([], short_names=short_names)
# Where the documentation will be written: a relative path from the
# makefile
short_name = docwriter.get_short_name(module_name)
outdir = os.path.join(base_outdir, short_name, "schema")
if not os.path.isdir(outdir):
os.makedirs(outdir)
# Go through all pipeline
for module_pipeline in module_pipelines:
# Get pipeline instance
pipeline_instance = get_process_instance(module_pipeline)
# Get output files
short_pipeline = docwriter.get_short_name(module_pipeline)
image_name = os.path.join(outdir, short_pipeline + ".png")
pipeline_tools.save_dot_image(pipeline_instance,
image_name,
nodesep=0.1,
include_io=False,
rankdir='TB')
logger.info("Pipeline '{0}' representation has been written at "
"location '{1}'.".format(module_pipeline,
os.path.abspath(image_name)))
# Just print a summary
logger.info("Summary: '{0}' files written for module '{1}'.".format(
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
