Jan 12, 2026

A Comprehensive Pipeline For Reproducible Analysis of ASL Using Quantiphyse V.1

DOI
https://dx.doi.org/10.17504/protocols.io.n2bvjenmbgk5/v1
A Comprehensive Pipeline For Reproducible Analysis of ASL Using Quantiphyse
  • Isaac Manny Tigbee1,
  • Abraham Awamba2,
  • Alaa Bessadok3,
  • Jeremiah Oluwatomi Itodo Daniel4,
  • Bilkisu Farouk5,
  • Ernest Okyere Darko1,
  • Bankole Happiness6,
  • Said Ibrahim Said7,
  • Ethan Draper8,9,
  • Abdalla Z Mohamed10,
  • Kesavi Kanagasabai11,
  • Udunna Anazodo8,
  • Cindy Garcia12,
  • Channelle Tham13
  • 1Department of Medical Imaging, University for Development Studies;
  • 2Institute of Radiography, Lagos, Nigeria;
  • 3Department of Computer Science, University of Carthage, Tunis, Tunisia;
  • 4Obafemi Awolowo University Ile-Ife;
  • 5Department of Radiology, Barau Dikko Teaching Hospital/Kaduna State University, Kaduna, Nigeria;
  • 6Department of Radiology, Lagos University Teaching Hospital, Lagos, Nigeria.;
  • 7Department of Radiology, Federal Teaching Hospital Gombe, Gombe, Nigeria;
  • 8Montreal Neurological Institute, McGill University, Montreal, Canada;
  • 9Oxford University Centre for Integrative Neuroimaging, Oxford University;
  • 10United Arab Emirates University, Al Ain, Abu Dhabi, United Arab Emirates;
  • 11Western University, London, Ontario, Canada;
  • 12McGill University, Montreal, Canada;
  • 13Radboud University, Nijmegen, Netherlands
  • Capstone_Project_Perfusion_CT
  • CONNExIN (COmprehensive Neuroimaging aNalysis Experience In resource constraiNed settings)
Isaac Manny Tigbee
Icon indicating open access to content
QR code linking to this content
DOI: https://dx.doi.org/10.17504/protocols.io.n2bvjenmbgk5/v1
Protocol Citation: Isaac Manny Tigbee, Abraham Awamba, Alaa Bessadok, Jeremiah Oluwatomi Itodo Daniel, Bilkisu Farouk, Ernest Okyere Darko, Bankole Happiness, Said Ibrahim Said, Ethan Draper, Abdalla Z Mohamed, Kesavi Kanagasabai, Udunna Anazodo, Cindy Garcia, Channelle Tham 2026. A Comprehensive Pipeline For Reproducible Analysis of ASL Using Quantiphyse. protocols.io https://dx.doi.org/10.17504/protocols.io.n2bvjenmbgk5/v1
License: This is an open access  protocol  distributed under the terms of the  Creative Commons Attribution License,  which permits unrestricted use, distribution, and reproduction in any medium, provided the original author and source are credited
Protocol status: Working
We use this protocol and it's working
Created: August 27, 2025
Last Modified: January 12, 2026
Protocol  Integer ID: 225663
Keywords: MRI, ASL, Perfusion, Quantiphyse , Fsl, Cbf, neuroimaging, using quantiphyse cerebral perfusion, quantiphyse cerebral perfusion, assessing perfusion, measuring cerebral blood flow, important biomarker for brain performance assessment, blood as an endogenous contrast agent, cerebral blood flow, important biomarker, asl processing option, perfusion, imaging method, creating imaging method, brain performance assessment, using blood, endogenous contrast agent, alzheimer, compliance to the asl processing option
Disclaimer
This pipeline was created by the 2025 Perfusion Team of Comprehensive Neuroimaging Analysis Experience in Resource-Constrained Settings (CONNExIN) as part of the group project of quantifying CBF in a given population using Quantiphyse.
The content in it is for information purposes only and does not serve as clinical, medical, or legal advice. It is not a mandatory pipeline for CBF quantification, however it provides a reproducible straightforward approach.
It has not undergone peer review or formal publication checks. You can make objective and subjective personal research before using any information provided in this pipeline. Neither the authors nor any affiliated organisation can be held liable for the use or misuse of this pipeline's content.
Abstract
Cerebral perfusion is a very important biomarker for brain performance assessment and understanding pathologies related to ageing, like Alzheimer's Disease, and other forms of Dementia. This importance is observed in how much effort has been put in over the years in creating imaging methods to measure perfusion in healthy and diseased populations. One of such methods that is highly effective is Arterial Spin Labeling(ASL). ASL offers an efficient means of measuring cerebral blood flow to assess perfusion in a non invasive and safe manner using blood as an endogenous contrast agent, making it a crucial modality for assessing perfusion in a wide range of populations including infants with fear of radiation risk and patients with kidney issues at risk of Nephrogenic Systemic Fibrosis(NSF) from Gadolinium Based Contrast Agents(GBCAs). This protocol offers a very straightforward and reproducible pipeline for the analysis of ASL images using Quantiphyse. There are express instructions detailing the necessary tools required for every step and the commands or scripts to run. This pipeline covers from Brain Imaging Data Structure(BIDS) compliance to the ASL processing option using Quantiphyse in conjunction with FSL, along with documentation to better understand the motivations and tools behind each step.
Materials
Software Dependencies
Core Analysis Software
Quantiphyse v0.9.9(core application) - Primary analysis platform

