NeuroAnalyzer.jl documentation

size(A::AbstractArray, [dim])

Return a tuple containing the dimensions of A. Optionally you can specify a dimension to just get the length of that dimension.

Note that size may not be defined for arrays with non-standard indices, in which case axes may be useful. See the manual chapter on arrays with custom indices.

See also: length, ndims, eachindex, sizeof.

Examples

julia> A = fill(1, (2,3,4));

julia> size(A)
(2, 3, 4)

julia> size(A, 2)
3

size(cb::CircularBuffer)

Return a tuple with the size of the buffer.

size(df::AbstractDataFrame[, dim])

Return a tuple containing the number of rows and columns of df. Optionally a dimension dim can be specified, where 1 corresponds to rows and 2 corresponds to columns.

See also: nrow, ncol

Examples

julia> df = DataFrame(a=1:3, b='a':'c');

julia> size(df)
(3, 2)

julia> size(df, 1)
3

size(dfr::DataFrameRow[, dim])

Return a 1-tuple containing the number of elements of dfr. If an optional dimension dim is specified, it must be 1, and the number of elements is returned directly as a number.

See also: length

Examples

julia> dfr = DataFrame(a=1:3, b='a':'c')[1, :]
DataFrameRow
 Row │ a      b
     │ Int64  Char
─────┼─────────────
   1 │     1  a

julia> size(dfr)
(2,)

julia> size(dfr, 1)
2

size(p::Plan, [dim])

Return the size of the input of a plan p, optionally at a specified dimenion dim.

size(::AbstractPolynomial, [i])

Returns the size of the polynomials coefficients, along axis i if provided.

size(s::Sampleable)

The size (i.e. shape) of each sample. Always returns () when s is univariate, and (length(s),) when s is multivariate.

size(d::MultivariateDistribution)

Return the sample size of distribution d, i.e (length(d),).

size(d::MatrixDistribution)

Return the size of each sample from distribution d.

size(model::AbstractDimensionalityReduction, d::Int)

Returns the dimension of the input data if d == 1, the dimension of the output data if d == 2, otherwise throws error.

size(f)

Dimensions of the coefficient matrix of the whitening transform f.

size(M)

Returns a tuple with the dimensions of input (the dimension of the observation space) and output (the dimension of the principal subspace).

size(M::PPCA)

Returns a tuple with values of the input dimension $d$, i.e the dimension of the observation space, and the output dimension $p$, i.e the dimension of the principal subspace.

size(M::KernelPCA)

Returns a tuple with the input dimension $d$, i.e the dimension of the observation space, and the output dimension $p$, i.e the dimension of the principal subspace.

size(M:CCA)

Return a tuple with the dimension of X, Y, and the output dimension.

size(M::MDS)

Returns tuple where the first value is the MDS model M input dimension, i.e the dimension of the observation space, and the second value is the output dimension, i.e the dimension of the embedding.

size(M::MetricMDS)

Returns tuple where the first value is the MDS model M input dimension, i.e the dimension of the observation space, and the second value is the output dimension, i.e the dimension of the embedding.

size(M::MulticlassLDA)

Get the input (i.e the dimension of the observation space) and output (i.e the dimension of the transformed features) dimensions of the model M.

size(M)

Get the input (i.e the dimension of the observation space) and output (i.e the dimension of the subspace projection) dimensions of the model M.

size(M::ICA)

Returns a tuple with the input dimension, i.e the number of observed mixtures, and the output dimension, i.e the number of independent components.

size(M::FactorAnalysis)

Returns a tuple with values of the input dimension $d$, i.e the dimension of the observation space, and the output dimension $p$, i.e the dimension of the principal subspace.

size(g, i)

Return the number of vertices in g if i=1 or i=2, or 1 otherwise.

Examples

julia> using Graphs

julia> g = cycle_graph(4);

julia> size(g, 1)
4

julia> size(g, 2)
4

julia> size(g, 3)
1

size(m::MixedModel)

Returns the size of a mixed model as a tuple of length four: the number of observations, the number of (non-singular) fixed-effects parameters, the number of conditional modes (random effects), the number of grouping variables

size(obj)

Return size of the object data.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• s::Tuple{Int64, Int64, Int64}

size(obj, n)

Return size of the object data.

Arguments

• obj::NeuroAnalyzer.NEURO
• d::Int64: compute size along dimension d

Returns

• s::Int64

add_component(obj; <keyword arguments>)

Add component.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

add_component!(obj; <keyword arguments>)

Add component.

Arguments

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

Returns

Nothing

add_note(obj; <keyword arguments>)

Add recording note to the object header.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

add_note!(obj; <keyword arguments>)

Add recording note to the object header.

Arguments

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

Returns

Nothing

apply(obj; <keyword arguments>)

Apply custom function.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• f::String: function to be applied, e.g. f="mean(obj, dims=3)"; OBJ signal is given using variable obj here.

Returns

• out::Array{Float64, 3}

areduce(a, f; <keyword arguments>)

Reduce an array at indices of a vector being multiplications of a constant. Useful e.g. for simplifying values across frequencies, when the number of frequencies (and thus values) is high.

Arguments

• a::AbstractArray: e.g. signal data
• f::AbstractVector: e.g. frequencies
• n::Float64=0.5: reduce at multiplications of this value

Returns

• a_new::Array{eltype(a), ndims(a)}
• f_new::Vector{eltype(f)}

arr2mat(x)

Reshape array into matrix.

Arguments

• x::AbstractArray

Returns

• m::AbstractMatrix

band_frq(obj, band)

Return band frequency limits.

Arguments

• obj::NeuroAnalyzer.NEURO
• band::Symbol: band range name:
  • :list
  • :total
  • :delta: 0.1 - 4.0 Hz
  • :theta: 4.0 - 8.0 Hz
  • :alpha: 8.0 - 13.0 Hz
  • :alpha_lower: 8.0 - 10.5 Hz
  • :alpha_higher: 10.5 - 13.0 Hz
  • :beta: 14.0 - 30.0 Hz
  • :beta_lower: 14.0 - 25.0 Hz
  • :beta_higher: 25.0 - 30.0 Hz
  • :gamma: 30.0 - 150.0 Hz
  • :gamma_1: 30.0 - 40.0 Hz
  • :gamma_2: 40.0 - 50.0 Hz
  • :gamma_lower: 30.0 - 80.0 Hz
  • :gamma_higher: 80.0 - 150.0 Hz

Returns

• bf::Tuple{Float64, Float64}

band_frq(fs, band)

Return band frequency limits.

Arguments

• fs::Int64: sampling rate
• band::Symbol: band range name:
  • :list
  • :total
  • :delta: 0.1 - 4.0 Hz
  • :theta: 4.0 - 8.0 Hz
  • :alpha: 8.0 - 13.0 Hz
  • :alpha_lower: 8.0 - 10.5 Hz
  • :alpha_higher: 10.5 - 13.0 Hz
  • :beta: 14.0 - 30.0 Hz
  • :beta_lower: 14.0 - 25.0 Hz
  • :beta_higher: 25.0 - 30.0 Hz
  • :gamma: 30.0 - 150.0 Hz
  • :gamma_1: 30.0 - 40.0 Hz
  • :gamma_2: 40.0 - 50.0 Hz
  • :gamma_lower: 30.0 - 80.0 Hz
  • :gamma_higher: 80.0 - 150.0 Hz

