Package {ravecore}

Title:	Core File Structures and Workflows for 'RAVE'
Version:	1.0.0
Description:	Defines storage standard for Read, process, and analyze intracranial electroencephalography and deep-brain stimulation in 'RAVE', a reproducible framework for analysis and visualization of iEEG by Magnotti, Wang, and Beauchamp, (2020, <doi:10.1016/j.neuroimage.2020.117341>). Supports brain imaging data structure (BIDS) https://bids.neuroimaging.io and native file structure to ingest signals from 'Matlab' data files, hierarchical data format 5 (HDF5), European data format (EDF), BrainVision core data format (BVCDF), or BlackRock Microsystem (NEV/NSx); process images in Neuroimaging informatics technology initiative (NIfTI) and 'FreeSurfer' formats, providing brain imaging normalization to template brain, facilitating 'threeBrain' package for comprehensive electrode localization via 'YAEL' (your advanced electrode localizer) by Wang, Magnotti, Zhang, and Beauchamp (2023, <doi:10.1523/ENEURO.0328-23.2023>).
License:	MIT + file LICENSE
Encoding:	UTF-8
Language:	en-US
URL:	https://rave.wiki, https://rave.wiki/ravecore/, https://github.com/rave-ieeg/ravecore
BugReports:	https://github.com/rave-ieeg/ravecore/issues
Imports:	tools, utils, bidsr, data.table, filearray (≥ 0.2.0), fs, ieegio, jsonlite, methods, R6, ravepipeline (≥ 0.0.2), ravetools, S7, threeBrain
Suggests:	rpyANTs, rpymat, htmltools, httpuv, knitr, plotly, rmarkdown, RNifti, RNiftyReg, shiny, testthat (≥ 3.0.0)
Config/testthat/edition:	3
Config/roxygen2/version:	8.1.1
NeedsCompilation:	no
Packaged:	2026-11-09 19:18:23 UTC; dipterix
Author:	Zhengjia Wang [aut, cre], Xiang Zhang [aut], John Magnotti [aut], Michael Beauchamp [aut], Trustees of the University of Pennsylvania [cph] (All files in this package unless explicitly stated in the file)
Maintainer:	Zhengjia Wang <dipterix.wang@gmail.com>
Repository:	CRAN
Date/Publication:	2026-11-09 20:10:02 UTC

ravecore: Core File Structures and Workflows for 'RAVE'

Description

Defines storage standard for Read, process, and analyze intracranial electroencephalography and deep-brain stimulation in 'RAVE', a reproducible framework for analysis and visualization of iEEG by Magnotti, Wang, and Beauchamp, (2020, doi:10.1016/j.neuroimage.2020.117341). Supports brain imaging data structure (BIDS) https://bids.neuroimaging.io and native file structure to ingest signals from 'Matlab' data files, hierarchical data format 5 (HDF5), European data format (EDF), BrainVision core data format (BVCDF), or BlackRock Microsystem (NEV/NSx); process images in Neuroimaging informatics technology initiative (NIfTI) and 'FreeSurfer' formats, providing brain imaging normalization to template brain, facilitating 'threeBrain' package for comprehensive electrode localization via 'YAEL' (your advanced electrode localizer) by Wang, Magnotti, Zhang, and Beauchamp (2023, doi:10.1523/ENEURO.0328-23.2023).

Author(s)

Maintainer: Zhengjia Wang dipterix.wang@gmail.com (ORCID)

Authors:

• Zhengjia Wang dipterix.wang@gmail.com (ORCID)

• Xiang Zhang xiang.zhang@pennmedicine.upenn.edu

• John Magnotti john.magnotti@pennmedicine.upenn.edu

• Michael Beauchamp michael.beauchamp@pennmedicine.upenn.edu

Other contributors:

• Trustees of the University of Pennsylvania (All files in this package unless explicitly stated in the file) [copyright holder]

See Also

Useful links:

• https://rave.wiki

• https://rave.wiki/ravecore/

• https://github.com/rave-ieeg/ravecore

• Report bugs at https://github.com/rave-ieeg/ravecore/issues

Class definition for auxiliary channels

Description

Class definition for auxiliary channels

Super classes

ravepipeline::RAVESerializable -> RAVEAbstarctElectrode -> Auxiliary_electrode

Active bindings

Methods

Public methods

• Auxiliary_electrode$@marshal()

• Auxiliary_electrode$@unmarshal()

• Auxiliary_electrode$print()

• Auxiliary_electrode$set_reference()

• Auxiliary_electrode$new()

• Auxiliary_electrode$.load_noref_voltage()

• Auxiliary_electrode$.load_raw_voltage()

• Auxiliary_electrode$load_data_with_epochs()

• Auxiliary_electrode$load_dimnames_with_epochs()

• Auxiliary_electrode$load_data_with_blocks()

• Auxiliary_electrode$load_dim_with_blocks()

• Auxiliary_electrode$clear_cache()

• Auxiliary_electrode$clear_memory()

• Auxiliary_electrode$clone()

Auxiliary_electrode$@marshal()

Internal method

Usage

Auxiliary_electrode$@marshal(...)

Arguments

Auxiliary_electrode$@unmarshal()

Internal method

Usage

Auxiliary_electrode$@unmarshal(object)

Arguments

Auxiliary_electrode$print()

print electrode summary

Usage

Auxiliary_electrode$print()

Auxiliary_electrode$set_reference()

set reference for current electrode

Usage

Auxiliary_electrode$set_reference(reference)

Arguments

Auxiliary_electrode$new()

constructor

Usage

Auxiliary_electrode$new(subject, number, quiet = FALSE)

Arguments

Auxiliary_electrode$.load_noref_voltage()

load non-referenced voltage (internally used)

Usage

Auxiliary_electrode$.load_noref_voltage(reload = FALSE)

Arguments

Auxiliary_electrode$.load_raw_voltage()

load raw voltage (no process)

Usage

Auxiliary_electrode$.load_raw_voltage(reload = FALSE)

Arguments

Auxiliary_electrode$load_data_with_epochs()

method to load electrode data

Usage

Auxiliary_electrode$load_data_with_epochs(type = c("raw-voltage", "voltage"))

Arguments

Auxiliary_electrode$load_dimnames_with_epochs()

get expected dimension names

Usage

Auxiliary_electrode$load_dimnames_with_epochs(
  type = c("raw-voltage", "voltage")
)

Arguments

Auxiliary_electrode$load_data_with_blocks()

load electrode block-wise data (with no reference), useful when epoch is absent

Usage

Auxiliary_electrode$load_data_with_blocks(
  blocks,
  type = c("raw-voltage", "voltage"),
  simplify = TRUE
)

Arguments

Returns

If simplify is enabled, and only one block is loaded, then the result will be a vector (type="voltage") or a matrix (others), otherwise the result will be a named list where the names are the blocks.

Auxiliary_electrode$load_dim_with_blocks()

get expected dimension information for block-based loader

Usage

Auxiliary_electrode$load_dim_with_blocks(
  blocks,
  type = c("raw-voltage", "voltage")
)

Arguments

Auxiliary_electrode$clear_cache()

method to clear cache on hard drive

Usage

Auxiliary_electrode$clear_cache(...)

Arguments

Auxiliary_electrode$clear_memory()

method to clear memory

Usage

Auxiliary_electrode$clear_memory(...)

Arguments

Auxiliary_electrode$clone()

The objects of this class are cloneable with this method.

Usage

Auxiliary_electrode$clone(deep = FALSE)

Arguments

Definitions of electrode with local field potential signal type

Description

Please use a safer new_electrode function to create instances. This documentation is to describe the member methods of the electrode class LFP_electrode

Super classes

ravepipeline::RAVESerializable -> RAVEAbstarctElectrode -> LFP_electrode

Active bindings

Methods

Public methods

• LFP_electrode$@marshal()

• LFP_electrode$@unmarshal()

• LFP_electrode$print()

• LFP_electrode$set_reference()

• LFP_electrode$new()

• LFP_electrode$.load_noref_wavelet()

• LFP_electrode$.load_noref_voltage()

• LFP_electrode$.load_wavelet()

• LFP_electrode$.load_voltage()

• LFP_electrode$.load_raw_voltage()

• LFP_electrode$load_data_with_epochs()

• LFP_electrode$load_dimnames_with_epochs()

• LFP_electrode$load_data_with_blocks()

• LFP_electrode$load_dim_with_blocks()

• LFP_electrode$clear_cache()

• LFP_electrode$clear_memory()

• LFP_electrode$clone()

LFP_electrode$@marshal()

Internal method

Usage

LFP_electrode$@marshal(...)

Arguments

LFP_electrode$@unmarshal()

Internal method

Usage

LFP_electrode$@unmarshal(object)

Arguments

LFP_electrode$print()

print electrode summary

Usage

LFP_electrode$print()

LFP_electrode$set_reference()

set reference for current electrode

Usage

LFP_electrode$set_reference(reference)

Arguments

LFP_electrode$new()

constructor

Usage

LFP_electrode$new(subject, number, quiet = FALSE)

Arguments

LFP_electrode$.load_noref_wavelet()

load non-referenced wavelet coefficients (internally used)

Usage

LFP_electrode$.load_noref_wavelet(reload = FALSE)

Arguments

Returns

if the reference number if NULL or 'noref', then returns 0, otherwise returns a FileArray-class

LFP_electrode$.load_noref_voltage()

load non-referenced voltage (internally used)

Usage

LFP_electrode$.load_noref_voltage(reload = FALSE)

Arguments

LFP_electrode$.load_wavelet()

load referenced wavelet coefficients (internally used)

Usage

LFP_electrode$.load_wavelet(
  type = c("power", "phase", "wavelet-coefficient"),
  reload = FALSE
)

Arguments

LFP_electrode$.load_voltage()

load referenced voltage (internally used)

Usage

LFP_electrode$.load_voltage(reload = FALSE)

Arguments

LFP_electrode$.load_raw_voltage()

load raw voltage (no process)

Usage

LFP_electrode$.load_raw_voltage(reload = FALSE)

Arguments

LFP_electrode$load_data_with_epochs()

method to load electrode data

Usage

