Anatomy of a certificate | Clean: every box ticked | Failed: backward error too large | Withheld: stochastic norm in the denominator | Generalized SPD: B-orthogonality matters | Comparing eigencore certificates to RSpectra diagnostics | Cheat sheet | Where to go next

Start with a positive-definite metric | Compute only part of the spectrum | Handle a dense general pencil | Use QZ when you need the Schur form | Keep sparse partial problems sparse | A note for older code | Where to go next

Compute a certified partial eigendecomposition | Generalized SPD eigenproblem (A v = lambda B v) | Partial SVD | RSpectra-compatible workflow | Under the hood: operators, problems, and plans | Where to go next

Build a sparse dataset with a low-rank signal | Center without densifying | Read the certificate on a composed operator | Does it match what you'd get by densifying? | Scale columns too | What did the planner actually do? | Going fully matrix-free | Why this matters at scale | Where to go next

What fit are we worried about? | Which inference routes are available? | How do I test the term anyway? | What about confidence intervals? | Where does cluster bootstrap stand? | Variance-component boundary tests | Summary | References

What problem does it solve? | One small model | Reading the formula before fitting | Reporting tables | Saving and reloading | Lower-level tools | What's next?

The study | Fit the model | 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 emmeans bridge | Reading status and reason | Where to read next

The two edits | Verb map | Argument map for lmm() / glmm() | Four things that will bite, and the fix | What is NA-with-a-reason (and why)

What model will we report? | What did the formula request? | What fit was used? | Which design facts belong in the report? | How are estimates and p-values labelled? | How are random effects reported? | What is unavailable or caveated? | What should go into your written report?

Inferential surfaces | Out of scope here | Caveats | Citation

The data | Step 1: Compile the model | Step 2: Fit | Step 3: Read the summary | Step 4: Extract components | Step 5: Test a specific claim | Step 6: Compare specific conditions | Step 7: Save and reload | Where to go next

Pipelining operations with a functional style | Mapping a function over every slice of a NeuroVol | Mapping a function over each volume of a NeuroVec object | Mapping a function over each vector of a NeuroVec object

Extract a time series from one ROI | Split a masked volume into parcels | Build searchlights lazily | Map a simple statistic over the first few searchlights | Where to go next

Read volumes to establish context | Coordinate conversion and spatial metadata | Masks and LogicalNeuroVol | Constructing volumes manually | Slicing and quick visualization | Reorienting and resampling | Downsampling | Writing a NIFTI formatted image volume

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

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

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

Load surfaces and an atlas | A continuous overlay with a colourbar | Adding atlas outlines | Next Steps

Introduction | Quick Start | Basic Surface Display | Data Visualization | Advanced Configuration | Vertex-Colored Surfaces | Interactive Controls | Troubleshooting | Advantages over Static Plots | 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

Family and Audit | Fit | Quadrature Sensitivity | Current Boundaries

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

Overview | New feature highlights | Code + output

What's new in this release | Semantic callouts | Typography and syntax tone | Contrast guardrail example | Overview | Palette families and roles | Image-derived palettes | Links, anchors, and rhythm | Callouts and code blocks | Tables | Plots: one highlight, others neutral | See also

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

What Is This Page For? | How Do You Use It? | What Does Each Control Change? | Can You Validate The Palette Quickly? | Copy Into YAML | Example Plot

What this page proves | Code on a light ground | A table | A plot on the matching ground

What this page proves | Code on a dark ground | A table | A plot on the matching ground

The albersdown system | The six families | The two directions, in plots | Picking a combination | Next step

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

Layer Diagram | The Backend Contract | Dataset Classes | matrix_dataset | fmri_file_dataset | latent_dataset | fmri_study_dataset | Temporal Structure | Extension Points | Adding a New Backend | BIDS + HDF5 as a Concrete Example | Object Zoo | Related Vignettes

Which compression mode should you use? | How do you create an archive? | Parcellated mode | Latent mode | How do you open an archive? | Exploring the study | Subsetting by task, subject, or session | Accessing data | Events | Confounds | Chunked iteration | Group operations | Latent-mode extras | Parcellation metadata | Next steps

Motivation | Creating a Dataset | Accessing Data | Temporal Structure | Event Tables | Chunked Processing | Run-wise Processing | File-based Datasets | See Also | Session Information

Create per-subject datasets | Compose into fmri_study_dataset() | Access data | Chunked iteration | Group operations with fmri_group() | Next steps

The six-method contract | backend_open(backend) | backend_close(backend) | backend_get_dims(backend) | backend_get_mask(backend) | backend_get_data(backend, rows = NULL, cols = NULL) | backend_get_metadata(backend) | Minimal working example: CSV backend | Registering your backend | Validation | Testing

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 does (1 | subject) say? | What changes when you add a random slope? | What do split blocks and || mean? | 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?