Returns

• bf::Tuple{Float64, Float64}

cextrema(x)

Return extreme values of the complex vector.

Arguments

• x::Vector{ComplexF64}

Returns

Tuple containing:

• cmax::ComplexF64
• cmin::ComplexF64

channels_cluster(obj; <keyword arguments>)

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{String}: list of channel numbers belonging to a given cluster of channels

channel_info(obj; <keyword arguments>)

Show channel info.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Int64

Returns

Nothing

channel_order(obj)

Return channel order of the object.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• co::Vector{Int64}

channel_pick(obj; <keyword arguments>)

Return set of channel indices corresponding to a set of electrodes ("pick", e.g. left or frontal electrodes).

Arguments

• obj::NeuroAnalyzer.NEURO
• 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

• chs::Vector{Int64}: channel numbers

chtypes(obj)

Return channel types.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• cht::Vector{String}

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

component_type(obj, c)

Return component data type.

Arguments

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

Return

• c_type::DataType

cums(signal)

Calculate cumulative sum of a 3-dimensional array.

Arguments

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

Returns

• signal_cs::Array{Float64, 3}

cwtfrq(s; <keyword arguments>)

Return mean frequencies of a collection of analytic or real wavelets for a given signal.

Arguments

• s::AbstractVector
• fs::Int64: sampling rate
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=32, Q=128), see ContinuousWavelets.jl documentation for the list of available wavelets

Returns

• f::Vector{Float64}: frequencies

cwtfrq(s; <keyword arguments>)

Return mean frequencies of a collection of analytic or real wavelets for a given signal.

Arguments

• s::AbstractArray
• fs::Int64: sampling rate
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=32, Q=128), see ContinuousWavelets.jl documentation for the list of available wavelets

Returns

• f::Vector{Float64}: frequencies

cwtfrq(obj; <keyword arguments>)

Return mean frequencies of a collection of analytic or real wavelets for a given signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=32, Q=128), see ContinuousWavelets.jl documentation for the list of available wavelets

Returns

• f::Vector{Float64}: frequencies

datatype(obj)

Return data type of the object.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• dt::String

delete_component(obj; <keyword arguments>)

Delete component.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

delete_component!(obj; <keyword arguments>)

Delete component.

Arguments

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

Returns

Nothing

delete_note(obj)

Delete recording note from the object header.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• obj_new::NeuroAnalyzer.NEURO

delete_note!(obj)

Delete recording note from the object header.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Nothing

delmean(s)

Demean signal.

Arguments

• s::AbstractArray

Returns

• s_new::AbstractArray

describe(obj; <keyword arguments>)

Return basic descriptive statistics of the object data.

Arguments

• obj::NeuroAnalyzer.NEURO
• df::Bool=false: if true, return statistics as a DataFrame

Returns

• Union{Nothing, DataFrame}

detector_labels(obj)

Return NIRS detector labels.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• l::Vector{String}

epoch_duration(obj)

Return epoch length.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• ed::Float64

epoch_len(obj)

Return epoch length.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• len::Int64

epoch_len(study)

Return length of epochs per NeuroAnalyzer NEURO object in the study.

Arguments

• study::NeuroAnalyzer.STUDY

Returns

• len::Int64

extract_component(obj, c)

Extract component values.

Arguments

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

Returns

• c::Any

f2t(f)

Convert frequency in Hz to cycle length in ms.

Arguments

• f::Real: frequency in Hz

Returns

• f::Float64: cycle length in ms

fft0(x, n)

Perform zeros-padded FFT.

Arguments

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

Returns

• fft0::Vector{ComplexF64}

fft2(x)

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

Arguments

• x::AbstractVector

Returns

• fft2::Vector{ComplexF64}

fft_transform(x; <keyword arguments>)

Perform FFT transformation.

Arguments

• x::AbstractVector
• fs::Int64: sampling rate
• wlen::Int64=fs: window length
• woverlap::Int64=round(Int64, wlen * 0.97):
• w::Bool=false: if true, apply Hanning window per segment
• demean::Bool=false: if true, demean each segment
• nfft::Int64=0: length of input vector to the FFT; if nfft > n_samples, then the input signal will be zero-padded until it is of length nfft
• mode::Symbol=:r:
  • :r: use one-sided FFT (rfft)
  • :f: use two-sided FFT (fft)

Returns

• mf::Vector{ComplexF64}: Fourier coefficients
• f::Vector{Float64}: frequencies

findpeaks(signal; <keyword arguments>)

Find peaks.

Arguments

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

Returns

• p_idx::Vector{Int64}

f_nearest(m, pos)

Find nearest position tuple in a matrix of positions.

Arguments

• m::Matrix{Tuple{Float64, Float64}}: matrix of positions
• p::Tuple{Float64, Float64}: position tuple

Returns

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

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::AbstractVector
• 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_csine(f, t, a)

Generates complex sine wave.

Arguments

• f::Real: frequency [Hz]
• t::Union{AbstractVector, AbstractRange}: time vector
• a::Real: amplitude, sine amplitude will be in [-amp, +amp]

Returns

• cs::Vector{ComplexF64}`

generate_gaussian(fs, f, t; <keyword arguments>)

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_morlet(fs, f, t; <keyword arguments>)

Generate Morlet wavelet.

Arguments

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

Returns

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

generate_morlet_fwhm(fs, f, t; <keyword arguments>)

Generate Morlet wavelet using FWHM (full width at half maximum) 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_noise(n, a; <keyword arguments>)

Generate noise.

Arguments

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

Returns

• s::Vector{Float64}

generate_signal(n, amp)

Generate signal based on normally distributed random noise.

Arguments

• n::Int64: length (in samples)
• a::Real=1.0: amplitude, signal amplitude will be in [-amp, +amp]

Returns

• s::Vector{Float64}

generate_sinc(t, f, peak, norm)

Generate sinc function.

Arguments

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

Returns

• s::Vector{Float64}

generate_sine(f, t, a, p)

Generates sine wave.

Arguments

• f::Real: frequency [Hz]
• t::Union{AbstractVector, AbstractRange}: time vector
• a::Real: amplitude, sine amplitude will be in [-amp, +amp]
• p::Real: initial phase [degrees]

Returns

• s::Vector{Float64}`

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}

generate_window(type, n; <keyword arguments>)

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 (increase length by 1 for odd value of n)

Returns

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

gradient(x; <keyword arguments>)

Calculate gradient of a 1-dimensional scalar field.

Arguments

• x::AbstractVector
• rev::Bool=false: by default the direction of the gradient vector field is towards maximum value, if rev=true, the direction is towards the minimum value

Returns

Named tuple containing:

• g::Vector{Vector{Float64}}: vector field of gradients
• g_len::Vector{Float64}: scalar field of gradient lengths

gradient(x; <keyword arguments>)

Calculate gradient of a 2-dimensional scalar field.

Arguments

