def project_on_surface(subject, volume_file, surf_output_fname, target_subject=None, overwrite_surf_data=False, modality='fmri', subjects_dir='', mmvt_dir='', **kargs): if target_subject is None: target_subject = subject if subjects_dir == '': subjects_dir = utils.get_link_dir(utils.get_links_dir(), 'subjects', 'SUBJECTS_DIR') if mmvt_dir == '': mmvt_dir = utils.get_link_dir(utils.get_links_dir(), 'mmvt') utils.make_dir(op.join(mmvt_dir, subject, 'fmri')) os.environ['SUBJECTS_DIR'] = subjects_dir os.environ['SUBJECT'] = subject for hemi in utils.HEMIS: if not op.isfile(surf_output_fname.format(hemi=hemi)) or overwrite_surf_data: print('project {} to {}'.format(volume_file, hemi)) if modality != 'pet': surf_data = project_volume_data(volume_file, hemi, subject_id=subject, surf="pial", smooth_fwhm=3, target_subject=target_subject, output_fname=surf_output_fname.format(hemi=hemi)) else: surf_data = project_pet_volume_data(subject, volume_file, hemi, surf_output_fname.format(hemi=hemi)) nans = np.sum(np.isnan(surf_data)) if nans > 0: print('there are {} nans in {} surf data!'.format(nans, hemi)) surf_data = np.squeeze(nib.load(surf_output_fname.format(hemi=hemi)).get_data()) output_fname = op.join(mmvt_dir, subject, modality, '{}_{}'.format(modality, op.basename( surf_output_fname.format(hemi=hemi)))) npy_output_fname = op.splitext(output_fname)[0] if not op.isfile('{}.npy'.format(npy_output_fname)) or overwrite_surf_data: print('Saving surf data in {}.npy'.format(npy_output_fname)) utils.make_dir(utils.get_parent_fol(npy_output_fname)) np.save(npy_output_fname, surf_data)
def get_links(): links_dir = utils.get_links_dir() subjects_dir = utils.get_link_dir(links_dir, 'subjects', 'SUBJECTS_DIR') freesurfer_home = utils.get_link_dir(links_dir, 'freesurfer', 'FREESURFER_HOME') mmvt_dir = utils.get_link_dir(links_dir, 'mmvt') return subjects_dir, mmvt_dir, freesurfer_home
def calc_dipoles_rois(subject, atlas='laus125', overwrite=False, n_jobs=4): links_dir = utils.get_links_dir() subjects_dir = utils.get_link_dir(links_dir, 'subjects') mmvt_dir = utils.get_link_dir(links_dir, 'mmvt') diploes_rois_output_fname = op.join(mmvt_dir, subject, 'meg', 'dipoles_rois.pkl') if op.isfile(diploes_rois_output_fname) and not overwrite: diploes_rois = utils.load(diploes_rois_output_fname) for dip in diploes_rois.keys(): diploes_rois[dip]['cortical_probs'] *= 1/sum(diploes_rois[dip]['cortical_probs']) diploes_rois[dip]['subcortical_probs'] = [] diploes_rois[dip]['subcortical_rois'] = [] # coritcal_labels = set(utils.flat_list_of_lists([diploes_rois[k]['cortical_rois'] for k in diploes_rois.keys()])) utils.save(diploes_rois, diploes_rois_output_fname) return True diploes_input_fname = op.join(mmvt_dir, subject, 'meg', 'dipoles.pkl') if not op.isfile(diploes_input_fname): print('No dipoles file!') return False labels = lu.read_labels(subject, subjects_dir, atlas, n_jobs=n_jobs) labels = list([{'name': label.name, 'hemi': label.hemi, 'vertices': label.vertices} for label in labels]) if len(labels) == 0: print('Can\'t find the labels for atlas {}!'.format(atlas)) return False # find the find_rois package mmvt_code_fol = utils.get_mmvt_code_root() ela_code_fol = op.join(utils.get_parent_fol(mmvt_code_fol), 'electrodes_rois') if not op.isdir(ela_code_fol) or not op.isfile(op.join(ela_code_fol, 'find_rois', 'main.py')): print("Can't find ELA folder!") print('git pull https://github.com/pelednoam/electrodes_rois.git') return False # load the find_rois package try: import sys if ela_code_fol not in sys.path: sys.path.append(ela_code_fol) from find_rois import main as ela except: print('Can\'t load find_rois package!') utils.print_last_error_line() return False dipoles_dict = utils.load(diploes_input_fname) diploles_names, dipoles_pos = [], [] for cluster_name, dipoles in dipoles_dict.items(): for begin_t, _, x, y, z, _, _, _, _, _ in dipoles: dipole_name = '{}_{}'.format(cluster_name, begin_t) if len(dipoles) > 1 else cluster_name diploles_names.append(dipole_name.replace(' ', '')) dipoles_pos.append([k * 1e3 for k in [x, y, z]]) dipoles_rois = ela.identify_roi_from_atlas( atlas, labels, diploles_names, dipoles_pos, approx=3, elc_length=0, hit_only_cortex=True, subjects_dir=subjects_dir, subject=subject, n_jobs=n_jobs) # Convert the list to a dict dipoles_rois_dict = {dipoles_rois['name']: dipoles_rois for dipoles_rois in dipoles_rois} utils.save(dipoles_rois_dict, diploes_rois_output_fname)
def main(args): # 1) Create links if utils.should_run(args, 'create_links'): links_created = create_links(args.links, args.gui) if not links_created: print('Not all the links were created! Make sure all the links are created before running MMVT.') # 2) Copy resources files if utils.should_run(args, 'copy_resources_files'): links_dir = utils.get_links_dir(args.links) mmvt_root_dir = utils.get_link_dir(links_dir, 'mmvt') resource_file_exist = copy_resources_files(mmvt_root_dir) if not resource_file_exist: print('Not all the resources files were copied to the MMVT folder.\n'.format(mmvt_root_dir) + 'Please copy them manually from the mmvt_code/resources folder') # 3) Install the addon in Blender (depends on resources and links) if utils.should_run(args, 'install_addon'): from src.mmvt_addon.scripts import install_addon install_addon.wrap_blender_call() # 4) Install dependencies from requirements.txt (created using pipreqs) if utils.should_run(args, 'install_reqs'): install_reqs() print('Finish!')
def create_seghead(subject, subjects_dir=None, print_only=False, **kargs): if subjects_dir is None: subjects_dir = utils.get_link_dir(utils.get_links_dir(), 'subjects', 'SUBJECTS_DIR') os.environ['SUBJECTS_DIR'] = subjects_dir rs = utils.partial_run_script(locals(), print_only=print_only) rs(mkheadsurf)
def pre_blender_call(args): from src.mmvt_addon import load_results_panel from src.preproc import fMRI as fmri from src.utils import preproc_utils as pu from src.utils import utils user_fol = op.join(pu.MMVT_DIR, args.subject) nii_fname = args.nii if not op.isfile(args.nii): args.nii = op.join(user_fol, 'fmri', nii_fname) if not op.isfile(args.nii): fmri_fol = op.join(utils.get_link_dir(utils.get_links_dir(), 'fMRI'), args.subject) args.nii = op.join(fmri_fol, nii_fname) if not op.isfile(args.nii): raise Exception("Can't find the nii file!") fmri_file_template, _, _ = load_results_panel.load_surf_files( args.nii, run_fmri_preproc=False, user_fol=user_fol) preproc_args = fmri.read_cmd_args( dict(subject=args.subject, atlas=args.atlas, function='load_surf_files', fmri_file_template=fmri_file_template, ignore_missing=True)) ret = pu.run_on_subjects(preproc_args, fmri.main) if ret: load_results_panel.clean_nii_temp_files(fmri_file_template, user_fol) args.fmri_file_template = fmri_file_template else: raise Exception("Couldn't load the surface files!") return args
def combine_images(fol, movie_name, frame_rate=10, start_number=-1, images_prefix='', images_format='', images_type='', ffmpeg_cmd='', movie_name_full_path=False, debug=False, copy_files=False, add_reverse_frames=False, **kwargs): if ffmpeg_cmd == '': ffmpeg_dir = utils.get_link_dir(utils.get_links_dir(), 'ffmpeg') ffmpeg_dir = op.join(ffmpeg_dir, 'bin') if utils.is_windows() else ffmpeg_dir ffmpeg_cmd = op.join(ffmpeg_dir, 'ffmpeg') if op.isdir(ffmpeg_dir) else 'ffmpeg' print('ffmpeg_cmd: {}'.format(ffmpeg_cmd)) images_type, images_prefix, images_format, images_format_len, start_number = find_images_props( fol, start_number, images_prefix, images_format, images_type) if movie_name == '' and images_prefix != '': movie_name = images_prefix elif movie_name == '': movie_name = 'output_video' org_fol = fol if utils.is_windows() or copy_files: fol = change_frames_names(fol, images_prefix, images_type, images_format_len) if add_reverse_frames: add_reverse_frames_fol(fol, images_prefix, images_type) images_prefix = op.join(fol, images_prefix) if not movie_name_full_path: movie_name = op.join(fol, movie_name) combine_images_cmd = '{ffmpeg_cmd} -framerate {frame_rate} ' if start_number != 1: # You might want to use a static ffmpeg if your ffmepg version doesn't support the start_number flag, like: # ffmpeg_cmd = '~/space1/Downloads/ffmpeg-git-static/ffmpeg' combine_images_cmd += '-start_number {start_number} ' # Not working in windows: # combine_images_cmd += '-pattern_type glob -i "*.{images_type}" ' combine_images_cmd += '-i {images_prefix}{images_format}.{images_type} ' # http://stackoverflow.com/questions/20847674/ffmpeg-libx264-height-not-divisible-by-2 combine_images_cmd += '-vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" ' combine_images_cmd += '-c:v libx264 -r 30 -pix_fmt yuv420p {movie_name}.mp4' if debug: combine_images_cmd += ' -loglevel debug' rs = utils.partial_run_script(locals()) rs(combine_images_cmd) with open(op.join(org_fol, 'combine_images_cmd.txt'), 'w') as f: f.write(combine_images_cmd.format(**locals())) return '{}.mp4'.format(movie_name)
def read_cmd_args(argv=None, subject='', mri_subject='', atlas=''): if argv is None and subject != '': mri_subject = subject if mri_subject == '' else mri_subject argv = ['-s', subject, '-m', mri_subject] args = meg.read_cmd_args(argv) if atlas != '' and args.atlas != atlas: args.atlas = atlas args.pick_meg = False args.pick_eeg = True args.reject = False args.fwd_usingMEG = False args.fwd_usingEEG = True args.modality = 'eeg' args.meg_dir = utils.get_link_dir(LINKS_DIR, 'eeg') if not op.isdir(args.meg_dir): raise Exception('EEG dir can\'t be found! Please rerun src.setup with -f create_links') return args
def copy_fmri_ts_files(subjects, delete_previous_files=True): FMRI_DIR = utils.get_link_dir(utils.get_links_dir(), 'fMRI') for sub in subjects: # ts_files = glob.glob(op.join(ts_root_fol, sub, 'rest', 'laus125_*.txt')) ts_files = glob.glob( op.join(ts_root_fol, '{}_laus125_*.txt'.format(sub))) if len(ts_files) == 0: print('No ts files for {}!'.format(sub)) for ts_file in ts_files: target_fname = op.join(FMRI_DIR, sub, utils.namebase_with_ext(ts_file)) if delete_previous_files: for old_fname in glob.glob( op.join(FMRI_DIR, sub, '*laus125_*.txt')): os.remove(old_fname) print('Copy {} to {}'.format(ts_file, target_fname)) utils.copy_file(ts_file, target_fname)
import argparse import os.path as op from src.preproc import connectivity as con from src.utils import utils from src.utils import args_utils as au from src.utils import preproc_utils as pu LINKS_DIR = utils.get_links_dir() ELECTRODES_DIR = utils.get_link_dir(LINKS_DIR, 'electrodes') MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') def example1(subject): # subject = 'fsaverage5c' args = con.read_cmd_args(['-s', subject]) args.atlas = 'laus125' args.mat_fname = '/cluster/neuromind/npeled/linda/figure_file1.mat' args.mat_field = 'figure_file' args.windows = 1 args.stat = con.STAT_DIFF args.threshold_percentile = 99 args.conditions = ['task', 'rest'] con.save_rois_connectivity(subject, args) def example2(subject): # subject = 'fsaverage5c' args = con.read_cmd_args(['-s', subject]) args.atlas = 'laus125' args.mat_fname = '/cluster/neuromind/npeled/linda/figure_file3.mat' args.mat_field = 'matrix_cognition_ratio_fpn_dmn'
from src.mmvt_addon.dell import find_electrodes_in_ct as fect import numpy as np import os.path as op import nibabel as nib from itertools import product from scipy.spatial.distance import cdist from src.utils import utils MMVT_DIR = utils.get_link_dir(utils.get_links_dir(), 'mmvt') def find_local_maxima_from_voxels(voxel, ct_data, threshold, find_nei_maxima=True): voxels = np.array([voxel]) maxs = fect.find_all_local_maxima(ct_data, voxels, threshold, find_nei_maxima) print(maxs) def test2(ct_data, ct_header, brain, aseg, threshold, min_distance): ct_voxels = fect.find_voxels_above_threshold(ct_data, threshold) ct_voxels = fect.mask_voxels_outside_brain(ct_voxels, ct_header, brain, aseg) voxels = fect.find_all_local_maxima(ct_data, ct_voxels, threshold, find_nei_maxima=True, max_iters=100)
from pymesh import obj import os.path as op from src.utils import utils MMVT_DIR = utils.get_link_dir(utils.get_links_dir(), 'mmvt') def create_eeg_mesh_from_obj(subject, obj_fname): mesh_ply_fname = op.join(MMVT_DIR, subject, 'eeg', 'eeg_helmet.ply') # mesh = obj.Obj(obj_fname) # verts, faces = mesh.vertices, mesh.faces verts, faces = utils.read_obj_file(obj_fname) utils.write_ply_file(verts, faces, mesh_ply_fname) faces_verts_out_fname = op.join(MMVT_DIR, subject, 'eeg', 'eeg_faces_verts.npy') utils.calc_ply_faces_verts(verts, faces, faces_verts_out_fname, True, utils.namebase(faces_verts_out_fname)) def recreate_mesh_faces_verts(subject, ply_fname): verts, faces = utils.read_ply_file(ply_fname) faces_verts_out_fname = op.join(MMVT_DIR, subject, 'eeg', 'eeg_faces_verts.npy') utils.calc_ply_faces_verts(verts, faces, faces_verts_out_fname, True, utils.namebase(faces_verts_out_fname)) if __name__ == '__main__': subject = 'ep001' # create_eeg_mesh_from_obj(subject, '/homes/5/npeled/space1/mmvt/ep001/eeg/eeg_helmet.obj') recreate_mesh_faces_verts(subject, '/homes/5/npeled/space1/mmvt/ep001/eeg/eeg_helmet.ply') print('Finish!')
import os import os.path as op from collections import defaultdict import glob import traceback from src.utils import utils from src.utils import args_utils as au LINKS_DIR = utils.get_links_dir() SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') MMVT_DIR = op.join(LINKS_DIR, 'mmvt') def run_on_subjects(args, main_func, subjects_itr=None, subject_func=None): if subjects_itr is None: subjects_itr = args.subject subjects_flags, subjects_errors = {}, {} args.n_jobs = utils.get_n_jobs(args.n_jobs) args.sftp_password = utils.get_sftp_password( args.subject, SUBJECTS_DIR, args.necessary_files, args.sftp_username, args.overwrite_fs_files) \ if args.sftp else '' if '*' in args.subject: args.subject = [utils.namebase(fol) for fol in glob.glob(op.join(SUBJECTS_DIR, args.subject))] os.environ['SUBJECTS_DIR'] = SUBJECTS_DIR for tup in subjects_itr: subject = get_subject(tup, subject_func) utils.make_dir(op.join(MMVT_DIR, subject, 'mmvt')) remote_subject_dir = utils.build_remote_subject_dir(args.remote_subject_dir, subject) print('****************************************************************') print('subject: {}, atlas: {}'.format(subject, args.atlas))
from functools import partial import os.path as op import shutil import mne import scipy.io as sio import scipy from collections import defaultdict, OrderedDict, Iterable import matplotlib.pyplot as plt from src.utils import utils from src.mmvt_addon import colors_utils as cu from src.utils import matlab_utils as mu from src.utils import preproc_utils as pu SUBJECTS_DIR, MMVT_DIR, FREESURFER_HOME = pu.get_links() ELECTRODES_DIR = utils.get_link_dir(utils.get_links_dir(), 'electrodes') HEMIS = utils.HEMIS STAT_AVG, STAT_DIFF = range(2) STAT_NAME = {STAT_DIFF: 'diff', STAT_AVG: 'avg'} DEPTH, GRID = range(2) def montage_to_npy(montage_file, output_file): sfp = mne.channels.read_montage(montage_file) np.savez(output_file, pos=np.array(sfp.pos), names=sfp.ch_names) def electrodes_csv_to_npy(ras_file, output_file, bipolar=False, delimiter=','): data = np.genfromtxt(ras_file, dtype=str, delimiter=delimiter) data = fix_str_items_in_csv(data) # Check if the electrodes coordinates has a header
import os.path as op import numpy as np from src.utils import utils from src.utils import freesurfer_utils as fu from src.preproc import meg LINKS_DIR = utils.get_links_dir() FMRI_DIR = utils.get_link_dir(utils.get_links_dir(), 'fMRI') MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') def morph_fmri(morph_from, morph_to, nii_template): utils.make_dir(op.join(MMVT_DIR, morph_to, 'fmri')) for hemi in utils.HEMIS: fu.surf2surf( morph_from, morph_to, hemi, op.join(MMVT_DIR, morph_from, 'fmri', nii_template.format(hemi=hemi)), op.join(MMVT_DIR, morph_to, 'fmri', nii_template.format(hemi=hemi))) def morph_stc(subject, events, morph_to_subject, inverse_method='dSPM', grade=5, smoothing_iterations=None, overwrite=False, n_jobs=6):
import os.path as op from src.utils import utils import nibabel as nib import numpy as np LINKS_DIR = utils.get_links_dir() SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') DTI_DIR = utils.get_link_dir(LINKS_DIR, 'dti') MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') def load_tck_file(subject, tck_file_name): input_fname = op.join(DTI_DIR, subject, tck_file_name) if not op.isfile(input_fname): print('Cannot find the input file! {}!'.format(input_fname)) return False tck_file = nib.streamlines.load(input_fname) tracks = tck_file.streamlines.get_data() header = tck_file.header return tracks, header def save_to_mmvt(subject, tracks, header, tracks_name): dti_fol = utils.make_dir(op.join(MMVT_DIR, subject, 'dti')) np.save(op.join(dti_fol, '{}_tracks.npy'.format(tracks_name)), tracks) utils.save(header, op.join(dti_fol, '{}_header.pkl'.format(tracks_name))) def plot_tracks(tracks): import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D
import matplotlib.colors as mcolors import matplotlib.pyplot as plt import numpy as np import os.path as op from src.utils import utils from src.utils import figures_utils as figu LINKS_DIR = utils.get_links_dir() MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') def create_BuPu_YlOrRd_cm(n=128): colors1 = plt.cm.PuBu(np.linspace(1, 0, n)) colors2 = plt.cm.YlOrRd(np.linspace(0, 1, n)) colors = np.vstack((colors1, colors2)) colors_map = mcolors.LinearSegmentedColormap.from_list( 'BuPu_YlOrRd', colors) return colors_map def create_PuBu_RdOrYl_cm(n=128): colors1 = plt.cm.PuBu(np.linspace(0.2, 1, n)) colors2 = plt.cm.YlOrRd(np.linspace(1, 0.2, n)) colors = np.vstack((colors1, colors2)) colors_map = mcolors.LinearSegmentedColormap.from_list( 'PuBu_RdOrYl', colors) return colors_map def combine_two_colormaps(cm1_name,
import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt from src.preproc import eeg from src.preproc import meg from src.utils import utils import glob import os.path as op import mne import numpy as np import re LINKS_DIR = utils.get_links_dir() MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') MEG_DIR = utils.get_link_dir(LINKS_DIR, 'meg') EEG_DIR = utils.get_link_dir(LINKS_DIR, 'eeg') def calc_fwd_inv(subject, modality, run_num, raw_fname, empty_fname, bad_channels, overwrite_inv=False, overwrite_fwd=False): # python -m src.preproc.eeg -s nmr00857 -f calc_inverse_operator,make_forward_solution # --overwrite_inv 0 --overwrite_fwd 0 -t epilepsy # --raw_fname /autofs/space/frieda_001/users/valia/epilepsy/5241495_00857/subj_5241495/190123/5241495_01_raw.fif # --empty_fname /autofs/space/frieda_001/users/valia/epilepsy/5241495_00857/subj_5241495/190123/5241495_roomnoise_raw.fif
import os.path as op import glob from src.utils import utils FFMPEG_DIR = utils.get_link_dir(utils.get_links_dir(), 'ffmpeg') FFMPEG_DIR = op.join(FFMPEG_DIR, 'bin') if utils.is_windows() else FFMPEG_DIR FFMPEG_CMD = op.join(FFMPEG_DIR, 'ffmpeg') if op.isdir(FFMPEG_DIR) else 'ffmpeg' # from moviepy.config import change_settings # change_settings({"IMAGEMAGICK_BINARY": r"/usr/bin/convert"}) # https://www.vultr.com/docs/install-imagemagick-on-centos-6 # https://github.com/BVLC/caffe/issues/3884 def check_movipy(): try: import moviepy.config as conf if conf.try_cmd([conf.FFMPEG_BINARY])[0]: print("MoviePy : ffmpeg successfully found.") else: print("MoviePy : can't find or access ffmpeg.") if conf.try_cmd([conf.IMAGEMAGICK_BINARY])[0]: print("MoviePy : ImageMagick successfully found.") else: print("MoviePy : can't find or access ImageMagick.") except: print("Can't import moviepy")
import argparse import os.path as op import shutil import glob from src.preproc import meg as meg from src.utils import utils from src.utils import args_utils as au from src.utils import preproc_utils as pu LINKS_DIR = utils.get_links_dir() MEG_DIR = utils.get_link_dir(LINKS_DIR, 'meg') FMRI_DIR = utils.get_link_dir(utils.get_links_dir(), 'fMRI') MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') def read_epoches_and_calc_activity(subject, mri_subject): args = meg.read_cmd_args(['-s', subject, '-m', mri_subject]) args.function = ['calc_stc', 'calc_labels_avg_per_condition', 'smooth_stc', 'save_activity_map'] args.pick_ori = 'normal' args.colors_map = 'jet' meg.run_on_subjects(args) def calc_single_trial_labels_msit(subject, mri_subject): args = meg.read_cmd_args(['-s', subject, '-m', mri_subject]) args.task = 'MSIT' args.atlas = 'laus250' args.function = 'calc_stc,calc_single_trial_labels_per_condition' args.t_tmin = -0.5 args.t_tmax = 2
try: from sklearn.neighbors import BallTree except: print('No sklearn!') import shutil import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from src.utils import utils from src.utils import freesurfer_utils as fu from src.preproc import meg_preproc as meg LINKS_DIR = utils.get_links_dir() SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') SUBJECTS_MEG_DIR = utils.get_link_dir(LINKS_DIR, 'meg') FREE_SURFER_HOME = utils.get_link_dir(LINKS_DIR, 'freesurfer', 'FREESURFER_HOME') BLENDER_ROOT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') FMRI_DIR = utils.get_link_dir(LINKS_DIR, 'fMRI') os.environ['FREESURFER_HOME'] = FREE_SURFER_HOME os.environ['SUBJECTS_DIR'] = SUBJECTS_DIR # SUBJECTS_DIR = '/homes/5/npeled/space3/subjects' # # SUBJECTS_DIR = '/autofs/space/lilli_001/users/DARPA-MEG/freesurfs' # # SUBJECTS_DIR = '/home/noam/subjects/mri' # # SUBJECT = 'ep001' # os.environ['SUBJECTS_DIR'] = SUBJECTS_DIR # ROOT_DIR = [f for f in ['/homes/5/npeled/space3/fMRI/MSIT', '/home/noam/fMRI/MSIT'] if op.isdir(f)][0] # BLENDER_DIR = '/homes/5/npeled/space3/visualization_blender' # FREE_SURFER_HOME = utils.get_exisiting_dir([os.environ.get('FREESURFER_HOME', ''), # '/usr/local/freesurfer/stable5_3_0', '/home/noam/freesurfer'])
import os.path as op import numpy as np import mne.io import traceback from src.utils import utils from src.utils import preproc_utils as pu from src.preproc import meg as meg SUBJECTS_MRI_DIR, MMVT_DIR, FREESURFER_HOME = pu.get_links() LINKS_DIR = utils.get_links_dir() MEG_DIR = utils.get_link_dir(LINKS_DIR, 'meg') SUBJECTS_EEG_DIR = utils.get_link_dir(LINKS_DIR, 'eeg') if SUBJECTS_EEG_DIR == '': print('No EEG folder, using MEG folder') SUBJECTS_EEG_DIR = MEG_DIR if SUBJECTS_EEG_DIR == '': raise Exception('No EEG folder (not MEG)!') SUBJECT_EEG_DIR = '' def read_eeg_sensors_layout(subject, mri_subject, args): return meg.read_sensors_layout(subject, mri_subject, args, pick_meg=False, pick_eeg=True) def save_evoked_to_blender(mri_subject, events, args, evoked=None): fol = op.join(MMVT_DIR, mri_subject, 'eeg') utils.make_dir(fol) if '{cond}' in meg.EVO: for event_ind, event_id in enumerate(events.keys()):
import os import os.path as op from pizco import Proxy os.chdir(os.environ['MMVT_CODE']) from src.mmvt_addon.scripts import run_mmvt from src.utils import utils subject, atlas = 'DC', 'laus250' run_mmvt.run(subject, atlas, run_in_background=False, debug=False) mmvt = Proxy('tcp://127.0.0.1:8001') meg_dir = utils.get_link_dir(utils.get_links_dir(), 'meg') stc_fname = op.join(meg_dir, subject, 'left-MNE-1-15-lh.stc') mmvt.plot_stc(stc_fname, 1270, threshold=0.1)
import os.path as op import numpy as np import mne.io import traceback from functools import partial from src.utils import utils from src.utils import preproc_utils as pu from src.preproc import meg as meg SUBJECTS_MRI_DIR, MMVT_DIR, FREESURFER_HOME = pu.get_links() LINKS_DIR = utils.get_links_dir() MEG_DIR = utils.get_link_dir(LINKS_DIR, 'meg') SUBJECTS_EEG_DIR = utils.get_link_dir(LINKS_DIR, 'eeg') if SUBJECTS_EEG_DIR == '': print('No EEG folder, using MEG folder') SUBJECTS_EEG_DIR = MEG_DIR if SUBJECTS_EEG_DIR == '': raise Exception('No EEG folder (not MEG)!') SUBJECT_EEG_DIR = '' calc_evokes = meg.calc_evokes_wrapper calc_fwd_inv = meg.calc_fwd_inv_wrapper calc_stc_per_condition = meg.calc_stc_per_condition_wrapper plot_evoked = meg.plot_evoked plot_topomap = meg.plot_topomap def read_sensors_layout_args(mri_subject, args): return meg.read_sensors_layout(mri_subject,
import os.path as op import scipy.io as sio import argparse import numpy as np from src.preproc import electrodes as elecs from src.utils import utils from src.utils import args_utils as au from src.utils import preproc_utils as pu from src.utils import matlab_utils as mu ELECTRODES_DIR = utils.get_link_dir(utils.get_links_dir(), 'electrodes') def read_electrodes_coordiantes_from_specific_xlsx_sheet(subject, bipolar): args = elecs.read_cmd_args(['-s', subject, '-b', str(bipolar)]) args.ras_xls_sheet_name = 'RAS_Snapped' elecs.main(subject, args) def save_msit_single_trials_data(subject, bipolar): args = elecs.read_cmd_args(['-s', subject, '-b', str(bipolar)]) args.task = 'MSIT' args.function = 'create_electrode_data_file' args.input_matlab_fname = 'electrodes_data_trials.mat' args.electrodes_names_field = 'electrodes' args.field_cond_template = '{}' elecs.main(subject, args) def load_edf_data_seizure(args): args = elecs.read_cmd_args(
import numpy as np import mne import os.path as op from src.preproc import meg from src.preproc import anatomy from src.utils import utils import glob import shutil from collections import defaultdict import traceback LINKS_DIR = utils.get_links_dir() SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') FREE_SURFER_HOME = utils.get_link_dir(LINKS_DIR, 'freesurfer', 'FREESURFER_HOME') SUBJECTS_MEG_DIR = op.join(LINKS_DIR, 'meg') BLENDER_ROOT_DIR = op.join(LINKS_DIR, 'mmvt') def find_events_indices(events_fname): data = np.genfromtxt(events_fname, dtype=np.int, delimiter=',', skip_header=1, usecols=(0, 2, 6), names=None, autostrip=True) data[:, 0] = range(len(data)) data = data[data[:, -1] == 1] indices = {} event_names = {1:'low_risk', 2:'med_risk', 3:'high_risk'} for risk, event_name in event_names.items(): event_indices = data[data[:, 1] == risk, 0] indices[event_name] = event_indices if len(event_indices) == 0: print('No events for {}!'.format(event_name)) return None return indices
to compute an inverse solution and apply it on event related fields. """ # Author: Denis A. Engemann # License: BSD 3 clause import os.path as op import mne import hcp from mne.minimum_norm import (make_inverse_operator, apply_inverse, write_inverse_operator, read_inverse_operator) from src.utils import utils links_dir = utils.get_links_dir() SUBJECTS_DIR = utils.get_link_dir(links_dir, 'subjects', 'SUBJECTS_DIR') MMVT_DIR = utils.get_link_dir(links_dir, 'mmvt') HCP_DIR = utils.get_link_dir(links_dir, 'hcp') MEG_DIR = utils.get_link_dir(links_dir, 'meg') # from hcp import preprocessing as preproc ############################################################################## # we assume our data is inside a designated folder under $HOME # storage_dir = op.expanduser('~/mne-hcp-data') recordings_path = op.join(HCP_DIR, 'hcp-meg') subject = '100307' # our test subject task = 'task_working_memory' meg_sub_fol = op.join(MEG_DIR, subject) fwd_fname = op.join(meg_sub_fol, '{}-fwd.fif'.format(subject))
from src.utils import utils from src.utils import labels_utils as lu from src.examples.epilepsy import pipeline from src.examples.epilepsy import utils as epi_utils from src.examples.epilepsy import plots from src.preproc import meg, eeg, connectivity from src.preproc import anatomy as anat import glob import traceback import mne import numpy as np from tqdm import tqdm LINKS_DIR = utils.get_links_dir() MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') MEG_DIR = utils.get_link_dir(LINKS_DIR, 'meg') EEG_DIR = utils.get_link_dir(LINKS_DIR, 'eeg') SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') ELECTRODES_DIR = utils.get_link_dir(LINKS_DIR, 'electrodes') def find_remote_subject_dir(subject): remote_subjects_dir = '/space/megraid/clinical/MEG-MRI/seder/freesurfer' if not op.isdir(op.join(remote_subjects_dir, subject)): remote_subjects_dir = SUBJECTS_DIR remote_subject_dir = op.join(remote_subjects_dir, subject) if not op.isdir(remote_subject_dir): raise Exception('No reocon-all files!') # print(('No reocon-all files!')) return remote_subject_dir
import matplotlib.colors as mcolors import matplotlib.pyplot as plt import numpy as np import os.path as op from src.utils import utils from src.utils import figures_utils as figu LINKS_DIR = utils.get_links_dir() MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') def create_BuPu_YlOrRd_cm(n=128): colors1 = plt.cm.PuBu(np.linspace(1, 0, n)) colors2 = plt.cm.YlOrRd(np.linspace(0, 1, n)) colors = np.vstack((colors1, colors2)) colors_map = mcolors.LinearSegmentedColormap.from_list('BuPu_YlOrRd', colors) return colors_map def create_jet_cm(n=256): colors = plt.cm.jet(np.linspace(0, 1, n)) colors_map = mcolors.LinearSegmentedColormap.from_list('jet', colors) return colors_map def create_YlOrRd_cm(n=256): colors = plt.cm.YlOrRd(np.linspace(0, 1, n)) colors_map = mcolors.LinearSegmentedColormap.from_list('YlOrRd', colors) return colors_map
import os import os.path as op from collections import defaultdict import glob import traceback import shutil import collections import logging from src.utils import utils from src.utils import args_utils as au LINKS_DIR = utils.get_links_dir() SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') MMVT_DIR = op.join(LINKS_DIR, 'mmvt') def decode_subjects(subjects): for sub in subjects: if '*' in sub: subjects.remove(sub) subjects.extend([ utils.namebase(fol) for fol in glob.glob(op.join(SUBJECTS_DIR, sub)) ]) elif 'file:' in sub: subjects.remove(sub) subjects.extend(utils.read_list_from_file(sub[len('file:'):])) return subjects
try: from sklearn.neighbors import BallTree except: print('No sklearn!') import shutil import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from src.utils import utils from src.utils import freesurfer_utils as fu from src.preproc import meg_preproc as meg LINKS_DIR = utils.get_links_dir() SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') SUBJECTS_MEG_DIR = utils.get_link_dir(LINKS_DIR, 'meg') FREE_SURFER_HOME = utils.get_link_dir(LINKS_DIR, 'freesurfer', 'FREESURFER_HOME') BLENDER_ROOT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') FMRI_DIR = utils.get_link_dir(LINKS_DIR, 'fMRI') os.environ['FREESURFER_HOME'] = FREE_SURFER_HOME os.environ['SUBJECTS_DIR'] = SUBJECTS_DIR # SUBJECTS_DIR = '/homes/5/npeled/space3/subjects' # # SUBJECTS_DIR = '/autofs/space/lilli_001/users/DARPA-MEG/freesurfs' # # SUBJECTS_DIR = '/home/noam/subjects/mri' # # SUBJECT = 'ep001' # os.environ['SUBJECTS_DIR'] = SUBJECTS_DIR # ROOT_DIR = [f for f in ['/homes/5/npeled/space3/fMRI/MSIT', '/home/noam/fMRI/MSIT'] if op.isdir(f)][0] # BLENDER_DIR = '/homes/5/npeled/space3/visualization_blender' # FREE_SURFER_HOME = utils.get_exisiting_dir([os.environ.get('FREESURFER_HOME', ''),
from collections import Counter, defaultdict import mne import numpy as np import scipy.io as sio import nibabel as nib from src.utils import labels_utils as lu from src.utils import matlab_utils from src.utils import utils from src.utils import freesurfer_utils as fu from src.mmvt_addon import colors_utils as cu LINKS_DIR = utils.get_links_dir() SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') FREE_SURFER_HOME = utils.get_link_dir(LINKS_DIR, 'freesurfer', 'FREESURFER_HOME') MMVT_DIR = op.join(LINKS_DIR, 'mmvt') os.environ['SUBJECTS_DIR'] = SUBJECTS_DIR BRAINDER_SCRIPTS_DIR = op.join(utils.get_parent_fol(utils.get_parent_fol()), 'brainder_scripts') ASEG_TO_SRF = op.join(BRAINDER_SCRIPTS_DIR, 'aseg2srf -s "{}"') # -o {}' HEMIS = ['rh', 'lh'] def subcortical_segmentation(subject, overwrite_subcortical_objs=False): # Must source freesurfer. You need to have write permissions on SUBJECTS_DIR if not op.isfile(op.join(SUBJECTS_DIR, subject, 'mri', 'norm.mgz')): return False script_fname = op.join(BRAINDER_SCRIPTS_DIR, 'aseg2srf') if not op.isfile(script_fname): raise Exception('The subcortical segmentation script is missing! {}'.format(script_fname))
import numpy as np import os.path as op import glob import time import traceback from src.utils import utils from src.utils import labels_utils as lu links_dir = utils.get_links_dir() SUBJECTS_DIR = utils.get_link_dir(links_dir, 'subjects', 'SUBJECTS_DIR') MMVT_DIR = utils.get_link_dir( links_dir, 'mmvt', ) def mode(arr): return np.bincount(arr).argmax() #from collections import Counter #return Counter(arr).most_common(1) # @utils.profileit(root_folder=op.join(MMVT_DIR, 'profileit')) def parcelate(subject, atlas, hemi, surface_type, vertices_labels_ids_lookup=None, overwrite_vertices_labels_lookup=False): output_fol = op.join(MMVT_DIR, subject, 'labels',
import os.path as op import glob import shutil from src.preproc import eeg from src.preproc import meg from src.utils import utils from src.mmvt_addon.scripts import import_sensors LINKS_DIR = utils.get_links_dir() EEG_DIR = utils.get_link_dir(LINKS_DIR, 'eeg') def init_flags(subject, task, conditions, remote_subject_dir=''): args = eeg.read_cmd_args(subject=subject) args.task = task args.sub_dirs_for_tasks = True eeg.init(subject, args) args.remote_subject_dir = remote_subject_dir args.conditions = list(conditions.values()) args.t_min, args.t_max = -0.2, 0.2 args.l_freq, args.h_freq = 1, 40 args.inverse_method = ['MNE', 'sLORETA'] args.inv_loose = 0.6 args.calc_max_min_diff = False args.calc_evoked_for_all_epoches = args.calc_stc_for_all = False args.calc_stc_diff = False args.normalize_data = False args.use_raw_for_noise_cov = True args.overwrite_epochs, args.overwrite_evoked, args.overwrite_sensors, args.overwrite_stc = False, True, False, False
import numpy as np from itertools import product try: import mplcursors MPLCURSORS_EXIST = True except: MPLCURSORS_EXIST = False from src.preproc import eeg from src.preproc import meg from src.utils import utils from src.examples.epilepsy import utils as epi_utils LINKS_DIR = utils.get_links_dir() MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') MEG_DIR = utils.get_link_dir(LINKS_DIR, 'meg') EEG_DIR = utils.get_link_dir(LINKS_DIR, 'eeg') SUBJECTS_DIR = utils.get_link_dir(LINKS_DIR, 'subjects') def plot_topomaps(subject, modality, windows, bad_channels, parallel=True): figs_fol = utils.make_dir( op.join(MMVT_DIR, subject, 'epilepsy-figures', 'topomaps')) params = [(subject, modality, window_fname, bad_channels, figs_fol) for window_fname in windows] utils.run_parallel(_plot_topomaps_parallel, params, len(windows) if parallel else 1) def _plot_topomaps_parallel(p):
import os import os.path as op import numpy as np import mne.io import glob from src.utils import utils from src.preproc import meg_preproc as meg LINKS_DIR = utils.get_links_dir() SUBJECTS_MEG_DIR = utils.get_link_dir(LINKS_DIR, 'meg') SUBJECTS_EEG_DIR = utils.get_link_dir(LINKS_DIR, 'eeg') if SUBJECTS_EEG_DIR == '': print('No EEG folder, using MEG folder') SUBJECTS_EEG_DIR = SUBJECTS_MEG_DIR if SUBJECTS_EEG_DIR == '': raise Exception('No EEG folder (not MEG)!') SUBJECT_EEG_DIR = '' SUBJECTS_MRI_DIR = utils.get_link_dir(LINKS_DIR, 'subjects', 'SUBJECTS_DIR') FREESURFER_HOME = utils.get_link_dir(LINKS_DIR, 'freesurfer', 'FREESURFER_HOME') print('FREE_SURFER_HOME: {}'.format(FREESURFER_HOME)) MMVT_DIR = utils.get_link_dir(LINKS_DIR, 'mmvt') os.environ['SUBJECTS_DIR'] = SUBJECTS_MRI_DIR def read_eeg_sensors_layout(mri_subject): if not op.isfile(meg.INFO): raw = mne.io.read_raw_fif(meg.RAW) info = raw.info utils.save(info, meg.INFO)