A masked volume | Views restrict the space | Same space, not merely same size | Parcels over a volume | Moving a frame between spaces | Bases and synthesis-only bases | Composite spaces | Where the package stops

The FDS manifest | Identity domains | Fingerprints are not content hashes | HDF5 round trip | Import from BIDS | Choosing the right identity

Why fmrigds? | What is a GDS? | Which path fits the summaries you have? | Plan first, compute later | Quick example | Building and inspecting a plan | Exploring a realised GDS | Tidy export | Deriving statistics | Group-level analysis with reduce() | Effects without first-level variance | z, t, or p summary statistics | Fixed-effects | Random-effects | Meta-regression | Repeated-measures mixed models | Post-hoc corrections | Writing results to disk | Working with NIfTI files | The pipeline at a glance | Next steps

Family and Audit | Fit | The fast profiled path | Prediction | Quadrature Sensitivity | What is refused where

What model are we fitting? | Coefficient p-values | Contrasts | Term tests | Model comparisons | When standard p-values are not well justified | The route map | How do I test the term anyway? | What about confidence intervals? | Where does cluster bootstrap stand? | Variance-component boundary tests | Profile confidence intervals | GLMM inference: the three-route contract | Estimands: what are you averaging? | The study | Reference grids with mm_grid() | Cell predictions with mm_predictions() | Marginal means with mm_means() | Pairwise comparisons with mm_comparisons() | Conditional comparisons with by = | Constraining the grid with at = | Custom contrasts with mm_lincomb() | The covariance contract | Summary | References

The dataset | A. The formula stays familiar | B. When a fit is degenerate, the object says so | C. Inference labels its method | The supported model contract | D. The fit is the record | Saving, reloading, and reviving in practice | The artifact contract | Lower-level tools | Where to read next

The data | Step 1: Read the formula before you fit | Step 2: Fit | Step 3: Read the summary | Step 4: Extract components | Step 5: Prediction and residuals | Prediction standard errors and intervals | Step 6: Case weights | Random-effects formulas in depth | What does (1 | subject) say? | What changes when you add a random slope? | What do split blocks and || mean? | Nested and crossed grouping | What are the three kinds of help? | How do you inspect nearby formulas? | Why is there no recommendation row? | Where do fitted-model changes appear? | Where to go next

The two edits | Verb map | Argument map for lmm() / glmm() | Four differences to check when porting | The supported envelope, generated | What is NA-with-a-reason (and why)

Overview | Simulating data for the examples | Fitting an AR model | Whitening design and data matrices | Inspecting innovations | Censored (scrubbed) frames | Correcting residual-projection bias | Parcel pooling and multiscale shrinkage | Fitting ARMA models | AFNI-style restricted AR filters | Diagnostics and sandwich estimates | Next steps

Inspect a loaded atlas | Get the right references | Trace changes to the object | Templates and probability maps | Save the evidence with your analysis

Transform a volume on an explicit target grid | Select sampling semantics | Inspect population cortical projection coverage | Route availability and nonlinear artifacts | Change fsaverage surface density | Nonlinear volume routes | Inspect alignment before and after | Work with the verified cache

Quick Start | Region legends | Colour Algorithms | rule_hcl (default) | maximin_view | network_harmony | embedding | Custom Colours | Named vector | Pre-computed tibble | Programmatic Colour Access | Controlling Slice Count | Surface Figures with Layout Control | Which entry point should you use?

What problem are we solving? | What do you need before you start? | How do you build one polished panel figure? | How do you show a continuous statistic instead? | How do you compare several maps with one legend? | How should you label the panels? | What should you remember? | Where should you go next?

What does dilation do? | How do you build a transparent example? | What changes with a small radius? | What changes with a larger radius? | How do you see the assignment? | What must be true for real data? | How do you use the result?

What are the objects? | How do you load and inspect an atlas? | How do you select regions? | How do you summarise an image by parcel? | What does map_atlas() return? | How do you inspect the atlas spatially? | When is resampling safe? | Where should you go next?

What is a surface atlas? | How do you verify geometry and labels? | How do you attach one value per parcel? | How do you extract one surface ROI? | How do you use per-vertex data? | What about other atlases and templates?

