EegFun

Appearance

Core Types ​

Data structures and type definitions in EegFun.jl.

Abstract Types ​

EegFun.EegFunData Type
julia
EegFunData

Abstract supertype for all primary EegFun data and result structures.

source
EegFun.EegData Type
julia
EegData

Abstract supertype for all EEG data structures.

This type represents the base interface for EEG data objects, providing a common interface for different data formats including continuous data, event-related potentials, and epoch-based data.

source
EegFun.SingleDataFrameEeg Type
julia
SingleDataFrameEeg

Abstract type for EEG data stored in a single DataFrame.

This type represents EEG data where all samples are stored in a single DataFrame, typically used for continuous data or event-related potentials that have been averaged into a single time series.

source
EegFun.MultiDataFrameEeg Type
julia
MultiDataFrameEeg

Abstract type for EEG data stored across multiple DataFrames.

This type represents EEG data where samples are distributed across multiple DataFrames, typically used for epoch-based data where each epoch is stored separately.

source

Data Container Types ​

EegFun.AnalysisInfo Type
julia
AnalysisInfo

Stores metadata about data preprocessing and analysis parameters.

This type contains information about how the EEG data has been processed, including filtering parameters, reference information, and other analysis settings that affect the interpretation of the data.

Fields

  • reference::Symbol: Reference type used (e.g., :avg, :mastoid, :none)

  • hp_filter::Float64: High-pass filter cutoff in Hz (0.0 if none)

  • lp_filter::Float64: Low-pass filter cutoff in Hz (0.0 if none)

source
EegFun.ContinuousData Type
julia
ContinuousData

Stores continuous EEG data with associated layout and analysis information.

This type represents continuous EEG recordings where all time points are stored in a single DataFrame. The data typically includes time series for each electrode channel along with metadata columns.

Fields

  • file::String: Source filename

  • data::DataFrame: DataFrame containing continuous data (without file column)

  • layout::Layout: Layout object containing electrode positioning information

  • sample_rate::Int64: Sample rate of the data in Hz

  • analysis_info::AnalysisInfo: Analysis information and preprocessing metadata

source
EegFun.ErpData Type
julia
ErpData

Stores event-related potential data with associated layout and analysis information.

This type represents averaged event-related potentials where multiple epochs have been averaged together into a single time series. The data includes the averaged ERP waveform for each electrode channel.

Fields

  • file::String: Source filename

  • condition::Int64: Condition number

  • condition_name::String: Name of the condition

  • data::DataFrame: DataFrame containing averaged ERP data (without condition/condition_name/n_epochs columns)

  • layout::Layout: Layout object containing electrode positioning information

  • sample_rate::Int64: Sample rate of the data in Hz

  • analysis_info::AnalysisInfo: Analysis information and preprocessing metadata

  • n_epochs::Int64: Number of epochs that were averaged together

source
EegFun.EpochData Type
julia
EpochData

Stores epoch-based EEG data with associated layout and analysis information.

This type represents EEG data organized into individual epochs, where each epoch is stored as a separate DataFrame. This format is useful for event-related potential analysis and other epoch-based processing.

Fields

  • file::String: Source filename (constant across all epochs)

  • condition::Int64: Condition number (constant across all epochs)

  • condition_name::String: Name of the condition (constant across all epochs)

  • data::Vector{DataFrame}: Vector of DataFrames, one for each epoch (without condition/condition_name/file columns; epoch column remains for original numbering)

  • layout::Layout: Layout object containing electrode positioning information

  • sample_rate::Int64: Sample rate of the data in Hz

  • analysis_info::AnalysisInfo: Analysis information and preprocessing metadata

source
EegFun.TimeFreqData Type
julia
TimeFreqData

Stores time-frequency analysis results for a single condition/average.

This type represents time-frequency power and phase data where all time-frequency points are stored in DataFrames with columns for time, frequency, and each electrode channel. Suitable for averaged TF representations.

Fields

  • file::String: Source filename

  • condition::Int64: Condition number

  • condition_name::String: Name of the condition

  • data_power::DataFrame: DataFrame with columns: time, freq, [electrode channels...] containing power values

  • data_phase::DataFrame: DataFrame with columns: time, freq, [electrode channels...] containing phase values (radians)

  • layout::Layout: Layout object containing electrode positioning information

  • sample_rate::Int64: Sample rate of the original data in Hz

  • method::Symbol: Analysis method (:wavelet, :superlet, :multitaper, :spectrum, :hanning_fixed, :hanning_adaptive)

  • baseline::Union{BaselineInfo,Nothing}: Baseline correction information (if applied)

  • analysis_info::AnalysisInfo: Analysis information and preprocessing metadata

