def concat_and_save(raws,
fname=None,
save=False,
annotations=None,
clear=True):
'''
concatenate a list of raw obj's to a new raw obj
calling mne.concatenate_raw
clear raws in list
with new raw obj:
set fname, annotations
save raw
Parameters
----------
raws : list of raw objs
fname : full filename <None>
save : <False>
clear : close all raw obj in raws <True>
annotations: set annotations in raw obj <None>.
Returns
-------
raw obj concatenated
'''
raw_concat = None
if raws:
raw_concat = mne.concatenate_raws(raws)
if clear:
while raws:
raws.pop().close()
del raws
if annotations:
raw_concat.set_annotations(annotations)
if fname:
jb.set_raw_filename(raw_concat, fname)
if save:
jb.apply_save_mne_data(raw_concat, fname=fname)
return raw_concat
def apply(self, **kwargs):
"""
:param kwargs:
flow,fhigh,raw,picks
:return:
fname
"""
self._update_from_kwargs(**kwargs)
logger.info("---> Filter start: {}".format(self.fname))
self.raw.filter(l_freq=self.flow, h_freq=self.fhigh, picks=self.picks)
self._update_postfix()
fname, ext = self.fname.rsplit('-', 1) #raw.fif'
fname += "," + self.postfix + "-" + ext
if self.save:
fname = jb.apply_save_mne_data(self.raw,
fname=fname,
overwrite=True)
jb.set_raw_filename(self.raw, fname)
logger.info("---> Filter done: {}".format(self.fname))
return fname
def apply_import_to_fif(opt):
"""
apply jumeg import 4D/BTi data to FIF
convert 4D-file to FIF format using mne
save raw-obj to new file
jumeg wrapper for <mne.io.read_raw_bti>
https://martinos.org/mne/stable/generated/mne.io.read_raw_bti.html#mne.io.read_raw_bti
Parameter
---------
opt
Outputfile
----------
<wawa>, -raw.fif
Returns
-------
return mne.io.Raw instance
"""
# --- ck file fullpath
fpdf = jb.isFile(opt.pdf_fname,
path=opt.pdf_stage,
head="apply_import_to_fif => file check: 4D/BTI <raw>",
exit_on_error=True)
if not fpdf: return
fcfg = jb.isFile(opt.config_fname,
path=opt.pdf_stage,
head="apply_import_to_fif:=> file check: 4D/BTI <config>",
exit_on_error=True)
if not fcfg: return
# ToDo ck if headshape file must exist
# pt.headshape_fake and touch hs
#---
#fhs = jb.isFile(opt.head_shape_fname,path=opt.pdf_stage,head="apply_import_to_fif:=> file check: 4D/BTI <head shape>",exit_on_error=True)
#if not fhs : return
#--- mk fif ouput file name
# fpdf="/mnt/meg_store2/megdaw_data21/211063/INTEXT01//18-11-15@11:20/1/c,rfDC"
# 211063_INTEXT01_181115_1120_1_c,rfDC-raw.fif size [Mb]: 703.534
#---> FIF / MNE path : /mnt/meg_store1/exp/INTEXT/mne/211063/INTEXT01/181115_1120/1/
fif_out = os.path.expandvars(os.path.expanduser(opt.fif_stage)) + "/"
#if opt.fif_path_prefix:
# fif_out += opt.fif_path_prefix+"/"
fif_out += "/".join(fpdf.split("/")[-5:-1]) + "/"
fif_out += "_".join(fpdf.split("/")[-5:])
fif_out = re.sub('/+', '/',
fif_out).replace('@', "_").replace(":",
"").replace("-", "")
fif_out += opt.fif_extention
if not opt.overwrite:
if os.path.isfile(fif_out):
if opt.verbose:
logger.info(
"---> 4D/BTI file : {}\n".format(fpdf) +
" --> FIF / MNE file: {} size [Mb]: {}\n".format(
os.path.basename(fif_out),
os.path.getsize(fif_out) / 1024.0**2) +
" --> FIF / MNE path: {}\n".format(os.path.dirname(
fif_out)) +
" -> !!! FIF File exist will not overwrite [overwrite={}\n"
.format(opt.overwrite) + "===> Done")
return
# --- check and set opt parameter
kwargs = dict()
if jb.isNotEmpty(opt.rotation_x):
kwargs["rotation_x"] = float(opt.rotation_x)
if jb.isNotEmpty(opt.translation):
kwargs["translation"] = float(opt.translation)
if jb.isNotEmpty(opt.ecg_ch): kwargs["ecg_ch"] = opt.ecg_ch
if jb.isNotEmpty(opt.eog_ch): kwargs["eog_ch"] = opt.eog_ch
#--- run
if opt.run:
#print("RUN")
# defaults mne017
# pdf_fname, config_fname='config', head_shape_fname='hs_file', rotation_x=0.0, translation=(0.0, 0.02, 0.11), convert=True,
# rename_channels=True, sort_by_ch_name=True, ecg_ch='E31', eog_ch=('E63', 'E64'), preload=False, verbose=None
try:
raw = mne.io.read_raw_bti(fpdf,
config_fname=opt.config_fname,
head_shape_fname=opt.head_shape_fname,
preload=opt.preload,
convert=opt.convert,
rename_channels=opt.rename_channels,
sort_by_ch_name=opt.sort_by_ch_name,
verbose=opt.verbose,
**kwargs)
except:
logger.exception(
"---> error in mne.io.read_raw_bti:\n -> file: {}".format(
fpdf))
#--- make output filename and save
if opt.save:
fif_out = jb.apply_save_mne_data(raw,
fname=fif_out,
overwrite=opt.overwrite)
if opt.verbose:
logger.info("===> 4D/BTI file : {}\n".format(fpdf) +
" --> FIF / MNE file: {} size [Mb]: {}\n".format(
os.path.basename(fif_out),
os.path.getsize(fif_out) / 1024.0**2) +
" --> FIF / MNE path: {}\n".format(
os.path.dirname(fif_out)))
return raw
def apply_filter(opt):
"""
apply jumeg filter with argparser options
load fif file (mne) get raw-obj
calc FIR FFT filter [bp,hp,lp,notches] for raw-obj data
save raw-obj to new file
filter_method : mne => fft mne-filter
bw => fft butterwoth
ws => fft - windowed sinc
Parameter
---------
opt: argparser option obj
Result
-------
raw-obj
"""
raw = None
fout = None
jb.verbose = opt.verbose
#--- check if fullfile exists
fin = jb.isfile(opt.fif_filename,
path=opt.fif_stage,
head="apply_suggest_bads: FIF File Check",
exit_on_error=False)
if not fin: return
#--- generate filter obj reset no defaults
filter_obj = jumeg_filter(filter_method=opt.method,
filter_type=opt.type,
fcut1=None,
fcut2=None,
remove_dcoffset=False,
notch=np.array([]),
notch_width=1.0,
order=4)
# !!! Py3 type(opt.fcut ) return < cls str>
#--- check and set opt parameter
if jb.isNotEmpty(opt.fcut1): filter_obj.fcut1 = float(opt.fcut1)
#---
if jb.isNotEmpty(opt.fcut2): filter_obj.fcut2 = float(opt.fcut2)
#---
if jb.isNotEmpty(opt.order): filter_obj.order = float(opt.order)
#--- calc notch array e.g. 50,100,150 .. max
if opt.notch:
filter_obj.calc_notches(opt.notch, opt.notch_max)
if jb.isNotEmpty(opt.notch_width):
filter_obj.notch_width = float(opt.notch_width)
#---
filter_obj.filter_window = opt.window
filter_obj.remove_dcoffset = opt.remove_dcoffset
filter_obj.verbose = opt.verbose
if opt.method.lower() == "mne":
filter_obj.mne_filter_method = opt.mne_method
if jb.isNotEmpty(opt.mne_length):
filter_obj.mne_filter_length = float(opt.mne_length)
if jb.isNotEmpty(opt.mne_trans_bandwith):
filter_obj.trans_bandwith = float(opt.mne_trans_bandwith)
#--- load fif
logger.info(" --> jumeg filter load MEG data: " + fin)
raw, _ = jb.get_raw_obj(fin, raw=raw)
#--- get MEG & Ref picks
picks = jb.picks.exclude_trigger(raw)
filter_obj.sampling_frequency = raw.info['sfreq']
#--- apply filter
logger.info(" --> jumeg filter apply filter")
filter_obj.apply_filter(raw._data, picks=picks)
logger.info(" --> jumeg filter info: " + filter_obj.filter_info)
filter_obj.update_info_filter_settings(
raw) # raw.info lowpass and highpass
#--- make output filename
name_raw = fin.split('-')[0]
fout = name_raw + "," + filter_obj.filter_name_postfix + opt.file_extention
if opt.save:
fout = jb.apply_save_mne_data(raw, fname=fout)
return raw
def apply(self, **kwargs):
"""
wrapper function for MNE version 19.2 notch filter cls
data in raw-obj will be overwritten
filename is updated in raw-obj
call MNE <raw.notch_filter>
notch_filter(self,freqs,picks=None,filter_length='auto',notch_widths=None,trans_bandwidth=1.0,n_jobs=1,method='fir',
iir_params=None,mt_bandwidth=None,p_value=0.05,phase='zero',fir_window='hamming',fir_design='firwin',
pad='reflect_limited',verbose=None)[source]
:param kwargs:
Example
--------
-> notch all chanels 50.0,100.0,150.0 Hz except STIM
from jumeg.base.jumeg_base import jumeg_base as jb
from jumeg.filter.jumeg_mne_filter import JUMEG_NOTCH_FILTER
jNFI = JUMEG_NOTCH_FILTER()
fname = jNFI.apply(
freqs = [50.0,100.0,150.0]
picks = jb.picks.exclude_trigger(raw)
)
Example
--------
-> filter all chanels 0.1 -45.0 Hz except STIM
from jumeg.filter.jumeg_mne_filter import JUMEG_FILTER
jFI = JUMEG_FILTER()
fname = jFI.apply(
flow = 0.1,
fhigh = 45.0,
save = True,
raw = raw,
picks = jb.picks.exclude_trigger(raw) )
:return:
fname
"""
self._update_from_kwargs(**kwargs)
self._is_filtered = False
self._is_reloaded = False
v = jb.verbose
jb.verbose = self.verbose
logger.info("---> Filter start: {}".format(self.fname))
self._update_postfix()
fname, ext = self.fname.rsplit('-', 1) #raw.fif'
fname += "," + self.postfix + "-" + ext
#--- ck if load from disk
if not self.overwrite:
if jb.isFile(fname):
logger.debug("Notch Filtered RAW reloading from disk ...")
self.raw, fname = jb.get_raw_obj(fname, None)
self._is_filtered = True
self._is_reloaded = True
if not self._is_filtered:
logger.info("Notch Filter start MNE filter ...")
if isinstance(self.picks, (list, np.ndarray)):
picks = self.picks
else:
logger.warning(
"picks not defined : excluding channel group <stim> and <resp>"
)
picks = jb.picks.exclude_trigger(self.raw)
self.raw.notch_filter(self.freqs,
picks=picks,
filter_length=self.filter_length,
notch_widths=self.notch_widths,
trans_bandwidth=self.trans_bandwidth,
n_jobs=self.n_jobs,
method=self.method,
iir_params=self.iir_params,
mt_bandwidth=self.mt_bandwidth,
p_value=self.p_value,
phase=self.phase,
fir_window=self.fir_window,
fir_design=self.fir_design,
pad=self.pad,
verbose=self.verbose)
self._fname_orig = jb.get_raw_filename(self.raw)
self._is_filtered = True
if self.save:
logger.info("Notch Filter saving data")
fname = jb.apply_save_mne_data(self.raw,
fname=fname,
overwrite=True)
else:
jb.set_raw_filename(self.raw, fname)
logger.info("Notch Filter done: {}\n".format(self.fname) +
" -> reloaded from disk: {}".format(self._is_reloaded))
jb.verbose = v
return fname