LFP_electrode$load_data_with_epochs(
  type = c("power", "phase", "voltage", "wavelet-coefficient", "raw-voltage")
)

Arguments

LFP_electrode$load_dimnames_with_epochs()

get expected dimension names

Usage

LFP_electrode$load_dimnames_with_epochs(
  type = c("power", "phase", "voltage", "wavelet-coefficient", "raw-voltage")
)

Arguments

LFP_electrode$load_data_with_blocks()

load electrode block-wise data (with no reference), useful when epoch is absent

Usage

LFP_electrode$load_data_with_blocks(
  blocks,
  type = c("power", "phase", "voltage", "wavelet-coefficient", "raw-voltage"),
  simplify = TRUE
)

Arguments

Returns

If simplify is enabled, and only one block is loaded, then the result will be a vector (type="voltage") or a matrix (others), otherwise the result will be a named list where the names are the blocks.

LFP_electrode$load_dim_with_blocks()

get expected dimension information for block-based loader

Usage

LFP_electrode$load_dim_with_blocks(
  blocks,
  type = c("power", "phase", "voltage", "wavelet-coefficient", "raw-voltage")
)

Arguments

LFP_electrode$clear_cache()

method to clear cache on hard drive

Usage

LFP_electrode$clear_cache(...)

Arguments

LFP_electrode$clear_memory()

method to clear memory

Usage

LFP_electrode$clear_memory(...)

Arguments

LFP_electrode$clone()

The objects of this class are cloneable with this method.

Usage

LFP_electrode$clone(deep = FALSE)

Arguments

Examples

# Download subject demo/DemoSubject

if(has_rave_subject("demo/DemoSubject")) {

subject <- as_rave_subject("demo/DemoSubject", strict = FALSE)

# Electrode 14 in demo/DemoSubject
e <- new_electrode(subject = subject, number = 14, signal_type = "LFP")

# Load CAR reference "ref_13-16,24"
ref <- new_reference(subject = subject, number = "ref_13-16,24",
                     signal_type = "LFP")
e$set_reference(ref)

# Set epoch
e$set_epoch(epoch = 'auditory_onset')

# Set loading window
e$trial_intervals <- list(c(-1, 2))

# Preview
print(e)

# Now epoch power
power <- e$load_data_with_epochs("power")
names(dimnames(power))

# Subset power
subset(power, Time ~ Time < 0, Electrode ~ Electrode == 14)


# clear cache on hard disk
e$clear_cache()
ref$clear_cache()

}

Definitions of reference with local field potential signal type

Description

Please use a safer new_reference function to create instances. This documentation is to describe the member methods of the electrode class LFP_reference

Super classes

ravepipeline::RAVESerializable -> RAVEAbstarctElectrode -> LFP_reference

Active bindings

Methods

Public methods

• LFP_reference$@marshal()

• LFP_reference$@unmarshal()

• LFP_reference$print()

• LFP_reference$set_reference()

• LFP_reference$new()

• LFP_reference$.load_noref_wavelet()

• LFP_reference$.load_noref_voltage()

• LFP_reference$.load_wavelet()

• LFP_reference$.load_voltage()

• LFP_reference$load_data_with_epochs()

• LFP_reference$load_data_with_blocks()

• LFP_reference$load_dim_with_blocks()

• LFP_reference$clear_cache()

• LFP_reference$clear_memory()

• LFP_reference$clone()

LFP_reference$@marshal()

Internal method

Usage

LFP_reference$@marshal(...)

Arguments

LFP_reference$@unmarshal()

Internal method

Usage

LFP_reference$@unmarshal(object)

Arguments

LFP_reference$print()

print reference summary

Usage

LFP_reference$print()

LFP_reference$set_reference()

set reference for current electrode

Usage

LFP_reference$set_reference(reference)

Arguments

LFP_reference$new()

constructor

Usage

LFP_reference$new(subject, number, quiet = FALSE)

Arguments

LFP_reference$.load_noref_wavelet()

load non-referenced wavelet coefficients (internally used)

Usage

LFP_reference$.load_noref_wavelet(reload = FALSE)

Arguments

Returns

if the reference number if NULL or 'noref', then returns 0, otherwise returns a FileArray-class

LFP_reference$.load_noref_voltage()

load non-referenced voltage (internally used)

Usage

LFP_reference$.load_noref_voltage(reload = FALSE)

Arguments

LFP_reference$.load_wavelet()

load referenced wavelet coefficients (internally used)

Usage

LFP_reference$.load_wavelet(
  type = c("power", "phase", "wavelet-coefficient"),
  reload = FALSE
)

Arguments

LFP_reference$.load_voltage()

load referenced voltage (internally used)

Usage

LFP_reference$.load_voltage(reload = FALSE)

Arguments

LFP_reference$load_data_with_epochs()

method to load electrode data

Usage

LFP_reference$load_data_with_epochs(
  type = c("power", "phase", "voltage", "wavelet-coefficient", "raw-voltage")
)

Arguments

LFP_reference$load_data_with_blocks()

load electrode block-wise data (with reference), useful when epoch is absent

Usage

LFP_reference$load_data_with_blocks(
  blocks,
  type = c("power", "phase", "voltage", "wavelet-coefficient"),
  simplify = TRUE
)

Arguments

Returns

If simplify is enabled, and only one block is loaded, then the result will be a vector (type="voltage") or a matrix (others), otherwise the result will be a named list where the names are the blocks.

LFP_reference$load_dim_with_blocks()

get expected dimension information for block-based loader

Usage

LFP_reference$load_dim_with_blocks(
  blocks,
  type = c("power", "phase", "voltage", "wavelet-coefficient", "raw-voltage")
)

Arguments

LFP_reference$clear_cache()

method to clear cache on hard drive

Usage

LFP_reference$clear_cache(...)

Arguments

LFP_reference$clear_memory()

method to clear memory

Usage

LFP_reference$clear_memory(...)

Arguments

LFP_reference$clone()

The objects of this class are cloneable with this method.

Usage

LFP_reference$clone(deep = FALSE)

Arguments

Examples

# Download subject demo/DemoSubject
if( has_rave_subject("demo/DemoSubject") ) {


subject <- as_rave_subject("demo/DemoSubject")

# Electrode 14 as reference electrode (Bipolar referencing)
e <- new_reference(subject = subject, number = "ref_14",
                   signal_type = "LFP")

# Reference "ref_13-16,24" (CAR or white-matter reference)
ref <- new_reference(subject = subject, number = "ref_13-16,24",
                     signal_type = "LFP")
ref

# Set epoch
e$set_epoch(epoch = 'auditory_onset')

# Set loading window
e$trial_intervals <- list(c(-1, 2))

# Preview
print(e)

# Now epoch power
power <- e$load_data_with_epochs("power")
names(dimnames(power))

# Subset power
subset(power, Time ~ Time < 0, Electrode ~ Electrode == 14)

# clear cache on hard disk
e$clear_cache()

}

Abstract definition of electrode class in 'RAVE'

Description

This class is not intended for direct use. Please create new child classes and implement some key methods.

Super class

ravepipeline::RAVESerializable -> RAVEAbstarctElectrode

Public fields

Active bindings

Methods

Public methods

• RAVEAbstarctElectrode$new()

• RAVEAbstarctElectrode$set_reference()

• RAVEAbstarctElectrode$set_epoch()

• RAVEAbstarctElectrode$clear_cache()

• RAVEAbstarctElectrode$clear_memory()

• RAVEAbstarctElectrode$load_data_with_epochs()

• RAVEAbstarctElectrode$load_data()

• RAVEAbstarctElectrode$load_dimnames_with_epochs()

• RAVEAbstarctElectrode$load_data_with_blocks()

• RAVEAbstarctElectrode$load_blocks()

• RAVEAbstarctElectrode$load_dim_with_blocks()

• RAVEAbstarctElectrode$clone()

RAVEAbstarctElectrode$new()

constructor

Usage

RAVEAbstarctElectrode$new(subject, number, quiet = FALSE)

Arguments

RAVEAbstarctElectrode$set_reference()

set reference for instance

Usage

RAVEAbstarctElectrode$set_reference(reference)

Arguments

RAVEAbstarctElectrode$set_epoch()

set epoch instance for the electrode

Usage

RAVEAbstarctElectrode$set_epoch(epoch, stitch_events = NULL)

Arguments

RAVEAbstarctElectrode$clear_cache()

method to clear cache on hard drive

Usage

RAVEAbstarctElectrode$clear_cache(...)

Arguments

RAVEAbstarctElectrode$clear_memory()

method to clear memory

Usage

RAVEAbstarctElectrode$clear_memory(...)

Arguments

RAVEAbstarctElectrode$load_data_with_epochs()

method to load electrode data

Usage

RAVEAbstarctElectrode$load_data_with_epochs(type)

Arguments

RAVEAbstarctElectrode$load_data()

alias of load_data_with_epochs for legacy code

Usage

RAVEAbstarctElectrode$load_data(type)

Arguments

RAVEAbstarctElectrode$load_dimnames_with_epochs()

get expected dimension names

Usage

RAVEAbstarctElectrode$load_dimnames_with_epochs(type)

Arguments

RAVEAbstarctElectrode$load_data_with_blocks()

load electrode block-wise data (with reference), useful when epoch is absent

Usage

RAVEAbstarctElectrode$load_data_with_blocks(blocks, type, simplify = TRUE)

Arguments

Returns

If simplify is enabled, and only one block is loaded, then the result will be a vector (type="voltage") or a matrix (others), otherwise the result will be a named list where the names are the blocks.

RAVEAbstarctElectrode$load_blocks()

alias of load_data_with_blocks for legacy code

Usage

RAVEAbstarctElectrode$load_blocks(blocks, type, simplify = TRUE)

Arguments

RAVEAbstarctElectrode$load_dim_with_blocks()

get expected dimension information for block-based loader

Usage

RAVEAbstarctElectrode$load_dim_with_blocks(blocks, type)

Arguments

RAVEAbstarctElectrode$clone()

The objects of this class are cloneable with this method.

Usage

RAVEAbstarctElectrode$clone(deep = FALSE)

Arguments

Examples

