OSCR

MICAFlow: Fast and robust MRI preprocessing bridging research neuroimaging and clinical practice.

Code ↔ Paper

17 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 17 matches
  1. [1] § Methods › SynthSeg-driven segmentation and labeling ↔ lamareg/scripts/synthseg.py, lines 1–46 · score 0.84 · neural network, segment brain, contrast agnostic, MRI contrast, SynthSeg, deep
  2. [2] § Methods › SynthSeg-driven segmentation and labeling ↔ micaflow/scripts/synthseg.py, lines 205–296 · score 0.80 · contrast agnostic brain, neural network, MRI contrast, SynthSeg, T2w, anatomical
  3. [3] § Methods › Pipeline overview and architecture ↔ micaflow/cli.py, lines 221–358 · score 0.79 · BIDS batch, DICE scores, transformation matrices, SynthSeg, distortion corrected, derivative
  4. [4] § Methods › Diffusion MRI preprocessing › Susceptibility distortion correction ↔ micaflow/scripts/apply_SDC.py, lines 1–48 · score 0.78 · field inhomogeneity, phase encoding directions, displacement field, diffusion images, unwarps, geometrically
  5. [5] § Methods › Pipeline overview and architecture ↔ micaflow/scripts/motion_correction.py, lines 207–333 · score 0.71 · tensor fitting, bias field correction, brain extraction, distortion correction, eddy, denoising
  6. [6] § Methods › Pipeline overview and architecture ↔ micaflow/cli.py, lines 221–358 · score 0.71 · bias field correction, brain extraction, Snakemake, distortion correction, MicaFlow, configured
  7. [7] § Methods › Diffusion MRI preprocessing › Susceptibility distortion correction ↔ micaflow/scripts/SDC.py, lines 1–82 · score 0.69 · PyTorch, unwarps, blip, Hyperelastic, opposite, inhomogeneity
  8. [8] § Methods › Diffusion MRI preprocessing › Motion and Eddy current correction ↔ micaflow/scripts/motion_correction.py, lines 207–333 · score 0.66 · subject motion, gradient direction, stretch, eddy, shear, geometrical
  9. [9] § Methods › Diffusion MRI preprocessing › Diffusion metric mapping ↔ micaflow/scripts/compute_fa_md.py, lines 486–547 · score 0.65 · diffusion tensor model, fitted tensor, DIPY, FA, maps, metric
  10. [10] § Methods › Diffusion MRI preprocessing › Susceptibility distortion correction ↔ micaflow/scripts/SDC.py, lines 432–497 · score 0.64 · phase encoding axis, geometric distortions, field maps, MICAFlow
  11. [11] § Methods › Diffusion MRI preprocessing ↔ micaflow/scripts/denoise.py, lines 159–258 · score 0.64 · diffusion weighted, diffusion metrics, gradient directions, raw, preprocessing, scans
  12. [12] § Methods › Diffusion MRI preprocessing › Denoising and Gibbs correction ↔ micaflow/scripts/denoise.py, lines 159–258 · score 0.61 · Gibbs ringing, Patch2Self, denoising, noise, algorithm, preprocessing
  13. [13] § Methods › Diffusion MRI preprocessing › Susceptibility distortion correction ↔ micaflow/scripts/apply_SDC.py, lines 123–169 · score 0.58 · susceptibility induced, geometric distortions, phase encoded, axis, field, maps
  14. [14] § Methods › Pipeline overview and architecture ↔ micaflow/cli.py, lines 361–443 · score 0.57 · MICAFlow pipeline, Snakemake, execution, interface, Python, command
  15. [15] § Methods › Structural MRI preprocessing ↔ micaflow/scripts/bias_correction.py, lines 558–645 · score 0.52 · N4 bias field, bias correction, T2w, ANTs, anatomical, intensity
  16. [16] § Methods › Structural MRI preprocessing ↔ micaflow/scripts/coregister.py, lines 169–292 · score 0.52 · standard space, LAMAReg, MNI152, matching, nonlinear, anatomical
  17. [17] § Results ↔ lamareg/scripts/coregister.py, lines 406–463 · score 0.50 · ANTsPy, environment variables, thread, linear, LAMAReg

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 1,925 lines · 85 KB · GPL-3.0 · 3 matches

  1. #!/usr/bin/env python3
  2. """
  3. cli - Command-Line Interface for MicaFlow MRI Processing Pipeline
  5. This module provides the main command-line interface (CLI) for the MicaFlow
  6. neuroimaging processing pipeline. It handles command routing, argument parsing,
  7. and execution of both the full pipeline and individual processing modules.
  9. Architecture:
  10. ------------
  11. The CLI uses a two-level command structure:
  12. 1. Main command: 'micaflow [command]' routes to either the pipeline or a module
  13. 2. Module commands: Each processing module has its own subcommand with specific arguments
  15. The CLI intercepts help requests before argparse to provide custom, color-coded help
  16. messages for each command. Arguments are dynamically transformed and forwarded to
  17. the appropriate processing scripts.
  19. Available Commands:
  20. ------------------
  21. Pipeline Command:
  22. pipeline : Run the full Snakemake-based processing pipeline
  24. Preprocessing Modules:
  25. bet : Brain extraction using HD-BET
  26. bias_correction : N4 bias field correction
  27. denoise : Patch2Self denoising for DWI
  28. motion_correction : Motion correction for DWI
  29. normalize_intensity: Normalize image intensity profiles
  31. Registration Modules:
  32. coregister : Image coregistration using ANTs
  33. apply_warp : Apply transformations to images
  35. Distortion Correction:
  36. SDC : Susceptibility distortion correction
  37. apply_SDC : Apply precomputed SDC warp fields
  38. synth_b0 : Synthetic B0 generation
  40. Segmentation and Analysis:
  41. synthseg : SynthSeg brain segmentation
  42. texture_generation: Texture feature extraction
  43. compute_fa_md : DTI metric computation
  45. Utilities:
  46. extract_b0 : Extract b=0 volumes from DWI
  47. calculate_dice : DICE coefficient calculation
  49. Command Routing:
  50. ---------------
  51. 1. User runs: micaflow [command] [args...]
  52. 2. CLI checks for help flags and intercepts if present
  53. 3. Command is routed to either:
  54. - Snakemake pipeline (for 'pipeline' command)
  55. - Individual script (for module commands)
  56. 4. Arguments are formatted and passed to the target
  58. Argument Transformation:
  59. -----------------------
  60. The CLI transforms Python-style argument names (with underscores) to
  61. command-line style (with hyphens) automatically:
  63. Python: output_mask -> CLI: --output-mask
  64. Python: direction_dimension -> CLI: --direction-dimension
  66. This ensures consistency between the CLI parser and individual scripts.
  68. Features:
  69. --------
  70. - Color-coded help messages using colorama
  71. - Custom help formatting with extended descriptions
  72. - Automatic help interception for subcommands
  73. - Dynamic argument forwarding to processing scripts
  74. - Support for both pipeline and standalone module execution
  75. - Comprehensive error handling and reporting
  76. - Dry-run support for pipeline execution
  78. Exit Codes:
  79. ----------
  80. 0 : Success - command completed successfully
  81. 1 : Error - command failed, file not found, or invalid arguments
  83. Examples:
  84. --------
  85. # Show main help
  86. $ micaflow
  87. $ micaflow --help
  89. # Show help for specific command
  90. $ micaflow bet --help
  91. $ micaflow synthseg -h
  93. # Run full pipeline
  94. $ micaflow pipeline --subject sub-001 --t1w-file t1.nii.gz --output /out
  96. # Run individual module
  97. $ micaflow bet --input t1.nii.gz --output brain.nii.gz --output-mask mask.nii.gz
  99. # Dry run (pipeline only)
  100. $ micaflow pipeline --dry-run --subject sub-001 --t1w-file t1.nii.gz
  102. Notes:
  103. -----
  104. - The CLI uses subprocess.run() to execute individual scripts
  105. - All scripts are invoked as Python modules: python -m micaflow.scripts.[name]
  106. - The pipeline command uses Snakemake for workflow management
  107. - Configuration can be provided via command-line args or YAML config file
  108. """
  110. import argparse
  111. import sys
  112. import subprocess
  113. import glob
  114. import os
  115. import time
  116. import json
  117. import datetime
  118. import urllib.request
  119. import zipfile
  120. import tempfile
  121. import shutil
  122. from colorama import init, Fore, Style
  123. import importlib.resources
  125. init()
  127. def check_and_download_models():
  128. """
  129. Checks if the models and atlas directories are populated.
  130. If not, downloads and extracts them from the MICAFlow-Models GitHub repository.
  131. """
  132. base_path = os.path.dirname(os.path.abspath(__file__))
  133. models_dir = os.path.join(base_path, "models")
  134. atlas_dir = os.path.join(base_path, "resources", "atlas")
  136. # Check if directories exist and have files
  137. models_full = os.path.exists(models_dir) and len(os.listdir(models_dir)) > 0
  138. atlas_full = os.path.exists(atlas_dir) and len(os.listdir(atlas_dir)) > 0
  140. if models_full and atlas_full:
  141. return
  143. print(f"{Fore.YELLOW}Required models or atlases are missing. Downloading from MICAFlow-Models repository...{Style.RESET_ALL}")
  145. os.makedirs(models_dir, exist_ok=True)
  146. os.makedirs(atlas_dir, exist_ok=True)
  148. url = "https://github.com/MICA-MNI/MICAFlow-Models/archive/refs/heads/main.zip"
  150. try:
  151. with tempfile.TemporaryDirectory() as temp_dir:
  152. zip_path = os.path.join(temp_dir, "models.zip")
  153. print(f"{Fore.CYAN}Downloading {url}...{Style.RESET_ALL}")
  154. urllib.request.urlretrieve(url, zip_path)
  156. print(f"{Fore.CYAN}Extracting files...{Style.RESET_ALL}")
  157. with zipfile.ZipFile(zip_path, 'r') as zip_ref:
  158. zip_ref.extractall(temp_dir)
  160. repo_dir = os.path.join(temp_dir, "MICAFlow-Models-main")
  162. # Map elements from repo to the tool's expected locations
  163. repo_models = os.path.join(repo_dir, "models")
  164. if os.path.exists(repo_models):
  165. shutil.copytree(repo_models, models_dir, dirs_exist_ok=True)
  167. repo_atlas = os.path.join(repo_dir, "resources", "atlas")
  168. repo_atlas_alt = os.path.join(repo_dir, "atlas")
  170. if os.path.exists(repo_atlas):
  171. shutil.copytree(repo_atlas, atlas_dir, dirs_exist_ok=True)
  172. elif os.path.exists(repo_atlas_alt):
  173. shutil.copytree(repo_atlas_alt, atlas_dir, dirs_exist_ok=True)
  175. print(f"{Fore.GREEN}Models and atlases downloaded successfully!{Style.RESET_ALL}")
  176. except Exception as e:
  177. print(f"{Fore.RED}Failed to download or extract models: {e}{Style.RESET_ALL}")
  180. def get_snakefile_path():
  181. """
  182. Get the path to the Snakefile within the installed package using importlib.resources.
  184. Returns
  185. -------
  186. str
  187. Absolute path to the Snakefile for use with Snakemake.
  189. Raises
  190. ------
  191. pkg_resources.DistributionNotFound
  192. If the micaflow package is not installed.
  193. pkg_resources.ResourceNotFound
  194. If the Snakefile is not found in the package resources.
  196. Examples
  197. --------
  198. >>> snakefile = get_snakefile_path()
  199. >>> print(snakefile)
  200. /path/to/site-packages/micaflow/resources/Snakefile
  202. >>> # Use with snakemake command
  203. >>> cmd = ['snakemake', '-s', get_snakefile_path(), '--cores', '4']
  205. Notes
  206. -----
  207. - The Snakefile must be in micaflow/resources/Snakefile
  208. - Path is resolved at runtime based on installation location
  209. - Used exclusively by the 'pipeline' command
  210. """
  211. try:
  212. # Python 3.9+: files() returns a Traversable object
  213. snakefile = importlib.resources.files("micaflow.resources").joinpath("Snakefile")
  214. return str(snakefile)
  215. except Exception:
  216. # Fallback for older Python versions
  217. import pkg_resources
  218. return pkg_resources.resource_filename("micaflow", "resources/Snakefile")
  221. def print_extended_help():
  222. # ANSI color codes
  223. CYAN = Fore.CYAN
  224. GREEN = Fore.GREEN
  225. YELLOW = Fore.YELLOW
  226. BLUE = Fore.BLUE
  227. MAGENTA = Fore.MAGENTA
  228. BOLD = Style.BRIGHT
  229. RESET = Style.RESET_ALL
  231. help_msg = f"""
  232. {CYAN}{BOLD}╔════════════════════════════════════════════════════════════════╗
  233. ║ MICAFLOW MRI PROCESSING PIPELINE ║
  234. ╚════════════════════════════════════════════════════════════════╝{RESET}
  236. MicaFlow is a comprehensive pipeline for processing structural and
  237. diffusion MRI data, with various modules that can be used independently.
  239. {CYAN}{BOLD}────────────────────────── USAGE ──────────────────────────{RESET}
  240. micaflow {GREEN}[command]{RESET} [options]
  241. micaflow {GREEN}pipeline{RESET} [options]
  242. micaflow {GREEN}bids{RESET} [options]
  244. {CYAN}{BOLD}─────────────────── AVAILABLE COMMANDS ───────────────────{RESET}
  245. {GREEN}pipeline{RESET} : Run the full processing pipeline (default)
  246. {GREEN}bids{RESET} : Run the pipeline on an entire BIDS dataset (batch mode)
  247. {GREEN}apply_warp{RESET} : Apply transformation to warp an image to a reference space
  248. {GREEN}bet{RESET} : Run brain extraction (using mask/SynthSeg)
  249. {GREEN}bias_correction{RESET} : Run N4 Bias Field Correction
  250. {GREEN}calculate_dice{RESET} : Calculate DICE score between two segmentations
  251. {GREEN}compute_fa_md{RESET} : Compute Fractional Anisotropy and Mean Diffusivity maps
  252. {GREEN}coregister{RESET} : Coregister a moving image to a reference image
  253. {GREEN}denoise{RESET} : Denoise diffusion-weighted images using Patch2Self
  254. {GREEN}motion_correction{RESET} : Perform motion correction on diffusion-weighted images
  255. {GREEN}normalize_intensity{RESET}: Normalize image intensity profiles
  256. {GREEN}SDC{RESET} : Run Susceptibility Distortion Correction on DWI images
  257. {GREEN}apply_SDC{RESET} : Apply pre-computed SDC warp field to an image
  258. {GREEN}synthseg{RESET} : Run SynthSeg brain segmentation
  259. {GREEN}texture_generation{RESET}: Generate texture features from neuroimaging data
  261. {CYAN}{BOLD}──────────────── PIPELINE REQUIRED PARAMETERS ────────────{RESET}
  262. {YELLOW}--subject{RESET} SUBJECT_ID Subject ID
  263. {YELLOW}--output{RESET} OUTPUT_DIR Output directory
  264. {YELLOW}--t1w-file{RESET} T1-weighted image file
  266. {CYAN}{BOLD}──────────────── PIPELINE OPTIONAL PARAMETERS ────────────{RESET}
  267. {YELLOW}--data-directory{RESET} DATA_DIR Input data directory
  268. {YELLOW}--session{RESET} SESSION_ID Session ID (default: none)
  269. {YELLOW}--flair-file{RESET} FLAIR_FILE FLAIR image file
  270. {YELLOW}--dwi-file{RESET} DWI_FILE Diffusion weighted image
  271. {YELLOW}--bval-file{RESET} B-value file for DWI
  272. {YELLOW}--bvec-file{RESET} B-vector file for DWI
  273. {YELLOW}--inverse-dwi-file{RESET} INV_FILE Inverse (PA) DWI for distortion correction
  274. {YELLOW}--inverse-bval-file{RESET} INV_BVAL Inverse b-value file for DWI
  275. {YELLOW}--inverse-bvec-file{RESET} INV_BVEC Inverse b-vector file for DWI
  276. {YELLOW}--gpu{RESET} Use GPU for computation
  277. {YELLOW}--cores{RESET} Number of CPU cores to use (default: 1)
  278. {YELLOW}--dry-run{RESET}, {YELLOW}-n{RESET} Dry run (don't execute commands)
  279. {YELLOW}--config-file{RESET} FILE Path to a YAML configuration file
  280. {YELLOW}--extract-brain{RESET} Generate brain-extracted versions of all outputs in a dedicated directory
  281. {YELLOW}--keep-temp{RESET} Keep temporary processing files (useful for debugging)
  282. {YELLOW}--rm-cerebellum{RESET} Remove cerebellum from brain extraction outputs
  283. {YELLOW}--PED{RESET} Phase encoding direction of DWI, options are: 'ap', 'pa', 'lr', 'rl', 'si', 'is' (default: 'pa')
  284. {YELLOW}--direction-dimension{RESET} Dimension of the DWI image referring to directions (default: 3)
  285. {YELLOW}--linear{RESET} Use linear-only registration to MNI space (if specified alone)
  286. {YELLOW}--nonlinear{RESET} Use nonlinear registration to MNI space (default if neither specified)
  288. {CYAN}{BOLD}─────────────────── BIDS BATCH USAGE ────────────────────{RESET}
  289. micaflow {GREEN}bids{RESET} {YELLOW}--bids-dir{RESET} PATH {YELLOW}--output-dir{RESET} PATH [options]
  291. {BLUE}# Process entire BIDS directory{RESET}
  292. micaflow {GREEN}bids{RESET} {YELLOW}--bids-dir{RESET} /data/bids {YELLOW}--output-dir{RESET} /data/derivatives \\
  293. {YELLOW}--cores{RESET} 4 {YELLOW}--gpu{RESET}
  295. {BLUE}# Process specific subjects with custom suffixes{RESET}
  296. micaflow {GREEN}bids{RESET} {YELLOW}--bids-dir{RESET} /data/bids {YELLOW}--output-dir{RESET} /data/derivatives \\
  297. {YELLOW}--participant-label{RESET} 001 002 {YELLOW}--dwi-suffix{RESET} dwi_acq-AP.nii.gz
  299. {CYAN}{BOLD}────────────────── EXAMPLE PIPELINE USAGE ───────────────{RESET}
  301. {BLUE}# Process a single subject with T1w only{RESET}
  302. micaflow {GREEN}pipeline{RESET} {YELLOW}--subject{RESET} sub-001 {YELLOW}--session{RESET} ses-01 \\
  303. {YELLOW}--data-directory{RESET} /data {YELLOW}--t1w-file{RESET} sub-001_ses-01_T1w.nii.gz \\
  304. {YELLOW}--output{RESET} /output {YELLOW}--cores{RESET} 4
  306. {BLUE}# Process with FLAIR and brain extraction{RESET}
  307. micaflow {GREEN}pipeline{RESET} {YELLOW}--subject{RESET} sub-001 {YELLOW}--session{RESET} ses-01 \\
  308. {YELLOW}--data-directory{RESET} /data {YELLOW}--t1w-file{RESET} sub-001_ses-01_T1w.nii.gz \\
  309. {YELLOW}--flair-file{RESET} sub-001_ses-01_FLAIR.nii.gz {YELLOW}--output{RESET} /output \\
  310. {YELLOW}--extract-brain{RESET} {YELLOW}--cores{RESET} 4
  312. {BLUE}# Process with diffusion data, keep temporary files and remove cerebellum{RESET}
  313. micaflow {GREEN}pipeline{RESET} {YELLOW}--subject{RESET} sub-001 {YELLOW}--session{RESET} ses-01 \\
  314. {YELLOW}--data-directory{RESET} /data {YELLOW}--t1w-file{RESET} sub-001_ses-01_T1w.nii.gz \\
  315. {YELLOW}--dwi-file{RESET} sub-001_ses-01_dwi.nii.gz \\
  316. {YELLOW}--bval-file{RESET} sub-001_ses-01_dwi.bval {YELLOW}--bvec-file{RESET} sub-001_ses-01_dwi.bvec \\
  317. {YELLOW}--inverse-dwi-file{RESET} sub-001_ses-01_acq-PA_dwi.nii.gz \\
  318. {YELLOW}--output{RESET} /output {YELLOW}--keep-temp{RESET} {YELLOW}--rm-cerebellum{RESET} {YELLOW}--cores{RESET} 4
  320. {CYAN}{BOLD}─────────────────── EXAMPLE MODULE USAGE ────────────────{RESET}
  322. {BLUE}# Run brain extraction{RESET}
  323. micaflow {GREEN}bet{RESET} {YELLOW}--input{RESET} t1w.nii.gz {YELLOW}--output{RESET} brain.nii.gz {YELLOW}--output-mask{RESET} mask.nii.gz
  325. {BLUE}# Run brain extraction with cerebellum removal{RESET}
  326. micaflow {GREEN}bet{RESET} {YELLOW}--input{RESET} t1w.nii.gz {YELLOW}--output{RESET} brain.nii.gz {YELLOW}--output-mask{RESET} mask.nii.gz {YELLOW}--remove-cerebellum{RESET}
  328. {BLUE}# Run SynthSeg segmentation{RESET}
  329. micaflow {GREEN}synthseg{RESET} {YELLOW}--i{RESET} t1w.nii.gz {YELLOW}--o{RESET} segmentation.nii.gz {YELLOW}--parc{RESET}
  331. {BLUE}# Apply warp transformation{RESET}
  332. micaflow {GREEN}apply_warp{RESET} {YELLOW}--moving{RESET} t1w.nii.gz {YELLOW}--reference{RESET} template.nii.gz \\
  333. {YELLOW}--warp{RESET} warp.nii.gz {YELLOW}--affine{RESET} transform.mat {YELLOW}--output{RESET} warped.nii.gz
  335. {CYAN}{BOLD}───────────────── OUTPUT DIRECTORY STRUCTURE ────────────{RESET}
  336. output/
  337. └── <subject>/
  338. └── <session>/
  339. ├── anat/ # Anatomical images (bias-corrected)
  340. ├── brain-extracted/ # Brain-extracted images (with --extract-brain)
  341. ├── dwi/ # Processed diffusion data and DTI metrics
  342. ├── metrics/ # Quality metrics and DICE scores
  343. ├── temp/ # Temporary files (preserved with --keep-temp)
  344. ├── textures/ # Texture features
  345. └── xfm/ # Transformation matrices and warps
  347. {CYAN}{BOLD}────────────────────────── NOTES ───────────────────────{RESET}
  348. {MAGENTA}•{RESET} For help on a specific module: micaflow [command] --help
  349. {MAGENTA}•{RESET} The pipeline uses Snakemake for workflow management
  350. {MAGENTA}•{RESET} Config file can be used to specify parameters instead of command line options
  351. {MAGENTA}•{RESET} Each module can be run independently with its own set of parameters
  352. {MAGENTA}•{RESET} Use --extract-brain to generate skull-stripped versions of all outputs in a dedicated directory
  353. {MAGENTA}•{RESET} Use --keep-temp to preserve intermediate files (useful for debugging)
  354. {MAGENTA}•{RESET} Use --rm-cerebellum to remove cerebellum from brain extraction outputs
  356. For more detailed help on any command, use: micaflow {GREEN}[command]{RESET} {YELLOW}--help{RESET}
  357. """
  358. return help_msg
  361. def main():
  362. """
  363. Main entry point for the MicaFlow command-line interface.
  365. This function handles all CLI operations including:
  366. - Argument parsing for pipeline and module commands
  367. - Help message interception and display
  368. - Command routing to appropriate handlers
  369. - Dynamic argument transformation and forwarding
  370. - Error handling and reporting
  372. The function uses a two-level command structure where the first argument
  373. determines whether to run the full pipeline or an individual module.
  375. Flow:
  376. -----
  377. 1. Check for help flags or no arguments -> display help and exit
  378. 2. Intercept subcommand help requests before argparse processing
  379. 3. Parse arguments using argparse with custom formatter
  380. 4. Route to appropriate command handler:
  381. - 'pipeline': Build and execute Snakemake command
  382. - Module commands: Transform args and execute module script
  383. 5. Handle errors and report results
  385. Command Routing:
  386. ---------------
  387. Pipeline Command:
  388. - Collects configuration parameters
  389. - Builds Snakemake command with --config options
  390. - Optionally loads YAML config file
  391. - Executes via subprocess.run()
  393. Module Commands:
  394. - Transform Python-style args to CLI-style (underscores to hyphens)
  395. - Build command-line argument list
  396. - Execute via subprocess.run() with python -m
  397. - Report results and any errors
  399. Argument Transformation:
  400. -----------------------
  401. For module commands, arguments are transformed:
  402. - Python: output_mask -> CLI: --output-mask
  403. - Python: direction_dimension -> CLI: --direction-dimension
  404. - Boolean flags: Included only if True
  405. - Lists: Expanded into multiple values
  407. Exit Codes:
  408. ----------
  409. 0 : Success - command completed
  410. 1 : Error - command failed or invalid arguments
  412. Examples
  413. --------
  414. >>> # Run from command line
  415. >>> # micaflow
  416. >>> # micaflow pipeline --subject sub-001 --t1w-file t1.nii.gz
  417. >>> # micaflow bet --input t1.nii.gz --output brain.nii.gz
  419. >>> # Can also be called programmatically
  420. >>> if __name__ == "__main__":
  421. ... main()
  423. Raises
  424. ------
  425. subprocess.CalledProcessError
  426. If a module or pipeline command fails during execution.
  427. SystemExit
  428. Called with exit code 0 or 1 depending on success/failure.
  430. Notes
  431. -----
  432. - Uses subprocess.run() for all command execution
  433. - Scripts executed as Python modules: python -m micaflow.scripts.[name]
  434. - Help is intercepted before argparse to allow custom formatting
  435. - Unknown arguments passed through to Snakemake for pipeline command
  436. - Print statements used for user feedback (not logging framework)
  438. See Also
  439. --------
  440. print_extended_help : Extended help message display
  441. get_snakefile_path : Get path to pipeline Snakefile
  442. """
  443. check_and_download_models()
  445. # If no arguments provided, show help and exit
  446. if len(sys.argv) == 1:
  447. print(print_extended_help())
  448. sys.exit(0)
  450. # Intercept help requests for subcommands before argparse processes them
  451. # This allows us to show custom help for individual modules
  452. if (len(sys.argv) >= 3 and sys.argv[2] in ["-h", "--help"]) or len(sys.argv) == 2:
  453. # Check if the first argument is a valid command
  454. command = sys.argv[1]
  456. # Map of command names to their Python module paths
  457. script_map = {
  458. "apply_warp": "micaflow.scripts.apply_warp",
  459. "bet": "micaflow.scripts.bet",
  460. "bias_correction": "micaflow.scripts.bias_correction",
  461. "calculate_dice": "micaflow.scripts.calculate_dice",
  462. "compute_fa_md": "micaflow.scripts.compute_fa_md",
  463. "coregister": "micaflow.scripts.coregister",
  464. "denoise": "micaflow.scripts.denoise",
  465. "motion_correction": "micaflow.scripts.motion_correction",
  466. "SDC": "micaflow.scripts.SDC",
  467. "apply_SDC": "micaflow.scripts.apply_SDC",
  468. "synthseg": "micaflow.scripts.synthseg",
  469. "texture_generation": "micaflow.scripts.texture_generation",
  470. "normalize": "micaflow.scripts.normalize",
  471. }
  473. if command in script_map:
  474. if command != "pipeline": # Special case for pipeline
  475. try:
  476. print(f"\n=== Help for '{command}' command ===\n")
  477. subprocess.run(
  478. ["python", "-m", script_map[command], "--help"], check=True
  479. )
  480. sys.exit(0)
  481. except subprocess.CalledProcessError as e:
  482. print(f"Error displaying help for {command}: {e}")
  483. sys.exit(1)
  485. # Create custom formatter that includes our extended help
  486. class CustomHelpFormatter(argparse.HelpFormatter):
  487. """
  488. Custom help formatter for argparse that displays extended help.
  490. This formatter overrides the default argparse help to show the
  491. comprehensive, color-coded help message from print_extended_help().
  492. """
  493. def __init__(self, *args, **kwargs):
  494. super().__init__(*args, **kwargs, width=100)
  496. def format_help(self):
  497. # Include standard argparse help and our extended help
  498. standard_help = super().format_help()
  499. if "-h" in sys.argv or "--help" in sys.argv:
  500. return print_extended_help()
  501. return standard_help
  503. parser = argparse.ArgumentParser(
  504. description="Run the micaflow MRI processing pipeline",
  505. formatter_class=CustomHelpFormatter,
  506. )
  508. # Create subparsers for different commands
  509. subparsers = parser.add_subparsers(dest="command", help="Commands")
  511. # Add arguments that match the config parameters
  512. # Pipeline command (default)
  513. pipeline_parser = subparsers.add_parser(
  514. "pipeline", help="Run the full micaflow pipeline"
  515. )
  516. # Add pipeline arguments
  517. pipeline_parser.add_argument("--subject", required=True, help="Subject ID (e.g., sub-01)")
  518. pipeline_parser.add_argument("--session", help="Session ID (e.g., ses-01)")
  519. # CHANGE: --output to --output-dir
  520. pipeline_parser.add_argument("--output-dir", required=True, help="Output directory")
  521. # CHANGE: --data-directory to --data-dir to match --bids-dir naming convention
  522. pipeline_parser.add_argument(
  523. "--data-dir", default="", help="Data directory path"
  524. )
  525. pipeline_parser.add_argument("--flair-file", help="Path to FLAIR image")
  526. pipeline_parser.add_argument("--t1w-file", required=True, help="Path to T1w image")
  527. pipeline_parser.add_argument("--dwi-file", help="Path to DWI image")
  528. pipeline_parser.add_argument("--bval-file", help="Path to bval file")
  529. pipeline_parser.add_argument("--bvec-file", help="Path to bvec file")
  530. pipeline_parser.add_argument("--inverse-dwi-file", help="Path to inverse DWI file")
  531. pipeline_parser.add_argument("--inverse-bval-file", help="Path to inverse bval file")
  532. pipeline_parser.add_argument("--inverse-bvec-file", help="Path to inverse bvec file")
  533. pipeline_parser.add_argument(
  534. "--gpu", action="store_true", help="Use GPU computation"
  535. )
  536. pipeline_parser.add_argument(
  537. "--dry-run", "-n", action="store_true", help="Dry run (don't execute commands)"
  538. )
  539. pipeline_parser.add_argument(
  540. "--cores", type=int, default=1,
  541. help="Number of Snakemake jobs to run in parallel (Snakemake --cores)"
  542. )
  543. pipeline_parser.add_argument(
  544. "--config-file", help="Path to a YAML configuration file"
  545. )
  546. pipeline_parser.add_argument(
  547. "--rm-cerebellum", action="store_true", help="Remove cerebellum from images"
  548. )
  549. pipeline_parser.add_argument(
  550. "--keep-temp", action="store_true", help="Keep temporary files after processing"
  551. )
  552. pipeline_parser.add_argument(
  553. "--extract-brain", action="store_true", help="Keep brain-extracted images"
  554. )
  555. pipeline_parser.add_argument(
  556. "--PED", default="pa", help="Phase encoding direction of DWI, options are: 'ap', 'pa', 'lr', 'rl', 'si', 'is'"
  557. )
  558. pipeline_parser.add_argument(
  559. "--direction-dimension", type=int, default=3, help="Dimension of the DWI image referring to directions"
  560. )
  561. pipeline_parser.add_argument(
  562. "--linear", action="store_true", help="Use linear-only registration to MNI space (if specified alone)"
  563. )
  564. pipeline_parser.add_argument(
  565. "--nonlinear", action="store_true", help="Use nonlinear registration to MNI space (default if neither specified)"
  566. )
  568. # BIDS Batch Processing Command
  569. bids_parser = subparsers.add_parser(
  570. "bids", help="Run the pipeline on an entire BIDS dataset"
  571. )
  572. bids_parser.add_argument("--bids-dir", required=True, help="Path to BIDS root directory")
  573. bids_parser.add_argument("--output-dir", required=True, help="Path to derivatives/output directory")
  574. bids_parser.add_argument("--participant-label", nargs="+", help="Specific list of subjects to process (without 'sub-' prefix)")
  575. bids_parser.add_argument("--session-label", nargs="+", help="Specific list of sessions to process (without 'ses-' prefix)")
  577. # ADD THIS LINE:
  578. bids_parser.add_argument("--analysis-level", choices=["participant", "group"], default="participant", help="Processing level (participant or group)")
  580. # Suffix configuration
  581. bids_parser.add_argument("--t1w-suffix", default="T1w.nii.gz", help="Suffix for T1w images (default: T1w.nii.gz)")
  582. bids_parser.add_argument("--flair-suffix", help="Suffix for FLAIR images (e.g. FLAIR.nii.gz). If not provided, FLAIR is skipped.")
  583. bids_parser.add_argument("--dwi-suffix", help="Suffix for DWI images (e.g. dwi.nii.gz). If not provided, DWI is skipped.")
  584. bids_parser.add_argument("--inverse-dwi-suffix", help="Suffix for Inverse DWI images (e.g. acq-rpe_dwi.nii.gz). If not provided, ignored.")
  585. bids_parser.add_argument("--bval-suffix", help="Suffix for bval files (e.g. dwi.bval). If not provided, bval is skipped.")
  586. bids_parser.add_argument("--bvec-suffix", help="Suffix for bvec files (e.g. dwi.bvec). If not provided, bvec is skipped.")
  587. bids_parser.add_argument("--inverse-bval-suffix", help="Suffix for inverse bval files (e.g. acq-rpe_dwi.bval). If not provided, ignored.")
  588. bids_parser.add_argument("--inverse-bvec-suffix", help="Suffix for inverse bvec files (e.g. acq-rpe_dwi.bvec). If not provided, ignored.")
  590. # Passthrough arguments
  591. bids_parser.add_argument("--gpu", action="store_true", help="Use GPU computation")
  592. bids_parser.add_argument("--dry-run", "-n", action="store_true", help="Print commands without executing")
  593. bids_parser.add_argument("--cores", type=int, default=1, help="Number of cores per subject")
  594. bids_parser.add_argument("--rm-cerebellum", action="store_true", help="Remove cerebellum")
  595. bids_parser.add_argument("--extract-brain", action="store_true", help="Generate brain-extracted outputs")
  596. bids_parser.add_argument("--keep-temp", action="store_true", help="Keep temporary files")
  597. bids_parser.add_argument("--linear", action="store_true", help="Use linear-only registration")
  598. bids_parser.add_argument("--nonlinear", action="store_true", help="Use nonlinear registration")
  599. bids_parser.add_argument("--PED", default="pa", help="Phase encoding direction (default: pa)")
  600. bids_parser.add_argument("--direction-dimension", type=int, default=3, help="Direction dimension")
  601. bids_parser.add_argument("--config-file", help="YAML config file")
  603. # SynthSeg command
  604. synthseg_parser = subparsers.add_parser(
  605. "synthseg", help="Run SynthSeg brain segmentation"
  606. )
  607. synthseg_parser.add_argument(
  608. "--input", help="Image(s) to segment. Can be a path to an image or to a folder."
  609. )
  610. synthseg_parser.add_argument(
  611. "--output",
  612. help="Segmentation output(s). Must be a folder if --input designates a folder.",
  613. )
  614. synthseg_parser.add_argument(
  615. "--parc",
  616. action="store_true",
  617. help="(optional) Whether to perform cortex parcellation.",
  618. )
  619. synthseg_parser.add_argument(
  620. "--robust",
  621. action="store_true",
  622. help="(optional) Whether to use robust predictions (slower).",
  623. )
  624. synthseg_parser.add_argument(
  625. "--fast",
  626. action="store_true",
  627. help="(optional) Bypass some postprocessing for faster predictions.",
  628. )
  629. synthseg_parser.add_argument(
  630. "--ct",
  631. action="store_true",
  632. help="(optional) Clip intensities to [0,80] for CT scans.",
  633. )
  634. synthseg_parser.add_argument(
  635. "--vol",
  636. help="(optional) Path to output CSV file with volumes (mm3) for all regions and subjects.",
  637. )
  638. synthseg_parser.add_argument(
  639. "--qc",
  640. help="(optional) Path to output CSV file with qc scores for all subjects.",
  641. )
  642. synthseg_parser.add_argument(
  643. "--post",
  644. help="(optional) Posteriors output(s). Must be a folder if --i designates a folder.",
  645. )
  646. synthseg_parser.add_argument(
  647. "--resample",
  648. help="(optional) Resampled image(s). Must be a folder if --i designates a folder.",
  649. )
  650. synthseg_parser.add_argument(
  651. "--crop",
  652. nargs="+",
  653. type=int,
  654. help="(optional) Size of 3D patches to analyse. Default is 192.",
  655. )
  656. synthseg_parser.add_argument(
  657. "--threads", help="(optional) Number of cores to be used. Default is 1."
  658. )
  659. synthseg_parser.add_argument(
  660. "--cpu",
  661. action="store_true",
  662. help="(optional) Enforce running with CPU rather than GPU.",
  663. )
  664. synthseg_parser.add_argument(
  665. "--v1",
  666. action="store_true",
  667. help="(optional) Use SynthSeg 1.0 (updated 25/06/22).",
  668. )
  670. # SDC command
  671. apply_sdc_parser = subparsers.add_parser("apply_SDC")
  672. apply_sdc_parser.add_argument(
  673. "--input",
  674. required=True,
  675. help="Path to the motion-corrected DWI image (.nii.gz)",
  676. )
  677. apply_sdc_parser.add_argument(
  678. "--warp",
  679. required=True,
  680. help="Path to the warp field estimated from SDC (.nii.gz)",
  681. )
  682. apply_sdc_parser.add_argument(
  683. "--affine",
  684. required=True,
  685. help="Path to an image from which to extract the affine matrix",
  686. )
  687. apply_sdc_parser.add_argument(
  688. "--output", required=True, help="Output path for the corrected image"
  689. )
  691. # Apply Warp command
  692. apply_warp_parser = subparsers.add_parser(
  693. "apply_warp", help="Apply transformation to warp an image to a reference space"
  694. )
  695. apply_warp_parser.add_argument(
  696. "--moving", required=True, help="Path to the moving image that will be warped"
  697. )
  698. apply_warp_parser.add_argument(
  699. "--reference", required=True, help="Path to the reference/target image"
  700. )
  701. apply_warp_parser.add_argument(
  702. "--warp",
  703. help="Path to the warp field for non-linear transformation",
  704. )
  705. apply_warp_parser.add_argument(
  706. "--secondary-warp",
  707. help="Path to a secondary warp field to be applied after the primary warp and affine",
  708. )
  709. apply_warp_parser.add_argument(
  710. "--affine", help="Path to the affine transformation file"
  711. )
  712. apply_warp_parser.add_argument(
  713. "--output", required=True, help="Output path for the warped image"
  714. )
  715. apply_warp_parser.add_argument(
  716. "--interpolation",
  717. default="linear",
  718. help="Interpolation method (default: linear).",
  719. )
  720. apply_warp_parser.add_argument(
  721. "--transforms", nargs="+", help="List of transforms to apply in order (First -> Last)."
  722. )
  724. # Brain Extraction Tool command
  725. bet_parser = subparsers.add_parser("bet", help="Run Brain Extraction (using SynthSeg or Mask)")
  726. bet_parser.add_argument(
  727. "--input", required=True, help="Path to the input image (.nii.gz)"
  728. )
  729. bet_parser.add_argument(
  730. "--output",
  731. required=True,
  732. help="Path to the output brain-extracted image (.nii.gz)",
  733. )
  734. bet_parser.add_argument(
  735. "--output-mask", help="Path to the output brain mask (.nii.gz)"
  736. )
  737. bet_parser.add_argument(
  738. "--input-mask", help="Path to the input brain mask (.nii.gz) (optional)"
  739. )
  740. bet_parser.add_argument(
  741. "--parcellation", help="Parcellation file for the input image (optional)"
  742. )
  743. bet_parser.add_argument(
  744. "--remove-cerebellum",
  745. action="store_true",
  746. help="Remove cerebellum from the input image (optional)",
  747. )
  749. # Bias Correction Tool command
  750. bias_corr_parser = subparsers.add_parser(
  751. "bias_correction", help="Run N4 Bias Field Correction"
  752. )
  753. bias_corr_parser.add_argument(
  754. "--input", "-i", required=True, help="Path to the input image (.nii.gz)"
  755. )
  756. bias_corr_parser.add_argument(
  757. "--output", "-o", required=True, help="Path to the output bias-corrected image (.nii.gz)"
  758. )
  759. bias_corr_parser.add_argument(
  760. "--mask", help="Path to a mask image (required for 4D images, optional for 3D)"
  761. )
  762. bias_corr_parser.add_argument(
  763. "--mode",
  764. choices=["3d", "4d", "auto"],
  765. default="auto",
  766. help="Processing mode: 3d=anatomical, 4d=diffusion, auto=detect (default)",
  767. )
  768. bias_corr_parser.add_argument(
  769. "--b0", help="b0 image path, required for 4D diffusion images."
  770. )
  771. bias_corr_parser.add_argument(
  772. "--b0-output", help="Path for the output corrected b0 image (only for 4D DWI)."
  773. )
  774. bias_corr_parser.add_argument(
  775. "--direction-dimension",
  776. type=int,
  777. default=3,
  778. help="Dimension of the DWI image referring to directions (default: 3)",
  779. )
  780. bias_corr_parser.add_argument(
  781. "--threads",
  782. type=int,
  783. default=1,
  784. help="Number of threads to use for bias correction (default: 1)",
  785. )
  786. bias_corr_parser.add_argument(
  787. "--gibbs", action="store_true", help="Apply Gibbs ringing correction"
  788. )
  790. # DICE Calculator command
  791. dice_parser = subparsers.add_parser(
  792. "calculate_dice",
  793. help="Calculate DICE between two segmentations",
  794. )
  795. dice_parser.add_argument("--input", "-i", required=True, help="First input volume")
  796. dice_parser.add_argument(
  797. "--reference", "-r", required=True, help="Reference volume to compare against"
  798. )
  799. dice_parser.add_argument(
  800. "--output", "-o", required=True, help="Output CSV file path"
  801. )
  803. # Compute FA/MD command
  804. compute_fa_md_parser = subparsers.add_parser(
  805. "compute_fa_md", help="Compute Fractional Anisotropy and Mean Diffusivity maps"
  806. )
  807. compute_fa_md_parser.add_argument(
  808. "--input", required=True, help="Path to the preprocessed DWI image (.nii.gz)"
  809. )
  810. compute_fa_md_parser.add_argument(
  811. "--bval", required=True, help="Path to the b-values file (.bval)"
  812. )
  813. compute_fa_md_parser.add_argument(
  814. "--bvec", required=True, help="Path to the b-vectors file (.bvec)"
  815. )
  816. compute_fa_md_parser.add_argument(
  817. "--mask", help="Optional: Path to a brain mask (.nii.gz)"
  818. )
  819. compute_fa_md_parser.add_argument(
  820. "--output-fa",
  821. required=True,
  822. help="Output path for the Fractional Anisotropy map (.nii.gz)",
  823. )
  824. compute_fa_md_parser.add_argument(
  825. "--output-md",
  826. required=True,
  827. help="Output path for the Mean Diffusivity map (.nii.gz)",
  828. )
  829. compute_fa_md_parser.add_argument("--b0-volume", type=str,
  830. help="Path to the b0 volume to merge with DWI.")
  831. compute_fa_md_parser.add_argument("--b0-bval", type=str,
  832. help="Path to b0 b-value file.")
  833. compute_fa_md_parser.add_argument("--b0-bvec", type=str,
  834. help="Path to b0 b-vector file.")
  835. compute_fa_md_parser.add_argument("--b0-index", type=int, default=0,
  836. help="Index at which to insert b0 volume (default: 0).")
  838. # Coregistration command
  839. coreg_parser = subparsers.add_parser(
  840. "coregister", help="Coregister a moving image to a reference image using label-augmented registration"
  841. )
  842. coreg_parser.add_argument(
  843. "--fixed-file", required=True,
  844. help="Path to the fixed/reference image (.nii.gz)"
  845. )
  846. coreg_parser.add_argument(
  847. "--moving-file", required=True,
  848. help="Path to the moving image to be registered (.nii.gz)"
  849. )
  850. coreg_parser.add_argument(
  851. "--fixed-segmentation",
  852. help="Path to the fixed segmentation image (.nii.gz). If not provided, will be generated automatically."
  853. )
  854. coreg_parser.add_argument(
  855. "--moving-segmentation",
  856. help="Path to the moving segmentation image (.nii.gz). If not provided, will be generated automatically."
  857. )
  858. coreg_parser.add_argument(
  859. "--output", required=True,
  860. help="Output path for the registered image (.nii.gz)"
  861. )
  862. coreg_parser.add_argument(
  863. "--warp-file", default=None,
  864. help="Optional path to save the forward warp field (moving to fixed) (.nii.gz)"
  865. )
  866. coreg_parser.add_argument(
  867. "--secondary-warp-file", default=None,
  868. help="Optional path to save a secondary warp field to be applied after the primary warp and affine (.nii.gz)"
  869. )
  870. coreg_parser.add_argument(
  871. "--affine-file", default=None,
  872. help="Optional path to save the forward affine transform (moving to fixed) (.mat)"
  873. )
  874. coreg_parser.add_argument(
  875. "--rev-warp-file", default=None,
  876. help="Optional path to save the reverse warp field (fixed to moving) (.nii.gz)"
  877. )
  878. coreg_parser.add_argument(
  879. "--secondary-rev-warp-file", default=None,
  880. help="Optional path to save a secondary reverse warp field to be applied after the primary reverse warp and affine (.nii.gz)"
  881. )
  882. coreg_parser.add_argument(
  883. "--threads", type=int, default=1,
  884. help="Number of threads for registration operations (default: 1)"
  885. )
  886. coreg_parser.add_argument(
  887. "--output-segmentation",
  888. help="Path to save the transformed segmentation alongside the registered image (.nii.gz)"
  889. )
  890. coreg_parser.add_argument(
  891. "--linear-only", action='store_true',
  892. help="Perform only linear registration (rigid + affine) without nonlinear SyN warping (faster)"
  893. )
  894. coreg_parser.add_argument(
  895. "--disable-robust", action='store_true',
  896. help="If set, disables robust registration mode in LAMAReg."
  897. )
  900. # Denoise command
  901. denoise_parser = subparsers.add_parser(
  902. "denoise", help="Denoise diffusion-weighted images using Patch2Self"
  903. )
  904. denoise_parser.add_argument(
  905. "--input", required=True, help="Path to the input DWI image (.nii.gz)"
  906. )
  907. denoise_parser.add_argument(
  908. "--bval", required=True, help="Path to the b-values file (.bval)"
  909. )
  910. denoise_parser.add_argument(
  911. "--bvec", required=True, help="Path to the b-vectors file (.bvec)"
  912. )
  913. denoise_parser.add_argument(
  914. "--output", required=True, help="Output path for the denoised image (.nii.gz)"
  915. )
  916. denoise_parser.add_argument("--b0-denoise", action='store_true', help="Denoise b0 volumes separately (default: False)")
  917. denoise_parser.add_argument("--gibbs", action='store_true', help="Apply Gibbs ringing correction (default: False)")
  918. denoise_parser.add_argument("--threads", type=int, help="Number of threads to use (default: 1)")
  920. # Motion Correction command
  921. motion_corr_parser = subparsers.add_parser(
  922. "motion_correction",
  923. help="Perform motion correction on diffusion-weighted images",
  924. )
  925. motion_corr_parser.add_argument(
  926. "--denoised", required=True, help="Path to the denoised DWI (NIfTI file)."
  927. )
  928. motion_corr_parser.add_argument(
  929. "--input-bvals",
  930. type=str,
  931. required=True,
  932. help="Path to the bvals file.",
  933. )
  934. motion_corr_parser.add_argument(
  935. "--input-bvecs",
  936. type=str,
  937. required=True,
  938. help="Path to the bvecs file.",
  939. )
  940. motion_corr_parser.add_argument(
  941. "--output-bvecs",
  942. type=str,
  943. required=True,
  944. help="Path to the adjusted bvecs file.",
  945. )
  946. motion_corr_parser.add_argument(
  947. "--output", required=True, help="Output path for the motion-corrected DWI."
  948. )
  949. motion_corr_parser.add_argument(
  950. "--b0",
  951. type=str,
  952. help="Path to an external B0 image to use as reference. If not provided, the first volume is used.",
  953. )
  954. motion_corr_parser.add_argument(
  955. "--direction-dimension",
  956. type=int,
  957. default=3,
  958. help="Dimension of the DWI image referring to directions (default: 3)",
  959. )
  960. motion_corr_parser.add_argument(
  961. "--threads",
  962. type=int,
  963. help="Number of threads to use (default: 1)",
  964. )
  965. motion_corr_parser.add_argument(
  966. "--temp-dir",
  967. type=str,
  968. default="tmp",
  969. help="Path to the temporary directory for intermediate files (default: tmp)."
  970. )
  972. # SDC command (main susceptibility distortion correction)
  973. sdc_parser = subparsers.add_parser(
  974. "SDC", help="Run Susceptibility Distortion Correction on DWI images")
  975. sdc_parser.add_argument(
  976. "--input", required=True, help="Path to the data image (NIfTI file)")
  977. sdc_parser.add_argument(
  978. "--reverse-image",
  979. required=True,
  980. help="Path to the reverse phase-encoded image (NIfTI file)",
  981. )
  982. sdc_parser.add_argument(
  983. "--output",
  984. required=True,
  985. help="Output name for the corrected image (NIfTI file)",
  986. )
  987. sdc_parser.add_argument(
  988. "--output-warp",
  989. required=True,
  990. help="Output name for the warp field (NIfTI file)",
  991. )
  992. sdc_parser.add_argument(
  993. "--phase-encoding",
  994. type=str,
  995. default="ap",
  996. choices=["ap", "pa", "lr", "rl", "si", "is"],
  997. help="Phase-encoding direction (default: ap)"
  998. )
  1000. # Texture Generation command
  1001. texture_parser = subparsers.add_parser(
  1002. "texture_generation", help="Generate texture features from neuroimaging data")
  1003. texture_parser.add_argument(
  1004. "--input", "-i", required=True, help="Path to the input image file (.nii.gz)")
  1005. texture_parser.add_argument(
  1006. "--mask", "-m", required=True, help="Path to the binary mask file (.nii.gz)")
  1007. texture_parser.add_argument(
  1008. "--output",
  1009. "-o",
  1010. required=True,
  1011. help="Output directory for texture feature maps",
  1012. )
  1014. normalize_parser = subparsers.add_parser(
  1015. "normalize", help="Normalize MRI intensity values")
  1016. normalize_parser.add_argument(
  1017. "--input", "-i", required=True, help="Input NIfTI image file (.nii.gz)")
  1018. normalize_parser.add_argument(
  1019. "--output", "-o", required=True, help="Output normalized image file (.nii.gz)")
  1020. normalize_parser.add_argument(
  1021. "--lower-percentile",
  1022. type=float,
  1023. default=1.0,
  1024. help="Lower percentile for clamping (default: 1.0)",
  1025. )
  1026. normalize_parser.add_argument(
  1027. "--upper-percentile",
  1028. type=float,
  1029. default=99.0,
  1030. help="Upper percentile for clamping (default: 99.0)",
  1031. )
  1032. normalize_parser.add_argument(
  1033. "--min-value",
  1034. type=float,
  1035. default=0,
  1036. help="Minimum value in output range (default: 0)",
  1037. )
  1038. normalize_parser.add_argument(
  1039. "--max-value",
  1040. type=float,
  1041. default=100,
  1042. help="Maximum value in output range (default: 100)",
  1043. )
  1045. # Synthetic B0 Generation command
  1046. synth_b0_parser = subparsers.add_parser(
  1047. "synth_b0", help="Create a synthetic B0 image from T1w and distorted B0 images using an ensemble of models")
  1048. synth_b0_parser.add_argument(
  1049. '--t1', required=True, help='Path to T1w input image (.nii.gz)')
  1050. synth_b0_parser.add_argument(
  1051. '--b0', required=True, help='Path to distorted B0 input image (.nii.gz)')
  1052. synth_b0_parser.add_argument(
  1053. '--output', required=True, help='Path for synthetic B0 output image (.nii.gz)')
  1054. synth_b0_parser.add_argument(
  1055. '--intermediate', help='Path to save the synthetic B0 before inverse transform')
  1056. synth_b0_parser.add_argument(
  1057. '--cpu', action='store_true', help='Force CPU usage (default: use GPU if available)')
  1058. synth_b0_parser.add_argument(
  1059. '--phase-encoding', help='Index of the volume to extract from 4D DWI images (if applicable)')
  1060. synth_b0_parser.add_argument(
  1061. '--warp', help='Path to save the warp field')
  1062. synth_b0_parser.add_argument(
  1063. '--temp-dir', help='Path to a temporary directory for intermediate files')
  1064. synth_b0_parser.add_argument(
  1065. '--corrected-b0', help='Path to save the corrected B0 image (optional)')
  1066. synth_b0_parser.add_argument(
  1067. '--dwi', help='Path to the full DWI image')
  1068. synth_b0_parser.add_argument(
  1069. '--direction-dimension', type=int, default=3, help='Dimension of the DWI image referring to directions (default: 3)')
  1070. synth_b0_parser.add_argument(
  1071. '--threads', type=int, help='Number of threads to use (default: all)')
  1072. synth_b0_parser.add_argument(
  1073. '--b0-to-T1-warp', help='Path to save the warp field from B0 to T1w (optional)')
  1074. synth_b0_parser.add_argument(
  1075. '--b0-to-T1-warp-secondary', help='Path to a secondary warp field to be applied after the primary warp and affine (optional)')
  1076. synth_b0_parser.add_argument(
  1077. '--b0-to-T1-affine', help='Path to save the affine transform from B0 to T1w (optional)')
  1078. synth_b0_parser.add_argument(
  1079. '--b0-index', type=int, default=0,
  1080. help="Index at which to insert b0 volume (default: 0).")
  1082. # Extract B0 command
  1083. extract_b0_parser = subparsers.add_parser(
  1084. "extract_b0", help="Extract b=0 volume from DWI")
  1085. extract_b0_parser.add_argument(
  1086. "--input", required=True, help="Path to DWI image")
  1087. extract_b0_parser.add_argument(
  1088. "--bvals", help="Path to bvals file")
  1089. extract_b0_parser.add_argument(
  1090. "--bvecs", help="Path to bvecs file")
  1091. extract_b0_parser.add_argument(
  1092. "--output", required=True, help="Path for extracted b=0 volume")
  1093. extract_b0_parser.add_argument(
  1094. "--output-dwi", help="Path for output non-b0 volumes")
  1095. extract_b0_parser.add_argument(
  1096. "--output-bvals", help="Path for output bvals file")
  1097. extract_b0_parser.add_argument(
  1098. "--output-bvecs", help="Path for output bvecs file")
  1099. extract_b0_parser.add_argument(
  1100. "--threshold", type=float, default=50, help="Maximum b-value to consider as b=0 (default: 50)")
  1101. extract_b0_parser.add_argument(
  1102. "--index", type=int, help="Directly specify volume index to extract")
  1103. extract_b0_parser.add_argument(
  1104. "--direction-dimension", type=int, default=3, help="Dimension of the DWI image referring to directions (default: 3)")
  1105. extract_b0_parser.add_argument("--b0-bval", help="Path for b0-only bval file")
  1106. extract_b0_parser.add_argument("--b0-bvec", help="Path for b0-only bvec file")
  1107. args, unknown = parser.parse_known_args()
  1109. # If no command is provided, default to pipeline
  1110. if not args.command:
  1111. args.command = "pipeline"
  1113. # ---> ADD THIS FUNCTION <---
  1114. def create_bids_dataset_description(out_dir):
  1115. """Creates a BIDS dataset_description.json in the derivative root directory."""
  1116. if not out_dir:
  1117. return
  1118. os.makedirs(out_dir, exist_ok=True)
  1119. desc_path = os.path.join(out_dir, "dataset_description.json")
  1120. if not os.path.exists(desc_path):
  1121. desc_data = {
  1122. "Name": "MICAFlow Derivatives",
  1123. "BIDSVersion": "1.8.0",
  1124. "DatasetType": "derivative",
  1125. "PipelineDescription": {
  1126. "Name": "MICAFlow"
  1127. }
  1128. }
  1129. try:
  1130. import json
  1131. with open(desc_path, "w") as f:
  1132. json.dump(desc_data, f, indent=4)
  1133. except Exception as e:
  1134. print(f"Warning: Could not create dataset_description.json: {e}")
  1136. if args.command == "bids":
  1137. # ADD THESE LINES TO HANDLE ANALYSIS LEVEL
  1138. if args.analysis_level == "group":
  1139. print("No group level analyses")
  1140. sys.exit(0)
  1142. # ---> ADD THIS CALL <---
  1143. create_bids_dataset_description(args.output_dir)
  1145. # 1. Identify Subjects
  1146. if args.participant_label:
  1147. subjects = [f"sub-{label}" if not label.startswith("sub-") else label for label in args.participant_label]
  1148. else:
  1149. subjects = [d for d in os.listdir(args.bids_dir) if d.startswith("sub-") and os.path.isdir(os.path.join(args.bids_dir, d))]
  1151. # Determine if 1-to-1 participant/session matching should be triggered
  1152. one_to_one = False
  1153. target_sessions = []
  1154. if args.participant_label and args.session_label and (len(args.participant_label) == len(args.session_label)):
  1155. one_to_one = True
  1156. target_sessions = [f"ses-{l}" if not l.startswith("ses-") else l for l in args.session_label]
  1157. elif args.session_label:
  1158. # Standard grouping if 1-to-1 isn't met (fallback for broadcasting sessions uniformly)
  1159. target_sessions = [f"ses-{l}" if not l.startswith("ses-") else l for l in args.session_label]
  1161. if not subjects:
  1162. print(f"{Fore.RED}No subjects found in {args.bids_dir}{Style.RESET_ALL}")
  1163. sys.exit(1)
  1165. print(f"{Fore.CYAN}Found {len(subjects)} subjects to process.{Style.RESET_ALL}")
  1167. # Helper to find unique files by suffix
  1168. def find_file(base, subfolder, suffix, desc):
  1169. path_pattern = os.path.join(base, subfolder, f"*{suffix}")
  1170. matches = glob.glob(path_pattern)
  1171. if len(matches) > 1:
  1172. print(f"{Fore.RED}Error: Multiple {desc} files found matching *{suffix} in {os.path.join(base, subfolder)}{Style.RESET_ALL}")
  1173. for m in matches:
  1174. print(f" - {os.path.basename(m)}")
  1175. return None, True # None found, Error=True
  1176. if len(matches) == 0:
  1177. return None, False # None found, Error=False
  1178. return matches[0], False # Found, Error=False
  1180. # 2. Iterate Subjects
  1181. for idx, sub in enumerate(subjects):
  1182. sub_dir = os.path.join(args.bids_dir, sub)
  1184. # Detect sessions based on matching structure
  1185. if one_to_one:
  1186. # Single session explicitly paired up with the subject
  1187. sessions = [target_sessions[idx]]
  1188. else:
  1189. sessions = [d for d in os.listdir(sub_dir) if d.startswith("ses-") and os.path.isdir(os.path.join(sub_dir, d))]
  1190. if not sessions:
  1191. sessions = [None] # No session structure
  1192. else:
  1193. sessions.sort()
  1194. # Filter sessions if requested generically
  1195. if target_sessions:
  1196. sessions = [s for s in sessions if s in target_sessions]
  1198. # 3. Iterate Sessions
  1199. for ses in sessions:
  1200. # Start Timer
  1201. start_time = time.time()
  1202. run_timestamp = datetime.datetime.now().isoformat()
  1204. # Define path
  1205. if ses:
  1206. base_path = os.path.join(sub_dir, ses)
  1207. ses_id = ses
  1208. sub_ses_str = f"{sub}/{ses}"
  1209. else:
  1210. base_path = sub_dir
  1211. ses_id = None
  1212. sub_ses_str = sub
  1214. print(f"\n{Fore.GREEN}Checking {sub_ses_str}...{Style.RESET_ALL}")
  1216. # 4. Find Files
  1217. # T1w (Required)
  1218. t1w, err = find_file(base_path, "anat", args.t1w_suffix, "T1w")
  1219. if err: continue # Skip on error (ambiguity)
  1220. if not t1w:
  1221. print(f"{Fore.YELLOW}Skipping {sub_ses_str}: No T1w found matching *{args.t1w_suffix}{Style.RESET_ALL}")
  1222. continue
  1224. # FLAIR (Optional)
  1225. flair = None
  1226. if args.flair_suffix:
  1227. flair, err = find_file(base_path, "anat", args.flair_suffix, "FLAIR")
  1228. if err: continue # Skip on ambiguity
  1230. # DWI (Optional)
  1231. dwi = None
  1232. if args.dwi_suffix:
  1233. dwi, err = find_file(base_path, "dwi", args.dwi_suffix, "DWI")
  1234. if err: continue # Skip on ambiguity
  1236. # Inverse DWI (Optional)
  1237. inv_dwi = None
  1238. if args.inverse_dwi_suffix:
  1239. inv_dwi, err = find_file(base_path, "dwi", args.inverse_dwi_suffix, "Inverse DWI")
  1240. if err: continue
  1242. # Check if DWI has bvals/bvecs (Required if DWI is present)
  1243. bval_file = None
  1244. bvec_file = None
  1245. if dwi:
  1246. # Infer bval/bvec by replacing extension
  1247. prefix = dwi
  1248. if prefix.endswith(".nii.gz"):
  1249. prefix = prefix[:-7]
  1250. elif prefix.endswith(".nii"):
  1251. prefix = prefix[:-4]
  1253. bval_cand = prefix + ".bval"
  1254. bvec_cand = prefix + ".bvec"
  1256. if os.path.exists(bval_cand) and os.path.exists(bvec_cand):
  1257. bval_file = bval_cand
  1258. bvec_file = bvec_cand
  1259. else:
  1260. # Fallback: Instead of skipping subject, just drop DWI and proceed with T1/FLAIR
  1261. print(f"{Fore.YELLOW}Warning: DWI found but missing .bval or .bvec files for {dwi}. Proceeding without DWI.{Style.RESET_ALL}")
  1262. dwi = None
  1264. # Check Inverse DWI bvals/bvecs
  1265. inv_bval_file = None
  1266. inv_bvec_file = None
  1267. if inv_dwi:
  1268. prefix = inv_dwi
  1269. if prefix.endswith(".nii.gz"):
  1270. prefix = prefix[:-7]
  1271. elif prefix.endswith(".nii"):
  1272. prefix = prefix[:-4]
  1274. cand_bval = prefix + ".bval"
  1275. cand_bvec = prefix + ".bvec"
  1276. if os.path.exists(cand_bval) and os.path.exists(cand_bvec):
  1277. inv_bval_file = cand_bval
  1278. inv_bvec_file = cand_bvec
  1280. # 5. Build Command
  1281. cmd = [sys.executable, "-m", "micaflow.cli", "pipeline"]
  1282. cmd.extend(["--subject", sub])
  1283. if ses_id:
  1284. cmd.extend(["--session", ses_id])
  1286. # CHANGE: Use --output-dir here instead of --output
  1287. cmd.extend(["--output-dir", args.output_dir])
  1289. # FIX: Do NOT pass data directory to avoid path duplication logic in pipeline.
  1290. # Instead, pass explicit absolute paths for all files.
  1291. # cmd.extend(["--data-directory", args.bids_dir])
  1293. cmd.extend(["--t1w-file", os.path.abspath(t1w)])
  1294. if flair:
  1295. cmd.extend(["--flair-file", os.path.abspath(flair)])
  1297. # DWI handling
  1298. if dwi:
  1299. cmd.extend(["--dwi-file", os.path.abspath(dwi)])
  1300. cmd.extend(["--bval-file", os.path.abspath(bval_file)])
  1301. cmd.extend(["--bvec-file", os.path.abspath(bvec_file)])
  1302. else:
  1303. # FIX: Explicitly pass empty strings to clear potential cache/defaults in pipeline
  1304. cmd.extend(["--dwi-file", ""])
  1305. cmd.extend(["--bval-file", ""])
  1306. cmd.extend(["--bvec-file", ""])
  1308. if inv_dwi:
  1309. cmd.extend(["--inverse-dwi-file", os.path.abspath(inv_dwi)])
  1310. cmd.extend(["--inverse-bval-file", os.path.abspath(inv_bval_file) if inv_bval_file else ""])
  1311. cmd.extend(["--inverse-bvec-file", os.path.abspath(inv_bvec_file) if inv_bvec_file else ""])
  1312. else:
  1313. cmd.extend(["--inverse-dwi-file", ""])
  1315. # Passthrough args
  1316. if args.gpu: cmd.append("--gpu")
  1317. if args.rm_cerebellum: cmd.append("--rm-cerebellum")
  1318. if args.extract_brain: cmd.append("--extract-brain")
  1319. if args.keep_temp: cmd.append("--keep-temp")
  1320. if args.linear: cmd.append("--linear")
  1321. if args.nonlinear: cmd.append("--nonlinear")
  1322. if args.config_file: cmd.extend(["--config-file", args.config_file])
  1324. cmd.extend(["--cores", str(args.cores)])
  1325. cmd.extend(["--PED", args.PED])
  1326. cmd.extend(["--direction-dimension", str(args.direction_dimension)])
  1328. # FIX: Pass unknown arguments (like --unlock, --rerun-incomplete) to the pipeline
  1329. if unknown:
  1330. cmd.extend(unknown)
  1332. # 6. Execute and Log
  1333. print(f"{Fore.CYAN}Launching pipeline for {sub_ses_str}...{Style.RESET_ALL}")
  1335. status = "unknown"
  1336. error_msg = None
  1338. if args.dry_run:
  1339. print(f"Dry run: {' '.join(cmd)}")
  1340. status = "dry_run"
  1341. else:
  1342. try:
  1343. subprocess.run(cmd, check=True)
  1344. status = "success"
  1345. except subprocess.CalledProcessError as e:
  1346. print(f"{Fore.RED}Pipeline failed for {sub_ses_str}{Style.RESET_ALL}")
  1347. status = "failed"
  1348. error_msg = str(e)
  1350. # 7. Generate Run Metadata JSON
  1351. # Logic updated: Append to a single summary JSON in the main output directory
  1352. if not args.dry_run:
  1353. try:
  1354. duration = time.time() - start_time
  1356. # Use main output dir
  1357. os.makedirs(args.output_dir, exist_ok=True)
  1359. metadata = {
  1360. "subject": sub,
  1361. "session": ses_id,
  1362. "timestamp": run_timestamp,
  1363. "duration_seconds": round(duration, 2),
  1364. "status": status,
  1365. "error": error_msg,
  1366. "inputs": {
  1367. "t1w": t1w,
  1368. "flair": flair,
  1369. "dwi": dwi,
  1370. "bval": bval_file,
  1371. "bvec": bvec_file,
  1372. "inverse_dwi": inv_dwi,
  1373. "inverse_bval": inv_bval_file,
  1374. "inverse_bvec": inv_bvec_file
  1375. },
  1376. "config": {
  1377. "linear": args.linear,
  1378. "nonlinear": args.nonlinear,
  1379. "ped": args.PED,
  1380. "direction_dimension": args.direction_dimension,
  1381. "extract_brain": args.extract_brain,
  1382. "rm_cerebellum": args.rm_cerebellum,
  1383. "gpu": args.gpu
  1384. },
  1385. "command_line": cmd
  1386. }
  1388. # Define the single summary log file path
  1389. json_path = os.path.join(args.output_dir, "micaflow_runs_summary.json")
  1391. # Load existing data if file exists
  1392. run_history = []
  1393. if os.path.exists(json_path):
  1394. try:
  1395. with open(json_path, "r") as f:
  1396. run_history = json.load(f)
  1397. if not isinstance(run_history, list):
  1398. # If for some reason it's not a list, wrap it or start new
  1399. # (Handling backward compatibility if it was dict)
  1400. run_history = []
  1401. except json.JSONDecodeError:
  1402. print(f"{Fore.YELLOW}Warning: Could not decode existing log file. Starting fresh.{Style.RESET_ALL}")
  1403. run_history = []
  1405. # Append new run
  1406. run_history.append(metadata)
  1408. # Write back to file
  1409. with open(json_path, "w") as f:
  1410. json.dump(run_history, f, indent=4)
  1412. print(f"Run metadata appended to {json_path}")
  1414. except Exception as e:
  1415. print(f"{Fore.RED}Error saving run metadata: {e}{Style.RESET_ALL}")
  1417. elif args.command == "pipeline":
  1418. # ---> ADD THIS CALL <---
  1419. # CHANGE: Use args.output_dir instead of args.output
  1420. create_bids_dataset_description(args.output_dir)
  1422. # Get the path to the Snakefile
  1423. snakefile = get_snakefile_path()
  1425. # Build the snakemake command
  1426. cmd = ["snakemake", "-s", snakefile]
  1428. # Add config parameters if provided
  1429. config = {}
  1430. for param in [
  1431. "subject",
  1432. "session",
  1433. "output_dir", # CHANGE THIS
  1434. "data_dir", # CHANGE THIS
  1435. "flair_file",
  1436. "t1w_file",
  1437. "dwi_file",
  1438. "bval_file",
  1439. "bvec_file",
  1440. "inverse_dwi_file",
  1441. "inverse_bval_file",
  1442. "inverse_bvec_file",
  1443. "phase_encoding_direction",
  1444. "rm_cerebellum",
  1445. "gpu",
  1446. "keep_temp",
  1447. "extract_brain",
  1448. "direction_dimension",
  1449. "PED",
  1450. "linear",
  1451. "nonlinear"
  1452. ]:
  1453. # FIX: Check if argument is strictly not None (allow empty strings to override cache)
  1454. val = getattr(args, param.replace("-", "_"), None)
  1455. if val is not None:
  1456. config[param] = val
  1458. # Add config parameters to command
  1459. if len(config) > 0:
  1460. cmd.append("--config")
  1461. for key, value in config.items():
  1462. cmd.extend([f"{key}={value}"])
  1464. # Add config file if provided
  1465. if args.config_file:
  1466. cmd.extend(["--configfile", args.config_file])
  1468. # Add other snakemake parameters
  1469. if args.dry_run:
  1470. cmd.append("-n")
  1472. cmd.extend(["--cores", str(args.cores)])
  1474. # Add any unknown arguments to pass to snakemake
  1475. if unknown:
  1476. cmd.extend(unknown)
  1477. print(f"Executing: {' '.join(cmd)}")
  1479. # Execute the snakemake command
  1480. try:
  1481. subprocess.run(cmd, check=True)
  1482. except subprocess.CalledProcessError as e:
  1483. print(f"Error running snakemake: {e}")
  1484. sys.exit(1)
  1486. elif args.command == "synthseg":
  1487. # Prepare arguments for SynthSeg
  1488. synthseg_args = []
  1489. for arg_name, arg_value in vars(args).items():
  1490. if arg_name != "command" and arg_value is not None:
  1491. # Map 'input' back to 'i' so the synthseg script recognizes it
  1492. passed_arg = "i" if arg_name == "input" else arg_name
  1494. if isinstance(arg_value, bool):
  1495. if arg_value:
  1496. synthseg_args.append(f"--{passed_arg}")
  1497. elif isinstance(arg_value, list):
  1498. synthseg_args.append(f"--{passed_arg}")
  1499. synthseg_args.extend([str(x) for x in arg_value])
  1500. else:
  1501. synthseg_args.append(f"--{passed_arg}")
  1502. synthseg_args.append(str(arg_value))
  1503. try:
  1504. print(f"Running SynthSeg brain segmentation on {args.input}...")
  1505. subprocess.run(
  1506. ["python", "-m", "micaflow.scripts.synthseg"] + synthseg_args,
  1507. check=True,
  1508. )
  1509. print(f"Brain segmentation completed. Output saved to {args.output}")
  1510. except subprocess.CalledProcessError as e:
  1511. print(f"Error running brain segmentation: {e}")
  1512. sys.exit(1)
  1514. elif args.command == "apply_SDC":
  1515. # Prepare arguments for apply_SDC
  1516. apply_sdc_parser = []
  1517. for arg_name, arg_value in vars(args).items():
  1518. if arg_name != "command" and arg_value is not None:
  1519. if isinstance(arg_value, bool):
  1520. if arg_value:
  1521. apply_sdc_parser.append(f"--{arg_name}")
  1522. elif isinstance(arg_value, list):
  1523. apply_sdc_parser.append(f"--{arg_name}")
  1524. apply_sdc_parser.extend([str(x) for x in arg_value])
  1525. else:
  1526. apply_sdc_parser.append(f"--{arg_name}")
  1527. apply_sdc_parser.append(str(arg_value))
  1529. # Run the apply_SDC script
  1530. try:
  1531. print(f"Applying susceptibility distortion correction to {args.input}...")
  1532. subprocess.run(
  1533. ["python", "-m", "micaflow.scripts.apply_SDC"] + apply_sdc_parser, check=True
  1534. )
  1535. print(
  1536. f"Susceptibility distortion correction completed. Output saved to {args.output}"
  1537. )
  1538. except subprocess.CalledProcessError as e:
  1539. print(f"Error applying susceptibility distortion correction: {e}")
  1540. sys.exit(1)
  1542. elif args.command == "apply_warp":
  1543. # Prepare arguments for apply_warp
  1544. apply_warp_args = []
  1545. for arg_name, arg_value in vars(args).items():
  1546. if arg_name != "command" and arg_value is not None:
  1547. arg_name_formatted = arg_name.replace("_", "-")
  1548. if isinstance(arg_value, bool):
  1549. if arg_value:
  1550. apply_warp_args.append(f"--{arg_name_formatted}")
  1551. elif isinstance(arg_value, list):
  1552. apply_warp_args.append(f"--{arg_name_formatted}")
  1553. apply_warp_args.extend([str(x) for x in arg_value])
  1554. else:
  1555. apply_warp_args.append(f"--{arg_name_formatted}")
  1556. apply_warp_args.append(str(arg_value))
  1558. try:
  1559. print(f"Applying warp transformation to {args.moving}...")
  1560. print(len(apply_warp_args))
  1561. subprocess.run(
  1562. ["python", "-m", "micaflow.scripts.apply_warp"] + apply_warp_args,
  1563. check=True,
  1564. )
  1565. print(f"Warp transformation completed. Output saved to {args.output}")
  1566. except subprocess.CalledProcessError as e:
  1567. print(f"Error applying warp transformation: {e}")
  1568. sys.exit(1)
  1570. elif args.command == "bet":
  1571. # Prepare arguments for bet
  1572. bet_args = []
  1573. for arg_name, arg_value in vars(args).items():
  1574. if arg_name != "command" and arg_value is not None:
  1575. # Convert underscores to hyphens in argument names for CLI compatibility
  1576. # This ensures --output_mask becomes --output-mask when passed to the script
  1577. arg_name_formatted = arg_name.replace("_", "-")
  1579. if isinstance(arg_value, bool):
  1580. if arg_value:
  1581. bet_args.append(f"--{arg_name_formatted}")
  1582. elif isinstance(arg_value, list):
  1583. bet_args.append(f"--{arg_name_formatted}")
  1584. bet_args.extend([str(x) for x in arg_value])
  1585. else:
  1586. bet_args.append(f"--{arg_name_formatted}")
  1587. bet_args.append(str(arg_value))
  1589. try:
  1590. print(f"Running brain extraction on {args.input}...")
  1591. subprocess.run(
  1592. ["python", "-m", "micaflow.scripts.bet"] + bet_args, check=True
  1593. )
  1594. print(f"Brain extraction completed. Output saved to {args.output}")
  1595. except subprocess.CalledProcessError as e:
  1596. print(f"Error running brain extraction: {e}")
  1597. sys.exit(1)
  1599. elif args.command == "bias_correction":
  1600. # Prepare arguments for bias_correction
  1601. bias_corr_args = []
  1602. for arg_name, arg_value in vars(args).items():
  1603. if arg_name != "command" and arg_value is not None:
  1604. arg_name_formatted = arg_name.replace("_", "-")
  1605. if isinstance(arg_value, bool):
  1606. if arg_value:
  1607. bias_corr_args.append(f"--{arg_name_formatted}")
  1608. elif isinstance(arg_value, list):
  1609. bias_corr_args.append(f"--{arg_name_formatted}")
  1610. bias_corr_args.extend([str(x) for x in arg_value])
  1611. else:
  1612. bias_corr_args.append(f"--{arg_name_formatted}")
  1613. bias_corr_args.append(str(arg_value))
  1615. # Run the bias_correction script
  1616. try:
  1617. print(f"Running bias field correction on {args.input}...")
  1618. subprocess.run(
  1619. ["python", "-m", "micaflow.scripts.bias_correction"] + bias_corr_args,
  1620. check=True,
  1621. )
  1622. print(f"Bias correction completed. Output saved to {args.output}")
  1623. except subprocess.CalledProcessError as e:
  1624. print(f"Error running bias correction: {e}")
  1625. sys.exit(1)
  1627. elif args.command == "calculate_dice":
  1628. # Prepare arguments for calculate_dice
  1629. dice_args = []
  1630. for arg_name, arg_value in vars(args).items():
  1631. if arg_name != "command" and arg_value is not None:
  1632. if isinstance(arg_value, bool):
  1633. if arg_value:
  1634. dice_args.append(f"--{arg_name}")
  1635. elif isinstance(arg_value, list):
  1636. dice_args.append(f"--{arg_name}")
  1637. dice_args.extend([str(x) for x in arg_value])
  1638. else:
  1639. dice_args.append(f"--{arg_name}")
  1640. dice_args.append(str(arg_value))
  1642. # Run the calculate_dice script
  1643. try:
  1644. print(f"Calculating DICE between {args.input} and {args.reference}...")
  1645. subprocess.run(
  1646. ["python", "-m", "micaflow.scripts.calculate_dice"] + dice_args,
  1647. check=True,
  1648. )
  1649. if args.output:
  1650. print(f"Results saved to {args.output}")
  1651. except subprocess.CalledProcessError as e:
  1652. print(f"Error calculating DICE: {e}")
  1653. sys.exit(1)
  1655. elif args.command == "compute_fa_md":
  1656. # Prepare arguments for compute_fa_md
  1657. compute_fa_md_args = []
  1658. for arg_name, arg_value in vars(args).items():
  1659. if arg_name != "command" and arg_value is not None:
  1660. arg_name_formatted = arg_name.replace("_", "-")
  1662. if isinstance(arg_value, bool):
  1663. if arg_value:
  1664. compute_fa_md_args.append(f"--{arg_name_formatted}")
  1665. elif isinstance(arg_value, list):
  1666. compute_fa_md_args.append(f"--{arg_name_formatted}")
  1667. compute_fa_md_args.extend([str(x) for x in arg_value])
  1668. else:
  1669. compute_fa_md_args.append(f"--{arg_name_formatted}")
  1670. compute_fa_md_args.append(str(arg_value))
  1672. # Run the compute_fa_md script
  1673. try:
  1674. print(f"Computing FA and MD maps from {args.input}...")
  1675. subprocess.run(
  1676. ["python", "-m", "micaflow.scripts.compute_fa_md"] + compute_fa_md_args,
  1677. check=True,
  1678. )
  1679. print(
  1680. f"DTI metrics computed. FA saved to {args.output_fa}, MD saved to {args.output_fa}"
  1681. )
  1682. except subprocess.CalledProcessError as e:
  1683. print(f"Error computing FA/MD maps: {e}")
  1684. sys.exit(1)
  1686. elif args.command == "coregister":
  1687. # Prepare arguments for coregister
  1688. coreg_args = []
  1689. for arg_name, arg_value in vars(args).items():
  1690. if arg_name != "command" and arg_value is not None:
  1691. # Convert hyphens to underscores for the script
  1692. arg_name_formatted = arg_name.replace("_", "-")
  1694. if isinstance(arg_value, bool):
  1695. if arg_value:
  1696. coreg_args.append(f"--{arg_name_formatted}")
  1697. elif isinstance(arg_value, list):
  1698. coreg_args.append(f"--{arg_name_formatted}")
  1699. coreg_args.extend([str(x) for x in arg_value])
  1700. else:
  1701. coreg_args.append(f"--{arg_name_formatted}")
  1702. coreg_args.append(str(arg_value))
  1704. # Run the coregister script
  1705. try:
  1706. print(f"Coregistering {args.moving_file} to {args.fixed_file}...")
  1707. subprocess.run(
  1708. ["python", "-m", "micaflow.scripts.coregister"] + coreg_args, check=True
  1709. )
  1710. print(f"Coregistration completed. Output saved to {args.output}")
  1711. if args.warp_file:
  1712. print(f"Warp field saved to {args.warp_file}")
  1713. if args.affine_file:
  1714. print(f"Affine transformation matrix saved to {args.affine_file}")
  1715. except subprocess.CalledProcessError as e:
  1716. print(f"Error during coregistration: {e}")
  1717. sys.exit(1)
  1719. elif args.command == "denoise":
  1720. # Prepare arguments for denoise
  1721. denoise_args = []
  1722. for arg_name, arg_value in vars(args).items():
  1723. if arg_name != "command" and arg_value is not None:
  1724. arg_name_formatted = arg_name.replace("_", "-")
  1725. if isinstance(arg_value, bool):
  1726. if arg_value:
  1727. denoise_args.append(f"--{arg_name_formatted}")
  1728. elif isinstance(arg_value, list):
  1729. denoise_args.append(f"--{arg_name_formatted}")
  1730. denoise_args.extend([str(x) for x in arg_value])
  1731. else:
  1732. denoise_args.append(f"--{arg_name_formatted}")
  1733. denoise_args.append(str(arg_value))
  1735. # Run the denoise script
  1736. try:
  1737. print(f"Denoising diffusion image {args.input}...")
  1738. subprocess.run(
  1739. ["python", "-m", "micaflow.scripts.denoise"] + denoise_args, check=True
  1740. )
  1741. print(f"Denoising completed. Output saved to {args.output}")
  1742. except subprocess.CalledProcessError as e:
  1743. print(f"Error during denoising: {e}")
  1744. sys.exit(1)
  1746. elif args.command == "motion_correction":
  1747. # Prepare arguments for motion_correction
  1748. motion_corr_args = []
  1749. for arg_name, arg_value in vars(args).items():
  1750. if arg_name != "command" and arg_value is not None:
  1751. arg_name_formatted = arg_name.replace("_", "-")
  1752. if isinstance(arg_value, bool):
  1753. if arg_value:
  1754. motion_corr_args.append(f"--{arg_name_formatted}")
  1755. elif isinstance(arg_value, list):
  1756. motion_corr_args.append(f"--{arg_name_formatted}")
  1757. motion_corr_args.extend([str(x) for x in arg_value])
  1758. else:
  1759. motion_corr_args.append(f"--{arg_name_formatted}")
  1760. motion_corr_args.append(str(arg_value))
  1762. # Run the motion_correction script
  1763. try:
  1764. print(f"Performing motion correction on {args.denoised}...")
  1765. subprocess.run(
  1766. ["python", "-m", "micaflow.scripts.motion_correction"]
  1767. + motion_corr_args,
  1768. check=True,
  1769. )
  1770. print(f"Motion correction completed. Output saved to {args.output}")
  1771. except subprocess.CalledProcessError as e:
  1772. print(f"Error during motion correction: {e}")
  1773. sys.exit(1)
  1775. elif args.command == "SDC":
  1776. # Prepare arguments for SDC
  1777. sdc_args = []
  1778. for arg_name, arg_value in vars(args).items():
  1779. if arg_name != "command" and arg_value is not None:
  1780. # Convert hyphens to underscores for the script
  1781. arg_name_formatted = arg_name.replace("_", "-")
  1783. if isinstance(arg_value, bool):
  1784. if arg_value:
  1785. sdc_args.append(f"--{arg_name_formatted}")
  1786. elif isinstance(arg_value, list):
  1787. sdc_args.append(f"--{arg_name_formatted}")
  1788. sdc_args.extend([str(x) for x in arg_value])
  1789. else:
  1790. sdc_args.append(f"--{arg_name_formatted}")
  1791. sdc_args.append(str(arg_value))
  1795. # Run the SDC script
  1796. try:
  1797. print(f"Running susceptibility distortion correction on {args.input}...")
  1798. subprocess.run(
  1799. ["python", "-m", "micaflow.scripts.SDC"] + sdc_args, check=True
  1800. )
  1801. print(
  1802. f"Susceptibility distortion correction completed. Output saved to {args.output}"
  1803. )
  1804. print(f"Warp field saved to {args.output_warp}")
  1805. except subprocess.CalledProcessError as e:
  1806. print(f"Error running susceptibility distortion correction: {e}")
  1807. sys.exit(1)
  1809. elif args.command == "texture_generation":
  1810. # Prepare arguments for texture_generation
  1811. texture_args = []
  1812. for arg_name, arg_value in vars(args).items():
  1813. if arg_name != "command" and arg_value is not None:
  1814. if isinstance(arg_value, bool):
  1815. if arg_value:
  1816. texture_args.append(f"--{arg_name}")
  1817. elif isinstance(arg_value, list):
  1818. texture_args.append(f"--{arg_name}")
  1819. texture_args.extend([str(x) for x in arg_value])
  1820. else:
  1821. texture_args.append(f"--{arg_name}")
  1822. texture_args.append(str(arg_value))
  1824. # Run the texture_generation script
  1825. try:
  1826. print(
  1827. f"Generating texture features for {args.input} using mask {args.mask}..."
  1828. )
  1829. subprocess.run(
  1830. ["python", "-m", "micaflow.scripts.texture_generation"] + texture_args,
  1831. check=True,
  1832. )
  1833. print(f"Texture generation completed. Output saved to {args.output}")
  1834. except subprocess.CalledProcessError as e:
  1835. print(f"Error during texture generation: {e}")
  1836. sys.exit(1)
  1837. elif args.command == "normalize":
  1838. # Prepare arguments for motion_correction
  1839. normalize_args = []
  1840. for arg_name, arg_value in vars(args).items():
  1841. if arg_name != "command" and arg_value is not None:
  1842. arg_name_formatted = arg_name.replace("_", "-")
  1844. if isinstance(arg_value, bool):
  1845. if arg_value:
  1846. normalize_args.append(f"--{arg_name_formatted}")
  1847. elif isinstance(arg_value, list):
  1848. normalize_args.append(f"--{arg_name_formatted}")
  1849. normalize_args.extend([str(x) for x in arg_value])
  1850. else:
  1851. normalize_args.append(f"--{arg_name_formatted}")
  1852. normalize_args.append(str(arg_value))
  1854. # Run the motion_correction script
  1855. try:
  1856. print(f"Performing motion correction on {args.input}...")
  1857. subprocess.run(
  1858. ["python", "-m", "micaflow.scripts.normalize"] + normalize_args,
  1859. check=True,
  1860. )
  1861. print(f"Motion correction completed. Output saved to {args.output}")
  1862. except subprocess.CalledProcessError as e:
  1863. print(f"Error during motion correction: {e}")
  1864. sys.exit(1)
  1866. elif args.command == "synth_b0":
  1867. # Prepare arguments for synth_b0
  1868. synth_b0_args = []
  1869. for arg_name, arg_value in vars(args).items():
  1870. if arg_name != "command" and arg_value is not None:
  1871. # Convert underscores to hyphens in argument names
  1872. arg_name_formatted = arg_name.replace("_", "-")
  1874. if isinstance(arg_value, bool):
  1875. if arg_value:
  1876. synth_b0_args.append(f"--{arg_name_formatted}")
  1877. elif isinstance(arg_value, list):
  1878. synth_b0_args.append(f"--{arg_name_formatted}")
  1879. synth_b0_args.extend([str(x) for x in arg_value])
  1880. else:
  1881. synth_b0_args.append(f"--{arg_name_formatted}")
  1882. synth_b0_args.append(str(arg_value))
  1884. # Run the synth_b0 script
  1885. try:
  1886. print(f"Generating synthetic B0 using T1w ({args.t1}) and B0 ({args.b0}) inputs...")
  1887. print(f"First performing linear registration between B0 and T1w...")
  1888. subprocess.run(
  1889. ["python", "-m", "micaflow.scripts.synth_b0"] + synth_b0_args, check=True
  1890. )
  1891. print(f"Synthetic B0 generation completed. Output saved to {args.output}")
  1892. except subprocess.CalledProcessError as e:
  1893. print(f"Error generating synthetic B0: {e}")
  1894. sys.exit(1)
  1896. elif args.command == "extract_b0":
  1897. # Prepare arguments for extract_b0
  1898. extract_b0_args = []
  1899. for arg_name, arg_value in vars(args).items():
  1900. if arg_name != "command" and arg_value is not None:
  1901. arg_name_formatted = arg_name.replace("_", "-")
  1902. if isinstance(arg_value, bool):
  1903. if arg_value:
  1904. extract_b0_args.append(f"--{arg_name_formatted}")
  1905. elif isinstance(arg_value, list):
  1906. extract_b0_args.append(f"--{arg_name_formatted}")
  1907. extract_b0_args.extend([str(x) for x in arg_value])
  1908. else:
  1909. extract_b0_args.append(f"--{arg_name_formatted}")
  1910. extract_b0_args.append(str(arg_value))
  1912. # Run the extract_b0 script
  1913. try:
  1914. print(f"Extracting b=0 volume from {args.input}...")
  1915. subprocess.run(
  1916. ["python", "-m", "micaflow.scripts.extract_b0"] + extract_b0_args,
  1917. check=True,
  1918. )
  1919. print(f"B0 extraction completed. Output saved to {args.output}")
  1920. except subprocess.CalledProcessError as e:
  1921. print(f"Error extracting b=0 volume: {e}")
  1922. sys.exit(1)
  1924. if __name__ == "__main__":
  1925. main()

