def _format_arg(self, opt, spec, val): """Convert input to appropriate format for spm """ if opt == 'in_files': return scans_for_fnames(filename_to_list(val)) if opt == 'target': return scans_for_fname(filename_to_list(val)) if opt == 'deformation': return np.array([list_to_filename(val)], dtype=object) if opt == 'deformation_field': return np.array([list_to_filename(val)], dtype=object) return val
def bandpass_filter(files, lowpass_freq, highpass_freq, fs): """Bandpass filter the input files Parameters ---------- files: list of 4d nifti files lowpass_freq: cutoff frequency for the low pass filter (in Hz) highpass_freq: cutoff frequency for the high pass filter (in Hz) fs: sampling rate (in Hz) """ out_files = [] for filename in filename_to_list(files): path, name, ext = split_filename(filename) out_file = os.path.join(os.getcwd(), name + '_bp' + ext) img = nb.load(filename) timepoints = img.shape[-1] F = np.zeros((timepoints)) lowidx = int(timepoints / 2) + 1 if lowpass_freq > 0: lowidx = np.round(float(lowpass_freq) / fs * timepoints) highidx = 0 if highpass_freq > 0: highidx = np.round(float(highpass_freq) / fs * timepoints) F[highidx:lowidx] = 1 F = ((F + F[::-1]) > 0).astype(int) data = img.get_data() if np.all(F == 1): filtered_data = data else: filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F)) img_out = nb.Nifti1Image(filtered_data, img.affine, img.header) img_out.to_filename(out_file) out_files.append(out_file) return list_to_filename(out_files)
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() subjects_dir = self.inputs.subjects_dir subject_path = op.join(subjects_dir, self.inputs.subject_id) output_traits = self._outputs() mesh_paths = [] for k in outputs.keys(): if k != 'mesh_files': val = self._get_files(subject_path, k, output_traits.traits()[k].loc, output_traits.traits()[k].altkey) if val: value_list = list_to_filename(val) if isinstance(value_list, list): out_files = [] for value in value_list: out_files.append(op.abspath(value)) elif isinstance(value_list, str): out_files = op.abspath(value_list) else: raise TypeError outputs[k] = out_files if not k.rfind('surface') == -1: mesh_paths.append(out_files) outputs['mesh_files'] = mesh_paths return outputs
def bandpass_filter(files, lowpass_freq, highpass_freq, fs): """Bandpass filter the input files Parameters ---------- files: list of 4d nifti files lowpass_freq: cutoff frequency for the low pass filter (in Hz) highpass_freq: cutoff frequency for the high pass filter (in Hz) fs: sampling rate (in Hz) """ out_files = [] for filename in filename_to_list(files): path, name, ext = split_filename(filename) out_file = os.path.join(os.getcwd(), name + '_bp' + ext) img = nb.load(filename) timepoints = img.shape[-1] F = np.zeros((timepoints)) lowidx = timepoints / 2 + 1 if lowpass_freq > 0: lowidx = np.round(float(lowpass_freq) / fs * timepoints) highidx = 0 if highpass_freq > 0: highidx = np.round(float(highpass_freq) / fs * timepoints) F[highidx:lowidx] = 1 F = ((F + F[::-1]) > 0).astype(int) data = img.get_data() if np.all(F == 1): filtered_data = data else: filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F)) img_out = nb.Nifti1Image(filtered_data, img.get_affine(), img.get_header()) img_out.to_filename(out_file) out_files.append(out_file) return list_to_filename(out_files)
def _format_arg(self, opt, spec, val): """Convert input to appropriate format for spm""" if opt == "deformation_field": return np.array([list_to_filename(val)], dtype=object) if opt == "in_files": return np.array(filename_to_list(val), dtype=object) return val
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 _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._outputs().get() outputs['outlier_files'] = [] outputs['intensity_files'] = [] outputs['statistic_files'] = [] for i,f in enumerate(filename_to_list(self.inputs.realigned_files)): outlierfile,intensityfile,statsfile, _ = 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) 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']) return outputs
def _format_arg(self, opt, spec, val): """Convert input to appropriate format for SPM """ if opt in ['in_files']: return scans_for_fnames(filename_to_list(val), keep4d=False) if opt == 'deformation_field': return np.array([list_to_filename(val)], dtype=object) return super(ApplyDeformationField, self)._format_arg(opt, spec, val)
def _list_outputs(self): outputs = self._outputs().get() jobtype = self.inputs.jobtype if jobtype == "calculatevdm": outputs['vdm'] = [] for phase in filename_to_list(self.inputs.phase): outputs['vdm'].append(fname_presuffix(phase, prefix='vdm5_sc')) outputs['vdm'] = list_to_filename(outputs['vdm']) return outputs
def _list_outputs(self): subjects_dir = self.inputs.subjects_dir subject_path = os.path.join(subjects_dir, self.inputs.subject_id) output_traits = self._outputs() outputs = output_traits.get() for k in outputs.keys(): val = self._get_files(subject_path, k, output_traits.traits()[k].loc, output_traits.traits()[k].altkey) if val: outputs[k] = list_to_filename(val) return outputs
def get_names(files, suffix): """Generate appropriate names for output files """ from nipype.utils.filemanip import (split_filename, filename_to_list, list_to_filename) out_names = [] for filename in files: _, name, _ = split_filename(filename) out_names.append(name + suffix) return list_to_filename(out_names)
def bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2): """Bandpass filter the input files Parameters ---------- files: list of str List 4d nifti file paths. lowpass_freq: float Cutoff frequency for the low pass filter (in Hz). highpass_freq: float Cutoff frequency for the high pass filter (in Hz). tr: float The repetition time in seconds. The inverse of sampling rate (in Hz). """ import os import nibabel as nb import numpy as np from nipype.utils.filemanip import (filename_to_list, list_to_filename, split_filename) fs = 1./tr out_files = [] for filename in filename_to_list(files): path, name, ext = split_filename(filename) out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext) img = nb.load(filename) timepoints = img.shape[-1] F = np.zeros((timepoints)) lowidx = int(timepoints / 2) + 1 if lowpass_freq > 0: lowidx = np.round(float(lowpass_freq) / fs * timepoints) highidx = 0 if highpass_freq > 0: highidx = np.round(float(highpass_freq) / fs * timepoints) F[int(highidx):int(lowidx)] = 1 F = ((F + F[::-1]) > 0).astype(int) data = img.get_data() if np.all(F == 1): filtered_data = data else: filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F)) img_out = nb.Nifti1Image(filtered_data, img.affine, img.header) img_out.to_filename(out_file) out_files.append(out_file) return list_to_filename(out_files)
def bandpass_filter(files, lowpass_freq=0.1, highpass_freq=0.01, tr=2): """Bandpass filter the input files Parameters ---------- files: list of str List 4d nifti file paths. lowpass_freq: float Cutoff frequency for the low pass filter (in Hz). highpass_freq: float Cutoff frequency for the high pass filter (in Hz). tr: float The repetition time in seconds. The inverse of sampling rate (in Hz). """ import os import nibabel as nb import numpy as np from nipype.utils.filemanip import (filename_to_list, list_to_filename, split_filename) fs = 1./tr out_files = [] for filename in filename_to_list(files): path, name, ext = split_filename(filename) out_file = os.path.join(os.getcwd(), name + '_bandpassed' + ext) img = nb.load(filename) timepoints = img.shape[-1] F = np.zeros((timepoints)) lowidx = int(timepoints / 2) + 1 if lowpass_freq > 0: lowidx = np.round(float(lowpass_freq) / fs * timepoints) highidx = 0 if highpass_freq > 0: highidx = np.round(float(highpass_freq) / fs * timepoints) F[highidx:lowidx] = 1 F = ((F + F[::-1]) > 0).astype(int) data = img.get_data() if np.all(F == 1): filtered_data = data else: filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F)) img_out = nb.Nifti1Image(filtered_data, img.affine, img.header) img_out.to_filename(out_file) out_files.append(out_file) return list_to_filename(out_files)
def _list_outputs(self): # infields are mandatory, however I could not figure out how to set 'mandatory' flag dynamically # hence manual check if self._infields: for key in self._infields: value = getattr(self.inputs, key) if not isdefined(value): msg = "%s requires a value for input '%s' because it was listed in 'infields'" % \ (self.__class__.__name__, key) outputs = {} subject_id = self.inputs.subject_id tp, group, pid = subject_id.split('_') for key, args in self.inputs.template_args.items(): outputs[key] = [] template = self.inputs.template if hasattr(self.inputs, 'field_template') and \ isdefined(self.inputs.field_template) and \ key in self.inputs.field_template: template = self.inputs.field_template[key] if isdefined(self.inputs.base_directory): template = os.path.join( os.path.abspath(self.inputs.base_directory), template) else: template = os.path.abspath(template) if (('concatenated_fmri.nii.gz' not in template) and ('filled_t1' not in template)): template = template % (tp, group, key, pid, key, tp, pid) elif 'concatenated_fmri.nii.gz' in template: template = template % (tp, group, key, pid) elif 'filled_t1' in template: template = template %( tp, group, pid, tp, group, pid, tp, pid) filelist = glob.glob(template) if len(filelist) == 0: msg = 'output key: %s template: %s returned no files' % ( key, template) if self.inputs.raise_on_empty: raise IOError(msg) else: warn(msg) else: if self.inputs.sort_filelist: filelist = human_order_sorted(filelist) outputs[key] = list_to_filename(filelist) if any([val is None for val in outputs[key]]): outputs[key] = [] if len(outputs[key]) == 0: outputs[key] = None elif len(outputs[key]) == 1: outputs[key] = outputs[key][0] return outputs
def rename(in_files, suffix=None): from nipype.utils.filemanip import (filename_to_list, split_filename, list_to_filename) out_files = [] for idx, filename in enumerate(filename_to_list(in_files)): _, name, ext = split_filename(filename) if suffix is None: out_files.append(name + ('_%03d' % idx) + ext) else: out_files.append(name + suffix + ext) return list_to_filename(out_files)
def selectindex(files, idx, flatten=True): """ Select the items in the list `files` in the indexes given by the list of integers `idx`.""" import numpy as np from nipype.utils.filemanip import filename_to_list, list_to_filename from pypes._utils import flatten_list if flatten: files = flatten_list(files) if isinstance(idx, list): return list_to_filename( np.array(filename_to_list(files))[idx].tolist()) else: return files[idx]
def _format_arg(self, opt, spec, val): """Convert input to appropriate format for spm """ if opt == 'template': return scans_for_fname(filename_to_list(val)) if opt == 'source': return scans_for_fname(filename_to_list(val)) if opt == 'apply_to_files': return scans_for_fnames(filename_to_list(val)) if opt == 'parameter_file': return np.array([list_to_filename(val)], dtype=object) if opt in ['write_wrap']: if len(val) != 3: raise ValueError('%s must have 3 elements' % opt) return super(Normalize, self)._format_arg(opt, spec, val)
def _list_outputs(self): #TODO: figure out file names and get rid off the globs outputs = self._outputs().get() root = self._get_design_root(list_to_filename(self.inputs.fsf_file)) design_file = glob(os.path.join(os.getcwd(), '%s*.mat' % root)) assert len(design_file) == 1, 'No mat file generated by FEAT Model' outputs['design_file'] = design_file[0] con_file = glob(os.path.join(os.getcwd(), '%s*.con' % root)) assert len(con_file) == 1, 'No con file generated by FEAT Model' outputs['con_file'] = con_file[0] fcon_file = glob(os.path.join(os.getcwd(), '%s*.fts' % root)) if fcon_file: assert len(fcon_file) == 1, 'No fts file generated by FEAT Model' outputs['fcon_file'] = fcon_file[0] return outputs
def _format_arg(self, opt, spec, val): """Convert input to appropriate format for spm """ if opt == "template": return scans_for_fname(filename_to_list(val)) if opt == "source": return scans_for_fname(filename_to_list(val)) if opt == "apply_to_files": return scans_for_fnames(filename_to_list(val)) if opt == "parameter_file": return np.array([list_to_filename(val)], dtype=object) if opt in ["write_wrap"]: if len(val) != 3: raise ValueError("%s must have 3 elements" % opt) return val
def _copyfiles_to_wd(self, outdir, execute): """ copy files over and change the inputs""" if hasattr(self._interface,'_get_filecopy_info'): for info in self._interface._get_filecopy_info(): files = self.inputs.get().get(info['key']) if not isdefined(files): continue if files: infiles = filename_to_list(files) if execute: newfiles = copyfiles(infiles, [outdir], copy=info['copy']) else: newfiles = fnames_presuffix(infiles, newpath=outdir) if not isinstance(files, list): newfiles = list_to_filename(newfiles) setattr(self.inputs, info['key'], newfiles)
def rename(in_files, suffix=None): """Rename all the files in `in_files` adding the `suffix` keeping its extension and basedir.""" import os.path as path from nipype.utils.filemanip import (filename_to_list, split_filename, list_to_filename) out_files = [] for idx, filename in enumerate(filename_to_list(in_files)): base, name, ext = split_filename(filename) if suffix is None: new_name = name + ('_%03d' % idx) + ext else: new_name = name + suffix + ext out_files.append(path.join(base, new_name)) return list_to_filename(out_files)
def _make_matlab_command(self, content): """validates spm options and generates job structure if mfile is True uses matlab .m file else generates a job structure and saves in .mat """ if isdefined(self.inputs.mask_image): # SPM doesn't handle explicit masking properly, especially # when you want to use the entire mask image postscript = "load SPM;\n" postscript += "SPM.xM.VM = spm_vol('%s');\n" % list_to_filename(self.inputs.mask_image) postscript += "SPM.xM.I = 0;\n" postscript += "SPM.xM.T = [];\n" postscript += "SPM.xM.TH = ones(size(SPM.xM.TH))*(%s);\n" % self.inputs.mask_threshold postscript += "SPM.xM.xs = struct('Masking', 'explicit masking only');\n" postscript += "save SPM SPM;\n" else: postscript = None return super(Level1Design, self)._make_matlab_command(content, postscript=postscript)
def bandpass_filter(files, lowpass_freq, highpass_freq, fs): """Bandpass filter the input files Parameters ---------- files: list of 4d nifti files lowpass_freq: cutoff frequency for the low pass filter (in Hz) highpass_freq: cutoff frequency for the high pass filter (in Hz) fs: sampling rate (in Hz) """ from nipype.utils.filemanip import split_filename, list_to_filename import numpy as np import nibabel as nb from nipype.utils import NUMPY_MMAP out_files = [] for filename in filename_to_list(files): path, name, ext = split_filename(filename) out_file = os.path.join(os.getcwd(), name + '_bp' + ext) img = nb.load(filename, mmap=NUMPY_MMAP) timepoints = img.shape[-1] F = np.zeros((timepoints)) lowidx = int(timepoints / 2) + 1 if lowpass_freq > 0: lowidx = np.round(lowpass_freq / fs * timepoints) highidx = 0 if highpass_freq > 0: highidx = np.round(highpass_freq / fs * timepoints) F[highidx:lowidx] = 1 F = ((F + F[::-1]) > 0).astype(int) data = img.get_data() if np.all(F == 1): filtered_data = data else: filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F)) img_out = nb.Nifti1Image(filtered_data, img.affine, img.header) img_out.to_filename(out_file) out_files.append(out_file) return list_to_filename(out_files)
def _list_outputs(self): # infields are mandatory, however I could not figure out # how to set 'mandatory' flag dynamically, hence manual check cache_dir = self.inputs.cache_dir or tempfile.gettempdir() if self.inputs.config: xnat = pyxnat.Interface(config=self.inputs.config) else: xnat = pyxnat.Interface(self.inputs.server, self.inputs.user, self.inputs.pwd, cache_dir ) if self._infields: for key in self._infields: value = getattr(self.inputs,key) if not isdefined(value): msg = ("%s requires a value for input '%s' " "because it was listed in 'infields'" % \ (self.__class__.__name__, key) ) raise ValueError(msg) outputs = {} for key, args in self.inputs.query_template_args.items(): outputs[key] = [] template = self.inputs.query_template if hasattr(self.inputs, 'field_template') and \ isdefined(self.inputs.field_template) and \ self.inputs.field_template.has_key(key): template = self.inputs.field_template[key] if not args: file_objects = xnat.select(template).get('obj') if file_objects == []: raise IOError('Template %s returned no files' \ % template ) outputs[key] = list_to_filename( [str(file_object.get()) for file_object in file_objects if file_object.exists() ]) for argnum, arglist in enumerate(args): maxlen = 1 for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): if (maxlen > 1) and (len(arg) != maxlen): raise ValueError('incompatible number ' 'of arguments for %s' % key ) if len(arg)>maxlen: maxlen = len(arg) outfiles = [] for i in range(maxlen): argtuple = [] for arg in arglist: if isinstance(arg, str) and \ hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): argtuple.append(arg[i]) else: argtuple.append(arg) if argtuple: target = template % tuple(argtuple) file_objects = xnat.select(target).get('obj') if file_objects == []: raise IOError('Template %s ' 'returned no files' % target ) outfiles = list_to_filename( [str(file_object.get()) for file_object in file_objects if file_object.exists() ] ) else: file_objects = xnat.select(template).get('obj') if file_objects == []: raise IOError('Template %s ' 'returned no files' % template ) outfiles = list_to_filename( [str(file_object.get()) for file_object in file_objects if file_object.exists() ] ) outputs[key].insert(i,outfiles) if len(outputs[key]) == 0: outputs[key] = None elif len(outputs[key]) == 1: outputs[key] = outputs[key][0] return outputs
def _list_outputs(self): # infields are mandatory, however I could not figure out how to set 'mandatory' flag dynamically # hence manual check cache_dir = self.inputs.cache_dir or tempfile.gettempdir() if self.inputs.xnat_server: xnat = pyxnat.Interface(self.inputs.xnat_server, self.inputs.xnat_user, self.inputs.xnat_pwd, cache_dir) else: xnat = pyxnat.Interface(self.inputs.xnat_config) # xnat.set_offline_mode() if self._infields: for key in self._infields: value = getattr(self.inputs, key) if not isdefined(value): msg = "%s requires a value for input '%s' because it was listed in 'infields'" % ( self.__class__.__name__, key, ) raise ValueError(msg) outputs = {} for key, args in self.inputs.query_template_args.items(): outputs[key] = [] template = self.inputs.query_template if ( hasattr(self.inputs, "field_template") and isdefined(self.inputs.field_template) and self.inputs.field_template.has_key(key) ): template = self.inputs.field_template[key] if not args: file_objects = xnat.select(template).get("obj") if file_objects == []: raise IOError("Template %s returned no files" % template) outputs[key] = list_to_filename([str(file_object.get()) for file_object in file_objects]) for argnum, arglist in enumerate(args): maxlen = 1 for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): if (maxlen > 1) and (len(arg) != maxlen): raise ValueError("incompatible number of arguments for %s" % key) if len(arg) > maxlen: maxlen = len(arg) outfiles = [] for i in range(maxlen): argtuple = [] for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): argtuple.append(arg[i]) else: argtuple.append(arg) if argtuple: file_objects = xnat.select(template % tuple(argtuple)).get("obj") if file_objects == []: raise IOError("Template %s returned no files" % (template % tuple(argtuple))) outfiles = list_to_filename([str(file_object.get()) for file_object in file_objects]) else: file_objects = xnat.select(template).get("obj") if file_objects == []: raise IOError("Template %s returned no files" % template) outfiles = list_to_filename([str(file_object.get()) for file_object in file_objects]) outputs[key].insert(i, outfiles) if len(outputs[key]) == 0: outputs[key] = None elif len(outputs[key]) == 1: outputs[key] = outputs[key][0] return outputs
def _list_outputs(self): # infields are mandatory, however I could not figure out how to set 'mandatory' flag dynamically # hence manual check if self._infields: for key in self._infields: value = getattr(self.inputs, key) if not isdefined(value): msg = "%s requires a value for input '%s' because it was listed in 'infields'" % \ (self.__class__.__name__, key) raise ValueError(msg) outputs = {} for key, args in self.inputs.template_args.items(): outputs[key] = [] template = self.inputs.template if hasattr(self.inputs, 'field_template') and \ isdefined(self.inputs.field_template) and \ key in self.inputs.field_template: template = self.inputs.field_template[key] if isdefined(self.inputs.base_directory): template = os.path.join( os.path.abspath(self.inputs.base_directory), template) else: template = os.path.abspath(template) if not args: filelist = glob.glob(template) if len(filelist) == 0: msg = 'Output key: %s Template: %s returned no files' % ( key, template) if self.inputs.raise_on_empty: raise IOError(msg) else: warn(msg) else: if self.inputs.sort_filelist: filelist.sort() outputs[key] = list_to_filename(filelist) for argnum, arglist in enumerate(args): maxlen = 1 for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): if (maxlen > 1) and (len(arg) != maxlen): raise ValueError( 'incompatible number of arguments for %s' % key) if len(arg) > maxlen: maxlen = len(arg) outfiles = [] for i in range(maxlen): argtuple = [] for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): argtuple.append(arg[i]) else: argtuple.append(arg) filledtemplate = template if argtuple: try: filledtemplate = template % tuple(argtuple) except TypeError as e: raise TypeError( e.message + ": Template %s failed to convert with args %s" % (template, str(tuple(argtuple)))) outfiles = glob.glob(filledtemplate) if len(outfiles) == 0: msg = 'Output key: %s Template: %s returned no files' % ( key, filledtemplate) if self.inputs.raise_on_empty: raise IOError(msg) else: warn(msg) outputs[key].insert(i, None) else: if self.inputs.sort_filelist: outfiles.sort() outputs[key].insert(i, list_to_filename(outfiles)) if any([val is None for val in outputs[key]]): outputs[key] = [] if len(outputs[key]) == 0: outputs[key] = None elif len(outputs[key]) == 1: outputs[key] = outputs[key][0] return outputs
def selectindex(files, idx): """ Select the items in the list `files` in the indexes given by the list of integers `idx`.""" import numpy as np from nipype.utils.filemanip import filename_to_list, list_to_filename return list_to_filename(np.array(filename_to_list(files))[idx].tolist())
def _list_outputs(self): """Find the files and expose them as interface outputs.""" outputs = {} info = dict([(k, v) for k, v in list(self.inputs.__dict__.items()) if k in self._infields]) # check if the crumb is not absolute or if in info we have the parameter for the base directory if not self._crumb.isabs(): first_arg_name, _ = self._crumb._first_open_arg() if first_arg_name not in info: raise KeyError('Crumb path is not absolute and could not find input for {}.'.format(first_arg_name)) elif not op.isabs(info[first_arg_name]): raise IOError('Expected an absolute path for {} argument in {} but got {}.'.format(first_arg_name, self._crumb, info[first_arg_name], )) force_lists = self.inputs.force_lists if isinstance(force_lists, bool): force_lists = self._outfields if force_lists else [] bad_fields = set(force_lists) - set(self._outfields) if bad_fields: bad_fields = ", ".join(list(bad_fields)) plural = "s" if len(bad_fields) > 1 else "" verb = "were" if len(bad_fields) > 1 else "was" msg = ("The field%s '%s' %s set in 'force_lists' and not in " "'templates'.") % (plural, bad_fields, verb) raise ValueError(msg) # loop over the crumb arguments to fill self_crumb crumb_info = {k: v for k, v in info.items() if k in self._crumb.open_args()} ocrumb = self._crumb.replace(**crumb_info) # check again if crumb path is absolute if not ocrumb.isabs(): raise ValueError('Expected a Crumb with an absolute path, got {}.'.format(ocrumb)) if not ocrumb.exists(): raise IOError('Expected an existing Crumb path, got {}.'.format(ocrumb)) # loop over all the ouput items and fill them with the info in templates for field, template in self._templates.items(): # Fill in the template and glob for files focrumb = ocrumb.replace(**dict(template)) if list(focrumb.open_args()): raise ValueError('Expected a full specification of the Crumb path by now, got {}.'.format(focrumb)) filelist = [cr.path for cr in focrumb.unfold()] # Handle the case where nothing matched if not filelist: msg = "No files were found unfolding %s crumb path: %s" % ( field, focrumb) if self.inputs.raise_on_empty: raise IOError(msg) else: warn(msg) # Possibly sort the list if self.inputs.sort_filelist: filelist = human_order_sorted(filelist) # Handle whether this must be a list or not if field not in force_lists: filelist = list_to_filename(filelist) outputs[field] = filelist # add the crumb argument values for output for arg_name in focrumb.all_args(): outputs[arg_name] = focrumb[arg_name][0] return outputs
def selectindex(files, idx): import numpy as np from nipype.utils.filemanip import filename_to_list, list_to_filename return list_to_filename( np.array(filename_to_list(files))[idx].tolist())
def selectN(files, N=1): from nipype.utils.filemanip import filename_to_list, list_to_filename return list_to_filename(filename_to_list(files)[:N])
def _list_outputs(self): # infields are mandatory, however I could not figure out how to set 'mandatory' flag dynamically # hence manual check if self._infields: for key in self._infields: value = getattr(self.inputs,key) if not isdefined(value): msg = "%s requires a value for input '%s' because it was listed in 'infields'" % \ (self.__class__.__name__, key) raise ValueError(msg) outputs = {} for key, args in self.inputs.template_args.items(): outputs[key] = [] template = self.inputs.template if hasattr(self.inputs, 'field_template') and \ isdefined(self.inputs.field_template) and \ self.inputs.field_template.has_key(key): template = self.inputs.field_template[key] if isdefined(self.inputs.base_directory): template = os.path.join(os.path.abspath(self.inputs.base_directory), template) else: template = os.path.abspath(template) if not args: filelist = glob.glob(template) if len(filelist) == 0: msg = 'Output key: %s Template: %s returned no files'%(key, template) if self.inputs.raise_on_empty: raise IOError(msg) else: warn(msg) else: if self.inputs.sort_filelist: filelist.sort() outputs[key] = list_to_filename(filelist) for argnum, arglist in enumerate(args): maxlen = 1 for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): if (maxlen > 1) and (len(arg) != maxlen): raise ValueError('incompatible number of arguments for %s' % key) if len(arg)>maxlen: maxlen = len(arg) outfiles = [] for i in range(maxlen): argtuple = [] for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): argtuple.append(arg[i]) else: argtuple.append(arg) filledtemplate = template if argtuple: filledtemplate = template%tuple(argtuple) outfiles = glob.glob(filledtemplate) if len(outfiles) == 0: msg = 'Output key: %s Template: %s returned no files'%(key, filledtemplate) if self.inputs.raise_on_empty: raise IOError(msg) else: warn(msg) outputs[key].insert(i, None) else: if self.inputs.sort_filelist: outfiles.sort() outputs[key].insert(i,list_to_filename(outfiles)) if any([val==None for val in outputs[key]]): outputs[key] = [] if len(outputs[key]) == 0: outputs[key] = None elif len(outputs[key]) == 1: outputs[key] = outputs[key][0] return outputs
def _list_outputs(self): # infields are mandatory, however I could not figure out how to set 'mandatory' flag dynamically # hence manual check config_info = load_json(self.inputs.config_file) cwd = os.getcwd() xnat = XNATInterface(config_info['url'], config_info['username'], config_info['password'], cachedir=cwd) if self._infields: for key in self._infields: value = getattr(self.inputs,key) if not isdefined(value): msg = "%s requires a value for input '%s' because it was listed in 'infields'" % \ (self.__class__.__name__, key) raise ValueError(msg) outputs = {} for key, args in self.inputs.query_template_args.items(): outputs[key] = [] template = self.inputs.query_template if hasattr(self.inputs, 'field_template') and \ isdefined(self.inputs.field_template) and \ self.inputs.field_template.has_key(key): template = self.inputs.field_template[key] if not args: file_objects = xnat.select(template).request_objects() if file_objects == []: raise IOError('Template %s returned no files'%template) outputs[key] = list_to_filename([str(file_object.get()) for file_object in file_objects]) for argnum, arglist in enumerate(args): maxlen = 1 for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): if (maxlen > 1) and (len(arg) != maxlen): raise ValueError('incompatible number of arguments for %s' % key) if len(arg)>maxlen: maxlen = len(arg) outfiles = [] for i in range(maxlen): argtuple = [] for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): argtuple.append(arg[i]) else: argtuple.append(arg) if argtuple: file_objects = xnat.select(template%tuple(argtuple)).request_objects() if file_objects == []: raise IOError('Template %s returned no files'%(template%tuple(argtuple))) outfiles = list_to_filename([str(file_object.get()) for file_object in file_objects]) else: file_objects = xnat.select(template).request_objects() if file_objects == []: raise IOError('Template %s returned no files'%template) outfiles = list_to_filename([str(file_object.get()) for file_object in file_objects]) outputs[key].insert(i,outfiles) if len(outputs[key]) == 0: outputs[key] = None elif len(outputs[key]) == 1: outputs[key] = outputs[key][0] return outputs
def selectindex(files, idx): import numpy as np from nipype.utils.filemanip import filename_to_list, list_to_filename return list_to_filename(np.array(filename_to_list(files))[idx].tolist())
def test_list_to_filename(): x = list_to_filename(['foo.nii']) yield assert_equal, x, 'foo.nii' x = list_to_filename(['foo', 'bar']) yield assert_equal, x, ['foo', 'bar']
def _list_outputs(self): # infields are mandatory, however I could not figure out # how to set 'mandatory' flag dynamically, hence manual check cache_dir = self.inputs.cache_dir or tempfile.gettempdir() if self.inputs.config: xnat = pyxnat.Interface(config=self.inputs.config) else: xnat = pyxnat.Interface(self.inputs.server, self.inputs.user, self.inputs.pwd, cache_dir) if self._infields: for key in self._infields: value = getattr(self.inputs, key) if not isdefined(value): msg = ("%s requires a value for input '%s' " "because it was listed in 'infields'" % (self.__class__.__name__, key)) raise ValueError(msg) outputs = {} for key, args in self.inputs.query_template_args.items(): outputs[key] = [] template = self.inputs.query_template if hasattr(self.inputs, 'field_template') and \ isdefined(self.inputs.field_template) and \ key in self.inputs.field_template: template = self.inputs.field_template[key] if not args: file_objects = xnat.select(template).get('obj') if file_objects == []: raise IOError('Template %s returned no files' % template) outputs[key] = list_to_filename([ str(file_object.get()) for file_object in file_objects if file_object.exists() ]) for argnum, arglist in enumerate(args): maxlen = 1 for arg in arglist: if isinstance(arg, str) and hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): if (maxlen > 1) and (len(arg) != maxlen): raise ValueError('incompatible number ' 'of arguments for %s' % key) if len(arg) > maxlen: maxlen = len(arg) outfiles = [] for i in range(maxlen): argtuple = [] for arg in arglist: if isinstance(arg, str) and \ hasattr(self.inputs, arg): arg = getattr(self.inputs, arg) if isinstance(arg, list): argtuple.append(arg[i]) else: argtuple.append(arg) if argtuple: target = template % tuple(argtuple) file_objects = xnat.select(target).get('obj') if file_objects == []: raise IOError('Template %s ' 'returned no files' % target) outfiles = list_to_filename([ str(file_object.get()) for file_object in file_objects if file_object.exists() ]) else: file_objects = xnat.select(template).get('obj') if file_objects == []: raise IOError('Template %s ' 'returned no files' % template) outfiles = list_to_filename([ str(file_object.get()) for file_object in file_objects if file_object.exists() ]) outputs[key].insert(i, outfiles) if len(outputs[key]) == 0: outputs[key] = None elif len(outputs[key]) == 1: outputs[key] = outputs[key][0] return outputs
def _list_outputs(self): """Find the files and expose them as interface outputs.""" outputs = {} info = dict([(k, v) for k, v in list(self.inputs.__dict__.items()) if k in self._infields]) # check if the crumb is not absolute or if in info we have the parameter for the base directory if not self._crumb.isabs(): first_arg_name, _ = self._crumb._first_open_arg() if first_arg_name not in info: raise KeyError( 'Crumb path is not absolute and could not find input for {}.' .format(first_arg_name)) elif not op.isabs(info[first_arg_name]): raise IOError( 'Expected an absolute path for {} argument in {} but got {}.' .format( first_arg_name, self._crumb, info[first_arg_name], )) force_lists = self.inputs.force_lists if isinstance(force_lists, bool): force_lists = self._outfields if force_lists else [] bad_fields = set(force_lists) - set(self._outfields) if bad_fields: bad_fields = ", ".join(list(bad_fields)) plural = "s" if len(bad_fields) > 1 else "" verb = "were" if len(bad_fields) > 1 else "was" msg = ("The field%s '%s' %s set in 'force_lists' and not in " "'templates'.") % (plural, bad_fields, verb) raise ValueError(msg) # loop over the crumb arguments to fill self_crumb crumb_info = { k: v for k, v in info.items() if k in self._crumb.open_args() } ocrumb = self._crumb.replace(**crumb_info) # check again if crumb path is absolute if not ocrumb.isabs(): raise ValueError( 'Expected a Crumb with an absolute path, got {}.'.format( ocrumb)) if not ocrumb.exists(): raise IOError( 'Expected an existing Crumb path, got {}.'.format(ocrumb)) # loop over all the ouput items and fill them with the info in templates for field, template in self._templates.items(): # Fill in the template and glob for files focrumb = ocrumb.replace(**dict(template)) if list(focrumb.open_args()): raise ValueError( 'Expected a full specification of the Crumb path by now, got {}.' .format(focrumb)) filelist = [cr.path for cr in focrumb.unfold()] # Handle the case where nothing matched if not filelist: msg = "No files were found unfolding %s crumb path: %s" % ( field, focrumb) if self.inputs.raise_on_empty: raise IOError(msg) else: warn(msg) # Possibly sort the list if self.inputs.sort_filelist: filelist = human_order_sorted(filelist) # Handle whether this must be a list or not if field not in force_lists: filelist = list_to_filename(filelist) outputs[field] = filelist # add the crumb argument values for output for arg_name in focrumb.all_args(): outputs[arg_name] = focrumb[arg_name][0] return outputs