Quantiphyse-ASL plugin v0.2.3.post2 - ASL-specific analysis tools

Required Software Libraries
FSL (FMRIB Software Library) v6.0.7.18 - For preprocessing and registration

Anaconda or Miniconda - Python environment management

Python v3.7.12 (recommended) - Core programming language

Sphinx - For HTML report generation

Additional Python Packages
pyobjc (Mac-specific requirement)

numpy (for NaN handling operations)

Supporting Tools
FSLeyes v1.14.2 - For visual inspection of images

BIDS Validator - For dataset validation

Denov2.3.3 - Runtime for BIDS validator

System Requirements
Minimum Hardware
Processor: Core i5 or equivalent

RAM: 8GB

Storage: 20GB free disk space

Operating System: macOS (tested on Sonoma 14.6.1) or Linux

Recommended Hardware
Processor: Apple M3 Pro 11-Core CPU or equivalent

RAM: 18GB

Storage: 300GB free disk space

File Format Dependencies
Required Input Files
ASL data: 4D or subtracted 3D NIfTI files (.nii.gz) in BIDS format

Structural T1w: 3D NIfTI files (.nii.gz) in BIDS format

M0 calibration images: 3D NIfTI files (.nii.gz) in BIDS format

JSON metadata files: Following ASL-BIDS specification with necessary sidecars.

ASL Context file: TSV containing acquisition order

Data Structure
BIDS format compliance required

ASL-BIDS specification for proper organization

Environment Variables
QT_MAC_WANTS_LAYER=1 (macOS Big Sur and later)

Embedded Dependencies
Additional FSL tools: FAST, FLIRT, epi_reg, BASIL v0.2.3.post2, fabber

Custom scripts: datastructure.sh, quick_qc.sh, full_cbf_quant.sh

This protocol requires a properly configured Conda environment with all Quantiphyse ASL plugins installed and FSL correctly set up in the system path.
Before start
This section will help you prepare your computer with the right materials needed to successfully implement this protocol.

Table 1.1: Computing Hardware Requirement

SpecificationMinimum System RequirementsSystem Specification Used for this Protocol
ProcessorCore i5 or moreApple m3Pro 11-Core CPU
Python Version3.7 (Quantiphyse recommended)3.7.12
RAM8GB RAM18GB RAM
Storage20GB of free disk space300GB Free Disk space