What are the four layers? | How do you find a valid surface asset? | How do you get a file path? | How do you load geometry? | How do you attach vertex data? | How is a labelled atlas different? | How do coordinate spaces enter the picture? | What should you use next?

Which product should you use? | How do you load the native surface atlas? | How do you map area-level values? | How do you inspect the volume product safely? | What about the other visual-cortex atlases? | A representation checklist | References

What do you need before you start? | How do you fetch one template image? | How do the query fields fit together? | How do you discover what exists? | How do you fetch surface geometry? | Does a matching grid mean a matching space? | What is cached? | Where should you go next?

What each backend costs | The number that actually decides it | The ladder | What object.size() does not see | Dropping to parcels | Choosing | Where to go next

Look at an image | From millimetres to voxels | Add a time axis | Summarise a region | Make a result and write it out | Where to go next

Choosing a reader | Looking before you load | The two affines | Writing | A precision surprise that is not about files | AFNI files | Where to go next

One region | Combining regions | Many regions: parcels | Every region: searchlights | A searchlight analysis that finds something | From a map back to regions | Iterating without ROIs | Doing it in parallel | Which support should you use? | Where to go next

Downsampling | Resampling onto a target grid | Build the target from the source affine | Choosing an interpolation method | Matching another image | Reorienting | Deobliquing | Where to go next

Gaussian blur | Edge-preserving filters | Sharpening | Filtering across time | Choosing | Where to go next

What a NeuroSpace holds | The affine transform | Three ways to address a voxel | Grid and linear index | Grid and world | World back to grid | Straight from linear index to millimetres | A round trip | Orientation codes | Oblique affines | Adding and dropping a time axis | Four things that catch people out | Quick reference | Where to go next

A montage of slices | One location in three planes | Overlaying a statistical map | Cleaning up a noisy map | Checking a registration | Colours | Which helper? | Where to go next

What survives an operation | Masks | Building one by hand | Taking an object apart | The matrix view | Putting objects together | Dense and sparse | Where to go next

Introduction | HRF Libraries: Systematic Parameter Exploration | Example 1: Library of Gamma HRFs | Example 2: Library of Lagged SPM HRFs | Reconstruction Matrices: From Coefficients to HRF Shapes | How Reconstruction Works | Building an HRF from Weighted Basis Functions | Regressor Sets: Multi-Condition Experimental Designs | Regressor Design: Complex Block Designs

Introduction: What is a Regressor? | Basic Regressor from Event Onsets | Evaluating and Plotting a Regressor | Varying Event Durations | Duration and Summation | Varying Event Amplitudes (Parametric Modulation) | Continuous Features | Combining Duration and Amplitude Modulation | Regressors with HRF Basis Sets | Shifting Regressors

Introduction to Hemodynamic Response Functions (HRFs) | Pre-defined HRF Objects | Choosing a Fixed HRF Scale | Modifying HRF Parameters with gen_hrf | Modeling Event Duration with block_hrf | Normalization | Averaging instead of summing: summate | Modeling Temporal Shifts with lag_hrf | Combining Lag and Duration | Multivariate HRFs: Basis Sets | SPM Basis Sets | B-Spline Basis Set | Sine Basis Set | Half-Cosine Basis Set (FLOBS-like) | Other HRF Shapes | Boxcar and Weighted HRFs (No Hemodynamic Delay) | Simple Boxcar HRF (hrf_boxcar) | What β Estimates: Boxcar Height | Weighted HRF (hrf_weighted) | Sub-second Precision | Normalized Weighted HRF | Practical Example: Comparing Early vs. Late Response Windows | Using Boxcar/Weighted HRFs with Regressors | Creating Custom Basis Sets with hrf_set | Creating Empirical HRFs | From a Single Measured Response (gen_empirical_hrf) | Empirical Basis Set via PCA

Why Generators? | Creating a Basis with a Generator | Visualising FIR Basis Functions | Summary

A vignette | Code and output | Figures | Tables | A pkgdown site

Overview | How the two directions relate | Dark code blocks | Tables | A plot on the matching ground