• x::AbstractMatrix
• rev::Bool=false: by default the direction of the gradient vector field is towards maximum value, if rev=true, the direction is towards the minimum value

Returns

Named tuple containing:

• g::Matrix{Vector{Float64}}: vector field of gradients
• g_len::Matrix{Float64}: scalar field of gradient lengths

gradient(x; <keyword arguments>)

Calculate gradient of a ≥3-dimensional scalar field.

Arguments

• x::AbstractArray
• rev::Bool=false: by default the direction of the gradient vector field is towards maximum value, if rev=true, the direction is towards the minimum value

Returns

Named tuple containing:

• g::Array{Vector{Float64}, 3}: vector field of gradients
• g_len::Array{Float64, 3}: scalar field of gradient lengths

history(obj)

Show processing history.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• h::Vector{String}

hz2rads(f)

Convert frequency in Hz to rad/s.

Arguments

• f::Real

Returns

• f_rads::Float64

ifft0(x, n)

Perform IFFT of zero-padded vector.

Arguments

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

Returns

• ifft0::Vector{ComplexF64}: reconstructed signal trimmed to original length

info(obj; <keyword arguments>)

Show info.

Arguments

• obj::NeuroAnalyzer.NEURO
• df::Bool=false: if true, return object data as a DataFrame containing time points and channels

Returns

• Union{Nothing, DataFrame}

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

labels(obj)

Return channel labels.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• l::Vector{String}

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{Float64}

list_component(obj)

List component names.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• components::Vector{Symbol}

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{Float64}

make_table(; <keyword arguments>)

Display data as a table.

Arguments

• header::Matrix{String}: table header, e.g. header = ["Group" "A" "B"]
• data::Matrix{Any}: table data, e.g. data = ["var1" 1.0 2.0; "var2" 3.0 4.0]

Returns

Nothing

maxat(x, y)

Find maximum value of one vector and return value at its index from another vector.

Argument

• x::AbstractVector
• y::AbstractVector

Returns

• value::Real
• idx::Int64

minat(x, y)

Find minimum value of one vector and return value at its index from another vector.

Argument

• x::AbstractVector
• y::AbstractVector

Returns

• value::Real
• idx::Int64

m_norm(m)

Normalize matrix.

Arguments

• m::AbstractArray

Returns

• m_norm::AbstractArray

m_pad0(m)

Pad matrix with zeros to make it square.

Arguments

• m::AbstractMatrix

Returns

• m::AbstractMatrix

m_sort(m, m_idx; <keyword arguments>)

Sorts matrix using sorting index.

Arguments

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

Returns

• m_sorted::AbstractMatrix

m_sortperm(m; <keyword arguments>)

Generates matrix sorting index.

Arguments

• m::AbstractMatrix
• rev::Bool: reverse sort
• dims::Int64=1: sort by columns (dims=1) or by rows (dims=2)

Returns

• idx::Matrix{Int64}

na_info()

Show NeuroAnalyzer and imported packages versions.

Arguments

Nothing

Returns

Nothing

na_plugins_install(plugin)

Install NeuroAnalyzer plugin from remote Git repository or from local .TAR.GZ/.ZIP archive (requires unzip or tar command to be available).

Arguments

• plugin::String: plugin Git repository URL or file name (with full path)

Returns

Nothing

na_plugins_list()

List NeuroAnalyzer plugins.

Arguments

Nothing

Returns

Nothing

na_plugins_reload()

Reload NeuroAnalyzer plugins.

Arguments

Nothing

Returns

Nothing

na_plugins_remove(plugin)

Remove NeuroAnalyzer plugin.

Arguments

• plugin::String: plugin name

Returns

Nothing

na_plugins_update(plugin)

Update NeuroAnalyzer plugin(s).

Arguments

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

Returns

Nothing

na_set_prefs(use_cuda, progress_bar, verbose)

Save NeuroAnalyzer preferences.

Arguments

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

Returns

Nothing

na_set_progress_bar(value)

Change progress_bar preference.

Arguments

• value::Bool: value

Returns

Nothing

na_set_use_cuda(value)

Change use_cuda preference.

Arguments

• value::Bool: value

Returns

Nothing

na_set_verbose(value)

Change verbose preference.

Arguments

• value::Bool: value

Returns

Nothing

na_version()

Convert NeuroAnalyzer version to string.

Arguments

Nothing

Returns

• VER::String

nchannels(obj; <keyword arguments>)

Return number type channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::String="all": channel type (stored in the global channel_types constant variable)

Returns

• ch_n::Int64

nchannels(study)

Return number of channels per NeuroAnalyzer NEURO object in the study.

Arguments

• study::NeuroAnalyzer.STUDY

Returns

• n::Int64

nepochs(obj)

Return number of epochs.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• ep_n::Int64

nepochs(study)

Return number of epochs per NeuroAnalyzer NEURO object in the study.

Arguments

• study::NeuroAnalyzer.STUDY

Returns

• n::Int64

nextpow2(x)

Return the next power of 2 for a given number.

Argument

• x::Int64

Returns

• nextpow2::Int64

optode_labels(obj)

Return optode labels.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• l::Vector{String}

pad0(x, n)

Pad row(s) with zeros. Works with 1-, 2- and 3-dimensional arrays.

Arguments

• x::Union{AbstractVector, AbstractArray}
• n::Int64: padding length (number of zeros to add)

Returns

• pad0::Union{AbstractVector, AbstractArray}

pad2(x)

Pad row(s) with zeros to the nearest power of 2 length. Works with 1-, 2- and 3-dimensional arrays.

Arguments

• x::Union{AbstractVector, AbstractArray}

Returns

• pad2::Union{AbstractVector, AbstractArray}

padm(x, n)

Pad row(s) with mean value(s). Works with 1-, 2- and 3-dimensional arrays.

Arguments

• x::Union{AbstractVector, AbstractArray}
• n::Int64: padding length (number of values to add)
• mode::Symbol=:row: how the mean is calculated:
  • :all: mean of all rows
  • :row: separate mean per each row

Returns

• padm::Union{AbstractVector, AbstractArray}

paired_labels(l; <keyword arguments>)

Return paired labels.

Arguments

• l::Vector{String}
• unq::Bool=true: if true, do not add pairs of the same labels, e.g. "label1-label1"

Returns

• l_paired::Vector{String}: paired labels

paired_labels(l1, l2)

Return paired labels.

Arguments

• l1::Vector{String}
• l2::Vector{String}

Returns

• l_paired::Vector{String}: paired labels

perm_cmp(a1, a2; <keyword arguments>)