cli.py at commit 51d2f73, under GPL-3.0 · at the source

Overview

Authors: Ian Goodall-Halliwell1, Jordan DeKraker1, Paul Bautin1, Daniel Mendelson1, Donna Gift Cabalo1, Ella Sahlas1, Alexander Ngo1, Ke Xie1, Jack Lam1, Meaghan Smith1, Youngeun Hwang1, Laura Vavassori1, Pietro Milano2, Judy Chen1, Arielle Dascal1, Rui Ding1, Guan Zhou1, Marlo Naish1, JiaJie Mo3, Fatemeh Fadaie1, Raul R. Cruces1, Boris C. Bernhardt1
ORCID iDs: Ian Goodall-Halliwell, Jordan DeKraker, Paul Bautin, Daniel Mendelson, Donna Gift Cabalo, Ella Sahlas, Alexander Ngo, Ke Xie, Jack Lam, Meaghan Smith, Youngeun Hwang, Laura Vavassori, Pietro Milano, Judy Chen, Arielle Dascal, Marlo Naish, JiaJie Mo, Fatemeh Fadaie, Raul R. Cruces, Boris C. Bernhardt
  1. McConnell Brain Imaging Centre (BIC) and Centre of Excellence in Epilepsy at The Neuro (CEEN), Montreal Neurological Institute, McGill University, Montreal, Quebec, Canada
  2. Neurophysiology Unit and Epilepsy Centre, AOU Modena, University of Modena and Reggio Emilia, Modena, Italy
  3. Department of Neurosurgery, Beijing Tiantan Hospital, Capital Medical University, Beijing, China