if( has_rave_subject("demo/DemoSubject") ) {

# To run this example, please download demo subject (~700 MB) from
# https://github.com/beauchamplab/rave/releases/tag/v0.1.9-beta

generator <- RAVEAbstarctElectrode

# load demo subject electrode 14
e <- generator$new("demo/DemoSubject", number = 14)

# set epoch
e$subject$epoch_names
e$set_epoch("auditory_onset")
head(e$epoch$table)

# set epoch range (-1 to 2 seconds relative to onset)
e$trial_intervals <- c(-1,2)
# or to set multiple ranges
e$trial_intervals <- list(c(-2,-1), c(0, 2))

# set reference
e$subject$reference_names
reference_table <- e$subject$meta_data(
  meta_type = "reference",
  meta_name = "default")
ref_name <- subset(reference_table, Electrode == 14)[["Reference"]]

# the reference is CAR type, mean of electrode 13-16,24
ref_name

# load & set reference
ref <- generator$new(e$subject, ref_name)
e$set_reference(ref)

}

Definition for epoch class

Description

Trial epoch, contains the following information: Block experiment block/session string; Time trial onset within that block; Trial trial number; Condition trial condition. Other optional columns are Event_xxx (starts with "Event"). Column ExcludedHint (logical, always present; missing or blank values are FALSE) marks trials that analyses may exclude; see exclude_trials and save. An epoch whose name ends with "_OutlierRemoved" is a trimmed copy: marked trials are removed, trials are renumbered from 1, and OriginalTrial holds the trial numbers of the epoch it was generated from.

Super class

ravepipeline::RAVESerializable -> RAVEEpoch

Public fields

Active bindings

Methods

Public methods

• RAVEEpoch$@marshal()

• RAVEEpoch$@unmarshal()

• RAVEEpoch$new()

• RAVEEpoch$trial_at()

• RAVEEpoch$update_table()

• RAVEEpoch$set_trial()

• RAVEEpoch$exclude_trials()

• RAVEEpoch$save()

• RAVEEpoch$get_event_colname()

• RAVEEpoch$get_condition_colname()

• RAVEEpoch$clone()

RAVEEpoch$@marshal()

Internal method

Usage

RAVEEpoch$@marshal(...)

Arguments

RAVEEpoch$@unmarshal()

Internal method

Usage

RAVEEpoch$@unmarshal(object, ...)

Arguments

RAVEEpoch$new()

constructor

Usage

RAVEEpoch$new(subject, name)

Arguments

RAVEEpoch$trial_at()

get ith trial

Usage

RAVEEpoch$trial_at(i, df = TRUE)

Arguments

RAVEEpoch$update_table()

manually update table field

Usage

RAVEEpoch$update_table()

Returns

self$table

RAVEEpoch$set_trial()

set one trial

Usage

RAVEEpoch$set_trial(Block, Time, Trial, Condition, ...)

Arguments

RAVEEpoch$exclude_trials()

Mark trials as excluded through the ExcludedHint column. Nothing is removed: pipelines decide whether to drop marked trials. Use save to write the marks to disk.

Usage

RAVEEpoch$exclude_trials(..., add = TRUE)

Arguments

Returns

The epoch instance, invisibly

RAVEEpoch$save()

Save the epoch to the subject's meta folder. A regular epoch writes epoch_<name>.csv with ExcludedHint (the existing file is renamed to a time-stamped backup first), then rebuilds epoch_<name>_OutlierRemoved.csv: the existing copy is always backed up and removed, and a new one is written when some (not all) trials are marked, without them, with trials renumbered from 1 and OriginalTrial holding the trial numbers of epoch_<name>.csv. An epoch whose name ends with _OutlierRemoved is saved trimmed the same way: its file is backed up and removed, then the unmarked trials are written. Its marked trials, including rows marked by hand in the replaced file, are also marked in the upstream epoch (the name without the suffix) when that epoch exists and the trial still matches by Block and Time; otherwise only the trimmed file is saved.

Usage

RAVEEpoch$save()

Returns

Paths of the written files, invisibly

RAVEEpoch$get_event_colname()

Get epoch column name that represents the desired event

Usage

RAVEEpoch$get_event_colname(
  event = "",
  missing = c("warning", "error", "none")
)

Arguments

Returns

If event is one of "trial onset", "default", "", or NULL, then the result will be "Time" column; if the event is found, then return will be the corresponding event column. When the event is not found and missing is "error", error will be raised; default is to return "Time" column, as it's trial onset and is mandatory.

RAVEEpoch$get_condition_colname()

Get condition column name that represents the desired condition type

Usage

RAVEEpoch$get_condition_colname(
  condition_type = "default",
  missing = c("error", "warning", "none")
)

Arguments

Returns

If condition_type is one of "default", "", or NULL, then the result will be "Condition" column; if the condition type is found, then return will be the corresponding condition type column. When the condition type is not found and missing is "error", error will be raised; default is to return "Condition" column, as it's the default and is mandatory.

RAVEEpoch$clone()

The objects of this class are cloneable with this method.

Usage

RAVEEpoch$clone(deep = FALSE)

Arguments

Examples

# Please download DemoSubject ~700MB from
# https://github.com/beauchamplab/rave/releases/tag/v0.1.9-beta

if(has_rave_subject("demo/DemoSubject")) {

# Load meta/epoch_auditory_onset.csv from subject demo/DemoSubject
epoch <-RAVEEpoch$new(subject = 'demo/DemoSubject',
                      name = 'auditory_onset')

# first several trials
head(epoch$table)

# query specific trial
old_trial1 <- epoch$trial_at(1)

# Create new trial or change existing trial
epoch$set_trial(Block = '008', Time = 10,
                Trial = 1, Condition = 'AknownVmeant')
new_trial1 <- epoch$trial_at(1)

# Compare new and old trial 1
list(old_trial1, new_trial1)

# To get updated trial table, must update first
epoch$update_table()
head(epoch$table)

# Mark trials 1 and 3; pipelines decide whether to drop them
epoch$exclude_trials(1, 3)
epoch$excluded_trials

}

Defines preprocess configurations

Description

R6 class definition

Super class

ravepipeline::RAVESerializable -> RAVEPreprocessSettings

Public fields

Active bindings

Methods

Public methods

• RAVEPreprocessSettings$@marshal()

• RAVEPreprocessSettings$@unmarshal()

• RAVEPreprocessSettings$new()

• RAVEPreprocessSettings$valid()

• RAVEPreprocessSettings$has_raw()

• RAVEPreprocessSettings$set_blocks()

• RAVEPreprocessSettings$get_block_paths()

• RAVEPreprocessSettings$set_electrodes()

• RAVEPreprocessSettings$set_sample_rates()

• RAVEPreprocessSettings$migrate()

• RAVEPreprocessSettings$electrode_info()

• RAVEPreprocessSettings$save()

• RAVEPreprocessSettings$get_compose_weights()

• RAVEPreprocessSettings$clone()

RAVEPreprocessSettings$@marshal()

Internal method

Usage

RAVEPreprocessSettings$@marshal(...)

Arguments

RAVEPreprocessSettings$@unmarshal()

Internal method

Usage

RAVEPreprocessSettings$@unmarshal(object, ...)

Arguments

RAVEPreprocessSettings$new()

constructor

Usage

RAVEPreprocessSettings$new(subject, read_only = TRUE)

Arguments

RAVEPreprocessSettings$valid()

whether configuration is valid or not

Usage

RAVEPreprocessSettings$valid()

RAVEPreprocessSettings$has_raw()

whether raw data folder exists

Usage

RAVEPreprocessSettings$has_raw()

RAVEPreprocessSettings$set_blocks()

set blocks

Usage

RAVEPreprocessSettings$set_blocks(blocks, force = FALSE)

Arguments

RAVEPreprocessSettings$get_block_paths()

get block-related files

Usage

RAVEPreprocessSettings$get_block_paths(
  block,
  force_native = FALSE,
  check = TRUE
)

Arguments

RAVEPreprocessSettings$set_electrodes()

set electrodes

Usage

RAVEPreprocessSettings$set_electrodes(
  electrodes,
  type = SIGNAL_TYPES,
  add = FALSE
)

Arguments

RAVEPreprocessSettings$set_sample_rates()

set sample frequency

Usage

RAVEPreprocessSettings$set_sample_rates(srate, type = SIGNAL_TYPES)

Arguments

RAVEPreprocessSettings$migrate()

convert old format to new formats

Usage

RAVEPreprocessSettings$migrate(force = FALSE)

Arguments

RAVEPreprocessSettings$electrode_info()

get electrode information

Usage

RAVEPreprocessSettings$electrode_info(electrode)

Arguments

Returns

list of electrode type, number, etc.

RAVEPreprocessSettings$save()

save settings to hard disk

Usage

RAVEPreprocessSettings$save()

RAVEPreprocessSettings$get_compose_weights()

get weights of each composed channels

Usage

RAVEPreprocessSettings$get_compose_weights(flat = TRUE)

Arguments

Returns

NULL when no channel is composed. When flat is TRUE, a data frame of weights with the columns composing electrode channel numbers, composed channel number, and corresponding weights; if flat is FALSE, then a weight matrix;

RAVEPreprocessSettings$clone()

The objects of this class are cloneable with this method.

Usage

RAVEPreprocessSettings$clone(deep = FALSE)

Arguments

Examples

# The following example require downloading demo subject (~700 MB) from
# https://github.com/beauchamplab/rave/releases/tag/v0.1.9-beta

if( has_rave_subject("demo/DemoSubject") ) {

conf <- RAVEPreprocessSettings$new(subject = 'demo/DemoSubject')
conf$blocks  # "008" "010" "011" "012"

conf$electrodes   # 5 electrodes

# Electrode 14 information
conf$electrode_info(electrode = 14)

conf$data_imported # All 5 electrodes are imported

conf$data_locked   # Whether block, sample rates should be locked

}

Definition for 'RAVE' project class

Description

See as_rave_project for creating 'RAVE' project class

Super class

ravepipeline::RAVESerializable -> RAVEProject

Active bindings

Methods

Public methods

• RAVEProject$@marshal()

• RAVEProject$@unmarshal()

• RAVEProject$print()

• RAVEProject$format()

• RAVEProject$new()

• RAVEProject$subjects()

• RAVEProject$has_subject()