Note

Accessing .data returns data_power via a getproperty override for backward compatibility.

source
EegFun.TimeFreqEpochData Type
julia
TimeFreqEpochData

Stores time-frequency analysis results with individual trials preserved.

This type represents time-frequency power and phase data organized into individual trials, where each trial is stored as a separate DataFrame. Each DataFrame contains columns for time, frequency, and each electrode channel.

Fields

  • file::String: Source filename (constant across all trials)

  • condition::Int64: Condition number (constant across all trials)

  • condition_name::String: Name of the condition (constant across all trials)

  • data_power::Vector{DataFrame}: Vector of DataFrames, one per trial (columns: time, freq, [electrodes...]) containing power values

  • data_phase::Vector{DataFrame}: Vector of DataFrames, one per trial (columns: time, freq, [electrodes...]) containing phase values (radians)

  • layout::Layout: Layout object containing electrode positioning information

  • sample_rate::Int64: Sample rate of the original data in Hz

  • method::Symbol: Analysis method (:wavelet, :superlet, :multitaper, :spectrum, :hanning_fixed, :hanning_adaptive)

  • baseline::Union{BaselineInfo,Nothing}: Baseline correction information (if applied)

  • analysis_info::AnalysisInfo: Analysis information and preprocessing metadata

Note

Accessing .data returns data_power via a getproperty override for backward compatibility.

source
EegFun.SpectrumData Type
julia
SpectrumData

Stores power spectrum analysis results (frequency domain, no time dimension).

This type represents power spectral density data computed using Welch's method or other spectral estimation techniques. The data is stored in a DataFrame with frequency values and power for each electrode channel.

Fields

  • file::String: Source filename

  • condition::Int64: Condition number

  • condition_name::String: Name of the condition

  • data::DataFrame: DataFrame with columns: freq, [electrode channels...] containing power spectral density (μV²/Hz)

  • layout::Layout: Layout object containing electrode positioning information

  • sample_rate::Int64: Sample rate of the original data in Hz

  • method::Symbol: Analysis method (:welch, :multitaper, etc.)

  • analysis_info::AnalysisInfo: Analysis information and preprocessing metadata

source

Layout Types ​

EegFun.Layout Type
julia
Layout

Stores electrode layout information and spatial relationships.

This type contains the complete electrode layout information including electrode positions in various coordinate systems (polar, 2D Cartesian, 3D Cartesian) and neighbor relationships for spatial operations.

Fields

  • data::DataFrame: DataFrame containing layout information with metadata groups

  • neighbours::Union{Nothing, OrderedDict{Symbol, Neighbours}}: Dictionary of neighbours for each electrode

  • criterion::Union{Nothing, Float64}: Distance criterion for neighbour calculation in normalized coordinate units

  • criterion_type::Union{Nothing, Symbol}: Type of neighbour calculation (:xy or :xyz)

source
EegFun.Neighbours Type
julia
Neighbours

Stores spatial neighbor information for an electrode in layout-based operations.

This type contains information about neighboring electrodes for spatial interpolation, artifact detection, and other layout-dependent operations. The distances and weights are typically calculated based on electrode positions in 2D or 3D space.

Fields

  • channels::Vector{Symbol}: List of neighboring channel labels

  • distances::Vector{Float64}: Distances to each neighbor in normalized coordinate units

  • weights::Vector{Float64}: Interpolation weights for each neighbor

source

Epoch Configuration ​

EegFun.EpochCondition Type
julia
EpochCondition

Defines parameters for extracting epochs for a specific experimental condition.

This type specifies the criteria for identifying and extracting epochs from continuous EEG data based on trigger sequences and timing constraints. It supports complex trigger patterns and timing relationships between events.