Software Installations:
You must also have the following software/software libraries installed:
For Ubuntu/WSL
sudo apt install python3 python3-pip python3-dev
For macOS(using Homebrew)
brew install python

conda create -n qp python=3.7
conda activate qp

  • dcm2niix
conda install -c conda-forge dcm2niix

  • Deno v2.3.3 (for the bids-validator)

conda install conda-forge::deno

  • Quantiphyse + ASL plugin(oxasl) installed in that env.
Visit https://quantiphyse.readthedocs.io/en/latest/basics/install.html or follow the steps below:

Main installation
pip install quantiphyse

Mac (additional step):
pip install pyobjc

Mac note: for recent macOS (Big Sur, Monterey, later), set before starting Quantiphyse:
export QT_MAC_WANTS_LAYER=1

Install build-essential (for plugins that require compilations, like quantiphyse-asl)

sudo apt update
sudo apt install build-essential

Install plugins
pip install quantiphyse-fabber quantiphyse-asl

Install Sphinx

pip install -U sphinx

Launch Quantiphyse

quantiphyse

Pipeline Scripts:

The scripts used in this pipeline can be gotten from the team's GitHub repository.
Visit the GitHub repo and download the latest versions of the following scripts, as they are important for the pipeline processes:

  • datastructure.sh (for BIDS compliance check)
  • quick_qc.sh (for objective QC and light IQM check)
  • full_cbf_quant.sh (for CBF quantification)

Required input files:

This pipeline depends heavily on BIDS compatibility. To use this pipeline, your dataset has to contain the following input folders, according to the ASL-BIDS guidelines:

  • *_asl.nii.gz - 4D NIfTI containing ASL volumes (label/control cycles or multi-PLD volumes) or 3D subtracted ASL file.

  • *_asl.json - JSON sidecar containing acquisition information about the ASL NIfTI file.

  • T1w.nii.gz - 3D T1-weighted anatomical image in subject space (for registration & structural masks).

  • *_m0scan.nii.gz - 3D NIfTI M0 calibration image. In the absence of this, the mean of the control images from the ASL 4D series is used. If the ASL data is already subtracted, a separate m0scan is mandatory.

  • *_m0scan.json - JSON sidecar containing acquisition information about the m0 scan, as well as linking information to the asl scan for the subject/

  • *_asl_context.tsv (strongly recommended) - JSON describing acquisition ordering.

HOW TO KNOW YOU ARE READY TO START
All required dependencies are installed and working properly.
FSL, miniconda, the pipeline scripts, and your input dataset are in the same parent directory (advisably your terminal root directory).
Data
Pipeline Test Data

The data used in the creation, illustration, and evaluation of this pipeline were from the publicly available OSIPI ASL challenge dataset (DRO1) and OMNI SWiM-CONNExIN Training data. You can simply visit https://osf.io/6xyu3 to download the OSIPI ASL Challenge data.
The DRO1 data contains an isotropic 3D T1W image, an m0 calibration scan with TR = 10s, and ASL data with 2D EPI PCASL acquisition and TE/TR = 10.49/4800 ms, labeling duration = 1650 ms, and post-label delay = 2025 ms.
Prepare The Data

The first step, as with every image analysis step, is preparing your data. This involves inspection, visually and, if possible, programmatically, to make sure it is in the right format for the analysis pipelines that would be used. For neuroimaging data, the BIDS Format1 is the accepted format for structuring data for analysis and this is the format that is expected by most software tools that are crucial to most neuroimaging studies, regardless of modality. The BIDS format1 offers a universally accepted and reproducible structure for Neuroimaging data, and it is even made more relevant to this pipeline with the ASL-BIDS2 structure that is more specific to this pipeline. It denotes that ASL data should follow the following format.