• RAVEProject$group_path()

• RAVEProject$subject_pipelines()

• RAVEProject$clone()

RAVEProject$@marshal()

Internal method

Usage

RAVEProject$@marshal(...)

Arguments

RAVEProject$@unmarshal()

Internal method

Usage

RAVEProject$@unmarshal(object, ...)

Arguments

RAVEProject$print()

override print method

Usage

RAVEProject$print(...)

Arguments

RAVEProject$format()

override format method

Usage

RAVEProject$format(...)

Arguments

RAVEProject$new()

constructor

Usage

RAVEProject$new(project_name, strict = TRUE, parent_path = NULL)

Arguments

RAVEProject$subjects()

get all imported subjects within project

Usage

RAVEProject$subjects()

Returns

character vector

RAVEProject$has_subject()

whether a specific subject exists in this project

Usage

RAVEProject$has_subject(subject_code)

Arguments

Returns

true or false whether subject is in the project

RAVEProject$group_path()

get group data path for 'RAVE' module

Usage

RAVEProject$group_path(module_id, must_work = FALSE)

Arguments

RAVEProject$subject_pipelines()

list saved pipelines

Usage

RAVEProject$subject_pipelines(
  pipeline_name,
  cache = FALSE,
  check = TRUE,
  all = FALSE
)

Arguments

Returns

A data table of pipeline time-stamps and directories

RAVEProject$clone()

The objects of this class are cloneable with this method.

Usage

RAVEProject$clone(deep = FALSE)

Arguments

Defines 'RAVE' subject class

Description

R6 class definition

Super class

ravepipeline::RAVESerializable -> RAVESubject

Active bindings

Methods

Public methods

• RAVESubject$@marshal()

• RAVESubject$@unmarshal()

• RAVESubject$print()

• RAVESubject$format()

• RAVESubject$new()

• RAVESubject$meta_data()

• RAVESubject$valid_electrodes()

• RAVESubject$initialize_paths()

• RAVESubject$set_default()

• RAVESubject$get_default()

• RAVESubject$get_note_summary()

• RAVESubject$get_epoch()

• RAVESubject$get_reference()

• RAVESubject$get_electrode_table()

• RAVESubject$get_frequency()

• RAVESubject$list_pipelines()

• RAVESubject$load_pipeline()

• RAVESubject$clone()

RAVESubject$@marshal()

Internal method

Usage

RAVESubject$@marshal(...)

Arguments

RAVESubject$@unmarshal()

Internal method

Usage

RAVESubject$@unmarshal(object, ...)

Arguments

RAVESubject$print()

override print method: prints format()

Usage

RAVESubject$print(...)

Arguments

RAVESubject$format()

summary of the subject's data

Usage

RAVESubject$format(...)

Arguments

Returns

A character vector, one element per line

RAVESubject$new()

constructor

Usage

RAVESubject$new(
  project_name,
  subject_code = NULL,
  strict = TRUE,
  parent_path = NULL
)

Arguments

RAVESubject$meta_data()

get subject meta data located in "meta/" folder

Usage

RAVESubject$meta_data(
  meta_type = c("electrodes", "frequencies", "time_points", "epoch", "references"),
  meta_name = "default",
  strict = TRUE
)

Arguments

Returns

data frame

RAVESubject$valid_electrodes()

get valid electrode numbers

Usage

RAVESubject$valid_electrodes(reference_name = NULL, refresh = FALSE)

Arguments

Returns

integer vector of valid electrodes

RAVESubject$initialize_paths()

create subject's directories on hard disk

Usage

RAVESubject$initialize_paths(include_freesurfer = TRUE)

Arguments

RAVESubject$set_default()

set default key-value pair for the subject, used by 'RAVE' modules

Usage

RAVESubject$set_default(key, value, namespace = "default")

Arguments

Returns

The same as value

RAVESubject$get_default()

get default key-value pairs for the subject, used by 'RAVE' modules

Usage

RAVESubject$get_default(
  ...,
  default_if_missing = NULL,
  simplify = TRUE,
  namespace = "default"
)

Arguments

Returns

A named list of key-value pairs, or if one key is specified and simplify=TRUE, then only the value will be returned.

RAVESubject$get_note_summary()

get summary table of all the key-value pairs used by 'RAVE' modules for the subject

Usage

RAVESubject$get_note_summary(namespaces, include_history = FALSE)

Arguments

Returns

A data frame with four columns: 'namespace' for the group name of the entry (entries within the same namespace usually share same module), 'timestamp' for when the entry was registered. 'entry_name' is the name of the entry. If include_history is true, then multiple entries with the same 'entry_name' might appear since the obsolete entries are included. 'entry_value' is the value of the corresponding entry.

RAVESubject$get_epoch()

check and get subject's epoch information

Usage

RAVESubject$get_epoch(
  epoch_name = "default",
  as_table = FALSE,
  trial_starts = 0
)

Arguments

Returns

If as_table is FALSE, then returns as RAVEEpoch instance; otherwise returns epoch table; will raise errors when file is missing or the epoch is invalid.

RAVESubject$get_reference()

check and get subject's reference information

Usage

RAVESubject$get_reference(reference_name, simplify = FALSE)

Arguments

Returns

If simplify is true, returns a vector of reference electrode names, otherwise returns the whole table; will raise errors when file is missing or the reference is invalid.

RAVESubject$get_electrode_table()

check and get subject's electrode table with electrodes that are load-able

Usage

RAVESubject$get_electrode_table(
  electrodes,
  reference_name,
  subset = FALSE,
  simplify = FALSE,
  warn = TRUE
)

Arguments

Returns

If simplify is true, returns a vector of electrodes that are valid (or won't be excluded) under given reference; otherwise returns a table. If subset is true, then the table will be subset and only rows with electrodes to be loaded will be kept.

RAVESubject$get_frequency()

check and get subject's frequency table, time-frequency decomposition is needed.

Usage

RAVESubject$get_frequency(simplify = TRUE)

Arguments

Returns

If simplify is true, returns a vector of frequencies; otherwise returns a table.

RAVESubject$list_pipelines()

list saved pipelines

Usage

RAVESubject$list_pipelines(
  pipeline_name,
  cache = FALSE,
  check = TRUE,
  all = FALSE
)

Arguments

Returns

A table of pipeline registry

RAVESubject$load_pipeline()

load saved pipeline

Usage

RAVESubject$load_pipeline(directory)

Arguments

Returns

A PipelineTools instance

RAVESubject$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubject$clone(deep = FALSE)

Arguments

See Also

load_meta2

'RAVE' class for base repository

Description

The class is for creating child classes, to instantiate the class, please use prepare_subject_bare0 to create base repository.

Super class

ravepipeline::RAVESerializable -> RAVESubjectRepository

Public fields

Active bindings

Methods

Public methods

• RAVESubjectRepository$@get_container()

• RAVESubjectRepository$@marshal()

• RAVESubjectRepository$@unmarshal()

• RAVESubjectRepository$print()

• RAVESubjectRepository$new()

• RAVESubjectRepository$export_matlab()

• RAVESubjectRepository$get_electrode_coordinate()

• RAVESubjectRepository$clone()

RAVESubjectRepository$@get_container()

Internal method, do not use it directly

Usage

RAVESubjectRepository$@get_container()

RAVESubjectRepository$@marshal()

Internal method

Usage

RAVESubjectRepository$@marshal(...)

Arguments

RAVESubjectRepository$@unmarshal()

Internal method

Usage

RAVESubjectRepository$@unmarshal(object, ...)

Arguments

RAVESubjectRepository$print()

User-friendly print method

Usage

RAVESubjectRepository$print()

RAVESubjectRepository$new()

constructor

Usage

RAVESubjectRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  ...,
  auto_exclude = TRUE,
  quiet = TRUE,
  repository_id = NULL,
  strict = TRUE,
  .class = NULL
)

Arguments

RAVESubjectRepository$export_matlab()

Export the repository to 'Matlab' for future analysis

Usage

RAVESubjectRepository$export_matlab(..., verbose = TRUE)

Arguments

Returns

The root directory where the files are stored.

RAVESubjectRepository$get_electrode_coordinate()

Get loaded electrode coordinates by type

Usage

RAVESubjectRepository$get_electrode_coordinate(
  type = "LFP",
  electrodes = KEY_MISSING,
  strict = TRUE
)

Arguments

Returns

Filtered table; see load_meta2 with meta type 'electrodes'. Besides the mandatory columns, the returned table also contains 'LabelPrefix', used by YAEL to store surgical labels to group channels by electrode device; 'LeadChannel' (logical) to indicate whether the channel is a leading channel in this group, typically the inner-most channel; and 'ShortLabel' for short electrode label.

RAVESubjectRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectRepository$clone(deep = FALSE)

Arguments

See Also

prepare_subject_bare0

'RAVE' class for epoch repository - time-frequency phase

Description

The repository inherits link{RAVESubjectEpochTimeFreqBaseRepository}, with epoch trials, and is intended for loading processed and referenced time-frequency coefficients. Use prepare_subject_phase_with_epochs to create an instance.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectEpochRepository -> RAVESubjectEpochTimeFreqBaseRepository -> RAVESubjectEpochPhaseRepository

Active bindings

Methods

Public methods

• RAVESubjectEpochPhaseRepository$@marshal()

• RAVESubjectEpochPhaseRepository$@unmarshal()

• RAVESubjectEpochPhaseRepository$new()

• RAVESubjectEpochPhaseRepository$clone()

RAVESubjectEpochPhaseRepository$@marshal()

Internal method

Usage

RAVESubjectEpochPhaseRepository$@marshal(...)

Arguments

RAVESubjectEpochPhaseRepository$@unmarshal()

Internal method

Usage

RAVESubjectEpochPhaseRepository$@unmarshal(object, ...)

Arguments

RAVESubjectEpochPhaseRepository$new()

constructor

Usage

RAVESubjectEpochPhaseRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  epoch_name = NULL,
  time_windows = NULL,
  stitch_events = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectEpochPhaseRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectEpochPhaseRepository$clone(deep = FALSE)

Arguments

'RAVE' class for epoch repository - time-frequency power

Description