Institutions: Montreal Neurological Institute and Hospital (Canada); McGill University (Canada); University of Modena and Reggio Emilia (Italy); Capital Medical University (China); Beijing Tian Tan Hospital (China)
Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1366
Dates: received 5 June 2026; accepted 17 August 2026; published online 11 September 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1162/imag.a.1366 · PMID 42746345 · PMCID PMC13576946 · OpenAlex W7162771624
Open access: diamond, a free copy (OpenAlex)
Preprint: doi:10.64898/2026.05.26.727725
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), epilepsy (population), methods / tools (subfield)
Methods: Connectivity, Statistics, Preprocessing, Graphs, Machine learning, fMRI & imaging
Keywords: magnetic resonance imaging, MRI preprocessing, image processing, multimodal MRI, diffusion MRI, MRI in epilepsy
MeSH: Brain*, Image Processing, Computer-Assisted*, Magnetic Resonance Imaging*, Neuroimaging*, Deep Learning, Humans, Reproducibility of Results (* major topic)
Journal subjects: Software Toolbox
Topic: Advanced Neuroimaging Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: Irma H. Bauer Research Fund; Natural Sciences and Engineering Research Council of Canada; Helmholtz International BigBrain Analytics and Learning Laboratory; Healthy Brains and Healthy Lives; Centre for Aging + Brain Health Innovation; Molson Engineering Fellowship of the Montreal Neurological Institute; Fonds de Recherche du Québec - Santé (373207); Fonds de recherche du Québec—Nature et technologies; Savoy Foundation; Vanier Canada Graduate Scholarship; Canadian Institutes of Health Research (FDN-154298, PJT-174995); China Scholarship Council; Ministère de la Santé et des Services sociaux du Québec; Quebec BioImaging Network; Montreal Neurological Institute Jeanne Timmins Costello Fellowship; Healthy Brains, Healthy Lives – Entrepreneur Postdoc Fellowship; SickKids Foundation (NI17-039); Centre Azrieli de recherche sur l'autisme, Institut et Hôpital Neurologiques de Montréal; BrainCanada; Canada Research Chairs; Centre of Excellence in Epilepsy at the Neuro; CIHR (PJT-206196, PJT-203761, PJT-191853); NSERC (RGPIN-2025-05932)
Citations: not cited yet (Europe PMC); 89 references in the paper

