diff --git a/nipype/interfaces/freesurfer/__init__.py b/nipype/interfaces/freesurfer/__init__.py index 705cf895e4..4efa90039a 100644 --- a/nipype/interfaces/freesurfer/__init__.py +++ b/nipype/interfaces/freesurfer/__init__.py @@ -93,3 +93,7 @@ Paint, MRICoreg, ) +from .petsurfer import ( + GTMSeg, + GTMPVC, +) diff --git a/nipype/interfaces/freesurfer/model.py b/nipype/interfaces/freesurfer/model.py index 81758b6ac3..9ab1ac96a3 100644 --- a/nipype/interfaces/freesurfer/model.py +++ b/nipype/interfaces/freesurfer/model.py @@ -401,6 +401,26 @@ class GLMFitInputSpec(FSTraitedSpec): synth = traits.Bool(argstr="--synth", desc="replace input with gaussian") resynth_test = traits.Int(argstr="--resynthtest %d", desc="test GLM by resynthsis") profile = traits.Int(argstr="--profile %d", desc="niters : test speed") + mrtm1 = traits.Tuple( + File(exists=True), + File(exists=True), + argstr="--mrtm1 %s %s", + desc="RefTac TimeSec : perform MRTM1 kinetic modeling", + ) + mrtm2 = traits.Tuple( + File(exists=True), + File(exists=True), + traits.Float, + argstr="--mrtm2 %s %s %f", + desc="RefTac TimeSec k2prime : perform MRTM2 kinetic modeling", + ) + logan = traits.Tuple( + File(exists=True), + File(exists=True), + traits.Float, + argstr="--logan %s %s %f", + desc="RefTac TimeSec tstar : perform Logan kinetic modeling", + ) force_perm = traits.Bool( argstr="--perm-force", desc="force perumtation test, even when design matrix is not orthog", @@ -423,6 +443,9 @@ class GLMFitInputSpec(FSTraitedSpec): sim_done_file = File( argstr="--sim-done %s", desc="create file when simulation finished" ) + _ext_xor = ['nii', 'nii_gz'] + nii = traits.Bool(argstr='--nii', desc='save outputs as nii', xor=_ext_xor) + nii_gz = traits.Bool(argstr='--nii.gz', desc='save outputs as nii.gz', xor=_ext_xor) class GLMFitOutputSpec(TraitedSpec): @@ -444,6 +467,8 @@ class GLMFitOutputSpec(TraitedSpec): frame_eigenvectors = File(desc="matrix of frame eigenvectors from residual PCA") singular_values = File(desc="matrix singular values from residual PCA") svd_stats_file = File(desc="text file summarizing the residual PCA") + k2p_file = File(desc="estimate of k2p parameter") + bp_file = File(desc="Binding potential estimates") class GLMFit(FSCommand): @@ -478,22 +503,33 @@ def _list_outputs(self): glmdir = os.path.abspath(self.inputs.glm_dir) outputs["glm_dir"] = glmdir + if isdefined(self.inputs.nii_gz): + ext = 'nii.gz' + elif isdefined(self.inputs.nii): + ext = 'nii' + else: + ext = 'mgh' + # Assign the output files that always get created - outputs["beta_file"] = os.path.join(glmdir, "beta.mgh") - outputs["error_var_file"] = os.path.join(glmdir, "rvar.mgh") - outputs["error_stddev_file"] = os.path.join(glmdir, "rstd.mgh") - outputs["mask_file"] = os.path.join(glmdir, "mask.mgh") + outputs["beta_file"] = os.path.join(glmdir, f"beta.{ext}") + outputs["error_var_file"] = os.path.join(glmdir, f"rvar.{ext}") + outputs["error_stddev_file"] = os.path.join(glmdir, f"rstd.{ext}") + outputs["mask_file"] = os.path.join(glmdir, f"mask.{ext}") outputs["fwhm_file"] = os.path.join(glmdir, "fwhm.dat") outputs["dof_file"] = os.path.join(glmdir, "dof.dat") # Assign the conditional outputs - if isdefined(self.inputs.save_residual) and self.inputs.save_residual: - outputs["error_file"] = os.path.join(glmdir, "eres.mgh") - if isdefined(self.inputs.save_estimate) and self.inputs.save_estimate: - outputs["estimate_file"] = os.path.join(glmdir, "yhat.mgh") + if self.inputs.save_residual: + outputs["error_file"] = os.path.join(glmdir, f"eres.{ext}") + if self.inputs.save_estimate: + outputs["estimate_file"] = os.path.join(glmdir, f"yhat.{ext}") + if any((self.inputs.mrtm1, self.inputs.mrtm2, self.inputs.logan)): + outputs["bp_file"] = os.path.join(glmdir, f"bp.{ext}") + if self.inputs.mrtm1: + outputs["k2p_file"] = os.path.join(glmdir, "k2prime.dat") # Get the contrast directory name(s) + contrasts = [] if isdefined(self.inputs.contrast): - contrasts = [] for c in self.inputs.contrast: if split_filename(c)[2] in [".mat", ".dat", ".mtx", ".con"]: contrasts.append(split_filename(c)[1]) @@ -503,19 +539,19 @@ def _list_outputs(self): contrasts = ["osgm"] # Add in the contrast images - outputs["sig_file"] = [os.path.join(glmdir, c, "sig.mgh") for c in contrasts] - outputs["ftest_file"] = [os.path.join(glmdir, c, "F.mgh") for c in contrasts] + outputs["sig_file"] = [os.path.join(glmdir, c, f"sig.{ext}") for c in contrasts] + outputs["ftest_file"] = [os.path.join(glmdir, c, f"F.{ext}") for c in contrasts] outputs["gamma_file"] = [ - os.path.join(glmdir, c, "gamma.mgh") for c in contrasts + os.path.join(glmdir, c, f"gamma.{ext}") for c in contrasts ] outputs["gamma_var_file"] = [ - os.path.join(glmdir, c, "gammavar.mgh") for c in contrasts + os.path.join(glmdir, c, f"gammavar.{ext}") for c in contrasts ] # Add in the PCA results, if relevant if isdefined(self.inputs.pca) and self.inputs.pca: pcadir = os.path.join(glmdir, "pca-eres") - outputs["spatial_eigenvectors"] = os.path.join(pcadir, "v.mgh") + outputs["spatial_eigenvectors"] = os.path.join(pcadir, f"v.{ext}") outputs["frame_eigenvectors"] = os.path.join(pcadir, "u.mtx") outputs["singluar_values"] = os.path.join(pcadir, "sdiag.mat") outputs["svd_stats_file"] = os.path.join(pcadir, "stats.dat") diff --git a/nipype/interfaces/freesurfer/petsurfer.py b/nipype/interfaces/freesurfer/petsurfer.py new file mode 100644 index 0000000000..d04409ad20 --- /dev/null +++ b/nipype/interfaces/freesurfer/petsurfer.py @@ -0,0 +1,644 @@ +# -*- coding: utf-8 -*- +# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*- +# vi: set ft=python sts=4 ts=4 sw=4 et: +"""Provides interfaces to various commands for running PET analyses provided by FreeSurfer +""" + +import os + +from ... import logging +from ..base import ( + TraitedSpec, + File, + traits, + Directory, + InputMultiPath, + isdefined, +) +from .base import FSCommand, FSTraitedSpec + +from .model import GLMFitInputSpec, GLMFit + +__docformat__ = "restructuredtext" +iflogger = logging.getLogger("nipype.interface") + + +class GTMSegInputSpec(FSTraitedSpec): + + subject_id = traits.String(argstr="--s %s", desc="subject id", mandatory=True) + + xcerseg = traits.Bool( + argstr="--xcerseg", + desc="run xcerebralseg on this subject to create apas+head.mgz", + ) + + out_file = File( + "gtmseg.mgz", + argstr="--o %s", + desc="output volume relative to subject/mri", + usedefault=True, + ) + + upsampling_factor = traits.Int( + argstr="--usf %i", desc="upsampling factor (default is 2)" + ) + + subsegwm = traits.Bool( + argstr="--subsegwm", default=True, desc="subsegment WM into lobes (default)" + ) + + keep_hypo = traits.Bool( + argstr="--keep-hypo", + desc="do not relabel hypointensities as WM when subsegmenting WM", + ) + + keep_cc = traits.Bool( + argstr="--keep-cc", desc="do not relabel corpus callosum as WM" + ) + + dmax = traits.Float( + argstr="--dmax %f", + desc="distance threshold to use when subsegmenting WM (default is 5)", + ) + + ctx_annot = traits.Tuple( + traits.String, + traits.Int, + traits.Int, + argstr="--ctx-annot %s %i %i", + desc="annot lhbase rhbase : annotation to use for cortical segmentation (default is aparc 1000 2000)", + ) + + wm_annot = traits.Tuple( + traits.String, + traits.Int, + traits.Int, + argstr="--wm-annot %s %i %i", + desc="annot lhbase rhbase : annotation to use for WM segmentation (with --subsegwm, default is lobes 3200 4200)", + ) + + output_upsampling_factor = traits.Int( + argstr="--output-usf %i", + desc="set output USF different than USF, mostly for debugging", + ) + + head = traits.String( + argstr="--head %s", desc="use headseg instead of apas+head.mgz" + ) + + subseg_cblum_wm = traits.Bool( + argstr="--subseg-cblum-wm", desc="subsegment cerebellum WM into core and gyri" + ) + + no_pons = traits.Bool( + argstr="--no-pons", desc="do not add pons segmentation when doing ---xcerseg" + ) + + no_vermis = traits.Bool( + argstr="--no-vermis", + desc="do not add vermis segmentation when doing ---xcerseg", + ) + + colortable = File(exists=True, argstr="--ctab %s", desc="colortable") + no_seg_stats = traits.Bool( + argstr="--no-seg-stats", desc="do not compute segmentation stats" + ) + + +class GTMSegOutputSpec(TraitedSpec): + out_file = File(desc="GTM segmentation") + + +class GTMSeg(FSCommand): + """create an anatomical segmentation for the geometric transfer matrix (GTM). + + Examples + -------- + >>> gtmseg = GTMSeg() + >>> gtmseg.inputs.subject_id = 'subject_id' + >>> gtmseg.cmdline + 'gtmseg --o gtmseg.mgz --s subject_id' + """ + + _cmd = "gtmseg" + input_spec = GTMSegInputSpec + output_spec = GTMSegOutputSpec + + def _list_outputs(self): + outputs = self.output_spec().get() + outputs['out_file'] = os.path.join( + self.inputs.subjects_dir, + self.inputs.subject_id, + 'mri', + self.inputs.out_file, + ) + return outputs + + +class GTMPVCInputSpec(FSTraitedSpec): + + in_file = File( + exists=True, + argstr="--i %s", + mandatory=True, + copyfile=False, + desc="input volume - source data to pvc", + ) + + frame = traits.Int( + argstr="--frame %i", desc="only process 0-based frame F from inputvol" + ) + + psf = traits.Float(argstr="--psf %f", desc="scanner PSF FWHM in mm") + + segmentation = File( + argstr="--seg %s", + exists=True, + mandatory=True, + desc="segfile : anatomical segmentation to define regions for GTM", + ) + + _reg_xor = ["reg_file", "regheader", "reg_identity"] + reg_file = File( + exists=True, + argstr="--reg %s", + mandatory=True, + desc="LTA registration file that maps PET to anatomical", + xor=_reg_xor, + ) + + regheader = traits.Bool( + argstr="--regheader", + mandatory=True, + desc="assume input and seg share scanner space", + xor=_reg_xor, + ) + + reg_identity = traits.Bool( + argstr="--reg-identity", + mandatory=True, + desc="assume that input is in anatomical space", + xor=_reg_xor, + ) + + pvc_dir = traits.Str(argstr="--o %s", desc="save outputs to dir", genfile=True) + + mask_file = File( + exists=True, + argstr="--mask %s", + desc="ignore areas outside of the mask (in input vol space)", + ) + + auto_mask = traits.Tuple( + traits.Float, + traits.Float, + argstr="--auto-mask %f %f", + desc="FWHM thresh : automatically compute mask", + ) + + no_reduce_fov = traits.Bool( + argstr="--no-reduce-fov", desc="do not reduce FoV to encompass mask" + ) + + reduce_fox_eqodd = traits.Bool( + argstr="--reduce-fox-eqodd", + desc="reduce FoV to encompass mask but force nc=nr and ns to be odd", + ) + + contrast = InputMultiPath( + File(exists=True), argstr="--C %s...", desc="contrast file" + ) + + default_seg_merge = traits.Bool( + argstr="--default-seg-merge", desc="default schema for merging ROIs" + ) + + merge_hypos = traits.Bool( + argstr="--merge-hypos", desc="merge left and right hypointensites into to ROI" + ) + + merge_cblum_wm_gyri = traits.Bool( + argstr="--merge-cblum-wm-gyri", + desc="cerebellum WM gyri back into cerebellum WM", + ) + + tt_reduce = traits.Bool( + argstr="--tt-reduce", desc="reduce segmentation to that of a tissue type" + ) + + replace = traits.Tuple( + traits.Int, + traits.Int, + argstr="--replace %i %i", + desc="Id1 Id2 : replace seg Id1 with seg Id2", + ) + + rescale = traits.List( + argstr="--rescale %s...", + desc="Id1 : specify reference region(s) used to rescale (default is pons)", + ) + + no_rescale = traits.Bool( + argstr="--no-rescale", + desc="do not global rescale such that mean of reference region is scaleref", + ) + + scale_refval = traits.Float( + argstr="--scale-refval %f", + desc="refval : scale such that mean in reference region is refval", + ) + + _ctab_inputs = ("color_table_file", "default_color_table") + color_table_file = File( + exists=True, + argstr="--ctab %s", + xor=_ctab_inputs, + desc="color table file with seg id names", + ) + + default_color_table = traits.Bool( + argstr="--ctab-default", + xor=_ctab_inputs, + desc="use $FREESURFER_HOME/FreeSurferColorLUT.txt", + ) + + tt_update = traits.Bool( + argstr="--tt-update", + desc="changes tissue type of VentralDC, BrainStem, and Pons to be SubcortGM", + ) + + lat = traits.Bool(argstr="--lat", desc="lateralize tissue types") + + no_tfe = traits.Bool( + argstr="--no-tfe", + desc="do not correct for tissue fraction effect (with --psf 0 turns off PVC entirely)", + ) + + no_pvc = traits.Bool( + argstr="--no-pvc", + desc="turns off PVC entirely (both PSF and TFE)", + ) + + tissue_fraction_resolution = traits.Float( + argstr="--segpvfres %f", + desc="set the tissue fraction resolution parameter (def is 0.5)", + ) + + rbv = traits.Bool( + argstr="--rbv", + requires=["subjects_dir"], + desc="perform Region-based Voxelwise (RBV) PVC", + ) + + rbv_res = traits.Float( + argstr="--rbv-res %f", + desc="voxsize : set RBV voxel resolution (good for when standard res takes too much memory)", + ) + + mg = traits.Tuple( + traits.Float, + traits.List(traits.String), + argstr="--mg %g %s", + desc="gmthresh RefId1 RefId2 ...: perform Mueller-Gaertner PVC, gmthresh is min gm pvf bet 0 and 1", + ) + + mg_ref_cerebral_wm = traits.Bool( + argstr="--mg-ref-cerebral-wm", desc=" set MG RefIds to 2 and 41" + ) + + mg_ref_lobes_wm = traits.Bool( + argstr="--mg-ref-lobes-wm", + desc="set MG RefIds to those for lobes when using wm subseg", + ) + + mgx = traits.Float( + argstr="--mgx %f", + desc="gmxthresh : GLM-based Mueller-Gaertner PVC, gmxthresh is min gm pvf bet 0 and 1", + ) + + km_ref = traits.List( + argstr="--km-ref %s...", + desc="RefId1 RefId2 ... : compute reference TAC for KM as mean of given RefIds", + ) + + km_hb = traits.List( + argstr="--km-hb %s...", + desc="RefId1 RefId2 ... : compute HiBinding TAC for KM as mean of given RefIds", + ) + + steady_state_params = traits.Tuple( + traits.Float, + traits.Float, + traits.Float, + argstr="--ss %f %f %f", + desc="bpc scale dcf : steady-state analysis spec blood plasma concentration, unit scale and decay correction factor. You must also spec --km-ref. Turns off rescaling", + ) + + X = traits.Bool( + argstr="--X", desc="save X matrix in matlab4 format as X.mat (it will be big)" + ) + + y = traits.Bool(argstr="--y", desc="save y matrix in matlab4 format as y.mat") + + beta = traits.Bool( + argstr="--beta", desc="save beta matrix in matlab4 format as beta.mat" + ) + + X0 = traits.Bool( + argstr="--X0", + desc="save X0 matrix in matlab4 format as X0.mat (it will be big)", + ) + + save_input = traits.Bool( + argstr="--save-input", desc="saves rescaled input as input.rescaled.nii.gz" + ) + + save_eres = traits.Bool(argstr="--save-eres", desc="saves residual error") + + save_yhat = traits.Bool( + argstr="--save-yhat", + xor=["save_yhat_with_noise"], + desc="save signal estimate (yhat) smoothed with the PSF", + ) + + save_yhat_with_noise = traits.Tuple( + traits.Int, + traits.Int, + argstr="--save-yhat-with-noise %i %i", + xor=["save_yhat"], + desc="seed nreps : save signal estimate (yhat) with noise", + ) + + save_yhat_full_fov = traits.Bool( + argstr="--save-yhat-full-fov", desc="save signal estimate (yhat)" + ) + + save_yhat0 = traits.Bool(argstr="--save-yhat0", desc="save signal estimate (yhat)") + + optimization_schema = traits.Enum( + "3D", + "2D", + "1D", + "3D_MB", + "2D_MB", + "1D_MB", + "MBZ", + "MB3", + argstr="--opt %s", + desc="opt : optimization schema for applying adaptive GTM", + ) + + opt_tol = traits.Tuple( + traits.Int, + traits.Float, + traits.Float, + argstr="--opt-tol %i %f %f", + desc="n_iters_max ftol lin_min_tol : optimization parameters for adaptive gtm using fminsearch", + ) + + opt_brain = traits.Bool(argstr="--opt-brain", desc="apply adaptive GTM") + + opt_seg_merge = traits.Bool( + argstr="--opt-seg-merge", + desc="optimal schema for merging ROIs when applying adaptive GTM", + ) + + num_threads = traits.Int( + argstr="--threads %i", desc="threads : number of threads to use" + ) + + psf_col = traits.Float( + argstr="--psf-col %f", desc="xFWHM : full-width-half-maximum in the x-direction" + ) + + psf_row = traits.Float( + argstr="--psf-row %f", desc="yFWHM : full-width-half-maximum in the y-direction" + ) + + psf_slice = traits.Float( + argstr="--psf-slice %f", + desc="zFWHM : full-width-half-maximum in the z-direction", + ) + + +class GTMPVCOutputSpec(TraitedSpec): + + pvc_dir = Directory(desc="output directory") + ref_file = File(desc="Reference TAC in .dat") + hb_nifti = File(desc="High-binding TAC in nifti") + hb_dat = File(desc="High-binding TAC in .dat") + nopvc_file = File(desc="TACs for all regions with no PVC") + gtm_file = File(desc="TACs for all regions with GTM PVC") + gtm_stats = File(desc="Statistics for the GTM PVC") + input_file = File(desc="4D PET file in native volume space") + reg_pet2anat = File(desc="Registration file to go from PET to anat") + reg_anat2pet = File(desc="Registration file to go from anat to PET") + reg_rbvpet2anat = File( + desc="Registration file to go from RBV corrected PET to anat" + ) + reg_anat2rbvpet = File( + desc="Registration file to go from anat to RBV corrected PET" + ) + mgx_ctxgm = File( + desc="Cortical GM voxel-wise values corrected using the extended Muller-Gartner method", + ) + mgx_subctxgm = File( + desc="Subcortical GM voxel-wise values corrected using the extended Muller-Gartner method", + ) + mgx_gm = File( + desc="All GM voxel-wise values corrected using the extended Muller-Gartner method", + ) + rbv = File(desc="All GM voxel-wise values corrected using the RBV method") + opt_params = File( + desc="Optimal parameter estimates for the FWHM using adaptive GTM" + ) + yhat0 = File(desc="4D PET file of signal estimate (yhat) after PVC (unsmoothed)") + yhat = File( + desc="4D PET file of signal estimate (yhat) after PVC (smoothed with PSF)", + ) + yhat_full_fov = File( + desc="4D PET file with full FOV of signal estimate (yhat) after PVC (smoothed with PSF)", + ) + yhat_with_noise = File( + desc="4D PET file with full FOV of signal estimate (yhat) with noise after PVC (smoothed with PSF)", + ) + + +class GTMPVC(FSCommand): + """create an anatomical segmentation for the geometric transfer matrix (GTM). + + Examples + -------- + >>> gtmpvc = GTMPVC() + >>> gtmpvc.inputs.in_file = 'sub-01_ses-baseline_pet.nii.gz' + >>> gtmpvc.inputs.segmentation = 'gtmseg.mgz' + >>> gtmpvc.inputs.reg_file = 'sub-01_ses-baseline_pet_mean_reg.lta' + >>> gtmpvc.inputs.pvc_dir = 'pvc' + >>> gtmpvc.inputs.psf = 4 + >>> gtmpvc.inputs.default_seg_merge = True + >>> gtmpvc.inputs.auto_mask = (1, 0.1) + >>> gtmpvc.inputs.km_ref = ['8 47'] + >>> gtmpvc.inputs.km_hb = ['11 12 50 51'] + >>> gtmpvc.inputs.no_rescale = True + >>> gtmpvc.inputs.save_input = True + >>> gtmpvc.cmdline # doctest: +NORMALIZE_WHITESPACE + 'mri_gtmpvc --auto-mask 1.000000 0.100000 --default-seg-merge \ + --i sub-01_ses-baseline_pet.nii.gz --km-hb 11 12 50 51 --km-ref 8 47 --no-rescale \ + --psf 4.000000 --o pvc --reg sub-01_ses-baseline_pet_mean_reg.lta --save-input \ + --seg gtmseg.mgz' + + >>> gtmpvc = GTMPVC() + >>> gtmpvc.inputs.in_file = 'sub-01_ses-baseline_pet.nii.gz' + >>> gtmpvc.inputs.segmentation = 'gtmseg.mgz' + >>> gtmpvc.inputs.regheader = True + >>> gtmpvc.inputs.pvc_dir = 'pvc' + >>> gtmpvc.inputs.mg = (0.5, ["ROI1", "ROI2"]) + >>> gtmpvc.cmdline # doctest: +NORMALIZE_WHITESPACE + 'mri_gtmpvc --i sub-01_ses-baseline_pet.nii.gz --mg 0.5 ROI1 ROI2 --o pvc --regheader --seg gtmseg.mgz' + """ + + _cmd = "mri_gtmpvc" + input_spec = GTMPVCInputSpec + output_spec = GTMPVCOutputSpec + + def _format_arg(self, name, spec, val): + # Values taken from + # https://github.com/freesurfer/freesurfer/blob/fs-7.2/mri_gtmpvc/mri_gtmpvc.cpp#L115-L122 + if name == 'optimization_schema': + return ( + spec.argstr + % { + "3D": 1, + "2D": 2, + "1D": 3, + "3D_MB": 4, + "2D_MB": 5, + "1D_MB": 6, + "MBZ": 7, + "MB3": 8, + }[val] + ) + if name == 'mg': + return spec.argstr % (val[0], ' '.join(val[1])) + return super(GTMPVC, self)._format_arg(name, spec, val) + + def _list_outputs(self): + outputs = self.output_spec().get() + # Get the top-level output directory + if not isdefined(self.inputs.pvc_dir): + pvcdir = os.getcwd() + else: + pvcdir = os.path.abspath(self.inputs.pvc_dir) + outputs["pvc_dir"] = pvcdir + + # Assign the output files that always get created + outputs["ref_file"] = os.path.join(pvcdir, "km.ref.tac.dat") + outputs["hb_nifti"] = os.path.join(pvcdir, "km.hb.tac.nii.gz") + outputs["hb_dat"] = os.path.join(pvcdir, "km.hb.tac.dat") + outputs["nopvc_file"] = os.path.join(pvcdir, "nopvc.nii.gz") + outputs["gtm_file"] = os.path.join(pvcdir, "gtm.nii.gz") + outputs["gtm_stats"] = os.path.join(pvcdir, "gtm.stats.dat") + outputs["reg_pet2anat"] = os.path.join(pvcdir, "aux", "bbpet2anat.lta") + outputs["reg_anat2pet"] = os.path.join(pvcdir, "aux", "anat2bbpet.lta") + + # Assign the conditional outputs + if self.inputs.save_input: + outputs["input_file"] = os.path.join(pvcdir, "input.nii.gz") + if self.inputs.save_yhat0: + outputs["yhat0"] = os.path.join(pvcdir, "yhat0.nii.gz") + if self.inputs.save_yhat: + outputs["yhat"] = os.path.join(pvcdir, "yhat.nii.gz") + if self.inputs.save_yhat_full_fov: + outputs["yhat_full_fov"] = os.path.join(pvcdir, "yhat.fullfov.nii.gz") + if self.inputs.save_yhat_with_noise: + outputs["yhat_with_noise"] = os.path.join(pvcdir, "yhat.nii.gz") + if self.inputs.mgx: + outputs["mgx_ctxgm"] = os.path.join(pvcdir, "mgx.ctxgm.nii.gz") + outputs["mgx_subctxgm"] = os.path.join(pvcdir, "mgx.subctxgm.nii.gz") + outputs["mgx_gm"] = os.path.join(pvcdir, "mgx.gm.nii.gz") + if self.inputs.rbv: + outputs["rbv"] = os.path.join(pvcdir, "rbv.nii.gz") + outputs["reg_rbvpet2anat"] = os.path.join(pvcdir, "aux", "rbv2anat.lta") + outputs["reg_anat2rbvpet"] = os.path.join(pvcdir, "aux", "anat2rbv.lta") + if self.inputs.opt: + outputs["opt_params"] = os.path.join(pvcdir, "aux", "opt.params.dat") + + return outputs + + +class MRTMInputSpec(GLMFitInputSpec): + mrtm1 = traits.Tuple( + File(exists=True), + File(exists=True), + mandatory=True, + argstr="--mrtm1 %s %s", + desc="RefTac TimeSec : perform MRTM1 kinetic modeling", + ) + + +class MRTM(GLMFit): + """Perform MRTM1 kinetic modeling. + + Examples + -------- + >>> mrtm = MRTM() + >>> mrtm.inputs.in_file = 'tac.nii' + >>> mrtm.inputs.mrtm1 = ('ref_tac.dat', 'timing.dat') + >>> mrtm.inputs.glm_dir = 'mrtm' + >>> mrtm.cmdline + 'mri_glmfit --glmdir mrtm --y tac.nii --mrtm1 ref_tac.dat timing.dat' + """ + + input_spec = MRTMInputSpec + + +class MRTM2InputSpec(GLMFitInputSpec): + mrtm2 = traits.Tuple( + File(exists=True), + File(exists=True), + traits.Float, + mandatory=True, + argstr="--mrtm2 %s %s %f", + desc="RefTac TimeSec k2prime : perform MRTM2 kinetic modeling", + ) + + +class MRTM2(GLMFit): + """Perform MRTM2 kinetic modeling. + Examples + -------- + >>> mrtm2 = MRTM2() + >>> mrtm2.inputs.in_file = 'tac.nii' + >>> mrtm2.inputs.mrtm2 = ('ref_tac.dat', 'timing.dat', 0.07872) + >>> mrtm2.inputs.glm_dir = 'mrtm2' + >>> mrtm2.cmdline + 'mri_glmfit --glmdir mrtm2 --y tac.nii --mrtm2 ref_tac.dat timing.dat 0.078720' + """ + + input_spec = MRTM2InputSpec + + +class LoganRefInputSpec(GLMFitInputSpec): + logan = traits.Tuple( + File(exists=True), + File(exists=True), + traits.Float, + mandatory=True, + argstr="--logan %s %s %g", + desc="RefTac TimeSec tstar : perform Logan kinetic modeling", + ) + + +class LoganRef(GLMFit): + """Perform Logan reference kinetic modeling. + Examples + -------- + >>> logan = LoganRef() + >>> logan.inputs.in_file = 'tac.nii' + >>> logan.inputs.logan = ('ref_tac.dat', 'timing.dat', 2600) + >>> logan.inputs.glm_dir = 'logan' + >>> logan.cmdline + 'mri_glmfit --glmdir logan --y tac.nii --logan ref_tac.dat timing.dat 2600' + """ + + input_spec = LoganRefInputSpec diff --git a/nipype/interfaces/freesurfer/tests/test_auto_GLMFit.py b/nipype/interfaces/freesurfer/tests/test_auto_GLMFit.py index 21c41eb691..a950caa7af 100644 --- a/nipype/interfaces/freesurfer/tests/test_auto_GLMFit.py +++ b/nipype/interfaces/freesurfer/tests/test_auto_GLMFit.py @@ -89,10 +89,27 @@ def test_GLMFit_inputs(): extensions=None, xor=["cortex"], ), + logan=dict( + argstr="--logan %s %s %f", + ), mask_file=dict( argstr="--mask %s", extensions=None, ), + mrtm1=dict( + argstr="--mrtm1 %s %s", + ), + mrtm2=dict( + argstr="--mrtm2 %s %s %f", + ), + nii=dict( + argstr="--nii", + xor=["nii", "nii_gz"], + ), + nii_gz=dict( + argstr="--nii.gz", + xor=["nii", "nii_gz"], + ), no_contrast_ok=dict( argstr="--no-contrasts-ok", ), @@ -208,6 +225,9 @@ def test_GLMFit_outputs(): beta_file=dict( extensions=None, ), + bp_file=dict( + extensions=None, + ), dof_file=dict( extensions=None, ), @@ -233,6 +253,9 @@ def test_GLMFit_outputs(): gamma_file=dict(), gamma_var_file=dict(), glm_dir=dict(), + k2p_file=dict( + extensions=None, + ), mask_file=dict( extensions=None, ), diff --git a/nipype/interfaces/freesurfer/tests/test_auto_GTMPVC.py b/nipype/interfaces/freesurfer/tests/test_auto_GTMPVC.py new file mode 100644 index 0000000000..7f7af1cdb4 --- /dev/null +++ b/nipype/interfaces/freesurfer/tests/test_auto_GTMPVC.py @@ -0,0 +1,276 @@ +# AUTO-GENERATED by tools/checkspecs.py - DO NOT EDIT +from ..petsurfer import GTMPVC + + +def test_GTMPVC_inputs(): + input_map = dict( + X=dict( + argstr="--X", + ), + X0=dict( + argstr="--X0", + ), + args=dict( + argstr="%s", + ), + auto_mask=dict( + argstr="--auto-mask %f %f", + ), + beta=dict( + argstr="--beta", + ), + color_table_file=dict( + argstr="--ctab %s", + extensions=None, + xor=("color_table_file", "default_color_table"), + ), + contrast=dict( + argstr="--C %s...", + ), + default_color_table=dict( + argstr="--ctab-default", + xor=("color_table_file", "default_color_table"), + ), + default_seg_merge=dict( + argstr="--default-seg-merge", + ), + environ=dict( + nohash=True, + usedefault=True, + ), + frame=dict( + argstr="--frame %i", + ), + in_file=dict( + argstr="--i %s", + copyfile=False, + extensions=None, + mandatory=True, + ), + km_hb=dict( + argstr="--km-hb %s...", + ), + km_ref=dict( + argstr="--km-ref %s...", + ), + lat=dict( + argstr="--lat", + ), + mask_file=dict( + argstr="--mask %s", + extensions=None, + ), + merge_cblum_wm_gyri=dict( + argstr="--merge-cblum-wm-gyri", + ), + merge_hypos=dict( + argstr="--merge-hypos", + ), + mg=dict( + argstr="--mg %g %s", + ), + mg_ref_cerebral_wm=dict( + argstr="--mg-ref-cerebral-wm", + ), + mg_ref_lobes_wm=dict( + argstr="--mg-ref-lobes-wm", + ), + mgx=dict( + argstr="--mgx %f", + ), + no_pvc=dict( + argstr="--no-pvc", + ), + no_reduce_fov=dict( + argstr="--no-reduce-fov", + ), + no_rescale=dict( + argstr="--no-rescale", + ), + no_tfe=dict( + argstr="--no-tfe", + ), + num_threads=dict( + argstr="--threads %i", + ), + opt_brain=dict( + argstr="--opt-brain", + ), + opt_seg_merge=dict( + argstr="--opt-seg-merge", + ), + opt_tol=dict( + argstr="--opt-tol %i %f %f", + ), + optimization_schema=dict( + argstr="--opt %s", + ), + psf=dict( + argstr="--psf %f", + ), + psf_col=dict( + argstr="--psf-col %f", + ), + psf_row=dict( + argstr="--psf-row %f", + ), + psf_slice=dict( + argstr="--psf-slice %f", + ), + pvc_dir=dict( + argstr="--o %s", + genfile=True, + ), + rbv=dict( + argstr="--rbv", + requires=["subjects_dir"], + ), + rbv_res=dict( + argstr="--rbv-res %f", + ), + reduce_fox_eqodd=dict( + argstr="--reduce-fox-eqodd", + ), + reg_file=dict( + argstr="--reg %s", + extensions=None, + mandatory=True, + xor=["reg_file", "regheader", "reg_identity"], + ), + reg_identity=dict( + argstr="--reg-identity", + mandatory=True, + xor=["reg_file", "regheader", "reg_identity"], + ), + regheader=dict( + argstr="--regheader", + mandatory=True, + xor=["reg_file", "regheader", "reg_identity"], + ), + replace=dict( + argstr="--replace %i %i", + ), + rescale=dict( + argstr="--rescale %s...", + ), + save_eres=dict( + argstr="--save-eres", + ), + save_input=dict( + argstr="--save-input", + ), + save_yhat=dict( + argstr="--save-yhat", + xor=["save_yhat_with_noise"], + ), + save_yhat0=dict( + argstr="--save-yhat0", + ), + save_yhat_full_fov=dict( + argstr="--save-yhat-full-fov", + ), + save_yhat_with_noise=dict( + argstr="--save-yhat-with-noise %i %i", + xor=["save_yhat"], + ), + scale_refval=dict( + argstr="--scale-refval %f", + ), + segmentation=dict( + argstr="--seg %s", + extensions=None, + mandatory=True, + ), + steady_state_params=dict( + argstr="--ss %f %f %f", + ), + subjects_dir=dict(), + tissue_fraction_resolution=dict( + argstr="--segpvfres %f", + ), + tt_reduce=dict( + argstr="--tt-reduce", + ), + tt_update=dict( + argstr="--tt-update", + ), + y=dict( + argstr="--y", + ), + ) + inputs = GTMPVC.input_spec() + + for key, metadata in list(input_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(inputs.traits()[key], metakey) == value + + +def test_GTMPVC_outputs(): + output_map = dict( + gtm_file=dict( + extensions=None, + ), + gtm_stats=dict( + extensions=None, + ), + hb_dat=dict( + extensions=None, + ), + hb_nifti=dict( + extensions=None, + ), + input_file=dict( + extensions=None, + ), + mgx_ctxgm=dict( + extensions=None, + ), + mgx_gm=dict( + extensions=None, + ), + mgx_subctxgm=dict( + extensions=None, + ), + nopvc_file=dict( + extensions=None, + ), + opt_params=dict( + extensions=None, + ), + pvc_dir=dict(), + rbv=dict( + extensions=None, + ), + ref_file=dict( + extensions=None, + ), + reg_anat2pet=dict( + extensions=None, + ), + reg_anat2rbvpet=dict( + extensions=None, + ), + reg_pet2anat=dict( + extensions=None, + ), + reg_rbvpet2anat=dict( + extensions=None, + ), + yhat=dict( + extensions=None, + ), + yhat0=dict( + extensions=None, + ), + yhat_full_fov=dict( + extensions=None, + ), + yhat_with_noise=dict( + extensions=None, + ), + ) + outputs = GTMPVC.output_spec() + + for key, metadata in list(output_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(outputs.traits()[key], metakey) == value diff --git a/nipype/interfaces/freesurfer/tests/test_auto_GTMSeg.py b/nipype/interfaces/freesurfer/tests/test_auto_GTMSeg.py new file mode 100644 index 0000000000..026cc33b77 --- /dev/null +++ b/nipype/interfaces/freesurfer/tests/test_auto_GTMSeg.py @@ -0,0 +1,88 @@ +# AUTO-GENERATED by tools/checkspecs.py - DO NOT EDIT +from ..petsurfer import GTMSeg + + +def test_GTMSeg_inputs(): + input_map = dict( + args=dict( + argstr="%s", + ), + colortable=dict( + argstr="--ctab %s", + extensions=None, + ), + ctx_annot=dict( + argstr="--ctx-annot %s %i %i", + ), + dmax=dict( + argstr="--dmax %f", + ), + environ=dict( + nohash=True, + usedefault=True, + ), + head=dict( + argstr="--head %s", + ), + keep_cc=dict( + argstr="--keep-cc", + ), + keep_hypo=dict( + argstr="--keep-hypo", + ), + no_pons=dict( + argstr="--no-pons", + ), + no_seg_stats=dict( + argstr="--no-seg-stats", + ), + no_vermis=dict( + argstr="--no-vermis", + ), + out_file=dict( + argstr="--o %s", + extensions=None, + usedefault=True, + ), + output_upsampling_factor=dict( + argstr="--output-usf %i", + ), + subject_id=dict( + argstr="--s %s", + mandatory=True, + ), + subjects_dir=dict(), + subseg_cblum_wm=dict( + argstr="--subseg-cblum-wm", + ), + subsegwm=dict( + argstr="--subsegwm", + ), + upsampling_factor=dict( + argstr="--usf %i", + ), + wm_annot=dict( + argstr="--wm-annot %s %i %i", + ), + xcerseg=dict( + argstr="--xcerseg", + ), + ) + inputs = GTMSeg.input_spec() + + for key, metadata in list(input_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(inputs.traits()[key], metakey) == value + + +def test_GTMSeg_outputs(): + output_map = dict( + out_file=dict( + extensions=None, + ), + ) + outputs = GTMSeg.output_spec() + + for key, metadata in list(output_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(outputs.traits()[key], metakey) == value diff --git a/nipype/interfaces/freesurfer/tests/test_auto_LoganRef.py b/nipype/interfaces/freesurfer/tests/test_auto_LoganRef.py new file mode 100644 index 0000000000..c66f460533 --- /dev/null +++ b/nipype/interfaces/freesurfer/tests/test_auto_LoganRef.py @@ -0,0 +1,278 @@ +# AUTO-GENERATED by tools/checkspecs.py - DO NOT EDIT +from ..petsurfer import LoganRef + + +def test_LoganRef_inputs(): + input_map = dict( + allow_ill_cond=dict( + argstr="--illcond", + ), + allow_repeated_subjects=dict( + argstr="--allowsubjrep", + ), + args=dict( + argstr="%s", + ), + calc_AR1=dict( + argstr="--tar1", + ), + check_opts=dict( + argstr="--checkopts", + ), + compute_log_y=dict( + argstr="--logy", + ), + contrast=dict( + argstr="--C %s...", + ), + cortex=dict( + argstr="--cortex", + xor=["label_file"], + ), + debug=dict( + argstr="--debug", + ), + design=dict( + argstr="--X %s", + extensions=None, + xor=("fsgd", "design", "one_sample"), + ), + diag=dict( + argstr="--diag %d", + ), + diag_cluster=dict( + argstr="--diag-cluster", + ), + environ=dict( + nohash=True, + usedefault=True, + ), + fixed_fx_dof=dict( + argstr="--ffxdof %d", + xor=["fixed_fx_dof_file"], + ), + fixed_fx_dof_file=dict( + argstr="--ffxdofdat %d", + extensions=None, + xor=["fixed_fx_dof"], + ), + fixed_fx_var=dict( + argstr="--yffxvar %s", + extensions=None, + ), + force_perm=dict( + argstr="--perm-force", + ), + fsgd=dict( + argstr="--fsgd %s %s", + xor=("fsgd", "design", "one_sample"), + ), + fwhm=dict( + argstr="--fwhm %f", + ), + glm_dir=dict( + argstr="--glmdir %s", + genfile=True, + ), + hemi=dict(), + in_file=dict( + argstr="--y %s", + copyfile=False, + extensions=None, + mandatory=True, + ), + invert_mask=dict( + argstr="--mask-inv", + ), + label_file=dict( + argstr="--label %s", + extensions=None, + xor=["cortex"], + ), + logan=dict( + argstr="--logan %s %s %g", + mandatory=True, + ), + mask_file=dict( + argstr="--mask %s", + extensions=None, + ), + mrtm1=dict( + argstr="--mrtm1 %s %s", + ), + mrtm2=dict( + argstr="--mrtm2 %s %s %f", + ), + nii=dict( + argstr="--nii", + xor=["nii", "nii_gz"], + ), + nii_gz=dict( + argstr="--nii.gz", + xor=["nii", "nii_gz"], + ), + no_contrast_ok=dict( + argstr="--no-contrasts-ok", + ), + no_est_fwhm=dict( + argstr="--no-est-fwhm", + ), + no_mask_smooth=dict( + argstr="--no-mask-smooth", + ), + no_prune=dict( + argstr="--no-prune", + xor=["prunethresh"], + ), + one_sample=dict( + argstr="--osgm", + xor=("one_sample", "fsgd", "design", "contrast"), + ), + pca=dict( + argstr="--pca", + ), + per_voxel_reg=dict( + argstr="--pvr %s...", + ), + profile=dict( + argstr="--profile %d", + ), + prune=dict( + argstr="--prune", + ), + prune_thresh=dict( + argstr="--prune_thr %f", + xor=["noprune"], + ), + resynth_test=dict( + argstr="--resynthtest %d", + ), + save_cond=dict( + argstr="--save-cond", + ), + save_estimate=dict( + argstr="--yhat-save", + ), + save_res_corr_mtx=dict( + argstr="--eres-scm", + ), + save_residual=dict( + argstr="--eres-save", + ), + seed=dict( + argstr="--seed %d", + ), + self_reg=dict( + argstr="--selfreg %d %d %d", + ), + sim_done_file=dict( + argstr="--sim-done %s", + extensions=None, + ), + sim_sign=dict( + argstr="--sim-sign %s", + ), + simulation=dict( + argstr="--sim %s %d %f %s", + ), + subject_id=dict(), + subjects_dir=dict(), + surf=dict( + argstr="--surf %s %s %s", + requires=["subject_id", "hemi"], + ), + surf_geo=dict( + usedefault=True, + ), + synth=dict( + argstr="--synth", + ), + uniform=dict( + argstr="--uniform %f %f", + ), + var_fwhm=dict( + argstr="--var-fwhm %f", + ), + vox_dump=dict( + argstr="--voxdump %d %d %d", + ), + weight_file=dict( + extensions=None, + xor=["weighted_ls"], + ), + weight_inv=dict( + argstr="--w-inv", + xor=["weighted_ls"], + ), + weight_sqrt=dict( + argstr="--w-sqrt", + xor=["weighted_ls"], + ), + weighted_ls=dict( + argstr="--wls %s", + extensions=None, + xor=("weight_file", "weight_inv", "weight_sqrt"), + ), + ) + inputs = LoganRef.input_spec() + + for key, metadata in list(input_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(inputs.traits()[key], metakey) == value + + +def test_LoganRef_outputs(): + output_map = dict( + beta_file=dict( + extensions=None, + ), + bp_file=dict( + extensions=None, + ), + dof_file=dict( + extensions=None, + ), + error_file=dict( + extensions=None, + ), + error_stddev_file=dict( + extensions=None, + ), + error_var_file=dict( + extensions=None, + ), + estimate_file=dict( + extensions=None, + ), + frame_eigenvectors=dict( + extensions=None, + ), + ftest_file=dict(), + fwhm_file=dict( + extensions=None, + ), + gamma_file=dict(), + gamma_var_file=dict(), + glm_dir=dict(), + k2p_file=dict( + extensions=None, + ), + mask_file=dict( + extensions=None, + ), + sig_file=dict(), + singular_values=dict( + extensions=None, + ), + spatial_eigenvectors=dict( + extensions=None, + ), + svd_stats_file=dict( + extensions=None, + ), + ) + outputs = LoganRef.output_spec() + + for key, metadata in list(output_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(outputs.traits()[key], metakey) == value diff --git a/nipype/interfaces/freesurfer/tests/test_auto_MRTM.py b/nipype/interfaces/freesurfer/tests/test_auto_MRTM.py new file mode 100644 index 0000000000..18e1dd6961 --- /dev/null +++ b/nipype/interfaces/freesurfer/tests/test_auto_MRTM.py @@ -0,0 +1,278 @@ +# AUTO-GENERATED by tools/checkspecs.py - DO NOT EDIT +from ..petsurfer import MRTM + + +def test_MRTM_inputs(): + input_map = dict( + allow_ill_cond=dict( + argstr="--illcond", + ), + allow_repeated_subjects=dict( + argstr="--allowsubjrep", + ), + args=dict( + argstr="%s", + ), + calc_AR1=dict( + argstr="--tar1", + ), + check_opts=dict( + argstr="--checkopts", + ), + compute_log_y=dict( + argstr="--logy", + ), + contrast=dict( + argstr="--C %s...", + ), + cortex=dict( + argstr="--cortex", + xor=["label_file"], + ), + debug=dict( + argstr="--debug", + ), + design=dict( + argstr="--X %s", + extensions=None, + xor=("fsgd", "design", "one_sample"), + ), + diag=dict( + argstr="--diag %d", + ), + diag_cluster=dict( + argstr="--diag-cluster", + ), + environ=dict( + nohash=True, + usedefault=True, + ), + fixed_fx_dof=dict( + argstr="--ffxdof %d", + xor=["fixed_fx_dof_file"], + ), + fixed_fx_dof_file=dict( + argstr="--ffxdofdat %d", + extensions=None, + xor=["fixed_fx_dof"], + ), + fixed_fx_var=dict( + argstr="--yffxvar %s", + extensions=None, + ), + force_perm=dict( + argstr="--perm-force", + ), + fsgd=dict( + argstr="--fsgd %s %s", + xor=("fsgd", "design", "one_sample"), + ), + fwhm=dict( + argstr="--fwhm %f", + ), + glm_dir=dict( + argstr="--glmdir %s", + genfile=True, + ), + hemi=dict(), + in_file=dict( + argstr="--y %s", + copyfile=False, + extensions=None, + mandatory=True, + ), + invert_mask=dict( + argstr="--mask-inv", + ), + label_file=dict( + argstr="--label %s", + extensions=None, + xor=["cortex"], + ), + logan=dict( + argstr="--logan %s %s %f", + ), + mask_file=dict( + argstr="--mask %s", + extensions=None, + ), + mrtm1=dict( + argstr="--mrtm1 %s %s", + mandatory=True, + ), + mrtm2=dict( + argstr="--mrtm2 %s %s %f", + ), + nii=dict( + argstr="--nii", + xor=["nii", "nii_gz"], + ), + nii_gz=dict( + argstr="--nii.gz", + xor=["nii", "nii_gz"], + ), + no_contrast_ok=dict( + argstr="--no-contrasts-ok", + ), + no_est_fwhm=dict( + argstr="--no-est-fwhm", + ), + no_mask_smooth=dict( + argstr="--no-mask-smooth", + ), + no_prune=dict( + argstr="--no-prune", + xor=["prunethresh"], + ), + one_sample=dict( + argstr="--osgm", + xor=("one_sample", "fsgd", "design", "contrast"), + ), + pca=dict( + argstr="--pca", + ), + per_voxel_reg=dict( + argstr="--pvr %s...", + ), + profile=dict( + argstr="--profile %d", + ), + prune=dict( + argstr="--prune", + ), + prune_thresh=dict( + argstr="--prune_thr %f", + xor=["noprune"], + ), + resynth_test=dict( + argstr="--resynthtest %d", + ), + save_cond=dict( + argstr="--save-cond", + ), + save_estimate=dict( + argstr="--yhat-save", + ), + save_res_corr_mtx=dict( + argstr="--eres-scm", + ), + save_residual=dict( + argstr="--eres-save", + ), + seed=dict( + argstr="--seed %d", + ), + self_reg=dict( + argstr="--selfreg %d %d %d", + ), + sim_done_file=dict( + argstr="--sim-done %s", + extensions=None, + ), + sim_sign=dict( + argstr="--sim-sign %s", + ), + simulation=dict( + argstr="--sim %s %d %f %s", + ), + subject_id=dict(), + subjects_dir=dict(), + surf=dict( + argstr="--surf %s %s %s", + requires=["subject_id", "hemi"], + ), + surf_geo=dict( + usedefault=True, + ), + synth=dict( + argstr="--synth", + ), + uniform=dict( + argstr="--uniform %f %f", + ), + var_fwhm=dict( + argstr="--var-fwhm %f", + ), + vox_dump=dict( + argstr="--voxdump %d %d %d", + ), + weight_file=dict( + extensions=None, + xor=["weighted_ls"], + ), + weight_inv=dict( + argstr="--w-inv", + xor=["weighted_ls"], + ), + weight_sqrt=dict( + argstr="--w-sqrt", + xor=["weighted_ls"], + ), + weighted_ls=dict( + argstr="--wls %s", + extensions=None, + xor=("weight_file", "weight_inv", "weight_sqrt"), + ), + ) + inputs = MRTM.input_spec() + + for key, metadata in list(input_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(inputs.traits()[key], metakey) == value + + +def test_MRTM_outputs(): + output_map = dict( + beta_file=dict( + extensions=None, + ), + bp_file=dict( + extensions=None, + ), + dof_file=dict( + extensions=None, + ), + error_file=dict( + extensions=None, + ), + error_stddev_file=dict( + extensions=None, + ), + error_var_file=dict( + extensions=None, + ), + estimate_file=dict( + extensions=None, + ), + frame_eigenvectors=dict( + extensions=None, + ), + ftest_file=dict(), + fwhm_file=dict( + extensions=None, + ), + gamma_file=dict(), + gamma_var_file=dict(), + glm_dir=dict(), + k2p_file=dict( + extensions=None, + ), + mask_file=dict( + extensions=None, + ), + sig_file=dict(), + singular_values=dict( + extensions=None, + ), + spatial_eigenvectors=dict( + extensions=None, + ), + svd_stats_file=dict( + extensions=None, + ), + ) + outputs = MRTM.output_spec() + + for key, metadata in list(output_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(outputs.traits()[key], metakey) == value diff --git a/nipype/interfaces/freesurfer/tests/test_auto_MRTM2.py b/nipype/interfaces/freesurfer/tests/test_auto_MRTM2.py new file mode 100644 index 0000000000..71b200a600 --- /dev/null +++ b/nipype/interfaces/freesurfer/tests/test_auto_MRTM2.py @@ -0,0 +1,278 @@ +# AUTO-GENERATED by tools/checkspecs.py - DO NOT EDIT +from ..petsurfer import MRTM2 + + +def test_MRTM2_inputs(): + input_map = dict( + allow_ill_cond=dict( + argstr="--illcond", + ), + allow_repeated_subjects=dict( + argstr="--allowsubjrep", + ), + args=dict( + argstr="%s", + ), + calc_AR1=dict( + argstr="--tar1", + ), + check_opts=dict( + argstr="--checkopts", + ), + compute_log_y=dict( + argstr="--logy", + ), + contrast=dict( + argstr="--C %s...", + ), + cortex=dict( + argstr="--cortex", + xor=["label_file"], + ), + debug=dict( + argstr="--debug", + ), + design=dict( + argstr="--X %s", + extensions=None, + xor=("fsgd", "design", "one_sample"), + ), + diag=dict( + argstr="--diag %d", + ), + diag_cluster=dict( + argstr="--diag-cluster", + ), + environ=dict( + nohash=True, + usedefault=True, + ), + fixed_fx_dof=dict( + argstr="--ffxdof %d", + xor=["fixed_fx_dof_file"], + ), + fixed_fx_dof_file=dict( + argstr="--ffxdofdat %d", + extensions=None, + xor=["fixed_fx_dof"], + ), + fixed_fx_var=dict( + argstr="--yffxvar %s", + extensions=None, + ), + force_perm=dict( + argstr="--perm-force", + ), + fsgd=dict( + argstr="--fsgd %s %s", + xor=("fsgd", "design", "one_sample"), + ), + fwhm=dict( + argstr="--fwhm %f", + ), + glm_dir=dict( + argstr="--glmdir %s", + genfile=True, + ), + hemi=dict(), + in_file=dict( + argstr="--y %s", + copyfile=False, + extensions=None, + mandatory=True, + ), + invert_mask=dict( + argstr="--mask-inv", + ), + label_file=dict( + argstr="--label %s", + extensions=None, + xor=["cortex"], + ), + logan=dict( + argstr="--logan %s %s %f", + ), + mask_file=dict( + argstr="--mask %s", + extensions=None, + ), + mrtm1=dict( + argstr="--mrtm1 %s %s", + ), + mrtm2=dict( + argstr="--mrtm2 %s %s %f", + mandatory=True, + ), + nii=dict( + argstr="--nii", + xor=["nii", "nii_gz"], + ), + nii_gz=dict( + argstr="--nii.gz", + xor=["nii", "nii_gz"], + ), + no_contrast_ok=dict( + argstr="--no-contrasts-ok", + ), + no_est_fwhm=dict( + argstr="--no-est-fwhm", + ), + no_mask_smooth=dict( + argstr="--no-mask-smooth", + ), + no_prune=dict( + argstr="--no-prune", + xor=["prunethresh"], + ), + one_sample=dict( + argstr="--osgm", + xor=("one_sample", "fsgd", "design", "contrast"), + ), + pca=dict( + argstr="--pca", + ), + per_voxel_reg=dict( + argstr="--pvr %s...", + ), + profile=dict( + argstr="--profile %d", + ), + prune=dict( + argstr="--prune", + ), + prune_thresh=dict( + argstr="--prune_thr %f", + xor=["noprune"], + ), + resynth_test=dict( + argstr="--resynthtest %d", + ), + save_cond=dict( + argstr="--save-cond", + ), + save_estimate=dict( + argstr="--yhat-save", + ), + save_res_corr_mtx=dict( + argstr="--eres-scm", + ), + save_residual=dict( + argstr="--eres-save", + ), + seed=dict( + argstr="--seed %d", + ), + self_reg=dict( + argstr="--selfreg %d %d %d", + ), + sim_done_file=dict( + argstr="--sim-done %s", + extensions=None, + ), + sim_sign=dict( + argstr="--sim-sign %s", + ), + simulation=dict( + argstr="--sim %s %d %f %s", + ), + subject_id=dict(), + subjects_dir=dict(), + surf=dict( + argstr="--surf %s %s %s", + requires=["subject_id", "hemi"], + ), + surf_geo=dict( + usedefault=True, + ), + synth=dict( + argstr="--synth", + ), + uniform=dict( + argstr="--uniform %f %f", + ), + var_fwhm=dict( + argstr="--var-fwhm %f", + ), + vox_dump=dict( + argstr="--voxdump %d %d %d", + ), + weight_file=dict( + extensions=None, + xor=["weighted_ls"], + ), + weight_inv=dict( + argstr="--w-inv", + xor=["weighted_ls"], + ), + weight_sqrt=dict( + argstr="--w-sqrt", + xor=["weighted_ls"], + ), + weighted_ls=dict( + argstr="--wls %s", + extensions=None, + xor=("weight_file", "weight_inv", "weight_sqrt"), + ), + ) + inputs = MRTM2.input_spec() + + for key, metadata in list(input_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(inputs.traits()[key], metakey) == value + + +def test_MRTM2_outputs(): + output_map = dict( + beta_file=dict( + extensions=None, + ), + bp_file=dict( + extensions=None, + ), + dof_file=dict( + extensions=None, + ), + error_file=dict( + extensions=None, + ), + error_stddev_file=dict( + extensions=None, + ), + error_var_file=dict( + extensions=None, + ), + estimate_file=dict( + extensions=None, + ), + frame_eigenvectors=dict( + extensions=None, + ), + ftest_file=dict(), + fwhm_file=dict( + extensions=None, + ), + gamma_file=dict(), + gamma_var_file=dict(), + glm_dir=dict(), + k2p_file=dict( + extensions=None, + ), + mask_file=dict( + extensions=None, + ), + sig_file=dict(), + singular_values=dict( + extensions=None, + ), + spatial_eigenvectors=dict( + extensions=None, + ), + svd_stats_file=dict( + extensions=None, + ), + ) + outputs = MRTM2.output_spec() + + for key, metadata in list(output_map.items()): + for metakey, value in list(metadata.items()): + assert getattr(outputs.traits()[key], metakey) == value diff --git a/nipype/interfaces/freesurfer/tests/test_auto_OneSampleTTest.py b/nipype/interfaces/freesurfer/tests/test_auto_OneSampleTTest.py index 533c0a17a9..eb199ddc50 100644 --- a/nipype/interfaces/freesurfer/tests/test_auto_OneSampleTTest.py +++ b/nipype/interfaces/freesurfer/tests/test_auto_OneSampleTTest.py @@ -89,10 +89,27 @@ def test_OneSampleTTest_inputs(): extensions=None, xor=["cortex"], ), + logan=dict( + argstr="--logan %s %s %f", + ), mask_file=dict( argstr="--mask %s", extensions=None, ), + mrtm1=dict( + argstr="--mrtm1 %s %s", + ), + mrtm2=dict( + argstr="--mrtm2 %s %s %f", + ), + nii=dict( + argstr="--nii", + xor=["nii", "nii_gz"], + ), + nii_gz=dict( + argstr="--nii.gz", + xor=["nii", "nii_gz"], + ), no_contrast_ok=dict( argstr="--no-contrasts-ok", ), @@ -208,6 +225,9 @@ def test_OneSampleTTest_outputs(): beta_file=dict( extensions=None, ), + bp_file=dict( + extensions=None, + ), dof_file=dict( extensions=None, ), @@ -233,6 +253,9 @@ def test_OneSampleTTest_outputs(): gamma_file=dict(), gamma_var_file=dict(), glm_dir=dict(), + k2p_file=dict( + extensions=None, + ), mask_file=dict( extensions=None, ), diff --git a/nipype/testing/data/gtmseg.mgz b/nipype/testing/data/gtmseg.mgz new file mode 100644 index 0000000000..e69de29bb2 diff --git a/nipype/testing/data/gtmseg.nii b/nipype/testing/data/gtmseg.nii new file mode 100644 index 0000000000..e69de29bb2 diff --git a/nipype/testing/data/ref_tac.dat b/nipype/testing/data/ref_tac.dat new file mode 100644 index 0000000000..e69de29bb2 diff --git a/nipype/testing/data/sub-01_ses-baseline_pet.nii.gz b/nipype/testing/data/sub-01_ses-baseline_pet.nii.gz new file mode 100644 index 0000000000..e69de29bb2 diff --git a/nipype/testing/data/sub-01_ses-baseline_pet_mean_reg.lta b/nipype/testing/data/sub-01_ses-baseline_pet_mean_reg.lta new file mode 100644 index 0000000000..e69de29bb2 diff --git a/nipype/testing/data/tac.nii b/nipype/testing/data/tac.nii new file mode 100644 index 0000000000..e69de29bb2 diff --git a/nipype/testing/data/timing.dat b/nipype/testing/data/timing.dat new file mode 100644 index 0000000000..e69de29bb2