Distinguish missing values from zero | Resample integer labels by voting | Separate adjoint application from reverse resampling | Experimental adaptive area interpolation | Qualification boundaries

Introduction | A complete fit first | Key Components and Workflow | 1. Data Representation | 2. Model Building | a) Hemodynamic Response Function (HRF) | b) Event Model (event_model) | c) Baseline Model (baseline_model) | d) Contrasts (pair_contrast, unit_contrast, etc.) | 3. Model Estimation (fmri_model, fmri_lm) | 4. Advanced Topics | Acceleration: Sketched / Nyström Analysis | Group-Level Meta-Analysis | Getting Started | Next Steps

Set up a synthetic dataset | Simulate data with AR(1) noise | Pack into an fmri dataset | Choose the approximation engine | Build parcels | Fit with Global AR + SRHT sketch | Fit with Parcel AR + SRHT sketch | Choosing a sketch | Compare sketching to an exact OLS baseline | Standard errors follow the estimator | Reduced-rank GLS with bootstrap standard errors | Landmark extension (full-voxel, global AR) | Choosing landmarks: practical guidance | What the comparisons establish | When to use which knob | Pros and cons | Practical defaults | Reproducibility tips | Next

Introduction to Contrasts | Example: A 2x2 Factorial Design | Basic Contrasts: pair_contrast | Defining Pair Contrasts | Computing Contrast Weights | Unit Contrasts: Comparing to Baseline | General Contrasts with contrast() | Contrasts for Main Effects and Interactions | Polynomial Contrasts for Ordered Factors | Helper Functions for Common Comparisons | Grouping Contrasts: contrast_set | Applying Contrasts in fmri_lm | Extracting Contrast Results | Execute an omnibus F-contrast | Visualizing Contrast Weights | Working with Contrast Weights | Conclusion | Next

Introduction to fMRI Linear Models | Simulating a Dataset for Analysis | Fitting a Linear Model | Accounting for Temporal Autocorrelation | Handling Outliers with Row-Wise Robust Fitting | Extracting Model Results | 1. Coefficient Estimates | 2. T-Statistics and P-Values | 3. Contrasts Between Conditions | Fitted HRF Curves | Estimating the HRF Shape from Data | Comparing Models with Different HRF Bases | Summary | From first‑level to group analysis (GDS) | Next

Introduction to fMRI Data Simulation | Simulating Clean BOLD Signals | Simulating Structured fMRI-like Noise | Power Spectrum Analysis | Creating a Complete Dataset with Signal and Noise | Simulating Matrix Time Series with Column-Specific Variation | Summary and Comparison | Next

Overview | Creating a Test Dataset with Known Connectivity | Modeling Scanner Drift | Connectivity Analysis Using fmrireg's GLM Framework | Validating the Results | Repeated-sampling calibration | Visualizing the Connectivity Map | Extending to Real Data | Summary

Introduction: Modeling Task Effects | Quick HRF Primer | Timing and Sampling | A Simple Single-Factor Design (Single Run) | Visualizing the Event Model | Design with Multiple Runs | Two-Factor Design | Amplitude Modulation (Parametric Regressors) | Continuous Features | Interaction Between Factors and Amplitude Modulation | Specifying Different HRFs | Per-Onset HRF Specification with hrf_fun | Advanced: Parametric Modulator with FIR HRF and Windowed F-contrast | Trialwise Models for Beta-Series Analysis | Covariates (Non-convolved Regressors) | Accessing Model Components | Visualizing the Design Matrix and Correlations | Contrasts Quickstart | Combining Event and Baseline Designs

What are the inputs? | How do you render one thresholded view? | How do you build the four canonical views? | Where do the medial wall and cortex mask enter? | How should a volume become a continuous surface field? | Which function draws what you need? | Next steps