Fields

  • name::String: Descriptive condition name for identification

  • trigger_sequences::Vector{Vector{Union{Int,Symbol,UnitRange{Int}}}}: Trigger sequences to match (e.g., [[1, 2, 3]], [[1, :any, 3]], [[1:5], [10:15]])

  • reference_index::Int: Which trigger position is t=0 (1-based, default: 1)

  • timing_pairs::Union{Nothing,Vector{Tuple{Int,Int}}}: Which trigger pairs to apply min/max intervals to (optional, default: nothing)

  • min_interval::Union{Nothing,Float64}: Minimum time between specified trigger pairs in seconds (optional, default: nothing)

  • max_interval::Union{Nothing,Float64}: Maximum time between specified trigger pairs in seconds (optional, default: nothing)

  • after::Union{Nothing,Int}: Only search for sequences after this trigger value (optional, default: nothing)

  • before::Union{Nothing,Int}: Only search for sequences before this trigger value (optional, default: nothing)

source

ICA Types ​

EegFun.IcaPrms Type
julia
IcaPrms

Parameters for Independent Component Analysis (ICA) decomposition.

This type contains all the parameters needed to configure ICA decomposition of EEG data, including learning rates, convergence criteria, and algorithm specific settings.

Fields

  • l_rate::Float64: Learning rate for the ICA algorithm

  • max_iter::Int: Maximum number of iterations for convergence

  • w_change::Float64: Weight change threshold for convergence

  • anneal_deg::Float64: Annealing degree for temperature scheduling

  • anneal_step::Float64: Annealing step size for temperature updates

  • blowup::Float64: Blowup factor for numerical stability

  • blowup_fac::Float64: Blowup factor for algorithm stability

  • max_weight::Float64: Maximum allowed weight value

  • restart_factor::Float64: Factor for restarting stuck algorithms

  • degconst::Float64: Degree constant for spherical coordinates

  • default_stop::Float64: Default stopping criterion threshold

source
EegFun.InfoIca Type
julia
InfoIca

Stores ICA analysis results and decomposition information.

This type contains the complete results of ICA decomposition including the unmixing and mixing matrices, component statistics, and metadata about the decomposition process.

Fields

  • filename::String: Filename of the input data file used to generate this ICA result

  • unmixing::Matrix{Float64}: Unmixing matrix (sources = unmixing × data)

  • mixing::Matrix{Float64}: Mixing matrix (data = mixing × sources)

  • sphere::Matrix{Float64}: Sphering matrix for data preprocessing

  • variance::Vector{Float64}: Variance explained by each component

  • scale::Float64: Scaling factor applied to the data

  • mean::Vector{Float64}: Mean vector subtracted from the data

  • ica_label::Vector{Symbol}: Component labels (e.g., [:IC1, :IC2, ...])

  • removed_activations::OrderedDict{Int, Matrix{Float64}}: Removed component activations by epoch

  • layout::Layout: Layout information for the ICA components (contains channel labels)

  • is_sub_gaussian::Vector{Bool}: Boolean vector indicating if each component is sub-Gaussian (true = sub-Gaussian, false = super-Gaussian). For regular Infomax, all components are super-Gaussian (all false).

source

Statistics Types ​

EegFun.StatsResult Type
julia
StatsResult

Abstract type for statistical test results. All statistical test results share common fields:

  • test_info::TestInfo: Test configuration and parameters

  • data::Vector{ErpData}: Grand average ERPs for conditions 1 and 2

  • stat_matrix::StatMatrix: T-statistics and optionally p-values

  • masks::Masks: Significance masks for positive and negative effects

  • electrodes::Vector{Symbol}: Electrode labels

  • time_points::Vector{Float64}: Time points in seconds

  • critical_t: Critical t-values (type varies by test method)

  • se::Array{Float64, 2}: Standard error of the mean difference [electrodes × time]

source
EegFun.PermutationResult Type
julia
PermutationResult

Stores complete results from a cluster-based permutation test.

Fields

  • test_info::TestInfo: Test configuration and parameters (includes ClusterInfo)

  • data::Vector{ErpData}: Grand average ERPs for conditions 1 and 2 (for visualization)

  • stat_matrix::StatMatrix: T-statistics matrix. Note: p is nothing for cluster permutation

  • masks::Masks: Significance masks for positive and negative effects

  • clusters::Clusters: Positive and negative clusters

  • permutation_distribution::PermutationDistribution: Null distribution of max cluster stats

  • electrodes::Vector{Symbol}: Electrode labels

  • time_points::Vector{Float64}: Time points in seconds

  • critical_t::Union{Array{Float64, 2}, Tuple{Float64, Float64}, Tuple{Array{Float64, 2}, Array{Float64, 2}}}: Critical t-values used

  • se::Array{Float64, 2}: Standard error of the mean difference [electrodes × time] (analysis interval)

  • se_cond1::Array{Float64, 2}: Standard error for condition 1 [electrodes × time] (full display interval)

  • se_cond2::Array{Float64, 2}: Standard error for condition 2 [electrodes × time] (full display interval)

  • se_diff::Array{Float64, 2}: Standard error of the mean difference [electrodes × time] (full display interval)