Abstract

MICAFlow is a fully automated MRI preprocessing pipeline designed to support translation of advanced neuroimaging workflows toward clinically feasible research and prospective clinical-evaluation settings. The pipeline emphasizes speed, robustness, and ease of use, focusing on structural and diffusion MRI. Key innovations include a Label-Augmented Modality-Agnostic Registration (LAMAReg) technique driven by deep learning segmentations for reliable cross-modal alignment, integration of state-of-the-art distortion corrections, and adherence to reproducible standards (Snakemake workflow, BIDSApp specifications). We describe the design of MICAFlow and evaluate its performance across heterogeneous datasets. First, accessibility: MICAFlow processes a multimodal MRI exam in minutes with clinically accessible hardware and without requiring GPU access, enabling same-day processing on clinically realistic hardware. Second, registration accuracy: LAMAReg achieves cutting-edge multimodal registration accuracy, yielding accurate alignment of diffusion MRI, FLAIR, and intra-subject T1-weighted images while remaining generally robust to common artifacts. Third, data reproducibility: Using identifiability, we show MICAFlow maintains consistent performance across diverse datasets, including subjects with pathology, and is closely comparable to contemporary pipelines. In sum, MICAFlow’s combination of machine learning and efficient workflows produces research-grade preprocessing outputs with runtimes compatible with clinically oriented research workflows. This work demonstrates that advanced MRI preprocessing can be done fast and robustly, helping close the gap between research neuroimaging and future clinical evaluation of quantitative MRI techniques. The source code for MICAFlow is available here: https://github.com/MICA-MNI/MICAFlow, and for LAMAReg here: https://github.com/MICA-MNI/LAMAReg

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 17 matches between paragraphs and lines of code.

