NeuroAnalyzer.jl documentation

na_info()

Show NeuroAnalyzer and imported packages versions.

na_plugins_reload()

Reload NeuroAnalyzer plugins.

na_plugins_list()

List NeuroAnalyzer plugins.

na_plugins_remove(plugin)

Remove NeuroAnalyzer plugin.

Arguments

• plugin::String: plugin name

na_plugins_install(plugin)

Install NeuroAnalyzer plugin.

Arguments

• plugin::String: plugin Git repository URL

na_plugins_update(plugin)

Install NeuroAnalyzer plugin.

Arguments

• plugin::String: plugin to update; if empty, update all

na_set_use_cuda(use_cuda)

Change use_cuda preference.

Arguments

• use_cuda::Bool: value

na_set_progress_bar(progress_bar)

Change progress_bar preference.

Arguments

• progress_bar::Bool: value

na_set_prefs(use_cuda, plugins_path, progress_bar, verbose)

Save NeuroAnalyzer preferences.

Arguments

• use_cuda::Bool
• progress_bar::Bool
• verbose::Bool

na_set_verbose(verbose)

Change verbose preference.

Arguments

• verbose::Bool: value

na_version()

Convert NeuroAnalyzer version to string.

Returns

• VER::String

apply(obj; ch, f)

Apply custom function.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• f::String: function to be applied, e.g. f="mean(obj, dims=3)"; OBJ signal is given using variableobj` here.

Returns

• out::Array{Float64, 3}

l1(a1, a2)

Compare two arrays (e.g. two spectrograms), using L1 (Manhattan) distance.

Arguments

• a1::AbstractArray: first array
• a2::AbstractArray: second array

Returns

• l1::Float64

l2(a1, a2)

Compare two arrays (e.g. two spectrograms), using L2 (Euclidean) distance.

Arguments

• a1::AbstractArray: first array
• a2::AbstractArray: second array

Returns

• l2::Float64

perm_cmp(a1, a2; p, perm_n)

Compare two 3-dimensional arrays a1 and a2 (e.g. two spectrograms), using permutation based statistic.

Arguments

• a1::Array{<:Real, 3}: first array
• a2::Array{<:Real, 3}: second array
• p::Float64=0.05: p-value
• perm_n::Int64=1000: number of permutations

Returns

Named tuple containing:

• zmap::Array{Float64, 3}: array of Z-values
• bm::Array{Float64, 3}: binarized mask of statistically significant positions

component_type(obj, c)

Return component data type.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name

Return

• c_type::DataType

rename_component(obj, c_old, c_new)

Rename component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c_old::Symbol: old component name
• c_new::Symbol: new component name

Return

• obj_new::NEURO

rename_component!(obj, c_old, c_new)

Rename component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c_old::Symbol: old component name
• c_new::Symbol: new component name

add_component(obj; c, v)

Add component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name
• v::Any: component value

Returns

• obj::NeuroAnalyzer.NEURO

add_component!(obj; c, v)

Add component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name
• v::Any: component value

list_component(obj)

List component names.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• components::Vector{Symbol}

extract_component(obj, c)

Extract component values.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name

Returns

• c::Any

delete_component(obj; c)

Delete component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name

Returns

• obj::NeuroAnalyzer.NEURO

delete_component!(obj; c)

Delete component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name

reset_components(obj)

Remove all components.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• obj_new::NeuroAnalyzer.NEURO

reset_components!(obj)

Remove all components.

Arguments

• obj::NeuroAnalyzer.NEURO

fft0(x, n)

Zeros-padded FFT.

Arguments

• x::AbstractVector
• n::Int64: number of zeros to add

Returns

• fft0::Vector{ComplexF64}

ifft0(x, n)

IFFT of zero-padded vector.

Arguments

• x::AbstractVector
• n::Int64: number of zeros added to x

Returns

• ifft0::Vector{Float64}: real part of the signal trimmed to original length

fft2(x)

Zeros-padded FFT, so the length of padded vector is a power of 2.

Arguments

• x::AbstractVector

Returns

• fft2::Vector{ComplexF64}

nextpow2(x)

Return the next power of 2 for given number x.

Argument

• x::Int64

Returns

• nextpow2::Int64

dft(signal; fs, pad)

Return FFT and DFT sample frequencies for a DFT.

Arguments

• signal::AbstractVector
• fs::Int64: sampling rate
• pad::Int64=0: number of zeros to add

Returns

Named tuple containing:

• ft::Vector{ComplexF64}: FFT
• f::Vector{Float64}: sample frequencies

dft(obj; channel)

Return FFT and DFT sample frequencies for a DFT.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• pad::Int64=0: number of zeros to add signal for FFT

Returns

Named tuple containing:

• ft::Array{ComplexF64, 3}: FFT
• f::Vector{Float64}: sample frequencies

findpeaks(signal; d)

Find peaks.

Arguments

• signal::AbstractVector
• d::Int64=32: distance between peeks in samples

Returns

• p_idx::Vector{Int64}

hz2rads(f)

Convert frequency f in Hz to rad/s.

Arguments

• f::Real

Returns

• f_rads::Float64

rads2hz(f)

Convert frequency f in rad/s to Hz.

Arguments

• f::Real

Returns

• f_rads::Float64

t2f(t)

Convert cycle length in ms to frequency.

Arguments

• t::Real: cycle length in ms

Returns

• f::Float64: frequency in Hz

f2t(f)

Convert frequency to cycle length in ms.

Arguments

• f::Real: frequency in Hz

Returns

• f::Float64: cycle length in ms

freqs(t)

Return vector of frequencies and Nyquist frequency for time vector.

Arguments

• t::AbstractVector, AbstractRange}: time vector

Returns

• hz::Vector{Float64}
• nf::Float64

freqs(s, fs)

Return vector of frequencies and Nyquist frequency for signal.

Arguments

• s::Vector{Float64}
• fs::Int64

Returns

• hz::Vector{Float64: signal vector
• nf::Float64

freqs(obj)

Return vector of frequencies and Nyquist frequency.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Named tuple containing:

• hz::Vector{Float64}
• nf::Float64

generate_window(type, n; even)

Return the n-point long symmetric window type.

Arguments

• type::Symbol: window type:
  • :hann: Hann
  • :bh: Blackman-Harris
  • :bohman: Bohman
  • :flat: Flat-top window
  • :bn: Blackman-Nuttall
  • :nutall: Nuttall
  • :triangle: symmetric triangle (left half ↑, right half ↓)
  • :exp: symmetric exponential (left half ↑, right half ↓)
• n::Int64: window length
• even::Bool=false: if true, make the window of even length (+1 for odd n)

Returns

• w::Vector{Float64}:: generated window

generate_sine(f, t, a, p)

Generates sine wave.

Arguments

• f::Real: frequency [Hz]
• t::Union{AbstractVector, AbstractRange}: time vector
• a::Real: amplitude
• p::Real: initial phase

Returns

• s::Vector{Float64}`

generate_csine(f, t, a)

Generates complex sine wave.

Arguments

• f::Real: frequency [Hz]
• t::Union{AbstractVector, AbstractRange}: time vector
• a::Real: amplitude

Returns

• cs::Vector{ComplexF64}`

generate_sinc(t, f, peak, norm)

Generate sinc function.

Arguments

• t::AbstractRange=-2:0.01:2: time
• f::Real=10.0: frequency
• peak::Real=0: sinc peak time
• norm::Bool=true: generate normalized function

Returns

• s::Vector{Float64}

generate_morlet(fs, f, t; ncyc, complex)

Generate Morlet wavelet.

Arguments

• fs::Int64: sampling rate
• f::Real: frequency
• t::Real=1: length = -t:1/fs:t
• ncyc::Int64=5: number of cycles
• complex::Bool=false: generate complex Morlet

Returns

• morlet::Union{Vector{Float64}, Vector{ComplexF64}}

generate_gaussian(fs, f, t; ncyc, a)

Generate Gaussian wave.

Arguments

• fs::Int64: sampling rate
• f::Real: frequency
• t::Real=1: length = -t:1/fs:t
• ncyc::Int64: : number of cycles, width, SD of the Gaussian
• a::Real=1: peak amp

Returns

• g::Vector{Float64}

generate_noise(n, amp; type)

Generate noise.

Arguments

• n::Int64: length (in samples)
• amp::Real=1.0: amplitude, signal amplitude will be in [-amp, +amp]
• type::Symbol=:whiten: noise type:
  • :whiten: normal distributed
  • :whiteu: uniformly distributed
  • :pink

Returns

• s::Float64

generate_morlet_fwhm(fs, f, t; h)

Generate Morlet wavelet using Mike X Cohen formula.

Arguments

• fs::Int64: sampling rate
• f::Real: frequency
• t::Real=1: length = -t:1/fs:t
• h::Float64=0.25: full width at half-maximum in seconds (FWHM)

Returns

• mw::Vector{ComplexF64}

Source

Cohen MX. A better way to define and describe Morlet wavelets for time-frequency analysis. NeuroImage. 2019 Oct;199:81–6.

generate_square(t, a, p, w, offset)

Generates square wave.

Arguments

• t::Union{AbstractVector, AbstractRange}: time vector
• a::Real: amplitude
• p::Real: duty cycle
• w::Real: width
• offset::Real: amplitude offset

Returns

• s::Vector{Float64}`

generate_triangle(t, a)

Generates triangle wave.

Arguments

• t::Union{AbstractVector, AbstractRange}: time vector
• a::Real: amplitude

Returns