Compare two 3-dimensional arrays (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::Matrix{Float64}: array of Z-values
• bm::BitMatrix: binarized mask of statistically significant positions

phases(s)

Calculate phases.

Arguments

• s::AbstractVector

Returns

• phases::Vector{Float64}

play(obj; <keyword arguments>)

Play channel signal as audio.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• seg::Tuple{Real, Real}: time segment to play
• ep::Int64: epoch number

Returns

Nothing

rads2hz(f)

Convert frequency in rad/s to Hz.

Arguments

• f::Real

Returns

• f_rads::Float64

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::NeuroAnalyzer.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

Returns

Nothing

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

Returns

Nothing

rfft0(x, n)

Perform zeros-padded single-sided FFT.

Arguments

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

Returns

• rfft0::Vector{ComplexF64}

rfft2(x)

Perform zeros-padded single-sided FFT, so the length of padded vector is a power of 2.

Arguments

• x::AbstractVector

Returns

• rfft2::Vector{ComplexF64}

s2t(s, fs)

Convert sample number to time in seconds.

Arguments

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

Returns

• s2t::Float64: time in s

s2t(obj; <keyword arguments>)

Convert time in samples to seconds.

Arguments

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

Returns

• s2t::Float64: time in seconds

signal_duration(obj)

Return signal duration.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• sd::Float64

signal_len(obj)

Return signal length.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• sl::Int64

source_labels(obj)

Return NIRS source labels.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• l::Vector{String}

sr(obj)

Return sampling rate.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• fs::Int64

sr(study)

Return sampling rate of NeuroAnalyzer NEURO objects in the study.

Arguments

• study::NeuroAnalyzer.STUDY

Returns

• sr::Int64

t2f(t)

Convert cycle length in ms to frequency.

Arguments

• t::Real: cycle length in ms

Returns

• f::Float64: frequency in Hz

t2s(t, fs)

Convert time in seconds to sample number.

Arguments

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

Returns

• t2s::Int64: sample number

t2s(obj; <keyword arguments>)

Convert time in seconds to sample number.

Arguments

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

Returns

• t2s::Int64: time in samples

tavg(s)

Average signal across trials.

Arguments

• s::AbstractArray

Returns

• s_new::AbstractArray

to_df(obj)

Export object data as DataFrame.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

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

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}

vec2mat(x; <keyword arguments>)

Reshape vector into matrix using fixed segment length and overlapping.

Arguments

• x::AbstractVector
• wlen::Int64: window length (in samples)
• woverlap::Int64: overlap with the previous window (in samples)

Returns

• m::AbstractMatrix

header(obj)

Show keys and values of the object header.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Nothing

view_note(obj)

Return the object recording note.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• note::String

vreduce(x, f; <keyword arguments>)

Reduce two vectors at indices of the second vector being multiplications of a constant. Useful e.g. for simplifying values across frequencies, when the number of frequencies (and thus values) is high.

Arguments

• x::AbstractVector: e.g. signal data
• f::AbstractVector: e.g. frequencies
• n::Float64=0.5: reduce at multiplications of this value

Returns

• x_new::AbstractVector
• f_new::AbstractVector

vsearch(y, x; <keyword arguments>)

Return the positions of the value in the vector.

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; <keyword arguments>)

Return the positions of the value in the vector.

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 vector into pieces.

Argument

• x::AbstractVector
• n::Int64: length of one piece

Returns

• x::Vector{AbstractVector}

export_csv(obj; <keyword arguments>)

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

Returns

Nothing

export_locs(obj; <keyword arguments>)

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

Arguments

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

Returns

Nothing

export_locs(locs; <keyword arguments>)

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

Arguments

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

Returns

Nothing

export_markers(obj; <keyword arguments>)

Export NeuroAnalyzer.NEURO object markers to CSV.

Arguments

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

Returns

Nothing

import_alice4(file_name; <keyword arguments>)

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; <keyword arguments>)

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; <keyword arguments>)

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_cnt(file_name; <keyword arguments>)

Load Neuroscan continuous signal 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
• data_format::Symbol=:i32: Neuroscan stores data either in 16-bit (:i16) or 32-bit (:i32) representation, but does not say so in the file format

Returns

• obj::NeuroAnalyzer.NEURO

Notes

Based on loadcnt.m by Sean Fitzgibbon and Arnaud Delorme (https://cnl.salk.edu/~arno/cntload/index.html)

import_csv(file_name; <keyword arguments>)

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_dat(file_name)

Load Neuroscan DAT file.

Arguments

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

Returns

• dat::DataFrame

import_digitrack(file_name; <keyword arguments>)

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_duomag(file_name)

Load DuoMAG TMS MEP recording file (.ascii or .m) and return NeuroAnalyzer.NEURO object.

Arguments

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

Returns

• obj::NeuroAnalyzer.NEURO

import_edf(file_name; <keyword arguments>)

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; 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; <keyword arguments>)

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)

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

Arguments

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

Returns

• obj::NeuroAnalyzer.NEURO

import_gdf(file_name; <keyword arguments>)

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)

Load channel locations. Supported formats:

• CED
• ELC
• LOCS
• TSV
• SFP
• CSD
• GEO
• MAT
• TXT
• DAT
• ASC
• CSV

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

Returns

• locs::DataFrame

import_locs_asc(file_name)

Load channel locations from ASC file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_ced(file_name)

Load channel locations from CED file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_csd(file_name)

Load channel locations from CSD file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_csv(file_name)

Load channel locations from CSV file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_dat(file_name)

Load channel locations from DAT file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_elc(file_name)

Load channel locations from ELC file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_geo(file_name)

Load channel locations from GEO file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_locs(file_name)

Load channel locations from LOCS file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_mat(file_name)

Load channel locations from MAT file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_sfp(file_name)

Load channel locations from SFP file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_tsv(file_name)

Load channel locations from TSV file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_txt(file_name)

Load channel locations from TXT file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_montage(file_name)

Load montage from a text file. Example montage files are located in the montages/ folder. The structure of the file is:

• first line: name of the montage, e.g. longitudinal-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::String: name of the montage

import_ncs(file_name)

Load Neuralinx Continuously Sampled Channels (CSC) and return NeuroAnalyzer.NEURO object.

Arguments

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

Returns

• obj::NeuroAnalyzer.NEURO

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_npy(file_name; <keyword arguments>)

Load NPY file (exported from MNE) and return NeuroAnalyzer.NEURO object. Data type and channel types are set as is EEG.

Arguments

• file_name::String: name of the file to load
• sampling_rate::Int64: NPY file contains only signal data, therefore its sampling rate must be provided upon importing

Returns

• obj::NeuroAnalyzer.NEURO

import_nwb(file_name; <keyword arguments>)

Load EEG data from 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_recording(file_name; <keyword arguments>)

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

• obj::NeuroAnalyzer.NEURO

import_set(file_name; <keyword arguments>)

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; <keyword arguments>)

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

import_thymatron(file_name)

Import scanned images of EEG printed by Thymatron ECT equipment and return NeuroAnalyzer.NEURO object.

Usually there are three images: baseline, during seizure activity and after seizure activity. If more then one image is provided, images are added as consecutive channels in the same object.

Image properties:

• 100 DPI
• 490 x 100 px
• height 2.5 cm
• width 12.5 cm

Arguments

• file_name::String: name of the file to load
• dpi::Int64=100: DPI of the scanned images

Returns

• obj::NeuroAnalyzer.NEURO

Source

Wysokiński A. EEG_ADC: Digitizer and Analyzer of Electroconvulsive Therapy Paper Electroencephalogram Recordings. JECT 2022; 4: 255-256

import_xdf(file_name)

Load Extensible Data Format (XDF) and return NeuroAnalyzer.NEURO object.

Arguments

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

Returns

• obj::NeuroAnalyzer.NEURO