The repository inherits link{RAVESubjectEpochTimeFreqBaseRepository}, with epoch trials, and is intended for loading processed and referenced time-frequency coefficients. Use prepare_subject_power_with_epochs to create an instance.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectEpochRepository -> RAVESubjectEpochTimeFreqBaseRepository -> RAVESubjectEpochPowerRepository

Active bindings

Methods

Public methods

• RAVESubjectEpochPowerRepository$@marshal()

• RAVESubjectEpochPowerRepository$@unmarshal()

• RAVESubjectEpochPowerRepository$new()

• RAVESubjectEpochPowerRepository$clone()

RAVESubjectEpochPowerRepository$@marshal()

Internal method

Usage

RAVESubjectEpochPowerRepository$@marshal(...)

Arguments

RAVESubjectEpochPowerRepository$@unmarshal()

Internal method

Usage

RAVESubjectEpochPowerRepository$@unmarshal(object, ...)

Arguments

RAVESubjectEpochPowerRepository$new()

constructor

Usage

RAVESubjectEpochPowerRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  epoch_name = NULL,
  time_windows = NULL,
  stitch_events = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectEpochPowerRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectEpochPowerRepository$clone(deep = FALSE)

Arguments

'RAVE' class for epoch repository - raw voltage

Description

The repository inherits link{RAVESubjectEpochRepository}, with epoch trials, and is intended for loading raw (without any processing or reference) voltage signals. Use prepare_subject_raw_voltage_with_epochs to create an instance.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectEpochRepository -> RAVESubjectEpochRawVoltageRepository

Active bindings

Methods

Public methods

• RAVESubjectEpochRawVoltageRepository$@marshal()

• RAVESubjectEpochRawVoltageRepository$@unmarshal()

• RAVESubjectEpochRawVoltageRepository$new()

• RAVESubjectEpochRawVoltageRepository$mount_data()

• RAVESubjectEpochRawVoltageRepository$clone()

RAVESubjectEpochRawVoltageRepository$@marshal()

Internal method

Usage

RAVESubjectEpochRawVoltageRepository$@marshal(...)

Arguments

RAVESubjectEpochRawVoltageRepository$@unmarshal()

Internal method

Usage

RAVESubjectEpochRawVoltageRepository$@unmarshal(object, ...)

Arguments

RAVESubjectEpochRawVoltageRepository$new()

constructor

Usage

RAVESubjectEpochRawVoltageRepository$new(
  subject,
  electrodes = NULL,
  epoch_name = NULL,
  time_windows = NULL,
  stitch_events = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  reference_name = "noref",
  .class = NULL
)

Arguments

RAVESubjectEpochRawVoltageRepository$mount_data()

function to mount raw voltage signals

Usage

RAVESubjectEpochRawVoltageRepository$mount_data(
  ...,
  force = TRUE,
  electrodes = NULL
)

Arguments

RAVESubjectEpochRawVoltageRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectEpochRawVoltageRepository$clone(deep = FALSE)

Arguments

'RAVE' class for epoch repository

Description

Compared to RAVESubjectBaseRepository, this repository requires epoch information. please use prepare_subject_with_epochs to instantiate this repository.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectEpochRepository

Active bindings

Methods

Public methods

• RAVESubjectEpochRepository$@marshal()

• RAVESubjectEpochRepository$@unmarshal()

• RAVESubjectEpochRepository$new()

• RAVESubjectEpochRepository$export_matlab()

• RAVESubjectEpochRepository$set_epoch()

• RAVESubjectEpochRepository$mount_data()

• RAVESubjectEpochRepository$get_container()

• RAVESubjectEpochRepository$clone()

RAVESubjectEpochRepository$@marshal()

Internal method

Usage

RAVESubjectEpochRepository$@marshal(...)

Arguments

RAVESubjectEpochRepository$@unmarshal()

Internal method

Usage

RAVESubjectEpochRepository$@unmarshal(object, ...)

Arguments

RAVESubjectEpochRepository$new()

constructor

Usage

RAVESubjectEpochRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  epoch_name = NULL,
  time_windows = NULL,
  stitch_events = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectEpochRepository$export_matlab()

Export the repository to 'Matlab' for future analysis

Usage

RAVESubjectEpochRepository$export_matlab(..., verbose = TRUE)

Arguments

Returns

The root directory where the files are stored.

RAVESubjectEpochRepository$set_epoch()

change trial epoch profiles

Usage

RAVESubjectEpochRepository$set_epoch(epoch_name, stitch_events = NULL)

Arguments

RAVESubjectEpochRepository$mount_data()

function to mount data, not doing anything in this class, but may be used by child classes

Usage

RAVESubjectEpochRepository$mount_data(..., force = TRUE, electrodes = NULL)

Arguments

RAVESubjectEpochRepository$get_container()

get container where loaded data are stored

Usage

RAVESubjectEpochRepository$get_container(force = FALSE, ...)

Arguments

Returns

A named map, typically with data arrays, shape/dimension information

RAVESubjectEpochRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectEpochRepository$clone(deep = FALSE)

Arguments

See Also

prepare_subject_with_epochs

'RAVE' class for epoch repository - time-frequency (internal)

Description

The repository inherits link{RAVESubjectEpochRepository}, with epoch trials, and is intended for loading processed and referenced time-frequency coefficients.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectEpochRepository -> RAVESubjectEpochTimeFreqBaseRepository

Active bindings

Methods

Public methods

• RAVESubjectEpochTimeFreqBaseRepository$@marshal()

• RAVESubjectEpochTimeFreqBaseRepository$@unmarshal()

• RAVESubjectEpochTimeFreqBaseRepository$new()

• RAVESubjectEpochTimeFreqBaseRepository$mount_data()

• RAVESubjectEpochTimeFreqBaseRepository$clone()

RAVESubjectEpochTimeFreqBaseRepository$@marshal()

Internal method

Usage

RAVESubjectEpochTimeFreqBaseRepository$@marshal(...)

Arguments

RAVESubjectEpochTimeFreqBaseRepository$@unmarshal()

Internal method

Usage

RAVESubjectEpochTimeFreqBaseRepository$@unmarshal(object, ...)

Arguments

RAVESubjectEpochTimeFreqBaseRepository$new()

constructor

Usage

RAVESubjectEpochTimeFreqBaseRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  epoch_name = NULL,
  time_windows = NULL,
  stitch_events = NULL,
  data_type = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectEpochTimeFreqBaseRepository$mount_data()

function to mount processed and referenced spectrogram

Usage

RAVESubjectEpochTimeFreqBaseRepository$mount_data(
  ...,
  force = TRUE,
  electrodes = NULL
)

Arguments

RAVESubjectEpochTimeFreqBaseRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectEpochTimeFreqBaseRepository$clone(deep = FALSE)

Arguments

'RAVE' class for epoch repository - time-frequency

Description

The repository inherits link{RAVESubjectEpochTimeFreqBaseRepository}, with epoch trials, and is intended for loading processed and referenced time-frequency coefficients. Use prepare_subject_time_frequency_coefficients_with_epochs to create an instance.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectEpochRepository -> RAVESubjectEpochTimeFreqBaseRepository -> RAVESubjectEpochTimeFreqCoefRepository

Active bindings

Methods

Public methods

• RAVESubjectEpochTimeFreqCoefRepository$@marshal()

• RAVESubjectEpochTimeFreqCoefRepository$@unmarshal()

• RAVESubjectEpochTimeFreqCoefRepository$new()

• RAVESubjectEpochTimeFreqCoefRepository$clone()

RAVESubjectEpochTimeFreqCoefRepository$@marshal()

Internal method

Usage

RAVESubjectEpochTimeFreqCoefRepository$@marshal(...)

Arguments

RAVESubjectEpochTimeFreqCoefRepository$@unmarshal()

Internal method

Usage

RAVESubjectEpochTimeFreqCoefRepository$@unmarshal(object, ...)

Arguments

RAVESubjectEpochTimeFreqCoefRepository$new()

constructor

Usage

RAVESubjectEpochTimeFreqCoefRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  epoch_name = NULL,
  time_windows = NULL,
  stitch_events = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectEpochTimeFreqCoefRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectEpochTimeFreqCoefRepository$clone(deep = FALSE)

Arguments

'RAVE' class for epoch repository - voltage

Description

The repository inherits link{RAVESubjectEpochRepository}, with epoch trials, and is intended for loading processed and referenced voltage signals. Use prepare_subject_voltage_with_epochs to create an instance.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectEpochRepository -> RAVESubjectEpochVoltageRepository

Active bindings

Methods

Public methods

• RAVESubjectEpochVoltageRepository$@marshal()

• RAVESubjectEpochVoltageRepository$@unmarshal()

• RAVESubjectEpochVoltageRepository$new()

• RAVESubjectEpochVoltageRepository$mount_data()

• RAVESubjectEpochVoltageRepository$clone()

RAVESubjectEpochVoltageRepository$@marshal()

Internal method

Usage

RAVESubjectEpochVoltageRepository$@marshal(...)

Arguments

RAVESubjectEpochVoltageRepository$@unmarshal()

Internal method

Usage

RAVESubjectEpochVoltageRepository$@unmarshal(object, ...)

Arguments

RAVESubjectEpochVoltageRepository$new()

constructor

Usage

RAVESubjectEpochVoltageRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  epoch_name = NULL,
  time_windows = NULL,
  stitch_events = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectEpochVoltageRepository$mount_data()

function to mount referenced voltage signals

Usage

RAVESubjectEpochVoltageRepository$mount_data(
  ...,
  force = TRUE,
  electrodes = NULL
)

Arguments

RAVESubjectEpochVoltageRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectEpochVoltageRepository$clone(deep = FALSE)

Arguments

'RAVE' class for loading time-frequency phase components

Description

Loads time-frequency phase

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectRecordingBlockRepository -> RAVESubjectRecordingBlockTimeFreqBaseRepository -> RAVESubjectRecordingBlockPhaseRepository

Active bindings

Methods

Public methods

• RAVESubjectRecordingBlockPhaseRepository$@marshal()

• RAVESubjectRecordingBlockPhaseRepository$@unmarshal()

• RAVESubjectRecordingBlockPhaseRepository$new()