Note
dataset/
README
dataset_description.json
participants.tsv
sub-01/
ses-01/ (if applicable)
perf/
sub-01_ses-01_asl.nii.gz
sub-01_ses-01_asl.json
sub-01_ses-01_aslcontext.tsv
sub-01_ses-01_m0scan.nii.gz
sub-01_ses-01_m0scan.json
fmap/ (optional, for distortion correction)
sub-01_ses-01_dir-pa_m0scan.nii.gz
sub-01_ses-01_dir-pa_m0scan.json
anat/
sub-01_ses-01_T1w.nii.gz
sub-01_ses-01_T1w.json
ses-02/
...
sub-02/
...


Important Notes on ASL BIDS:

The m0scan: The M0 calibration image can be stored in two ways, as per the ASL-BIDS specification2:

Within the perf directory:
If the m0 is from a separate scan, it should be included as its own file in the perf subdirectory:
sub-01_ses-01_m0scan.nii.gz
sub-01_ses-01_m0scan.json

As a metadata field:
If the m0 is derived from the ASL time series (e.g., control average), it is not saved as a separate file. Instead, the M0Type parameter is set in the _asl.json file.

Critical JSON Metadata:
The _asl.json file is vital. Check and edit it where necessary to ensure it contains all required ASL parameters, such as:

"ArterialSpinLabelingType": "PCASL" (or "PASL" or "CASL")

"PostLabelingDelay": [1.8, ...]

"LabelingDuration": 1.8

"m0Type": "Separate" (or "Included")

"TotalAcquiredPairs": 10

"BackgroundSuppression": true

All these are some of the parameters collected from the scanner as described in the ISMRM Whitepaper for ASL acquisition.3
Using the Datastructure script

You can assess your dataset to test for BIDS compatibility using the script we created for this pipeline - datastructure.sh. To use it, you will need to have installed the needed dependencies as stated in the Before Start section, as follows:
  • dcm2niix v1.0.20250505
  • deno v2.3.3

To execute this script, simply run the following in order:
Command
this makes the script executable (Mac OS Sonoma 14.6.1)
datastructure script
chmod +x datastructure.sh

Command
this checks if your dataset is BIDS compliant, and gives errors when it is not, as well as instructions for correction (Mac OS Sonoma 14.6.1)
dataset BIDS check
./datastructure.sh $path/to/dataset
Check to see the feedback on the terminal or in the bids_validator.log file created after the run. If your dataset is in the correct ASL-BIDS format, you should get the following feedback:

Expected result
This dataset appears to be BIDS compatible.

Quality Control
Visual Inspection of Structural and Perfusion Images:

Visually inspect the images (structural, asl, and m0 scans where available) using fsleyes(v1.14.2)4.
From your terminal, navigate to the directory containing your dataset and run
Command
This opens up the file in the 3 standard planes(SG, CO, AX). Replace NII_... with the path to your NIfTI file  (Mac OS Sonoma 14.6.1)
FSLEYES Viewer
fsleyes $NII_FILE
For Anatomical T1w scans, inspect for:
  • Motion Artifacts
  • Signal Intensity Issues
  • Pathologies like lesions and tumours.
  • Completeness

For Perfusion ASL scans, inspect for
  • Motion Artifacts
  • Signal Dropout
  • Labeling Efficiency
  • Background Suppression

For M0 calibration scans, inspect for:
  • Contrast
  • Geometric Alignment with ASL series


Conduct objective QC on the Perfusion Nifti and JSON files using a script

You can use the quick_qc.sh script to run a quick QC check on your perfusion data to check for errors in the files and issues with calibration that might affect quantification values. It also does some IQM checks on your BIDS dataset images.

NOTE THE FOLLOWING:
  • Your data must be in BIDS format before using this script as hierarchy matters.
  • This script will also not work for data without separate m0scan as the m0scan files are a crucial factor for its functioning.
  • You should run this script from a working directory that can access your FSL installation.

To use it, first run the following to make the script executable
Command
Making quick_qc.sh executable (Mac OS Sonoma 14.6.1)
chmod +x quick_qc.sh