load(file_name)

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

Arguments

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

Returns

• obj::NeuroAnalyzer.NEURO

load_fiff(file_name)

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

Arguments

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

Returns

• fiff::Dict{Symbol, Dict{Any, Any}}
• fiff_object::Vector{Any}
• fiff_blocks::Matrix{Int64}

Source

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

load_locs(obj; <keyword arguments>)

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
• TXT
• DAT
• ASC
• CSV

Channel locations:

• loc_theta: polar angle
• loc_radius: 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

Returns

• obj_new::NeuroAnalyzer.NEURO

load_locs!(obj; <keyword arguments>)

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
• TXT
• DAT
• ASC

Channel locations:

• loc_theta: polar angle
• loc_radius: 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

Return

Nothing

load_study(file_name)

Load NeuroAnalyzer.STUDY object from file_name file (HDF5-based).

Arguments

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

Returns

• obj::NeuroAnalyzer.STUDY

save(obj; <keyword arguments>)

Save NeuroAnalyzer.NEURO object to file_name file (HDF5-based).

Arguments

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

Return

Nothing

save_study(obj; <keyword arguments>)

Save NeuroAnalyzer.STUDY object to file_name file (HDF5-based).

Arguments

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

Return

Nothing

add_channel(obj; <keyword arguments>)

Add channels data to an empty NeuroAnalyzer.NEURO object.

Arguments

• obj::NeuroAnalyzer.NEURO
• data::Array{<:Number, 3}: channels data
• label::Union{String, Vector{String}}: channels labels
• type::Union{String, Vector{String}}: channels types

Returns

• obj_new::NeuroAnalyzer.NEURO

add_channel!(obj; <keyword arguments>)

Add channels data to an empty NeuroAnalyzer.NEURO object.

Arguments

• obj::NeuroAnalyzer.NEURO
• data::Array{<:Number, 3}: channels data
• label::Union{String, Vector{String}}: channels labels
• type::Union{String, Vector{String}}: channels types

Returns

Nothing

add_label(obj; <keyword arguments>)

Add channel labels.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

add_label!(obj; <keyword arguments>)

Add channel labels.

Arguments

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

Returns

Nothing

add_marker(obj; <keyword arguments>)

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_new::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

Returns

Nothing

channel2marker(obj; <keyword arguments>)

Convert event channel to markers.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• 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_new::NeuroAnalyzer.NEURO

channel2marker!(obj; <keyword arguments>)

Convert event channel to markers.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• 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_")

Returns

Nothing

channel_type(obj; <keyword arguments>)

Get channel type.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name

Returns

• cht::String

chop(obj; <keyword arguments>)

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_new::NeuroAnalyzer.NEURO

chop!(obj; <keyword arguments>)

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

Nothing

create_data(obj; <keyword arguments>)

Create data, channel labels, types and units and time points for NeuroAnalyzer.NEURO object.

Arguments

• obj::NeuroAnalyzer.NEURO
• data::Array{Float64, 3}
• fs::Int64
• type::String: channel types of imported data channels

Returns

• obj_new::NeuroAnalyzer.NEURO

create_data!(obj; <keyword arguments>)

Create data, channel labels, types and units and time points for NeuroAnalyzer.NEURO object.

Arguments

• obj::NeuroAnalyzer.NEURO
• data::Array{Float64, 3}
• fs::Int64
• type::String: channel types of imported data channels

Returns

Nothing

create_object(; <keyword arguments>)

Create an empty NeuroAnalyzer.NEURO object.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

create_time(obj; <keyword arguments>)

Create time points vector for NeuroAnalyzer.NEURO object.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

create_time!(obj; <keyword arguments>)

Create time points vector for NeuroAnalyzer.NEURO object.

Arguments

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

Returns

Nothing

delete_channel(obj; <keyword arguments>)

Delete channel(s).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channels to be removed
• del_opt::Bool=false: for NIRS data is set as true if called from remove_optode()

Returns

• obj_new::NeuroAnalyzer.NEURO

delete_channel!(obj; <keyword arguments>)

Delete channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channels to be removed
• del_opt::Bool=false: for NIRS data is set as true if called from remove_optode()

Returns

Nothing

delete_epoch(obj; <keyword arguments>)

Remove epochs.

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch numbers to be removed

Returns

• obj_new::NeuroAnalyzer.NEURO

delete_epoch!(obj; <keyword arguments>)

Remove epochs.

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch numbers to be removed

Returns

Nothing

delete_marker(obj; <keyword arguments>)

Delete marker.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

delete_marker!(obj; n)

Delete marker.

Arguments

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

Returns

Nothing

delete_optode(obj; <keyword arguments>)

Delete optodes) and channels associated with removed optodes.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

delete_optode!(obj; <keyword arguments>)

Delete optopode(s).

Arguments

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

Returns

Nothing

detect_bad(obj; <keyword arguments>)

Detect bad channels and epochs.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• method::Union{Symbol, Vector{Symbol}}=[:flat, :rmse, :rmsd, :euclid, :var, :p2p, :tkeo, :kurt, :z, :ransac, :amp]: detection method:
  • :flat: flat channel(s)
  • :rmse: RMSE vs average channel outside of 95% CI
  • :rmsd: RMSD
  • :euclid: Euclidean distance
  • :var: mean signal variance outside of 95% CI and variance inter-quartile outliers
  • :p2p: mark bad channels based on peak-to-peak amplitude; good for detecting transient artifacts
  • :tkeo: mark bad channels based on z-score TKEO value outside of 95% CI
  • :kurt: mark bad channels based on z-scores of kurtosis values
  • :z: mark bad channels based on their z-score of amplitude
  • :ransac: calculate each channel correlation to its nearest neighbor with outliers removed using random sample consensus (RANSAC) in successive 1-s segments; channel signals exhibiting low correlation to signals in neighboring scalp channels in individual windows (here, r < ransac_r at more than ransac_tr of the data points) are marked as bad
  • :amp: mark bad channels based on their amplitude
• w::Int64=10: window width in samples (signal is averaged within w-width window)
• flat_tol::Float64=0.1: tolerance (signal is flat within -tol to +tol), eps() gives very low tolerance
• flat_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.99: probability threshold (0.0 to 1.0) for marking a 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); also threshold for :z method: percentage of channel length per epoch for marking a channel as bad
• tc::Float64=0.3: threshold (0.0 to 1.0) of bad channels ratio to mark the epoch as bad
• tkeo_method::Symbol=:pow: method of calculating TKEO, see tkeo() for details
• z::Real=3: threshold number of z-scores
• ransac_r::Float64=0.8: threshold (0.0 to 1.0) correlation between channels
• ransac_tr::Float64=0.4: threshold (0.0 to 1.0) ratio of uncorrelated channels
• ransac_t::Float64=100.0: threshold distance of a sample point to the regression hyperplane to determine if it fits the model well
• amp_t::Float64=400.0: two-sided rejection amplitude threshold (± 400 μV)

Returns

Named tuple containing:

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

detect_bad!(obj; <keyword arguments>)

