mia_processes.bricks.reports package¶
The bricks and functions to calculate the values needed in the reports and to create the report itself.
Submodules¶
mia_processes.bricks.reports.processes module¶
The report preprocess library of the mia_processes package.
The purpose of this module is to provide bricks and functions to compute necessary values for reporting.
- Contains
- Class
AnatIQMs
BoldIQMs
BoldIQMsPlot
CarpetParcellation
ComputeDVARS
FramewiseDisplacement
PlotSignalROI
Mean_stdDev_calc
Result_collector
Spikes
- Function
art_qi1
art_qi2
cjv
cnr
efc
fber
fuzzy_jaccard
find_peaks
find_spikes
gsr
image_binary_dilation
normalize_mc_params
regress_poly
rpve
snr
snr_dietrich
summary_stats
volume_fraction
wm2max
_AR_est_YW
_flatten_dict
_prepare_mask
_robust_zscore
References
- Atkinson1997
Atkinson et al., Automatic correction of motion artifacts in magnetic resonance images using an entropy focus criterion, IEEE Trans Med Imag 16(6):903-910, 1997. doi:10.1109/42.650886.
- Dietrich2007
Dietrich et al., Measurement of SNRs in MR images: influence of multichannel coils, parallel imaging and reconstruction filters, JMRI 26(2):375–385. 2007. doi:10.1002/jmri.20969.
- Ganzetti2016
Ganzetti et al., Intensity inhomogeneity correction of structural MR images: a data-driven approach to define input algorithm parameters. Front Neuroinform 10:10. 2016. doi:10.3389/fninf.2016.00010.
- Giannelli2010
Giannelli et al., Characterization of Nyquist ghost in EPI-fMRI acquisition sequences implemented on two clinical 1.5 T MR scanner systems: effect of readout bandwidth and echo spacing. J App Clin Med Phy, 11(4). 2010. doi:10.1120/jacmp.v11i4.3237.
- Magnota2006
Magnotta, VA., & Friedman, L., Measurement of signal-to-noise and contrast-to-noise in the fBIRN multicenter imaging study. J Dig Imag 19(2):140-147, 2006. doi:10.1007/s10278-006-0264-x.
- Shehzad2015
Shehzad Z et al., The Preprocessed Connectomes Project Quality Assessment Protocol - a resource for measuring the quality of MRI data, Front. Neurosci. Conference Abstract: Neuroinformatics 2015. doi:10.3389/conf.fnins.2015.91.00047.
- class mia_processes.bricks.reports.processes.AnatIQMs[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Computes the anatomical IQMs
Please, see the complete documentation for the AnatIQMs brick in the mia_processes website
adapted from mriqc
Note
Type ‘AnatIQMs.help()’ for a full description of this process parameters.
Type ‘<AnatIQMs>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<AnatIQMs>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation / instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.processes.BoldIQMs[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Computes the functional IQMs
Please, see the complete documentation for the BoldIQMs brick in the mia_processes website
adapted from mriqc
Note
Type ‘BoldIQMs.help()’ for a full description of this process parameters.
Type ‘<BoldIQMs>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<BoldIQMs>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation / instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.processes.BoldIQMsPlot[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Plot a figure showing the slice-wise signal intensity at the extremes for the identification of spikes, the outliers metric, the DVARS, the FD and the carpetplot.
Note
Type ‘BoldIQMsPlot.help()’ for a full description of this process parameters.
Type ‘<BoldIQMsPlot>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<BoldIQMsPlot>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation/instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. In order not to include an output in the database, this output must be a value of the optional key ‘notInDb’ of the self.outputs dictionary. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.processes.CarpetParcellation[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Dilate the brain mask, remove it from itself then generate the union of the obtained crown mask and the EPI parcellation
Please, see the complete documentation for the CarpetParcellation brick in the mia_processes website
Adapted from niworkflows binary dilatation, niworkflows binary subtraction, mriqc
Note
Type ‘CarpetParcellation.help()’ for a full description of this process parameters.
Type ‘<CarpetParcellation>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<CarpetParcellation>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation/instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. In order not to include an output in the database, this output must be a value of the optional key ‘notInDb’ of the self.outputs dictionary. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.processes.ComputeDVARS[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Computes the DVARS
Please, see the complete documentation for the ComputeDVARS brick in the mia_processes website
adapted from nipype
Note
Type ‘ComputeDVARS.help()’ for a full description of this process parameters.
Type ‘<ComputeDVARS>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<ComputeDVARS>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation/instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. In order not to include an output in the database, this output must be a value of the optional key ‘notInDb’ of the self.outputs dictionary. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.processes.FramewiseDisplacement[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Calculate the FD (framewise displacement) as in [Power2012]
This implementation reproduces the calculation in fsl_motion_outliers
[Power2012] Power et al., Spurious but systematic correlations in functional connectivity MRI networks arise from subject motion, NeuroImage 59(3).
Please, see the complete documentation for the FramewiseDisplacement brick in the mia_processes website
adapted from nipype
Note
Type ‘FramewiseDisplacement.help()’ for a full description of this process parameters.
Type ‘<FramewiseDisplacement>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<FramewiseDisplacement>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation/instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. In order not to include an output in the database, this output must be a value of the optional key ‘notInDb’ of the self.outputs dictionary. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.processes.Mean_stdDev_calc[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Makes the mean and standard deviation of parametric_maps
The rois_files parametric_maps are first resized, if necessary, to the size of the parametric_maps. Next, the parametric_maps and the rois_files are convolved. Finally, the mean and standard deviation are calculated for the corresponding ROIs.
The “PatientName_data/ROI_data/ROI_analysis” directory is created to receive the results. If this directory exists at runtime, it is overwritten.
To work correctly, the database entry for the first element of parametric_maps must have the PatientName tag filled in.
Please, see the complete documentation for the Mean_stdDev_calc brick in the mia_processes website
Note
Type ‘Mean_stdDev_calc.help()’ for a full description of this process parameters.
Type ‘<Mean_stdDev_calc>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<Mean_stdDev_calc>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation/instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. In order not to include an output in the database, this output must be a value of the optional key ‘notInDb’ of the self.outputs dictionary. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.processes.PlotSignalROI[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Plot signals from ROI using a segmentation file with label
Please, see the complete documentation for the PlotSignalROI brick in the mia_processes website
Note
Type ‘PlotSignalROI.help()’ for a full description of this process parameters.
Type ‘<PlotSignalROI>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<PlotSignalROI>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation / instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.processes.Result_collector[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Save a file.xlm with the data collection for a patient
To work correctly, the database entry for the first element of parameter_files must have the “PatientName” tag filled in.
The “PatientName_data/results_aggregation” directory is created to receive the results. If this directory exists at runtime, new results can overwrite old results with the same name.
To work correctly, the name of each file in parameter_files must be exactly like this:
roi
_hemi
_calcul
_param
_contrast
.txt, where:roi: region of interest (ex. ACA)
hemi: hemisphere (ex. L)
calcul: type of calcul (ex. mean)
param: the parameter studied (ex. spmT)
contrast: the type of contrast/effect used (ex. BOLD)
Please, see the complete documentation for the Result_collector brick in the mia_processes website
Note
Type ‘Result_collector.help()’ for a full description of this process parameters.
Type ‘<Result_collector>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<Result_collector>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation/instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. In order not to include an output in the database, this output must be a value of the optional key ‘notInDb’ of the self.outputs dictionary. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.processes.Spikes[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Computes the number of spikes
Please, see the complete documentation for the Spikes brick in the mia_processes website
adapted from mriqc spikes_mask function and mriqc Spikes class
Note
Type ‘Spikes.help()’ for a full description of this process parameters.
Type ‘<Spikes>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<Spikes>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation/instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. In order not to include an output in the database, this output must be a value of the optional key ‘notInDb’ of the self.outputs dictionary. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- mia_processes.bricks.reports.processes.art_qi1(airmask, artmask)[source]¶
Detect artifacts in the image using the method described in [Mortamet2009].
Caculates \(\text{QI}_1\), as the proportion of voxels with intensity corrupted by artifacts normalized by the number of voxels in the background:
\[\text{QI}_1 = \frac{1}{N} \sum\limits_{x\in X_\text{art}} 1\]Lower values are better.
- Parameters
airmask (numpy.ndarray) – input air mask, without artifacts
artmask (numpy.ndarray) – input artifacts mask
- mia_processes.bricks.reports.processes.art_qi2(img, airmask, min_voxels=1000, max_voxels=300000)[source]¶
Calculates \(\text{QI}_2\), based on the goodness-of-fit of a centered \(\chi^2\) distribution onto the intensity distribution of non-artifactual background (within the “hat” mask):
\[\chi^2_n = \frac{2}{(\sigma \sqrt{2})^{2n} \, (n - 1)!}x^{2n - 1}\, e^{-\frac{x}{2}}\]where \(n\) is the number of coil elements.
- Parameters
img (numpy.ndarray) – input data
airmask (numpy.ndarray) – input air mask without artifacts
- mia_processes.bricks.reports.processes.cjv(mu_wm, mu_gm, sigma_wm, sigma_gm)[source]¶
Calculate the CJV, a measure related to SNR and CNR that is presented as a proxy for the INU artifact [Ganzetti2016].
Lower is better.
\[\text{CJV} = \frac{\sigma_\text{WM} + \sigma_\text{GM}}{|\mu_\text{WM} - \mu_\text{GM}|}.\]- Parameters
mu_wm (float) – mean of signal within white-matter mask.
mu_gm (float) – mean of signal within gray-matter mask.
sigma_wm (float) – standard deviation of signal within white-matter mask.
sigma_gm (float) – standard deviation of signal within gray-matter mask.
- Returns
the computed CJV
- mia_processes.bricks.reports.processes.cnr(mu_wm, mu_gm, sigma_air)[source]¶
Calculate the CNR [Magnota2006].
Higher values are better.
\[\text{CNR} = \frac{|\mu_\text{GM} - \mu_\text{WM} |}{\sqrt{\sigma_B^2 + \sigma_\text{WM}^2 + \sigma_\text{GM}^2}}\]where \(\sigma_B\) is the standard deviation of the noise distribution within the air (background) mask.
- Parameters
mu_wm (float) – mean of signal within white-matter mask.
mu_gm (float) – mean of signal within gray-matter mask.
sigma_air (float) – standard deviation of the air surrounding the head (“hat” mask).
- Returns
the computed CNR
- mia_processes.bricks.reports.processes.efc(img, framemask=None)[source]¶
Calculate the EFC [Atkinson1997].
Uses the Shannon entropy of voxel intensities as an indication of ghosting and blurring induced by head motion. A range of low values is better, with EFC = 0 for all the energy concentrated in one pixel.
\[\text{E} = - \sum_{j=1}^N \frac{x_j}{x_\text{max}} \ln \left[\frac{x_j}{x_\text{max}}\right]\]with \(x_\text{max} = \sqrt{\sum_{j=1}^N x^2_j}\).
The original equation is normalized by the maximum entropy, so that the EFC can be compared across images with different dimensions:
\[\text{EFC} = \left( \frac{N}{\sqrt{N}} \, \log{\sqrt{N}^{-1}} \right) \text{E}\]- Parameters
img (numpy.ndarray) – input data
framemask (numpy.ndarray) – a mask of empty voxels inserted after a rotation of data
- mia_processes.bricks.reports.processes.fber(img, headmask, rotmask=None)[source]¶
Calculate the FBER [Shehzad2015], defined as the mean energy of image values within the head relative to outside the head.
Higher values are better.
\[\text{FBER} = \frac{E[|F|^2]}{E[|B|^2]}\]- Parameters
img (numpy.ndarray) – input data
headmask (numpy.ndarray) – a mask of the head (including skull, skin, etc.)
rotmask (numpy.ndarray) – a mask of empty voxels inserted after a rotation of data
- mia_processes.bricks.reports.processes.find_peaks(data)[source]¶
- Parameters
data – a numpy ndarray
- Returns
a list
- mia_processes.bricks.reports.processes.gsr(epi_data, mask, direction='y', ref_file=None, out_file=None)[source]¶
Compute the GSR [Giannelli2010].
- The procedure is as follows:
Create a Nyquist ghost mask by circle-shifting the original mask by \(N/2\).
Rotate by \(N/2\)
Remove the intersection with the original mask
Generate a non-ghost background
Calculate the GSR
Warning
This should be used with EPI images for which the phase encoding direction is known.
- Parameters
epi_data (str) – path to epi file
mask (str) – path to brain mask
direction (str) – the direction of phase encoding (x, y, all)
- Returns
the computed gsr
- mia_processes.bricks.reports.processes.image_binary_dilation(in_mask, radius=2)[source]¶
Dilate the input binary mask.
- Parameters
in_mask (numpy.ndarray) – a 3D binary array
radius (int) – the radius of the ball-shaped footprint for dilation of the mask (optional)
- mia_processes.bricks.reports.processes.normalize_mc_params(params, source)[source]¶
Normalize a single row of motion parameters to the SPM format.
- SPM saves motion parameters as:
x Right-Left (mm)
y Anterior-Posterior (mm)
z Superior-Inferior (mm)
rx Pitch (rad)
ry Roll (rad)
rz Yaw (rad)
- mia_processes.bricks.reports.processes.regress_poly(degree, data, remove_mean=True, axis=- 1, failure_mode='error')[source]¶
Returns data with degree polynomial regressed out. :param bool remove_mean: whether or not demean data (i.e. degree 0), :param int axis: numpy array axes along which regression is performed
- mia_processes.bricks.reports.processes.rpve(pvms, seg)[source]¶
- Computes the rPVeof each tissue class.
\[\text{rPVE}^k = \frac{1}{N} \left[ \sum\limits_{p^k_i \in [0.5, P_{98}]} p^k_i + \sum\limits_{p^k_i \in [P_{2}, 0.5)} 1 - p^k_i \right]\]
- mia_processes.bricks.reports.processes.snr(mu_fg, sigma_fg, n)[source]¶
Calculate the SNR.
The estimation may be provided with only one foreground region in which the noise is computed as follows:
\[\text{SNR} = \frac{\mu_F}{\sigma_F\sqrt{n/(n-1)}}\]- where:
\(\mu_F\) is the mean intensity of the foreground
\(\sigma_F\) is the standard deviation of the same region
- Parameters
mu_fg (float) – mean of foreground.
sigma_fg (float) – standard deviation of foreground.
n (int) – number of voxels in foreground mask.
- Returns
the computed SNR
- mia_processes.bricks.reports.processes.snr_dietrich(mu_fg, mad_air=0.0, sigma_air=1.0)[source]¶
Calculate the SNR.
This must be an air mask around the head, and it should not contain artifacts. The computation is done following the eq. A.12 of [Dietrich2007], which includes a correction factor in the estimation of the standard deviation of air and its Rayleigh distribution:
\[\text{SNR} = \frac{\mu_F}{\sqrt{\frac{2}{4-\pi}}\,\sigma_\text{air}}.\]- Parameters
mu_fg (float) – mean of foreground.
sigma_air (float) – standard deviation of the air surrounding the head (“hat” mask).
- Returns
the computed SNR for the foreground segmentation
- mia_processes.bricks.reports.processes.summary_stats(img, pvms, airmask=None, erode=True)[source]¶
Estimates the mean, the standard deviation, the 95% and the 5% percentiles of each tissue distribution.
Warning
Sometimes (with datasets that have been partially processed), the air mask will be empty. In those cases, the background stats will be zero for the mean, median, percentiles and kurtosis, the sum of voxels in the other remaining labels for
n
, and finally the MAD and the \(\sigma\) will be calculated as:\[\sigma_\text{BG} = \sqrt{\sum \sigma_\text{i}^2}\]
mia_processes.bricks.reports.reporting module¶
The reporting library of the mia_processes package.
The purpose of this module is to provide the reporting bricks necessary to generate automatic report at the end of a pipeline calculation.
- Contains
- Class
ReportAnatMriqc
ReportCO2inhalCvr
ReportFuncMriqc
ReportGroupMriqc
- class mia_processes.bricks.reports.reporting.ReportAnatMriqc[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Generates the report for anatomical data in MRIQC pipeline
Please, see the complete documentation for the ReportAnatMriqc brick in the mia_processes website
Note
Type ‘ReportAnatMriqc.help()’ for a full description of this process parameters.
Type ‘<ReportAnatMriqc>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<ReportAnatMriqc>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation / instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.reporting.ReportCO2inhalCvr[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Generates report for CVR study by CO2 inhalation task
Please, see the complete documentation for the ReportCO2inhalCvr brick in the mia_processes website
Note
Type ‘ReportCO2inhalCvr.help()’ for a full description of this process parameters.
Type ‘<ReportCO2inhalCvr>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<ReportCO2inhalCvr>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation / instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.reporting.ReportFuncMriqc[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Generates the report for functional data in MRIQC pipeline
Please, see the complete documentation for the ReportFuncMriqc brick in the mia_processes website
Note
Type ‘ReportFuncMriqc.help()’ for a full description of this process parameters.
Type ‘<ReportFuncMriqc>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<ReportFuncMriqc>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation / instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.
- class mia_processes.bricks.reports.reporting.ReportGroupMriqc[source]¶
Bases:
populse_mia.user_interface.pipeline_manager.process_mia.ProcessMIA
Generates a group report for mriqc pipelines
Please, see the complete documentation for the ReportGroupMriqc brick in the mia_processes website
Note
Type ‘ReportGroupMriqc.help()’ for a full description of this process parameters.
Type ‘<ReportGroupMriqc>.get_input_spec()’ for a full description of this process input trait types.
Type ‘<ReportGroupMriqc>.get_output_spec()’ for a full description of this process output trait types.
- __init__()[source]¶
Dedicated to the attributes initialisation / instantiation.
The input and output plugs are defined here. The special ‘self.requirement’ attribute (optional) is used to define the third-party products necessary for the running of the brick.
- list_outputs(is_plugged=None)[source]¶
Dedicated to the initialisation step of the brick.
The main objective of this method is to produce the outputs of the bricks (self.outputs) and the associated tags (self.inheritance_dic), if defined here. To work properly this method must return self.make_initResult() object.
- Parameters
is_plugged – the state, linked or not, of the plugs.
- Returns
a dictionary with requirement, outputs and inheritance_dict.