Overview | Design Philosophy | Core Concepts | What is a Morphism? | The Morphism Hierarchy | Quick Start | Creating Morphisms | Transforming Coordinates | Composing Transforms | Inverting Transforms | Working with Neuroimaging Tools | ANTs Transforms | FSL Transforms | AFNI Transforms | FreeSurfer Coordinates | Resampling Data | Volume Samplers | Grid Specifications | Resampling Plans | Jacobian Determinants | Volume-to-Surface Mapping | Coordinate Conventions | Affine Utilities | Building Affine Matrices | Decomposing Affine Matrices | Common Workflows | Workflow 1: Register Native to Template | Workflow 2: Transform ROI Coordinates | Workflow 3: Chain Multiple Transforms | Performance Tips | Summary | Further Reading

Why niflowr? | Quick example | Browsing available specs | The core workflow | Step 1: Build a call | Step 2: Inspect the command | Step 3: Execute | Dry-run mode | Using the convenience wrappers | Provenance | Container support | FastSurfer: GPU-accelerated segmentation | Runtime diagnostics with ni_doctor() | Pinning and validating lockfiles | Lock enforcement during execution | Ecosystem integration | neuroim2 — read outputs as R objects | neurotransform — work with spatial transforms | bidser — BIDS-aware input discovery | Building pipelines with | Using ni_run_files() in targets | Using tar_ni_step() for less boilerplate | Dynamic branching over subjects | Writing your own specs | Next steps

Introduction | Quick Start with ni_bids_app() | Understanding the app.R Template | Example: Brain Extraction App | Example: Multi-Step Preprocessing App | Container Deployment | Custom CLI Parameters | Best Practices | Next Steps

The mental model | First win: a 12-line spec | Anatomy of a spec | Positional vs. switched arguments | Output paths come from inputs | Runtime profile | Object zoo | Promoting a spec from local to bundled | Avoid these traps | Next steps

Introduction | The workflow | Step 1: Preprocess with fmriprepper | Step 2: Inspect fMRIPrep outputs | Step 3: Read confounds | Step 4: Post-process with niflowr | Full pipeline with targets | Tips

Introduction | Setup | Step 1: Browse OpenNeuro | Step 2: Download with ni_from_openneuro() | Step 3: Process with niflowr | Skull strip T1w images | Register to MNI space | Step 4: Scale with targets | Working with fMRIPrep derivatives | Tips | Next steps

The protocol | An RDS-backed source | Try it | Validate it | Composition comes for free | Checklist for a storage package

Introduction: Linking Data and Design | The sampling_frame | In-Memory Volumetric Data (neurovec_frame) | File-Based Volumetric Data (nifti_frame) | Matrix Data (matrix_frame) | Latent Data (latent_frame) | Reading a frame back | Next

Why use the plugin API? | How do you build a minimal dataset? | How do you register a custom basis? | How do you register a custom engine? | Which helper should you use? | How do capabilities affect the executed configuration? | How can you inspect engine specs? | What should extension authors remember?

Build a frame | Select by ID or by metadata | Views are lazy | Inspect without reading | Run structure is metadata | Durable and ephemeral IDs | Bind frames along observations | What a frame promises

Which interface are you evaluating? | What similarity does Slice-MSF use? | Compare natural and requested exact K | How is feasibility enforced? | Which provenance should be retained? | What should you test before using it?

What does the complete workflow do? | How do you create a reproducible input boundary? | How do you read and check the data? | How do you fit and validate the partition? | How do you export and prove the round trip? | What should you preserve with the result?

What should you inspect before export? | How do you inspect the parcel map? | What do the parcel signals look like? | How do you write the complete label map? | How do you export one parcel as a mask?

What does stitching change? | What does consensus change?

What is the shortest successful path? | Which methods share the unified interface? | When should you use a direct function? | What should you inspect after fitting?

What does the unified interface map? | Can a mapping be checked rather than trusted? | Which interface should you publish?

Where does each family spend its work? | What is distinctive about each method? | What should drive the final choice?

What exactly is measured here? | What belongs in the receipt?

Which decisions come first? | What does K change? | What does spatial weight change? | How should you tune real data?

What makes a comparison fair? | How do you hold inputs constant? | Which quantities are you comparing? | What should you compare next?

What problem are you solving? | What goes in? | How do you make a first parcellation? | How do you check the object? | Where should you go next?