Command
Replace the $path/to/... by the actual path to your BIDS dataset (Mac OS Sonoma 14.6.1)
Running quick_qc.sh
./quick.sh $path/to/bids/dataset
This will generate a folder named qc under the individual subject directory containing files generated during the QC checks including a html report named $subid_qcreport.html (for example; sub-DR01_qcreport.html). It will also create a csv file called dataset_qc_summary.csv containing QC metrics for all subjects in the dataset and store it in the dataset directory.
For example:
The resultant html report would look like the following:
Expected result
ASL QC Report: sub-DRO10
Generated by quick_qc_bids_full.sh >> ASL NIfTI Checks Dimensions: 64 x64 x36 x60 Voxel size (mm): 3.437500 x3.437500 x4.500000 TR (s) from NIfTI: 4.800000 Scaling factors: 1.000000 ,0.000000 qform/sform codes: qform_code:2,sform_code:2 >> M0 NIfTI Checks Dimensions: 64 x64 x36 x1 Voxel size (mm): 3.437500 x3.437500 x4.500000 Scaling factors: 1.000000 ,0.000000 qform/sform codes: qform_code:2,sform_code:2 >> Cross-Check ASL vs M0 ‱ First 3 dims match between ASL and M0‱ ASL is 4D (multi-volume), M0 is 3D (dim4=1) >> Detected ordering: c-l >> Multi-PLD info: Single-PLD:2.025 >> ΔM / M0 Signal Check Mean ΔM intensity: 3.346600 Mean M0 intensity: 1931.257213 ‱ ΔM/M0 ratio within plausible range (0.002 = 0.2%) >> SNR Checks M0 SNR ≈ 2.89024446336618555093 ASL SNR ≈ 1.81481311555958043764 ASL tSNR ≈ 201.35575415760385708589 >> Motion & Temporal Metrics Mean FD: 0.074015 Max FD: 0.175964 Mean DVARS: 0.009291 Max DVARS: 0.010854 >> Outlier Detection DVARS Threshold: 0.050000 FD Threshold: 0.5 ‱ No outlier frames detected by FD/DVARS criteria. >> Registration & Coverage Checks M0->T1 mask Dice overlap: 0.6679 Coverage of T1 brain by M0 (fraction): 0.991


Analysis
Using the Quantiphyse GUI

The Quantiphyse GUI is user-friendly and gives visual feedback on the steps being taken for Analysis. However, it is not ideal for a dataset with multiple subjects, as it would mean manually getting the needed information per subject run. The full_cbf_quant.sh script can work for single to multiple subject datasets with less need for user interference. To use the script, kindly proceed to the next step. You can continue on this step if you prefer to use the GUI.
The analysis will be done on Quantiphyse(v0.9.9)5, it will handle preprocessing steps as well as processing, pooling tools from FSL(V6.0.7.18)6, and additional installed ASL plugins7.

First of all, you should open Quantiphyse(v0.9.9).5 by typing the following in the terminal:
Command
This opens the conda environment containing Quantiphyse. Replace $PERFUSION_ENV with your environment name (Mac OS Sonoma 14.6.1)
conda environment activation 
conda activate $PERFUSION_ENV

Command
This launches Quantiphyse (Mac OS Sonoma 14.6.1)
Quantiphyse launch
quantiphyse
It should bring up a window on your screen like the following image:


Second, you need to upload your files by clicking on "File" then "Load Data".
In the  Load Data dialog In the  Load Data dialog select Data
Load Data
 dialog select 
Data
Select Data



You will find the data loaded on the right side of the window:



Fix NaN voxels

This is very crucial because NaN(Not a number voxels), when ignored in the perfusion timeseries, would negatively impact the final perfusion map and CBF quantification.
Simply got to Widgets, Processing, then Simple Maths.