Detect bad channels and epochs and update the :bad_channel field in the OBJ header.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• method::Union{Symbol, Vector{Symbol}}=[:flat, :rmse, :rmsd, :euclid, :var, :p2p, :tkeo, :kurt, :z, :ransac, :amp]: detection method:
  • :flat: flat channel(s)
  • :rmse: RMSE vs average channel outside of 95% CI
  • :rmsd: RMSD
  • :euclid: Euclidean distance
  • :var: mean signal variance outside of 95% CI and variance inter-quartile outliers
  • :p2p: mark bad channels based on peak-to-peak amplitude; good for detecting transient artifacts
  • :tkeo: mark bad channels based on z-score TKEO value outside of 95% CI
  • :kurt: mark bad channels based on z-scores of kurtosis values
  • :z: mark bad channels based on their z-score of amplitude
  • :ransac: calculate each channel correlation to its nearest neighbor with outliers removed using random sample consensus (RANSAC) in successive 1-s segments; channel signals exhibiting low correlation to signals in neighboring scalp channels in individual windows (here, r < ransac_r at more than ransac_tr of the data points) are marked as bad
  • :amp: mark bad channels based on their amplitude
• w::Int64=10: window width in samples (signal is averaged within w-width window)
• flat_tol::Float64=0.1: tolerance (signal is flat within -tol to +tol), eps() gives very low tolerance
• flat_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.99: probability threshold (0.0 to 1.0) for marking a 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); also threshold for :z method: percentage of channel length per epoch for marking a channel as bad
• tc::Float64=0.3: threshold (0.0 to 1.0) of bad channels ratio to mark the epoch as bad
• tkeo_method::Symbol=:pow: method of calculating TKEO, see tkeo() for details
• z::Real=3: threshold number of z-scores
• ransac_r::Float64=0.8: threshold (0.0 to 1.0) correlation between channels
• ransac_tr::Float64=0.4: threshold (0.0 to 1.0) ratio of uncorrelated channels
• ransac_t::Float64=100.0: threshold distance of a sample point to the regression hyperplane to determine if it fits the model well
• amp_t::Float64=400.0: two-sided rejection amplitude threshold (± 400 μV)

Returns

Nothing

edit_channel(obj; <keyword arguments>)

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

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• field::Symbol
• value::String

Returns

• obj_new::NeuroAnalyzer.NEURO

edit_channel!(obj; <keyword arguments>)

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

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• field::Symbol
• value::String

Returns

Nothing

edit_marker(obj; <keyword arguments>)

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=0: channel number, if 0 then marker is related to all channels

Returns

• obj_new::NeuroAnalyzer.NEURO

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

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=0: channel number, if 0 then marker is related to all channels

Returns

Nothing

epoch(obj; <keyword arguments>)

Split 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_new::NeuroAnalyzer.NEURO

epoch!(obj; <keyword arguments>)

Split 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

Nothing

epoch_ts(obj; <keyword arguments>)

Edit epochs time start.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

epoch_ts!(obj; <keyword arguments>)

Edit OBJ epochs time start.

Arguments

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

Returns

Nothing

extract_channel(obj; <keyword arguments>)

Extract channel data.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name

Returns

• d::Array{Float64, 3}

extract_data(obj; <keyword arguments>)

Extract data.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}=1:nepochs(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_epoch(obj; <keyword arguments>)

Extract epoch.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

extract_epoch!(obj; <keyword arguments>)

Extract epoch.

Arguments

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

Returns

Nothing

extract_eptime(obj)

Extract epochs time.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• et::Vector{Float64}

extract_time(obj)

Extract time.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• tpts::Vector{Float64}

get_channel(obj; <keyword arguments>)

Return list of channel names of specified type or their numbers if names are specified.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}="": channel name or list of channel names
• type::Union{String, Vector{String}}="all": channels types
• wl::Real: return NIRS channels for wavelength (in nm)
• exclude::Union{String, Vector{String}}="bad": channel name or list of channel names to exclude from the list

Returns

• ch::Union{Vector{String}, Vector{Int64}}

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_new::NeuroAnalyzer.NEURO

join!(obj1, obj2)

Join two NeuroAnalyzer objects into the first object. 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

Nothing

keep_channel(obj; <keyword arguments>)

Keep channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channels to keep

Returns

• obj_new::NeuroAnalyzer.NEURO

keep_channel!(obj; <keyword arguments>)

Keep channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channels to keep

Returns

Nothing

keep_epoch(obj; <keyword arguments>)

Keep epochs.

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch numbers to keep

Returns

• obj_new::NeuroAnalyzer.NEURO

keep_epoch!(obj; <keyword arguments>)

Keep epochs.

Arguments

• obj::NeuroAnalyzer.NEURO
• ep::Union{Int64, Vector{Int64}, <:AbstractRange}: epoch numbers to keep

Returns

Nothing

reflect(obj; <keyword arguments>)

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_new::NeuroAnalyzer.NEURO

reflect!(obj; <keyword arguments>)

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

Nothing

rename_channel(obj; <keyword arguments>)

Rename channel.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• name::String: new name

Returns

• obj_new::NeuroAnalyzer.NEURO

rename_channel!(obj; <keyword arguments>)

Rename channel.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• name::String: new name

Returns

Nothing

replace_channel(obj; <keyword arguments>)

Replace channel.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• s::AbstractArray

Returns

• obj_new::NeuroAnalyzer.NEURO

replace_channel!(obj; <keyword arguments>)

Replace channel.

Arguments

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

Returns

Nothing

set_channel_type(obj; <keyword arguments>)

Set channel type.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• type::String: new type

Returns

• obj_new::NeuroAnalyzer.NEURO

set_channel_type!(obj; <keyword arguments>)

Set channel type.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• type::String

Returns

Nothing

subepoch(obj; <keyword arguments>)

Extract sub-epochs with a reduced time range.

Arguments

• obj::NeuroAnalyzer.NEURO
• ep_start::Real: sub-epoch start
• ep_end::Real: sub-epoch end

Returns

• obj_new::NeuroAnalyzer.NEURO

subepoch!(obj; <keyword arguments>)

Extract sub-epochs with a reduced time range.

Arguments

• obj::NeuroAnalyzer.NEURO
• ep_start::Real: sub-epoch start
• ep_end::Real: sub-epoch end

Returns

Nothing

trim(s; <keyword arguments>)

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; <keyword arguments>)

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::Matrix{Float64}

trim(a; <keyword arguments>)

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, 3}

trim(obj; <keyword arguments>)

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_new::NeuroAnalyzer.NEURO

trim!(obj; <keyword arguments>)

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

Nothing

vch(obj; <keyword arguments>)

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

view_marker(obj)

Show markers.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Nothing

add_signal(s1, s2)

Add signal.

Arguments

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

Returns

• s_noisy::AbstractVector

add_signal(obj; <keyword arguments>)

Add signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• s::AbstractVector: signal to be added to each channel

Returns

• obj_new::NeuroAnalyzer.NEURO

add_signal!(obj; <keyword arguments>)

Add signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• s::AbstractVector: signal to be added to each channel

Returns

Nothing

average(s)

Average all channels.

Arguments

• s::AbstractArray

Returns

• average::AbstractArray

average(s1, s2)

Averages two signals.