MICA-MNI/MICAFlow

License: GPL-3.0
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 51d2f73d2009809234b5ac9f5209be37a96b3cc2, 15 July 2026
Languages: Python (29), JavaScript (15)
Size: 237 files, 44 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Holds: README, license file, environment (Dockerfile, pyproject.toml, requirements.txt), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: NumPy (13 files), NiBabel (11 files), ANTs (8 files), PyTorch (4 files), SciPy (4 files), DIPY (3 files), Nilearn (1 file), Snakemake (1 file), TensorFlow (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
46 files
At the source: github.com/MICA-MNI/MICAFlow

mica-mni.github.io/micaflow

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: the link answers
Software Heritage: not checked
Found in: “Data and Code Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 26 September 2026: the link answers (HTTP 200)
  • 26 September 2026: the link answers (HTTP 200)
At the source: mica-mni.github.io/MICAFlow

MICA-MNI/MICAFlow-Models

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 581e9fbaf0390341654483a100e14ef4fd9c263d, 10 March 2026
Size: 28 files, 0 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
At the source: github.com/MICA-MNI/MICAFlow-Models

MICA-MNI/LAMAReg

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 78b3c97d4d31b49c9cafb9d393c351955c7f3b27, 15 July 2026
Languages: Python (46)
Size: 232 files, 46 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Holds: README, license file, environment (pyproject.toml, requirements.txt), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: NumPy (30 files), TensorFlow (23 files), Keras (21 files), SciPy (6 files), ANTs (4 files), NiBabel (4 files), Matplotlib (2 files), FreeSurfer (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
48 files
At the source: github.com/MICA-MNI/LAMAReg

MICA-MNI/LAMAR-Models

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 5f43003b01e56d2754b4c0e23a98f38d1d134de3, 10 April 2025
Size: 9 files, 0 scripts
Software Heritage: not archived
Found in: “Data and Code Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
At the source: github.com/MICA-MNI/LAMAR-Models

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 5 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 90 scripts, each with its path and the digest of its content;
  • 17 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data and Code Availability

MICAFlow is available as an open-source Python package. The full source code, version history, and issue tracker are hosted on GitHub https://github.com/MICA-MNI/MICAFlow, with documentation maintained on ReadTheDocs https://mica-mni.github.io/MICAFlow. Command-line usage and options are documented via the built-in help interface (i.e., micaflow —help). The package is also distributed via PyPI https://pypi.org/project/MICAFlow/ and can be installed with “pip install micaflow” on systems with a supported Python environment (≥3.10). Models for Synb0-DISCO and MNI152 atlases are downloaded at runtime (repository link: https://github.com/MICA-MNI/MICAFlow-Models).

LAMAReg is additionally released as a standalone open-source package, with source code hosted on GitHub https://github.com/MICA-MNI/LAMAReg and distribution via PyPI https://pypi.org/project/LAMAReg. Command-line usage and options are also documented via the built-in help interface (e.g., lamareg —help). LAMAReg uses the original SynthSeg model weights; for lightweight installation, the weights are hosted as a set of packaged components that are downloaded and reassembled at runtime (https://github.com/MICA-MNI/LAMAR-Models).

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 22 authors, 6 keywords, 7 MeSH terms, 23 funders, 88 references.

Cite

This paper

Goodall-Halliwell, I., DeKraker, J., Bautin, P., Mendelson, D., Cabalo, D. G., Sahlas, E., Ngo, A., Xie, K., Lam, J., Smith, M., Hwang, Y., Vavassori, L., Milano, P., Chen, J., Dascal, A., Ding, R., Zhou, G., Naish, M., Mo, J., . . . Bernhardt, B. C. (2026). MICAFlow: Fast and robust MRI preprocessing bridging research neuroimaging and clinical practice. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1366. https://doi.org/10.1162/imag.a.1366

BibTeX

@article{goodallhalliwell2026micaflow,
author = {Goodall-Halliwell, Ian and DeKraker, Jordan and Bautin, Paul and Mendelson, Daniel and Cabalo, Donna Gift and Sahlas, Ella and Ngo, Alexander and Xie, Ke and Lam, Jack and Smith, Meaghan and Hwang, Youngeun and Vavassori, Laura and Milano, Pietro and Chen, Judy and Dascal, Arielle and Ding, Rui and Zhou, Guan and Naish, Marlo and Mo, JiaJie and Fadaie, Fatemeh and Cruces, Raul R. and Bernhardt, Boris C.},
title = {{MICAFlow: Fast and robust MRI preprocessing bridging research neuroimaging and clinical practice}},
journal = {Imaging neuroscience (Cambridge, Mass.)},
year = {2026},
month = sep,
volume = {4},
pages = {IMAG.a.1366},
publisher = {MIT Press},
issn = {2837-6056},
doi = {10.1162/imag.a.1366},
url = {https://doi.org/10.1162/imag.a.1366},
pmid = {42746345},
pmcid = {PMC13576946}
}

RIS

TY - JOUR
AU - Goodall-Halliwell, Ian
AU - DeKraker, Jordan
AU - Bautin, Paul
AU - Mendelson, Daniel
AU - Cabalo, Donna Gift
AU - Sahlas, Ella
AU - Ngo, Alexander
AU - Xie, Ke
AU - Lam, Jack
AU - Smith, Meaghan
AU - Hwang, Youngeun
AU - Vavassori, Laura
AU - Milano, Pietro
AU - Chen, Judy
AU - Dascal, Arielle
AU - Ding, Rui
AU - Zhou, Guan
AU - Naish, Marlo
AU - Mo, JiaJie
AU - Fadaie, Fatemeh
AU - Cruces, Raul R.
AU - Bernhardt, Boris C.
TI - MICAFlow: Fast and robust MRI preprocessing bridging research neuroimaging and clinical practice
T2 - Imaging neuroscience (Cambridge, Mass.)
J2 - Imaging Neurosci (Camb)
PY - 2026
DA - 2026/09/11
VL - 4
SP - IMAG.a.1366
SN - 2837-6056
PB - MIT Press
DO - 10.1162/imag.a.1366
UR - https://doi.org/10.1162/imag.a.1366
LA - en
ER -

CSL-JSON

{
"id": "10.1162/imag.a.1366",
"type": "article-journal",
"title": "MICAFlow: Fast and robust MRI preprocessing bridging research neuroimaging and clinical practice",
"container-title": "Imaging neuroscience (Cambridge, Mass.)",
"author": [
{
"family": "Goodall-Halliwell",
"given": "Ian"
},
{
"family": "DeKraker",
"given": "Jordan"
},
{
"family": "Bautin",
"given": "Paul"
},
{
"family": "Mendelson",
"given": "Daniel"
},
{
"family": "Cabalo",
"given": "Donna Gift"
},
{
"family": "Sahlas",
"given": "Ella"
},
{
"family": "Ngo",
"given": "Alexander"
},
{
"family": "Xie",
"given": "Ke"
},
{
"family": "Lam",
"given": "Jack"
},
{
"family": "Smith",
"given": "Meaghan"
},
{
"family": "Hwang",
"given": "Youngeun"
},
{
"family": "Vavassori",
"given": "Laura"
},
{
"family": "Milano",
"given": "Pietro"
},
{
"family": "Chen",
"given": "Judy"
},
{
"family": "Dascal",
"given": "Arielle"
},
{
"family": "Ding",
"given": "Rui"
},
{
"family": "Zhou",
"given": "Guan"
},
{
"family": "Naish",
"given": "Marlo"
},
{
"family": "Mo",
"given": "JiaJie"
},
{
"family": "Fadaie",
"given": "Fatemeh"
},
{
"family": "Cruces",
"given": "Raul R."
},
{
"family": "Bernhardt",
"given": "Boris C."
}
],
"container-title-short": "Imaging Neurosci (Camb)",
"volume": "4",
"page": "IMAG.a.1366",
"DOI": "10.1162/imag.a.1366",
"PMID": "42746345",
"PMCID": "PMC13576946",
"ISSN": "2837-6056",
"publisher": "MIT Press",
"URL": "https://doi.org/10.1162/imag.a.1366",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
11
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1002/epi.70254
Use of artificial intelligence in magnetic resonance imaging across the epileptic patient's journey: A meta-analysis of four clinical applications.
Journal: Epilepsia
In common: epilepsy, structural MRI / diffusion, 1 reference, 3 authors
[2] doi:10.1073/pnas.2604111123 [code]
Multiscale characterization of the human claustrum from histology to MRI.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: ANTs, FreeSurfer, structural MRI / diffusion, 3 references, 2 authors
[3] doi:10.64898/2026.04.02.26349812 [code]
9.4 Tesla MRI in focal epilepsy patients with high-resolution surface-based profiling of focal cortical dysplasias
Journal: medRxiv (preprint)
In common: ANTs, FreeSurfer, Nilearn, 4 other tools, epilepsy, structural MRI / diffusion, 4 references
[4] doi:10.2463/mrms.mp.2024-0149 [code]
Image Distortion Correction for Diffusion MR Imaging Using a Transformer-based U-Net.
Journal: Magnetic resonance in medical sciences : MRMS : an official journal of Japan Society of Magnetic Resonance in Medicine
In common: ANTs, FreeSurfer, NiBabel, 4 other tools, structural MRI / diffusion, 4 references
[5] doi:10.1002/nbm.70353 [code]
Automated Surface-Based Segmentation of Deep Gray Matter Regions Based on Diffusion Tensor Images Reveals Unique Age Trajectories Over the Healthy Lifespan.
Journal: NMR in biomedicine
In common: DIPY, ANTs, FreeSurfer, 3 other tools, structural MRI / diffusion, 5 references
[6] doi:10.7554/elife.108408 [code]
Frequency and laminar profile of feature-specific visual activity revealed by interleaved EEG-fMRI.
Journal: eLife
In common: DIPY, ANTs, FreeSurfer, 4 other tools, 5 references
[7] doi:10.1371/journal.pbio.3003755 [code]
Action information is integrated into entorhinal representations of conceptual space and is reflected in eye movements.
Journal: PLoS biology
In common: ANTs, TensorFlow, Nilearn, 4 other tools, 5 references
[8] doi:10.1162/imag.a.1362 [code]
Human fMRI at 11.7T: Assessing feasibility, stability, and reliability on the Iseult scanner.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: ANTs, FreeSurfer, Nilearn, 4 other tools, methods / tools, 4 references
[9] doi:10.64898/2026.08.18.26360725 [code]
Temporal pole blurring in hippocampal sclerosis reflects seizure-disrupted myelination
Journal: medRxiv (preprint)
In common: FreeSurfer, Nilearn, NiBabel, 4 other tools, epilepsy, structural MRI / diffusion, 3 references
[10] doi:10.1038/s41467-026-71555-0 [code]
A deep representation learning model to predict response to vagus nerve stimulation.
Journal: Nature communications
In common: ANTs, FreeSurfer, NiBabel, 4 other tools, epilepsy, structural MRI / diffusion, 4 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.