Set the command to: np.nan_to_num(asl_file_name)
Example of file input: subDRO10_asl



Once you click on the "Run" button, you will find the output file as you named "subDRO10_asl_nonan" , under the "Volumes" section as shown below. You will use the file subDRO10_asl_nonan for the ASL analysis.



ASL Data Processing

Now, you can proceed with the data processing.


At the ASL data Tab, choose the right file name for the "ASL data", then add the requested information based on data in the JSON files.
Do not forget to put the folder name where the result of processing will be saved.


Under Corrections tab, you need to tick the "Motion correction". This corrects for the artefacts accumulated during the scan due to the patient's movement.



Under the "Structural Data" tab, you need to upload the structural image so that it will be used as a mask for creating the CBF. And do not tick any of the segmentation options, as this will override the automatic segmentation done by Quantiphyse.


Under the "Calibration" tab, choose the calibration image and the option suggested by quantiphyse. Edit the TR appropriately from the JSON file data.


Now you have arrived at the important tab "Analysis" which includes the steps you want Quantiphyse to do for you. Select:
1- Spatial regularization
2- Fix label duration
3- Fix arterial transit time


In the Output tab, make sure to include outputs in the native(ASL) and structural space. Also output mask, calibration data, registration data, structural segmentation, and model fitting data as selected below.


To save the HTML report properly, you need to have installed the package "sphinx" in your conda environment beforehand.

Now you can click on the Run button to start the processing of your ASL data.





If you want to check what is happening behind the scenes, you can click on View log.



The HTML file will appear in your browser after completion of the processing as follows:



You can go to the output results:








Using the CBF Quantification script

To use the full_cbf_quant.sh script, run the following in order:

Command
to make the cbf quantification script executable (Mac OS Sonoma 14.6.1)
Make full_cbf_quant.sh executable
chmod +x full_cbf_quant.sh

Command
this runs the cbf quantification script (Mac OS Sonoma 14.6.1)
run cbf quantification
./full_cbf_quant.sh $path/to/bids/dataset
This script creates subject-level processed folders containing oxasl output images and perfusion values. It also creates a dataset-level CSV file called cbf_quant_summary, containing all relevant cbf output values for all subjects in the input dataset. This script merges data from the participants.tsv file for each subject, providing group data for statistical testing.
What Goes on In The Background?

Quantiphyse uses the OXASL tool in the Quantiphyse-ASL plugin to run the analysis in a way that inculcates preprocessing down to kinetic modeling for the analysis.
Viewing the log, you can appreciate that OXASL runs the following tools:

  • OXASL(v0.2.3.post2)6: This is the primary pipeline that orchestrates the entire ASL data processing workflow. It reads the ASL and structural data, and calls other tools to perform the necessary steps.
  • FAST8: FMRIB's Automated Segmentation Tool is used to segment the structural MRI image into different tissue types: gray matter (GM), white matter (WM), and cerebrospinal fluid (CSF).
  • FLIRT9: FMRIB's Linear Image Registration Tool is used to perform linear transformations (like rotation and translation) to align different images. In this log, it's used to register the ASL data to the structural image and to a standard space (e.g., MNI).
  • epi_reg: This is a specialized tool for Boundary-Based Registration (BBR)10. It's used to perform a more accurate, localized registration of the ASL data to the structural image, specifically by matching the brain boundaries in both images.
  • BASIL(v0.2.3.post2)11: Bayesian Analysis Superior to Inverse Laplace. This is the core quantification tool used to model the ASL signal. It takes the difference images and uses a kinetic model to estimate the Cerebral Blood Flow (CBF) and other parameters, such as the Arterial Transit Time (ATT).
  • fabber12: A general-purpose Bayesian inference tool used by BASIL to perform the mathematical model fitting. It takes the model (aslrest in this case) and the data to infer the most likely values for the perfusion and other parameters.
Reproducibility Test
Testing The Pipeline's Reproducibility

