def _run_interface(self, runtime): from pyacwereg import viz if self.inputs.view == 'all': view = ['axial', 'coronal', 'sagittal'] else: view = np.atleast_1d(self.inputs.view).tolist() label = None if isdefined(self.inputs.label): label = self.inputs.label slices = None if isdefined(self.inputs.slices): slices = self.inputs.slices if self.inputs.split: self._out_file = [] for i, v in enumerate(view): o = op.abspath('%s%04d.pdf' % (self.inputs.out_file, i)) viz.slices_gridplot(self.inputs.in_files, view=v, out_file=o, label=label[i], slices=slices) self._out_file.append(o) else: self._out_file = [op.abspath(self.inputs.out_file + '.pdf')] viz.slices_gridplot(self.inputs.in_files, view=view, out_file=self._out_file, label=label, slices=slices) return runtime
def _check_mlab_inputs(self): if not isdefined(self.inputs.matlab_cmd) and self._matlab_cmd: self.inputs.matlab_cmd = self._matlab_cmd if not isdefined(self.inputs.paths) and self._paths: self.inputs.paths = self._paths if not isdefined(self.inputs.use_mcr) and self._use_mcr: self.inputs.use_mcr = self._use_mcr
def _list_outputs(self): outputs = self.output_spec().get() outputs['out_file'] = self.inputs.out_file if not isdefined(outputs['out_file']) and isdefined(self.inputs.in_file): outputs['out_file']=self._gen_fname(self.inputs.in_file, suffix='_sigloss') return outputs
def _list_outputs(self): """Execute this module. """ outdir = self.inputs.base_directory if not isdefined(outdir): outdir = os.path.abspath('.') if isdefined(self.inputs.container): print "container defined", self.inputs.container outdir = os.path.join(outdir, self.inputs.container) print outdir cwd = os.getcwd() dst = self._get_dst(os.path.join(cwd,self.inputs.json_name+'.json')) print "dst = ", dst outdir = os.path.join(outdir,dst) print "new outdir = ", outdir outdir = self._substitute(outdir) print "substituted outdir = ", outdir if not os.path.exists(outdir): try: os.makedirs(outdir) except OSError, inst: if 'File exists' in inst: pass else: raise(inst)
def _run_interface(self, runtime): mask_erode_mm = self.inputs.mask_erode_mm if not isdefined(mask_erode_mm): mask_erode_mm = None erode_mm = self.inputs.erode_mm if not isdefined(erode_mm): erode_mm = None mask_erode_prop = self.inputs.mask_erode_prop if not isdefined(mask_erode_prop): mask_erode_prop = None erode_prop = self.inputs.erode_prop if not isdefined(erode_prop): erode_prop = None roi_file, eroded_mask = _tpm2roi( self.inputs.in_tpm, self.inputs.in_mask, mask_erode_mm, erode_mm, mask_erode_prop, erode_prop, self.inputs.prob_thresh, newpath=runtime.cwd, ) self._results['roi_file'] = roi_file self._results['eroded_mask'] = eroded_mask return runtime
def _list_outputs(self): outputs = self.output_spec().get() #if isdefined(self.inputs.output_csv_file): #write to a csv file and assign a value to self.coherence_file (a #file name + path) #Always defined (the arrays): outputs['coherence_array']=self.coherence outputs['timedelay_array']=self.delay #Conditional if isdefined(self.inputs.output_csv_file) and hasattr(self,'coherence'): # we need to make a function that we call here that writes the # coherence values to this file "coherence_csv" and makes the # time_delay csv file?? self._make_output_files() outputs['coherence_csv']=fname_presuffix(self.inputs.output_csv_file,suffix='_coherence') outputs['timedelay_csv']=fname_presuffix(self.inputs.output_csv_file,suffix='_delay') if isdefined(self.inputs.output_figure_file) and hasattr(self, 'coherence'): self._make_output_figures() outputs['coherence_fig'] = fname_presuffix(self.inputs.output_figure_file,suffix='_coherence') outputs['timedelay_fig'] = fname_presuffix(self.inputs.output_figure_file,suffix='_delay') return outputs
def _list_outputs(self): outputs = self.output_spec().get() outputs['out_file'] = os.path.join(os.getcwd(), self.inputs.out_base + '.nii.gz') if not (isdefined(self.inputs.no_fmapreg) and self.inputs.no_fmapreg) and isdefined(self.inputs.fmap): outputs['out_1vol'] = os.path.join(os.getcwd(), self.inputs.out_base + '_1vol.nii.gz') outputs['fmap2str_mat'] = os.path.join(os.getcwd(), self.inputs.out_base + '_fieldmap2str.mat') outputs['fmap2epi_mat'] = os.path.join(os.getcwd(), self.inputs.out_base + '_fieldmaprads2epi.mat') outputs['fmap_epi'] = os.path.join(os.getcwd(), self.inputs.out_base + '_fieldmaprads2epi.nii.gz') outputs['fmap_str'] = os.path.join(os.getcwd(), self.inputs.out_base + '_fieldmaprads2str.ni `i.gz') outputs['fmapmag_str'] = os.path.join(os.getcwd(), self.inputs.out_base + '_fieldmap2str.nii.gz') outputs['shiftmap'] = os.path.join(os.getcwd(), self.inputs.out_base + '_fieldmaprads2epi_shift.nii.gz') outputs['fullwarp'] = os.path.join(os.getcwd(), self.inputs.out_base + '_warp.nii.gz') outputs['epi2str_inv'] = os.path.join(os.getcwd(), self.inputs.out_base + '_inv.mat') outputs['epi2str_mat'] = os.path.join(os.getcwd(), self.inputs.out_base + '.mat') outputs['wmedge'] = os.path.join(os.getcwd(), self.inputs.out_base + '_fast_wmedge.nii.gz') outputs['wmseg'] = os.path.join(os.getcwd(), self.inputs.out_base + '_fast_wmseg.nii.gz') return outputs
def _run_interface(self, runtime): in_file_ref = Path(self.inputs.in_file) if isdefined(self.inputs.out_file): in_file_ref = Path(self.inputs.out_file) fname = in_file_ref.name.rstrip( ''.join(in_file_ref.suffixes)) out_file = (Path(runtime.cwd) / ('plot_%s_contours.svg' % fname)).resolve() self._results['out_file'] = str(out_file) vmax = None if not isdefined(self.inputs.vmax) else self.inputs.vmax vmin = None if not isdefined(self.inputs.vmin) else self.inputs.vmin plot_segmentation( self.inputs.in_file, self.inputs.in_contours, out_file=str(out_file), cut_coords=self.inputs.cut_coords, display_mode=self.inputs.display_mode, levels=self.inputs.levels, colors=self.inputs.colors, saturate=self.inputs.saturate, vmin=vmin, vmax=vmax) return runtime
def modify_paths(object, relative=True, basedir=None): """Modify filenames in a data structure to either full paths or relative paths """ if not basedir: basedir = os.getcwd() if isinstance(object, dict): out = {} for key, val in sorted(object.items()): if isdefined(val): out[key] = modify_paths(val, relative=relative, basedir=basedir) elif isinstance(object, (list,tuple)): out = [] for val in object: if isdefined(val): out.append(modify_paths(val, relative=relative, basedir=basedir)) if isinstance(object, tuple): out = tuple(out) else: if isdefined(object): if isinstance(object, str) and os.path.isfile(object): if relative: if config.getboolean('execution','use_relative_paths'): out = relpath(object,start=basedir) else: out = object else: out = os.path.abspath(os.path.join(basedir,object)) if not os.path.exists(out): raise FileNotFoundError('File %s not found'%out) else: out = object return out
def _list_outputs(self): outputs = self._outputs().get() jobtype = self.inputs.jobtype if jobtype.startswith('est'): outputs['normalization_parameters'] = [] for imgf in filename_to_list(self.inputs.source): outputs['normalization_parameters'].append(fname_presuffix(imgf, suffix='_sn.mat', use_ext=False)) outputs['normalization_parameters'] = list_to_filename(outputs['normalization_parameters']) if self.inputs.jobtype == "estimate": if isdefined(self.inputs.apply_to_files): outputs['normalized_files'] = self.inputs.apply_to_files outputs['normalized_source'] = self.inputs.source elif 'write' in self.inputs.jobtype: outputs['normalized_files'] = [] if isdefined(self.inputs.apply_to_files): for imgf in filename_to_list(self.inputs.apply_to_files): outputs['normalized_files'].append(fname_presuffix(imgf, prefix='w')) if isdefined(self.inputs.source): outputs['normalized_source'] = [] for imgf in filename_to_list(self.inputs.source): outputs['normalized_source'].append(fname_presuffix(imgf, prefix='w')) return outputs
def _format_arg(self, opt, spec, val): if opt == 'moving_image': retval = [] for ii in range(len(self.inputs.moving_image)): retval.append('--metric "%s[%s,%s,%d,%d]"' % (self.inputs.metric, self.inputs.fixed_image[ii], self.inputs.moving_image[ii],self.inputs.metric_weight,self.inputs.radius)) return " ".join(retval) elif opt == 'moving_image_mask': return '--masks "[%s,%s]"' % (self.inputs.fixed_image_mask, self.inputs.moving_image_mask) elif opt == 'initial_moving_transform': if isdefined(self.inputs.invert_initial_moving_transform) and self.inputs.invert_initial_moving_transform: return '--initial-moving-transform "[%s,1]"' % self.inputs.initial_moving_transform else: return '--initial-moving-transform "[%s,0]"' % self.inputs.initial_moving_transform elif opt == "number_of_iterations": convergence_iter = "x".join([str(i) for i in self.inputs.number_of_iterations]) return '--convergence "[%s,%g,%d]"' % (convergence_iter, self.inputs.convergence_threshold, self.inputs.convergence_window_size) elif opt == 'output_transform_prefix': if isdefined(self.inputs.output_inverse_warped_image) and self.inputs.output_inverse_warped_image: return '--output "[%s,%s,%s]"' % (self.inputs.output_transform_prefix, self.inputs.output_warped_image, self.inputs.output_inverse_warped_image ) elif isdefined(self.inputs.output_warped_image) and self.inputs.output_warped_image: return '--output "[%s,%s]"' % (self.inputs.output_transform_prefix, self.inputs.output_warped_image ) else: return '--output %s' % self.inputs.output_transform_prefix return super(antsRegistration, self)._format_arg(opt, spec, val)
def _list_outputs(self): outputs = self._outputs().get() outputs["out_file"] = self.inputs.out_file if not isdefined(outputs["out_file"]): source = self.inputs.source_file # Some recon-all files don't have a proper extension (e.g. "lh.thickness") # so we have to account for that here bad_extensions = [".%s" % e for e in ["area", "mid", "pial", "avg_curv", "curv", "inflated", "jacobian_white", "orig", "nofix", "smoothwm", "crv", "sphere", "sulc", "thickness", "volume", "white"]] use_ext = True if split_filename(source)[2] in bad_extensions: source = source + ".stripme" use_ext = False ext = "" if isdefined(self.inputs.target_type): ext = "." + filemap[self.inputs.target_type] use_ext = False outputs["out_file"] = fname_presuffix(source, suffix=".%s%s" % (self.inputs.target_subject, ext), newpath=os.getcwd(), use_ext=use_ext) else: outputs["out_file"] = os.path.abspath(self.inputs.out_file) return outputs
def _format_arg(self, name, trait_spec, value): if name == 'syn_file': if (isdefined(self.inputs.bvec_file) == False) or (isdefined(self.inputs.b0_file) == False): return "" else: return trait_spec.argstr % value return super(DwiTool, self)._format_arg(name, trait_spec, value)
def _gen_outfilename(self): out_file = self.inputs.out_file if not isdefined(out_file) and isdefined(self.inputs.in_file): out_file = self._gen_fname(self.inputs.in_file, suffix="_surf") #out_file = self._gen_fname(self.inputs.in_file, suffix="_surf") return out_file
def _parse_inputs( self, skip=None ): if skip is None: skip = [] if not isdefined(self.inputs.out_base ): self.inputs.out_base = './nipypetu' self.inputs.out_base = os.path.abspath(self.inputs.out_base) if isdefined( self.inputs.encoding_file ): skip.append( 'encoding_direction' ) skip.append( 'readout_times' ) else: encdir = 'y' enctimes = None if isdefined( self.inputs.encoding_direction ): encdir = self.inputs.encoding_direction if isdefined( self.inputs.readout_times ): enctimes = self.inputs.readout_times self.inputs.encoding_file = self._generate_encfile( encdir, enctimes ) return super(TOPUP, self)._parse_inputs(skip=skip)
def _list_outputs(self): outputs = self._outputs().get() jobtype = self.inputs.jobtype if jobtype.startswith("est"): outputs["normalization_parameters"] = [] for imgf in filename_to_list(self.inputs.source): outputs["normalization_parameters"].append(fname_presuffix(imgf, suffix="_sn.mat", use_ext=False)) outputs["normalization_parameters"] = list_to_filename(outputs["normalization_parameters"]) if self.inputs.jobtype == "estimate": if isdefined(self.inputs.apply_to_files): outputs["normalized_files"] = self.inputs.apply_to_files outputs["normalized_source"] = self.inputs.source elif "write" in self.inputs.jobtype: outputs["normalized_files"] = [] if isdefined(self.inputs.apply_to_files): for imgf in filename_to_list(self.inputs.apply_to_files): outputs["normalized_files"].append(fname_presuffix(imgf, prefix="w")) if isdefined(self.inputs.source): outputs["normalized_source"] = [] for imgf in filename_to_list(self.inputs.source): outputs["normalized_source"].append(fname_presuffix(imgf, prefix="w")) return outputs
def _list_outputs(self): outputs = self.output_spec().get() _in = self.inputs if isdefined(_in.out_reg_file): outputs["out_reg_file"] = op.abspath(_in.out_reg_file) elif _in.source_file: suffix = "_bbreg_%s.dat" % _in.subject_id outputs["out_reg_file"] = fname_presuffix(_in.source_file, suffix=suffix, use_ext=False) if isdefined(_in.registered_file): if isinstance(_in.registered_file, bool): outputs["registered_file"] = fname_presuffix(_in.source_file, suffix="_bbreg") else: outputs["registered_file"] = op.abspath(_in.registered_file) if isdefined(_in.out_fsl_file): if isinstance(_in.out_fsl_file, bool): suffix = "_bbreg_%s.mat" % _in.subject_id out_fsl_file = fname_presuffix(_in.source_file, suffix=suffix, use_ext=False) outputs["out_fsl_file"] = out_fsl_file else: outputs["out_fsl_file"] = op.abspath(_in.out_fsl_file) outputs["min_cost_file"] = outputs["out_reg_file"] + ".mincost" return outputs
def _run_interface(self, runtime): out_file = op.abspath(self._gen_outfilename()) settings = dict(mask=None, rician=(self.inputs.noise_model == 'rician')) if isdefined(self.inputs.in_mask): settings['mask'] = nb.load(self.inputs.in_mask).get_data() if isdefined(self.inputs.patch_radius): settings['patch_radius'] = self.inputs.patch_radius if isdefined(self.inputs.block_radius): settings['block_radius'] = self.inputs.block_radius noise_mask = None if isdefined(self.inputs.in_mask): noise_mask = nb.load(self.inputs.noise_mask).get_data() _, s = nlmeans_proxy(self.inputs.in_file, settings, noise_mask=noise_mask, out_file=out_file) iflogger.info(('Denoised image saved as {i}, estimated ' 'sigma={s}').format(i=out_file, s=s)) return runtime
def _list_outputs(self): outputs = self.output_spec().get() if not isdefined(self.inputs.out_dir): out_dir = self._gen_filename("out_dir") else: out_dir = self.inputs.out_dir outputs['log'] = os.path.abspath(os.path.join(out_dir, 'probtrackx.log')) #utputs['way_total'] = os.path.abspath(os.path.join(out_dir, 'waytotal')) if isdefined(self.inputs.opd == True): if isinstance(self.inputs.seed, list) and isinstance(self.inputs.seed[0], list): outputs['fdt_paths'] = [] for seed in self.inputs.seed: outputs['fdt_paths'].append( os.path.abspath( self._gen_fname("fdt_paths_%s" % ("_".join([str(s) for s in seed])), cwd=out_dir, suffix=''))) else: outputs['fdt_paths'] = os.path.abspath(self._gen_fname("fdt_paths", cwd=out_dir, suffix='')) # handle seeds-to-target output files if isdefined(self.inputs.target_masks): outputs['targets'] = [] for target in self.inputs.target_masks: outputs['targets'].append(os.path.abspath( self._gen_fname('seeds_to_' + os.path.split(target)[1], cwd=out_dir, suffix=''))) if isdefined(self.inputs.verbose) and self.inputs.verbose == 2: outputs['particle_files'] = [os.path.abspath( os.path.join(out_dir, 'particle%d' % i)) for i in range(self.inputs.n_samples)] return outputs
def _post_run_hook(self, runtime): outputs = self.aggregate_outputs(runtime=runtime) mri_dir = None if isdefined(self.inputs.subject_id): mri_dir = os.path.join(self.inputs.subjects_dir, self.inputs.subject_id, 'mri') if isdefined(self.inputs.reference_file): target_file = self.inputs.reference_file else: target_file = os.path.join(mri_dir, 'brainmask.mgz') # Apply transform for simplicity mri_vol2vol = fs.ApplyVolTransform( source_file=self.inputs.source_file, target_file=target_file, lta_file=outputs.out_lta_file, interp='nearest') res = mri_vol2vol.run() self._fixed_image = target_file self._moving_image = res.outputs.transformed_file if mri_dir is not None: self._contour = os.path.join(mri_dir, 'ribbon.mgz') NIWORKFLOWS_LOG.info( 'Report - setting fixed (%s) and moving (%s) images', self._fixed_image, self._moving_image) return super(MRICoregRPT, self)._post_run_hook(runtime)
def _run_interface(self, runtime): mask = None if isdefined(self.inputs.in_mask): mask = self.inputs.in_mask title = self.inputs.title if isdefined(self.inputs.subject): title += ', subject %s' % self.inputs.subject if isdefined(self.inputs.metadata): title += ' (' + '_'.join(self.inputs.metadata) + ')' if isdefined(self.inputs.figsize): fig = plot_mosaic( self.inputs.in_file, title=title, overlay_mask=mask, figsize=self.inputs.figsize) else: fig = plot_mosaic( self.inputs.in_file, title=title, overlay_mask=mask) fig.savefig(self.inputs.out_file, dpi=self.inputs.dpi) return runtime
def _list_outputs(self): outputs = self._outputs().get() outputs['outlier_files'] = [] outputs['intensity_files'] = [] outputs['statistic_files'] = [] if isdefined(self.inputs.use_norm) and self.inputs.use_norm: outputs['norm_files'] = [] if isdefined(self.inputs.save_plot) and self.inputs.save_plot: outputs['plot_files'] = [] for i, f in enumerate(filename_to_list(self.inputs.realigned_files)): outlierfile, intensityfile, statsfile, normfile, plotfile = self._get_output_filenames(f, os.getcwd()) outputs['outlier_files'].insert(i, outlierfile) outputs['intensity_files'].insert(i, intensityfile) outputs['statistic_files'].insert(i, statsfile) if isdefined(self.inputs.use_norm) and self.inputs.use_norm: outputs['norm_files'].insert(i, normfile) if isdefined(self.inputs.save_plot) and self.inputs.save_plot: outputs['plot_files'].insert(i, plotfile) ''' outputs['outlier_files'] = list_to_filename(outputs['outlier_files']) outputs['intensity_files'] = list_to_filename(outputs['intensity_files']) outputs['statistic_files'] = list_to_filename(outputs['statistic_files']) if isdefined(self.inputs.use_norm) and self.inputs.use_norm: outputs['norm_files'] = list_to_filename(outputs['norm_files']) if isdefined(self.inputs.save_plot) and self.inputs.save_plot: outputs['plot_files'] = list_to_filename(outputs['plot_files']) ''' return outputs
def _get_dst(self, src): path, fname = os.path.split(src) if self.inputs.parameterization: dst = path if isdefined(self.inputs.strip_dir): dst = dst.replace(self.inputs.strip_dir, '') if not isdefined(self.inputs.container): folders = [folder for folder in dst.split(os.path.sep) if folder.startswith('_')] else: folders = [folder for folder in dst.split(os.path.sep) if (folder.startswith('_') and not self.inputs.container in folder)] dst = os.path.sep.join(folders).replace('_','') else: if fname: dst = fname else: dst = path.split(os.path.sep)[-1] try: if dst[0] == os.path.sep(dst): dst = dst[1:] except: pass return dst
def _list_outputs(self): outputs = self.output_spec().get() outputs["out_reg_file"] = self.inputs.out_reg_file if not isdefined(self.inputs.out_reg_file) and self.inputs.source_file: outputs["out_reg_file"] = fname_presuffix(self.inputs.source_file, suffix="_robustreg.lta", use_ext=False) prefices = dict(src=self.inputs.source_file, trg=self.inputs.target_file) suffices = dict( registered_file=("src", "_robustreg", True), weights_file=("src", "_robustweights", True), half_source=("src", "_halfway", True), half_targ=("trg", "_halfway", True), half_weights=("src", "_halfweights", True), half_source_xfm=("src", "_robustxfm.lta", False), half_targ_xfm=("trg", "_robustxfm.lta", False), ) for name, sufftup in suffices.items(): value = getattr(self.inputs, name) if isdefined(value): if isinstance(value, bool): outputs[name] = fname_presuffix( prefices[sufftup[0]], suffix=sufftup[1], newpath=os.getcwd(), use_ext=sufftup[2] ) else: outputs[name] = value return outputs
def _generate_design(self, infolist=None): """Generate design specification for a typical fmri paradigm """ realignment_parameters = [] if isdefined(self.inputs.realignment_parameters): for parfile in self.inputs.realignment_parameters: realignment_parameters.append(np.loadtxt(parfile)) outliers = [] if isdefined(self.inputs.outlier_files): for filename in self.inputs.outlier_files: try: outindices = np.loadtxt(filename, dtype=int) except IOError: outliers.append([]) else: if outindices.size == 1: outliers.append([outindices.tolist()]) else: outliers.append(outindices.tolist()) if infolist is None: if isdefined(self.inputs.subject_info): infolist = self.inputs.subject_info else: infolist = gen_info(self.inputs.event_files) self._sessinfo = self._generate_standard_design( infolist, functional_runs=self.inputs.functional_runs, realignment_parameters=realignment_parameters, outliers=outliers, )
def _run_interface(self, runtime): if not isdefined(self.inputs.screenshot_stem): stem = "%s_%s_%s" % ( self.inputs.subject_id, self.inputs.hemi, self.inputs.surface) else: stem = self.inputs.screenshot_stem stem_args = self.inputs.stem_template_args if isdefined(stem_args): args = tuple([getattr(self.inputs, arg) for arg in stem_args]) stem = stem % args # Check if the DISPLAY variable is set -- should avoid crashes (might not?) if not "DISPLAY" in os.environ: raise RuntimeError("Graphics are not enabled -- cannot run tksurfer") runtime.environ["_SNAPSHOT_STEM"] = stem self._write_tcl_script() runtime = super(SurfaceSnapshots, self)._run_interface(runtime) # If a display window can't be opened, this will crash on # aggregate_outputs. Let's try to parse stderr and raise a # better exception here if that happened. errors = ["surfer: failed, no suitable display found", "Fatal Error in tksurfer.bin: could not open display"] for err in errors: if err in runtime.stderr: self.raise_exception(runtime) # Tksurfer always (or at least always when you run a tcl script) # exits with a nonzero returncode. We have to force it to 0 here. runtime.returncode = 0 return runtime
def _run_interface(self, runtime): print 'in plot_coclass' coclass_matrix_file = self.inputs.coclass_matrix_file labels_file = self.inputs.labels_file list_value_range = self.inputs.list_value_range print 'loading coclass' coclass_mat = np.load(coclass_matrix_file) if isdefined(labels_file): print 'loading labels' labels = [line.strip() for line in open(labels_file)] else : labels = [] if not isdefined(list_value_range): list_value_range = [np.amin(coclass_mat),np.amax(coclass_mat)] print 'plotting heatmap' path,fname,ext = split_f(coclass_matrix_file) plot_coclass_matrix_file = os.path.abspath('heatmap_' + fname + '.eps') plot_ranged_cormat(plot_coclass_matrix_file,coclass_mat,labels,fix_full_range = list_value_range) return runtime
def _list_outputs(self): outputs = self._outputs().get() jobtype = self.inputs.jobtype if jobtype.startswith('est'): outputs['normalization_parameters'] = [] for imgf in filename_to_list(self.inputs.source): outputs['normalization_parameters'].append(fname_presuffix(imgf, suffix='_sn.mat', use_ext=False)) outputs['normalization_parameters'] = list_to_filename(outputs['normalization_parameters']) if self.inputs.jobtype == "estimate": if isdefined(self.inputs.apply_to_files): outputs['normalized_files'] = self.inputs.apply_to_files outputs['normalized_source'] = self.inputs.source elif 'write' in self.inputs.jobtype: outputs['normalized_files'] = [] if isdefined(self.inputs.apply_to_files): filelist = filename_to_list(self.inputs.apply_to_files) for f in filelist: if isinstance(f, list): run = [fname_presuffix(in_f, prefix=self.inputs.out_prefix) for in_f in f] else: run = [fname_presuffix(f, prefix=self.inputs.out_prefix)] outputs['normalized_files'].extend(run) if isdefined(self.inputs.source): outputs['normalized_source'] = fname_presuffix(self.inputs.source, prefix=self.inputs.out_prefix) return outputs
def _run_interface(self, runtime): tracks, header = trk.read(self.inputs.in_file) if not isdefined(self.inputs.data_dims): data_dims = header['dim'] else: data_dims = self.inputs.data_dims if not isdefined(self.inputs.voxel_dims): voxel_size = header['voxel_size'] else: voxel_size = self.inputs.voxel_dims affine = header['vox_to_ras'] streams = ((ii[0]) for ii in tracks) data = density_map(streams, data_dims, voxel_size) if data.max() < 2**15: data = data.astype('int16') img = nb.Nifti1Image(data,affine) out_file = op.abspath(self.inputs.out_filename) nb.save(img, out_file) iflogger.info('Track density map saved as {i}'.format(i=out_file)) iflogger.info('Data Dimensions {d}'.format(d=data_dims)) iflogger.info('Voxel Dimensions {v}'.format(v=voxel_size)) return runtime
def _list_outputs(self): outputs = self.output_spec().get() outfile = self.inputs.binary_file if not isdefined(outfile): if isdefined(self.inputs.out_type): outfile = fname_presuffix(self.inputs.in_file, newpath=os.getcwd(), suffix='.'.join(('_thresh', self.inputs.out_type)), use_ext=False) else: outfile = fname_presuffix(self.inputs.in_file, newpath=os.getcwd(), suffix='_thresh') outputs['binary_file'] = outfile value = self.inputs.count_file if isdefined(value): if isinstance(value, bool): if value: outputs['count_file'] = fname_presuffix(self.inputs.in_file, suffix='_count.txt', newpath=os.getcwd(), use_ext=False) else: outputs['count_file'] = value return outputs
def _post_run_hook(self, runtime): """ generates a report showing slices from each axis """ brain_extraction_mask = self.aggregate_outputs( runtime=runtime).BrainExtractionMask if (isdefined(self.inputs.keep_temporary_files) and self.inputs.keep_temporary_files == 1): self._anat_file = self.aggregate_outputs( runtime=runtime).N4Corrected0 else: self._anat_file = self.inputs.anatomical_image self._mask_file = brain_extraction_mask self._seg_files = [brain_extraction_mask] self._masked = False NIWORKFLOWS_LOG.info( 'Generating report for ANTS BrainExtraction. file "%s", mask "%s"', self._anat_file, self._mask_file, ) return super(BrainExtractionRPT, self)._post_run_hook(runtime)
def _generate_segment(self): if not isdefined(self.inputs.subjects_dir): freesurfer_status = 'Not run' else: recon = fs.ReconAll(subjects_dir=self.inputs.subjects_dir, subject_id=self.inputs.subject_id, T1_files=self.inputs.t1w, flags='-noskullstrip') if recon.cmdline.startswith('echo'): freesurfer_status = 'Pre-existing directory' else: freesurfer_status = 'Run by sMRIPrep' t2w_seg = '' if self.inputs.t2w: t2w_seg = '(+ {:d} T2-weighted)'.format(len(self.inputs.t2w)) return SUBJECT_TEMPLATE.format(subject_id=self.inputs.subject_id, n_t1s=len(self.inputs.t1w), t2w=t2w_seg, output_spaces=', '.join( self.inputs.output_spaces), freesurfer_status=freesurfer_status)
def _check_len(self, name, new): if name == "keys": nitems = len(new) if len(set(new)) != nitems: raise ValueError( 'Found duplicated entries in the index of ordered keys') if not isdefined(self.inputs.keys): return if name == "key" and new not in self.inputs.keys: raise ValueError('Selected key "%s" not found in the index' % new) if name in self._fields: if isinstance(new, str) or len(new) < 1: raise ValueError( 'Trying to set an invalid value (%s) for input "%s"' % (new, name)) if len(new) != len(self.inputs.keys): raise ValueError( 'Length of value (%s) for input field "%s" does not match ' 'the length of the indexing list.' % (new, name))
def _list_outputs(self): """Create a Bunch which contains all possible files generated by running the interface. Some files are always generated, others depending on which ``inputs`` options are set. Returns ------- outputs : Bunch object Bunch object containing all possible files generated by interface object. If None, file was not generated Else, contains path, filename of generated outputfile """ outputs = self._outputs().get() ext = Info.output_type_to_ext(self.inputs.output_type) outbase = 'vol*' if isdefined(self.inputs.out_base_name): outbase = '%s*' % self.inputs.out_base_name outputs['out_files'] = sorted(glob(os.path.join(os.getcwd(), outbase + ext))) return outputs
def _run_interface(self, runtime): sub = self.inputs.sub ses = self.inputs.ses task = self.inputs.task fwhm = self.inputs.fwhm run = self.inputs.run rec = self.inputs.rec acq = self.inputs.acq df = pd.DataFrame([], columns=metric_columns) for metric_name, metric_function in pvc_metrics.items(): mse = pvc_mse(self.inputs.pvc, self.inputs.pve, fwhm) temp = pd.DataFrame( [['pvc', sub, ses, task, run, acq, rec, 02, metric_name, mse]], columns=metric_columns) df = pd.concat([df, temp]) df.fillna(0, inplace=True) if not isdefined(self.inputs.out_file): self.inputs.out_file = self._gen_output( self.inputs.sub, self.inputs.ses, self.inputs.task, self.inputs.run, self.inputs.acq, self.inputs.rec) df.to_csv(self.inputs.out_file, index=False) return runtime
def _run_interface(self, runtime): self._merged_file = None if not isdefined(self.inputs.in_files): return runtime in_imgs = [nib.load(in_file) for in_file in self.inputs.in_files] if len(in_imgs) == 0: return runtime outshape = first(in_imgs).shape assert all(in_img.shape == outshape for in_img in in_imgs) in_data = [np.asanyarray(in_img.dataobj).astype(np.bool) for in_img in in_imgs] outarr = np.logical_and.reduce(in_data) outimg = new_img_like(first(in_imgs), outarr) self._merged_file = op.abspath(f"merged.nii.gz") nib.save(outimg, self._merged_file) return runtime
def _post_run_hook(self, runtime): self._fixed_image = self.inputs.after self._moving_image = self.inputs.before if self.inputs.base == 'before': resampled_after = nli.resample_to_img(self._fixed_image, self._moving_image) fname = fname_presuffix(self._fixed_image, suffix='_resampled', newpath=runtime.cwd) resampled_after.to_filename(fname) self._fixed_image = fname else: resampled_before = nli.resample_to_img(self._moving_image, self._fixed_image) fname = fname_presuffix(self._moving_image, suffix='_resampled', newpath=runtime.cwd) resampled_before.to_filename(fname) self._moving_image = fname self._contour = self.inputs.wm_seg if isdefined(self.inputs.wm_seg) else None NIWORKFLOWS_LOG.info( 'Report - setting before (%s) and after (%s) images', self._fixed_image, self._moving_image) runtime = super(ResampleBeforeAfterRPT, self)._post_run_hook(runtime) NIWORKFLOWS_LOG.info('Successfully created report (%s)', self._out_report) os.unlink(fname) return runtime
def _run_interface(self, runtime): models = self.inputs.model if not isinstance(models, list): layout = gb.BIDSLayout(self.inputs.bids_dir) if not isdefined(models): models = layout.get(type='model') if not models: raise ValueError("No models found") elif models == 'default': models = ba.auto_model(layout) models = [_ensure_model(m) for m in models] if self.inputs.selectors: # This is almost certainly incorrect models = [model for model in models if all(val in model['input'].get(key, [val]) for key, val in self.inputs.selectors.items())] self._results['model_spec'] = models return runtime
def _run_interface(self, runtime): function_handle = create_function_from_source(self.inputs.function_str) args = {} for name in self._input_names: value = getattr(self.inputs, name) if isdefined(value): args[name] = value out = function_handle(**args) if len(self._output_names) == 1: self._out[self._output_names[0]] = out else: if isinstance(out, tuple) and (len(out) != len(self._output_names)): raise RuntimeError('Mismatch in number of expected outputs') else: for idx, name in enumerate(self._output_names): self._out[name] = out[idx] return runtime
def _list_outputs(self): outputs = self.output_spec().get() includelist = [ re.match(self.inputs.pattern, in_value) is None for in_value in self.inputs.keys ] for field in self._fields: valuelist = getattr(self.inputs, field) if not isdefined(valuelist): # require all inputs return outputs for field in self._fields: valuelist = getattr(self.inputs, field) if not isinstance(valuelist, list): valuelist = [valuelist] outputs[field] = [ value for include, value in zip(includelist, valuelist) if include ] return outputs
def set_mapnode_substitutions(self, n_runs): """Find mapnode names and add datasink substitutions to sort by run.""" # First determine top-level mapnode names mapnode_names = find_mapnodes(self.wf) # Then determine mapnode names for each nested workflow # Note that this currently only works for one level of nesting nested_workflows = find_nested_workflows(self.wf) for wf in nested_workflows: mapnode_names.extend(find_mapnodes(wf)) # Build a list of substitution tuples substitutions = [] for r in reversed(range(n_runs)): for name in mapnode_names: substitutions.append(("_%s%d" % (name, r), "run_%d" % (r + 1))) # Set the substitutions attribute on the DataSink node if isdefined(self.sink_node.inputs.substitutions): self.sink_node.inputs.substitutions.extend(substitutions) else: self.sink_node.inputs.substitutions = substitutions
def _run_interface(self, runtime): from scipy.ndimage.morphology import binary_dilation from nilearn.masking import compute_epi_mask orig_file_nii = nb.load(self.inputs.in_file) in_file_data = orig_file_nii.get_fdata() # pad the data to avoid the mask estimation running into edge effects in_file_data_padded = np.pad(in_file_data, (1, 1), "constant", constant_values=(0, 0)) padded_nii = nb.Nifti1Image(in_file_data_padded, orig_file_nii.affine, orig_file_nii.header) mask_nii = compute_epi_mask(padded_nii, exclude_zeros=True) mask_data = np.asanyarray(mask_nii.dataobj).astype(np.uint8) if isdefined(self.inputs.dilation): mask_data = binary_dilation(mask_data).astype(np.uint8) # reverse image padding mask_data = mask_data[1:-1, 1:-1, 1:-1] # exclude zero and NaN voxels mask_data[in_file_data == 0] = 0 mask_data[np.isnan(in_file_data)] = 0 better_mask = nb.Nifti1Image(mask_data, orig_file_nii.affine, orig_file_nii.header) better_mask.set_data_dtype(np.uint8) better_mask.to_filename("mask_file.nii.gz") self._mask_file = os.path.join(runtime.cwd, "mask_file.nii.gz") runtime.returncode = 0 return super(ComputeEPIMask, self)._run_interface(runtime)
def _run_interface(self, runtime): # Create function handle if self.as_module: import importlib pieces = self.inputs.function_str.split('.') module = '.'.join(pieces[:-1]) function = pieces[-1] try: function_handle = getattr(importlib.import_module(module), function) except ImportError: raise RuntimeError('Could not import module: %s' % self.inputs.function_str) else: function_handle = create_function_from_source( self.inputs.function_str, self.imports) # Get function args args = {} for name in self._input_names: value = getattr(self.inputs, name) if isdefined(value): args[name] = value out = function_handle(**args) if len(self._output_names) == 1: self._out[self._output_names[0]] = out else: if isinstance(out, tuple) and \ (len(out) != len(self._output_names)): raise RuntimeError('Mismatch in number of expected outputs') else: for idx, name in enumerate(self._output_names): self._out[name] = out[idx] return runtime
def _generate_segment(self): dof = self.inputs.registration_dof stc = { True: 'Applied', False: 'Not applied', 'TooShort': 'Skipped (too few volumes)' }[self.inputs.slice_timing] reg = { 'FSL': [ 'FSL <code>flirt</code> with boundary-based registration' ' (BBR) metric - %d dof' % dof, 'FSL <code>flirt</code> rigid registration - 6 dof' ], 'FreeSurfer': [ 'FreeSurfer <code>bbregister</code> ' '(boundary-based registration, BBR) - %d dof' % dof, 'FreeSurfer <code>mri_coreg</code> - %d dof' % dof ], }[self.inputs.registration][self.inputs.fallback] if self.inputs.pe_direction is None: pedir = 'MISSING - Assuming Anterior-Posterior' else: pedir = { 'i': 'Left-Right', 'j': 'Anterior-Posterior' }[self.inputs.pe_direction[0]] if isdefined(self.inputs.confounds_file): with open(self.inputs.confounds_file) as cfh: conflist = cfh.readline().strip('\n').strip() return FUNCTIONAL_TEMPLATE.format( pedir=pedir, stc=stc, sdc=self.inputs.distortion_correction, registration=reg, confounds=re.sub(r'[\t ]+', ', ', conflist), tr=self.inputs.tr)
def prepare_contrasts(contrasts, all_regressors): """Make mutable copy of contrast list, and generate contrast design_matrix from dictionary weight mapping Each value in the contrasts list is a ContrastInfo object: ContrastInfo = namedtuple( 'ContrastInfo', ('name', 'conditions', 'weights', 'test', 'entities') ) """ if not isdefined(contrasts): return [] out_contrasts = [] for contrast_info in contrasts: conds = contrast_info["conditions"] in_weights = np.atleast_2d(contrast_info["weights"]) # Are any necessary values missing for contrast estimation? missing = len(conds) != in_weights.shape[1] or any( cond not in all_regressors for cond in conds) if missing: continue weights = np.zeros((in_weights.shape[0], len(all_regressors)), dtype=in_weights.dtype) # Find indices of input conditions in all_regressors list sorter = np.argsort(all_regressors) indices = sorter[np.searchsorted(all_regressors, conds, sorter=sorter)] weights[:, indices] = in_weights out_contrasts.append(( contrast_info['name'], weights, contrast_info['entities'].copy(), contrast_info['test'], )) return out_contrasts
def _run_interface(self, runtime): df = pd.read_csv(self.inputs.in_file) out_columns = [ 'sub', 'ses', 'task', 'roi', 'metric', 'measure', 'value' ] df_out = pd.DataFrame(columns=out_columns) for ses, ses_df in df.groupby(['ses']): for task, task_df in ses_df.groupby(['task']): for measure, measure_name in zip(outlier_measures.values(), outlier_measures.keys()): for metric_name, metric_df in task_df.groupby(['metric']): metricValues = metric_df.value.values if len(metricValues.shape) == 1: metricValues = metricValues.reshape(-1, 1) if 'cdf' in inspect.getargspec(measure).args: if 'coreg' or 'pvc' in metric_df.analysis: cdf = True else: cdf = False m = np.array(measure(metricValues, cdf=cdf)) else: m = np.array(measure(metricValues)) if len(m.shape) > 1: m = m.flatten() r = pd.Series(m) #Get column number of the current outlier measure Reindex the test_df from 0 to the number of rows it has #Get the series with the calculate the distance measure for the current measure df.index = range(df.shape[0]) df['value'] = r df['measure'] = [measure_name] * df.shape[0] df_out = pd.concat([df_out, df], axis=0) if not isdefined(self.inputs.out_file): self.inputs.out_file = self._gen_output() df_out.to_csv(self.inputs.out_file, index=False) return runtime
def _list_outputs(self): outputs = self.output_spec().get() self._set_outputs() if isdefined(self.inputs.warped_image): outputs["warped_image"] = self.inputs.warped_image if isdefined(self.inputs.inverse_warped_image): outputs["inverse_warped_image"] = self.inputs.inverse_warped_image if isdefined(self.inputs.composite_transform): outputs["composite_transform"] = self.inputs.composite_transform if isdefined(self.inputs.out_matrix): outputs["out_matrix"] = self.inputs.out_matrix if isdefined(self.inputs.out_matrix_inverse): outputs["out_matrix_inverse"] = self.inputs.out_matrix_inverse if isdefined(self.inputs.inverse_composite_transform): outputs[ "inverse_composite_transform"] = self.inputs.inverse_composite_transform return outputs
def aggregate_outputs(self, runtime=None, needed_outputs=None): outputs = self._outputs() info = runtime.stdout # Modified file if isdefined(self.inputs.copy_sform2qform) or isdefined(self.inputs.copy_qform2sform) or isdefined(self.inputs.delete_orient) or isdefined(self.inputs.force_radiological) or isdefined(self.inputs.force_neurological) or isdefined(self.inputs.swap_orient): outputs.out_file = self.inputs.in_file #outputs['out_file'] = self.inputs.in_file # Get information if isdefined(self.inputs.get_orient): outputs.orient = info if isdefined(self.inputs.get_sform): outputs.sform = info if isdefined(self.inputs.get_qform): outputs.qform= info if isdefined(self.inputs.get_sformcode): outputs.sformcode = info if isdefined(self.inputs.get_qformcode): outputs.qformcode = info return outputs
def _run_interface(self, runtime): """Generate a reportlet.""" if isdefined(self.inputs.mif_file): odf_img, directions = mif2amps(self.inputs.mif_file, runtime.cwd) elif isdefined(self.inputs.fib_file): odf_img, directions = fib2amps(self.inputs.fib_file, self.inputs.background_image, runtime.cwd) elif isdefined(self.inputs.odf_file) and isdefined( self.inputs.directions_file): odf_img = nb.load(self.inputs.odf_file) directions = np.load(self.inputs.directions_file) else: raise Exception('Requires either a mif file or fib file') odf_4d = odf_img.get_fdata() sphere = HemiSphere(xyz=directions.astype(np.float)) if not isdefined(self.inputs.background_image ) or self.inputs.background_image is None: background_data = odf_4d.mean(3) else: background_data = nb.load(self.inputs.background_image).get_fdata() peak_report = op.join(runtime.cwd, 'peak_report.png') peak_slice_series(odf_4d, sphere, background_data, peak_report, n_cuts=self._ncuts, mask_image=self.inputs.mask_file, padding=self._padding) self._results['out_report'] = peak_report # Plot ODFs in interesting regions if isdefined(self.inputs.odf_rois): odf_report = op.join(runtime.cwd, 'odf_report.png') odf_roi_plot(odf_4d, sphere, background_data, odf_report, self.inputs.odf_rois, subtract_iso=self.inputs.subtract_iso, mask=self.inputs.mask_file) self._results['odf_report'] = odf_report return runtime
def _cond_to_regress(self, info, nscans): """Converts condition information to full regressors """ reg = [] regnames = [] for i, cond in enumerate(info.conditions): if hasattr(info, 'amplitudes') and info.amplitudes: amplitudes = info.amplitudes[i] else: amplitudes = None regnames.insert(len(regnames), cond) scaled_onsets = scale_timings(info.onsets[i], self.inputs.input_units, 'secs', self.inputs.time_repetition) scaled_durations = scale_timings(info.durations[i], self.inputs.input_units, 'secs', self.inputs.time_repetition) regressor = self._gen_regress(scaled_onsets, scaled_durations, amplitudes, nscans) if isdefined(self.inputs.use_temporal_deriv) and \ self.inputs.use_temporal_deriv: reg.insert(len(reg), regressor[0]) regnames.insert(len(regnames), cond + '_D') reg.insert(len(reg), regressor[1]) else: reg.insert(len(reg), regressor) # need to deal with temporal and parametric modulators # for sparse-clustered acquisitions enter T1-effect regressors nvol = self.inputs.volumes_in_cluster if nvol > 1: for i in range(nvol - 1): treg = np.zeros((nscans / nvol, nvol)) treg[:, i] = 1 reg.insert(len(reg), treg.ravel().tolist()) regnames.insert(len(regnames), 'T1effect_%d' % i) return reg, regnames
def _run_interface(self, runtime): if not isdefined(self.inputs.out_file): fname = os.path.splitext(os.path.basename(self.inputs.in_file))[0] dname = dname = os.getcwd() self.inputs.out_file = dname + os.sep + fname + self._suffix + '.mnc' temp_fn="/tmp/tmp_mnc_"+ strftime("%Y%m%d%H%M%S", gmtime())+str(np.random.randint(9999999999))+".mnc" shutil.copy(self.inputs.in_file, temp_fn) infile = volumeFromFile(self.inputs.in_file) for view in ['xspace','yspace','zspace']: #start = -1*infile.separations[infile.dimnames.index(view)]*infile.sizes[infile.dimnames.index(view)]/2 dim = infile.dimnames.index( view ) start = infile.starts[dim] run_modifHrd=ModifyHeaderCommand() run_modifHrd.inputs.in_file = temp_fn run_modifHrd.inputs.dinsert = True; run_modifHrd.inputs.opt_string = view+":start="+str(start); run_modifHrd.run() node_name="fixIrregularDimension" fixIrregular = ModifyHeaderCommand() #-dinsert xspace:direction_cosines=1,0,0 -dinsert yspace:direction_cosines=0,1,0 -dinsert zspace:direction_cosines=0,0,1 fixIrregular.inputs.opt_string = " -sinsert time:spacing=\"regular__\" -sinsert time-width:spacing=\"regular__\" -sinsert xspace:spacing=\"regular__\" -sinsert yspace:spacing=\"regular__\" -sinsert zspace:spacing=\"regular__\"" fixIrregular.inputs.in_file = temp_fn print( fixIrregular.cmdline ) fixIrregular.run() fixCosine = FixCosinesCommand() fixCosine.inputs.in_file = fixIrregular.inputs.out_file fixCosine.inputs.keep_real_range=True fixCosine.inputs.dircos=True fixCosine.run() print(fixCosine.cmdline) shutil.copy(fixCosine.inputs.out_file, self.inputs.out_file) return runtime
def _list_outputs(self): outputs = self._outputs().get() outputs['annotated_trackvis_file'] = os.path.abspath( self.inputs.out_tracks) outputs['max_maps'] = [] outputs['mean_maps'] = [] if isdefined(self.inputs.stat_labels) and len( self.inputs.stat_labels) == len(self.inputs.stat_files): for label in self.inputs.stat_labels: outputs['max_maps'].append( os.path.abspath(self.inputs.out_max_map_prefix + "_%s" % label + '.nii')) outputs['mean_maps'].append( os.path.abspath(self.inputs.out_mean_map_prefix + "_%s" % label + '.nii')) else: for i in range(len(self.inputs.stat_files)): outputs['max_maps'].append( os.path.abspath(self.inputs.out_max_map_prefix + str(i) + '.nii')) outputs['mean_maps'].append( os.path.abspath(self.inputs.out_mean_map_prefix + str(i) + '.nii')) return outputs
def _list_outputs(self): outputs = self._outputs().get() outfile = self.inputs.out_file if not isdefined(outfile): _, infile1, _ = split_filename(self.inputs.in_file) if self.inputs.invert_xfm: outfile = fname_presuffix(infile1, suffix="_inv.mat", newpath=os.getcwd(), use_ext=False) else: if self.inputs.concat_xfm: _, infile2, _ = split_filename(self.inputs.in_file2) outfile = fname_presuffix("%s_%s" % (infile1, infile2), suffix=".mat", newpath=os.getcwd(), use_ext=False) else: outfile = fname_presuffix(infile1, suffix="_fix.mat", newpath=os.getcwd(), use_ext=False) outputs["out_file"] = os.path.abspath(outfile) return outputs
def _run_interface(self, runtime): if not isdefined(self.inputs.out_file): self.inputs.out_file = self._gen_output(self.inputs.in_file) temp_fn = os.getcwd()+"/tmp_mnc_"+ strftime("%Y%m%d%H%M%S", gmtime())+str(np.random.randint(9999999999))+".mnc" convert = nii2mnc_shCommand() convert.inputs.in_file=self.inputs.in_file convert.inputs.out_file=temp_fn convert.inputs.dfloat = self.inputs.dfloat convert.inputs.dint = self.inputs.dint print(convert.cmdline) convert.run() minc2 = mincconvertCommand() minc2.inputs.in_file=temp_fn minc2.inputs.out_file=self.inputs.out_file minc2.inputs.two=True print(minc2.cmdline) minc2.run() move(minc2.inputs.out_file, self.inputs.out_file) os.remove(temp_fn) return runtime
def _checkinitxfm(in_bval, excl_nodiff, in_xfms=None): from nipype.interfaces.base import isdefined import numpy as np import os.path as op bvals = np.loadtxt(in_bval) gen_id = ((in_xfms is None) or (not isdefined(in_xfms)) or (len(in_xfms) != len(bvals))) init_xfms = [] if excl_nodiff: dws = np.where(bvals != 0)[0].tolist() else: dws = range(len(bvals)) if gen_id: for i in dws: xfm_file = op.abspath('init_%04d.mat' % i) np.savetxt(xfm_file, np.eye(4)) init_xfms.append(xfm_file) else: init_xfms = [in_xfms[i] for i in dws] return init_xfms
def _list_outputs(self): exclude = None if self.inputs.strict: exclude = ['derivatives/', 'code/', 'sourcedata/'] if bids_ver < version.parse('0.5'): raise ImportError("pybids must be >= 0.5") elif bids_ver >= version.parse('0.5') and bids_ver < version.parse('0.6'): layout = bidslayout.BIDSLayout(self.inputs.base_dir, config=self.inputs.domains, exclude=exclude) else: if self.inputs.domains is None: self.inputs.domains = ['bids'] layout = bidslayout.BIDSLayout((self.inputs.base_dir, self.inputs.domains), exclude=exclude) # If infield is not given nm input value, silently ignore filters = {} for key in self._infields: value = getattr(self.inputs, key) if isdefined(value): filters[key] = value outputs = {} for key, query in self.inputs.output_query.items(): args = query.copy() args.update(filters) filelist = layout.get(return_type=self.inputs.return_type, **args) if len(filelist) == 0: msg = 'Output key: %s returned no files' % key if self.inputs.raise_on_empty: raise IOError(msg) else: iflogger.warning(msg) filelist = Undefined outputs[key] = filelist return outputs
def _get_dst(self, src): # If path is directory with trailing os.path.sep, # then remove that for a more robust behavior src = src.rstrip(os.path.sep) path, fname = os.path.split(src) if self.inputs.parameterization: dst = path if isdefined(self.inputs.strip_dir): dst = dst.replace(self.inputs.strip_dir, '') folders = [ folder for folder in dst.split(os.path.sep) if folder.startswith('_') ] dst = os.path.sep.join(folders) if fname: dst = os.path.join(dst, fname) else: if fname: dst = fname else: dst = path.split(os.path.sep)[-1] if dst[0] == os.path.sep: dst = dst[1:] return dst
def cmdline(self): cmd = super(MakeMidthickness, self).cmdline if not isdefined(self.inputs.graymid) or len(self.inputs.graymid) < 1: return cmd # Possible graymid values inclue {l,r}h.{graymid,midthickness} # Prefer midthickness to graymid, require to be of the same hemisphere # as input source = None in_base = Path(self.inputs.in_file).name mt = self._associated_file(in_base, "midthickness") gm = self._associated_file(in_base, "graymid") for surf in self.inputs.graymid: if Path(surf).name == mt: source = surf break if Path(surf).name == gm: source = surf if source is None: return cmd return "cp {} {}".format(source, self._list_outputs()["out_file"])
def _transform(self, array): design = np.loadtxt(self.inputs.design_file, dtype=np.float64, ndmin=2) filter_all = self.inputs.filter_all if filter_all is not True: filter_columns = self.inputs.filter_columns else: filter_columns = list(range(1, design.shape[1] + 1)) calculate_mask = isdefined( self.inputs.mask) and self.inputs.mask is True np.nan_to_num(array, copy=False) # nans create problems further down the line array2 = regfilt(array, design, filter_columns, calculate_mask=calculate_mask, aggressive=self.inputs.aggressive) return array2
def _run_interface(self, runtime): if not isdefined(self.inputs.out_file): self.inputs.out_file = self._gen_output(self.inputs.in_file) beast = mincbeastCommand() beast.inputs.out_file = "/tmp/" + str(np.random.randint( 0, 9999999)) + "_" + os.path.basename(self.inputs.out_file) beast.inputs.in_file = self.inputs.in_file beast.inputs.library_dir = self.inputs.library_dir beast.inputs.voxel_size = self.inputs.voxel_size beast.inputs.same_resolution = self.inputs.same_resolution beast.inputs.median = self.inputs.median beast.inputs.fill = self.inputs.fill beast.inputs.configuration = self.inputs.configuration beast.run() resample = FixCosinesCommand() resample.inputs.two = True resample.inputs.in_file = beast.inputs.out_file resample.inputs.out_file = self.inputs.out_file print(resample.cmdline) resample.run() return runtime