def fastr_apply_network():
network = fastr.create_network(id="applynetwork")
source_t1 = network.create_source('NiftiImageFileCompressed', id='T1')
source_t2 = network.create_source('NiftiImageFileCompressed', id='T2')
source_t1Gd = network.create_source('NiftiImageFileCompressed', id='T1GD')
source_flair = network.create_source('NiftiImageFileCompressed',
id='FLAIR')
source_model = network.create_source('Model', id='model')
source_config = network.create_source('JsonFile', id='config')
source_brainmask = network.create_source('NiftiImageFileCompressed',
id='MASK')
limit = fastr.core.resourcelimit.ResourceLimit(memory='5G')
apply = network.create_node("glassimaging/SegmentTumor:1.0",
tool_version='1.0',
id='segment',
resources=limit)
source_t1.output >> apply.inputs['t1']
source_t2.output >> apply.inputs['t2']
source_t1Gd.output >> apply.inputs['t1gd']
source_flair.output >> apply.inputs['flair']
source_model.output >> apply.inputs['model']
source_config.output >> apply.inputs['config']
source_brainmask.output >> apply.inputs['brainmask']
sink = network.create_sink('NiftiImageFileCompressed', id='segmentation')
apply.outputs['seg'] >> sink.input
return network
def create_network(self):
self.network = fastr.create_network(id="transformix")
self.MovingImageSource = self.network.create_source('ITKImageFile', id='MovingImage')
self.ParameterMapSource = self.network.create_source('ElastixTransformFile', id='ParameterFile')
self.transformix_node = self.network.create_node('elastix_dev/transformix_dev:4.9-dev-wyke', tool_version='0.2', id='transformix')
self.transformix_node.inputs['image'] = self.MovingImageSource.output
self.transformix_node.inputs['transform'] = self.ParameterMapSource.output
self.outimage = self.network.create_sink('ITKImageFile', id='sink_image')
self.outimage.inputs['input'] = self.transformix_node.outputs['image']
self.network.draw(file_path='transformix.svg')
self.network.dumpf('{}.json'.format(self.network.id), indent=2)
def __init__(self,
label_type,
ensemble=50,
scores='percentages',
parent=None,
features=None,
fastr_plugin='LinearExecution',
name='Example'):
"""
Initialize object.
Parameters
----------
network: fastr network, default None
If you input a network, the evaluate network is added
to the existing network.
"""
if parent is not None:
self.parent = parent
self.network = parent.network
self.mode = 'WORC'
self.name = parent.network.id
self.ensemble = parent.configs[0]['Ensemble']['Use']
else:
self.mode = 'StandAlone'
self.fastr_plugin = fastr_plugin
self.name = 'WORC_Evaluate_' + name
self.network = fastr.create_network(id=self.name)
self.fastr_tmpdir = os.path.join(fastr.config.mounts['tmp'],
self.name)
self.ensemble = ensemble
if features is None and self.mode == 'StandAlone':
raise WORCexceptions.WORCIOError(
'Either features as input or a WORC network is required for the Evaluate network.'
)
self.features = features
self.label_type = label_type
self.create_network()
def create_network_egd():
network = fastr.create_network(id="preprocess_glioma_egd")
source_t1 = network.create_source('NiftiImageFileCompressed', id='T1')
source_t2 = network.create_source('NiftiImageFileCompressed', id='T2')
source_t1Gd = network.create_source('NiftiImageFileCompressed', id='T1GD')
source_flair = network.create_source('NiftiImageFileCompressed',
id='FLAIR')
bet_node = network.create_node('fsl/Bet:5.0.9',
tool_version='0.2',
id='bet')
bet_constant_eye = [True] >> bet_node.inputs['eye_cleanup']
bet_constant_robust = [True] >> bet_node.inputs['robust_estimation']
link_t1_bet = source_t1.output >> bet_node.inputs['image']
link_t2_bet = source_t2.output >> bet_node.inputs['T2_image']
node_resample = network.create_node('custom/resample:0.1',
tool_version='0.1',
id='resample')
link_img_resample = source_t1.output >> node_resample.inputs['image']
link_mask_resample = bet_node.outputs[
'mask_image'] >> node_resample.inputs['mask']
sink_resample = network.create_sink('NiftiImageFileCompressed',
id='resampled_t1')
link_resample_sink = node_resample.outputs[
'image_resampled'] >> sink_resample.input
sink_mask = network.create_sink('NiftiImageFileCompressed', id='bet_mask')
link_mask_sink = node_resample.outputs['mask_resampled'] >> sink_mask.input
source_elastix_params = network.create_source('ElastixParameterFile',
id='parameters')
create_coregister_transform(network, source_t1Gd.output, node_resample,
source_elastix_params, 't1gd')
create_coregister_transform(network, source_t2.output, node_resample,
source_elastix_params, 't2')
create_coregister_transform(network, source_flair.output, node_resample,
source_elastix_params, 'flair')
return network
def create_network(self, nettype):
if nettype == 'pairwise':
# Create the network
self.network = fastr.create_network(id="elastix_pair")
# Create Sources
self.FixedImageSource = self.network.create_source('ITKImageFile',
id='FixedImage')
self.FixedMaskSource = self.network.create_source('ITKImageFile',
id='FixedMask')
self.MovingImageSource = self.network.create_source(
'ITKImageFile', id='MovingImage')
self.MovingMaskSource = self.network.create_source('ITKImageFile',
id='MovingMask')
self.ToTransformSource = self.network.create_source(
'ITKImageFile', id='ToTransform')
self.ParameterMapSource = self.network.create_source(
'ElastixParameterFile', id='ParameterMaps', node_group='par')
# Elastix requires the output folder as a sink
# self.OutputFolderSource = self.network.create_sink('Directory', id_='Out')
# Create Elastix node and links
self.elastix_node = self.network.create_node(
'self.elastix_toolname', tool_version='unknown', id='elastix')
self.elastix_node.inputs[
'fixed_image'] = self.FixedImageSource.output
self.elastix_node.inputs[
'fixed_mask'] = self.FixedMaskSource.output
self.elastix_node.inputs[
'moving_image'] = self.MovingImageSource.output
self.elastix_node.inputs[
'moving_mask'] = self.MovingMaskSource.output
# self.OutputFolderSource.input = self.elastix_node.outputs['directory']
self.link_param = self.network.create_link(
self.ParameterMapSource.output,
self.elastix_node.inputs['parameters'])
self.link_param.collapse = 'par'
# Create Sinks
self.outtrans = self.network.create_sink('ElastixTransformFile',
id='sink_trans')
self.outimage = self.network.create_sink('ITKImageFile',
id='sink_image')
self.outseg = self.network.create_sink('ITKImageFile',
id='sink_seg')
self.outtrans.inputs['input'] = self.elastix_node.outputs[
'transform']
# Transform output image
self.transformix_node = self.network.create_node(
'self.transformix_toolname',
tool_version='unknown',
id='transformix')
self.transformix_node.inputs[
'image'] = self.MovingImageSource.output
self.transformix_node.inputs[
'transform'] = self.elastix_node.outputs['transform'][-1]
self.outimage.inputs['input'] = self.transformix_node.outputs[
'image']
# First change the FinalBSplineInterpolationOrder to 0 for the segmentation
self.changeorder_node = self.network.create_node(
'elastixtools/EditElastixTransformFile:0.1',
tool_version='0.1',
id='editelpara')
self.link_trans = self.network.create_link(
self.elastix_node.outputs['transform'][-1],
self.changeorder_node.inputs['transform'])
# self.link_trans.converge = 0
# self.link_trans.collapse = 'FixedImage'
# self.link_trans.expand = True
# Co[y metadata from image to segmentation as Elastix uses this
self.copymetadata_node = self.network.create_node(
'itktools/0.3.2/CopyMetadata:1.0',
tool_version='1.0',
id='copymetadata')
self.copymetadata_node.inputs[
'source'] = self.MovingImageSource.output
self.copymetadata_node.inputs[
'destination'] = self.ToTransformSource.output
# Then transform the segmentation
self.transformix_node_seg = self.network.create_node(
'self.transformix_toolname',
tool_version='unknown',
id='transformix_seg')
self.transformix_node_seg.inputs[
'image'] = self.copymetadata_node.outputs['output']
self.transformix_node_seg.inputs[
'transform'] = self.changeorder_node.outputs['transform'][-1]
self.outseg.inputs['input'] = self.transformix_node_seg.outputs[
'image']
else:
# Create the network
self.network = fastr.create_network(id="elastix_group")
# Create Sources
self.FixedImageSource = self.network.create_source('ITKImageFile',
id='FixedImage')
self.FixedMaskSource = self.network.create_source('ITKImageFile',
id='FixedMask')
self.ToTransformSource = self.network.create_source(
'ITKImageFile', id='ToTransform')
self.ParameterMapSource = self.network.create_source(
'ElastixParameterFile', id='ParameterMaps', node_group='par')
# Elastix requires the output folder as a sink
# self.OutputFolderSource = self.network.create_sink('Directory', id_='Out')
# Create Elastix node and links
self.elastix_node = self.network.create_node(
'self.elastix_toolname', tool_version='unknown', id='elastix')
self.elastix_node.inputs[
'fixed_image'] = self.FixedImageSource.output
self.elastix_node.inputs[
'fixed_mask'] = self.FixedMaskSource.output
self.elastix_node.inputs[
'moving_image'] = self.FixedImageSource.output
self.elastix_node.inputs[
'moving_mask'] = self.FixedMaskSource.output
# self.OutputFolderSource.input = self.elastix_node.outputs['directory']
self.link_param = self.network.create_link(
self.ParameterMapSource.output,
self.elastix_node.inputs['parameters'])
self.link_param.collapse = 'par'
# Create Sinks
self.outtrans = self.network.create_sink('ElastixTransformFile',
id='sink_trans')
self.outimage = self.network.create_sink('ITKImageFile',
id='sink_image')
self.outseg = self.network.create_sink('ITKImageFile',
id='sink_seg')
self.outtrans.inputs['input'] = self.elastix_node.outputs[
'transform']
# Transform output image
self.transformix_node = self.network.create_node(
'self.transformix_toolname',
tool_version='unknown',
id='transformix')
self.transformix_node.inputs[
'image'] = self.MovingImageSource.output
self.transformix_node.inputs[
'transform'] = self.elastix_node.outputs['transform'][-1]
self.outimage.inputs['input'] = self.transformix_node.outputs[
'image']
# First change the FinalBSplineInterpolationOrder to 0 for the segmentation
self.changeorder_node = self.network.create_node(
'elastixtools/EditElastixTransformFile:0.1',
tool_version='0.1',
id='editelpara')
self.changeorder_node.inputs['set'] = [
"FinalBSplineInterpolationOrder=0"
]
self.link_trans = self.network.create_link(
self.elastix_node.outputs['transform'],
self.changeorder_node.inputs['transform'][-1])
# self.link_trans.converge = 0
# self.link_trans.collapse = 'FixedImage'
# self.link_trans.expand = True
# Co[y metadata from image to segmentation as Elastix uses this
self.copymetadata_node = self.network.create_node(
'itktools/0.3.2/CopyMetadata:1.0',
tool_version='1.0',
id='copymetadata')
self.copymetadata_node.inputs[
'source'] = self.MovingImageSource.output
self.copymetadata_node.inputs[
'destination'] = self.ToTransformSource.output
# Then transform the segmentation
self.transformix_node_seg = self.network.create_node(
'self.transformix_toolname',
tool_version='unknown',
id='transformix_seg')
self.transformix_node_seg.inputs[
'image'] = self.copymetadata_node.outputs['output']
self.transformix_node_seg.inputs[
'transform'] = self.changeorder_node.outputs['transform'][-1]
self.outseg.inputs['input'] = self.transformix_node_seg.outputs[
'image']
def test_combat_fastr():
"""Test ComBat feature harmonization."""
# Check if example data directory exists
example_data_dir = th.find_exampledatadir()
# Check if example data required exists
features = glob.glob(
os.path.join(example_data_dir, 'examplefeatures_Patient*.hdf5'))
if len(features) < 6:
message = 'Too few example features for ComBat testing not found!' +\
'Run the create_example_data script from the WORC exampledata ' +\
'directory!'
raise WORCValueError(message)
elif len(features) > 6:
message = 'Too many example features for ComBat testing not found!' +\
'Run the create_example_data script from the WORC exampledata ' +\
'directory!'
raise WORCValueError(message)
objectlabels = os.path.join(example_data_dir, 'objectlabels.csv')
# Python
config = os.path.join(example_data_dir, 'ComBatConfig_python.ini')
# Create the fastr network
experiment = fastr.create_network('test_ComBat')
source_features = experiment.create_source('HDF5',
id='features_in',
node_group='features')
source_labels = experiment.create_source('PatientInfoFile',
id='labels',
node_group='pctrain')
source_config = experiment.create_source('ParameterFile',
id='config',
node_group='conf')
sink_features = experiment.create_sink('HDF5', id='features_out')
node_combat = experiment.create_node(
'combat/ComBat:1.0',
tool_version='1.0',
id='ComBat',
)
link_combat_1 = experiment.create_link(source_config.output,
node_combat.inputs['config'])
link_combat_2 = experiment.create_link(
source_labels.output, node_combat.inputs['patientclass_train'])
link_combat_1.collapse = 'conf'
link_combat_2.collapse = 'pctrain'
# Mimic using two feature toolboxes
links_Combat1_train = node_combat.inputs['features_train'][
'MR_0'] << source_features.output
links_Combat1_train.collapse = 'features'
links_Combat2_train = node_combat.inputs['features_train'][
'MR_1'] << source_features.output
links_Combat2_train.collapse = 'features'
links_Combat_out_train = sink_features.input << node_combat.outputs[
'features_train_out']
links_Combat_out_train.collapse = 'ComBat'
# Provide source and sink data
source_data = dict()
source_data['features_in'] = features
source_data['labels'] = objectlabels
source_data['config'] = config
sink_data = dict()
sink_data[
'features_out'] = "vfs://output/test_ComBat/ComBat/features_ComBat_{{sample_id}}_{{cardinality}}{{ext}}"
# Execute
experiment.execute(source_data,
sink_data,
execution_plugin='LinearExecution')
# Remove the feature files
for i in glob.glob(os.path.join(example_data_dir,
'*features_ComBat*.hdf5')):
os.remove(i)
def create_network_egd(apply_model=False, segmentation=False):
network = fastr.create_network(id="preprocess_glioma_egd")
source_t1 = network.create_source('NiftiImageFileCompressed', id='T1')
source_t2 = network.create_source('NiftiImageFileCompressed', id='T2')
source_t1Gd = network.create_source('NiftiImageFileCompressed', id='T1GD')
source_flair = network.create_source('NiftiImageFileCompressed',
id='FLAIR')
limit = fastr.core.resourcelimit.ResourceLimit(memory='3G')
bet_node = network.create_node('fsl/Bet:5.0.9',
tool_version='0.2',
id='bet',
resources=limit)
bet_constant_eye = [True] >> bet_node.inputs['eye_cleanup']
bet_constant_robust = [True] >> bet_node.inputs['robust_estimation']
link_t1_bet = source_t1.output >> bet_node.inputs['image']
link_t2_bet = source_t2.output >> bet_node.inputs['T2_image']
node_resample = network.create_node('custom/resample:0.1',
tool_version='0.1',
id='resample',
resources=limit)
link_img_resample = source_t1.output >> node_resample.inputs['image']
link_mask_resample = bet_node.outputs[
'mask_image'] >> node_resample.inputs['mask']
sink_resample = network.create_sink('NiftiImageFileCompressed',
id='resampled_t1')
link_resample_sink = node_resample.outputs[
'image_resampled'] >> sink_resample.input
sink_mask = network.create_sink('NiftiImageFileCompressed', id='bet_mask')
link_mask_sink = node_resample.outputs['mask_resampled'] >> sink_mask.input
source_elastix_params = network.create_source('ElastixParameterFile',
id='parameters')
transform_t1gd = create_coregister_transform(network, source_t1Gd.output,
node_resample,
source_elastix_params, 't1gd')
transform_t2 = create_coregister_transform(network, source_t2.output,
node_resample,
source_elastix_params, 't2')
transform_flair = create_coregister_transform(network, source_flair.output,
node_resample,
source_elastix_params,
'flair')
limit_bias = fastr.core.resourcelimit.ResourceLimit(memory='5G')
node_biasfield = network.create_node('n4/N4:1.6',
tool_version='0.1',
id='biasfield',
resources=limit_bias)
transform_flair.outputs['image'] >> node_biasfield.inputs['image']
node_resample.outputs['mask_resampled'] >> node_biasfield.inputs['mask']
sink_bias_corrected_flair = network.create_sink('NiftiImageFileCompressed',
id='corrected_flair')
link_cast_sink = node_biasfield.outputs[
'image'] >> sink_bias_corrected_flair.input
if apply_model:
source_model = network.create_source('Model', id='MODEL')
source_config = network.create_source('JsonFile', id='MODEL_CONFIG')
apply_model = network.create_node("glassimaging/SegmentTumor:1.0",
tool_version='1.0',
id='segment')
node_resample.outputs['image_resampled'] >> apply_model.inputs['t1']
transform_t2.outputs['image'] >> apply_model.inputs['t2']
transform_t1gd.outputs['image'] >> apply_model.inputs['t1gd']
transform_flair.outputs['image'] >> apply_model.inputs['flair']
source_model.output >> apply_model.inputs['model']
source_config.output >> apply_model.inputs['config']
node_resample.outputs['mask_resampled'] >> apply_model.inputs[
'brainmask']
sink = network.create_sink('NiftiImageFileCompressed',
id='segmentation')
apply_model.outputs['seg'] >> sink.input
if segmentation:
source_elastix_params_seg = network.create_source(
'ElastixParameterFile', id='parameters_seg')
source_seg = network.create_source('NiftiImageFileCompressed',
id='SEG')
source_imseg = network.create_source('NiftiImageFileCompressed',
id='IMSEG')
create_coregister_transform_seg(network, source_imseg.output,
node_resample, source_seg.output,
source_elastix_params_seg, 'seg')
return network