What does a valid result look like? | How are labels related to centers? | What should you notice in a slice? | What belongs in a saved receipt?

What can be estimated before a run? | How should performance be measured?

What does spatial weight change? | What does connectivity mean? | How should artifacts be diagnosed?

Which unified methods accept parallel? | How do direct APIs control threads? | How should a speedup claim be tested?

Which question are you asking? | Is the result internally consistent? | What does one partition measure? | How do you compare two outputs? | What belongs in a report?

What does a scene contain? | How do you build one bilateral, multi-map viewer? | Which option controls appearance and behavior? | How is geometry shared across maps? | How do you write an offline report? | How do you mount the scene on a plain web page? | What happens when interaction is unavailable? | When should you use the legacy shortcuts? | What should you read next?

Setup and Loading Data | Basic Surface Plotting | Coloring Based on Curvature | Overlaying Data Values | Thresholding Data Visualization | Direct Vertex Coloring | Controlling Transparency | Adjusting Lighting and Material | Snapshotting to an image (for knitr/CI) | Changing Viewpoints | Displaying Two Hemispheres | Adding Spheres to the Surface | Plotting Other NeuroSurface Objects | Showing an activation map overlaid on a surface mesh | Showing two hemispheres in same scene | Next Steps

Setup | SurfaceGeometry: Representing the Mesh | Loading a SurfaceGeometry | Accessing Geometry Properties | NeuroSurface: Mapping Data to Geometry | Creating a NeuroSurface | Loading Data with read_surf (Optional Data File) | Accessing NeuroSurface Properties | NeuroSurfaceVector: Mapping Multiple Data Vectors | Creating a NeuroSurfaceVector | Accessing NeuroSurfaceVector Properties | Specialized NeuroSurface Classes | Next Steps

Introduction to bidser | What is BIDS? | What does bidser do? | Loading a BIDS Dataset | Basic Dataset Queries | Dataset Structure | Finding Files by Type | Filtering by Subject and Task | Working with Multiple Subjects | Working with Event Files | Analyzing Event Data | Working with Metadata Sidecars | Working with Individual Subjects | Advanced Querying with query_files() | Match Modes | Entity Presence, Extension, and Datatype Filters | Tibble Output with Parsed Entities | Scoped Queries and Derivatives | Permissive Loading | Run-Level Variables and Report Data | Full File Paths | Working with fMRIPrep Derivatives

Introduction | Available Benchmark Datasets | Loading and Exploring a Dataset | Examining the Data Structure | Visualizing the Data | Creating Design Matrices | Does the Benchmark Recover Its Own Ground Truth? | Comparing True vs Estimated Betas | Testing Different Datasets | HRF Variability Dataset | Trial Amplitude Variability | Summary | Next

Overview | Create a small ROI dataset | Fit group meta-analysis | Extract coefficients and a contrast | A quick visualization | Notes on voxelwise analysis | Minimal NIfTI Example (Reproducible) | Exact contrasts and stored covariance | Two-sample t-test (Welch and OLS) on NIfTI | Combining t-statistics only (Stouffer/Fisher/Lancaster) | Meta engine via fmri_ttest with weights | ROI t-only example (Stouffer and Lancaster) | A brief recap

The problem | A minimal, runnable example | Reducers: what each subject becomes | Discovering subjects from BIDS | Preflight before you fan out | Running: locally, in parallel, or on a cluster | Closing the loop: the group level | Summary | Next

Introduction to Contrasts | Types of Contrasts | Defining Contrasts in Event Models | Quick Validation | Advanced Contrast Specifications | Pairwise Contrasts | Polynomial Contrasts | Factorial Design Contrasts | Main Effects and Interactions | Parametric Modulators: Do You Need a Contrast? | F-contrasts for Omnibus Tests | Working with Contrast Weights | Extracting and Manipulating Weights | Contrast Validation | Contrasts for Multi-Run Designs | Contrast Specification Best Practices | 2. Scaling and Normalization | Advanced Topics | Custom Contrast Functions | Troubleshooting Common Issues | 1. Rank-Deficient Contrasts | 2. Multicollinearity in Contrasts | Summary