Arguments

• s1::AbstractArray
• s2::AbstractArray

Returns

• average::AbstractArray

average(obj; <keyword arguments>)

Return the average signal of channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names

Returns

• obj_new::NeuroAnalyzer.NEURO

average(obj1, obj2)

Return the average signal of two objects.

Arguments

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

Returns

• obj_new::NeuroAnalyzer.NEURO

average!(obj; <keyword arguments>)

Return the average signal of channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names

Returns

Nothing

average_epochs(obj; <keyword arguments>)

Average EEG/MEG epochs. Non-EEG/MEG channels are removed. OBJ.header.recording[:data_type] becomes erp (for EEG) or erf for MEG. First epoch is the ERP/ERF.

Arguments

• obj::NeuroAnalyzer.NEURO
• bl::Tuple{Real, Real}=(0, 0): baseline is from b[1] to b[2] seconds; if bl is greater than (0, 0), DC value is calculated as mean of the b[1] to b[2] seconds and subtracted from the signal
• blfirst::Bool=false: if true, subtract the baseline segment prior to averaging

Returns

• obj_new::NeuroAnalyzer.NEURO

average_epochs!(obj; <keyword arguments>)

Average EEG/MEG epochs. Non-EEG/MEG channels are removed. OBJ.header.recording[:data_type] becomes erp (for EEG) or erf for MEG. First epoch is the ERP/ERF.

Arguments

• obj::NeuroAnalyzer.NEURO
• bl::Tuple{Real, Real}=(0, 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
• blfirst::Bool=false: if true, subtract the baseline segment prior to averaging

Returns

Nothing

bpsplit(obj; <keyword arguments>)

Split signal into frequency bands using a FIR band-pass filter.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• order::Int64=8: number of taps for FIR band-pass filter
• w::Union{Nothing, AbstractVector, <:Real}=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; <keyword arguments>)

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; <keyword arguments>)

Perform convolution bandpass filtering.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• pad::Int64: pad the signal with pad zeros
• frq::Real: filter frequency

Returns

• obj_new::NeuroAnalyzer.NEURO

cbp!(obj; <keyword arguments>)

Perform convolution bandpass filtering.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• pad::Int64: pad the signal with pad zeros
• frq::Tuple{Real, Real}: filter frequency

Returns

Nothing

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

Returns

Nothing

csd(obj; <keyword arguments>)

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; <keyword arguments>)

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

Nothing

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; <keyword arguments>)

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::Matrix{Float64}: CWT coefficients (by rows)

cw_trans(s; <keyword arguments>)

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; <keyword arguments>)

Perform continuous wavelet transformation (CWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• 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_cwt(s; <keyword arguments>)

Perform denoising using continuous wavelet transformation (iCWT).

Arguments

• s::AbstractVector
• fs::Int64: sampling rate
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=32, Q=128), see ContinuousWavelets.jl documentation for the list of available wavelets
• nf::Real: noise frequency in Hz
• w::Int64=5: width (in Hz) of the area surrounding noise (from nf - w to nf + w)
• type::Symbol=:nd: inverse style type:
  • :pd: PenroseDelta
  • :nd: NaiveDelta
  • :df: DualFrames

Returns

• s_new::Vector{Float64}

denoise_cwt(s; <keyword arguments>)

Perform denoising using continuous wavelet transformation (CWT).

Arguments

• s::AbstractArray
• fs::Int64: sampling rate
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=32, Q=128), see ContinuousWavelets.jl documentation for the list of available wavelets
• nf::Real: noise frequency in Hz
• w::Int64=5: width (in Hz) of the area surrounding noise (from nf - w to nf + w)
• type::Symbol=:nd: inverse style type:
  • :pd: PenroseDelta
  • :nd: NaiveDelta
  • :df: DualFrames

Returns

• s_new::Array{Float64, 3}

denoise_cwt(obj; <keyword arguments>)

Perform denoising using continuous wavelet transformation (CWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=32, Q=128), see ContinuousWavelets.jl documentation for the list of available wavelets
• nf::Real: noise frequency in Hz
• w::Int64=5: width (in Hz) of the area surrounding noise (from nf - w to nf + w)
• type::Symbol=:nd: inverse style type:
  • :pd: PenroseDelta
  • :nd: NaiveDelta
  • :df: DualFrames

Returns

• obj_new::NeuroAnalyzer.NEURO

denoise_cwt!(obj; <keyword arguments>)

Perform denoising using continuous wavelet transformation (CWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=32, Q=128), see ContinuousWavelets.jl documentation for the list of available wavelets
• nf::Real: noise frequency in Hz
• w::Int64=5: width (in Hz) of the area surrounding noise (from nf - w to nf + w)
• type::Symbol=:nd: inverse style type:
  • :pd: PenroseDelta
  • :nd: NaiveDelta
  • :df: DualFrames

Returns

Nothing

denoise_dwt(s; <keyword arguments>)

Perform denoising using 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

Returns

• s_new::Vector{Float64}

denoise_dwt(s; <keyword arguments>)

Perform denoising using 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

Returns

• s_new::Array{Float64, 3}

denoise_dwt(obj; <keyword arguments>)

Perform denoising using discrete wavelet transformation (DWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• 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_dwt!(obj; <keyword arguments>)

Perform denoising using discrete wavelet transformation (DWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• wt<:DiscreteWavelet: discrete wavelet, e.g. wt = wavelet(WT.haar), see Wavelets.jl documentation for the list of available wavelets

Returns

Nothing

denoise_fft(s; <keyword arguments>)

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}: denoised signal
• f_idx::BitVector: index of components zeroed

denoise_fft(s; <keyword arguments>)

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

• s_new::Array{Float64, 3}

denoise_fft(obj; <keyword arguments>)

Perform FFT denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• 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; <keyword arguments>)

Perform FFT denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• pad::Int64=0: number of zeros to add signal for FFT
• t::Int64=100: PSD threshold for keeping frequency components

Returns

Nothing

denoise_wien(s)

Perform Wiener deconvolution denoising.

Arguments

• s::AbstractArray

Returns

• s_new::AbstractArray

denoise_wien(obj; <keyword arguments>)

Perform Wiener deconvolution denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names

Returns

• obj_new::NeuroAnalyzer.NEURO

denoise_wien!(obj; <keyword arguments>)

Perform Wiener deconvolution denoising.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names

Returns

Nothing

derivative(s)

Return derivative (calculated using symmetric difference quotient) of a discrete signal of the same length.

Arguments

• s::AbstractVector

Returns

• s_new::AbstractVector

derivative(s)

Return derivative (calculated using symmetric difference quotient) of a discrete signal of the same length.

Arguments

• s::AbstractArray

Returns

• s_new::Array{Float64, 3}

derivative(obj; <keyword arguments>)

Return derivative (calculated using symmetric difference quotient) of a discrete signal of the same length.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names

Returns

• obj_new::NeuroAnalyzer.NEURO

derivative!(obj; <keyword arguments>)

Return derivative (calculated using symmetric difference quotient) of a discrete signal of the same length.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names

Returns

Nothing

detect_powerline(s; <keyword arguments>)

Detect power line noise frequency.

Arguments

