From 19e117bc81f03943e0850c1d90a882c6c6a9fe27 Mon Sep 17 00:00:00 2001 From: Pierre-Antoine Comby Date: Fri, 1 Nov 2024 14:20:32 +0100 Subject: [PATCH] Paper for JOSS (#200) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * add draft paper.md * update * update * ci: build the pdf please * update affiliations * typo * Add model * update * format * format table * update * unindent table * update with bibliography * move paper in doc * update * update * Apply suggestions from code review Co-authored-by: Chaithya G R * add lnk to PR * update action * Fill-in affiliation and fix name * fix name * Apply suggestions from code review Co-authored-by: Guillaume Daval-Frérot * update authors order * smaller figure * Correct names * add orcid Co-authored-by: Chaithya G R * apply suggestion from guillaume Co-authored-by: Guillaume Daval-Frérot * Update paper.md * Update paper.md * Update paper.bib add pysap-mri paper * Update paper.md * Update paper.bib * Update paper.md --------- Co-authored-by: Chaithya G R Co-authored-by: Matteo Cencini <83717049+mcencini@users.noreply.github.com> Co-authored-by: LenaOudjman Co-authored-by: Guillaume Daval-Frérot Co-authored-by: Asma TANABENE <121893894+AsmaTANABEN@users.noreply.github.com> --- .github/workflows/draft-pdf.yml | 42 +++++++++ docs/paper-joss/paper.bib | 154 ++++++++++++++++++++++++++++++++ docs/paper-joss/paper.md | 137 ++++++++++++++++++++++++++++ 3 files changed, 333 insertions(+) create mode 100644 .github/workflows/draft-pdf.yml create mode 100644 docs/paper-joss/paper.bib create mode 100644 docs/paper-joss/paper.md diff --git a/.github/workflows/draft-pdf.yml b/.github/workflows/draft-pdf.yml new file mode 100644 index 00000000..b6649aad --- /dev/null +++ b/.github/workflows/draft-pdf.yml @@ -0,0 +1,42 @@ +name: Draft PDF +on: + push: + paths: + - docs/paper-joss/* + - .github/workflows/draft-pdf.yml* + +permissions: + pull-requests: write + +jobs: + paper: + runs-on: ubuntu-latest + name: Paper Draft + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Build draft PDF + uses: openjournals/openjournals-draft-action@master + with: + journal: joss + # This should be the path to the paper within your repo. + paper-path: docs/paper-joss/paper.md + - name: Upload + uses: actions/upload-artifact@v4 + with: + name: paper + # This is the output path where Pandoc will write the compiled + # PDF. Note, this should be the same directory as the input + # paper.md + path: docs/paper-joss/paper.pdf + + link: + needs: paper # make sure the artifacts are uploaded first + runs-on: ubuntu-latest + permissions: + contents: write # for commenting on your commit + pull-requests: write # for commenting on your pr + steps: + - uses: beni69/artifact-link@v1 + with: + token: ${{ github.token }} diff --git a/docs/paper-joss/paper.bib b/docs/paper-joss/paper.bib new file mode 100644 index 00000000..a31ab269 --- /dev/null +++ b/docs/paper-joss/paper.bib @@ -0,0 +1,154 @@ +@unpublished{shih_cufinufft_2021, + title = {{{cuFINUFFT}}: A Load-Balanced {{GPU}} Library for General-Purpose Nonuniform {{FFTs}}}, + shorttitle = {{{cuFINUFFT}}}, + author = {Shih, Yu-hsuan and Wright, Garrett and Andén, Joakim and Blaschke, Johannes and Barnett, Alex H.}, + date = {2021-03-25}, + eprint = {2102.08463}, + eprinttype = {arXiv}, + eprintclass = {cs, eess, math}, + url = {http://arxiv.org/abs/2102.08463}, + urldate = {2021-12-10}, + abstract = {Nonuniform fast Fourier transforms dominate the computational cost in many applications including image reconstruction and signal processing. We thus present a generalpurpose GPU-based CUDA library for type 1 (nonuniform to uniform) and type 2 (uniform to nonuniform) transforms in dimensions 2 and 3, in single or double precision. It achieves high performance for a given user-requested accuracy, regardless of the distribution of nonuniform points, via cache-aware point reordering, and load-balanced blocked spreading in shared memory. At low accuracies, this gives on-GPU throughputs around 109 nonuniform points per second, and (even including hostdevice transfer) is typically 4–10× faster than the latest parallel CPU code FINUFFT (at 28 threads). It is competitive with two established GPU codes, being up to 90× faster at high accuracy and/or type 1 clustered point distributions. Finally we demonstrate a 5–12× speedup versus CPU in an X-ray diffraction 3D iterative reconstruction task at 10−12 accuracy, observing excellent multi-GPU weak scaling up to one rank per GPU.}, + langid = {english}, + keywords = {{Computer Science - Distributed, Parallel, and Cluster Computing},Computer Science - Mathematical Software,Electrical Engineering and Systems Science - Signal Processing,Mathematics - Numerical Analysis,No DOI found}, + file = {/volatile/home/pc266769/Zotero/storage/K5LLWXZE/shih_cufinufft_2021.pdf} +} + +@inproceedings{uecker_berkley_2015, + title = {Berkley Advanced Reconstruction Toolbox}, + shorttitle = {Mrirecon/Bart}, + booktitle = {Proc. {{Intl}}. {{Soc}}. {{Mag}}. {{Reson}}. {{Med}}. 23}, + author = {Uecker, Martin and Ong, Frank and Tamir, J}, + date = {2015}, + location = {Toronto}, + url = {https://zenodo.org/records/10277939}, + urldate = {2023-12-19}, + keywords = {No DOI found}, + file = {/volatile/home/pc266769/Zotero/storage/LIMD2P5S/10277939.html} +} + +@inproceedings{ong_frank_sigpy_2019, + title = {{{SigPy}}: {{A Python Package}} for {{High Performance Iterative Reconstruction}}}, + booktitle = {{{ISMRM}} 2019}, + author = {{Ong Frank} and {Lustig Michael}}, + date = {2019}, + abstract = {We present SigPy, a Python package designed for high performance iterative reconstruction. Its main features include: - A unified CPU and GPU Python interface to signal processing functions, including convolution, FFT, NUFFT, wavelet transform, and thresholding functions. - Convenient classes (Linop, Prox, Alg, App) to build more complicated iterative reconstruction algorithms. - Commonly used MRI reconstruction methods as Apps, including SENSE, L1-wavelet regularized reconstruction, total-variation regularized reconstruction, and JSENSE. - MRI-specific functions, including poisson-disc sampling, ESPIRiT calibration, and non-Cartesian preconditioners. - Simple installation via pip and conda.}, + eventtitle = {{{ISMRM}}}, + keywords = {No DOI found} +} + +@article{sutton_fast_2003, + title = {Fast, Iterative Image Reconstruction for {{MRI}} in the Presence of Field Inhomogeneities}, + author = {Sutton, B.P. and Noll, D.C. and Fessler, J.A.}, + date = {2003-02}, + journaltitle = {IEEE Transactions on Medical Imaging}, + volume = {22}, + number = {2}, + pages = {178--188}, + issn = {1558-254X}, + doi = {10.1109/TMI.2002.808360}, + abstract = {In magnetic resonance imaging, magnetic field inhomogeneities cause distortions in images that are reconstructed by conventional fast Fourier transform (FFT) methods. Several noniterative image reconstruction methods are used currently to compensate for field inhomogeneities, but these methods assume that the field map that characterizes the off-resonance frequencies is spatially smooth. Recently, iterative methods have been proposed that can circumvent this assumption and provide improved compensation for off-resonance effects. However, straightforward implementations of such iterative methods suffer from inconveniently long computation times. This paper describes a tool for accelerating iterative reconstruction of field-corrected MR images: a novel time-segmented approximation to the MR signal equation. We use a min-max formulation to derive the temporal interpolator. Speedups of around 60 were achieved by combining this temporal interpolator with a nonuniform fast Fourier transform with normalized root mean squared approximation errors of 0.07\%. The proposed method provides fast, accurate, field-corrected image reconstruction even when the field map is not smooth.}, + eventtitle = {{{IEEE Transactions}} on {{Medical Imaging}}}, + keywords = {Biomedical engineering,Frequency,Image reconstruction,Image segmentation,Iterative methods,Magnetic fields,Magnetic resonance imaging,Optical imaging,Reconstruction algorithms,Spirals}, + file = {/volatile/home/pc266769/Zotero/storage/8XA5ZU44/sutton_fast_2003.pdf} +} + +@article{fessler_nonuniform_2003, + title = {Nonuniform Fast Fourier Transforms Using Min-Max Interpolation}, + author = {Fessler, J.A. and Sutton, B.P.}, + date = {2003-02}, + journaltitle = {IEEE Transactions on Signal Processing}, + shortjournal = {IEEE Trans. Signal Process.}, + volume = {51}, + number = {2}, + pages = {560--574}, + issn = {1053-587X}, + doi = {10.1109/tsp.2002.807005}, + url = {http://ieeexplore.ieee.org/document/1166689/}, + urldate = {2021-05-03}, + abstract = {The FFT is used widely in signal processing for efficient computation of the Fourier transform (FT) of finitelength signals over a set of uniformly-spaced frequency locations. However, in many applications, one requires nonuniform sampling in the frequency domain, i.e., a nonuniform FT. Several papers have described fast approximations for the nonuniform FT based on interpolating an oversampled FFT. This paper presents an interpolation method for the nonuniform FT that is optimal in the min-max sense of minimizing the worst-case approximation error over all signals of unit norm. The proposed method easily generalizes to multidimensional signals. Numerical results show that the min-max approach provides substantially lower approximation errors than conventional interpolation methods. The min-max criterion is also useful for optimizing the parameters of interpolation kernels such as the Kaiser-Bessel function.}, + langid = {english}, + file = {/volatile/home/pc266769/Zotero/storage/4NDF5834/fessler_nonuniform_2003.pdf} +} + +@article{wang_efficient_2023, + title = {Efficient Approximation of {{Jacobian}} Matrices Involving a Non-Uniform Fast {{Fourier}} Transform ({{NUFFT}})}, + author = {Wang, Guanhua and Fessler, Jeffrey A.}, + date = {2023}, + journaltitle = {IEEE Transactions on Computational Imaging}, + shortjournal = {IEEE Trans. Comput. Imaging}, + volume = {9}, + eprint = {2111.02912}, + eprinttype = {arXiv}, + eprintclass = {eess}, + pages = {43--54}, + issn = {2333-9403, 2334-0118, 2573-0436}, + doi = {10.1109/TCI.2023.3240081}, + url = {http://arxiv.org/abs/2111.02912}, + urldate = {2024-04-11}, + abstract = {There is growing interest in learning k-space sampling patterns for MRI using optimization approaches [1], [2], [3], [4]. For non-Cartesian sampling patterns, reconstruction methods typically involve non-uniform FFT (NUFFT) operations. A typical NUFFT method contains frequency domain interpolation using Kaiser-Bessel kernel values that are retrieved by nearest neighbor look-up in a finely tabulated kernel [5]. That look-up operation is not differentiable with respect to the sampling pattern, complicating auto-differentiation routines for backpropagation (stochastic gradient descent) for sampling pattern optimization. This paper describes an efficient and accurate approach for computing approximate gradients with respect to the sampling pattern for learning k-space sampling. Various numerical experiments validate the accuracy of the proposed approximation. We also showcase the trajectories optimized for different iterative reconstruction algorithms, including smooth convex regularized reconstruction and compressed sensing-based reconstruction.}, + langid = {english}, + keywords = {Electrical Engineering and Systems Science - Image and Video Processing,Electrical Engineering and Systems Science - Signal Processing}, + file = {/volatile/home/pc266769/Zotero/storage/HU6FNVQU/Wang et Fessler - 2023 - Efficient approximation of Jacobian matrices invol.pdf} +} +@inproceedings{knoll_gpunufft_2014, + title={gpuNUFFT - An Open Source GPU Library for 3D Regridding with Direct Matlab Interface}, + author={Florian Knoll and Andreas Schwarzl and Clemens Diwoky and Daniel K. Sodickson}, + year={2014}, + url={https://api.semanticscholar.org/CorpusID:53652346} +} +@inproceedings{muckley_torchkbnufft_2020, + author = {M. J. Muckley and R. Stern and T. Murrell and F. Knoll}, + title = {{TorchKbNufft}: A High-Level, Hardware-Agnostic Non-Uniform Fast {Fourier} Transform}, + booktitle = {ISMRM Workshop on Data Sampling \& Image Reconstruction}, + year = 2020, + note = {Source code available at https://github.com/mmuckley/torchkbnufft}, +} +@inproceedings{comby_snake-fmri_2024, + ids = {Comby_Vignaud_Ciuciu_2024}, + title = {{{SNAKE-fMRI}}: {{A}} Modular {{fMRI}} Simulator from the Space-Time Domain to k-Space Data and Back}, + booktitle = {{{ISMRM}} Annual Meeting, (in Press)}, + author = {Comby, P.-A. and Vignaud, A. and Ciuciu, P.}, + date = {2024}, + location = {Singapore}, + keywords = {No DOI found} +} + +@article{farrens_pysap_2020, + title = {{{PySAP}}: {{Python Sparse Data Analysis Package}} for Multidisciplinary Image Processing}, + shorttitle = {{{PySAP}}}, + author = {Farrens, S. and Grigis, A. and El Gueddari, L. and Ramzi, Z. and G.r., Chaithya and Starck, S. and Sarthou, B. and Cherkaoui, H. and Ciuciu, P. and Starck, J. -L.}, + date = {2020-07-01}, + journaltitle = {Astronomy and Computing}, + shortjournal = {Astronomy and Computing}, + volume = {32}, + pages = {100402}, + issn = {2213-1337}, + doi = {10.1016/j.ascom.2020.100402}, + url = {https://www.sciencedirect.com/science/article/pii/S2213133720300561}, + urldate = {2024-09-27}, + abstract = {We present the open-source image processing software package PySAP (Python Sparse data Analysis Package) developed for the COmpressed Sensing for Magnetic resonance Imaging and Cosmology (COSMIC) project. This package provides a set of flexible tools that can be applied to a variety of compressed sensing and image reconstruction problems in various research domains. In particular, PySAP offers fast wavelet transforms and a range of integrated optimisation algorithms. In this paper we present the features available in PySAP and provide practical demonstrations on astrophysical and magnetic resonance imaging data.}, + keywords = {Convex optimisation,Image processing,Open-source software,Reconstruction}, + file = {/volatile/home/pc266769/Zotero/storage/X4725MSA/Farrens et al. - 2020 - PySAP Python Sparse Data Analysis Package for multidisciplinary image processing.pdf} +} + +@software{tachella_deepinverse_2023, + title = {{{DeepInverse}}: {{A}} Deep Learning Framework for Inverse Problems in Imaging}, + shorttitle = {{{DeepInverse}}}, + author = {Tachella, Julian and Chen, Dongdong and Hurault, Samuel and Terris, Matthieu and Wang, Andrew}, + date = {2023-06}, + doi = {10.5281/zenodo.7982256}, + url = {https://github.com/deepinv/deepinv}, + urldate = {2024-09-27}, + abstract = {PyTorch library for solving imaging inverse problems using deep learning}, + version = {latest} +} + +@inproceedings{gueddari_pysap-mri_2020, + ids = {gueddari_pysap-mri_2020-1,gueddari_pysap-mri_2020-2}, + title = {{{PySAP-MRI}}: A Python Package for {{MR}} Image Reconstruction}, + booktitle = {{{ISMRM}} Workshop on Data Sampling and Image Reconstruction}, + author = {Gueddari, Loubna and Gr, Chaithya and Ramzi, Zaccharie and Farrens, Samuel and Starck, Sophie and Grigis, Antoine and Starck, Jean-Luc and Ciuciu, Philippe}, + year = {2020}, +} + diff --git a/docs/paper-joss/paper.md b/docs/paper-joss/paper.md new file mode 100644 index 00000000..b5304241 --- /dev/null +++ b/docs/paper-joss/paper.md @@ -0,0 +1,137 @@ +--- +title: 'MRI-NUFFT: Doing non-Cartesian MRI has never been easier' +tags: + - Python + - MRI + - NUFFT + - Numpy + - CUDA + - Torch +authors: + - name: Pierre-Antoine Comby + orcid: 0000-0001-6998-232X + corresponding: true + affiliation: "1, 2" + - name: Guillaume Daval-Frérot + orcid: 0000-0002-5317-2522 + affiliation: 3 + - name: Caini Pan + affiliation: "1, 2" + - name: Asma Tanabene + affiliation: "1,2,5" + - name: Léna Oudjman + affiliation: "1, 2" + - name: Matteo Cencini + affiliation: 4 + - name: Philippe Ciuciu + orcid: 0000-0001-5374-962X + affiliation: "1,2" + - name: Chaithya GR + orcid: 0000-0001-9859-6006 + corresponding: true + affiliation: "1,2" + +affiliations: + - name: MIND, Inria + index: 1 + - name: Université Paris-Saclay / CEA + index: 2 + - name: Chipiron + index: 3 + - name: INFN, Pisa Division + index: 4 + - name: Siemens Healthineers + index: 5 + +date: 20 September 2024 +bibliography: paper.bib +--- + + +# Summary +MRI-NUFFT is a python package that provides a universal interface to various Non-Uniform Fast Fourier Transform libraries running on CPU or GPU (gpuNUFFT, FINUFFT, CUFINUFFT, pyNFFT), adding compatibily with standard array library (NumPy, CuPy, PyTorch, TensorFlow, etc.) On top of these libraries it extends the existing NUFFT operations to provide a physical model of the MRI acquisition process (e.g. multi-coil acquisition and static-field inhomogeneities). It also provides a wide variety of customizable implementations of non-Cartesian sampling trajectories, as well as density compensation methods. Finally, it proposes optimized auto-differentiation with respect to the data and sampling locations for machine learning. With MRI-NUFFT one can experiment with non-Cartesian sampling in MRI, get access to the latest advances in the field and state-of-the-art sampling patterns. + + +# Statement of need +MRI is an non-invasive biomedical imaging technique, where raw data is sampled in the spatial frequency domain (k-space) and final images are obtained by applying an inverse (fast) Fourier transform on this data. +Traditionnaly, the data is sampled on a Cartesian grid (often partially by skipping lines to accelerate the acquisition) and reconstructed using FFT-based algorithms. +However, the Cartesian approach is not always the best choice for data collection, and non-Cartesian sampling schemes have been proposed to improve image quality, reduce acquisition time or enable new imaging modalities. But the reconstruction of non-Cartesian data is more challenging and requires the use of non-uniform fast Fourier transform (NUFFT) algorithms. +Several NUFFT libraries have been developed in the past few years, but they are not always easy to use or don't account for the specificities of MRI data acquisition (e.g. multi-coil acquisition, static-field inhomogeneities, density compensation, etc.). Also their performances can vary a lot depending on the use cases (2D vs 3D data, number of coils, etc.). + +Moreover, non-Cartesian acquisitions are still an active research field, with new sampling patterns being proposed regularly. With MRI-NUFFT one can easily experiment with these new patterns and compare them to existing ones. +Furthermore, there has been a growing interest in using deep learning to jointly learn MRI acquisition and reconstruction, which requires to compute the gradients of the reconstruction with respect to the raw data and/or the sampling locations. + +# Features + +![MRI-NUFFT as an interface for non-Cartesian MRI](../_static/mri-nufft-scheme.svg){width=10cm} + +## NUFFT Library compatibility +MRI-NUFFT is compatible with the following NUFFT librairies: FINUFFT[@barnett_parallel_2019], CUFINUFFT[@shih_cufinufft_2021], gpuNUFFT[@knoll_gpunufft_2014], TorchKbNufft[@muckley_torchkbnufft_2020], pyNFFT, sigpy[@ong_frank_sigpy_2019] and BART[@uecker_berkley_2015]. +Using our [benchmark](https://github.com/mind-inria/mri-nufft-benchmark/) we can also determine which NUFFT implementation provides the best performances both in term of computation time and memory footprint. At the time of writing, cufinufft and gpunufft provide the best performances by leveraging CUDA acceleration. MRI-NUFFT supports as well standard array libraries (NumPy, CuPy, PyTorch, TensorFlow, etc.) and optimizes data copies, relying on the array-API standard. +It also provides several enhancements on top of these backends, notably an optimized 2.5D NUFFT (for stacks of 2D non uniform trajectories, commonly used in MRI), and a data-consistency term for iterative reconstruction ($\mathcal{F}_\Omega^*(\mathcal{F}_\Omega x - y)$). + + +## Extended Fourier Model +MRI-NUFFT provides a physical model of the MRI acquisition processus, including multi-coil acquisition and static-field inhomogeneities. This model is compatible with the NUFFT libraries, and can be used to simulate the acquisition of MRI data, or to reconstruct data from a given set of measurements. Namely we provide a linear operator that encapsulates the forward and adjoint NUFFT operators, the coil sensitivity maps and (optionnaly) the static field inhomogeneities. The forward model is described by the following equation: +$$y(\boldsymbol{\nu}_i) = \sum_{j=1}^N x(\boldsymbol{u}_j) e^{-2\imath\pi\boldsymbol{u}_j\cdot\boldsymbol{\nu_i}} + n_i, \quad i=1,\dots,M$$ +where: +$x(\boldsymbol{u})$ is the spatially varying image contrast acquired; $y_1, \dots, y_M$ are the sampled points at frequency locations; $\Omega=\lbrace \boldsymbol{\nu}_1, \dots, \boldsymbol{\nu}_M \in [-1/2, 1/2]^d\rbrace$; $\boldsymbol{u}_j$ are the $N$ spatial locations of image voxels, and $n_i$ is a zero-mean complex-valued Gaussian noise, modeling the thermal noise of the scanner. + +This can also be formulated using the operator notation $\boldsymbol{y} = \mathcal{F}_\Omega (\boldsymbol{x}) + \boldsymbol{n}$ + +As the sampling locations $\Omega$ are non-uniform and the image locations $\boldsymbol{u}_j$ are uniform, $\mathcal{F}_\Omega$ is a NUDFT operator, and the equation above describe a Type 2 NUDFT. +Similarly the adjoint operator is a Type 1 NUDFT: + +: Correspondence Table between NUFFT and MRI acquisition model. + +| NUFFT Type | Operation | MRI Transform | Operator | +|:-----------|:----------|:-------------------|:-----------------------| +| Type 1 | Adjoint | K-space $\to$ image | $\mathcal{F}_\Omega^*$ | +| Type 2 | Forward | Image $\to$ k-space | $\mathcal{F}_\Omega$ | + + +### Parallel Imaging Model +In MRI the acquired signal can be received by multiple antennas (\"coils\"). +Each coil possesses a specific sensitivity profile (i.e. each sees the object differently due to its physical layout). + +$$\begin{aligned} +\tilde{\boldsymbol{y}} = \begin{bmatrix} + \mathcal{F}_\Omega S_1 \\ + \vdots \\ + \mathcal{F}_\Omega S_L \\ + \end{bmatrix} + \boldsymbol{x} + \boldsymbol{n}_\ell = \mathcal{F}_\Omega S \otimes \boldsymbol{x} + \tilde{\boldsymbol{n}} +\end{aligned}$$ + +where $S_1, \dots, S_L$ are the sensitivity maps of each coil. +Such maps can be acquired separately by sampling the k-space low frequencies, or estimated from the data. + +### Off-resonance correction model +The constant magnetic field $B0$ applied in an MRI machine (typically 1.5, 3 or 7 teslas) is inherently disturbed by metal implants or even simply by difference in magnetic susceptibilities of tissues (such at air-tissue interfaces close to the nose and ear canals). +Those field perturbations introduce a spatially varying phase shift in the acquired frequencies (noted $\Delta\omega_0$), causing the physical model to deviate from the ideal Fourier model. +Fortunately, this inhomogeneity map can be acquired separately or estimated then integrated as: + +$$y(t_i) = \int_{\mathbb{R}^d} x(\boldsymbol{u}) e^{-2\imath\pi \boldsymbol{u} \cdot\boldsymbol{\nu_i} + \Delta\omega(\boldsymbol{u}) t_i} d\boldsymbol{u}$$ + +where $t_i$ is the time at which the frequency $\nu_i$ is acquired. +With these mixed-domain field perturbations, the Fourier model does not hold anymore and the FFT algorithm can no longer be used. +The main solution [@sutton_fast_2003] is to interpolate the mixed-domain exponential term by splitting it into single-domain weights $b_{m, \ell}$ and $c_{\ell, n}, where $L \ll M, N$ regular Fourier transforms are performed to approximate the non-Fourier transform. + +$$x(\boldsymbol{u_n}) = \sum_{\ell=1}^L c_{\ell, n} \sum_{m}^M y(t_m) b_{m, \ell} e^{2\imath\pi \boldsymbol{u} \cdot \boldsymbol{\nu_i}}$$ + +The coefficients $B=(b_{m, \ell}) \in \mathbb{C}^{M\times L}$ and $C=(c_\ell, n) \in \mathbb{C}^{L\times N}$ can be estimated within MRI-NUFFT. + +## Trajectories generation and expansions +MRI-NUFFT comes with a wide variety of non-Cartesian trajectory generation routines that have been gathered from the literature. It also provides ways to extend existing trajectories and export them to specific formats, for use in other toolkits and on MRI hardware. + +## Auto-differentiation for data and sampling pattern + +Following the formulation of [@wang_efficient_2023], MRI-NUFFT provides automatic differentiation for all NUFFT backends, with respect to both gradients and data (image or k-space). This enables efficient backpropagation through NUFFT operators and supports research on learned sampling model and image reconstruction network. + +# MRI-NUFFT utilization +MRI-NUFFT is already used in conjunction with other software such as SNAKE-fMRI [@comby_snake-fmri_2024], deepinv [@tachella_deepinverse_2023] and PySAP-MRI [@farrens_pysap_2020; @gueddari_pysap-mri_2020] + +# References + + +