• s::Vector{Float64}`

sr(obj)

Return sampling rate.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• sr::Int64

channel_n(obj; type)

Return number of channels of type.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::Vector{Symbol}=:all: channel type (stored in the global channel_types constant variable)

Returns

• ch_n::Int64

epoch_n(obj)

Return number of epochs.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• ep_n::Int64

signal_len(obj)

Return signal length.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• s_len::Int64

epoch_len(obj)

Return epoch length.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• ep_len::Int64

history(obj)

Show processing history.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• history::Vector{String}

labels(obj)

Return channel labels.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• labels::Vector{String}

info(obj)

Show info.

Arguments

• obj::NeuroAnalyzer.NEURO

channels_cluster(obj, cluster)

Return channels belonging to a cluster of channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• cluster::Symbol: available clusters are:
  • :f1: left frontal (F1, F3, F5, F7, AF3, AF7)
  • :f2: right frontal (F2, F4, F6, F8, AF4, AF8)
  • :t1: left temporal (C3, C5, T7, FC3, FC5, FT7)
  • :t2: right temporal (C4, C6, T8, FC4, FC6, FT8)
  • :c1: anterior central (Cz, C1, C2, FC1, FC2, FCz)
  • :c2: posterior central (Pz, P1, P2, CP1, CP2, CPz)
  • :p1: left parietal (P3, P5, P7, CP3, CP5, TP7)
  • :p2: right parietal (P4, P6, P8, CP4, CP6, TP8)
  • :o: occipital (Oz, O1, O2, POz, PO3, PO4)

Returns

• ch::Vector{Int64}: list of channel numbers belonging to a given cluster of channels

band_frq(obj, band)

Return frequency limits for a band.

Arguments

• obj::NeuroAnalyzer.NEURO
• band::Symbol: band range name:
  • :list
  • :total
  • :delta
  • :theta
  • :alpha
  • :beta
  • :beta_high
  • :gamma
  • :gamma_1
  • :gamma_2
  • :gamma_lower
  • :gamma_higher.

Returns

• band_frequency::Tuple{Real, Real}

band_frq(fs, band)

Return frequency limits of a band.

Arguments

• fs::Int64: sampling rate
• band::Symbol: band range name:
  • :list
  • :total
  • :delta
  • :theta
  • :alpha
  • :beta
  • :beta_high
  • :gamma
  • :gamma_1
  • :gamma_2
  • :gamma_lower
  • :gamma_higher.

Returns

• band_frq::Tuple{Real, Real}

describe(obj)

Return basic descriptive statistics of obj.data.

Arguments

• obj::NeuroAnalyzer.NEURO

size(obj)

Return size of the obj data.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• size::Tuple{Int64, Int64, Int64}

m_pad0(m)

Pad matrix with zeros to make it square.

Arguments

• m::Matrix{<:Number}

Returns

• m::Matrix{<:Number}

m_sortperm(m; rev=false, dims=1)

Generates sorting index for matrix m by columns (dims = 1) or by rows (dims = 2).

Arguments

• m::AbstractMatrix
• rev::Bool
• dims::Int64

Returns

• idx::Matrix{Int64}

m_sort(m, m_idx; rev=false, dims=1)

Sorts matrix m using sorting index m_idx

Arguments

• m::Matrix
• m_idx::Vector{Int64}
• rev::Bool=false
• dims::Int64=1: sort by columns (dims=1) or by rows (dims=2)

Returns

• m_sorted::Matrix

m_norm(m)

Normalize matrix.

Arguments

• m::AbstractArray

Returns

• m_norm::AbstractArray

linspace(start, stop, length)

Generates a sequence of evenly spaced numbers between start and stop.

Arguments

• start::Number
• stop::Number
• n::Int64: sequence length

Returns

• range::Vector

logspace(start, stop, n)

Generates a sequence of log10-spaced numbers between start and stop.

Arguments

• start::Number
• stop::Number
• n::Int64: sequence length

Returns

• range::Vector{<:Number}

cmax(x)

Return maximum value of the complex vector.

Arguments

• x::Vector{ComplexF64}

Returns

• cmax::ComplexF64

cmin(x)

Return minimum value of the complex vector.

Arguments

• x::Vector{ComplexF64}

Returns

• cmin::ComplexF64

tuple_order(t, rev)

Order tuple elements in ascending or descending (rev=true) order.

Arguments

• t::Tuple{Real, Real}
• rev::Bool=false

Returns

• t::Tuple{Real, Real}

cums(signal)

Calculate cumulative sum.

Arguments

• signal::Array{<:Real, 3}

Returns

• signal_cs::Array{Float64, 3}

f_nearest(m, pos)

Find nearest position tuple pos in vector of positions m.

Arguments

• m::Matrix{Tuple{Float64, Float64}}
• p::Tuple{Float64, Float64}

Returns

• pos::Tuple{Int64, Int64}: row and column in m

view_note(obj)

Return recording note.

Arguments

• obj::NeuroAnalyzer.NEURO

add_note(obj; note)

Add recording note.

Arguments

• obj::NeuroAnalyzer.NEURO
• note::String

Returns

• obj::NeuroAnalyzer.NEURO

add_note!(obj; note)

Add recording note.

Arguments

• obj::NeuroAnalyzer.NEURO
• note::String

delete_note(obj)

Delete recording note.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• obj::NeuroAnalyzer.NEURO

delete_note!(obj)

Delete recording note.

Arguments

• obj::NeuroAnalyzer.NEURO

pad0(x, n)

Pad vector / rows of matrix / array with zeros. Works with 1-, 2- and 3-dimensional arrays.

Arguments

• x::Union{AbstractVector, AbstractArray
• n::Int64: number of zeros to add

Returns

• pad0::Union{AbstractVector, AbstractArray

pad2(x)

Pad vector / rows of matrix / array with zeros to the nearest power of 2 length.

Arguments

• x::Union{AbstractVector, AbstractArray

Returns

• pad2::Union{AbstractVector, AbstractArray

phases(s; pad)

Calculate phases.

Arguments

• s::AbstractVector
• pad::Int64=0: number of zeros to add

Returns

• phases::Vector{Float64}

pick(obj; p)

Return set of channel indices corresponding with p of electrodes

Arguments

• p::Vector{Symbol}: pick of electrodes; picks may be combined, e.g. [:left, :frontal]
  • :list
  • :central (or :c)
  • :left (or :l)
  • :right (or :r)
  • :frontal (or :f)
  • :temporal (or :t)
  • :parietal (or :p)
  • :occipital (or :o)

Returns

• channels::Vector{Int64}: channel numbers

t2s(t, fs)

Convert time to sample number.

Arguments

• t::T: time in s
• fs::Int64: sampling rate

Returns

• t2s::Int64: sample number

s2t(s, fs)

Convert sample number to time.

Arguments

• t::Int64: sample number
• fs::Int64: sampling rate

Returns

• s2t::Float64: time in s

t2s(obj; t)

Convert time in seconds to samples.

Arguments

• obj::NeuroAnalyzer.NEURO
• t::T: time in seconds

Returns

• t2s::Int64: time in samples

s2t(obj; s)

Convert time in samples to seconds.

Arguments

• obj::NeuroAnalyzer.NEURO
• s::Int64: time in samples

Returns

• s2t::Float64: time in seconds

to_df(obj)

Export OBJ data to DataFrame.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• df::DataFrame: DataFrame containing time points and channels

vsearch(y, x; acc)

Return the positions of the y value in the vector x.

Arguments

• y::T: value of interest
• x::AbstractVector: vector to search within
• acc::Bool=false: if true, return the difference between y and x[idx]

Returns

• idx::Int64
• d::Real: the difference between y and x[idx]

vsearch(y, x; acc)

Return the positions of the y vector in the vector x.

Arguments

• y::AbstractVector: vector of interest
• x::AbstractVector: vector to search within
• acc::Bool=false: if true, return the difference between y and x[idx:idx + length(y)]

Returns

• idx::Int64
• d::Real: the difference between y and x[idx:idx + length(y)]

vsplit(x, n)

Splits the vector x into n-long pieces.

Argument

• x::AbstractVector
• n::Int64

Returns

• x::Vector{AbstractVector}

header(obj)

Show keys and values of OBJ header.

Arguments

• obj::NeuroAnalyzer.NEURO

export_csv(obj; file_name, header, components, markers, overwrite)

Export NeuroAnalyzer.NEURO object to CSV.

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String
• header::Bool=false: export header
• epoch_time::Bool=false: export epoch time points
• components::Bool=false: export components
• markers::Bool=false: export event markers
• locs::Bool=false: export channel locations
• history::Bool=false: export history
• overwrite::Bool=false

export_locs(obj; file_name, overwrite)

Export channel locations data, format is based on file_name extension (.ced, .locs or .tsv)

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String
• overwrite::Bool=false

export_locs(locs; file_name, overwrite)

Export channel locations, format is based on file_name extension (.ced, .locs, .tsv)

Arguments

• locs::DataFrame
• file_name::String
• overwrite::Bool=false

Returns

• success::Bool

export_markers(obj; file_name, overwrite)

Export NeuroAnalyzer.NEURO object markers to CSV.

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String
• overwrite::Bool=false

import_recording(file_name; detect_type)

Load recording file and return NeuroAnalyzer.NEURO object. Supported formats:

• EDF/EDF+
• BDF/BDF+
• GDF
• BrainVision
• CSV
• SET (EEGLAB dataset)
• NWB (Neurodata Without Borders)
• FIFF
• SNIRF
• NIRS

This is a meta-function that triggers appropriate import_*() function. File format is detected based on file extension (.edf|.bdf|.gdf|.vhdr|.ahdr|.csv|.csv.gz|.set|.nwb|.fif|.fiff|.snirf|.nirs). Signal data type (e.g. EEG or MEG is auto-detected) and stored in the obj.header.recording[:data_type] field.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on channel label
• n::Int64=0: subject number to extract in case of multi-subject file

Returns

• ::NeuroAnalyzer.NEURO

import_alice4(file_name; detect_type)

Load EDF exported from Alice 4 Polysomnography System and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

• EDF files exported from Alice 4 have incorrect value of data_records (-1) and multiple sampling rate; channels are upsampled to the highest rate.

import_bdf(file_name; default_type)

Load BDF/BDF+ file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on channel label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

• sampling_rate = n.samples ÷ data.record.duration
• gain = (physical maximum - physical minimum) ÷ (digital maximum - digital minimum)
• value = (value - digital minimum ) × gain + physical minimum

Source

https://www.biosemi.com/faq/file_format.htm

import_bv(file_name; detect_type)

Load BrainVision BVCDF file and return NeuroAnalyzer.NEURO object. At least two files are required: .vhdr (header) and .eeg (signal data). If available, markers are loaded from .vmrk file.

Arguments

• file_name::String: name of the file to load, should point to .vhdr file.
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

import_csv(file_name; detect_type)

Load CSV file (e.g. exported from EEGLAB) and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

CSV first row or first column must contain channel names. Shape of data array will be detected automatically. Sampling rate will be detected. If file is gzip-ed, it will be uncompressed automatically while reading.

import_digitrack(file_name; detect_type)

Load Digitrack ASCII file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

import_edf(file_name; detect_type)

Load EDF/EDF+ file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

• sampling_rate = n.samples ÷ data.record.duration
• gain = (physical maximum - physical minimum) ÷ (digital maximum - digital minimum)
• value = (value - digital minimum ) × gain + physical minimum

Source

1. Kemp B, Varri A, Rosa AC, Nielsen KD, Gade J. A simple format for exchange of digitized polygraphic recordings. Electroencephalography and Clinical Neurophysiology. 1992 May;82(5):391–3.
2. Kemp B, Olivan J. European data format ‘plus’(EDF+), an EDF alike standard format for the exchange of physiological data. Clinical Neurophysiology 2003;114:1755–61.
3. https://www.edfplus.info/specs/

import_edf_annotations(file_name; detect_type)

Load annotations from EDF+ file and return markers DataFrame. This function is used for EDF+ files containing annotations only.

Arguments

• file_name::String: name of the file to load

Returns

• markers::DataFrame

import_fiff(file_name; detect_type)

Load FIFF (Functional Image File Format) file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Source

Elekta Neuromag: Functional Image File Format Description. FIFF version 1.3. March 2011

import_gdf(file_name; detect_type)

Load GDF file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

• sampling_rate = n.samples ÷ data.record.duration
• gain = (physical maximum - physical minimum) ÷ (digital maximum - digital minimum)
• value = (value - digital minimum ) × gain + physical minimum

Source

1. Schlögl A, Filz O, Ramoser H, Pfurtscheller G. GDF - A General Dataformat for Biosignals Version 1.25. 1998
2. Schlögl, A. GDF - A General Dataformat for Biosignals Version 2.12. 2009
3. Schlögl, A. GDF - A General Dataformat for Biosignals Version 2.51. 2013

import_locs(file_name; maximize)

Load channel locations. Supported formats:

• CED
• ELC
• LOCS
• TSV
• SFP
• CSD
• GEO
• MAT

This is a meta-function that triggers appropriate import_locs_*() function. File format is detected based on file extension.

Arguments

• file_name::String: name of the file to load
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• locs::DataFrame

import_locs_ced(file_name; maximize)

Load channel locations from CED file.

Arguments

• file_name::String
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• locs::DataFrame

import_locs_locs(file_name; maximize)

Load channel locations from LOCS file.

Arguments

• file_name::String
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• locs::DataFrame

import_locs_elc(file_name; maximize)

Load channel locations from ELC file.

Arguments

• file_name::String
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• locs::DataFrame

import_locs_tsv(file_name; maximize)

Load channel locations from TSV file.

Arguments

• file_name::String
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• locs::DataFrame

import_locs_sfp(file_name; maximize)

Load channel locations from SFP file.

Arguments

• file_name::String
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• locs::DataFrame

import_locs_csd(file_name; maximize)

Load channel locations from CSD file.

Arguments

• file_name::String
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• locs::DataFrame

import_locs_geo(file_name; maximize)

Load channel locations from GEO file.

Arguments

• file_name::String
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• locs::DataFrame

import_locs_mat(file_name; maximize)

Load channel locations from MAT file.

Arguments

• file_name::String
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• locs::DataFrame

import_montage(file_name)

Load montage from a text file. The structure of the file is:

• first line: name of the montage, e.g. BIP ||
• next lines: channel pairs or individual channels, e.g. Fz-Cz or Fp1

Each channel/channel pair must be in a separate line

Arguments

• file_name::String: name of the file to load

Returns

Named tuple containing:

• ref_list::Vector{String}: list of channel pairs
• ref_name::Vector{String}: name of the montage

import_nirs(file_name)

Load NIRS file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load

Returns

• obj::NeuroAnalyzer.NEURO

Source

https://github.com/BUNPC/Homer3/wiki/HOMER3-file-formats

import_nirx(file_name)

Load NIRX file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load, should point to .hdr file.

Returns

• obj::NeuroAnalyzer.NEURO

Source

https://nirx.net/file-formats

import_nwb(file_name; detect_type)

Load Neurodata Without Borders (NWB) file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Source

1. https://www.biorxiv.org/content/10.1101/523035v1

import_set(file_name; detect_type)

Load SET file (exported from EEGLAB) and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Source

1. https://eeglab.org/tutorials/ConceptsGuide/Data_Structures.html

import_snirf(file_name; n)

Load Shared Near Infrared Spectroscopy Format (SNIRF) file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• n::Int64=0: subject number to extract in case of multi-subject file

Returns

• obj::NeuroAnalyzer.NEURO

Source

https://github.com/fNIRS/snirf/blob/v1.1/snirf_specification.md

load_locs(obj; file_name)

Load channel locations from file_name and return NeuroAnalyzer.NEURO object with locs data frame.

Accepted formats:

• CED
• LOCS
• ELC
• TSV
• SFP
• CSD
• GEO
• MAT

Channel locations:

• loc_theta: planar polar angle
• loc_radius: planar polar radius
• loc_x: spherical Cartesian x
• loc_y: spherical Cartesian y
• loc_z: spherical Cartesian z
• loc_radius_sph: spherical radius
• loc_theta_sph: spherical horizontal angle
• loc_phi_sph: spherical azimuth angle

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String: name of the file to load
• maximize::Bool=true: maximize locations to a unit circle after importing

Returns

• obj::NeuroAnalyzer.NEURO

load_locs!(obj; file_name, maximize)

Load channel locations from file_name and return NeuroAnalyzer.NEURO object with locs data frame.

Accepted formats:

• CED
• LOCS
• ELC
• TSV
• SFP
• CSD
• GEO
• MAT

Channel locations:

• loc_theta: planar polar angle
• loc_radius: planar polar radius
• loc_x: spherical Cartesian x
• loc_y: spherical Cartesian y
• loc_z: spherical Cartesian z
• loc_radius_sph: spherical radius
• loc_theta_sph: spherical horizontal angle
• loc_phi_sph: spherical azimuth angle

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String
• maximize::Bool=true: maximize locations after importing

save(obj; file_name, overwrite)

Save obj to file_name file (HDF5-based).

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String: name of the file to save to
• overwrite::Bool=false

load(file_name)

Load NeuroAnalyzer.NEURO from file_name file (HDF5-based).

Arguments

• file_name::String: name of the file to load

Returns

• obj::NeuroAnalyzer.NEURO

signal_channels(obj)

Return all signal (e.g. EEG or MEG) channels; signal is determined by :data_type variable in obj.header.recording). For MEG data type, 'meg', grad and mag channels are returned.

Arguments

• obj::NeuroAnalyzer.NEURO:

Returns

• chs::Vector{Int64}

get_channel_bytype(obj; type)

Return channel number(s) for channel of type type.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::Union{Symbol, Vector{Symbol}}=:all: channel type

Returns

• ch_idx::Vector{Int64}

get_channel_bywl(obj; wl)

Return NIRS channel number(s) for wavelength wl.

Arguments

• obj::NeuroAnalyzer.NEURO
• wl::Real: wavelength (in nm)

Returns

• ch_idx::Vector{Int64}

channel_type(obj; ch, type)

Change channel type.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, String}
• type::String

Returns

• obj::NeuroAnalyzer.NEURO

channel_type!(obj; ch, new_name)

Change channel type.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, String}
• type::String

get_channel(obj; ch)

Return channel number (if provided by name) or name (if provided by number).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, String}: channel number or name

Returns

• ch_idx::Union{Int64, String}: channel number or name

rename_channel(obj; ch, name)

Rename channel.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, String}: channel number or name
• name::String: new name

Returns

• obj::NeuroAnalyzer.NEURO

rename_channel!(obj; ch, name)

Rename channel.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, String}: channel number or name
• name::String: new name

edit_channel(obj; ch, field, value)

Edit channel properties (:channel_type or :labels) in OBJ.header.recording.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Int64
• field::Symbol
• value::Any

Returns

• obj_new::NeuroAnalyzer.NEURO

edit_channel!(obj; ch, field, value)

Edit channel properties (:channel_type or :labels) in OBJ.header.recording.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Int64
• field::Symbol
• value::Any

replace_channel(obj; ch, s)

Replace channel.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, String}: channel number or name
• s::Array{Float64, 3}

Returns

• obj::NeuroAnalyzer.NEURO

replace_channel!(obj; ch, s)

Replace channel.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, String}: channel number or name
• s::Array{Float64, 3}: signal to replace with

add_labels(obj; labels)

Add channel labels.

Arguments

• obj::NeuroAnalyzer.NEURO
• clabels::Vector{String}

Returns

• obj::NeuroAnalyzer.NEURO

add_labels!(obj::NeuroAnalyzer.NEURO; clabels::Vector{String})

Add OBJ channel labels.

Arguments

• obj::NeuroAnalyzer.NEURO
• clabels::Vector{String}

add_channel(obj; data, label, type)

Add channel(s) data to empty NeuroAnalyzer.NEURO object.

Arguments

• obj::NeuroAnalyzer.NEURO
• data::Array{<:Number, 3}: channel(s) data
• label::Union{String, Vector{String}}=string.(_c(size(data, 1))): channel(s) label(s)
• type::Union{Symbol, Vector{Symbol}}: channel(s) type(s)

Returns

• obj_new::NeuroAnalyzer.NEURO

add_channel!(obj; data, label, type)

Add channel(s) data to empty NeuroAnalyzer.NEURO object.

Arguments

• obj::NeuroAnalyzer.NEURO
• data::Array{<:Number, 3}: channel(s) data
• label::Union{String, Vector{String}}=string.(_c(size(data, 1))): channel(s) label(s)
• type::Union{Symbol, Vector{Symbol}}: channel(s) type(s)

create(; data_type)

Create an empty NeuroAnalyzer.NEURO object.

Arguments

• data_type::String: data type of the new object ("eeg", "meg", "nirs", "ecog")

Returns

• obj::NeuroAnalyzer.NEURO

create_time(obj)

Create time points vector for NeuroAnalyzer.NEURO object.

Arguments

• obj::NeuroAnalyzer.NEURO
• `fs::Int64