Overview | The fMRI Design Matrix | Package Architecture | Quick Start: Complete Workflow | Understanding the Components | Sampling Frame | Event Specification | Common Use Cases | 1. Block Design | 2. Rapid Event-Related Design | 3. Parametric Modulation | Integration with fMRI Analysis | Best Practices | Next Steps | Getting Help

The Purpose of a Baseline Model | Modeling Drift with Basis Functions | Visualizing Baseline Regressors | Intercept Control | Adding Arbitrary Nuisance Regressors | Combining Basis Sets and Nuisance Regressors | Accessing the Design Matrix

What does the input look like? | What model is fitted? | What is the fastest end-to-end path? | How are the random effects estimated? | How do first-level variance estimates enter the model? | Should variance components be pooled or fitted voxelwise? | What if your repeated-measure metadata is already separate? | What is supported, and what is intentionally out of scope? | Where do you go next?

Why use the CLI? | What are we driving? | How do you get a result quickly? | How do you inspect a source before you commit to a model? | How do you separate planning from execution? | How do you preview a saved plan? | How do you reach more complex workflows? | How do you discover available methods? | Where should you go next?

What data do you need? | How do you run the examination? | How do you read the action plane? | What does the residual geometry add? | How do you inspect one retained subject? | What happens to the post-hoc conclusion? | How do you share the examination?

When do you need this? | Sample data | Chaining operations on realized objects | Standard FDR correction | Spatial FDR | Requirements for spatial FDR | Next steps

When do you need this? | Two paths for reading data | Native /gds layout (Path B) | Labeled volumes (LabeledVolumeSet) | Parcellated data (H5ParcellatedScan) | Temporal policies | Space type | Latent bases (LatentNeuroVec) | Reading subsets efficiently | Provenance tracking | Quick reference | Next steps

When do you need this? | Building a GDS from in-memory data | Masking: dealing with missing data | Why mask? | Setting up the example | Intersection mask (the default) | Threshold mask | Other mask rules | Masking in a pipeline | Alignment: bringing subjects into a common space | Why align? | Creating test data in a latent space | Providing per-subject rotation matrices | Bundling rotations into a MapFamily | Running the alignment | Alignment followed by group analysis | Other alignment types | Space transformations with map_to() | Why transform spaces? | Setting up a mapping | Applying the transformation | How uncertainty propagation works | Combining test statistics without effect estimates | Putting it all together | Space types at a glance | Next steps

What converged_interior establishes — and what it does not | Boundary and reduced-rank fits are labeled facts | How singularity is decided: rank, not θ entries | Verifying an optimum: verify_convergence() | When the requested estimator does not certify (GLMM) | What a boundary refuses | References

What does a small mock project look like? | How do you query raw and derivative files? | How do you inspect injected events and confounds? | How do you pack the project for sharing? | Next Steps

Where are the derivatives? | How do you pull one derivative run? | How do you read and check confounds? | How do you verify run-level coverage? | How do you turn that into a report? | Next Steps

Building a test dataset | Confound sets: predefined recipes | Reading confounds | Selecting variables by name or wildcard | Flat output for quick modeling | Confound strategies: PCA reduction | Custom strategies | Reading event files | The variables table: one tibble per run | Dataset QA with bids_report() | Putting it together | Next steps

How do I install a backend? | Does it just work? | Am I actually on the GPU? | What does "fast" precision actually mean? | Why did my small matrix stay on the CPU? | What happens when the GPU fails? | The one sharp edge: resident handles alias the GPU buffer | Where next?

The speed contract | Calibrate once per machine | Read the benchmark report | When the GPU wins | When the CPU wins (and you should let it) | Ask the dispatcher | Residency and fallback telemetry | Regenerating the baseline | Honest defaults

Prerequisites | Reading the fluent $ syntax | Step 1: Download an OpenNeuro dataset | Step 2: Build an fMRIPrep plan | Step 3: Validate and run | Tips

Why openneuro? | Load the package | Find datasets | Inspect versions and files | Download data | Manage the cache | Discover derivatives | Next steps