What model are we fitting? | Coefficient p-values | Contrasts | Term tests | Model comparisons | Unavailable is still useful information

The dataset | A. The formula stays familiar | B. When a fit is degenerate, you find out which part | C. Expose when asymptotics are weak, then offer bootstrap | D. The fit is the record | What this page did not show | Where to read next

What are we plotting? | How do I make a slice montage? | How do I inspect one location in three planes? | How do I overlay a signed statistical map? | How do I check registration by eye? | Which helper should I reach for? | Practical tips

What does the benchmark show? | What should you measure? | How do you benchmark fitting? | How do you benchmark bootstrap? | What does inference method choice cost? | How do you read the result? | What should go in a report?

expected_status | expected_reliability_reason | reason_code

Fit a model | Round trip through RDS | Rebuild design matrices when needed | What stays explicit? | What should you report?

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?

What data are we fitting? | What happens when you call lmm()? | How do you read the coefficient table? | Which familiar extractors work? | How do prediction and residuals line up? | Where is the design audit? | What should you read next?

Why Backends Matter | Quick Rules | Decision Table | Dense In-Memory Data | Sparse Masked Data | Memory-Mapped Access | File-Backed Access | 5D Data | Recommended Defaults | Related Articles

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

Working with neuroimaging time-series data | Reading multiple four-dimensional images | Creating a NeuroVec from an in-memory array | Time-series transforms: z-scoring and summary volumes | Concatenating along time | Dense ↔ sparse workflows | Writing vectors to disk | Putting it together with an ROI

ROI types in neuroim2 | Quick start | Basic ROI operations | Creating a Spherical ROI | Performance Note: C++ vs Pure R Implementation | Creating a Spherical ROI Around Real-World Coordinates | Creating Multiple Spherical ROIs Efficiently | Creating Cuboid and Square ROIs | Cuboid ROIs (3D boxes) | Square ROIs (2D in 3D space) | Working with ROI Data | Converting ROIs to Sparse Volumes | Using ROIVec for 4D ROI Data | Image Patches | Advanced ROI Techniques | Custom Weighted ROIs with Kernels | Working with ClusteredNeuroVec for Parcellated Data | ROI Set Operations | Best Practices and Performance | Memory Management | Choosing ROI Sizes | Parallel Processing Tips | Troubleshooting and Tips | Common Issues and Solutions | Issue: ROI extends outside brain mask | Issue: Different coordinate systems | See Also

What is a NeuroSpace? | The Affine Transform | Passing an explicit affine | Voxel vs World Coordinates | Coordinate Conversions | Grid <-> linear index | Grid -> world coordinates | World -> grid coordinates | Convenience: linear index <-> world | A concrete round-trip | Orientation Codes | Reorienting a space | Creating NeuroSpaces | From dim + spacing + origin (axis-aligned) | From an explicit affine | When does spacing() differ from the affine diagonal? | Dimension Manipulation | Adding a time dimension: add_dim | Dropping the time dimension: drop_dim | Resampling and Reorientation | resample — change voxel size, keep geometry | deoblique — remove scanner tilt | Common Gotchas | Quick Reference | Where to go next

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?

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 fmrilss? | Quick example | Create a rapid event design | Add baseline and nuisance regressors | Simulate data with known ground truth | Run LSS | LSS vs standard GLM | Prewhitening | Computational backends | OASIS: single-pass LSS with extras | Nuisance pre-projection | Next steps | References