source
EegFun.AnalyticResult Type
julia
AnalyticResult

Stores results from an analytic (parametric) t-test without permutation.

Fields

  • test_info::TestInfo: Test configuration (type, df, alpha, tail, correction_method, cluster_info=nothing)

  • data::Vector{ErpData}: Grand average ERPs for conditions 1 and 2 (for visualization/storage)

  • stat_matrix::StatMatrix: Statistical results containing t (t-statistics) and p (p-values) [electrodes × time]

  • masks::Masks: Significance masks containing positive and negative significant points [electrodes × time]

  • electrodes::Vector{Symbol}: Electrode labels

  • time_points::Vector{Float64}: Time points in seconds

  • critical_t::Float64: Critical t-value for significance (uniform across all points)

  • se::Array{Float64, 2}: Standard error of the mean difference [electrodes × time] (analysis interval)

  • se_cond1::Array{Float64, 2}: Standard error for condition 1 [electrodes × time] (full display interval)

  • se_cond2::Array{Float64, 2}: Standard error for condition 2 [electrodes × time] (full display interval)

  • se_diff::Array{Float64, 2}: Standard error of the mean difference [electrodes × time] (full display interval)

source

Decoding Types ​

EegFun.DecodingParameters Type
julia
DecodingParameters

Stores parameters used for decoding analysis.

Fields

  • chance_level::Float64: Expected chance-level performance (e.g., 0.5 for binary, 1/n_classes for n-class)

  • n_iterations::Int64: Number of iterations/permutations performed

  • n_folds::Int64: Number of cross-validation folds

  • class_coding::Symbol: Multi-class coding scheme (:one_vs_one, :one_vs_all, :binary)

  • n_classes::Int64: Number of classes/conditions being decoded

source
EegFun.DecodedData Type
julia
DecodedData

Stores MVPA/decoding analysis results for a single participant.

This type represents the results of multivariate pattern classification analysis, including classification accuracy over time, confusion matrices, and metadata about the analysis parameters.

Fields

  • file::String: Source filename

  • condition_names::Vector{String}: Names of conditions/bins being decoded

  • times::Vector{Float64}: Time points in seconds where decoding was performed

  • average_score::Vector{Float64}: Average classification accuracy at each time point

  • channels::Vector{Symbol}: Channel names used in the analysis

  • parameters::DecodingParameters: Decoding analysis parameters (chance_level, n_iterations, n_folds, class_coding, n_classes)

  • stderror::Union{Vector{Float64}, Nothing}: Standard error of accuracy, or nothing

  • confusion_matrix::Union{Array{Float64, 3}, Nothing}: Confusion matrices [time × true_class × predicted_class], or nothing

  • raw_predictions::Union{Array{Float64, 4}, Nothing}: Raw predictions [iteration × fold × time × class], or nothing

source

RSA Types ​

EegFun.NoiseCeiling Type
julia
NoiseCeiling

Stores noise ceiling estimates for RSA analysis.

The noise ceiling quantifies the maximum correlation that an ideal model could achieve with the observed neural data, given the noise and variability in the measurements. This is computed using leave-one-out cross-validation across participants (Nili et al., 2014).

Fields

  • lower_bound::Vector{Float64}: Lower bound of noise ceiling at each time point [time]

    • Computed as correlation between each left-out participant and the average of remaining participants

    • Conservative estimate (underestimates true ceiling)

  • upper_bound::Vector{Float64}: Upper bound of noise ceiling at each time point [time]

    • Computed as correlation between each left-out participant and the average of all participants

    • Liberal estimate (overestimates true ceiling)

  • n_participants::Int: Number of participants used in computation

References

Nili, H., Wingfield, C., Walther, A., Su, L., Marslen-Wilson, W., & Kriegeskorte, N. (2014). A toolbox for representational similarity analysis. PLoS computational biology, 10(4), e1003553.

source
EegFun.RsaData Type
julia
RsaData

