3 d@sdZddlZddlmZddlZddlmZmZm Z m Z ddl m Z m Z mZmZmZmZmZmZdd l mZmZmZmZmZmZd ZGd d d eZGd dde ZGdddeZGdddeZGddde ZGdddeZ GdddeZ!Gddde Z"GdddeZ#GdddeZ$Gdd d e Z%Gd!d"d"eZ&Gd#d$d$eZ'Gd%d&d&e Z(Gd'd(d(eZ)Gd)d*d*eZ*Gd+d,d,e Z+Gd-d.d.eZ,Gd/d0d0eZ-Gd1d2d2e Z.Gd3d4d4eZ/Gd5d6d6eZ0Gd7d8d8e Z1Gd9d:d:eZ2Gd;d<dd>e Z4Gd?d@d@eZ5GdAdBdBeZ6GdCdDdDe Z7GdEdFdFeZ8GdGdHdHeZ9GdIdJdJe Z:GdKdLdLeZ;GdMdNdNeZGdSdTdTeZ?GdUdVdVe Z@GdWdXdXeZAGdYdZdZeZBGd[d\d\e ZCGd]d^d^eZDGd_d`d`eZEGdadbdbe ZFGdcddddeZGGdedfdfeZHGdgdhdhe ZIGdidjdjeZJGdkdldleZKGdmdndne ZLGdodpdpeZMdS)qz$SPM wrappers for preprocessing data N)deepcopy)fname_presuffix ensure_list simplify_listsplit_filename)OutputMultiPath TraitedSpec isdefinedtraitsInputMultiPathInputMultiObjectFileStr) SPMCommandscans_for_fname func_is_3dscans_for_fnamesSPMCommandInputSpec ImageFileSPMZrestructuredtextc@seZdZejdddddZedddddd Zedddd d d Zej ej ej dd d dZ ej dddddZ ejddIddddZej ddddZej dddddZej dddddZejddddddd Zejd!d"dd#d$d%Zejd!d!dd&d'd%Zej ddd(d)dZeddd*d+d,Zejd!d-dd.d$d%Zejd!d/dd0d1d%Zejd!d2dd3d1d%Zej d4dd5d6dZej d7dd8d9dZedddd:d;d<Zej ddd=d>dZed?dd@dAdZ ej dddBdCdZ!edddDdEd,Z"ej dddFdGdZ#dHS)JFieldMapInputSpec calculatevdmTz1.9.0zAMust be 'calculatevdm'; to apply VDM, use the ApplyVDM interface.) usedefault deprecateddescFzsubj.data.presubphasemag.phasezpresubstracted phase file) mandatoryexistscopyfilefieldrz"subj.data.presubphasemag.magnitudezpresubstracted magnitude filezsubj.defaults.defaultsval.etzshort and long echo times)rr rz#subj.defaults.defaultsval.maskbrainz"masking or no masking of the brain)rr rrz!subj.defaults.defaultsval.blipdirz"polarity of the phase-encode blipszsubj.defaults.defaultsval.tertztotal EPI readout timezsubj.defaults.defaultsval.epifmzepi-based field mapzsubj.defaults.defaultsval.ajmzjacobian modulationZMark3DZMark2DZ Huttonishz!One of: Mark3D, Mark2D, Huttonishz'subj.defaults.defaultsval.uflags.method)rrr r z%subj.defaults.defaultsval.uflags.fwhmzgaussian smoothing kernel width)lowvaluerr rz$subj.defaults.defaultsval.uflags.padzpadding kernel widthz#subj.defaults.defaultsval.uflags.wszweighted smoothingz)subj.defaults.defaultsval.mflags.templatez template image for brain masking)rrr rz%subj.defaults.defaultsval.mflags.fwhmrz'subj.defaults.defaultsval.mflags.nerodeznumber of erosionsz(subj.defaults.defaultsval.mflags.ndilateg?z'subj.defaults.defaultsval.mflags.threshz7threshold used to create brain mask from segmented datag{Gz?z$subj.defaults.defaultsval.mflags.regz-regularization value used in the segmentationzsubj.session.epiz EPI to unwarp)rrrr rz subj.matchvdmzmatch VDM to EPIz_run-z subj.sessnamezVDM filename extensionzsubj.writeunwarpedzwrite unwarped EPIz subj.anatzanatomical image for comparisonzsubj.matchanatzmatch anatomical image to EPIN)$__name__ __module__ __qualname__r Enumjobtyper phase_filemagnitude_fileTupleFloatZ echo_timesBoolZ maskbrainZblip_directionZtotal_readout_timeZepifmZjacobian_modulationmethodRangeZ unwarp_fwhmpadwstemplateZ mask_fwhmZnerodeZndilateZthreshregepi_fileZmatchvdmrZsessnameZ writeunwarped anat_fileZ matchanatr9r9B/tmp/pip-build-7vycvbft/nipype/nipype/interfaces/spm/preprocess.pyr)src@seZdZedddZdS)FieldMapOutputSpecTzvoxel difference map)rrN)r'r(r)rvdmr9r9r9r:r;sr;csDeZdZdZeZeZdZdZ fddZ fddZ dd Z Z S) FieldMapaUse the fieldmap toolbox from spm to calculate the voxel displacement map (VDM). http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=173 .. important:: This interface does not deal with real/imag magnitude images nor with the two phase files case. Examples -------- >>> from nipype.interfaces.spm import FieldMap >>> fm = FieldMap() >>> fm.inputs.phase_file = 'phase.nii' >>> fm.inputs.magnitude_file = 'magnitude.nii' >>> fm.inputs.echo_times = (5.19, 7.65) >>> fm.inputs.blip_direction = 1 >>> fm.inputs.total_readout_time = 15.6 >>> fm.inputs.epi_file = 'epi.nii' >>> fm.run() # doctest: +SKIP toolsfieldmapcs(|dkrtt|Stt|j|||S)z+Convert input to appropriate format for spmr,r-r8r7)r,r-r8r7)rrsuperr= _format_arg)selfoptspecval) __class__r9r:rAs zFieldMap._format_argcstt|j}d|digS)z3validate spm fieldmap options if set to None ignorerr)r@r= _parse_inputs)rBeinputs)rFr9r:rGszFieldMap._parse_inputscCs,|jj}|jj}t|jjdd|d<|S)NZvdm5_sc)prefixr<)_outputsgetinputsr+rr,)rBoutputsr+r9r9r: _list_outputss zFieldMap._list_outputs)r'r(r)__doc__r input_specr; output_spec_jobtype_jobnamerArGrN __classcell__r9r9)rFr:r=s r=c@seZdZeedddddddZedddddZej d d d dd Z ej d d gdd d dddZ ej ddddddZejej dddddZejdddZejdddd d!Zd"S)#ApplyVDMInputSpecT)rz data.scansz%list of filenames to apply the vdm to)r rrrz data.vdmfilezVoxel displacement map to use)r rrrrzroptions.pedirz9phase encode direction input data have been acquired with)r rrrzroptions.whichzjIf the first value is non-zero, reslice all images. If the second value is non-zero, reslice a mean image.)r minlenmaxlenrrr%rzroptions.rinterpz)degree of b-spline used for interpolation)r#r"highr rrz roptions.wrapz-Check if interpolation should wrap in [x,y,z])rVrWr rz roptions.maskz"True/False mask time series images)r ruzroptions.prefixz fieldmap corrected output prefix)r rrN)r'r(r)rrin_filesrvdmfiler IntZdistortion_directionListInt write_whichr2 interpolationList write_wrapr0 write_maskString out_prefixr9r9r9r:rUsT rUc@s>eZdZeejejeddeddddZedddZ dS)ApplyVDMOutputSpecT)rz+These will be the fieldmap corrected files.)rz Mean image)rrN) r'r(r)r r Eitherrar out_files mean_imager9r9r9r:rf8srfcsDeZdZdZeZeZdZdZ fddZ fddZ dd Z Z S) ApplyVDMa'Use the fieldmap toolbox from spm to apply the voxel displacement map (VDM) to some epi files. http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=173 .. important:: This interface does not deal with real/imag magnitude images nor with the two phase files case. r>r?cs(|dkrtt|Stt|j|||S)z+Convert input to appropriate format for spmr[r\)r[r\)rrr@rjrA)rBrCrDrE)rFr9r:rAQs zApplyVDM._format_argcstt|j}d|digS)z3validate spm fieldmap options if set to None ignoreZapplyvdmr)r@rjrG)rBrH)rFr9r:rGXszApplyVDM._parse_inputsc Cs|jj}|jjddk}|jjddk}|rpt|jjdtrT|jjdd}n |jjd}t|dd|d<|rg|d<x~tt |jjD]j\}}g}t|trxDtt |D]"\}} t| |jj d} |j | qWnt||jj d}|dj |qW|S)Nrrmeanu)rIrirh) rJrKrLr_ isinstancer[listr enumeraterreappend) rBrM resliced_all resliced_mean first_imageidximgfZappliedvdm_runi inner_imgfnewfiler9r9r:rN_s*   zApplyVDM._list_outputs)r'r(r)rOrUrPrfrQrRrSrArGrNrTr9r9)rFr:rj@s   rjc@seZdZeejejeddedddddddZej dddd Z ej d d dd Z ej d d dd Z ejejej ej dddd Zejej ej dddd ZejdddddZdS)SliceTimingInputSpecT)rscansz'list of filenames to apply slice timingF)r rrrZnslicesznumber of slices in a volume)r rrtrz6time between volume acquisitions (start to start time)tazDtime of volume acquisition. usually calculated as TR-(TR/num_slices)soz;1-based order or onset (in ms) in which slices are acquiredZrefslicez^1-based Number of the reference slice or reference time point if slice_order is in onsets (ms)arIzslicetimed output prefix)r rrN)r'r(r)r r rgrarr[r]Z num_slicesr/Ztime_repetitionZtime_acquisitionZ slice_orderZ ref_slicerdrer9r9r9r:rx|s< rxc@s2eZdZeejejeddeddddZdS)SliceTimingOutputSpecT)rzslice time corrected files)rN) r'r(r)r r rgrartimecorrected_filesr9r9r9r:r~sr~cs8eZdZdZeZeZdZdZ fddZ ddZ Z S) SliceTimingaUse spm to perform slice timing correction. http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=19 Examples -------- >>> from nipype.interfaces.spm import SliceTiming >>> st = SliceTiming() >>> st.inputs.in_files = 'functional.nii' >>> st.inputs.num_slices = 32 >>> st.inputs.time_repetition = 6.0 >>> st.inputs.time_acquisition = 6. - 6./32. >>> st.inputs.slice_order = list(range(32,0,-1)) >>> st.inputs.ref_slice = 1 >>> st.run() # doctest: +SKIP Ztemporalstcs.|dkrtt|dddStt|j|||S)z+Convert input to appropriate format for spmr[FT)keep4dseparate_sessions)rrr@rrA)rBrCrDrE)rFr9r:rAszSliceTiming._format_argcsnjj}g|d<tjj}xH|D]@}t|trHfdd|D}nt|jjd}|dj |q&W|S)Nrcsg|]}t|jjdqS))rI)rrLre).0in_f)rBr9r: sz-SliceTiming._list_outputs..)rI) rJrKrrLr[rlrmrrero)rBrMfilelistfrunr9)rBr:rNs    zSliceTiming._list_outputs) r'r(r)rOrxrPr~rQrRrSrArNrTr9r9)rFr:rs rc@s(eZdZeejeddejedddddddZej dddd dd Z ej d d d ddZ ej d dddZ ej d dddZejdddZeddddZej dddddZejejddd d!d"Zejd#d$gd%d#d#dd&d'Zej ddd(ddZejejddd)d!d"Zejd*d+dZejd,d-dd.d/Zd0S)1RealignInputSpecT)rdatazlist of filenames to realign)r rrrestwriteestimatewritez!one of: estimate, write, estwrite)rrgg?zeoptions.qualityz0.1 = fast, 1.0 = precise)r"rYr rz eoptions.fwhmzgaussian smoothing kernel width)r"r rz eoptions.sepzsampling separation in mmz eoptions.rtmz6Indicate whether realignment is done to the mean image)r rzeoptions.weightzfilename of weighting image)rr rrrXzeoptions.interpz)degree of b-spline used for interpolationrz eoptions.wrapz-Check if interpolation should wrap in [x,y,z])rVrWr rrrzroptions.whichz"determines which images to reslice)r rVrWrrzroptions.interpz roptions.wrapz roptions.maskzTrue/False mask output imagerzroptions.prefixzrealigned output prefix)r rrN)r'r(r)r r rgrrar[r*r+r2qualityfwhm separationr0register_to_meanr weight_imginterpr]wrapr^r_ write_interprbrcrdrer9r9r9r:rsp   rc@sveZdZedddZeejejeddeddddZ eejejeddeddddZ eeddddZ d S) RealignOutputSpecTz$Mean image file from the realignment)rr)rzCopies of all files passed to in_files. Headers will have been modified to align all images with the first, or optionally to first do that, extract a mean image, and re-align to that mean image.)rzIf jobtype is write or estwrite, these will be the resliced files. Otherwise, they will be copies of in_files that have had their headers rewritten.z-Estimated translation and rotation parametersN) r'r(r)rrir r rgramodified_in_filesrealigned_filesrealignment_parametersr9r9r9r:r)s  rcsDeZdZdZeZeZdZdZ fddZ fddZ dd Z Z S) RealignawUse spm_realign for estimating within modality rigid body alignment http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=25 Examples -------- >>> import nipype.interfaces.spm as spm >>> realign = spm.Realign() >>> realign.inputs.in_files = 'functional.nii' >>> realign.inputs.register_to_mean = True >>> realign.run() # doctest: +SKIP spatialZrealigncs@|dkr,|jjdkrd}nd}t|d|dStt|j|||S)z+Convert input to appropriate format for spmr[rFT)rr)rLr+rr@rrA)rBrCrDrEr)rFr9r:rA\s  zRealign._format_argcs$tt|j}d|jj|digS)z2validate spm realign options if set to None ignorez%sr)r@rrGrLr+)rBrH)rFr9r:rGhszRealign._parse_inputsc Cs|jj}|jjddk}|jjddk}|jjdkrt|jjrLg|d<xX|jjD]L}t|trn|d}n|}|dj t |ddddt|t rVt |rVPqVW|jjd kr|jj|d <|jjd ks|jjd kr|jj|d <|jjdks|jjd krt|jjdtr"|jjdd}n |jjd}|rDt |d d|d<|rg|d <xt t |jjD]p\}}g}t|trxFt t |D]$\} } t | |jjd} |j | qWnt ||jjd}|d j |qdW|S)Nrrrrrp_z.txtF)rIsuffixuse_extrrrrZmean)rIri)rJrKrLr_r+r r[rlrmrorrrnrre) rBrMrprqrttmp_imgfrrrs realigned_runrurvrwr9r9r:rNmsL          zRealign._list_outputs)r'r(r)rOrrPrrQrRrSrArGrNrTr9r9)rFr:rFs rc@seZdZeejeddejedddddddZe dddd Z ej d d d d dZ ej d dddZ ej d dddZejdddZe ddddZej dddddZejejdddd d!Zejejd"d"d#d$d!Zej ddd%d&dZejd'gd(d)d)dd*d+Zejd,d-dZejejd)d.d/d0d!Zejejd)d.d1d2d!Zej d d3d4dZejd5d6dZejd7gd8d)d)dd9d+Zejd:d;ddd"d"dd?d+Z!ej ddd@ddZ"ejejdddAd d!Z#ejdBdCdZ$ejdDdEddFd=Z%dGS)HRealignUnwarpInputSpecT)rz data.scansz'list of filenames to realign and unwarp)r rrrz data.pmscanzuVoxel displacement map to use in unwarping. Unlike SPM standard behaviour, the same map will be used for all sessionsF)r rrgg?zeoptions.qualityz0.1 = fast, 1.0 = precise)r"rYr rz eoptions.fwhmzgaussian smoothing kernel width)r"r rz eoptions.sepzsampling separation in mmz eoptions.rtmz6Indicate whether realignment is done to the mean image)r rzeoptions.weightzfilename of weighting image)rr rrrXzeoptions.einterpz)degree of b-spline used for interpolationrzeoptions.ewrapz-Check if interpolation should wrap in [x,y,z])rVrWr rrzuweoptions.basfcnz3Number of basis functions to use for each dimensionzuweoptions.regorderzThis parameter determines how to balance the compromise between likelihood maximization and smoothness maximization of the estimated field.izuweoptions.lambdarz0Regularisation factor. Default: 100000 (medium).)r rVrWrrz uweoptions.jmzcJacobian deformations. In theory a good idea to include them, in practice a bad idea. Default: No.zuweoptions.fotzDFirst order effects should only depend on pitch and roll, i.e. [4 5]zuweoptions.sotz:List of second order terms to model second derivatives of.zuweoptions.uwfwhmz*gaussian smoothing kernel width for unwarpzuweoptions.remz>> import nipype.interfaces.spm as spm >>> realignUnwarp = spm.RealignUnwarp() >>> realignUnwarp.inputs.in_files = ['functional.nii', 'functional2.nii'] >>> realignUnwarp.inputs.phase_map = 'voxeldisplacemap.vdm' >>> realignUnwarp.inputs.register_to_mean = True >>> realignUnwarp.run() # doctest: +SKIP rZ realignunwarpcs.|dkrtt|dddStt|j|||S)z+Convert input to appropriate format for spmr[FT)rr)rrr@rrA)rBrCrDrE)rFr9r:rAeszRealignUnwarp._format_argcstt|jfdd}t|jjr0|ddndt|jjrt|jjtrjfdd|ddD}nt |ddd g}||d<|gS) N)skiprrpmscancsg|]}t|dqS))ryr)dict)rsess)rr9r:rysz/RealignUnwarp._parse_inputs..ry)ryr) r@rrGr rLrr[rlrmr)rBrZspmdictr)rF)rr:rGms  zRealignUnwarp._parse_inputsc Cst|jj}|jjddk}|jjddk}t|jjr@g|d<xX|jjD]L}t|trb|d}n|}|djt |ddddt|t rJt |rJPqJWt|jjdtr|jjdd}n |jjd}|rt |dd |d <|rpg|d <xt t |jjD]n\}}g}t|trNxFt t |D]$\} } t | |jj d } |j| q$Wnt ||jj d }|d j|qW|S) Nrrrrz.txtF)rIrrrk)rIrir)rJrKrLrr r[rlrmrorrrnrre) rBrMrprqrtrrrrsrrurvrwr9r9r:rNs<      zRealignUnwarp._list_outputs)r'r(r)rOrrPrrQrRrSrArGrNrTr9r9)rFr:rKs rc@seZdZeddddddZeeddddddd Zejd d d d ddZ ee ddddddZ ejdddddddZ ej ejdddddZej ejdddZej ejdd dZejd!d"d#d$d%Zej ejd&d&d'd(dZejd)d*dZejd+d,dd-d.Zd/S)0CoregisterInputSpecTrefzreference file to register toF)rrr rr)rsourcezfile to register to target)r rrrrrrz!one of: estimate, write, estwrite)rrotherz files to apply transformation to)r rrmiZnmiZeccZncczeoptions.cost_funzcost function, one of: 'mi' - Mutual Information, 'nmi' - Normalised Mutual Information, 'ecc' - Entropy Correlation Coefficient, 'ncc' - Normalised Cross Correlation)r rrz eoptions.fwhmz$gaussian smoothing kernel width (mm))rVrWr rz eoptions.sepzsampling separation in mmz eoptions.tolz*acceptable tolerance for each of 12 paramsrrXzroptions.interpz)degree of b-spline used for interpolation)r"rYr rrz roptions.wrapz-Check if interpolation should wrap in [x,y,z]z roptions.maskzTrue/False mask output imagerzroptions.prefixzcoregistered output prefix)r rrN)r'r(r)rtargetr rr r*r+rapply_to_filesZ cost_functionrar/rrZ tolerancer2rr]rbr0rcrdrer9r9r9r:rsprc@s0eZdZeeddddZeeddddZdS)CoregisterOutputSpecT)rzCoregistered source files)rzCoregistered other filesN)r'r(r)r rcoregistered_sourcecoregistered_filesr9r9r9r:rsrcsDeZdZdZeZeZdZdZ fddZ fddZ dd Z Z S) CoregisteraoUse spm_coreg for estimating cross-modality rigid body alignment http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=39 Examples -------- >>> import nipype.interfaces.spm as spm >>> coreg = spm.Coregister() >>> coreg.inputs.target = 'functional.nii' >>> coreg.inputs.source = 'structural.nii' >>> coreg.run() # doctest: +SKIP rZcoregcs|dks|dkr,|jjdkr,tt|ddS|dkrFtjt|tdS|dkr~|jjdkr~t|jjrvt||jjSt|St t |j |||S)z+Convert input to appropriate format for spmrrrT)rr)dtype) rLr+rrnparrayobjectr rr@rrA)rBrCrDrE)rFr9r:rAs zCoregister._format_argcsL|jjdkr tt|jdd}ntt|jdd}|jj}d||digS)z5validate spm coregister options if set to None ignorerr+r)rz%sr)r+r)rLr+r@rrG)rBrHr+)rFr9r:rG!s    zCoregister._parse_inputscCs|jj}|jjdkr>t|jjr0|jj|d<|jj|d<n|jjdksV|jjdkrt|jjrg|d<x.t|jjD]}|djt ||jj dqxWg|d<x.t|jjD]}|djt ||jj dqW|S)Nrrrrr)rI) rJrKrLr+r rrrrorre)rBrMrtr9r9r:rN,s      zCoregister._list_outputs)r'r(r)rOrrPrrQrRrSrArGrNrTr9r9)rFr:rs rc@seZdZedddddgddZeeddddgd ddd Zej d d d dddZ eej eddej eddddddZ eddddgdddZeddddZeddddZejdddZejdd dZej d!d"d#d$d%dZejd&d'dZejd(d)dZejd*d+dZejd,d-dZej ej ejd.d.d/d0d1d1d2d3Zej ejd4d.d.d5d3Zejd6d7d8d9d:Zej ejd;ddd?d@Z!dAS)BNormalizeInputSpecTzeoptions.templateztemplate file to normalize toparameter_fileF)rr rrxorr)rz subj.sourcezfile to normalize to template)r rrrrrestrzEstimate, Write or do both)rrz subj.resamplez files to apply transformation to)r rrz subj.matnamerr5z$normalization parameter file*_sn.mat)r rrrrz subj.wtsrcz"name of weighting image for sourcezeoptions.weightz$name of weighting image for templatezeoptions.smosrczsource smoothing)r rzeoptions.smorefztemplate smoothingmnisizenonezeoptions.regtypezmni, size, nonezeoptions.cutoffzCutoff of for DCT basesz eoptions.nitsz)Number of iterations of nonlinear warpingz eoptions.regzLthe amount of the regularization for the nonlinear part of the normalizationzroptions.preservez&True/False warped images are modulatedr)rVrWz roptions.bbrz3x2-element list of lists)r rVrWrz roptions.voxz3-element listrrXzroptions.interpz)degree of b-spline used for interpolation)r"rYr rz roptions.wrapz=Check if interpolation should wrap in [x,y,z] - list of boolswzroptions.prefixznormalized output prefix)r rrN)"r'r(r)rr5r rrr r*r+rgrarrZ source_weightZtemplate_weightr/Zsource_image_smoothingZtemplate_image_smoothingaffine_regularization_typeZDCT_period_cutoffr]Znonlinear_iterationsnonlinear_regularizationr0write_preservewrite_bounding_boxwrite_voxel_sizesr2rrbrdrer9r9r9r:rHs      rc@sBeZdZeeddddZeeddddZeeddddZdS)NormalizeOutputSpecT)rz1MAT files containing the normalization parameters)rzNormalized source fileszNormalized other filesN)r'r(r)r rnormalization_parametersnormalized_sourcenormalized_filesr9r9r9r:rs rcsDeZdZdZeZeZdZdZ fddZ fddZ dd Z Z S) Normalizea0use spm_normalise for warping an image to a template http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=203 Examples -------- >>> import nipype.interfaces.spm as spm >>> norm = spm.Normalize() >>> norm.inputs.source = 'functional.nii' >>> norm.run() # doctest: +SKIP r normalisecs|dkrtt|S|dkr(tt|S|dkr.)rI)rJrKrLr+ startswithrrrorrr rrjoinrerlrmr)rBrMr+rtrrrr9)rr:rNs>        zNormalize._list_outputs)r'r(r)rOrrPrrQrRrSrArGrNrTr9r9)rFr:rs   rc@szeZdZeddddgdddZeejeddejedddddd Z ed dd d gd ddZ ej ddddddZ ej ddddddddddd Z ej d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/dZedd0d1dgd d2Zej d3d4d5d6d7dZejejd8d9d9d:d;Zejdd?dZejejejd@d@dAdBdCdCdDd;ZejejdEd@d@dFd;ZejddGdHdIdJZejdKdLddMdNZdOS)PNormalize12InputSpecTzsubj.volz.file to estimate normalization parameters withdeformation_file)rr rrrr)rz subj.resamplez files to apply transformation to)r rrzsubj.defimage_to_aligntpmFzXfile y_*.nii containing 3 deformation fields for the deformation in x, y and z dimension)r rrrrrrrzEstimate, Write or do Both)rrrgh㈵>g-C6?gMbP?g{Gz?g?rr!zeoptions.biasregzno(0) - extremely heavy (10))r r(2<FPZdnxInfzeoptions.biasfwhmz#FWHM of Gaussian smoothness of biasz eoptions.tpmz;template in form of tissue probablitiy maps to normalize to)rr rrrrrrzeoptions.affregzmni, size, nonez eoptions.regr$z,controls balance between parameters and data)r rVrWrz eoptions.fwhmz5value (in mm) to smooth the data before normalizationz eoptions.sampz2Sampling distance on data for parameter estimationr)rVrWz woptions.bbrzM3x2-element list of lists representing the bounding box (in mm) to be writtenz woptions.voxzT3-element list representing the voxel sizes (in mm) of the written normalised imagesrXzwoptions.interpz)degree of b-spline used for interpolation)r"rYr rrzwoptions.prefixzNormalized output prefix)r rrN)r'r(r)rrr r rgrarrr*r+bias_regularization bias_fwhmrrrr/warping_regularizationZ smoothnesssampling_distancerrr2rrdrer9r9r9r:r src@sBeZdZeeddddZeeddddZeeddddZdS)Normalize12OutputSpecT)rzVNIfTI file containing 3 deformation fields for the deformation in x, y and z dimension)rz)Normalized file that needed to be alignedzNormalized other filesN)r'r(r)r rdeformation_fieldnormalized_imagerr9r9r9r:rs rcsHeZdZdZeZeZdZdZ fddZ fffdd Z dd Z Z S) Normalize12auses SPM12's new Normalise routine for warping an image to a template. Spatial normalisation is now done via the segmentation routine (which was known as ``New Segment`` in SPM8). Note that the normalisation in SPM12 is done towards a file containing multiple tissue probability maps, which was not the case in SPM8. http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=49 Examples -------- >>> import nipype.interfaces.spm as spm >>> norm12 = spm.Normalize12() >>> norm12.inputs.image_to_align = 'structural.nii' >>> norm12.inputs.apply_to_files = 'functional.nii' >>> norm12.run() # doctest: +SKIP rrcs|dkrtt|S|dkr(tt|S|dkr.)rJrKrLr+rrrrorrr rrlrmr)rBrMr+rtrrrr9r9r:rNs2        zNormalize12._list_outputs)r'r(r)rOrrPrrQrRrSrArGrNrTr9r9)rFr:rs rc@sLeZdZeedddddddZejejdddd d Z ejejddd d d Z ejejddd dd Z ejdddZ ej ddddddZejedddddZejejdddZej dddddd d!dZejd"d#dZejd$d%dZej d&d'd(d)d*d+d,d-d.d/d Zej d0d1d2d3d4d5d6d7d8d9d:d;dd?dZedd@dAdBZdCS)DSegmentInputSpecT)rrzone scan per subjectF)r rrrrz output.GMa Options to produce grey matter images: c1*.img, wc1*.img and mwc1*.img. None: [False,False,False], Native Space: [False,False,True], Unmodulated Normalised: [False,True,False], Modulated Normalised: [True,False,False], Native + Unmodulated Normalised: [False,True,True], Native + Modulated Normalised: [True,False,True], Native + Modulated + Unmodulated: [True,True,True], Modulated + Unmodulated Normalised: [True,True,False])rVrWr rz output.WMa Options to produce white matter images: c2*.img, wc2*.img and mwc2*.img. None: [False,False,False], Native Space: [False,False,True], Unmodulated Normalised: [False,True,False], Modulated Normalised: [True,False,False], Native + Unmodulated Normalised: [False,True,True], Native + Modulated Normalised: [True,False,True], Native + Modulated + Unmodulated: [True,True,True], Modulated + Unmodulated Normalised: [True,True,False]z output.CSFa Options to produce CSF images: c3*.img, wc3*.img and mwc3*.img. None: [False,False,False], Native Space: [False,False,True], Unmodulated Normalised: [False,True,False], Modulated Normalised: [True,False,False], Native + Unmodulated Normalised: [False,True,True], Native + Modulated Normalised: [True,False,True], Native + Modulated + Unmodulated: [True,True,True], Modulated + Unmodulated Normalised: [True,True,False]zoutput.biascorz)True/False produce a bias corrected image)r rnolightthoroughzoutput.cleanupz:clean using estimated brain mask ('no','light','thorough')zopts.tpmz&list of gray, white & csf prob. (opt,)z opts.ngausz,num Gaussians capture intensity distributionreasternrrrz opts.regtypezcPossible options: "mni", "eastern", "subj", "none" (no reguralisation), "" (no affine registration)z opts.warpregz,Controls balance between parameters and dataz opts.warpcozCutoff of DCT basesrgh㈵>g-C6?gMbP?g{Gz?g?rr!z opts.biasregzno(0) - extremely heavy (10)rrrrrrrrrrrrz opts.biasfwhmz#FWHM of Gaussian smoothness of biasz opts.sampz2Sampling distance on data for parameter estimationzopts.mskz.Binary image to restrict parameter estimation )rr rN)r'r(r)r rrr rar0Zgm_output_typeZwm_output_typeZcsf_output_typesave_bias_correctedr* clean_masksrtissue_prob_mapsr]gaussians_per_classaffine_regularizationr/rZwarp_frequency_cutoffrrr mask_imager9r9r9r:rs       rc@seZdZeddZeddZeddZeddZeddZeddZ eddZ ed dZ ed dZ ed d d dZ ed dZedddZedddZdS)SegmentOutputSpecz!native space grey probability map)rznormalized grey probability mapz*modulated, normalized grey probability mapz"native space white probability mapz normalized white probability mapz+modulated, normalized white probability mapz native space csf probability mapznormalized csf probability mapz)modulated, normalized csf probability mapz0.10bias_corrected_imagez%bias-corrected version of input image)rnew_namerTzNormalization transformation)rrzInverse normalization infoN)r'r(r)rZnative_gm_imageZnormalized_gm_imageZmodulated_gm_imageZnative_wm_imageZnormalized_wm_imageZmodulated_wm_imageZnative_csf_imageZnormalized_csf_imageZmodulated_csf_imageZmodulated_input_imagertransformation_matinverse_transformation_matr9r9r9r:rus            rcs8eZdZdZeZeZddZfddZ ddZ Z S)SegmentaEuse spm_segment to separate structural images into different tissue classes. http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=209 Examples -------- >>> import nipype.interfaces.spm as spm >>> seg = spm.Segment() >>> seg.inputs.data = 'structural.nii' >>> seg.run() # doctest: +SKIP cKs@tj}|r"d|kr"d|_d|_n d|_d|_tj|f|dS)Nz12.r>Zoldsegrpreproc)rversionrRrS__init__)rBrL_local_versionr9r9r:rs zSegment.__init__csxdddd}|d kr.t|tr&t|St|Sd|krDdd |DS|d krTt|S|d krd||Stt|j|||S) z+Convert input to appropriate format for spmrrr)rrrrr output_typecSsg|] }t|qSr9)int)rvr9r9r:rsz'Segment._format_arg..rr)rr)rlrmrrr@rrA)rBrCrDrEZclean_masks_dict)rFr9r:rAs  zSegment._format_argc Cs|jj}|jjd}xtdddgD]x\}}d|}tt|j|r(xVtdddgD]D\}\}}t|j||rXd ||f} t|d ||dfd|| <qXWq(Wt|jjr|jjrt|dd|d<t|ddd} | |d<t|ddd} | |d<|S)Nrgmwmcsfz%s_output_type modulatedmw normalizedrnativerz %s_%s_imagez%sc%dr)rIrrz _seg_sn.matF)rrrz_seg_inv_sn.matr)rr)rr)rr) rJrKrLrrnr getattrrr) rBrMrZtidxtissueZouttypersimagerIZoutfieldZt_matZinvt_matr9r9r:rNs&   " zSegment._list_outputs) r'r(r)rOrrPrrQrrArNrTr9r9)rFr:rs   rc@seZdZeedddddddZejejejejej ej dddZ ej ejejeddej ej ejej ej ejej ej d d dZ ejd d d ddddZejej ejdddejdddZejdddZej ej dddddZdS)NewSegmentInputSpecT)rzA list of files to be segmentedchannelF)rrr rzA tuple with the following fields: - bias reguralisation (0-10) - FWHM of Gaussian smoothness of bias - which maps to save (Field, Corrected) - a tuple of two boolean values)rr aLA list of tuples (one per tissue) with the following fields: - tissue probability map (4D), 1-based index to frame - number of gaussians - which maps to save [Native, DARTEL] - a tuple of two boolean values - which maps to save [Unmodulated, Modulated] - a tuple of two boolean valuesrrrrrz warp.affregzmni, eastern, subj, none )r rr$)rVrWzwarp.regzfWarping regularization parameter(s). Accepts float or list of floats (the latter is required by SPM12)z warp.sampz2Sampling distance on data for parameter estimationrz warp.writez4Which deformation fields to write:[Inverse, Forward])rVrWr rN)r'r(r)r r channel_filesr r.r/r0 channel_inforar]tissuesr*rrgrrwrite_deformation_fieldsr9r9r9r:rsP rc@seZdZejejeddddZejejeddddZejejeddddZejejeddddZ e eddddZ e eddd dZ e eddd dZ e eddZe eddZd S) NewSegmentOutputSpecT)rznative space probability maps)rzdartel imported class imagesznormalized class imagesz!modulated+normalized class imageszNormalization transformationzbias corrected imageszbias field imagesN)r'r(r)r rarnative_class_imagesdartel_input_imagesnormalized_class_imagesmodulated_class_imagesr rbias_corrected_imagesbias_field_imagesforward_deformation_fieldinverse_deformation_fieldr9r9r9r:rsrcs8eZdZdZeZeZddZfddZ ddZ Z S) NewSegmentaUse spm_preproc8 (New Segment) to separate structural images into different tissue classes. Supports multiple modalities. NOTE: This interface currently supports single channel input only http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=43 Examples -------- >>> import nipype.interfaces.spm as spm >>> seg = spm.NewSegment() >>> seg.inputs.channel_files = 'structural.nii' >>> seg.inputs.channel_info = (0.0001, 60, (True, True)) >>> seg.run() # doctest: +SKIP For VBM pre-processing [http://www.fil.ion.ucl.ac.uk/~john/misc/VBMclass10.pdf], TPM.nii should be replaced by /path/to/spm8/toolbox/Seg/TPM.nii >>> seg = NewSegment() >>> seg.inputs.channel_files = 'structural.nii' >>> tissue1 = (('TPM.nii', 1), 2, (True,True), (False, False)) >>> tissue2 = (('TPM.nii', 2), 2, (True,True), (False, False)) >>> tissue3 = (('TPM.nii', 3), 2, (True,False), (False, False)) >>> tissue4 = (('TPM.nii', 4), 2, (False,False), (False, False)) >>> tissue5 = (('TPM.nii', 5), 2, (False,False), (False, False)) >>> seg.inputs.tissues = [tissue1, tissue2, tissue3, tissue4, tissue5] >>> seg.run() # doctest: +SKIP cKs@tj}|r"d|kr"d|_d|_n d|_d|_tj|f|dS)Nz12.rrr>preproc8)rrrRrSr)rBrLr r9r9r:rLs zNewSegment.__init__c sp|dkrri}t|jj|d<t|jjrl|jj}|d|d<|d|d<t|ddt|ddg|d <|gS|d kr&g}x|D]}i}tjd j|ddt |ddggt d |d <|d|d<t|ddt|ddg|d<t|ddt|ddg|d<|j |qW|S|dkrXt t |j||t|dt|dgSt t |j|||SdS)z+Convert input to appropriate format for spmrrvolsrbiasregrbiasfwhmrrr,)rrngausrrwarpedrN)rr)rrLrr rr rrrstrrror@r&rA) rBrCrDrE new_channelinfo new_tissuesr new_tissue)rFr9r:rAWs0   $  . $$  zNewSegment._format_argc Cs|jj}g|d<g|d<g|d<g|d<g|d<g|d<g|d<g|d<g|d <d }t|jjrpt|jj}xHt|D]<}|djg|djg|djg|djgqzWx@|jjD]2}t |\}}}t|jjrxt |jjD]\}}|d d r4|d|jt j j |d |d|f|d drj|d|jt j j |d|d|f|dd r|d|jt j j |d|d|f|ddr|d|jt j j |d|d|fqWn>> import nipype.interfaces.spm as spm >>> seg = spm.MultiChannelNewSegment() >>> seg.inputs.channels = [('structural.nii',(0.0001, 60, (True, True)))] >>> seg.run() # doctest: +SKIP For VBM pre-processing [http://www.fil.ion.ucl.ac.uk/~john/misc/VBMclass10.pdf], TPM.nii should be replaced by /path/to/spm8/toolbox/Seg/TPM.nii >>> seg = MultiChannelNewSegment() >>> channel1= ('T1.nii',(0.0001, 60, (True, True))) >>> channel2= ('T2.nii',(0.0001, 60, (True, True))) >>> seg.inputs.channels = [channel1, channel2] >>> tissue1 = (('TPM.nii', 1), 2, (True,True), (False, False)) >>> tissue2 = (('TPM.nii', 2), 2, (True,True), (False, False)) >>> tissue3 = (('TPM.nii', 3), 2, (True,False), (False, False)) >>> tissue4 = (('TPM.nii', 4), 2, (False,False), (False, False)) >>> tissue5 = (('TPM.nii', 5), 2, (False,False), (False, False)) >>> seg.inputs.tissues = [tissue1, tissue2, tissue3, tissue4, tissue5] >>> seg.run() # doctest: +SKIP cKs@tj}|r"d|kr"d|_d|_n d|_d|_tj|f|dS)Nz12.rrr>r')rrrRrSr)rBrLr r9r9r:rCs zMultiChannelNewSegment.__init__c s|dkrg}xz|D]r}i}t|d|d<t|drz|d}|d|d<|d|d<t|ddt|ddg|d<|j|qW|S|d kr@g}x|D]} i} tjd j| ddt| ddggtd | d <| d| d <t| ddt| ddg| d<t| ddt| ddg| d<|j| qW|S|dkrrt t |j ||t|dt|dgSt t |j |||SdS)z+Convert input to appropriate format for spmr<rr(rr)r*rrrr+)rrr,rrr-rN) rr r rorrrr.rr@r>rA) rBrCrDrEZ new_channelsrr/r0r1rr2)rFr9r:rANs6    $  . $$  z"MultiChannelNewSegment._format_argc Cs@|jj}g|d<g|d<g|d<g|d<g|d<g|d<g|d<g|d<g|d <d }t|jjrpt|jj}xHt|D]<}|djg|djg|djg|djgqzWx|jjd d D]}t |\}}}t|jjrxt |jjD]\}}|d d r<|d|jt j j |d |d|f|d drr|d|jt j j |d|d|f|dd r|d|jt j j |d|d|f|ddr|d|jt j j |d|d|fqWn"s  #r>c@sxeZdZeedddddddZejejej dddej d d d Z ej d d d Z ej ddd ZejdddddZdS)SmoothInputSpecT)rrzlist of files to smoothF)r rrrr)rVrWrz!3-list of fwhm for each dimension)r rrzData type of the output imagesZimz*A mask implied by a particular voxel valuesrIzsmoothed output prefix)r rrN)r'r(r)r rr[r rgrar/rr]Z data_typer0Zimplicit_maskingrdrer9r9r9r:r?s  r?c@seZdZeeddddZdS)SmoothOutputSpecT)rzsmoothed files)rN)r'r(r)r rsmoothed_filesr9r9r9r:rAsrAcs8eZdZdZeZeZdZdZ fddZ ddZ Z S)Smootha`Use spm_smooth for 3D Gaussian smoothing of image volumes. http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=55 Examples -------- >>> import nipype.interfaces.spm as spm >>> smooth = spm.Smooth() >>> smooth.inputs.in_files = 'functional.nii' >>> smooth.inputs.fwhm = [4, 4, 4] >>> smooth.run() # doctest: +SKIP rZsmoothcst|dkrtt|S|dkr`t|ts0|||gSt|tr`t|dkr\|d|d|dgS|Stt|j|||S)Nr[rrr)r[)rrrlrmrr@rCrA)rBrCrDrE)rFr9r:rAs     zSmooth._format_argcCsH|jj}g|d<x.t|jjD]}|djt||jjdq"W|S)NrB)rI)rJrKrrLr[rorre)rBrMrtr9r9r:rNs  zSmooth._list_outputs) r'r(r)rOr?rPrArQrRrSrArNrTr9r9)rFr:rCs  rCc@seZdZejejedddddddZejdddd d Zej d d d dddZ ejej ej ddej ej ej ej ej dddddddddd ej ddddddddddd d!d"Zej ej ej ddej ddd#d$dZd%S)&DARTELInputSpecT)rzA list of files to be segmentedz warp.imagesF)rr rrTemplatezwarp.settings.templatezPrefix for template)rr rLinearMembraneBendingzwarp.settings.rformz"Form of regularization energy term)r rrr!rr% @irg?r zwarp.settings.paramzList of tuples for each iteration * Inner iterations * Regularization parameters * Time points for deformation model * smoothing parameter )rVrWr rzwarp.settings.optimzpOptimization settings a tuple: * LM regularization * cycles of multigrid solver * relaxation iterations N)r'r(r)r rar image_filesrtemplate_prefixr*regularization_formr.r2r/iteration_parametersoptimization_parametersr9r9r9r:rD sB    rDc@s@eZdZedddZejeddddZejeddddZdS) DARTELOutputSpecTzfinal DARTEL template)rr)rz,Templates from different stages of iteration)rzDARTEL flow fieldsN) r'r(r)rfinal_template_filer ratemplate_filesdartel_flow_fieldsr9r9r9r:rU> s rUcs8eZdZdZeZeZdZdZ fddZ ddZ Z S)DARTELa]Use spm DARTEL to create a template and flow fields http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=185 Examples -------- >>> import nipype.interfaces.spm as spm >>> dartel = spm.DARTEL() >>> dartel.inputs.image_files = [['rc1s1.nii','rc1s2.nii'],['rc2s1.nii', 'rc2s2.nii']] >>> dartel.run() # doctest: +SKIP r>dartelcs|dkrt|dddS|dkr2dddd}||S|d krg}xN|D]F}i}|d|d <t|d|d <|d|d <|d |d<|j|qDW|S|dkri}|d|d<|d|d<|d|d <|gStt|j|||SdS)z+Convert input to appropriate format for spmrPT)rrrRrrr)rFrGrHrSZitsZrparamKrZslamrTZlmregZcycN)rP)rrmror@rYrA)rBrCrDrEZmapperparamsparam new_param)rFr9r:rAY s,        zDARTEL._format_argcCs|jj}g|d<x6tdD]*}|djtjjd|jj|dfqWtjjd|jj|d<g|d<xF|jj dD]6}t |\}}}|djtjjd ||jj|fqzW|S) NrWrz %s_%d.niirz%s_6.niirVrXrz u_%s_%s%s) rJrKr3ror4r5realpathrLrQrPr)rBrMrur7r8r9r:r9r9r:rNt s " zDARTEL._list_outputs) r'r(r)rOrDrPrUrQrRrSrArNrTr9r9)rFr:rYF s  rYc @seZdZeddddddZeedddddd Zeeddd d ddd Zej ej ej ej d ddZ ej ej ej ej ej ej ej d ddZ ej dddZejejej dddej dddZdS)DARTELNorm2MNIInputSpecTFzDARTEL templatezmni_norm.template)rrrrr )rzDARTEL flow fields u_rc1*zmni_norm.data.subjs.flowfields)rrr zFiles to apply the transform tozmni_norm.data.subjs.images)rr rrzVoxel sizes for output filez mni_norm.vox)rr z mni_norm.bbzmni_norm.preservez>> import nipype.interfaces.spm as spm >>> nm = spm.DARTELNorm2MNI() >>> nm.inputs.template_file = 'Template_6.nii' >>> nm.inputs.flowfield_files = ['u_rc1s1_Template.nii', 'u_rc1s3_Template.nii'] >>> nm.inputs.apply_to_files = ['c1s1.nii', 'c1s3.nii'] >>> nm.inputs.modulate = True >>> nm.run() # doctest: +SKIP r>rZcs|d krtj|gtdS|d kr,t|ddS|dkrBt|dddS|dkrRt|S|d krbt|S|d krt|trx|S|||gSntt|j|||Sd S)z+Convert input to appropriate format for spmra)rrbT)rr)rrrcrdrN)ra)rb)r) rrrrrmrlr@rhrA)rBrCrDrE)rFr9r:rA s   zDARTELNorm2MNI._format_argcCs|jj}t|jj\}}}tjj|d|d<g|d<d}t|jj rZ|jj rZd|}t|jj  st|jj dkr|d|}x>|jj D]2}t|\}}}|dj tjjd|||fqW|S) Nz _2mni.matrgrrrrr@z%s%s%s) rJrKrrLrar4r5r_r rerrro)rBrMr8r9r:rIr7r9r9r:rN s zDARTELNorm2MNI._list_outputs) r'r(r)rOr`rPrfrQrRrSrArNrTr9r9)rFr:rh s rhc@sneZdZeedddddddZeeddddddd Zejd d d d dZ ejd ddddZ ej dddZ dS)CreateWarpedInputSpecT)rzA list of files to be warpedzcrt_warped.imagesF)rrr rzDARTEL flow fields u_rc1*zcrt_warped.flowfields)rrr rr z4The number of iterations: log2(number of time steps)z crt_warped.K)r"rYrr rXzcrt_warped.interpz)degree of b-spline used for interpolation)r"rYr rzcrt_warped.jactransfzModulate images)r rN) r'r(r)r rrPrbr r2Z iterationsrr0rer9r9r9r:ri s.ric@seZdZejedddZdS)CreateWarpedOutputSpecTzfinal warped files)rrN)r'r(r)r rar warped_filesr9r9r9r:rk srkcs8eZdZdZeZeZdZdZ fddZ ddZ Z S) CreateWarpedaApply a flow field estimated by DARTEL to create warped images http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=190 Examples -------- >>> import nipype.interfaces.spm as spm >>> create_warped = spm.CreateWarped() >>> create_warped.inputs.image_files = ['rc1s1.nii', 'rc1s2.nii'] >>> create_warped.inputs.flowfield_files = ['u_rc1s1_Template.nii', 'u_rc1s2_Template.nii'] >>> create_warped.run() # doctest: +SKIP r>rZcsB|dkrt|dddS|dkr*t|ddStt|j|||SdS) z+Convert input to appropriate format for spmrPT)rrrb)rN)rP)rb)rr@rmrA)rBrCrDrE)rFr9r:rA5 s  zCreateWarped._format_argcCs|jj}g|d<xp|jjD]d}t|\}}}t|jjrd|jjrd|djtj j d||fq|djtj j d||fqW|S)Nrlzmw%s%szw%s%s) rJrKrLrPrr reror4r5r_)rBrMr7r8r9r:r9r9r:rN? s  "zCreateWarped._list_outputs) r'r(r)rOrirPrkrQrRrSrArNrTr9r9)rFr:rm! s  rmc@sNeZdZeedddddZeddddZeddddZe j dd d d d Z d S)ApplyDeformationFieldInputSpecT)rfnames)rr z comp{1}.def)rrr zcomp{2}.id.spacerrXrz)degree of b-spline used for interpolation)r"rYr rN) r'r(r)r rr[rrreference_volumer r2rr9r9r9r:rnK s  rnc@seZdZeeddZdS)ApplyDeformationFieldOutputSpecT)rN)r'r(r)r rrhr9r9r9r:rqV srqcs4eZdZeZeZdZdZfddZ ddZ Z S)ApplyDeformationsutilZdefscsR|dkr|g}|d kr$t|dddS|d kr:t|dddStt|j|||SdS) z+Convert input to appropriate format for spmrrpTF)rrr[N)rrp)r)r[rp)rr@rrrA)rBrCrDrE)rFr9r:rAa szApplyDeformations._format_argcCsT|jj}g|d<x:|jjD].}tjj|\}}|djtjjd|qW|S)Nrhzw%s) rJrKrLr[r4r5splitror_)rBrMr7_fnamer9r9r:rNn s  zApplyDeformations._list_outputs) r'r(r)rnrPrqrQrRrSrArNrTr9r9)rFr:rrZ s  rrc@sveZdZeedddddddZedddd ZejdTej gd dddZ ej ddUddddZ ej ddVd'dd(dZ ejd dd)d*d+Zejd dd,d-d+Zej d.d/dd0Zedd1d2Zejdd d dd3d4d+Zejd5dd6d7Zej ddd8d9d+Zejddd:d7Zejddd;d7Zejdddd+Zejdd ddd?d@d+ZejdddAd7ZejdddBd7Zejdd d ddCd>d+Zejdd dddDd@d+Z ejdddEd7Z!ejdddFd7Z"ejdd d ddGd>d+Z#ejdd dddHd@d+Z$ejdddId7Z%ejdddJd7Z&ejdddKd7Z'ejdddLd7Z(ejdddMd7Z)ejdd dddNd@d+Z*ejdddOd7Z+ejdWejejddPdQd+Z,dRS)XVBMSegmentInputSpecT)rzA list of files to be segmentedz estwrite.dataF)rr rrz estwrite.tpmztissue probability map)rr rrrr%rz)number of gaussians for each tissue class)rr-C6?rh㈵>MbP?{Gz?皙?rr!zestwrite.opts.biasregzno(0) - extremely heavy (10))r rrrrrrrrrrrrrrzestwrite.opts.biasfwhmz#FWHM of Gaussian smoothness of biaszestwrite.opts.sampz2Sampling distance on data for parameter estimation)rr rzestwrite.opts.warpregz,Controls balance between parameters and datarYr")rz.estwrite.extopts.dartelwarp.normhigh.darteltpm)rr zestwrite.extopts.sanlmz60=No denoising, 1=denoising,2=denoising multi-threadedg333333?zestwrite.extopts.mrf)rr zestwrite.extopts.cleanupz0=None,1=light,2=thoroughzestwrite.extopts.printzestwrite.output.GM.nativezestwrite.output.GM.warpedzestwrite.output.GM.modulatedz:0=none,1=affine+non-linear(SPM8 default),2=non-linear onlyzestwrite.output.GM.dartelz%0=None,1=rigid(SPM8 default),2=affinezestwrite.output.WM.nativezestwrite.output.WM.warpedzestwrite.output.WM.modulatedzestwrite.output.WM.dartelzestwrite.output.CSF.nativezestwrite.output.CSF.warpedzestwrite.output.CSF.modulatedzestwrite.output.CSF.dartelzestwrite.output.bias.nativezestwrite.output.bias.warpedzestwrite.output.bias.affinezestwrite.output.label.nativezestwrite.output.label.warpedzestwrite.output.label.dartelzestwrite.jacobian.warpedzestwrite.output.warpszforward and inverse fieldNrrrrr%r)r})rryrxrzr{r|rr!) rrrrrrrrrrrr)rr)-r'r(r)r rr[rr r.r]rr*rrr/rrspatial_normalizationdartel_templater2Zuse_sanlm_denoising_filterZ mrf_weightingZcleanup_partitionsr0Zdisplay_resultsZ gm_nativeZ gm_normalizedZgm_modulated_normalizedZ gm_dartelZ wm_nativeZ wm_normalizedZwm_modulated_normalizedZ wm_dartelZ csf_nativeZcsf_normalizedZcsf_modulated_normalizedZ csf_dartelbias_corrected_nativebias_corrected_normalizedZbias_corrected_affinepve_label_nativepve_label_normalizedpve_label_darteljacobian_determinantrr9r9r9r:rww s            rwc@seZdZejejeddddZejejeddddZejejeddddZejejeddddZ e eddddZ e eddd dZ e eddd dZ e eddZe eddZe eddZe eddZe eddZe eddZd S) VBMSegmentOuputSpecT)rznative space probability maps)rzdartel imported class imagesznormalized class imagesz!modulated+normalized class imageszNormalization transformationzbias corrected imagesN)r'r(r)r rarrrr r!r rr" normalized_bias_corrected_imagespve_label_native_imagespve_label_normalized_imagespve_label_registered_imagesr$r%jacobian_determinant_imagesr9r9r9r:r! s(rcsDeZdZdZeZeZdZdZ ddZ fddZ fdd Z Z S) VBMSegmentaEUse VBM8 toolbox to separate structural images into different tissue classes. Example ------- >>> import nipype.interfaces.spm as spm >>> seg = spm.VBMSegment() >>> seg.inputs.tissues = 'TPM.nii' >>> seg.inputs.dartel_template = 'Template_1_IXI550_MNI152.nii' >>> seg.inputs.bias_corrected_native = True >>> seg.inputs.gm_native = True >>> seg.inputs.wm_native = True >>> seg.inputs.csf_native = True >>> seg.inputs.pve_label_native = True >>> seg.inputs.deformation_field = (True, False) >>> seg.run() # doctest: +SKIP r>Zvbm8c Cs|jj}|jj}d}|r d}gggg|d<gggg|d<gggg|d<gggg|d<g|d<g|d<g|d <g|d <g|d <g|d <g|d <g|d<g|d<xJ|jjD]<}t|\}}}|djtjj |d|xt dddgD]|\}} t |jd| r2|d|jtjj |d|d|ft |jd| dkrr|d|jtjj |d|d|fn>t |jd| dkr|d|jtjj |d|d|ft |jd| r|d|jtjj |d||d|ft |jd| dkr.|d|jtjj |d||d|fqt |jd| dkr|d|jtjj |d||d|fqW|jj r|d jtjj |d ||jj r|djtjj |d!||f|jjdkr|djtjj |d"|n*|jjdkr|djtjj |d#||jjr<|djtjj |d$||jjrf|d jtjj |d%||f|jjd&r|d jtjj |d'||f|jjdr|d jtjj |d(||f|jjr|r|d jtjj |d)|qW|S)*Nrrrrr r!rr"rr%r$rrrrz %s_seg8.matr rrz %s_nativez p%d%s.niirz %s_dartelz rp%d%s.niirzrp%d%s_affine.niiz %s_normalizedz w%sp%d%s.niiz%s_modulated_normalizedz mw%sp%d%s.niizm0w%sp%d%s.niizp0%s.niiz w%sp0%s.niiz rp0%s.niizrp0%s_affine.niizm%s.niiz wm%s%s.niirz y_%s%s.niiz iy_%s%s.niizjac_wrp1%s.nii)rJrKrLr~r[rror4r5rrnrrrrrrrr) rBrMZ do_dartelZ dartel_pxr7r8r9r:ruZtisr9r9r:rN] s        "     zVBMSegment._list_outputscs|d krt|ddS|dkr.|dkrdgiSn\|dkrFtj|gtdS|dkrvtt|j||t|d t|d gStt|j|||Sd S)z+Convert input to appropriate format for spmr[T)rr~r"normlowr)rrrrN)r[)r~)r)r)rrrrr@rrAr )rBrCrDrE)rFr9r:rA s   zVBMSegment._format_argcsP|jjdkr:tt|jd d}ddi|ddd d <|Stt|jddSdS) Nr"r~r)rrrrrZextoptsZ dartelwarp)r~r)rLr~r@rrG)rBrH)rFr9r:rG s   zVBMSegment._parse_inputs)r'r(r)rOrwrPrrQrRrSrNrArGrTr9r9)rFr:rD si r)NrOr4copyrnumpyrZutils.filemaniprrrrr9r r r r r rrrrrrrrrZ __docformat__rr;r=rUrfrjrxr~rrrrrrrrrrrrrrrrrrrrrr&r;r=r>r?rArCrDrUrYr`rfrhrirkrmrnrqrrrwrrr9r9r9r:s ( !56<+2IZaJ I^ ]w\I@K,9A2 =* +#