• RAVESubjectRecordingBlockPhaseRepository$clone()

RAVESubjectRecordingBlockPhaseRepository$@marshal()

Internal method

Usage

RAVESubjectRecordingBlockPhaseRepository$@marshal(...)

Arguments

RAVESubjectRecordingBlockPhaseRepository$@unmarshal()

Internal method

Usage

RAVESubjectRecordingBlockPhaseRepository$@unmarshal(object, ...)

Arguments

RAVESubjectRecordingBlockPhaseRepository$new()

constructor

Usage

RAVESubjectRecordingBlockPhaseRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  blocks = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectRecordingBlockPhaseRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectRecordingBlockPhaseRepository$clone(deep = FALSE)

Arguments

See Also

prepare_subject_phase_with_blocks

'RAVE' class for loading time-frequency power components

Description

Loads time-frequency power

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectRecordingBlockRepository -> RAVESubjectRecordingBlockTimeFreqBaseRepository -> RAVESubjectRecordingBlockPowerRepository

Active bindings

Methods

Public methods

• RAVESubjectRecordingBlockPowerRepository$@marshal()

• RAVESubjectRecordingBlockPowerRepository$@unmarshal()

• RAVESubjectRecordingBlockPowerRepository$new()

• RAVESubjectRecordingBlockPowerRepository$clone()

RAVESubjectRecordingBlockPowerRepository$@marshal()

Internal method

Usage

RAVESubjectRecordingBlockPowerRepository$@marshal(...)

Arguments

RAVESubjectRecordingBlockPowerRepository$@unmarshal()

Internal method

Usage

RAVESubjectRecordingBlockPowerRepository$@unmarshal(object, ...)

Arguments

RAVESubjectRecordingBlockPowerRepository$new()

constructor

Usage

RAVESubjectRecordingBlockPowerRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  blocks = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectRecordingBlockPowerRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectRecordingBlockPowerRepository$clone(deep = FALSE)

Arguments

See Also

prepare_subject_power_with_blocks

'RAVE' class for blocks of voltage repository

Description

Compared to RAVESubjectBaseRepository, this repository loads the entire voltage traces for selected blocks; use prepare_subject_raw_voltage_with_blocks to instantiate this repository.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectRecordingBlockRepository -> RAVESubjectRecordingBlockRawVoltageRepository

Active bindings

Methods

Public methods

• RAVESubjectRecordingBlockRawVoltageRepository$@marshal()

• RAVESubjectRecordingBlockRawVoltageRepository$@unmarshal()

• RAVESubjectRecordingBlockRawVoltageRepository$new()

• RAVESubjectRecordingBlockRawVoltageRepository$mount_data()

• RAVESubjectRecordingBlockRawVoltageRepository$clone()

RAVESubjectRecordingBlockRawVoltageRepository$@marshal()

Internal method

Usage

RAVESubjectRecordingBlockRawVoltageRepository$@marshal(...)

Arguments

RAVESubjectRecordingBlockRawVoltageRepository$@unmarshal()

Internal method

Usage

RAVESubjectRecordingBlockRawVoltageRepository$@unmarshal(object, ...)

Arguments

RAVESubjectRecordingBlockRawVoltageRepository$new()

constructor

Usage

RAVESubjectRecordingBlockRawVoltageRepository$new(
  subject,
  electrodes = NULL,
  reference_name = "noref",
  blocks = NULL,
  downsample = NA,
  ...,
  quiet = TRUE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectRecordingBlockRawVoltageRepository$mount_data()

function to mount data

Usage

RAVESubjectRecordingBlockRawVoltageRepository$mount_data(
  ...,
  force = TRUE,
  electrodes = NULL
)

Arguments

RAVESubjectRecordingBlockRawVoltageRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectRecordingBlockRawVoltageRepository$clone(deep = FALSE)

Arguments

See Also

prepare_subject_raw_voltage_with_blocks

'RAVE' class for loading entire recording block repository

Description

Compared to RAVESubjectBaseRepository, this repository requires specifying block information. please use prepare_subject_with_blocks to instantiate this repository.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectRecordingBlockRepository

Active bindings

Methods

Public methods

• RAVESubjectRecordingBlockRepository$@marshal()

• RAVESubjectRecordingBlockRepository$@unmarshal()

• RAVESubjectRecordingBlockRepository$new()

• RAVESubjectRecordingBlockRepository$export_matlab()

• RAVESubjectRecordingBlockRepository$get_container()

• RAVESubjectRecordingBlockRepository$clone()

RAVESubjectRecordingBlockRepository$@marshal()

Internal method

Usage

RAVESubjectRecordingBlockRepository$@marshal(...)

Arguments

RAVESubjectRecordingBlockRepository$@unmarshal()

Internal method

Usage

RAVESubjectRecordingBlockRepository$@unmarshal(object, ...)

Arguments

RAVESubjectRecordingBlockRepository$new()

constructor

Usage

RAVESubjectRecordingBlockRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  blocks = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectRecordingBlockRepository$export_matlab()

Export the repository to 'Matlab' for future analysis

Usage

RAVESubjectRecordingBlockRepository$export_matlab(..., verbose = TRUE)

Arguments

Returns

The root directory where the files are stored.

RAVESubjectRecordingBlockRepository$get_container()

get container where loaded data are stored

Usage

RAVESubjectRecordingBlockRepository$get_container(force = FALSE, ...)

Arguments

Returns

A named map, typically with data arrays, shape/dimension information

RAVESubjectRecordingBlockRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectRecordingBlockRepository$clone(deep = FALSE)

Arguments

See Also

prepare_subject_with_blocks

'RAVE' class for loading entire block of time-frequency coefficients

Description

'RAVE' class for loading entire block of time-frequency coefficients

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectRecordingBlockRepository -> RAVESubjectRecordingBlockTimeFreqBaseRepository

Active bindings

Methods

Public methods

• RAVESubjectRecordingBlockTimeFreqBaseRepository$@marshal()

• RAVESubjectRecordingBlockTimeFreqBaseRepository$@unmarshal()

• RAVESubjectRecordingBlockTimeFreqBaseRepository$new()

• RAVESubjectRecordingBlockTimeFreqBaseRepository$mount_data()

• RAVESubjectRecordingBlockTimeFreqBaseRepository$clone()

RAVESubjectRecordingBlockTimeFreqBaseRepository$@marshal()

Internal method

Usage

RAVESubjectRecordingBlockTimeFreqBaseRepository$@marshal(...)

Arguments

RAVESubjectRecordingBlockTimeFreqBaseRepository$@unmarshal()

Internal method

Usage

RAVESubjectRecordingBlockTimeFreqBaseRepository$@unmarshal(object, ...)

Arguments

RAVESubjectRecordingBlockTimeFreqBaseRepository$new()

constructor

Usage

RAVESubjectRecordingBlockTimeFreqBaseRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  blocks = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectRecordingBlockTimeFreqBaseRepository$mount_data()

function to mount data

Usage

RAVESubjectRecordingBlockTimeFreqBaseRepository$mount_data(
  ...,
  force = TRUE,
  electrodes = NULL
)

Arguments

RAVESubjectRecordingBlockTimeFreqBaseRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectRecordingBlockTimeFreqBaseRepository$clone(deep = FALSE)

Arguments

See Also

prepare_subject_with_blocks

'RAVE' class for loading time-frequency coefficients

Description

Loads time-frequency coefficients (complex numbers)

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectRecordingBlockRepository -> RAVESubjectRecordingBlockTimeFreqBaseRepository -> RAVESubjectRecordingBlockTimeFreqCoefRepository

Active bindings

Methods

Public methods

• RAVESubjectRecordingBlockTimeFreqCoefRepository$@marshal()

• RAVESubjectRecordingBlockTimeFreqCoefRepository$@unmarshal()

• RAVESubjectRecordingBlockTimeFreqCoefRepository$new()

• RAVESubjectRecordingBlockTimeFreqCoefRepository$clone()

RAVESubjectRecordingBlockTimeFreqCoefRepository$@marshal()

Internal method

Usage

RAVESubjectRecordingBlockTimeFreqCoefRepository$@marshal(...)

Arguments

RAVESubjectRecordingBlockTimeFreqCoefRepository$@unmarshal()

Internal method

Usage

RAVESubjectRecordingBlockTimeFreqCoefRepository$@unmarshal(object, ...)

Arguments

RAVESubjectRecordingBlockTimeFreqCoefRepository$new()

constructor

Usage

RAVESubjectRecordingBlockTimeFreqCoefRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  blocks = NULL,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectRecordingBlockTimeFreqCoefRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectRecordingBlockTimeFreqCoefRepository$clone(deep = FALSE)

Arguments

See Also

prepare_subject_time_frequency_coefficients_with_blocks

'RAVE' class for blocks of voltage repository

Description

Compared to RAVESubjectBaseRepository, this repository loads the entire voltage traces for selected blocks; use prepare_subject_voltage_with_blocks to instantiate this repository.

Super classes

ravepipeline::RAVESerializable -> RAVESubjectRepository -> RAVESubjectRecordingBlockRepository -> RAVESubjectRecordingBlockVoltageRepository

Active bindings

Methods

Public methods

• RAVESubjectRecordingBlockVoltageRepository$@marshal()

• RAVESubjectRecordingBlockVoltageRepository$@unmarshal()

• RAVESubjectRecordingBlockVoltageRepository$new()

• RAVESubjectRecordingBlockVoltageRepository$mount_data()

• RAVESubjectRecordingBlockVoltageRepository$clone()

RAVESubjectRecordingBlockVoltageRepository$@marshal()

Internal method

Usage

RAVESubjectRecordingBlockVoltageRepository$@marshal(...)

Arguments

RAVESubjectRecordingBlockVoltageRepository$@unmarshal()

Internal method

Usage

RAVESubjectRecordingBlockVoltageRepository$@unmarshal(object, ...)

Arguments

RAVESubjectRecordingBlockVoltageRepository$new()

constructor

Usage

RAVESubjectRecordingBlockVoltageRepository$new(
  subject,
  electrodes = NULL,
  reference_name = NULL,
  blocks = NULL,
  downsample = NA,
  ...,
  quiet = FALSE,
  repository_id = NULL,
  strict = TRUE,
  lazy_load = FALSE,
  .class = NULL
)

Arguments

RAVESubjectRecordingBlockVoltageRepository$mount_data()

function to mount data

Usage

RAVESubjectRecordingBlockVoltageRepository$mount_data(
  ...,
  force = TRUE,
  electrodes = NULL
)

Arguments

RAVESubjectRecordingBlockVoltageRepository$clone()

The objects of this class are cloneable with this method.

Usage

RAVESubjectRecordingBlockVoltageRepository$clone(deep = FALSE)

Arguments

See Also

prepare_subject_voltage_with_blocks

Class definition for micro-wire spike channels

Description

Class definition for micro-wire spike channels

Super classes

ravepipeline::RAVESerializable -> RAVEAbstarctElectrode -> Spike_electrode

Active bindings

Methods

Public methods

• Spike_electrode$@marshal()

• Spike_electrode$@unmarshal()

• Spike_electrode$print()

• Spike_electrode$set_reference()

• Spike_electrode$new()

• Spike_electrode$.load_noref_voltage()

• Spike_electrode$.load_raw_voltage()

• Spike_electrode$load_data_with_epochs()

• Spike_electrode$load_dimnames_with_epochs()

• Spike_electrode$load_data_with_blocks()

• Spike_electrode$load_dim_with_blocks()

• Spike_electrode$clear_cache()

• Spike_electrode$clear_memory()

• Spike_electrode$clone()

Spike_electrode$@marshal()

Internal method

Usage

Spike_electrode$@marshal(...)

Arguments

Spike_electrode$@unmarshal()

Internal method

Usage

Spike_electrode$@unmarshal(object)

Arguments

Spike_electrode$print()

print electrode summary

Usage

Spike_electrode$print()

Spike_electrode$set_reference()

set reference for current electrode

Usage

Spike_electrode$set_reference(reference)

Arguments

Spike_electrode$new()

constructor

Usage

Spike_electrode$new(subject, number, quiet = FALSE)

Arguments

Spike_electrode$.load_noref_voltage()

load non-referenced voltage (internally used)

Usage

Spike_electrode$.load_noref_voltage(reload = FALSE)

Arguments

Spike_electrode$.load_raw_voltage()

load raw voltage (no process)

Usage

Spike_electrode$.load_raw_voltage(reload = FALSE)

Arguments

Spike_electrode$load_data_with_epochs()

method to load electrode data

Usage

Spike_electrode$load_data_with_epochs(type = c("raw-voltage", "voltage"))

Arguments

Spike_electrode$load_dimnames_with_epochs()

get expected dimension names

Usage

Spike_electrode$load_dimnames_with_epochs(type = c("raw-voltage", "voltage"))

Arguments

Spike_electrode$load_data_with_blocks()

load electrode block-wise data (with no reference), useful when epoch is absent

Usage

Spike_electrode$load_data_with_blocks(
  blocks,
  type = c("raw-voltage", "voltage"),
  simplify = TRUE
)

Arguments

Returns

If simplify is enabled, and only one block is loaded, then the result will be a vector (type="voltage") or a matrix (others), otherwise the result will be a named list where the names are the blocks.

Spike_electrode$load_dim_with_blocks()

get expected dimension information for block-based loader

Usage

Spike_electrode$load_dim_with_blocks(
  blocks,
  type = c("raw-voltage", "voltage")
)

Arguments

Spike_electrode$clear_cache()

method to clear cache on hard drive

Usage

Spike_electrode$clear_cache(...)

Arguments

Spike_electrode$clear_memory()

method to clear memory

Usage

Spike_electrode$clear_memory(...)

Arguments

Spike_electrode$clone()

The objects of this class are cloneable with this method.

Usage

Spike_electrode$clone(deep = FALSE)

Arguments

Class definition of the native ⁠YAEL⁠ image pipeline

Description

Rigid registration across multiple types of images, non-linear normalization from the native brain to common templates, and mapping of template atlases or regions of interest back to the native brain, without 'Python'. The class has the same methods, arguments and active fields as YAELProcess and writes the same files (names, folders, ⁠'ANTs'⁠-compatible .mat and warp files, ⁠'JSON'⁠ logs), so the results of one class can be read by the other. The registrations, bias-field correction and tissue segmentation come from ravetools. See examples at as_yael_process (with engine = "native") and yael_preprocess_native.

Details

Differences from YAELProcess and the rpyANTs pipeline behind it:

• There is no deep_atropos: argument use_antspynet of map_to_template is ignored, and the tissue segmentation with the template priors (the ⁠Atropos⁠ branch) always runs.

• The non-linear stage uses the local cross-correlation for every image (ravetools has no non-linear mutual information), also when an initial ⁠affine⁠ transform is given.

• Algorithms: ravetools runs a greedy ⁠SyN⁠ with a single field and a fixed-point inverse; its linear stages use an automatic step size, random (⁠Bernoulli⁠) sampling and no histogram matching, and its ⁠affine⁠ registration starts with a rigid pass. The smoothing of the ⁠SyN⁠ update field takes the rpyANTs values (3 for the initial registration, 3.5 for the final one) as a ⁠Gaussian⁠ standard deviation in voxels, whereas ⁠ANTs⁠ reads them as a variance, so the native update field is smoothed more. These values hold for 1 mm templates; for templates with more voxels per brain they are multiplied by the cube root of the ratio of brain voxels, rounded to a half (2 for the 0.5 mm 'mni_icbm152_nlin_asym_09b' and 'mni_icbm152_nlin_sym_09b', 1.5 for the 0.25 mm macaque template): with the 1 mm values, the greedy update folded the deformation in about 1.5 percent of the brain on 'mni_icbm152_nlin_asym_09b'. The share of the template brain mask where the final deformation folds (is not one-to-one) is logged, with a warning above 1 percent. The initial registration, which places the template brain mask and the tissue priors, always goes to the 1 mm 'mni_icbm152_nlin_asym_09a' (see the brain extraction below), whereas rpyANTs registers to the template of the normalization.

• The quick three-class segmentation that finds the white matter for the intensity normalization runs on the raw image, as in rpyANTs; when a few extreme intensities inside the brain leave one of its classes empty (⁠Atropos⁠ keeps going, ravetools stops), it is run again with the intensities clipped at their 99.9 percent quantile inside the brain (then at the 99 percent quantile).

• Brain extraction (yael_brain_extract): the brain mask of 'mni_icbm152_nlin_asym_09a', mapped to the native image by the initial registration whatever the template of the normalization, is adjusted to the subject, as in ⁠antsBrainExtraction.sh⁠, on the image corrected by ⁠N4⁠ without intensity truncation. A three-class segmentation of the mask grown by 2 mm finds the largest connected white and gray matter; an erosion, the largest component, a dilation, hole filling and a closing cut what hangs on the brain by a thread, and the mapped mask is added back. Then, as in the watershed of 'FreeSurfer', the gray and white matter that dark voxels (⁠CSF⁠ or bone) cut off from the brain, such as skull marrow, ⁠dura⁠ or ⁠scalp⁠, leaves the mask, also where the mapped mask held it, which ⁠antsBrainExtraction.sh⁠ keeps whole. The thin strands this can leave (such as marrow as dark as gray matter) go too: the part of the mask that survives an erosion by 2 mm, grown back by 3 mm and kept inside the mask, holds the brain but not what is thinner than about 4 mm and reaches more than about 1 mm out. The distances are millimeters along each axis of the image, so they hold on thick slices. The result replaces the mapped mask in the tissue segmentation (whose priors also come from that template), in the final registration and its final brain mask and image (brainmask2.nii.gz, brain2.nii.gz), and in construct_ants_folder_from_template; the files of the extraction in the stage folder of the normalization are reused when all of them are there. The rpyANTs engine uses a network mask from deep_atropos for the registration when 'antspynet' is available, and always saves the mapped mask. The mapped mask is kept, with a warning, when the segmentation fails or the volume changes by more than 20 percent.

• White-matter artifacts: the brain mask can still hold skull marrow that touches the brain with no dark voxel between, which the tissue segmentation labels as white matter and the final registration would pull into the brain. Each white-matter voxel casts one ray away from the center of the white matter; when the ray misses the smoothed outer surface of the gray matter and the cerebellum (ravetools::mris_outer_surface), the voxel is taken to lie outside the brain. These voxels, dilated by two voxels, are left out of the white-matter channel, and those labeled white matter also leave the brain mask and the brain image of the final registration; the cone below the center of the white matter, which holds the brain stem, is kept, and the removed volume is logged. The tissue classes keep the order of their priors; when the median intensities of the ⁠CSF⁠, gray-matter and white-matter classes do not increase, a warning is given and nothing is left out.

• Grids: additional images are resampled onto the grid of the native 'T1w' image, and left out (with a warning) when they cover less than 95 percent of the brain mask; template tissue priors are resampled onto the grid of the template 'T1' image; the outermost voxel layer of the stored warp fields has no displacement.

• The template brain mask is made binary (this matters for 'fsaverage', whose mask holds intensities); a tissue class whose prior is empty inside the brain is left out of the segmentation (with a warning) instead of failing.

• Outputs: transform_image_from_template and transform_image_to_template return ieegio_volume objects; only nearest-neighbor and linear (⁠trilinear⁠) interpolation are available, and interpolator = "auto" follows its documented rule (YAELProcess uses nearest-neighbor); the queries never create folders; set_input_image reads the new image before it removes the old one; atlases are saved as ⁠float32⁠ as with ⁠'ANTs'⁠, and the ⁠'NIfTI'⁠ data types of other images are chosen by ieegio; normalization results are replaced together, after the new ones are complete, and stale ants<K> transforms of earlier layouts are removed; nothing is written into the template folders.

• Streamlines: ieegio reads and writes ⁠VTK⁠ files through 'Python', so generate_streamlines_from_template skips ⁠VTK⁠ inputs (with a warning) and refuses format = "vtk"; it also refuses format = "tt" and saves ⁠TT⁠ inputs as ⁠TCK⁠ files, since ieegio cannot write ⁠TT⁠ files.

Super class

ravepipeline::RAVESerializable -> YAELNativeProcess

Active bindings

Methods

Public methods

• YAELNativeProcess$@marshal()

• YAELNativeProcess$@unmarshal()

• YAELNativeProcess$new()

• YAELNativeProcess$set_input_image()

• YAELNativeProcess$get_input_image()

• YAELNativeProcess$get_subject()

• YAELNativeProcess$register_to_T1w()

• YAELNativeProcess$get_native_mapping()

• YAELNativeProcess$map_to_template()

• YAELNativeProcess$get_template_mapping()

• YAELNativeProcess$transform_image_from_template()

• YAELNativeProcess$transform_image_to_template()

• YAELNativeProcess$generate_atlas_from_template()

• YAELNativeProcess$generate_streamlines_from_template()

• YAELNativeProcess$transform_points_to_template()

• YAELNativeProcess$transform_points_from_template()

• YAELNativeProcess$write_talairach_xfm()

• YAELNativeProcess$construct_ants_folder_from_template()

• YAELNativeProcess$get_brain()

• YAELNativeProcess$clone()

YAELNativeProcess$@marshal()

Internal method

Usage

YAELNativeProcess$@marshal(...)

Arguments

YAELNativeProcess$@unmarshal()

Internal method

Usage

YAELNativeProcess$@unmarshal(object, ...)

Arguments

YAELNativeProcess$new()

Constructor to instantiate the class

Usage

YAELNativeProcess$new(subject, image_types, imaging_path = NULL, ...)

Arguments

YAELNativeProcess$set_input_image()

Set the raw input for different image types

Usage

YAELNativeProcess$set_input_image(
  path,
  type = YAEL_IMAGE_TYPES,
  overwrite = FALSE,
  on_error = c("warning", "error", "ignore")
)

Arguments

Returns

whether the image has been set (or replaced)

YAELNativeProcess$get_input_image()

Get image path

Usage

YAELNativeProcess$get_input_image(type = YAEL_IMAGE_TYPES)

Arguments

Returns

Absolute path if the image, or NULL if missing

YAELNativeProcess$get_subject()

Get 'RAVE' subject instance

Usage

YAELNativeProcess$get_subject(..., strict = FALSE)

Arguments

Returns

'RAVE' subject instance

YAELNativeProcess$register_to_T1w()

Register other images to 'T1' weighted 'MRI' with two rigid passes (mutual information)

Usage

YAELNativeProcess$register_to_T1w(
  image_type = "CT",
  reverse = FALSE,
  verbose = TRUE
)

Arguments

Returns

Nothing

YAELNativeProcess$get_native_mapping()

Get the mapping configurations used by register_to_T1w

Usage

YAELNativeProcess$get_native_mapping(
  image_type = YAEL_IMAGE_TYPES,
  relative = FALSE
)

Arguments

Returns

A list of moving and fixing images, with rigid transformations from different formats; mappings is empty before the image is registered. No folder is created.

YAELNativeProcess$map_to_template()

Normalize native brain to 'MNI152' template

Usage

YAELNativeProcess$map_to_template(
  template_name = rpyants_builtin_templates(),
  use_images = c("T1w", "T2w", "T1wContrast", "fGATIR", "preopCT"),
  native_type = "T1w",
  use_antspynet = TRUE,
  verbose = TRUE,
  ...
)

Arguments

Returns

See method get_template_mapping

YAELNativeProcess$get_template_mapping()

Get configurations used for normalization

Usage

YAELNativeProcess$get_template_mapping(
  template_name = rpyants_builtin_templates(),
  native_type = "T1w",
  relative = FALSE
)

Arguments

Returns

A list of input, output images, with forward and inverse transform files (usually two 'Affine' with one displacement field), or NULL if the image is not normalized to the template yet. The transforms of the subject are used; transforms whose subject entity is spelled in another letter case are used if there is only one such spelling, and the transforms of another subject only if they are the only ones and the native image was imported under that subject (with a warning)

YAELNativeProcess$transform_image_from_template()

Apply transform from images (usually an atlas or a region of interest) on template to native space

Usage

YAELNativeProcess$transform_image_from_template(
  template_roi_path,
  template_name = rpyants_builtin_templates(),
  native_type = "T1w",
  interpolator = c("auto", "nearestNeighbor", "linear", "gaussian", "bSpline",
    "cosineWindowedSinc", "welchWindowedSinc", "hammingWindowedSinc",
    "lanczosWindowedSinc", "genericLabel"),
  verbose = TRUE
)

Arguments

Returns

transformed image on the grid of the native image, as an ieegio_volume object

YAELNativeProcess$transform_image_to_template()

Apply transform to images (usually an atlas or a region of interest) from native space to template

Usage

YAELNativeProcess$transform_image_to_template(
  native_roi_path,
  template_name = rpyants_builtin_templates(),
  native_type = "T1w",
  interpolator = c("auto", "nearestNeighbor", "linear", "gaussian", "bSpline",
    "cosineWindowedSinc", "welchWindowedSinc", "hammingWindowedSinc",
    "lanczosWindowedSinc", "genericLabel"),
  verbose = TRUE
)

Arguments

Returns

transformed image on the grid of the template 'T1' image, as an ieegio_volume object

YAELNativeProcess$generate_atlas_from_template()

Generate atlas maps from template and morph to native brain

Usage

YAELNativeProcess$generate_atlas_from_template(
  template_name = rpyants_builtin_templates(),
  atlas_folder = NULL,
  surfaces = NA,
  verbose = TRUE,
  lambda = 0.2,
  degree = 2,
  threshold_lb = 0.5,
  threshold_ub = NA,
  smooth_method = c("implicit", "explicit"),
  max_vertices = 5e+05
)

Arguments

Returns

Paths to the atlas (volume) files under the 'atlases' folder of the working directory

YAELNativeProcess$generate_streamlines_from_template()

Transform streamline tract files from template space to native brain space

Usage

YAELNativeProcess$generate_streamlines_from_template(
  template_name = rpyants_builtin_templates(),
  streamlines_folder = NULL,
  verbose = TRUE,
  format = c("auto", "tck", "trk", "tt", "vtk"),
  native_type = "T1w"
)

Arguments

Returns

Invisibly returns a character vector of the relative paths to the input streamline files that were processed (⁠VTK⁠ files are left out); transformed files are written under fs/streamline/ from the working directory. The points of all files are transformed together; points with missing coordinates are dropped. 'Python' is never started: the files are read and written with the 'Python' support of ieegio disabled.

YAELNativeProcess$transform_points_to_template()

Transform points from native images to template

Usage

YAELNativeProcess$transform_points_to_template(
  native_ras,
  template_name = rpyants_builtin_templates(),
  native_type = "T1w",
  verbose = TRUE
)

Arguments

Returns

A matrix of 3 columns, each row is a transformed points ( invalid rows will be filled with NA)

YAELNativeProcess$transform_points_from_template()

Transform points from template images to native

Usage

YAELNativeProcess$transform_points_from_template(
  template_ras,
  template_name = rpyants_builtin_templates(),
  native_type = "T1w",
  verbose = TRUE
)

Arguments

Returns

A matrix of 3 columns, each row is a transformed points ( invalid rows will be filled with NA)

YAELNativeProcess$write_talairach_xfm()

Write the linear transform 'ants/mri/transforms/talairach.xfm' from native 'T1w' scanner 'RAS' coordinates to 'MNI305' space, using the ⁠affine⁠ part of the normalization created by map_to_template. For templates that are not in 'MNI152' space, the transform maps to the template space instead ('fsaverage' is already in 'MNI305' space). This method is called by construct_ants_folder_from_template.

Usage

YAELNativeProcess$write_talairach_xfm(
  template_name = rpyants_builtin_templates()
)

Arguments

Returns

The path to the transform file, invisibly

YAELNativeProcess$construct_ants_folder_from_template()

Create a reconstruction folder (as an alternative option) that is generated from template brain to facilitate the three-dimensional viewer. Please make sure method map_to_template is called before using this method (or the program will fail). The folder holds the conformed 'mri/T1.mgz', the brain mask of the normalization (yael_brain_extract, read from its stage folder 'tmp/coregister_T1w_with_<template>' when all of its files are there, computed again otherwise; 'mri/brainmask.nii.gz', binary), the bias-corrected image ('mri/nu.nii.gz'), its skull-stripped version scaled to 0 to 255 ('mri/brain.finalsurfs.nii.gz'), and the linear transform 'mri/transforms/talairach.xfm' written by write_talairach_xfm; if that fails, the file is removed and a warning is logged.

Usage

YAELNativeProcess$construct_ants_folder_from_template(
  template_name = rpyants_builtin_templates(),
  add_surfaces = TRUE
)

Arguments

YAELNativeProcess$get_brain()

Get three-dimensional brain model

Usage

YAELNativeProcess$get_brain(
  electrodes = TRUE,
  coord_sys = c("scannerRAS", "tkrRAS", "MNI152", "MNI305"),
  ...
)

Arguments

YAELNativeProcess$clone()

The objects of this class are cloneable with this method.

Usage

YAELNativeProcess$clone(deep = FALSE)

Arguments

Class definition of 'YAEL' image pipeline

Description

Rigid-registration across multiple types of images, non-linear normalization from native brain to common templates, and map template atlas or regions of interest back to native brain. See examples at as_yael_process

Super class

ravepipeline::RAVESerializable -> YAELProcess

Active bindings

Methods

Public methods

• YAELProcess$@marshal()

• YAELProcess$@unmarshal()

• YAELProcess$new()

• YAELProcess$set_input_image()

• YAELProcess$get_input_image()

• YAELProcess$get_subject()

• YAELProcess$register_to_T1w()

• YAELProcess$get_native_mapping()

• YAELProcess$map_to_template()

• YAELProcess$get_template_mapping()

• YAELProcess$transform_image_from_template()

• YAELProcess$transform_image_to_template()

• YAELProcess$generate_atlas_from_template()

• YAELProcess$generate_streamlines_from_template()

• YAELProcess$transform_points_to_template()

• YAELProcess$transform_points_from_template()

• YAELProcess$write_talairach_xfm()

• YAELProcess$construct_ants_folder_from_template()

• YAELProcess$get_brain()

• YAELProcess$clone()