Returns

• obj_new::NeuroAnalyzer.NEURO

create_time!(obj)

Create time points vector for NeuroAnalyzer.NEURO object.

Arguments

• obj::NeuroAnalyzer.NEURO
• `fs::Int64

delete_channel(obj; ch)

Delete channel(s).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: channel number(s) to be removed

Returns

• obj::NeuroAnalyzer.NEURO

delete_channel!(obj; ch)

Delete channel(s).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: channel number(s) to be removed

keep_channel(obj; ch)

Keep channel(s).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: channel number(s) to keep

Returns

• obj::NeuroAnalyzer.NEURO

keep_channel!(obj; ch)

Keep channel(s).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: channel number(s) to keep

keep_channel_type(obj; type)

Keep channel(s) of type type.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::Symbol=:eeg: type of channels to keep

Returns

• obj::NeuroAnalyzer.NEURO

keep_channel_type!(obj; type)

Keep OBJ channels of type type.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::Symbol=:eeg: type of channels to keep

delete_epoch(obj; ep)

Remove epoch(s).

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch number(s) to be removed

Returns

• obj::NeuroAnalyzer.NEURO

delete_epoch!(obj; ep)

Remove epoch(s).

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch number(s) to be removed

keep_epoch(obj; ep)

Keep epoch(s).

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch number(s) to keep

Returns

• obj::NeuroAnalyzer.NEURO

keep_epoch!(obj; ep)

Keep OBJ epoch(s).

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch number(s) to keep

detect_bad(obj; method, ch_t)

Detect bad channels and epochs.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• method::Vector{Symbol}=[:flat, :rmse, :rmsd, :euclid, :p2p, :var]: detection method:
  • :flat: flat channel(s)
  • :p2p: peak-to-peak amplitude; good for detecting transient artifacts
  • :var: mean signal variance outside of 95%CI and variance inter-quartile outliers
  • :rmse: RMSE vs average channel outside of 95%CI
  • :rmsd: RMSD
  • :euclid: Euclidean distance
• w::Int64=10: window width in samples (signal is averaged within w-width window)
• ftol::Float64=0.1: tolerance (signal is flat within -tol to +tol), eps() gives very low tolerance
• fr::Float64=0.3: acceptable ratio (0.0 to 1.0) of flat segments within a channel before marking it as flat
• p::Float64=0.95: probability threshold (0.0 to 1.0) for marking channel as bad; also threshold for :p2p detection: above mean + p * std and below mean - p * std, here p (as percentile) will be converted to z-score (0.9 (90th percentile): 1.282, 0.95 (95th percentile): 1.645, 0.975 (97.5th percentile): 1.960, 0.99 (99th percentile): 2.326)
• tc::Float64=0.3: threshold (0.0 to 1.0) of bad channels ratio to mark the epoch as bad

Returns

Named tuple containing:

• bm::Matrix{Bool}: matrix of bad channels × epochs
• be::Vector{Int64}: list of bad epochs

epoch(obj; marker, offset, ep_n, ep_len)

Split OBJ into epochs. Return signal that is split either by markers (if specified), by epoch length or by number of epochs.

Arguments

• obj::NeuroAnalyzer.NEURO
• marker::String="": marker description to split at
• offset::Real=0: time offset (in seconds) for marker-based epoching (each epoch time will start at marker time - offset)
• ep_n::Union{Int64, Nothing}=nothing: number of epochs
• ep_len::Union{Real, Nothing}=nothing: epoch length in seconds

Returns

• obj::NeuroAnalyzer.NEURO

epoch!(obj; marker, offset, ep_n, ep_len)

Split OBJ into epochs. Return signal that is split either by markers (if specified), by epoch length or by number of epochs.

Arguments

• obj::NeuroAnalyzer.NEURO
• marker::String="": marker description to split at
• offset::Real=0: time offset (in seconds) for marker-based epoching (each epoch time will start at marker time - offset)
• ep_n::Union{Int64, Nothing}=nothing: number of epochs
• ep_len::Union{Real, Nothing}=nothing: epoch length in seconds

epoch_ts(obj; ts)

Edit epochs time start.

Arguments

• obj::NeuroAnalyzer.NEURO
• ts::Real: time start in seconds

Returns

• obj::NeuroAnalyzer.NEURO

epoch_ts!(obj; ts)

Edit OBJ epochs time start.

Arguments

• obj::NeuroAnalyzer.NEURO
• ts::Real: time start in seconds

Returns

• obj::NeuroAnalyzer.NEURO

extract_channel(obj; ch)

Extract channel data.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, String}: channel number or name

Returns

• extract_channel::Vector{Float64}

extract_epoch(obj; ep)

Extract epoch.

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Int64: epoch index

Returns

• obj_new::NeuroAnalyzer.NEURO

extract_epoch!(obj; ep)

Extract epoch.

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Int64: epoch index

extract_data(obj; ch)

Extract data.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}=1:epoch_n(obj): index of epochs, default is all epochs
• time::Bool=false: return time vector
• etime::Bool=false: return epoch time vector

Returns

• signal::Array{Float64, 3}
• time::Vector{Float64}
• etime::Vector{Float64}

extract_time(obj)

Extract time.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• tpts::Array{Float64, 3}

extract_eptime(obj)

Extract epochs time.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• et::Array{Float64, 3}

join(obj1, obj2)

Join two NeuroAnalyzer objects. Each obj2 epoch are horizontally concatenated (along time) with respective obj1 epoch. Both objects must have the same data type, number of channels, epochs and sampling rate, but may differ in epoch lengths.

Arguments

• obj1::NeuroAnalyzer.NEURO
• obj2::NeuroAnalyzer.NEURO

Returns

• obj::NeuroAnalyzer.NEURO

join!(obj1, obj2)

Join two NeuroAnalyzer objects. Each obj2 epoch are horizontally concatenated (along time) with respective obj1 epoch. Both objects must have the same data type, number of channels, epochs and sampling rate, but may differ in epoch lengths.

Arguments

• obj1::NeuroAnalyzer.NEURO
• obj2::NeuroAnalyzer.NEURO

view_marker(obj)

Show markers.

Arguments

• obj::NeuroAnalyzer.NEURO

delete_marker(obj; n)

Delete marker.

Arguments

• obj::NeuroAnalyzer.NEURO
• n::Int64: marker number

Returns

• obj::NeuroAnalyzer.NEURO

delete_marker!(obj; n)

Delete marker.

Arguments

• obj::NeuroAnalyzer.NEURO
• n::Int64: marker number

add_marker(obj; id, start, len, desc, ch)

Add marker.

Arguments

• obj::NeuroAnalyzer.NEURO
• id::String: marker ID
• start::Real: marker time in seconds
• len::Real=1.0: marker length in seconds
• desc::String: marker description
• ch::Int64=0: channel number, if 0 then marker is related to all channels

Returns

• obj::NeuroAnalyzer.NEURO

add_marker!(obj; id, start, len, desc, ch)

Add marker.

Arguments

• obj::NeuroAnalyzer.NEURO
• id::String: marker ID
• start::Real: marker time in seconds
• len::Real=1.0: marker length in seconds
• desc::String: marker description
• ch::Int64=0: channel number, if 0 then marker is related to all channels

edit_marker(obj; n, id, start, len, desc)

Edit marker.

Arguments

• obj::NeuroAnalyzer.NEURO
• n::Int64: marker number
• id::String: marker ID
• start::Real: marker time in seconds
• len::Real=1.0: marker length in seconds
• desc::String: marker description
• ch::Int64: channel number, if 0 then marker is related to all channels

Returns

• obj::NeuroAnalyzer.NEURO

edit_marker!(obj; n, id, start, len, desc)

Edit marker.

Arguments

• obj::NeuroAnalyzer.NEURO
• n::Int64: marker number
• id::String: marker ID
• start::Real: marker time in seconds
• len::Real=1: marker length in seconds
• desc::String: marker description
• ch::Int64: channel number, if 0 then marker is related to all channels

channel2marker(obj; ch, v, id, desc)

Convert event channel to markers.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Int64: event channel number
• v::Real=1.0: event channel value interpreted as an event
• id::String: prefix for marker ID; default is based on event channel name (e.g. "stim1_")
• desc::String="": marker description; default is based on event channel name (e.g. "stim1")

Returns

• obj::NeuroAnalyzer.NEURO

channel2marker!(obj; ch, v, id, desc)

Convert event channel to markers.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Int64: event channel number
• v::Real=1.0: event channel value interpreted as an event
• id::String: prefix for marker ID; default is "mrk_"
• desc::String="": prefix for marker description; default is based on event channel name (e.g. "stim1_")

reflect(obj; n)

Expand signal by adding reflected signal before the signal and after the signal, i.e. a signal 1234 becomes 432112344321. This may reduce edge artifacts, but will also affect amplitude of the filtered signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• n::Int64=sr(obj): number of samples to add, default is 1 second

Returns

• obj::NeuroAnalyzer.NEURO

reflect!(obj; n)

Expand signal by adding reflected signal before the signal and after the signal, i.e. a signal 1234 becomes 432112344321. This may reduce edge artifacts, but will also affect amplitude of the filtered signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• n::Int64=sr(obj): number of samples to add, default is 1 second

chop(obj; n)

Reduce signal by removing reflected signal before the signal and after the signal, i.e. a signal 432112344321 becomes 1234.

Arguments

• obj::NeuroAnalyzer.NEURO
• n::Int64=sr(obj): number of samples to remove, default is 1 second

Returns

• obj::NeuroAnalyzer.NEURO

chop!(obj; v)

Reduce signal by removing reflected signal before the signal and after the signal, i.e. a signal 432112344321 becomes 1234.

Arguments

• obj::NeuroAnalyzer.NEURO
• n::Int64=sr(obj): number of samples to remove, default is 1 second

trim(s; seg, inverse)

Remove segment from the signal.

Arguments

• v::AbstractVector
• seg::Tuple{Int64, Int64}: segment (from, to) in samples
• inverse::Bool=false: if true, keep the segment

Returns

• trim::Vector{Float64}

trim(m; seg, inverse)

Remove segment from the signal.

Arguments

• m::AbstractMatrix
• seg::Tuple{Int64, Int64}: segment (from, to) in samples
• inverse::Bool=false: if true, keep the segment

Returns

• trim::Array{Float64}

trim(a; seg, inverse)

Remove segment from the signal.

Arguments

• a::AbstractArray
• seg::Tuple{Int64, Int64}: segment (from, to) in samples
• inverse::Bool=false: if true, keep the segment

Returns

• trim::Array{Float64}

trim(obj; seg, inverse, remove_epochs)

Trim signal by removing parts of the signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• seg::Tuple{Real, Real}: segment to be removed (from, to) in seconds
• inverse::Bool=false: if true, keep the segment
• remove_epochs::Bool=true: if true, remove epochs containing signal to trim or remove signal and re-epoch trimmed signal

Returns

• obj::NeuroAnalyzer.NEURO

trim!(obj; seg, inverse, remove_epochs)

Trim signal by removing parts of the signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• seg::Tuple{Real, Real}: segment to be removed (from, to) in seconds
• inverse::Bool=false: if true, keep the segment
• remove_epochs::Bool=true: if true, remove epochs containing signal to trim or remove signal and re-epoch trimmed signal

vch(obj; f)

Calculate virtual channel using formula f.

Arguments

• obj::NeuroAnalyzer.NEURO
• f::String: channel calculation formula, e.g. "cz / mean(fp1 + fp2)"; case of labels in the formula is ignored, all standard Julia math operators are available, channel labels must be the same as of the OBJ object

Returns

• vc::Array{Float64, 3}: single channel × time × epochs

add_signal(s1, s2)

Add signal.

Arguments

• s1::AbstractVector: target signal
• s2::AbstractVector: signal to be added

Returns

• s_noisy::AbstractVector

add_signal(obj; ch, s)

Add signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• s::AbstractVector: signal to be added to each channel

Returns

• obj::NeuroAnalyzer.NEURO

add_signal!(obj; ch, n)

Add signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• s::AbstractVector: signal to be added to each channel

average(s)

Average all channels.

Arguments

• s::AbstractArray

Returns

• average::AbstractArray

average(s1, s2)

Averages two signals.

Arguments

• s1::AbstractArray
• s2::AbstractArray

Returns

• average::Vector{Float64}

average(obj; ch)

Return the average signal of channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels

Returns

• obj::NeuroAnalyzer.NEURO

average!(obj; ch)

Return the average signal of channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels

average(obj1, obj2)

Return the average signal of all obj1 and obj2 channels.

Arguments

• obj1::NeuroAnalyzer.NEURO
• obj2::NeuroAnalyzer.NEURO

Returns

• obj_new::NeuroAnalyzer.NEURO

bpsplit(obj; ch, order, window)

Split signal into frequency bands using IIR band-pass filter.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• order::Int64=8: number of taps for FIR band-pass filter
• window::Union{Nothing, AbstractVector, Int64}=nothing: window for :fir filter; default is Hamming window, number of taps is calculated using Fred Harris' rule-of-thumb

Returns

Named tuple containing:

• s::Array{Float64, 4}: split signal
• bn::Vector{Symbol}: band names
• bf::Vector{Tuple{Real, Real}}: band frequencies

cbp(s; pad, frq, fs)

Perform convolution band-pass filtering.

Arguments

• s::AbstractVector
• pad::Int64: pad with pad zeros
• frq::Real: filter frequency
• fs::Int64: sampling rate

Returns

• cbp::Vector{Float64}

cbp(obj; ch, pad, frq)

Perform convolution bandpass filtering.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• pad::Int64: pad the signal with pad zeros
• frq::Real: filter frequency

Returns

• obj_new::NeuroAnalyzer.NEURO

cbp!(obj; ch, pad, frq)

Perform convolution bandpass filtering.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• pad::Int64: pad the signal with pad zeros
• frq::Tuple{Real, Real}: filter frequency

ch_zero(obj)

Zero channels at the beginning and at the end.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• obj_new::NeuroAnalyzer.NEURO

ch_zero!(obj)

Zero channels at the beginning and at the end.

Arguments

• obj::NeuroAnalyzer.NEURO

csd(obj; m, n, lambda)

Transform data using Current Source Density (CSD) transformation based on spherical spline surface Laplacian.

Arguments

• obj::NeuroAnalyzer.NEURO
• m::Int64=4: positive integer constant that affects spherical spline flexibility, higher m values mean increased rigidity
• n::Int64=8: Legendre polynomial order
• lambda::Float64=10^-5: smoothing factor

Returns

• obj_new::NeuroAnalyzer.NEURO: with csd channel types and µV/m² units

Source

Perrin F, Pernier J, Bertrand O, Echallier JF. Spherical splines for scalp potential and current density mapping. Electroencephalography and Clinical Neurophysiology. 1989;72(2):184-187 Kayser J, Tenke CE. Principal components analysis of Laplacian waveforms as a generic method for identifying ERP generator patterns: I. Evaluation with auditory oddball tasks. Clin Neurophysiol 2006;117(2):348-368

csd!(obj; m, n, lambda)

Transform data using Current Source Density (CSD) transformation based on spherical spline surface Laplacian.

Arguments

• obj::NeuroAnalyzer.NEURO
• m::Int64=4: positive integer constant that affects spherical spline flexibility, higher m values mean increased rigidity
• n::Int64=8: Legendre polynomial order
• lambda::Float64=10^-5: smoothing factor

Returns

• G::Matrix{Float64}: transformation matrix (SP spline)
• H::Matrix{Float64}: transformation matrix (CSD spline)

Source

Perrin F, Pernier J, Bertrand O, Echallier JF. Spherical splines for scalp potential and current density mapping. Electroencephalography and Clinical Neurophysiology. 1989;72(2):184-7

gh(locs; m, n)

Generate G and H matrices.

Arguments

• locs::DataFrame
• m::Int64=4: positive integer constant that affects spherical spline flexibility, higher m values mean increased rigidity
• n::Int64=8: Legendre polynomial order

Returns

Named tuple containing:

• G::Matrix{Float64}: transformation matrix (SP spline)
• H::Matrix{Float64}: transformation matrix (CSD spline)

Source

Perrin F, Pernier J, Bertrand O, Echallier JF. Spherical splines for scalp potential and current density mapping. Electroencephalography and Clinical Neurophysiology. 1989;72(2):184-7

cw_trans(s; wt, type, l)

Perform continuous wavelet transformation (CWT).

Arguments

• s::AbstractVector
• wt<:CWT: continuous wavelet, e.g. wt = wavelet(Morlet(π), β=2), see ContinuousWavelets.jl documentation for the list of available wavelets

Returns

• ct::Array{Float64, 2}: CWT coefficients (by rows)

icw_trans(ct; wt, type)

Perform inverse continuous wavelet transformation (iCWT).

Arguments

• ct::AbstractArray: CWT coefficients (by rows)
• wt<:CWT: continuous wavelet, e.g. wt = wavelet(Morlet(π), β=2), see ContinuousWavelets.jl documentation for the list of available wavelets
• type::Symbol=df: inverse style type:
  • :nd: NaiveDelta
  • :pd: PenroseDelta
  • :df: DualFrames

Returns

• s::Vector{Float64}: reconstructed signal

cw_trans(s; wt)

Perform continuous wavelet transformation (CWT).

Arguments

• s::AbstractArray
• wt<:CWT: continuous wavelet, e.g. wt = wavelet(Morlet(π), β=2), see ContinuousWavelets.jl documentation for the list of available wavelets

Returns

• ct::Array{Float64, 4}: CWT coefficients (by rows)

cw_trans(obj; ch, wt)

Perform continuous wavelet transformation (CWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• wt<:CWT: continuous wavelet, e.g. wt = wavelet(Morlet(π), β=2), see ContinuousWavelets.jl documentation for the list of available wavelets

Returns

• ct::Array{Float64, 4}: CWT coefficients (by rows)

denoise_fft(s; pad, t)

Perform FFT denoising.

Arguments

• s::AbstractVector
• pad::Int64=0: number of zeros to add
• t::Real=0: PSD threshold for keeping frequency components; if 0, use mean signal power value

Returns

Named tuple containing:

• s::Vector{Float64}
• f_idx::BitVector: index of components zeroed

denoise_fft(s; pad, t)

Perform FFT denoising.

Arguments

• s::AbstractArray
• pad::Int64=0: number of zeros to add
• t::Real=0: PSD threshold for keeping frequency components; if 0, use mean signal power value

Returns

• obj_new::NeuroAnalyzer.NEURO

denoise_fft(obj; ch, pad, t)

Perform FFT denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• pad::Int64=0: number of zeros to add signal for FFT
• t::Int64=100: PSD threshold for keeping frequency components

Returns

• obj_new::NeuroAnalyzer.NEURO

denoise_fft!(obj; ch, pad, t)

Perform FFT denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• pad::Int64=0: number of zeros to add signal for FFT
• t::Int64=100: PSD threshold for keeping frequency components

denoise_wavelet(s; wt)

Perform wavelet denoising.

Arguments

• s::AbstractVector
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets

Returns

• s_new::Vector{Float64}

denoise_wavelet(s; wt)

Perform wavelet denoising.

Arguments

• s::AbstractArray
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets

Returns

• obj_new::NeuroAnalyzer.NEURO

denoise_wavelet(obj; ch, wt)

Perform wavelet denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets

Returns

• obj_new::NeuroAnalyzer.NEURO

denoise_wavelet!(obj; ch, wt)

Perform wavelet denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets

denoise_wien(s)

Perform Wiener deconvolution denoising.

Arguments

• s::AbstractArray

Returns

• s_new::Vector{Float64}

denoise_wien(obj; ch)

Perform Wiener deconvolution denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels

Returns

• obj_new::NeuroAnalyzer.NEURO

denoise_wien!(obj; ch)

Perform Wiener deconvolution denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels

derivative(s)

Return derivative of the same length.

Arguments

• s::AbstractVector

Returns

• s_new::AbstractVector

derivative(s)

Return derivative of the same length.

Arguments

• s::AbstractArray

Returns

• s_new::Array{Float64, 3}

derivative(obj; ch)

Return derivative of the same length.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels

Returns

• obj::NeuroAnalyzer.NEURO

derivative!(obj; ch)

Return derivative of the same length.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels

detrend(s; type, offset, order, span, fs)

Perform piecewise detrending.

Arguments

• s::AbstractVector
• type::Symbol=:ls:
  • :loess: fit and subtract loess approximation
  • :poly: polynomial of order is subtracted
  • :constant: offset or the mean of s (if offset = 0) is subtracted
  • :linear: linear trend is subtracted from s
  • :ls: the result of a linear least-squares fit to s is subtracted from s
• offset::Real=0: constant for :constant detrending
• order::Int64=1: polynomial fitting order
• f::Float64=1.0: smoothing factor for :loess or frequency for :hp

Returns

• s_new::Vector{Float64}

detrend(s; type, offset, order, f)

Perform piecewise detrending.

Arguments

• s::AbstractArray
• type::Symbol=:linear: detrending method
  • :loess: fit and subtract loess approximation
  • :poly: polynomial of order is subtracted
  • :constant: offset or the mean of s (if offset = 0) is subtracted
  • :linear: linear trend is subtracted from s
  • :ls: the result of a linear least-squares fit to s is subtracted from s
• offset::Real=0: constant for :constant detrending
• order::Int64=1: polynomial fitting order
• f::Float64=1.0: smoothing factor for :loess or frequency for :hp

Returns

• s_new::Array{Float64, 3}

detrend(obj; ch, type, offset, order, f)

Perform piecewise detrending.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• type::Symbol=:linear: detrending method
  • :loess: fit and subtract loess approximation
  • :poly: polynomial of order is subtracted
  • :constant: offset or the mean of s (if offset = 0) is subtracted
  • :linear: linear trend is subtracted from s
  • :ls: the result of a linear least-squares fit to s is subtracted from s
• offset::Real=0: constant for :constant detrending
• order::Int64=1: polynomial fitting order
• f::Float64=1.0: smoothing factor for :loess or frequency for :hp

Returns

• obj::NeuroAnalyzer.NEURO

detrend!(obj; ch, type, offset, order, span)

Perform piecewise detrending.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• type::Symbol=:linear: detrending method
  • :loess: fit and subtract loess approximation
  • :poly: polynomial of order is subtracted
  • :constant: offset or the mean of s (if offset = 0) is subtracted
  • :linear: linear trend is subtracted from s
  • :ls: the result of a linear least-squares fit to s is subtracted from s
• offset::Real=0: constant for :constant detrending
• order::Int64=1: polynomial fitting order
• f::Float64=1.0: smoothing factor for :loess or frequency for :hp

dw_trans(s; wt, type, l)

Perform discrete wavelet transformation (DWT).

Arguments

• s::AbstractVector
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets
• type::Symbol: transformation type:
  • :sdwt: Stationary Wavelet Transforms
  • :acdwt: Autocorrelation Wavelet Transforms
• l::Int64=0: number of levels, default maximum number of levels available or total transformation

Returns

• dt::Array{Float64, 2}: DWT coefficients cAl, cD1, ..., cDl (by rows)

dw_trans(s; wt, type, l)

Perform discrete wavelet transformation (DWT).

Arguments

• s::AbstractArray
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets
• type::Symbol: transformation type:
  • :sdwt: Stationary Wavelet Transforms
  • :acdwt: Autocorrelation Wavelet Transforms
• l::Int64=0: number of levels, default is maximum number of levels available or total transformation

Returns

• dt::Array{Float64, 4}: DWT coefficients cAl, cD1, ..., cDl (by rows)

dw_trans(obj; ch, wt, type, l)

Perform discrete wavelet transformation (DWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets
• type::Symbol: transformation type:
  • :sdwt: Stationary Wavelet Transforms
  • :acdwt: Autocorrelation Wavelet Transforms
• l::Int64=0: number of levels, default is maximum number of levels available or total transformation

Returns

• dt::Array{Float64, 4}: DWT coefficients cAl, cD1, ..., cDl (by rows)

idw_trans(dwt_coefs; wt, type)

Perform inverse discrete wavelet transformation (iDWT) of the dwt_coefs.

Arguments

• dwt_coefs::AbstractArray: DWT coefficients cAl, cD1, ..., cDl (by rows)
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets
• type::Symbol: transformation type:
  • :sdwt: Stationary Wavelet Transforms
  • :acdwt: Autocorrelation Wavelet Transforms

Returns

• s_new::Vector{Float64}: reconstructed signal

dwtsplit(obj; ch, wt, type, n)

Split into bands using discrete wavelet transformation (DWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64}: channel number
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets
• type::Symbol: transformation type:
  • :sdwt: Stationary Wavelet Transforms
  • :acdwt: Autocorrelation Wavelet Transforms
• n::Int64=0: number of bands, default is maximum number of bands available or total transformation

Returns

• b::Array{Float64, 4}: bands from lowest to highest frequency (by rows)

erp(obj; bl)

Average epochs. Non-signal channels are removed. OBJ.header.recording[:data_type] becomes erp. First epoch is the ERP.

Arguments

• obj::NeuroAnalyzer.NEURO
• bl::Real=0: baseline is the first bl seconds; if bl is greater than 0, DC value is calculated as mean of the first bl seconds and subtracted from the signal

Returns

• obj_new::NeuroAnalyzer.NEURO

erp!(obj; bl)

Average epochs. Non-signal channels are removed. OBJ.header.recording[:data_type] becomes erp. First epoch is the ERP.

Arguments

• obj::NeuroAnalyzer.NEURO
• bl::Real=0: baseline is the first bl seconds; if bl is greater than 0, DC value is calculated as mean of the first n samples and subtracted from the signal

fconv(s; kernel, norm)

Perform convolution in the frequency domain.

Arguments

• s::AbstractVector
• kernel::AbstractVector
• pad::Int64=0: number of zeros to add
• norm::Bool=true: normalize kernel

Returns

• s_new::Vector{Float64}

fconv(s; kernel, norm)

Perform convolution in the frequency domain.

Arguments

• s::AbstractArray
• kernel::Union{Vector{<:Real}, Vector{ComplexF64}}: kernel for convolution
• norm::Bool=true: normalize kernel to keep the post-convolution results in the same scale as the original data
• pad::Int64=0: number of zeros to add signal for FFT

Returns

• s_new::Array{Float64, 3}: convoluted signal

fconv(obj; ch, kernel, norm)

Perform convolution in the frequency domain.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• kernel::Union{Vector{<:Real}, Vector{ComplexF64}}: kernel for convolution
• norm::Bool=true: normalize kernel to keep the post-convolution results in the same scale as the original data
• pad::Int64=0: number of zeros to add signal for FFT

Returns

• obj_new::NeuroAnalyzer.NEURO: convoluted signal

fconv!(obj; ch)

Perform convolution in the frequency domain.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• kernel::Union{Vector{<:Real}, Vector{ComplexF64}}: kernel for convolution
• norm::Bool=true: normalize kernel to keep the post-convolution results in the same scale as the original data
• pad::Int64=0: number of zeros to add signal for FFT

filter_create(signal; <keyword arguments>)

Create IIR or FIR filter.

Arguments

• fprototype::Symbol: filter prototype:
  • :butterworth
  • :chebyshev1
  • :chebyshev2
  • :elliptic
  • :fir
  • :iirnotch: second-order IIR notch filter
  • :remez: Remez FIR filter
• ftype::Union{Nothing, Symbol}=nothing: filter type:
  • :lp: low pass
  • :hp: high pass
  • :bp: band pass
  • :bs: band stop
• cutoff::Union{Real, Tuple{Real, Real}}=0: filter cutoff in Hz (tuple for :bp and :bs)
• n::Int64: signal length in samples
• fs::Int64: sampling rate
• order::Int64=8: filter order (6 dB/octave), number of taps for :remez, attenuation (× 4 dB) for :fir filters
• rp::Real=-1: ripple amplitude in dB in the pass band; default: 0.0025 dB for :elliptic, 2 dB for others
• rs::Real=-1: ripple amplitude in dB in the stop band; default: 40 dB for :elliptic, 20 dB for others
• bw::Real=-1: bandwidth for :iirnotch and :remez filters
• window::Union{Nothing, AbstractVector, Int64}=nothing: window for :fir filter; default is Hamming window, number of taps is calculated using Fred Harris' rule-of-thumb

Returns

• flt::Union{Vector{Float64}, ZeroPoleGain{:z, ComplexF64, ComplexF64, Float64}, Biquad{:z, Float64}}

filter_apply(s; <keyword arguments>)

Apply IIR or FIR filter.

Arguments

• s::AbstractVector
• flt::Union{Vector{Float64}, ZeroPoleGain{:z, ComplexF64, ComplexF64, Float64}, Biquad{:z, Float64}}: filter
• dir:Symbol=:twopass: filter direction (for causal filter use :onepass):
  • :twopass
  • :onepass
  • :reverse: one pass, reverse direction

Returns

• s_filtered::Vector{Float64}

filter(obj; <keyword arguments>)

Apply filtering.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• fprototype::Symbol: filter prototype:
  • :butterworth
  • :chebyshev1
  • :chebyshev2
  • :elliptic
  • :fir
  • :iirnotch: second-order IIR notch filter
  • :remez: Remez FIR filter
• ftype::Union{Nothing, Symbol}=nothing: filter type:
  • :lp: low pass
  • :hp: high pass
  • :bp: band pass
  • :bs: band stop
• cutoff::Union{Real, Tuple{Real, Real}}=0: filter cutoff in Hz (tuple for :bp and :bs)
• rp::Real=-1: ripple amplitude in dB in the pass band; default: 0.0025 dB for :elliptic, 2 dB for others
• rs::Real=-1: ripple amplitude in dB in the stop band; default: 40 dB for :elliptic, 20 dB for others
• bw::Real=-1: bandwidth for :iirnotch and :remez filters
• dir:Symbol=:twopass: filter direction (for causal filter use :onepass):
  • :twopass
  • :onepass
  • :reverse: one pass, reverse direction
• order::Int64=8: filter order (6 dB/octave) for IIR filters, number of taps for :remez filter, attenuation (× 4 dB) for :fir filter
• window::Union{Nothing, AbstractVector, Int64}=nothing: window length for :remez and :fir filters
• preview::Bool=false: plot filter response

Returns

• obj::NeuroAnalyzer.NEURO

Notes

For :poly filter order and window have to be set experimentally, recommended initial values are: order=4 and window=32.

filter!(obj; <keyword arguments>)

Apply filtering.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• fprototype::Symbol: filter prototype:
  • :butterworth
  • :chebyshev1
  • :chebyshev2
  • :elliptic
  • :fir
  • :iirnotch: second-order IIR notch filter
  • :remez: Remez FIR filter
• ftype::Union{Nothing, Symbol}=nothing: filter type:
  • :lp: low pass
  • :hp: high pass
  • :bp: band pass
  • :bs: band stop
• cutoff::Union{Real, Tuple{Real, Real}}=0: filter cutoff in Hz (tuple for :bp and :bs)
• rp::Real=-1: ripple amplitude in dB in the pass band; default: 0.0025 dB for :elliptic, 2 dB for others
• rs::Real=-1: ripple amplitude in dB in the stop band; default: 40 dB for :elliptic, 20 dB for others
• bw::Real=-1: bandwidth for :iirnotch and :remez filters
• dir:Symbol=:twopass: filter direction (for causal filter use :onepass):
  • :twopass
  • :onepass
  • :reverse: one pass, reverse direction
• order::Int64=8: filter order (6 dB/octave) for IIR filters, number of taps for :remez filter, attenuation (× 4 dB) for :fir filter
• window::Union{Nothing, AbstractVector, Int64}=nothing: window length for :remez and :fir filters
• preview::Bool=false: plot filter response

Notes

For :poly filter order and window have to be set experimentally, recommended initial values are: order=4 and window=32.

filter_g(s, fs, pad, f, gw)

Filter using Gaussian in the frequency domain.

Arguments

• s::AbstractVector
• fs::Int64: sampling rate
• pad::Int64=0: number of zeros to add
• f::Real: filter frequency
• gw::Real=5: Gaussian width in Hz

Returns

Named tuple containing:

• s_filtered::Vector{Float64}

filter_g(s; pad, f, gw)

Filter using Gaussian in the frequency domain.

Arguments

• s::AbstractArray
• fs::Int64: sampling rate
• pad::Int64=0: number of zeros to add
• f::Real: filter frequency
• gw::Real=5: Gaussian width in Hz

Returns

• s_filtered::NeuroAnalyzer.NEURO

filter_g(obj; ch, pad, f, gw)

Filter using Gaussian in the frequency domain.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• pad::Int64=0: number of zeros to add
• f::Real: filter frequency
• gw::Real=5: Gaussian width in Hz

Returns

• obj_new::NeuroAnalyzer.NEURO

filter_g!(obj; ch, pad, f, gw)

Filter using Gaussian in the frequency domain.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• pad::Int64=0: number of zeros to add
• f::Real: filter frequency
• gw::Real=5: Gaussian width in Hz

filter_mavg(s; <keyword arguments>)

Filter using moving average (FIR) filter (with threshold).

Arguments

• s::AbstractVector
• k::Int64=8: window length is 2 × k + 1; for cut-off frequency f, k is sqrt(0.196202 + f^2) / f
• t::Real=0: threshold (t = mean(s) - t * std(s):mean(s) + t * std(s)); only samples below/above the threshold are being filtered
• window::Union{Nothing, AbstractVector}=nothing: weighting window

Returns

• s_filtered::Vector{Float64}

filter_mavg(s; k, t, window)

Filter using moving average filter (with threshold).

Arguments

• s::AbstractArray
• k::Int64=8: window length is 2 × k + 1; for cut-off frequency f, k is sqrt(0.196202 + f^2) / f
• t::Real=0: threshold (t = mean(s) - t * std(s):mean(s) + t * std(s)); only samples below/above the threshold are being filtered
• window::Union{Nothing, AbstractVector}=nothing: weighting window

Returns

• s_filtered::Array{Float64, 3}: convoluted signal

filter_mavg(obj; ch, k, t, window)

Filter using moving average filter (with threshold).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• k::Int64=8: window length is 2 × k + 1; for cut-off frequency F, k is sqrt(0.196202 + F^2) / F, where F is a normalized frequency (F = f/fs)
• t::Real=0: threshold (t = mean(s) - t * std(s):mean(s) + t * std(s)); only samples below/above the threshold are being filtered
• window::Union{Nothing, AbstractVector}=nothing: weighting window

Returns

• obj_new::NeuroAnalyzer.NEURO: convoluted signal

Source

1. https://dsp.stackexchange.com/questions/9966/what-is-the-cut-off-frequency-of-a-moving-average-filter

filter_mavg!(obj; ch, k, t, window)

Filter using moving average filter (with threshold).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• k::Int64=8: window length is 2 × k + 1; for cut-off frequency f, k is sqrt(0.196202 + f^2) / f
• t::Real=0: threshold (t = mean(s) - t * std(s):mean(s) + t * std(s))
• window::Union{Nothing, AbstractVector}=nothing: weighting window

filter_mmed(s; <keyword arguments>)

Filter using moving median filter (with threshold).

Arguments

• s::AbstractVector
• k::Int64=8: window length is 2 × k + 1
• t::Real=0: threshold (t = mean(s) - t * std(s):mean(s) + t * std(s)); only samples below/above the threshold are being filtered
• window::Union{Nothing, AbstractVector}=nothing: weighting window

Returns

• s_filtered::Vector{Float64}

filter_mmed(s; k, t, window)

Filter using moving median filter (with threshold).

Arguments

• s::AbstractArray
• k::Int64=8: window length is 2 × k + 1
• t::Real=0: threshold (t = mean(s) - t * std(s):mean(s) + t * std(s)); only samples below/above the threshold are being filtered
• window::Union{Nothing, AbstractVector}=nothing: weighting window

Returns

• s_filtered::Array{Float64, 3}: convoluted signal

filter_mmed(obj; ch, k, t, window)

Filter using moving median filter (with threshold).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• k::Int64=8: window length is 2 × k + 1
• t::Real=0: threshold (t = mean(s) - t * std(s):mean(s) + t * std(s)); only samples above the threshold are being filtered
• window::Union{Nothing, AbstractVector}=nothing: weighting window

Returns

• obj_new::NeuroAnalyzer.NEURO: convoluted signal

filter_mmed!(obj; ch, k, t, window)

Filter using moving median filter (with threshold).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• k::Int64=8: window length is 2 × k + 1
• t::Real=0: threshold (t = mean(s) - t * std(s):mean(s) + t * std(s)); only samples above the threshold are being filtered
• window::Union{Nothing, AbstractVector}=nothing: weighting window

filter_poly(s; order, window)

Filter using polynomial filter.

Arguments

• s::AbstractVector
• order::Int64=8: polynomial order
• window::Int64=10: window length

Returns

• s_filtered::Vector{Float64}

filter_poly(s; order, window)

Filter using polynomial filter.

Arguments

• s::AbstractArray
• order::Int64=8: polynomial order
• window::Int64=10: window length

Returns

• s_filtered::Array{Float64, 3}: convoluted signal

filter_poly(obj; ch, order, window)

Filter using polynomial filter.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• order::Int64=8: polynomial order
• window::Int64=10: window length

Returns

• obj_new::NeuroAnalyzer.NEURO: convoluted signal

filter_poly!(obj; ch, order, window)

Filter using polynomial filter.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• order::Int64=8: polynomial order
• window::Int64=10: window length

filter_sg(s; order, window)

Filter using Savitzky-Golay filter.

Arguments

• s::AbstractVector
• order::Int64=6: order of the polynomial used to fit the samples; must be less than window
• window::Int64=11: length of the filter window (i.e., the number of coefficients); must be an odd number

Returns

• s_filtered::Vector{Float64}

filter_sg(s; order, window)

Filter using Savitzky-Golay filter.

Arguments

• s::AbstractArray
• order::Int64=6: order of the polynomial used to fit the samples; must be less than window
• window::Int64=11: length of the filter window (i.e., the number of coefficients); must be an odd number

Returns

• s_filtered::Array{Float64, 3}: convoluted signal

filter_sg(obj; ch, order, window)

Filter using Savitzky-Golay filter.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• order::Int64=6: order of the polynomial used to fit the samples; must be less than window
• window::Int64=11: length of the filter window (i.e., the number of coefficients); must be an odd number

Returns

• obj_new::NeuroAnalyzer.NEURO: convoluted signal

filter_sg!(obj; ch, order, window)

Filter using Savitzky-Golay filter.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• order::Int64=6: order of the polynomial used to fit the samples; must be less than window
• window::Int64=11: length of the filter window (i.e., the number of coefficients); must be an odd number

ica_decompose(s; <keyword arguments>)

Calculate n first Independent Components using FastICA algorithm.

Arguments

• s::AbstractMatrix
• n::Int64: number of ICs
• iter::Int64=100: maximum number of iterations
• f::Symbol=:tanh: neg-entropy functor:
  • :tanh
  • :gaus

Returns

Named tuple containing:

• ic::Matrix{Float64}: components IC(1)..IC(n) (W * data), components are sorted by decreasing variance
• ic_mw::Matrix{Float64}: weighting matrix IC(1)..IC(n) (inv(W))

ica_decompose(obj; <keyword arguments>)

Perform independent component analysis (ICA) using FastICA algorithm.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• n::Int64=length(ch): number of ICs, default is the number of channels
• iter::Int64=100: maximum number of iterations
• f::Symbol=:tanh: neg-entropy functor:
  • :tanh
  • :gaus

Returns

Named tuple containing:

• ic::Matrix{Float64}: components IC(1)..IC(n) (W * data), components are sorted by decreasing variance
• ic_mw::Matrix{Float64}: weighting matrix IC(1)..IC(n) (inv(W))
• ic_var::Vector{Float64}: variance of components

ica_reconstruct(; ic, ic_mw, ic_idx)

Reconstruct signal using ICA components.

Arguments

• ic::Matrix{Float64}: components IC(1)..IC(n)
• ic_mw::Matrix{Float64}: weighting matrix IC(1)..IC(n)
• `ic_idx::Union{Int64, Vector{Int64}, <:AbstractRange} - list of ICs to remove or keep
• keep::Bool=false: if true, then the ICs are kept instead of removed