Introduction | The Ground Truth: Three Dynamic Latent Components | Visualize the Ground Truth | Method 1: DiPCA (Dynamic Inner PCA) | How Well Did DiPCA Recover the Components? | DiPCA Properties: Orthogonality | DiPCA Properties: Predictability | Method 2: DiCCA (Dynamic Inner Canonical Correlation) | DiCCA Property: Descending Predictability | Compare DiPCA and DiCCA | Reconstruction: Going Back to Original Space | Dynamic Whitening: Removing Autocorrelation | Summary | When to Use Which Method? | References | Session Info

Why dipca? | Quick example | DiPCA: unsupervised dynamic components | DiCCA: components ordered by predictability | DiPLS: supervised dynamic components | Projecting new data | Next steps

Why templateflow? | Installation | Discovering templates | Listing files for a template | Fetching files | Reading files directly into R | Template metadata and citations | Using the global client | Cache management | Configuration | Next steps

When should you reach for the advanced tools? | What will the execution plan do? | How do you let delarr choose a chunk size? | How do you compute several summaries in one pass? | How do you work block-by-block? | How do delayed matrix products fit into a pipeline? | How do you stream a transformed matrix to disk? | How do you use shared-memory workers? | How do you profile a candidate pipeline? | Where should you go after this?

What problem does delarr solve? | What does a lazy pipeline look like? | How do row and column vectors broadcast? | How do you stream a result to HDF5? | How do you wrap your own storage layer? | Where should you go next?

What signal are we trying to represent? | Which temporal basis fits this shape? | What changes for spatial bases? | How should you choose in practice?

What do you start with? | How do you make a first payload? | Where did the payload budget go? | How do you decode only what you need? | How should you tune the budget? | When do events help? | Where does this fit in fmrilatent?

What is the baseline size? | How does component count change error? | What should be checked before trusting a result? | Where to next?

Compressing the time dimension | Slepian/DPSS sequences | DCT | B-splines | Comparing temporal families | Compressing the voxel dimension | Graph Slepian | Heat wavelet | HRBF (hierarchical radial basis functions) | Wavelet active (CDF 5/3 lifting) | PCA (cluster-local) | Shared parcel templates | Compressing both dimensions | The convenience factory | Handle vs. matrix materialization | Benchmarking | Quick reference

Why fmrilatent? | A first encoding | Getting data back | Choosing a basis | Quick reference | Two latent representations | Next steps

What is shared? | How do subjects differ?

Shared Basis Assets | In-Session References and Subject Deltas | Shared Temporal Specs and Event Dictionaries | BOLDZip-SR | What to Use When

What sets a standalone codec apart?

What basis are we transporting? | What does the field operator look like? | How are coefficients recovered? | What is handed downstream?

What do we start with? | How is the object encoded? | How do you read one voxel? | How do you slice it like an array? | When should handles be used?

The two tiers | Which encoders return which? | Working with explicit latents | Working with decoder-backed latents | Serialization implications | Shared structure is orthogonal | Choosing between tiers | Further reading

What do your inputs look like? | What is the quickest end-to-end path? | How does amatrix decide where to run? | When does shared-design caching help? | What should you inspect after a fit? | How do you ask for a fast backend? | Where next?

Find recent sessions and download three subjects | Search for sessions by date range | Find scans by acquisition parameters | Browse files before downloading | Build a local inventory of a project | Use alias tokens for shared scripts | Clean up

Connect and explore in 30 seconds | The XNAT data hierarchy | How do I find my project? | Who is in the project? | What sessions exist? | What scans are in a session? | How do I download data? | Download all scans from a session | Download specific scans or resource types | Download an entire subject | Download a session by experiment ID alone | Credential management | Clean up | Next steps

A first example | The three core objects | Sharing inputs | Output buffers | Shard descriptors | Running shard_map() | What if workers return values? | Convenience wrappers | Column-wise apply | List lapply | Diagnostics | Worker pool management | Copy-on-write protection | Clean up | Next steps