• s::AbstractVector
• fs::Int64: sampling rate

Returns

• noise_frq::Float64: peak noise frequency in Hz

detect_powerline(obj)

Detect power line noise frequency.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• noise_frq::Array{Float64, 3}: peak noise frequency in Hz

detect_powerline!(obj)

Detect power line noise frequency.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Nothing

detrend(s; <keyword arguments>)

Perform piecewise detrending.

Arguments

• s::AbstractVector
• type::Symbol=:linear:
  • :loess: fit loess approximation and subtract it from s
  • :poly: polynomial of order is subtracted from s
  • :mean: the mean of s is subtracted from s
  • :constant: offset is subtracted from s
  • :ls: the result of a linear least-squares fit to s is subtracted from s
  • :linear: linear trend (1st order polynomial) 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; <keyword arguments>)

Perform piecewise detrending.

Arguments

• s::AbstractArray
• type::Symbol=:linear: detrending method
  • :loess: fit loess approximation and subtract it from s
  • :poly: polynomial of order is subtracted from s
  • :mean: the mean of s is subtracted from s
  • :constant: offset is subtracted from s
  • :ls: the result of a linear least-squares fit to s is subtracted from s
  • :linear: linear trend (1st order polynomial) 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; <keyword arguments>)

Perform piecewise detrending.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• type::Symbol=:linear: detrending method
  • :loess: fit loess approximation and subtract it from s
  • :poly: polynomial of order is subtracted from s
  • :mean: the mean of s is subtracted from s
  • :constant: offset is subtracted from s
  • :ls: the result of a linear least-squares fit to s is subtracted from s
  • :linear: linear trend (1st order polynomial) 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_new::NeuroAnalyzer.NEURO

detrend!(obj; <keyword arguments>)

Perform piecewise detrending.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• type::Symbol=:linear: detrending method
  • :loess: fit loess approximation and subtract it from s
  • :poly: polynomial of order is subtracted from s
  • :mean: the mean of s is subtracted from s
  • :constant: offset is subtracted from s
  • :ls: the result of a linear least-squares fit to s is subtracted from s
  • :linear: linear trend (1st order polynomial) 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

Nothing

downsample(obj; <keyword arguments>)

Downsample.

Arguments

• obj::NeuroAnalyzer.NEURO
• new_sr::Int64: new sampling rate

Returns

• obj_new::NeuroAnalyzer.NEURO

downsample!(obj; <keyword arguments>)

Downsample.

Arguments

• obj::NeuroAnalyzer.NEURO
• new_sr::Int64: new sampling rate

Returns

Nothing

dw_split(obj; <keyword arguments>)

Split into bands using discrete wavelet transformation (DWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• 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, 3}: bands from lowest to highest frequency (by rows)

dw_trans(s; <keyword arguments>)

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::Matrix{Float64}: DWT coefficients cAl, cD1, ..., cDl (by rows)

dw_trans(s; <keyword arguments>)

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; <keyword arguments>)

Perform discrete wavelet transformation (DWT).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• 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)

edit_montage(file_name; <keyword arguments>)

Edit montage file in the OS editor.

Arguments

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

Returns

Nothing

fconv(s; <keyword arguments>)

Perform convolution in the frequency domain.

Arguments

• s::AbstractVector
• kernel::AbstractVector
• norm::Bool=true: normalize kernel to keep the post-convolution results in the same scale as the original data

Returns

• s_new::Vector{ComplexF64}: convoluted signal

fconv(s; <keyword arguments>)

Perform convolution in the frequency domain.

Arguments

• s::AbstractArray
• kernel::AbstractVector: convolution kernel
• norm::Bool=true: normalize kernel to keep the post-convolution results in the same scale as the original data

Returns

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

fconv(obj; <keyword arguments>)

Perform convolution in the frequency domain.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• kernel::AbstractVector: convolution kernel
• norm::Bool=true: normalize kernel to keep the post-convolution results in the same scale as the original data

Returns

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

filter(obj; <keyword arguments>)

Apply filtering.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• fprototype::Symbol: filter prototype:
  • :butterworth: IIR filter
  • :chebyshev1 IIR filter
  • :chebyshev2 IIR filter
  • :elliptic IIR filter
  • :iirnotch: second-order IIR notch filter
  • :fir: FIR filter
  • :firls: weighted least-squares FIR 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 (must be a pair of frequencies 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
• w::Union{Nothing, AbstractVector, <:Real}=nothing: window for :fir filter (default is Hamming window, number of taps is calculated using Fred Harris' rule-of-thumb) or weights for :firls filter
• preview::Bool=false: plot filter response

Returns

• obj_new::NeuroAnalyzer.NEURO

filter!(obj; <keyword arguments>)

Apply filtering.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• fprototype::Symbol: filter prototype:
  • :butterworth: IIR filter
  • :chebyshev1 IIR filter
  • :chebyshev2 IIR filter
  • :elliptic IIR filter
  • :iirnotch: second-order IIR notch filter
  • :fir: FIR filter
  • :firls: weighted least-squares FIR 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 (must be a pair of frequencies 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
• w::Union{Nothing, AbstractVector, <:Real}=nothing: window for :fir filter (default is Hamming window, number of taps is calculated using Fred Harris' rule-of-thumb) or weights for :firls filter
• preview::Bool=false: plot filter response

Returns

Nothing

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_new::Vector{Float64}

filter_create(; <keyword arguments>)

Create IIR or FIR filter.

Arguments

• fprototype::Symbol: filter prototype:
  • :butterworth: IIR filter
  • :chebyshev1 IIR filter
  • :chebyshev2 IIR filter
  • :elliptic IIR filter
  • :iirnotch: second-order IIR notch filter
  • :fir: FIR filter
  • :firls: weighted least-squares FIR 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 (must be a pair of frequencies 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
• w::Union{Nothing, AbstractVector, <:Real}=nothing: window for :fir filter (default is Hamming window, number of taps is calculated using Fred Harris' rule-of-thumb) or weights for :firls filter

Returns

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

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

• s_new::Vector{Float64}

filter_g(s; <keyword arguments>)

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_new::Array{Float64, 3}

filter_g(obj; <keyword arguments>)

Filter using Gaussian in the frequency domain.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• 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; <keyword arguments>)

Filter using Gaussian in the frequency domain.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• pad::Int64=0: number of zeros to add
• f::Real: filter frequency
• gw::Real=5: Gaussian width in Hz

Returns

Nothing

filter_mavg(s; <keyword arguments>)

Filter using moving average 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; <keyword arguments>)

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}

filter_mavg(obj; <keyword arguments>)

Filter using moving average filter (with threshold).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• 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

Source

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

filter_mavg!(obj; <keyword arguments>)

Filter using moving average filter (with threshold).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• 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

Returns

Nothing

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; <keyword arguments>)

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}

filter_mmed(obj; <keyword arguments>)

Filter using moving median filter (with threshold).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• 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

filter_mmed!(obj; <keyword arguments>)

Filter using moving median filter (with threshold).

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}}: channel name or list of channel names
• 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

Nothing

filter_poly(s; <keyword arguments>)

Filter using polynomial filter.

Arguments

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

Returns