Returns

• s_new::Matrix{Float64}: reconstructed signal

ica_reconstruct(obj; ch, ic_idx, keep)

Reconstruct signals using embedded ICA components (:ic and :ic_mw).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• ic_idx::Union{Int64, Vector{Int64}, <:AbstractRange}: list of ICs to remove or keep or keep
• keep::Bool=false: if true, then the ICs are kept instead of removed

Returns

• obj::NeuroAnalyzer.NEURO

ica_reconstruct!(obj; ch, ic_idx, keep)

Reconstruct signals using embedded ICA components (:ic and :ic_mw).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all channels
• `ic_idx::Union{Int64, Vector{Int64}, <:AbstractRange} - list of ICs to remove or keep
• keep::Bool=false: if true, then the ICs are kept instead of removed

ica_reconstruct(obj, ic, ic_mw; ch, ic_idx, keep)

Reconstruct signals using external ICA components.

Arguments

• obj::NeuroAnalyzer.NEURO
• ic::Matrix{Float64}: components IC(1)..IC(n)
• ic_mw::Matrix{Float64}: weighting matrix IC(1)..IC(n)
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• `ic_idx::Union{Int64, Vector{Int64}, <:AbstractRange} - list of ICs to remove or keep
• keep::Bool=false: if true, then the ICs are kept instead of removed