We ran the pipeline on one subject from the publicly available OSIPI dataset (sub-DRO1) and got the following results13, similar to the results gotten by the Quantiphyse team in the OSIPI ASL challenge.
Summary of Quantiphyse implementation and replication analysis performed on one OSIPI ASL Challenge data during the CONNExIN training program. The analyses were performed on personal computers in either graphical user interface (GUI) or command-line (CL) mode.

Protocol references
1. Gorgolewski, K. J., et al. The brain imaging data structure, a format for organizing and describing outputs of neuroimaging experiments. Sci. Data 3, 160044 (2016).
2. Clement, P. et al. ASL-BIDS, the brain imaging data structure extension for arterial spin labeling. Sci. Data 9, 543 (2022)
3. Alsop, D. C. et al. Recommended Implementation of Arterial Spin Labeled Perfusion MRI for Clinical Applications: A consensus of the ISMRM Perfusion Study Group and the European Consortium for ASL in Dementia. J. Magn. Reson. Imaging 22, 778–785 (2015)
4. McCarthy, P. et al. FSLeyes: an accessible, powerful and extensible neuroimaging display tool. NeuroImage 223, 117327 (2020).
5. Craig, M., Irving, B., Chappell, M. & Croal, P. Quantiphyse (v0.9.9) — analysis and visualisation tool for quantitative imaging data. Documentation and software, University of Oxford (2019). Available at: https://quantiphyse.readthedocs.io/en/latest/ (accessed 15 Sep 2025)
6. Jenkinson, M. et al. FSL. NeuroImage 62, 782–790 (2012).
7. Quantiphyse ASL Analysis Tab. Quantiphyse documentation. Available at https://quantiphyse.readthedocs.io/en/latest/asl/asl_analysis.html (Accessed: September 15, 2025).
8. Zhang, Y., Brady, M. & Smith, S. Segmentation of brain MR images through a hidden Markov random field model and the expectation-maximization algorithm. IEEE Trans. Med. Imaging 20, 45-57 (2001).
9. Jenkinson, M. & Smith, S. A global optimisation method for robust affine registration of brain images. Med. Image Anal. 5, 143-156 (2001).
10. Greve, D. N. & Fischl, B. Accurate and robust brain image alignment using boundary-based registration. NeuroImage 48, 63–72 (2009).
11. Chappell, M. A., Groves, A. R., Whitcher, B. & Woolrich, M. W. Variational Bayesian inference for a non-linear forward model. IEEE Trans. Signal Process. 57, 223–236 (2009).
12. Woolrich, M. W., Jbabdi, S., Patenaude, B., Chappell, M., Makni, S., Behrens, T. & Smith, S. M. Bayesian analysis of neuroimaging data in FSL. NeuroImage 45, S173–S186 (2009).
13. Tham C, et al. Capacity building for reproducible ASL perfusion quantification in an African cohort. Abstract submitted for review to the ISMRM Annual Meeting (2025).
Acknowledgements
Tigbee I. M.: Conceptualization, Project Administration, Methodology, Writing – Original Draft, Software, Validation, Writing – Review & Editing.
Bessadok A.: Conceptualization, Methodology, Software, Validation, Formal Analysis, Writing – Review & Editing.
Awamba A. I.: Conceptualization, Methodology, Writing – Original Draft, Software, Validation, Writing – Review & Editing.
Daniel J. O. I.: Conceptualization, Methodology, Writing – Original Draft, Writing – Review & Editing., Wrote the Before Start sections and Statistical Plan sections of the Protocol
Farouk B.U.: Conceptualization, Writing – Original Draft, Writing – Review & Editing.
Darko E. O.: Conceptualization, Writing – Original Draft, Writing – Review & Editing.
Bankole H.: Conceptualization, Writing – Original Draft.
Ibrahim S. S.: Conceptualization, Writing – Review & Editing.
Garcia Cindy: Supervision.
Tham Channelle: Supervision.