def _format_arg(self, name, spec, value):
import os
import shutil
cur_dir = os.getcwd()
new_value = []
if name == 'in_file':
if isinstance(value, list):
print("A list for in_file")
for in_file in value:
print(in_file)
# copy en local
shutil.copy(in_file, cur_dir)
new_value.append(os.path.join(cur_dir, in_file))
else:
print("Not a list for in_file {}".format(value))
shutil.copy(value, cur_dir)
path, fname, ext = split_f(value)
new_value = os.path.join(cur_dir, fname + ext)
print(new_value)
value = new_value
elif name == 'out_file':
if isinstance(value, list):
print("A list for out_file")
print("out_file:", value)
for out_file in value[:1]:
print(out_file)
path, fname, ext = split_f(out_file)
new_value.append(
os.path.join(cur_dir, fname + "_Nwarp" + ext))
for i in range(1, 4):
new_value.append(
os.path.join(cur_dir, "tmp_%02d.nii.gz" % i))
print("after out_file:", new_value)
else:
print("Not a list for out_file {}".format(value))
path, fname, ext = split_f(value)
new_value = os.path.abspath(fname + "_Nwarp" + ext)
print(new_value)
self.new_value = new_value
value = new_value
return super(NwarpApplyPriors, self)._format_arg(name, spec, value)
def _gen_outfilename(self):
from nipype.utils.filemanip import split_filename as split_f
_, in_brain, _ = split_f(self.inputs.inb_file)
_, ref, _ = split_f(self.inputs.refb_file)
if isdefined(self.inputs.xp):
outname = self.inputs.xp
else:
outname = in_brain + "_FLIRT-to_" + ref
return outname
def _list_outputs(self):
import os
from nipype.utils.filemanip import split_filename as split_f
outputs = self._outputs().get()
t1_path, t1_fname, ext = split_f(self.inputs.t1_file)
t2_path, t2_fname, ext = split_f(self.inputs.t2_file)
if self.inputs.c:
# !!!!warning, in Regis bash, only .nii.gz are handled
outputs["t1_cropped_file"] = os.path.abspath(
t1_fname + self.inputs.cs + ".nii.gz")
if self.inputs.aT2:
outputs["t2_cropped_file"] = os.path.abspath(
t2_fname + self.inputs.opt_as + self.inputs.cs + ".nii.gz")
else:
outputs["t2_cropped_file"] = os.path.abspath(
t2_fname + self.inputs.cs + ".nii.gz")
outputs["t1_brain_file"] = os.path.abspath(
t1_fname + self.inputs.opt_os + self.inputs.cs + ".nii.gz")
outputs["t2_brain_file"] = os.path.abspath(
t2_fname + self.inputs.opt_os + self.inputs.cs + ".nii.gz")
if self.inputs.m:
# !!!!warning, in Regis bash, only .nii.gz are handled
outputs["mask_file"] = os.path.abspath(
t1_fname + self.inputs.opt_os + self.inputs.ms +
self.inputs.cs + ".nii.gz")
else:
outputs["t1_brain_file"] = os.path.abspath(
t1_fname + self.inputs.opt_os + ".nii.gz")
outputs["t2_brain_file"] = os.path.abspath(
t2_fname + self.inputs.opt_os + ".nii.gz")
if self.inputs.m:
# !!!!warning, in Regis bash, only .nii.gz are handled
outputs["mask_file"] = os.path.abspath(
t1_fname + self.inputs.opt_os + self.inputs.ms + ".nii.gz")
if self.inputs.aT2:
outputs["t2_coreg_file"] = os.path.abspath(
t2_fname + self.inputs.opt_as + ".nii.gz")
return outputs
def convert_ds_to_raw_fif(ds_file):
import os
import os.path as op
from nipype.utils.filemanip import split_filename as split_f
from mne.io import read_raw_ctf
subj_path,basename,ext = split_f(ds_file)
print subj_path,basename,ext
raw = read_raw_ctf(ds_file)
#raw_fif_file = os.path.abspath(basename + "_raw.fif")
#raw.save(raw_fif_file)
#return raw_fif_file
raw_fif_file = os.path.join(subj_path,basename + "_raw.fif")
if not op.isfile(raw_fif_file):
raw = read_raw_ctf(ds_file)
raw.save(raw_fif_file)
else:
print '*** RAW FIF file %s exists!!!' % raw_fif_file
return raw_fif_file
def _is_trans(raw_fname, trans_fname_template=None):
"""Check if coregistration file."""
data_path, raw_fname, ext = split_f(raw_fname)
if not trans_fname_template:
raw_fname_4trans = raw_fname
raw_fname_4trans = raw_fname_4trans.replace('_', '*')
raw_fname_4trans = raw_fname_4trans.replace('-', '*')
raw_fname_4trans = raw_fname_4trans.replace('filt', '*')
raw_fname_4trans = raw_fname_4trans.replace('dsamp', '*')
raw_fname_4trans = raw_fname_4trans.replace('ica', '*')
raw_fname_4trans = raw_fname_4trans.replace('raw', '*')
trans_fpath = op.join(data_path, '%s*trans.fif' % raw_fname_4trans)
else:
trans_fpath = op.join(data_path, trans_fname_template)
trans_files = glob.glob(trans_fpath)
assert len(trans_files) == 1, "Error, should be only one trans file"
trans_fname = trans_files[0]
print(('\n*** coregistration file %s found!!!\n' % trans_fname))
print (trans_fname)
if not op.isfile(trans_fname):
raise RuntimeError('*** coregistration file %s NOT found!!!'
% trans_fname)
return trans_fname
def get_MRI_sbj_dir(dcm_file):
from nipype.utils.filemanip import split_filename as split_f
import os.path as op
MRI_sbj_dir, basename, ext = split_f(dcm_file)
struct_filename = op.join(MRI_sbj_dir, 'struct.nii.gz')
return struct_filename
def plot_coclass_matrix_labels_range(coclass_matrix_file,labels_file,list_value_range):
import numpy as np
import os
from nipype.utils.filemanip import split_filename as split_f
from dmgraphanalysis.utils_plot import plot_ranged_cormat
#from dmgraphanalysis.utils_plot import plot_cormat
print 'loading labels'
labels = [line.strip() for line in open(labels_file)]
np_labels = np.array(labels,dtype = 'string')
#print np_labels
#print coclass_mat.shape
print 'loading coclass'
coclass_mat = np.load(coclass_matrix_file)
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 plot_coclass_matrix_file
def _is_trans(raw_fname, trans_fname_template=None):
"""Check if coregistration file."""
data_path, raw_fname, ext = split_f(raw_fname)
if not trans_fname_template:
raw_fname_4trans = raw_fname
raw_fname_4trans = raw_fname_4trans.replace('_', '*')
raw_fname_4trans = raw_fname_4trans.replace('-', '*')
raw_fname_4trans = raw_fname_4trans.replace('filt', '*')
raw_fname_4trans = raw_fname_4trans.replace('dsamp', '*')
raw_fname_4trans = raw_fname_4trans.replace('ica', '*')
raw_fname_4trans = raw_fname_4trans.replace('raw', '*')
trans_fpath = op.join(data_path, '%s*trans.fif' % raw_fname_4trans)
else:
trans_fpath = op.join(data_path, trans_fname_template)
for trans_fname in glob.glob(trans_fpath):
print(('\n*** coregistration file %s found!!!\n' % trans_fname))
if not op.isfile(trans_fname):
raise RuntimeError('*** coregistration file %s NOT found!!!' %
trans_fname)
return trans_fname
def plot_igraph_coclass_matrix(coclass_matrix_file,gm_mask_coords_file,threshold):
import numpy as np
import os
import pylab as pl
from dmgraphanalysis.plot_igraph import plot_igraph_3D_int_mat
from nipype.utils.filemanip import split_filename as split_f
print 'loading coclass_matrix'
coclass_matrix = np.load(coclass_matrix_file)
path,fname,ext = split_f(coclass_matrix_file)
print 'loading gm mask corres'
gm_mask_coords = np.loadtxt(gm_mask_coords_file)
print gm_mask_coords.shape
print 'plotting igraph'
coclass_matrix[coclass_matrix < threshold] = 0
plot_igraph_3D_coclass_matrix_file = os.path.abspath('plot_igraph_3D_coclass_matrix.eps')
plot_igraph_3D_int_mat(coclass_matrix,gm_mask_coords,plot_igraph_3D_coclass_matrix_file)
return plot_igraph_3D_coclass_matrix_file
def preprocess_fif(fif_file, l_freq=None, h_freq=None, down_sfreq=None):
"""Filter and downsample data"""
import os
from mne.io import read_raw_fif
from mne import pick_types
from nipype.utils.filemanip import split_filename as split_f
_, basename, ext = split_f(fif_file)
raw = read_raw_fif(fif_file, preload=True)
filt_str, down_str = '', ''
select_sensors = pick_types(raw.info, meg=True, ref_meg=False, eeg=False)
if l_freq or h_freq:
raw.filter(l_freq=l_freq, h_freq=h_freq,
picks=select_sensors, fir_design='firwin')
filt_str = '_filt'
if down_sfreq:
raw.resample(sfreq=down_sfreq, npad=0, stim_picks=select_sensors)
down_str = '_dsamp'
savename = os.path.abspath(basename + filt_str + down_str + ext)
raw.save(savename)
return savename
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 _format_arg(self, name, spec, value):
import os
import shutil
cur_dir = os.getcwd()
new_value = []
if name == 'in_file':
for in_file in value:
print(in_file)
# copy en local
shutil.copy(in_file, cur_dir)
new_value.append(os.path.join(cur_dir, in_file))
value = new_value
elif name == 'out_file':
for out_file in value[:1]:
print(out_file)
path, fname, ext = split_f(out_file)
# out_files.append(os.path.join(path,fname + "_Nwarp" + ext))
new_value.append(os.path.join(cur_dir, fname + "_Nwarp" + ext))
for i in range(1, 4):
new_value.append(os.path.join(cur_dir, "tmp_%02d.nii.gz" % i))
value = new_value
return super(NwarpApplyPriors, self)._format_arg(name, spec, value)
def split_indexed_mask(nii_file, background_val=0):
import os
import nibabel as nib
import numpy as np
from nipype.utils.filemanip import split_filename as split_f
path, fname, ext = split_f(nii_file)
nii = nib.load(nii_file)
nii_data = nii.get_data()
list_split_files = []
for index in np.unique(nii_data):
if index == background_val:
continue
split_file = os.path.abspath("{}_{}{}".format(fname, index, ext))
split_data = np.zeros(shape=nii_data.shape)
split_data[nii_data == index] = 1
nib.save(
nib.Nifti1Image(split_data, header=nii.header, affine=nii.affine),
split_file)
list_split_files.append(split_file)
return list_split_files
def convert_ds_to_raw_fif(ds_file):
"""CTF .ds to .fif and save result in pipeline folder structure."""
import os
import os.path as op
from nipype.utils.filemanip import split_filename as split_f
from mne.io import read_raw_ctf
_, basename, ext = split_f(ds_file)
# print(subj_path, basename, ext)
raw = read_raw_ctf(ds_file)
# raw_fif_file = os.path.abspath(basename + "_raw.fif")
# raw.save(raw_fif_file)
# return raw_fif_file
raw_fif_file = os.path.abspath(basename + "_raw.fif")
if not op.isfile(raw_fif_file):
raw = read_raw_ctf(ds_file)
raw.save(raw_fif_file)
else:
print(('*** RAW FIF file %s exists!!!' % raw_fif_file))
return raw_fif_file
def _format_arg(self, name, spec, value):
import os
import shutil
cur_path = os.path.abspath("")
print("***** In formating args for ", name)
# all the files have to be in local and
if name == 'brain_file' or name == 'brainmask_file':
# requires local copy
shutil.copy(value, cur_path)
value = os.path.split(value)[1]
elif name == 'priors':
new_value = []
print("***** Copying prior files in cur dir:", value)
for prior_file in value:
shutil.copy(prior_file, cur_path)
new_value.append(os.path.split(prior_file)[1])
print("After copying:", new_value)
value = "tmp_%02d_allineate_hd.nii.gz"
elif name == 'out_pref':
pth, fname, ext = split_f(self.inputs.brain_file)
value = fname + '_'
self.inputs.out_pref = value
return super(AtroposN4, self)._format_arg(name, spec, value)
def create_epochs(fif_file, ep_length):
"""Split raw .fif file into epochs of
length ep_length with rejection criteria"""
import os
from mne.io import Raw
from mne import Epochs
from mne import pick_types
from nipype.utils.filemanip import split_filename as split_f
# flat = dict(mag=0.1e-12, grad=1e-13)
# reject = dict(mag=6e-12, grad=25e-11)
flat = None
reject = None
raw = Raw(fif_file)
picks = pick_types(raw.info, ref_meg=False, eeg=False)
if raw.times[-1] >= ep_length:
events = create_events(raw, ep_length)
else:
raise Exception('File {} is too short!'.format(fif_file))
epochs = Epochs(raw, events=events, tmin=0, tmax=ep_length,
preload=True, picks=picks, proj=False,
flat=flat, reject=reject)
_, base, ext = split_f(fif_file)
savename = os.path.abspath(base + '-epo' + ext)
epochs.save(savename)
return savename
def _list_outputs(self):
from nipype.utils.filemanip import split_filename as split_f
outputs = self._outputs().get()
path, fname, ext = split_f(self.inputs.T1_file)
outputs["aff_file"] = os.path.abspath(fname + "_affine" + ext)
# TODO will require some checks
# outputs["warpinv_file"] = os.path.abspath(
# fname + "_shft_WARPINV.nii")
outputs["warpinv_file"] = os.path.abspath(fname + "_WARPINV.nii.gz")
outputs["warp_file"] = os.path.abspath(fname + "_WARP.nii.gz")
# outputs["warpinv_file"] = os.path.abspath(
# fname + "_shft_WARPINV" + ext)
outputs["transfo_file"] = os.path.abspath(
fname + "_composite_linear_to_NMT.1D")
outputs["inv_transfo_file"] = os.path.abspath(
fname + "_composite_linear_to_NMT_inv.1D")
return outputs
def compute_noise_cov(cov_fname, raw):
import os.path as op
from mne import compute_raw_covariance, pick_types, write_cov
from nipype.utils.filemanip import split_filename as split_f
from neuropype_ephy.preproc import create_reject_dict
print '***** COMPUTE RAW COV *****' + cov_fname
if not op.isfile(cov_fname):
data_path, basename, ext = split_f(raw.info['filename'])
fname = op.join(data_path, '%s-cov.fif' % basename)
reject = create_reject_dict(raw.info)
# reject = dict(mag=4e-12, grad=4000e-13, eog=250e-6)
picks = pick_types(raw.info, meg=True, ref_meg=False, exclude='bads')
noise_cov = compute_raw_covariance(raw, picks=picks, reject=reject)
write_cov(fname, noise_cov)
else:
print '*** NOISE cov file %s exists!!!' % cov_fname
return cov_fname
def _save_psd_img(data_fname, psds, freqs, is_epoched=False, method=''):
import os
import matplotlib.pyplot as plt
import numpy as np
from nipype.utils.filemanip import split_filename as split_f
data_path, basename, ext = split_f(data_fname)
psds_img_fname = basename + '-psds.png'
psds_img_fname = os.path.abspath(psds_img_fname)
# save PSD as img
f, ax = plt.subplots()
psds = 10 * np.log10(psds)
if is_epoched:
psds_mean = psds.mean(0).mean(0)
psds_std = psds.mean(0).std(0)
else:
psds_mean = psds.mean(0)
psds_std = psds.std(0)
ax.plot(freqs, psds_mean, color='g')
ax.fill_between(freqs,
psds_mean - psds_std,
psds_mean + psds_std,
color='g',
alpha=.5)
ax.set(title='{} PSD'.format(method),
xlabel='Frequency',
ylabel='Power Spectral Density (dB)')
print(('*** save {} ***'.format(psds_img_fname)))
plt.savefig(psds_img_fname)
def _read_hdf5(filename, dataset_name='dataset', transpose=False):
"""
Read hdf5 file
Inputs
filename : str
hdf5 filename
dataset_name : str
name of dataset to create
transpose: bool
if the data needs to be transpose or not
Outputs
data : array, shape (n_vertices, n_times)
raw data for whose the dataset is created
"""
hf = h5py.File(filename, 'r')
data = hf[dataset_name][()]
if transpose:
data = np.transpose(data)
old_path, basename, ext = split_f(filename)
npy_filename = os.path.abspath(basename + '.npy')
print(npy_filename)
np.save(npy_filename, data, allow_pickle=True)
return npy_filename
def get_MRI_sbj_dir(dcm_file):
from nipype.utils.filemanip import split_filename as split_f
import os.path as op
MRI_sbj_dir, basename, ext = split_f(dcm_file)
struct_filename = op.join(MRI_sbj_dir, 'struct.nii.gz')
return struct_filename
def _run_interface(self, runtime):
coclass_matrix_file = self.inputs.coclass_matrix_file
labels_file = self.inputs.labels_file
list_value_range = self.inputs.list_value_range
coclass_mat = np.load(coclass_matrix_file)
if isdefined(labels_file):
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)]
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 _create_epochs(fif_file, ep_length):
"""Split raw .fif file into epochs.
Splitted epochs have a length ep_length with rejection criteria.
"""
flat = None
reject = None
raw = read_raw_fif(fif_file)
picks = pick_types(raw.info, ref_meg=False, eeg=False)
if raw.times[-1] >= ep_length:
events = _create_events(raw, ep_length)
else:
raise Exception('File {} is too short!'.format(fif_file))
epochs = Epochs(raw,
events=events,
tmin=0,
tmax=ep_length,
preload=True,
picks=picks,
proj=False,
flat=flat,
reject=reject,
baseline=None)
_, base, ext = split_f(fif_file)
savename = os.path.abspath(base + '-epo' + ext)
epochs.save(savename)
return savename
def is_trans(raw_fname):
"""Check if coregistration file."""
import glob
import os.path as op
from nipype.utils.filemanip import split_filename as split_f
data_path, raw_fname, ext = split_f(raw_fname)
# check if the co-registration file was created
# if not raise an runtime error
# i_ica = raw_fname.find('ica')
# if i_ica != -1:
# raw_fname = raw_fname[:i_ica]
raw_fname_4trans = raw_fname
raw_fname_4trans = raw_fname_4trans.replace('_', '*')
raw_fname_4trans = raw_fname_4trans.replace('-', '*')
raw_fname_4trans = raw_fname_4trans.replace('filt', '*')
raw_fname_4trans = raw_fname_4trans.replace('dsamp', '*')
raw_fname_4trans = raw_fname_4trans.replace('ica', '*')
trans_fname = op.join(data_path, '%s*trans.fif' % raw_fname_4trans)
for trans_fname in glob.glob(trans_fname):
print(('\n*** coregistration file %s found!!!\n' % trans_fname))
if not op.isfile(trans_fname):
raise RuntimeError('*** coregistration file %s NOT found!!!' %
trans_fname)
return trans_fname
def compute_ROI_nii_from_ROI_coords_files(ref_img_file,
MNI_coords_file,
labels_file,
neighbourhood=1):
"""
Export single file VOI binary nii image
"""
ref_image = nib.load(ref_img_file)
ref_image_data = ref_image.get_data()
ref_image_data_shape = ref_image_data.shape
ref_image_data_sform = ref_image.get_sform()
ROI_MNI_coords_list = np.array(np.loadtxt(MNI_coords_file),
dtype='int').tolist()
ROI_labels = [lign.strip() for lign in open(labels_file)]
# transform MNI coords to numpy coords
mni_sform_inv = np.linalg.inv(ref_image_data_sform)
ROI_coords = np.array([
_coord_transform(x, y, z, mni_sform_inv)
for x, y, z in ROI_MNI_coords_list
],
dtype="int64")
for i, ROI_coord in enumerate(ROI_coords):
ROI_coords_labelled_mask = np.zeros(shape=ref_image_data_shape,
dtype='int64')
neigh_range = list(range(-neighbourhood, neighbourhood + 1))
for relative_coord in iter.product(neigh_range, repeat=3):
neigh_x, neigh_y, neigh_z = ROI_coord + relative_coord
print(neigh_x, neigh_y, neigh_z)
if check_np_dimension(
ROI_coords_labelled_mask.shape,
np.array([neigh_x, neigh_y, neigh_z], dtype='int64')):
ROI_coords_labelled_mask[neigh_x, neigh_y, neigh_z] = 1
print(ROI_coords_labelled_mask)
path, fname, ext = split_f(MNI_coords_file)
ROI_coords_labelled_mask_file = os.path.join(
path, "ROI_{}-neigh_{}_2.nii".format(ROI_labels[i],
str(neighbourhood)))
# save ROI_coords_labelled_mask
nib.save(
nib.Nifti1Image(ROI_coords_labelled_mask, ref_image.affine,
ref_image.header), ROI_coords_labelled_mask_file)
return ROI_coords_labelled_mask_file
def _run_interface(self, runtime):
raw_filename = self.inputs.raw_filename
cov_fname_in = self.inputs.cov_fname_in
is_epoched = self.inputs.is_epoched
is_evoked = self.inputs.is_evoked
events_id = self.inputs.events_id
t_min = self.inputs.t_min
t_max = self.inputs.t_max
data_path, basename, ext = split_f(raw_filename)
self.cov_fname_out = op.join(data_path, '%s-cov.fif' % basename)
# Check if a noise cov matrix was already computed
if not op.isfile(cov_fname_in):
if is_epoched and is_evoked:
raw = read_raw_fif(raw_filename)
events = find_events(raw)
if not op.isfile(self.cov_fname_out):
print(('\n*** COMPUTE COV FROM EPOCHS ***\n' +
self.cov_fname_out))
reject = _create_reject_dict(raw.info)
picks = pick_types(raw.info,
meg=True,
ref_meg=False,
exclude='bads')
epochs = Epochs(raw,
events,
events_id,
t_min,
t_max,
picks=picks,
baseline=(None, 0),
reject=reject)
# TODO method='auto'? too long!!!
noise_cov = compute_covariance(epochs,
tmax=0,
method='diagonal_fixed')
write_cov(self.cov_fname_out, noise_cov)
else:
print(('\n *** NOISE cov file %s exists!!! \n' %
self.cov_fname_out))
else:
# Compute noise cov matrix from empty room data
self.cov_fname_out = compute_noise_cov(
op.join(data_path, cov_fname_in), raw_filename)
else:
print(
('\n *** NOISE cov file {} exists!!! \n'.format(cov_fname_in)))
self.cov_fname_out = cov_fname_in
return runtime
def _list_outputs(self):
outputs = self._outputs().get()
path, fname, ext = split_f(self.inputs.Pajek_net_file)
#outputs["rada_log_file"] = os.path.abspath(fname + '.log')
return outputs
def plot_coclass_matrix(coclass_matrix_file):
import numpy as np
import os
import matplotlib.pyplot as plt
import pylab as pl
from nipype.utils.filemanip import split_filename as split_f
print 'loading sum_coclass_matrix'
sum_coclass_matrix = np.load(coclass_matrix_file)
path,fname,ext = split_f(coclass_matrix_file)
print 'plotting heatmap'
plot_heatmap_coclass_matrix_file = os.path.abspath('heatmap_' + fname + '.eps')
#fig1 = figure.Figure()
fig1 = plt.figure()
ax = fig1.add_subplot(1,1,1)
im = ax.matshow(sum_coclass_matrix)
im.set_cmap('spectral')
fig1.colorbar(im)
fig1.savefig(plot_heatmap_coclass_matrix_file)
plt.close(fig1)
#fig1.close()
del fig1
############# histogram
print 'plotting distance matrix histogram'
#plt.figure()
#plt.figure.Figure()
plot_hist_coclass_matrix_file = os.path.abspath('hist_coclass_matrix.eps')
#fig2 = figure.Figure()
fig2 = plt.figure()
ax = fig2.add_subplot(1,1,1)
y, x = np.histogram(sum_coclass_matrix, bins = 100)
ax.plot(x[:-1],y)
#ax.bar(x[:-1],y, width = y[1]-y[0])
fig2.savefig(plot_hist_coclass_matrix_file)
plt.close(fig2)
#fig2.close()
del fig2
return plot_hist_coclass_matrix_file,plot_heatmap_coclass_matrix_file
def _list_outputs(self):
outputs = self._outputs().get()
path, fname, ext = split_f(self.inputs.Pajek_net_file)
outputs["rada_log_file"] = os.path.abspath(fname + '.log')
return outputs
def _list_outputs(self):
outputs = self._outputs().get()
path,fname,ext = split_f(self.inputs.coclass_matrix_file)
outputs["plot_coclass_matrix_file"] = os.path.abspath('heatmap_' + fname + '.eps')
return outputs
def compute_ts_inv_sol(raw, fwd_filename, cov_fname, snr, inv_method, aseg):
"""Compute ts inverse solution."""
import os.path as op
import numpy as np
import mne
from mne.minimum_norm import make_inverse_operator, apply_inverse_raw
from nipype.utils.filemanip import split_filename as split_f
print(('***** READ FWD SOL %s *****' % fwd_filename))
forward = mne.read_forward_solution(fwd_filename)
# Convert to surface orientation for cortically constrained
# inverse modeling
if not aseg:
forward = mne.convert_forward_solution(forward, surf_ori=True)
lambda2 = 1.0 / snr**2
# compute inverse operator
print('***** COMPUTE INV OP *****')
inverse_operator = make_inverse_operator(raw.info,
forward,
cov_fname,
loose=0.2,
depth=0.8)
# apply inverse operator to the time windows [t_start, t_stop]s
# TEST
t_start = 0 # sec
t_stop = 3 # sec
start, stop = raw.time_as_index([t_start, t_stop])
print(('***** APPLY INV OP ***** [%d %d]sec' % (t_start, t_stop)))
stc = apply_inverse_raw(raw,
inverse_operator,
lambda2,
inv_method,
label=None,
start=start,
stop=stop,
pick_ori=None)
print('***')
print(('stc dim ' + str(stc.shape)))
print('***')
subj_path, basename, ext = split_f(raw.info['filename'])
data = stc.data
print(('data dim ' + str(data.shape)))
# save results in .npy file that will be the input for spectral node
print('***** SAVE SOL *****')
ts_file = op.abspath(basename + '.npy')
np.save(ts_file, data)
return ts_file
def _list_outputs(self):
import os
from nipype.utils.filemanip import split_filename as split_f
outputs = self._outputs().get()
path, fname, ext = split_f(self.inputs.t1_restored_file)
outputs["brain_file"] = os.path.abspath(fname + '_brain' + ext)
return outputs
def _list_outputs(self):
outputs = self._outputs().get()
path, fname, ext = split_f(self.inputs.coclass_matrix_file)
outputs["plot_coclass_matrix_file"] = os.path.abspath('heatmap_' +
fname + '.eps')
return outputs
def _get_raw_array(raw_fname, save_data=True):
"""Read a raw data from **.fif** file and save the data time series, the
sensors coordinates and labels in .npy and .txt files.
Parameters
----------
raw_fname : str
pathname of the raw data to read
Returns
-------
array_file : str
pathname of the numpy file (.npy) containing the data read from
raw_fname
channel_coords_file : str
pathname of .txt file containing the channels coordinates
channel_names_file : str
pathname of .txt file containing the channels labels
sfreq : float
sampling frequency
"""
raw = read_raw_fif(raw_fname, preload=True)
subj_path, basename, ext = split_f(raw_fname)
select_sensors = mne.pick_types(raw.info,
meg=True,
ref_meg=False,
exclude='bads')
# save electrode locations
sens_loc = [raw.info['chs'][i]['loc'][:3] for i in select_sensors]
sens_loc = np.array(sens_loc)
channel_coords_file = os.path.abspath('correct_channel_coords.txt')
np.savetxt(channel_coords_file, sens_loc, fmt=str("%s"))
# save electrode names
ch_names = np.array([raw.ch_names[pos] for pos in select_sensors],
dtype='str')
channel_names_file = os.path.abspath('correct_channel_names.txt')
np.savetxt(channel_names_file, ch_names, fmt=str('%s'))
if save_data:
data, times = raw[select_sensors, :]
print((data.shape))
array_file = os.path.abspath(basename + '.npy')
np.save(array_file, data)
print('\n *** TS FILE {} *** \n'.format(array_file))
else:
array_file = None
print('*** raw.info[sfreq] = {}'.format(raw.info['sfreq']))
return array_file, channel_coords_file, channel_names_file, raw.info[
'sfreq'] # noqa
def _get_fwd_filename(raw_fpath, aseg, spacing):
data_path, raw_fname, ext = split_f(raw_fpath)
fwd_filename = raw_fname + '-' + spacing
if aseg:
fwd_filename += '-aseg'
fwd_filename = op.join(data_path, fwd_filename + '-fwd.fif')
print(('\n *** fwd_filename {} ***\n'.format(fwd_filename)))
return fwd_filename
def _list_outputs(self):
outputs = self._outputs().get()
net_List_file = self.inputs.net_List_file
path, fname, ext = split_f(net_List_file)
outputs["Pajek_net_file"] = os.path.abspath(fname + '.net')
return outputs
def _list_outputs(self):
outputs = self._outputs().get()
net_List_file = self.inputs.net_List_file
path, fname, ext = split_f(net_List_file)
outputs["Pajek_net_file"] = os.path.abspath(fname + '.net')
return outputs
def _get_fwd_filename(self, raw_info, aseg, spacing):
data_path, raw_fname, ext = split_f(raw_info)
fwd_filename = '%s-%s' % (raw_fname, spacing)
if aseg:
fwd_filename += '-aseg'
fwd_filename = op.join(data_path, fwd_filename + '-fwd.fif')
print(('\n *** fwd_filename %s ***\n' % fwd_filename))
return fwd_filename
def split_fif_into_eo_ec(fif_file, lCondStart, lCondEnd, first_samp, cond):
# import mne
import os
from nipype.utils.filemanip import split_filename as split_f
from mne.io import Raw
subj_path, basename, ext = split_f(fif_file)
# raw1 = raw.crop(tmin=10, tmax=30)
# print("I did smth")
# --------------- Delete later ----------------------- #
subj_name = subj_path[-5:]
results_dir = subj_path[:-6]
results_dir += '2016'
subj_path = results_dir + '/' + subj_name
if not os.path.exists(subj_path):
os.makedirs(subj_path)
########################################################
print(fif_file)
Raw_fif = Raw(fif_file, preload=True)
# first_samp_time = Raw_fif.index_as_time(Raw_fif.first_samp)
lRaw_cond = []
# print("I did smth")
if cond == 'eo':
eo_ec_split_fif = subj_path + '/' + basename + '_eo'
elif cond == 'ec':
eo_ec_split_fif = subj_path + '/' + basename + '_ec'
for i in range(len(lCondStart)):
tmin = lCondStart[i] - first_samp
tmax = lCondEnd[i] - first_samp
# To make sure, that my eo-ec time intervals are inside the recording
if i == 0:
tmin += 0.5
if i == range(len(lCondStart))[-1]:
tmax -= 0.5
####################################
# print("tmin = ")
# print(tmin)
# print("tmax = ")
# print(tmax)
fif_cropped = Raw_fif.crop(tmin=tmin, tmax=tmax)
cropped_filename = eo_ec_split_fif + '_' + str(i) + ext
fif_cropped.save(cropped_filename, overwrite=True)
lRaw_cond.append(fif_cropped)
Raw_cond = lRaw_cond[0]
Raw_cond.append(lRaw_cond[1:])
print(eo_ec_split_fif)
eo_ec_split_fif = eo_ec_split_fif + ext
Raw_cond.save(eo_ec_split_fif, overwrite=True)
return eo_ec_split_fif
def merge_masks(mask_csf_file,
mask_wm_file,
mask_gm_file,
index_csf=1,
index_gm=2,
index_wm=3):
import nibabel as nib
import numpy as np
import os.path as op
from nipype.utils.filemanip import split_filename as split_f
# csf (and init indexed_mask)
path, fname, ext = split_f(mask_csf_file)
mask_csf = nib.load(mask_csf_file)
mask_csf_data = mask_csf.get_data()
indexed_mask_data = np.zeros(shape=mask_csf_data.shape)
indexed_mask_data[mask_csf_data == 1] = index_csf
# gm
mask_gm = nib.load(mask_gm_file)
mask_gm_data = mask_gm.get_data()
assert np.all(indexed_mask_data.shape == mask_gm_data.shape)
indexed_mask_data[mask_gm_data == 1] = index_gm
# wm
mask_wm = nib.load(mask_wm_file)
mask_wm_data = mask_wm.get_data()
assert np.all(indexed_mask_data.shape == mask_wm_data.shape)
indexed_mask_data[mask_wm_data == 1] = index_wm
# creating indexed_mask
indexed_mask = nib.Nifti1Image(dataobj=indexed_mask_data,
affine=mask_csf.affine,
header=mask_csf.header)
# saving indexed_mask_file
indexed_mask_file = op.abspath(fname + "_indexed_mask" + ext)
nib.save(indexed_mask, indexed_mask_file)
return indexed_mask_file
def average_align(list_img):
import os
import nibabel as nib
import numpy as np
from nipype.utils.filemanip import split_filename as split_f
import nipype.interfaces.fsl as fsl
print("average_align:", list_img)
if isinstance(list_img, list):
assert len(list_img) > 0, "Error, list should have at least one file"
if len(list_img) == 1:
assert os.path.exists(list_img[0])
av_img_file = list_img[0]
else:
img_0 = nib.load(list_img[0])
path, fname, ext = split_f(list_img[0])
list_data = [img_0.get_data()]
for i, img in enumerate(list_img[1:]):
print("running flirt on {}".format(img))
flirt = fsl.FLIRT(dof=6)
flirt.inputs.in_file = img
flirt.inputs.reference = list_img[0]
flirt.inputs.interp = "sinc"
flirt.inputs.no_search = True
out_file = flirt.run().outputs.out_file
print(out_file)
data = nib.load(out_file).get_data()
list_data.append(data)
avg_data = np.mean(np.array(list_data), axis=0)
print(avg_data.shape)
av_img_file = os.path.abspath("avg_" + fname + ext)
nib.save(
nib.Nifti1Image(avg_data,
header=img_0.get_header(),
affine=img_0.get_affine()), av_img_file)
else:
assert os.path.exists(list_img)
av_img_file = list_img
return av_img_file
def _get_fwd_filename(self, raw_info, aseg, spacing):
data_path, raw_fname, ext = split_f(raw_info['filename'])
if aseg == traits.Undefined:
fwd_filename = op.join(data_path, '%s-%s-fwd.fif'
% (raw_fname, spacing))
else:
fwd_filename = op.join(data_path, '%s-%s-aseg-fwd.fif'
% (raw_fname, spacing))
print '*** fwd_filename %s ***' % fwd_filename
return fwd_filename
def get_ext_file(raw_file):
from nipype.utils.filemanip import split_filename as split_f
subj_path, basename, ext = split_f(raw_file)
print raw_file
is_ds = False
if ext is 'ds':
is_ds = True
return is_ds
elif ext is 'fif':
return is_ds
else:
raise RuntimeError('only fif and ds file format!!!')
def _get_fwd_filename(self, raw_info, aseg, spacing, is_blind):
data_path, raw_fname, ext = split_f(raw_info['filename'])
fwd_filename = '%s-%s' % (raw_fname, spacing)
if is_blind:
fwd_filename += '-blind'
if aseg:
fwd_filename += '-aseg'
fwd_filename = op.join(data_path, fwd_filename + '-fwd.fif')
print '\n *** fwd_filename %s ***\n' % fwd_filename
return fwd_filename
def is_trans(raw_info):
import os.path as op
from nipype.utils.filemanip import split_filename as split_f
data_path, raw_fname, ext = split_f(raw_info['filename'])
# check if the co-registration file was created
# if not raise an runtime error
trans_fname = op.join(data_path, '%s-trans.fif' % raw_fname)
if not op.isfile(trans_fname):
raise RuntimeError('*** coregistration file %s NOT found!!!'
% trans_fname)
return trans_fname
def import_mat_to_conmat(mat_file,orig_channel_names_file,orig_channel_coords_file):
import os
import numpy as np
import mne
from mne.io import RawArray
from nipype.utils.filemanip import split_filename as split_f
from scipy.io import loadmat
subj_path,basename,ext = split_f(mat_file)
mat = loadmat(mat_file)
#field_name = basename.split('_')[0]
#field_name = basename.split('_')[1]
#print field_name
print mat["mat_x"].shape
raw_data = np.array(mat["mat_x"],dtype = "f")
print raw_data
print raw_data.shape
conmat_file = os.path.abspath(basename +".npy")
np.save(conmat_file,raw_data)
correct_channel_coords = np.loadtxt(orig_channel_coords_file)
print correct_channel_coords
correct_channel_names = np.loadtxt(orig_channel_coords_file)
print correct_channel_names
### save channel coords
channel_coords_file = os.path.abspath("correct_channel_coords.txt")
np.savetxt(channel_coords_file ,correct_channel_coords , fmt = '%s')
### save channel names
channel_names_file = os.path.abspath("correct_channel_names.txt")
np.savetxt(channel_names_file,correct_channel_names , fmt = '%s')
return conmat_file,channel_coords_file,channel_names_file
def compute_ts_inv_sol(raw, fwd_filename, cov_fname, snr, inv_method, aseg):
import os.path as op
import numpy as np
import mne
from mne.minimum_norm import make_inverse_operator, apply_inverse_raw
from nipype.utils.filemanip import split_filename as split_f
print '***** READ FWD SOL %s *****' % fwd_filename
forward = mne.read_forward_solution(fwd_filename)
# Convert to surface orientation for cortically constrained
# inverse modeling
if not aseg:
forward = mne.convert_forward_solution(forward, surf_ori=True)
lambda2 = 1.0 / snr ** 2
# compute inverse operator
print '***** COMPUTE INV OP *****'
inverse_operator = make_inverse_operator(raw.info, forward, cov_fname,
loose=0.2, depth=0.8)
# apply inverse operator to the time windows [t_start, t_stop]s
# TEST
t_start = 0 # sec
t_stop = 3 # sec
start, stop = raw.time_as_index([t_start, t_stop])
print '***** APPLY INV OP ***** [%d %d]sec' % (t_start, t_stop)
stc = apply_inverse_raw(raw, inverse_operator, lambda2, inv_method,
label=None,
start=start, stop=stop, pick_ori=None)
print '***'
print 'stc dim ' + str(stc.shape)
print '***'
subj_path, basename, ext = split_f(raw.info['filename'])
data = stc.data
print 'data dim ' + str(data.shape)
# save results in .npy file that will be the input for spectral node
print '***** SAVE SOL *****'
ts_file = op.abspath(basename + '.npy')
np.save(ts_file, data)
return ts_file
def community_list_Louvain(Louvain_bin_file,Louvain_conf_file,louvain_bin_path):
import os
from nipype.utils.filemanip import split_filename as split_f
#path, fname, ext = '','',''
path, fname, ext = split_f(Louvain_bin_file)
Louvain_mod_file = os.path.abspath(fname + '.mod')
cmd = os.path.join(louvain_bin_path,'community') + ' ' + Louvain_bin_file + ' ' + Louvain_conf_file + ' > ' + Louvain_mod_file
print "executing command " + cmd
os.system(cmd)
return Louvain_mod_file
def import_tsmat_to_ts(tsmat_file,data_field_name = 'F', good_channels_field_name = 'ChannelFlag'):
#,orig_channel_names_file,orig_channel_coords_file):
import os
import numpy as np
import mne
from mne.io import RawArray
from nipype.utils.filemanip import split_filename as split_f
from scipy.io import loadmat
print tsmat_file
subj_path,basename,ext = split_f(tsmat_file)
mat = loadmat(tsmat_file)
raw_data = np.array(mat[data_field_name],dtype = "f")
print raw_data.shape
if good_channels_field_name != None:
print "Using good channels to sort channels"
good_channels = np.array(mat[good_channels_field_name])
print good_channels.shape
good_channels = good_channels.reshape(good_channels.shape[0])
print good_channels.shape
good_data = raw_data[good_channels == 1,:]
print good_data.shape
else:
print "No channel sorting"
good_data = raw_data
#### save data
print good_data.shape
ts_file = os.path.abspath("tsmat.npy")
np.save(ts_file,good_data)
return ts_file
def plot_order_coclass_matrix_labels(coclass_matrix_file,node_order_vect_file,labels_file):
import numpy as np
import os
from nipype.utils.filemanip import split_filename as split_f
from dmgraphanalysis.utils_plot import plot_cormat
print 'loading labels'
labels = [line.strip() for line in open(labels_file)]
np_labels = np.array(labels,dtype = 'string')
#print np_labels
#print coclass_mat.shape
print 'loading coclass'
coclass_mat = np.load(coclass_matrix_file)
print 'loading node order'
node_order_vect = np.array(np.loadtxt(node_order_vect_file),dtype = 'int')
print 'reordering labels'
#print node_order_vect
np_reordered_labels = np_labels[node_order_vect]
list_reordered_labels = np_reordered_labels.tolist()
print 'reordering coclass'
mat = coclass_mat[node_order_vect,: ]
reordered_coclass_mat = mat[:, node_order_vect]
path,fname,ext = split_f(coclass_matrix_file)
print 'plotting reorder heatmap'
plot_reordered_coclass_matrix_file = os.path.abspath('reordered_heatmap_' + fname + '.eps')
plot_cormat(plot_reordered_coclass_matrix_file,reordered_coclass_mat,list_reordered_labels)
return plot_reordered_coclass_matrix_file
def _run_interface(self, runtime):
radatools_path = self.inputs.radatools_path
net_List_file = self.inputs.net_List_file
path, fname, ext = split_f(net_List_file)
Pajek_net_file = os.path.abspath(fname + '.net')
cmd = os.path.join(radatools_path,'01-Prepare_Network','List_To_Net.exe') + ' ' + net_List_file + ' ' + Pajek_net_file + ' U'
print "defining command " + cmd
os.system(cmd)
return runtime
def _run_interface(self, runtime):
raw_filename = self.inputs.raw_filename
cov_fname_in = self.inputs.cov_fname_in
is_epoched = self.inputs.is_epoched
is_evoked = self.inputs.is_evoked
events_id = self.inputs.events_id
t_min = self.inputs.t_min
t_max = self.inputs.t_max
if cov_fname_in == '' or not op.exists(cov_fname_in):
if is_epoched and is_evoked:
raw = Raw(raw_filename)
events = find_events(raw)
data_path, basename, ext = split_f(raw.info['filename'])
self.cov_fname_out = op.join(data_path, '%s-cov.fif' % basename)
if not op.exists(self.cov_fname_out):
print '\n*** COMPUTE COV FROM EPOCHS ***\n' + self.cov_fname_out
reject = create_reject_dict(raw.info)
picks = pick_types(raw.info, meg=True, ref_meg=False,
exclude='bads')
epochs = Epochs(raw, events, events_id, t_min, t_max,
picks=picks, baseline=(None, 0),
reject=reject)
# TODO method='auto'? too long!!!
noise_cov = compute_covariance(epochs, tmax=0,
method='diagonal_fixed')
write_cov(self.cov_fname_out, noise_cov)
else:
print '\n *** NOISE cov file %s exists!!! \n' % self.cov_fname_out
else:
'\n *** NO EPOCH DATA \n'
else:
print '\n *** NOISE cov file %s exists!!! \n' % cov_fname_in
self.cov_fname_out = cov_fname_in
return runtime
def prep_radatools(List_net_file,radatools_prep_path):
import os
from nipype.utils.filemanip import split_filename as split_f
#path, fname, ext = '','',''
path, fname, ext = split_f(List_net_file)
Pajek_net_file = os.path.abspath(fname + '.net')
cmd = os.path.join(radatools_prep_path,'List_To_Net.exe') + ' ' + List_net_file + ' ' + Pajek_net_file + ' U'
print "executing command " + cmd
os.system(cmd)
return Pajek_net_file
def import_amplmat_to_ts(tsmat_file):
#,orig_channel_names_file,orig_channel_coords_file):
import os
import numpy as np
import mne
from mne.io import RawArray
from nipype.utils.filemanip import split_filename as split_f
from scipy.io import loadmat
print tsmat_file
subj_path,basename,ext = split_f(tsmat_file)
mat = loadmat(tsmat_file)
#field_name = basename.split('_')[0]
#field_name = basename.split('_')[1]
#print field_name
raw_data = np.array(mat['F'],dtype = "f")
print raw_data.shape
good_channels = np.array(mat['ChannelFlag'])
good_channels = good_channels.reshape(good_channels.shape[0])
print "Good channels:"
print good_channels.shape
good_data = raw_data[good_channels == 1,:]
print good_data.shape
#### save data
ts_file = os.path.abspath("amplmat.npy")
np.save(ts_file,good_data)
#np.save(ts_file,raw_data)
return ts_file
def import_mat_to_conmat(mat_file, data_field_name='F',
orig_channel_names_file=None,
orig_channel_coords_file=None):
import os
import numpy as np
from nipype.utils.filemanip import split_filename as split_f
from scipy.io import loadmat
subj_path, basename, ext = split_f(mat_file)
mat = loadmat(mat_file)
print mat[data_field_name].shape
raw_data = np.array(mat[data_field_name], dtype='f')
print raw_data
print raw_data.shape
ts_file = os.path.abspath(basename + '.npy')
np.save(ts_file, raw_data)
if orig_channel_names_file is not None:
correct_channel_coords = np.loadtxt(orig_channel_coords_file)
print correct_channel_coords
# save channel coords
channel_coords_file = os.path.abspath('correct_channel_coords.txt')
np.savetxt(channel_coords_file, correct_channel_coords, fmt='%s')
if orig_channel_coords_file is not None:
correct_channel_names = np.loadtxt(orig_channel_coords_file)
print correct_channel_names
# save channel names
channel_names_file = os.path.abspath('correct_channel_names.txt')
np.savetxt(channel_names_file, correct_channel_names, fmt='%s')
if orig_channel_names_file is not None and orig_channel_coords_file is not None:
return ts_file, channel_coords_file, channel_names_file
else:
return ts_file
def _run_interface(self, runtime):
radatools_path = self.inputs.radatools_path
Pajek_net_file = self.inputs.Pajek_net_file
optim_seq = self.inputs.optim_seq
path, fname, ext = split_f(Pajek_net_file)
rada_lol_file = os.path.abspath(fname + '.lol')
rada_log_file = os.path.abspath(fname + '.log')
cmd = os.path.join(radatools_path,'02-Find_Communities','Communities_Detection.exe') + ' v ' + optim_seq + ' ' + Pajek_net_file + ' ' + rada_lol_file + ' > ' + rada_log_file
print "defining command " + cmd
os.system(cmd)
return runtime
def _run_interface(self, runtime):
radatools_path = self.inputs.radatools_path
Pajek_net_file = self.inputs.Pajek_net_file
optim_seq = self.inputs.optim_seq
path, fname, ext = split_f(Pajek_net_file)
rada_log_file = os.path.abspath(fname + '.log')
cmd = os.path.join(radatools_path,'04-Other_Tools','Network_Properties.exe') + ' ' + Pajek_net_file + ' ' + optim_seq + ' > ' + rada_log_file
#+ ' > '+ rada_res_file
print "defining command " + cmd
os.system(cmd)
return runtime
def community_radatools(Pajek_net_file,optim_seq,radatools_comm_path):
import os
from nipype.utils.filemanip import split_filename as split_f
#path, fname, ext = '','',''
path, fname, ext = split_f(Pajek_net_file)
rada_lol_file = os.path.abspath(fname + '.lol')
rada_log_file = os.path.abspath(fname + '.log')
#cmd = os.path.join(radatools_comm_path,'Communities_Detection.exe') + ' v WS f 1 ' + Pajek_net_file + ' ' + rada_lol_file + ' > ' + rada_log_file
cmd = os.path.join(radatools_comm_path,'Communities_Detection.exe') + ' v ' + optim_seq + ' ' + Pajek_net_file + ' ' + rada_lol_file + ' > ' + rada_log_file
print "executing command " + cmd
os.system(cmd)
return rada_lol_file,rada_log_file
def convert_list_Louvain(Louvain_list_file,louvain_bin_path):
import os
from nipype.utils.filemanip import split_filename as split_f
#path, fname, ext = '','',''
path, fname, ext = split_f(Louvain_list_file)
Louvain_bin_file = os.path.abspath(fname + '.bin')
Louvain_node_file = os.path.abspath(fname + '.node.txt')
Louvain_conf_file = os.path.abspath(fname + '.conf')
cmd = os.path.join(louvain_bin_path,'slicer') + ' -i ' + Louvain_list_file + ' -o ' + Louvain_bin_file + ' -n ' + Louvain_node_file + ' -c ' + Louvain_conf_file + ' -u'
print "executing command " + cmd
os.system(cmd)
return Louvain_bin_file,Louvain_node_file,Louvain_conf_file
def create_ts(raw_fname):
import os
import numpy as np
import mne
from mne.io import Raw
from nipype.utils.filemanip import split_filename as split_f
raw = Raw(raw_fname, preload=True)
subj_path, basename, ext = split_f(raw_fname)
select_sensors = mne.pick_types(raw.info, meg=True, ref_meg=False,
exclude='bads')
# save electrode locations
sens_loc = [raw.info['chs'][i]['loc'][:3] for i in select_sensors]
sens_loc = np.array(sens_loc)
channel_coords_file = os.path.abspath("correct_channel_coords.txt")
np.savetxt(channel_coords_file, sens_loc, fmt='%s')
# save electrode names
sens_names = np.array([raw.ch_names[pos] for pos in select_sensors],
dtype="str")
channel_names_file = os.path.abspath("correct_channel_names.txt")
np.savetxt(channel_names_file, sens_names, fmt='%s')
data, times = raw[select_sensors, :]
print data.shape
ts_file = os.path.abspath(basename + '.npy')
np.save(ts_file, data)
print '\n *** TS FILE ' + ts_file + '*** \n'
return ts_file, channel_coords_file, channel_names_file, raw.info['sfreq']