Returns

• obj::NeuroAnalyzer.NEURO

ica_reconstruct!(obj, ic, ic_mw; ch, ic_idx, keep)

Reconstruct signals using external ICA components.

Arguments

• obj::NeuroAnalyzer.NEURO
• ic::Matrix{Float64}: components IC(1)..IC(n)
• ic_mw::Matrix{Float64}: weighting matrix IC(1)..IC(n)
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all channels
• `ic_idx::Union{Int64, Vector{Int64}, <:AbstractRange} - list of ICs to remove or keep
• keep::Bool=false: if true, then the ICs are kept instead of removed

ica_remove(obj, ic, ic_mw; ch, ic_idx)

Remove external ICA components from the signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• ic::Matrix{Float64}: components IC(1)..IC(n)
• ic_mw::Matrix{Float64}: weighting matrix IC(1)..IC(n)
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• `ic_idx::Union{Int64, Vector{Int64}, <:AbstractRange} - list of ICs to remove

Returns

• obj::NeuroAnalyzer.NEURO

ica_remove!(obj, ic, ic_mw; ch, ic_idx)

Remove external ICA components from the signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• ic::Matrix{Float64}: components IC(1)..IC(n)
• ic_mw::Matrix{Float64}: weighting matrix IC(1)..IC(n)
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all channels
• `ic_idx::Union{Int64, Vector{Int64}, <:AbstractRange} - list of ICs to remove or keep

ica_remove(obj, ic; ch, ic_idx)

Remove embedded ICA components (:ic and :ic_mw).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• `ic_idx::Union{Int64, Vector{Int64}, <:AbstractRange} - list of ICs to remove