What is H5ParcellatedMultiScan? | Simple Example: From Data to Storage | Step 1: Create Brain Data | Step 2: Create Brain Regions (Clusters) | Step 3: Create Some fMRI Data | Step 4: Save Using the New Simple Interface | Step 5: Load Using the New Simple Interface | Step 6: Extract and Visualize Data | Understanding Single Scan vs Multi-Scan Containers | Single Scan: H5ParcellatedScanSummary | Multi-Scan: H5ParcellatedMultiScan | Converting ClusteredNeuroVec Objects | When to Use Each Format | Advanced Example: Multiple Runs with Summary Data | Create Multiple Runs | Save Multiple Runs | Automatic Type Detection | Working with Multiple Runs | Creating Summary Data | Key Functions Summary | write_dataset() - Save Your Data | read_dataset() - Load Your Data | detect_h5_type() - Identify File Contents | Memory Efficiency Tips | When to Use H5ParcellatedMultiScan | Cleanup | Next Steps

Why fmristore? | Quick Start: Choose Your Storage Format | Data Conversion Workflows | 1. Converting neuroim2 ClusteredNeuroVec | 2. Converting Regular NeuroVec to HDF5 | 3. Creating Multi-Scan Experiments | Performance Comparison | Best Practices | 1. Memory Management | 2. Choosing Between Single and Multi-Scan | 3. Data Access Patterns | Common Use Cases | Use Case 1: Single Subject, Multiple Runs | Use Case 2: Storing Subject Maps with LabeledVolumeSet | Use Case 3: Resting State Connectivity from Parcellated Data | Advanced Features | Latent Representations | Working with Atlas Labels | Troubleshooting | Common Issues and Solutions | Next Steps | Format Chooser

Why Use HDF5 for Neuroimaging? | Quick Start: 3D Brain Volumes | Working with fMRI Time Series (4D Data) | Loading Existing HDF5 Files | Best Practices | 1. Always Close Your Files | 2. Use Chunk Sizes Wisely | 3. Memory vs Speed Trade-off | Common Use Cases | Preprocessing Large Datasets | Region of Interest Analysis | Summary

How are individual scans organized? | The Data Hierarchy | Step 1: Create Sample Data Using the New Interface | Create Multiple fMRI Runs with Different Characteristics | Save Mixed Full and Summary Data | Converting neuroim2 ClusteredNeuroVec Objects | Creating a ClusteredNeuroVec | Converting to HDF5: Single Scan (Default) | Converting to HDF5: Multi-Scan Container | Step 2: Load the Data with read_dataset() | Step 3: Accessing Individual Scans from the Container | Understanding Individual Scan Properties | H5ParcellatedScan: Operations on Individual Full Scans | Extract Time Series from Individual Voxels | Extract Time Series for All Voxels in a Cluster | Compare Task vs Rest Scans (Individual Scan Analysis) | H5ParcellatedScanSummary: Operations on Individual Summary Scans | Extract and Analyze Summary Data | Compute Cluster-to-Cluster Correlations | Practical Usage Guidelines | Choose H5ParcellatedScan when you need: | Choose H5ParcellatedScanSummary when you need: | Key Individual Scan Operations Summary | Memory and Performance Considerations | Clean Up | Key Takeaways | Next Steps

What is a LabeledVolumeSet? | Quick Example: Storing Statistical Maps | Step 1: Create Example Data | Step 2: Create Brain Mask | Step 3: Save with Labels | Step 4: Load and Access | Real-World Use Case: Group Analysis Results | Working with Subject-Specific Maps | Create Subject Data | Add Activation Patterns | Save Subject Maps | Compute Group Statistics | Advanced: Efficient Access Patterns | Best Practices | 1. Use Meaningful Labels | 2. Organize Your Analysis | 3. Remember to Close | Summary

Overview | Creating synthetic activation maps | Basic cluster detection | Controlling sub-peak detection | Sorting options | P-value computation | Flat data.frame output | MNI coordinate column names | Formatted tables with tinytable | Atlas labeling | Combining with overlay plots | Connectivity options | Edge cases | The cluster_table object | Summary

Why fmrireport? | Package overview | Quick example: cluster_table() | Flat table for rendering | MNI coordinate labels | Tinytable output | Full PDF report workflow | Controlling the activation table | Next steps