Stores RSA analysis results for a single participant.

This type represents the results of Representational Similarity Analysis, including Representational Dissimilarity Matrices (RDMs) computed at each time point, correlations with model RDMs, and metadata about the analysis.

Fields

  • file::String: Source filename

  • condition_names::Vector{String}: Names of conditions/bins analyzed

  • times::Vector{Float64}: Time points in seconds where RDMs were computed

  • rdm::Array{Float64, 3}: Representational Dissimilarity Matrices [time × condition × condition]

  • dissimilarity_measure::Symbol: Measure used (:correlation, :euclidean, :mahalanobis, etc.)

  • channels::Vector{Symbol}: Channel names used in the analysis

  • layout::Layout: Layout object containing electrode positioning information

  • sample_rate::Int64: Sample rate of the original data in Hz

  • model_correlations::Union{Array{Float64, 2}, Nothing}: Correlations with model RDMs [time × model]

  • model_names::Union{Vector{String}, Nothing}: Names of models compared (if any)

  • p_values::Union{Array{Float64, 2}, Nothing}: P-values for model correlations [time × model]

  • noise_ceiling::Union{NoiseCeiling, Nothing}: Noise ceiling estimates, or nothing

  • analysis_info::AnalysisInfo: Analysis information and preprocessing metadata

source

ERP Measurement Types ​

EegFun.ErpMeasurementsResult Type
julia
ErpMeasurementsResult

Stores ERP measurement results with metadata about the analysis.

This type contains the measurement results DataFrame along with metadata about the analysis type and interval used, allowing the plotting function to automatically use the correct parameters.

Fields

  • data::DataFrame: DataFrame containing measurement results

  • analysis_type::String: Type of measurement (e.g., "mean_amplitude", "max_peak_latency")

  • analysis_interval::Union{Interval,Nothing}: Analysis interval used

  • baseline_interval::Union{Interval,Nothing}: Baseline interval used (if any)

source
EegFun.ValidationResult Type
julia
ValidationResult

Result of parameter validation.

Fields

  • success::Bool: Whether validation succeeded

  • error::Union{Nothing,String}: Error message if validation failed, nothing if validation succeeded (default: nothing)

  • key_path::Union{Nothing,String}: Path of TOML keys to the parameter that failed validation, nothing if validation succeeded (default: nothing)

source

Artifact & Rejection Types ​

EegFun.ArtifactInfo Type
julia
ArtifactInfo

Flexible container for storing all artifact-related information from preprocessing. Can hold multiple continuous repair infos and epoch rejection infos.

Fields

  • continuous_repairs::Vector{ContinuousRepairInfo}: Vector of continuous repair info objects

  • epoch_rejections::Vector{EpochRejectionInfo}: Vector of epoch rejection info objects

  • ica_components::Union{ArtifactComponents, Nothing}: ICA artifact components (Nothing if ICA was not applied)

source
EegFun.EpochRejectionInfo Type
julia
EpochRejectionInfo

Stores information about which epochs were rejected and why, and optionally tracks channel repairs.

Fields

  • name::String: Name/identifier for this rejection info (e.g., "rejection_step1", "rejection_step2")

  • info::EpochInfo: Condition metadata (number, name, n_epochs)

  • n_artifacts::Int: Total number of artifact detections (channel-epoch pairs)

  • abs_criterion::Real: Absolute voltage threshold (μV) used for rejection

  • abs_rejections::Union{Vector{Rejection}, Nothing}: Rejections due to absolute voltage threshold (Nothing if abs_criterion = 0)

  • z_criterion::Real: Z-score criterion used for rejection

  • z_rejections::Union{ZScoreRejectionInfo, Nothing}: Z-score based rejection info (Nothing if z_criterion = 0)

  • rejected::Vector{Rejection}: All rejected epochs

  • repaired::Union{OrderedDict{Int, Vector{Symbol}}, Nothing}: Channels repaired per epoch, ordered by epoch number (populated during repair, Nothing if no repairs)

  • skipped::Union{OrderedDict{Int, Vector{Symbol}}, Nothing}: Channels skipped per epoch, ordered by epoch number (populated during repair, Nothing if no repairs)

source
EegFun.ContinuousRepairInfo Type
julia
ContinuousRepairInfo

Stores information about channels repaired at the continuous data level (before epoching). These repairs apply to all epochs.

Fields

  • name::String: Name/identifier for this repair info (e.g., "continuous_repair_pre_ica")

  • method::Symbol: Repair method used (:neighbor_interpolation or :spherical_spline)

  • repaired::Vector{Symbol}: Channels that were successfully repaired (populated during repair)

  • skipped::Vector{Symbol}: Channels that were identified as bad but couldn't be repaired (populated during repair)

source
EegFun.ZScoreRejectionInfo Type
julia
ZScoreRejectionInfo

Stores z-score based rejection information.

Fields

  • z_measures::Vector{Symbol}: Which z-score measures were evaluated

  • z_variance::Vector{Rejection}: Rejections due to high variance

  • z_max::Vector{Rejection}: Rejections due to high maximum values

  • z_min::Vector{Rejection}: Rejections due to low minimum values

  • z_abs::Vector{Rejection}: Rejections due to high absolute values

  • z_range::Vector{Rejection}: Rejections due to large range

  • z_kurtosis::Vector{Rejection}: Rejections due to high kurtosis

source
EegFun.EpochRepairInfo Type
julia
EpochRepairInfo

Stores information about channels repaired at the epoch level for a specific condition.

Fields

  • condition::Int64: Condition number

  • condition_name::String: Condition name

  • repaired::OrderedDict{Int, Vector{Symbol}}: Maps epoch index to channels repaired in that epoch (ordered by epoch number)

  • method::Symbol: Repair method used (:neighbor_interpolation or :spherical_spline)

  • neighbors::Union{Dict{Symbol, Vector{Symbol}}, Nothing}: For neighbor interpolation, maps each repaired channel to its neighbor channels (may be the same across epochs)

  • skipped::OrderedDict{Int, Vector{Symbol}}: Maps epoch index to channels that were identified as bad but couldn't be repaired (bad neighbors or too few neighbors) (ordered by epoch number)

source
EegFun.ChannelRepairInfo Type
julia
ChannelRepairInfo

Comprehensive tracking of all channel repairs during preprocessing.

Fields

  • continuous::Union{ContinuousRepairInfo, Nothing}: Repairs at continuous level (Nothing if none)

  • epochs::Vector{EpochRepairInfo}: Repairs at epoch level, one per condition

source

Batch & Pipeline Types ​

EegFun.AnalysisSettings Type
julia
AnalysisSettings

Stores the final analysis settings applied by the user in the databrowser.

Fields

  • hp_filter::Float64: High-pass filter frequency (0.0 if not applied)

  • lp_filter::Float64: Low-pass filter frequency (0.0 if not applied)

  • reference::Symbol: Reference type used (:avg, :mastoid, :none, or channel name)

  • repaired_channels::Vector{Symbol}: List of channels that were repaired

  • repair_method::Symbol: Repair method used for all repaired channels

  • selected_regions::Vector{Tuple{Float64,Float64}}: Time regions selected by user

  • removed_ica_components::Vector{Int}: ICA components that were removed

source
EegFun.PipelineTemplateOptions Type
julia
PipelineTemplateOptions

Configuration options for generating pipeline templates.

Fields

  • num_steps::Int: Number of processing steps to generate (default: 5)

  • subsections_per_step::Int: Number of subsections per step (default: 2)

  • include_usage_example::Bool: Whether to include usage example comments (default: true)

  • include_setup::Bool: Whether to include setup section (default: true)

  • include_summary::Bool: Whether to include summary section (default: true)

source

Decoding & Statistics Result Types ​

EegFun.DecodingStatisticsResult Type
julia
DecodingStatisticsResult

Stores results from statistical tests on decoding data.

Fields

  • times::Vector{Float64}: Time points in seconds

  • t_statistics::Vector{Float64}: T-statistics at each time point

  • p_values::Vector{Float64}: P-values at each time point

  • significant_mask::BitVector: Boolean mask indicating significant time points

  • df::Float64: Degrees of freedom

  • alpha::Float64: Significance threshold used

  • correction_method::Symbol: Multiple comparison correction method used

  • clusters::Union{Vector{TemporalCluster}, Nothing}: Temporal clusters (if cluster-based test was performed)

source

Constants ​

EegFun.VALID_MEASUREMENT_TYPES Constant

Valid ERP measurement type strings.

source
EegFun.MEASUREMENT_TYPE_LABELS Constant

Human-readable labels paired with measurement type strings, for use in GUI menus.

source

See Also ​