Returns

• obj::NeuroAnalyzer.NEURO

ica_remove!(obj; ch, ic_idx)

Remove embedded ICA components (:ic and :ic_mw).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all channels
• `ic_idx::Union{Int64, Vector{Int64}, <:AbstractRange} - list of ICs to remove or keep

intensity2od(s)

Convert NIRS intensity (RAW data) to optical density (OD).

Arguments

• s::AbstractArray

Returns

• od::AbstractArray

intensity2od(obj; ch)

Convert NIRS intensity (RAW data) to optical density (OD).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=get_channel_bytype(obj, type=:nirs_int)): index of channels, default is NIRS intensity channels

Returns

• obj::NeuroAnalyzer.NEURO

intensity2od!(obj; ch)

Convert NIRS intensity (RAW data) to optical density (OD).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=get_channel_bytype(obj, type=:nirs_int)): index of channels, default is NIRS intensity channels

invert_polarity(obj; ch)

Invert polarity.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels

Returns

• obj_new::NeuroAnalyzer.NEURO

invert_polarity!(obj; ch)

Invert polarity.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): channel(s) to invert

lrinterpolate_channel(obj; ch, ep)

Interpolate channel using linear regression.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: channel number to interpolate
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch number(s) within to interpolate

Returns

• obj::NeuroAnalyzer.NEURO

lrinterpolate_channel!(obj; ch, ep)

Interpolate channel using linear regression.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: channel number to interpolate
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch number(s) within to interpolate

Returns

• obj::NeuroAnalyzer.NEURO

normalize(s, n; method)

Normalize.

Arguments

• s::AbstractArray
• m::Real=0.0
• n::Real=1.0
• method::Symbol:
  • :zscore: by z-score
  • :minmax: in [-1, +1]
  • :log: using log-transformation
  • :log10: using log10-transformation
  • :neglog: using -log-transformation
  • :neglog10: using -log10-transformation
  • :neg: in [0, -∞]
  • :pos: in [0, +∞]
  • :perc: in percentages
  • :gauss: to Gaussian
  • :invroot: in inverse root (1/sqrt(x))
  • :n: in [0, n1], default is [0, 1]; to normalize to [n1, n2], use normalize_n(s) .* (n2 - n1) .+ n1
  • :none

Returns

• normalized::Vector{Float64}

normalize_zscore(s)

Normalize (by z-score).

Arguments

• s::AbstractArray

Returns

• normalize_zscore::Vector{Float64}

normalize_minmax(s)

Normalize in [-1, +1].

Arguments

• s::AbstractArray

Returns

• normalize_minmax::AbstractArray

normalize_n(s, n)

Normalize in [0, n], default is [0, +1].

Arguments

• s::AbstractArray
• n::Real=1.0

Returns

• normalize_n::AbstractArray

normalize_log(s)

Normalize using log-transformation.

Arguments

• s::AbstractArray

Returns

• normalize_log::AbstractArray

normalize_gauss(s, dims)

Normalize to Gaussian.

Arguments

• s::AbstractArray
• dims::Int64=1: dimension for cumsum()

Returns

• normalize_gauss::Vector{Float64}

normalize_log10(s)

Normalize using log10-transformation.

Arguments

• s::AbstractArray

Returns

• normalize_log10::Vector{Float64}

normalize_neglog(s)

Normalize to using -log-transformation.

Arguments

• s::AbstractArray

Returns

• normalize_neglog::Vector{Float64}

normalize_neglog10(s)

Normalize using -log10-transformation.

Arguments

• s::AbstractArray

Returns

• normalize_neglog::Vector{Float64}

normalize_neg(s)

Normalize in [0, -∞].

Arguments

• s::AbstractArray

Returns

• normalize_neg::Vector{Float64}

normalize_pos(s)

Normalize in [0, +∞].

Arguments

• s::AbstractArray

Returns

• normalize_pos::Vector{Float64}

normalize_perc(s)

Normalize in percentages.

Arguments

• s::AbstractArray

Returns

• normalize_perc::Vector{Float64}

normalize_invroot(s)

Normalize in inverse root (1/sqrt(x)).

Arguments

• s::AbstractArray

Returns

• normalize_invroot::Vector{Float64}

normalize(obj; ch, method)

Normalize channel(s)

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• method::Symbol: method for normalization, see normalize() for details

Returns

• obj::NeuroAnalyzer.NEURO

normalize!(obj; ch, method)

Normalize channel(s)

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=_c(channel_n(obj)): index of channels, default is all channels
• method::Symbol: method for normalization, see normalize() for details

npl(obj)

Calculate non-phase-locked signal.

Arguments

• obj::NeuroAnalyzer.NEURO: must be ERP object

Returns

• obj_new::NeuroAnalyzer.NEURO

npl!(obj)

Calculate non-phase-locked signal.

Arguments

• obj::NeuroAnalyzer.NEURO: must be ERP object

od2conc(obj; ch, ppf)

Convert NIRS optical density (OD) to concentration (HbO, HbR, HbT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=get_channel_bytype(obj, type=:nirs_od)): index of channels, default is NIRS intensity channels
• ppf::Vector{Real}=ones(length(obj.header.recording[:wavelengths])): Partial path length factors for each wavelength. This is a vector of factors per wavelength. Typical value is ~6 for each wavelength if the absorption change is uniform over the volume of tissue measured. To approximate the partial volume effect of a small localized absorption change within an adult human head, this value could be as small as 0.1. Convention is becoming to set ppf=1 and to not divide by the source-detector separation such that the resultant "concentration" is in units of Molar mm (or Molar cm if those are the spatial units). This is becoming wide spread in the literature but there is no fixed citation. Use a value of 1 to choose this option.

Returns

• obj::NeuroAnalyzer.NEURO

od2conc(obj; ch, ppf)

Convert NIRS optical density (OD) to concentration (HbO, HbR, HbT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=get_channel_bytype(obj, type=:nirs_od)): index of channels, default is NIRS intensity channels
• ppf::Vector{Real}=ones(length(obj.header.recording[:wavelengths])): Partial path length factors for each wavelength. This is a vector of factors per wavelength. Typical value is ~6 for each wavelength if the absorption change is uniform over the volume of tissue measured. To approximate the partial volume effect of a small localized absorption change within an adult human head, this value could be as small as 0.1. Convention is becoming to set ppf=1 and to not divide by the source-detector separation such that the resultant "concentration" is in units of Molar mm (or Molar cm if those are the spatial units). This is becoming wide spread in the literature but there is no fixed citation. Use a value of 1 to choose this option.

pca_decompose(s, n)

Calculate n first Primary Components (PCs).

Arguments

• s::AbstractArray
• n::Int64: number of PCs

Returns

Named tuple containing:

• pc::Array{Float64, 3}:: PC(1)..PC(n) × epoch
• pcv::Matrix{Float64}: variance of PC(1)..PC(n) × epoch (% of total variance)
• pcm::PCA{Float64}: PC mean
• pc_model::MultivariateStats.PCA{Float64}: PC model

pca_decompose(obj; ch, n)

Calculate n first Primary Components (PCs).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels
• n::Int64: number of PCs to calculate

Returns

Named tuple containing:

• pc::Array{Float64, 3}:: PC(1)..PC(n) × epoch
• pcv::Matrix{Float64}: variance of PC(1)..PC(n) × epoch (% of total variance)
• pcm::Vector{Float64}: PC mean
• pc_model::MultivariateStats.PCA{Float64}: PC model

pca_reconstruct(s, pc, pca)

Reconstructs signal using PCA components.

Arguments

• s::AbstractArray
• pc::AbstractArray:: IC(1)..IC(n) × epoch
• pc_model::MultivariateStats.PCA{Float64}:: PC model

Returns

• s_new::Array{Float64, 3}

pca_reconstruct(obj; ch)

Reconstruct signal using embedded PCA components (:pc) and model (:pc_model).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels

Returns

• obj::NeuroAnalyzer.NEURO

pca_reconstruct!(obj; ch)

Reconstruct signal using embedded PCA components (:pc) and model (:pc_model).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels

pca_reconstruct(obj, pc, pc_model; ch)

Reconstruct signal using external PCA components (pc and pca).

Arguments

• obj::NeuroAnalyzer.NEURO
• pc::Array{Float64, 3}:: PC(1)..PC(n) × epoch
• pc_model::MultivariateStats.PCA{Float64}: PC model
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels

Returns

• obj::NeuroAnalyzer.NEURO

pca_reconstruct!(obj, pc, pc_model; ch)

Reconstruct signals using external PCA components (pc and pc_model).

Arguments

• obj::NeuroAnalyzer.NEURO
• pc::Array{Float64, 3}:: PC(1)..PC(n) × epoch
• pc_model::MultivariateStats.PCA{Float64}: PC model
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}=signal_channels(obj): index of channels, default is all signal channels

plinterpolate_channel(obj; ch, ep, m, q)

Interpolate channel(s) using planar interpolation.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: channel number(s) to interpolate
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch number(s) within to interpolate
• imethod::Symbol=:sh: interpolation method:
  • :sh: Shepard
  • :mq: Multiquadratic
  • :imq: InverseMultiquadratic
  • :tp: ThinPlate
  • :nn: NearestNeighbour
  • :ga: Gaussian
• interpolation_factor::Int64=100: interpolation quality

Returns

• obj::NeuroAnalyzer.NEURO

plinterpolate_channel!(obj; ch, ep, imethod, interpolation_factor)

Interpolate channel(s) using planar interpolation.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: channel number(s) to interpolate
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch number(s) within to interpolate
• imethod::Symbol=:sh: interpolation method Shepard (:sh), Multiquadratic (:mq), InverseMultiquadratic (:imq), ThinPlate (:tp), NearestNeighbour (:nn), Gaussian (:ga)
• interpolation_factor::Int64=100: interpolation quality

reference_ch(obj; ch, med)

Reference to selected channel(s). Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: index of channels used as reference; if multiple channels are specified, their average is used as the reference
• med::Bool=false: use median instead of mean

Returns

• obj::NeuroAnalyzer.NEURO

reference_ch!(obj; ch, med)

Reference to selected channel(s). Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{Int64, Vector{Int64}, <:AbstractRange}: index of channels used as reference; if multiple channels are specified, their average is used as the reference
• med::Bool=false: use median instead of mean

reference_car(obj; exclude_fpo, exclude_current, med)

Reference to common average reference. Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• exclude_fpo::Bool=false: exclude Fp1, Fp2, O1, O2 from CAR calculation
• exclude_current::Bool=true: exclude current channel from CAR calculation
• med::Bool=false: use median instead of mean

Returns

• obj::NeuroAnalyzer.NEURO

reference_car!(obj; exclude_fpo, exclude_current, med)

Reference to common average reference. Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• exclude_fpo::Bool=false: exclude Fp1, Fp2, O1, O2 from CAR mean calculation
• exclude_current::Bool=true: exclude current channel from CAR mean calculation
• med::Bool=false: use median instead of mean

reference_a(obj; type, med)

Reference to auricular (A1, A2) channels. Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::Symbol=:l:
  • :l: linked - average of A1 and A2
  • :i: ipsilateral - A1 for left channels, A2 for right channels
  • :c: contraletral - A1 for right channels, A2 for left channels
• med::Bool=false: use median instead of mean

Returns

• obj::NeuroAnalyzer.NEURO

reference_a!(obj; type, med)

Reference to auricular (A1, A2) channels. Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::Symbol=:l:
  • :l: linked - average of A1 and A2
  • :i: ipsilateral - A1 for left channels, A2 for right channels
  • :c: contraletral - A1 for right channels, A2 for left channels
• med::Bool=false: use median instead of mean

reference_m(obj; type, med)

Reference to mastoid (M1, M2) channels. Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::Symbol=:l:
  • :l: linked - average of M1 and M2
  • :i: ipsilateral - M1 for left channels, M2 for right channels
  • :c: contraletral - M1 for right channels, M2 for left channels
• med::Bool=false: use median instead of mean

Returns

• obj::NeuroAnalyzer.NEURO

reference_m!(obj; type, med)

Reference to mastoid (M1, M2) channels. Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::Symbol=:l:
  • :l: linked - average of M1 and M2
  • :i: ipsilateral - M1 for left channels, M2 for right channels
  • :c: contraletral - M1 for right channels, M2 for left channels
• med::Bool=false: use median instead of mean

reference_plap(obj; nn, weights)

Reference using planar Laplacian (using nn adjacent electrodes). Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• nn::Int64=4: use nn adjacent electrodes
• weights::Bool=false: use mean of nn nearest channels if false; if true, mean of nn nearest channels is weighted by distance to the referenced channel
• med::Bool=false: use median instead of mean

Returns

• obj::NeuroAnalyzer.NEURO

reference_plap!(obj; nn, weights)

Reference using planar Laplacian (using nn adjacent electrodes). Only signal channels are processed.

Arguments

• obj::NeuroAnalyzer.NEURO
• nn::Int64=4: use nn adjacent electrodes
• weights::Bool=false: use distance weights; use mean of nearest channels if false
• med::Bool=false: use median instead of mean

reference_custom(obj; ref_list, ref_name)

Reference using custom montage. Only signal channels are processed. Custom montage may be imported using import_montage().

Arguments

• obj::NeuroAnalyzer.NEURO
• ref_list::Vector{String}=["Fz-Cz", "Cz-Pz", "Fp1-F7", "Fp1-F3", "F7-T3", "T3-T5", "T5-O1", "F3-C3", "C3-P3", "P3-O1", "Fp2-F8", "Fp2-F4", "F8-T4", "T4-T6", "T6-O2", "F4-C4", "C4-P4", "P4-O2"]: list of channel pairs
• ref_name::String="BIP ||": name of the montage

Returns

• obj::NeuroAnalyzer.NEURO

Notes

If the reference contains a single channel (e.g. "Fz"), than the channel is copied to the referenced data. For each reference pair (e.g. "Fz-Cz"), the referenced channel is equal to the amplitude of channel 2 ("Cz") - amplitude of channel 1 ("Fz").

Examples of montages:

• bipolar transverse: ["Fp2-Fp1", "F8-Fp2", "F8-F4", "F4-Fz", "Fz-F3", "F3-F7", "Fp1-F7", "T4-C4", "C4-Cz", "Cz-C3", "C3-T3", "T6-P4", "P4-Pz", "Pz-P3", "P3-T5", "O2-O1"], "BIP ="
• bipolar longitudinal: ["Fz", "Cz", "Pz", "Fp1-F7", "Fp1-F3", "F7-T3", "T3-T5", "T5-O1", "F3-C3", "C3-P3", "P3-O1", "Fp2-F8", "Fp2-F4", "F8-T4", "T4-T6", "T6-O2", "F4-C4", "C4-P4", "P4-O2"], "BIP ||"
• bipolar longitudinal: ["Fp-Fz", "Fz-Cz", "Cz-Pz", "Pz-O", "Fp1-F7", "Fp1-F3", "F7-T7", "T7-P7", "P7-O1", "F3-C3", "C3-P3", "P3-O1", "Fp1-F7", "Fp2-F4", "F8-T8", "T8-P8", "P8-O2", "F4-C4", "C4-P4", "P4-O2"], "BIP ||"

reference_custom!(obj; ref_list, ref_name)

Reference using custom montage. Only signal channels are processed. Custom montage may be imported using import_montage().

Arguments

• obj::NeuroAnalyzer.NEURO
• ref_list::Vector{String}=["Fz-Cz", "Cz-Pz", "Fp1-F7", "Fp1-F3", "F7-T3", "T3-T5", "T5-O1", "F3-C3", "C3-P3", "P3-O1", "Fp2-F8", "Fp2-F4", "F8-T4", "T4-T6", "T6-O2", "F4-C4", "C4-P4", "P4-O2"]: list of channel pairs
• ref_name::String="BIP ||": name of the montage

Notes

If the reference contains a single channel (e.g. "Fz"), than the channel is copied to the referenced data. For each reference pair (e.g. "Fz-Cz"), the referenced channel is equal to the amplitude of channel 2 ("Cz") - amplitude of channel 1 ("Fz").

Examples of montages: