210 lines
6.6 KiB
Rust
210 lines
6.6 KiB
Rust
//! # RustyNeuro Core - Unified Neuroimaging Platform
|
|
//!
|
|
//! A consolidated super-crate that unifies 16 neuroimaging crates (47K LOC) into a single
|
|
//! coherent API. This crate provides GPU-accelerated MEG/EEG/fMRI analysis capabilities
|
|
//! inspired by Brainstorm, FieldTrip, and MNE-Python, built natively in Rust.
|
|
//!
|
|
//! ## Architecture
|
|
//!
|
|
//! This super-crate consolidates the following crates:
|
|
//!
|
|
//! ### Core Functionality (default features)
|
|
//! - `rtx-neuro`: Core data types, channels, events, recordings
|
|
//! - `rtx-neuro-io`: File I/O (EDF, BDF, FIF, CTF, BrainVision, BIDS, NWB)
|
|
//! - `rtx-neuro-signal`: Signal processing (filtering, epoching, time-frequency)
|
|
//!
|
|
//! ### Analysis Modules (optional features)
|
|
//! - `rtx-neuro-forward`: Forward modeling (spherical models, BEM)
|
|
//! - `rtx-neuro-inverse`: Inverse solutions (MNE, dSPM, sLORETA, LCMV)
|
|
//! - `rtx-neuro-connectivity`: Connectivity analysis (coherence, PLV, wPLI, Granger)
|
|
//! - `rtx-neuro-artifacts`: Artifact detection/removal (SSP, ICA)
|
|
//! - `rtx-neuro-stats`: Statistical analysis (cluster permutation tests)
|
|
//! - `rtx-neuro-anatomy`: Anatomical structures (cortical surfaces, parcellations)
|
|
//!
|
|
//! ### Real-time & Streaming (optional features)
|
|
//! - `rtx-neuro-realtime`: Real-time processing pipelines
|
|
//! - `rtx-neuro-lsl`: Lab Streaming Layer integration
|
|
//!
|
|
//! ### Machine Learning Extensions (optional features)
|
|
//! - `rtx-neuro-gnn`: Graph Neural Networks for brain connectivity
|
|
//! - `rtx-neuro-pinn`: Physics-Informed Neural Networks
|
|
//! - `rtx-neuro-fem`: Finite Element Method integration
|
|
//!
|
|
//! ### Database & Storage (optional features)
|
|
//! - `rtx-neuro-db`: Database integration for large datasets
|
|
//!
|
|
//! ## Feature Flags
|
|
//!
|
|
//! - `default`: Core functionality (core, io, signal)
|
|
//! - `core`: Core data types and recording structures
|
|
//! - `io`: File I/O support for neuroimaging formats
|
|
//! - `signal`: Signal processing and filtering
|
|
//! - `forward`: Forward modeling capabilities
|
|
//! - `inverse`: Inverse solution methods
|
|
//! - `connectivity`: Connectivity analysis
|
|
//! - `artifacts`: Artifact detection and removal
|
|
//! - `stats`: Statistical analysis tools
|
|
//! - `anatomy`: Anatomical structure support
|
|
//! - `realtime`: Real-time processing and LSL integration
|
|
//! - `ml`: Machine learning extensions (GNN, PINN, FEM)
|
|
//! - `db`: Database support
|
|
//! - `cuda`: CUDA GPU acceleration
|
|
//! - `metal`: Metal GPU acceleration
|
|
//! - `full`: All features enabled
|
|
//!
|
|
//! ## Quick Start
|
|
//!
|
|
//! ```rust,ignore
|
|
//! use rtx_neuro_core::{NeuroData, Recording};
|
|
//!
|
|
//! // Load an EDF file
|
|
//! #[cfg(feature = "io")]
|
|
//! {
|
|
//! use rtx_neuro_core::io::edf::EdfReader;
|
|
//! let recording = EdfReader::open("data.edf")?;
|
|
//!
|
|
//! // Apply bandpass filter (1-40 Hz)
|
|
//! #[cfg(feature = "signal")]
|
|
//! {
|
|
//! let filtered = recording.filter(1.0, 40.0)?;
|
|
//!
|
|
//! // Create epochs around events
|
|
//! let epochs = filtered.create_epochs(&events, -0.2, 0.5)?;
|
|
//!
|
|
//! // Compute average
|
|
//! let evoked = epochs.average()?;
|
|
//! }
|
|
//! }
|
|
//! ```
|
|
//!
|
|
//! ## Edition 2024 Compliance
|
|
//!
|
|
//! This crate is built with Rust Edition 2024 and follows modern Rust best practices:
|
|
//! - Strict lifetime capture rules for `impl Trait`
|
|
//! - No deprecated patterns or unsafe code (unless absolutely necessary)
|
|
//! - Full error handling with `Result<T, E>` propagation
|
|
//! - Zero-cost abstractions with trait-based design
|
|
|
|
#![warn(missing_docs)]
|
|
|
|
// Core error types (always available)
|
|
pub mod error;
|
|
|
|
// Re-export error types at the crate root
|
|
pub use error::{NeuroError, NeuroResult};
|
|
|
|
// Conditional re-exports based on features
|
|
|
|
// Core module (default feature)
|
|
#[cfg(feature = "core")]
|
|
pub mod core;
|
|
|
|
#[cfg(feature = "core")]
|
|
pub use core::{
|
|
Anatomy, Annotation, Annotations, Channel, ChannelInfo, ChannelType, Condition,
|
|
ElectrodePosition, Epochs, EpochsConfig, Event, EventId, Events, Evoked, GroupAnalysis,
|
|
Montage, MontageType, NeuroData, ProcessingHistory, ProcessingStep, Protocol, ProtocolSettings,
|
|
Recording, RecordingFormat, RecordingInfo, ReferenceScheme, SampleIndex, SampleRate, Subject,
|
|
TimeSeconds, channel, data, epoch, event, montage, protocol, recording,
|
|
};
|
|
|
|
// I/O module (default feature) - now built-in
|
|
#[cfg(feature = "io")]
|
|
pub mod io;
|
|
|
|
// Signal processing module (default feature) - now built-in
|
|
#[cfg(feature = "signal")]
|
|
pub mod signal;
|
|
|
|
// Forward modeling module (optional) - now built-in
|
|
#[cfg(feature = "forward")]
|
|
pub mod forward;
|
|
|
|
// Inverse solutions module (optional) - now built-in
|
|
#[cfg(feature = "inverse")]
|
|
pub mod inverse;
|
|
|
|
// Connectivity analysis module (optional) - now built-in
|
|
#[cfg(feature = "connectivity")]
|
|
pub mod connectivity;
|
|
|
|
// Anatomical structures module (optional) - now built-in
|
|
#[cfg(feature = "anatomy")]
|
|
pub mod anatomy;
|
|
|
|
// Statistical analysis module (optional) - now built-in
|
|
#[cfg(feature = "stats")]
|
|
pub mod stats;
|
|
|
|
// Artifact processing module (optional)
|
|
#[cfg(feature = "artifacts")]
|
|
pub use rtx_neuro_artifacts as artifacts;
|
|
|
|
// Real-time processing module (optional)
|
|
#[cfg(feature = "realtime")]
|
|
pub use rtx_neuro_realtime as realtime;
|
|
|
|
// Lab Streaming Layer module (optional)
|
|
#[cfg(feature = "realtime")]
|
|
pub use rtx_neuro_lsl as lsl;
|
|
|
|
// Database module (optional)
|
|
#[cfg(feature = "db")]
|
|
pub use rtx_neuro_db as db;
|
|
|
|
// Machine learning modules (optional)
|
|
#[cfg(feature = "ml")]
|
|
pub use rtx_neuro_gnn as gnn;
|
|
|
|
#[cfg(feature = "ml")]
|
|
pub use rtx_neuro_pinn as pinn;
|
|
|
|
#[cfg(feature = "ml")]
|
|
pub use rtx_neuro_fem as fem;
|
|
|
|
/// Version information for rtx-neuro-core
|
|
pub const VERSION: &str = env!("CARGO_PKG_VERSION");
|
|
|
|
/// Crate name
|
|
pub const NAME: &str = env!("CARGO_PKG_NAME");
|
|
|
|
/// Edition compliance marker (Rust 2024)
|
|
pub const EDITION: &str = "2024";
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_version_info() {
|
|
assert_eq!(VERSION, "1.0.0");
|
|
assert_eq!(NAME, "rtx-neuro-core");
|
|
assert_eq!(EDITION, "2024");
|
|
}
|
|
|
|
#[test]
|
|
fn test_error_types() {
|
|
let err = NeuroError::Signal("test".to_string());
|
|
assert!(matches!(err, NeuroError::Signal(_)));
|
|
}
|
|
|
|
#[cfg(feature = "core")]
|
|
#[test]
|
|
fn test_core_types_available() {
|
|
// Verify that core types are accessible
|
|
use crate::core::ChannelType;
|
|
let _channel_type: ChannelType = ChannelType::MegGrad;
|
|
let sample_rate: SampleRate = 1000.0;
|
|
assert_eq!(sample_rate, 1000.0);
|
|
}
|
|
|
|
#[cfg(not(feature = "core"))]
|
|
#[test]
|
|
fn test_minimal_build() {
|
|
// Test that the crate can build without default features
|
|
// Only error types should be available
|
|
let err = NeuroError::InvalidData("test".to_string());
|
|
assert!(err.to_string().contains("Invalid data"));
|
|
}
|
|
}
|