Motivation | Prerequisites | Computational Intuition | Visual Comparison of Computational Scaling | Classical LSS Recap | Single-Basis OASIS Algebra | Fractional Ridge | Standard Errors | Multi-Basis Extension | [\begin | HRF-Aware Design Construction | AR(1) Whitening | Diagnostics Output | Algorithm Summary | Complexity and Memory | Next Steps | References

The Problem | Step 1: Build the Shared Basis | Visualizing the Basis | Choosing the Rank | Library Coverage | Step 2: Generate Synthetic Data | Step 3: Run the SBHM Pipeline | Step 4: Evaluate Recovery | Matching Accuracy | Matching Confidence | Amplitude Recovery | Recovered HRF Shapes | Library Manifold | Soft Assignment for Ambiguous Voxels | Shape Estimation Strategies | Low-Confidence Gating | Amplitude Policy | Returning Coefficients for Custom Analysis | Parameter Quick Reference | Performance Considerations | Prewhitening | References | Summary

What OASIS Adds Over Plain LSS | Synthetic Data | Basic OASIS Call | Equivalence to LSS | Ridge Regularization | Absolute Ridge | Fractional Ridge | Multi-Basis HRFs | FIR Basis | HRF Grid Search | Multiple Conditions | Standard Errors | Prewhitening | When to Use OASIS | Next Steps

Introduction | When to Use lss_design() | When to Use Traditional lss() | Simulated Data Setup | Quick Start | Multi-Run Experiments | Onset Convention: Run-Relative | Why Run-Relative Onsets? | Adding Baseline Correction | Adding Motion Parameters | Multi-Basis HRFs | Ridge Regularization | Comparison with design_spec | Using design_spec (old approach) | Using lss_design() (new approach) | Validation: Estimated vs True Betas | Advanced: Parametric Modulators | Troubleshooting | Error: "Y has X rows but sampling_frame expects Y scans" | Error: "event_model and baseline_model have different sampling_frames" | Warning: "High collinearity detected" | Summary | Further Reading

Why HRF Variability Matters | Setup | Simulate Data with Variable HRFs | Experiment parameters | Voxel-specific HRFs | Generate signal and noise | Visualise the design | Standard LSS with Canonical HRF | Estimate Voxel-Specific HRFs | Multi-basis GLM | Apply Voxel-Specific HRFs in LSS | OASIS Alternative | Compare Methods | Compute accuracy metrics | Scatter plots | Next Steps

Overview | Why ClusteredNeuroVec? | Creating a ClusteredNeuroVec | From scratch with synthetic data | Key properties | Array-like access | Cluster searchlight analysis | Real-world example: Schaefer parcellation | Integration with existing workflows | Performance benefits | Summary

Reducing a 4D NeuroVec over time into a NeuroVol | Splitting a NeuroVec into blocks by an index vector | Converting a NeuroVec to a memory‑mapped MappedNeuroVec | Mapping a kernel over a 3D NeuroVol with mapf | Splitting a NeuroVec into ROIs by voxel clusters | Group‑wise voxel reduction with split_reduce | Concatenating NeuroVols into a NeuroVec | Concatenating NeuroVecs along the time dimension | Connected components in a 3D mask

1. Resampling to a new space | 2. Downsampling to coarser resolution | 2.1 Downsample a 4D NeuroVec | 2.2 Downsample a 3D NeuroVol | 3. Reorienting images | 4. Putting it together

1. Gaussian smoothing with gaussian_blur() | 2. Edge‑preserving guided filter with guided_filter() | 3. Bilateral spatial filter with bilateral_filter() | 4. Laplacian enhancement with laplace_enhance() | 5. 4D bilateral smoothing with bilateral_filter_4d() | 6. Correlation‑guided bilateral filtering with cgb_filter() | Choosing a smoother

Introduction | Quick start | What should you read next? | The core objects | A small end-to-end workflow | Spatial operations come next | When should you change backends? | Where to go next | Core path | Advanced and specialized articles | Reference and help | Summary

Start with a single volume | Read a 4D time series | Pull out the volumes you need | Convert to a matrix when you need table-like work | Extract one voxel or one ROI time series | Switch to sparse storage when the support matters | Where to go 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

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 | Interactive Visualization: Building an HRF Step by Step | 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) | Combining Duration and Amplitude Modulation | Regressors with HRF Basis Sets | Shifting Regressors

Introduction to Hemodynamic Response Functions (HRFs) | Pre-defined HRF Objects | Modifying HRF Parameters with gen_hrf | Modeling Event Duration with block_hrf | Normalization | Modeling Saturation with 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 | Gamma HRF | Mexican Hat Wavelet HRF | Inverse Logit Difference HRF | Boxcar and Weighted HRFs (No Hemodynamic Delay) | Simple Boxcar HRF (hrf_boxcar) | Normalized Boxcar: Estimating Mean Signal | Weighted HRF (hrf_weighted) | Using width for Evenly Spaced Weights | Using Explicit times for Custom Spacing | Smooth Weights (Linear Interpolation) | Sub-second Precision | Normalized Weighted HRF: Estimating Weighted Mean | Practical Example: Comparing Early vs. Late Response Windows | Using Boxcar/Weighted HRFs with Regressors | Creating Custom Basis Sets with gen_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

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) | 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

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

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

Why phynd? | Quick example | How the pipeline works | Stage 1: The wNN map | Stage 2-3: Component extraction | Stage 4: Cleaned output | Tuning parameters | CompCor baseline | Diagnostics and timing | Saving QC artifacts | Next steps | References

Overview | Simulating data for the examples | Fitting an AR model | Whitening design and data matrices | Inspecting innovations | Parcel pooling and multiscale shrinkage | Fitting ARMA models | AFNI-style restricted AR filters | Diagnostics and sandwich estimates | Next steps