From c1bbc5ccdd81ef6f76d91ee5ffce5e0bb7a4d21a Mon Sep 17 00:00:00 2001 From: lukepolson Date: Wed, 7 Aug 2024 03:22:26 +0000 Subject: [PATCH] update paper --- paper/paper.bib | 99 ++++++++++++++++++++++++++++++++++++++++++++++++- paper/paper.md | 31 ++++++++-------- 2 files changed, 113 insertions(+), 17 deletions(-) diff --git a/paper/paper.bib b/paper/paper.bib index 3b652ac..218b671 100644 --- a/paper/paper.bib +++ b/paper/paper.bib @@ -226,4 +226,101 @@ @article{ac6 pages={2504--2514}, year={2024}, doi={10.1007/s00259-024-06681-2} -} \ No newline at end of file +} + +@article{GRF_2, +doi = {10.1088/0031-9155/35/1/008}, +url = {https://dx.doi.org/10.1088/0031-9155/35/1/008}, +year = {1990}, +month = {jan}, +publisher = {}, +volume = {35}, +number = {1}, +pages = {81}, +author = {B M W Tsui and G T Gullberg}, +title = {The geometric transfer function for cone and fan beam collimators}, +journal = {Physics in Medicine & Biology}, +abstract = {Geometric response functions are derived for both cone and fan beam collimators for the scintillation camera. The formulation is based on an effective response function which is determined by the geometric response of a single hole. The technique provides an accurate description of the spatial resolution by characterising the complete geometric response function which includes the effects of the shape and orientation of the collimator holes. The theoretical formulation was used to design a fan beam collimator for SPECT imaging and was shown to agree well with the experimental results.} +} + +@article{GRF_3, +doi = {10.1088/0031-9155/43/4/021}, +url = {https://dx.doi.org/10.1088/0031-9155/43/4/021}, +year = {1998}, +month = {apr}, +publisher = {}, +volume = {43}, +number = {4}, +pages = {941}, +author = {E C Frey and B M W Tsui and G T Gullberg}, +title = {Improved estimation of the detector response function for converging beam collimators}, +journal = {Physics in Medicine & Biology}, +abstract = {Converging beam collimator geometries offer improved tradeoffs between resolution and noise for single photon emission computed tomography (SPECT). The major factor limiting the resolution in SPECT is the collimator-detector response blurring. In order to compensate for this blurring it is useful to be able to calculate the collimator response function. A previous formulation presented a method for calculating the response for parallel and converging beam collimators that assumed that the shape of the holes did not change over the face of the collimator. However, cast collimators are fabricated using pins with a constant cross-section (shape perpendicular to the pin axis). As a result, due to the angulation of the pins, the holes made by these pins have shapes on the front and back faces of the collimator that change with position. This change in hole shape is especially pronounced when the angle between the collimator hole and the collimator normal is large, as is the case for half-fan-beam or short-focal-length collimators. This paper presents a derivation of a modification to the original method that accounts for the change in shape of the collimator holes. The method has been verified by comparing predicted line spread functions to experimentally measured ones for a collimator with a maximum hole angle of with respect to the normal. This formulation is useful for predicting the response of fan-beam collimators in the design process and for use in detector response compensation algorithms.} +} + +@article{GRF_4, +doi = {10.1088/0031-9155/43/11/013}, +url = {https://dx.doi.org/10.1088/0031-9155/43/11/013}, +year = {1998}, +month = {nov}, +publisher = {}, +volume = {43}, +number = {11}, +pages = {3359}, +author = {Andreas Robert Formiconi}, +title = {Geometrical response of multihole collimators}, +journal = {Physics in Medicine & Biology}, +abstract = {A complete theory of camera multihole collimators is presented. The geometrical system response is determined in closed form in frequency space. This closed form accounts for the known efficiency and resolution formulae for parallel beam, fan beam, cone beam and astigmatic collimators as well as for the most frequent hole array patterns and hole shapes. The point spread function in the space domain for a certain collimator and source position can be calculated via a discrete fast Fourier transform. Beside the complete theoretical definition of the response of multihole collimators, this theory allows the definition of accurate models of the geometrical response for SPECT reconstruction and it is suitable for designing new collimators.} +} + +@article{metz1980geometric, + title={The geometric transfer function component for scintillation camera collimators with straight parallel holes}, + author={Metz, C E and Atkins, F B and Beck, R N}, + journal={Physics in Medicine and Biology}, + volume={25}, + number={6}, + pages={1059--1070}, + year={1980}, + publisher={IOP Publishing}, + doi={10.1088/0031-9155/25/6/003} +} + +@ARTICLE{septal, + author={Du, Y. and Frey, E.C. and Wang, W.T. and Tocharoenchai, C. and Baird, W.H. and Tsui, B.M.W.}, + journal={IEEE Transactions on Nuclear Science}, + title={Combination of MCNP and SimSET for Monte Carlo simulation of SPECT with medium- and high-energy photons}, + year={2002}, + volume={49}, + number={3}, + pages={668-674}, + keywords={Single photon emission computed tomography;Computational modeling;Imaging phantoms;Medical simulation;Optical collimators;Particle scattering;Nuclear medicine;Reconstruction algorithms;Electromagnetic scattering;X-ray scattering}, + doi={10.1109/TNS.2002.1039547}} + +@Inbook{Zaidi2006, +author="Zaidi, H. +and Hasegawa, B. H.", +editor="Zaidi, Habib", +title="Overview of Nuclear Medical Imaging: Physics and Instrumentation", +bookTitle="Quantitative Analysis in Nuclear Medicine Imaging", +year="2006", +publisher="Springer US", +address="Boston, MA", +pages="1--34", +isbn="978-0-387-25444-9", +doi="10.1007/0-387-25444-7_1", +url="https://doi.org/10.1007/0-387-25444-7_1" +} + +@article {bi213_amyloid, + author = {Bender, Aidan A. and Kirkeby, Emily K. and Cross, Donna J. and Minoshima, Satoshi and Roberts, Andrew G. and Mastren, Tara E.}, + title = {Development of a 213Bi-Labeled Pyridyl Benzofuran for Targeted α-Therapy of Amyloid-β Aggregates}, + elocation-id = {jnumed.124.267482}, + year = {2024}, + doi = {10.2967/jnumed.124.267482}, + publisher = {Society of Nuclear Medicine}, + abstract = {Alzheimer disease is a neurodegenerative disorder with limited treatment options. It is characterized by the presence of several biomarkers, including amyloid-β aggregates, which lead to oxidative stress and neuronal decay. Targeted α-therapy (TAT) has been shown to be efficacious against metastatic cancer. TAT takes advantage of tumor-localized α-particle emission to break disease-associated covalent bonds while minimizing radiation dose to healthy tissues due to the short, micrometer-level, distances traveled. We hypothesized that TAT could be used to break covalent bonds within amyloid-β aggregates and facilitate natural plaque clearance mechanisms. Methods: We synthesized a 213Bi-chelate{\textendash}linked benzofuran pyridyl derivative (BiBPy) and generated [213Bi]BiBPy, with a specific activity of 120.6 GBq/μg, dissociation constant of 11 {\textpm} 1.5 nM, and logP of 0.14 {\textpm} 0.03. Results: As the first step toward the validation of [213Bi]BiBPy as a TAT agent for the reduction of Alzheimer disease{\textendash}associated amyloid-β, we showed that brain homogenates from APP/PS1 double-transgenic male mice (6{\textendash}9 mo old) incubated with [213Bi]BiBPy exhibited a marked reduction in amyloid-β plaque concentration as measured using both enzyme-linked immunosorbent and Western blotting assays, with a half-maximal effective concentration of 3.72 kBq/pg. Conclusion: This [213Bi]BiBPy-concentration{\textendash}dependent activity shows that TAT can reduce amyloid plaque concentration in~vitro and supports the development of targeting systems for in~vivo validations.}, + issn = {0161-5505}, + URL = {https://jnm.snmjournals.org/content/early/2024/07/25/jnumed.124.267482}, + eprint = {https://jnm.snmjournals.org/content/early/2024/07/25/jnumed.124.267482.full.pdf}, + journal = {Journal of Nuclear Medicine} +} diff --git a/paper/paper.md b/paper/paper.md index cd72c80..a03e95d 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -37,19 +37,20 @@ aas-journal: Astrophysical Journal <- The name of the AAS journal. # Summary -`SPECTPSFToolbox` is a python toolbox for SPECT point spread function (PSF) fitting. The library provides functionality for obtaining comprehensive PSF models that can be used in the python library PyTomography [@pytomography] for SPECT reconstruction. The models are constructed from linear operators that can be chained together and fit to Monte Carlo (MC) or real point source data. +`SPECTPSFToolbox` is a python toolbox built with PyTorch for point spread function (PSF) modeling in clinical Single photon emission computed tomography (SPECT) imaging. The toolbox provides functions and classes that model distinct components of SPECT PSFs for parallel hole collimator systems. The individual components can be chained through addition and multiplication to construct a full PSF model. Developed models may also contain parameters which can be fit to Monte Carlo (MC) or real SPECT projection data. The toolbox is an independent repository of the PyTomography [@pytomography] project; developed models can be directly used in the main PyTomography library for SPECT image reconstruction. # Statement of need -SPECT imaging is used to measure the 3D distribution of a radioactive molecule within a patient; it requires (i) acquisition of 2D projection images at different angles using a gamma camera followed by (ii) use of a tomographic image reconstruction algorithm to obtain a 3D radioactivity distribution consistent with the acquired data [@Barrett2003FoundationsOI]. The gamma cameras used in SPECT imaging have finite resolution: infinitesmal point sources of radioactivity show up as finite "point spread functions" (PSF) on the camera. The PSF consists of three main components: (i) the geometric component (GC) which depends on the shape and spacing of the collimator bores, (ii) the septal penetration component (SPC) which results from photons that travel through the collimator material without being attenuated, and (iii) the septal scatter component (SSC), which consists of photons that scatter within the collimator material and subsequently get detected in the scintillator. When the thickness of the SPECT collimator sufficiently matches the energy of the detected radiation, the PSF is dominated by the GC and can be sufficiently approximated using a distance dependent Gaussian function. When the energy of the photons is large relative to the thickness and hole size of the collimator material, the PSF contains significant contributions from SPC and SSC and it can no longer be approximated using simple Gaussian functions. +SPECT is an \textit{in vivo} imaging modality modality used to estimate the 3D radiopharmaceutical distributions within a patient [@Zaidi2006]. It requires (i) acquisition of 2D ``projection'' images at different angles using a gamma camera followed by (ii) use of a tomographic image reconstruction algorithm to obtain a 3D radioactivity distribution consistent with the acquired data. In order to reconstruct SPECT projection data, a system model is needed that captures all features of the imaging system, such as resolution modeling. The gamma cameras used in SPECT imaging have finite resolution, meaning point sources of radioactivity appear as point spread functions (PSFs) on the camera. The PSF has two main components: (i) the intrisic response function (IRF), which results from the inability of the scintillator to precisely locate the point of interaction and (ii) the collimator detector response function (CDRF), which results from the inability of the collimator to select for photons travelling perpendicular to the bores. -Unfortunately, many currently available open source reconstruction library only provide support for Gaussian PSF modeling which can only capture the GC. Given the recent success of ${}^{225}$Ac based radiopharmaceuticals for prostate cancer treatment that emit high energy photons [@ac1; @ac2; @ac3; @ac4; @ac5; @ac6], there is a need for tools that provides comprehensive SPECT PSF modeling that include SPC and SSC. This python based library provides the tools to build general SPECT PSF models. The developed models can be saved and used in open source image reconstruction libraries, such as PyTomography. +The CDRF itself consists of three main components: (i) the geometric response function (GRF) [@metz1980geometric; @GRF_2;@GRF_3; @GRF_4] which results from photons that pass through the collimator bores without intersecting the septa, (ii) the septal penetration response function (SPRF) which results from photons that travel through the septa without being attenuated, and (iii) the septal scatter response function (SSRF), which consists of photons that scatter within the collimator material and subsequently get detected in the scintillator [@septal]. As the thickness of the collimator increases and diameter of the collimator bores decreases, the relative contribution from the SPRF and SSRF decreases. When the SPRF and SSRF are sufficiently small, the net PSF is dominated by the IRF and GRF and it can be reasonably approximated using a Gaussian function. The trade-off, however, is that a thick collimator with narrow bores also has lower detector sensitivity. It may necessary to have non-negligible contributions from the SPRF and SSRF in order to increase detector sensitivity. In certain situations, the imaged photons have energies so high that the available commerical collimators are unable to surpress the SPRF and SSRF. +Unfortunately, the exisiting open source reconstruction libraries only provide support for Gaussian PSF modeling and thus can only be used reconstruct SPECT data where the PSF is dominated the IRF and GRF. In many recent SPECT applications, this does not hold. For example, ${}^{225}$Ac based treatments have recently shown promise in clinical studies [@ac1; @ac2; @ac3; @ac4; @ac5; @ac6], and targetted alpha therapy with ${}^{213}$Bi has shown promise in reducing amyloid plaque concentrations in male mice, eluding to a potential treatment option for Alzeimer disease [@bi213_amyloid]. Both ${}^{225}$Ac and ${}^{213}$Bi are imaged using a 440 keV photon emissions that result in significant SPRF and SSRF components in the PSF. If the nuclear medicine community is to explore and develop novel reconstruction techniques in these domains, then there is a need for open source tools that provide comprehensive and computationally efficient SPECT PSF modeling. This python based toolbox provides those tools. # Overview of SPECTPSFToolbox -The purpose of SPECT reconstruction is to estimate the 3D radionuclide concentration $f$ that produces the acquired detector data $g$ given an analytical model for the imaging system, known as the system matrix. Under standard conditions, the SPECT system matrix estimates the projection $g_{\theta}$ at angle $\theta$ as +The purpose of SPECT reconstruction is to estimate the 3D radionuclide concentration $f$ that produces the acquired 2D image data $g$ given an analytical model for the imaging system, known as the system matrix. Under standard conditions, the SPECT system matrix estimates the projection $g_{\theta}$ at angle $\theta$ as \begin{equation} g_{\theta}(x,y) = \sum_{d} \mathrm{PSF}(d) \left[f'(x,y,d)\right] @@ -58,27 +59,25 @@ The purpose of SPECT reconstruction is to estimate the 3D radionuclide concentra where $(x,y)$ is the position on the detector, $d$ is the perpendicular distance to the detector, $f'$ is the attenuation adjusted image corresponding to the detector angle, and $\mathrm{PSF}(d)$ is a 2D linear operator that operates seperately on $f$ at each distance $d$. The toolbox provides the necessary tools to obtain $\mathrm{PSF}(d)$. -The toolbox is seperated into three main classes +The toolbox is seperated into three main class types; they are best described by the implementation of their `__call__` methods: -\begin{enumerate} -\item `Kernel1D`: objects that take in 1D position $x$, source-detector distance $d$, hyperparameters $b$, and return a 1D kernel at each source-detector distance. -\item `Kernel2D`: objects that take in a 2D meshgrid $(x,y)$, source-detector distance $d$, hyperparameters $b$, and return a 2D kernel at each source-detector distance. -\item `Operator`: objects take in take in a 2D meshgrid $(x,y)$, source-detector distance $d$, as well as an input $f$, and return the operation $\mathrm{PSF}(d) \left[f'(x,y,d)\right]$ -\end{enumerate} +1. `Kernel1D`: called using 1D positions $x$, source-detector distances $d$, hyperparameters $b$, and return a 1D kernel at each source-detector distance. +2. `Kernel2D`: called using a 2D meshgrid $(x,y)$, source-detector distances $d$, hyperparameters $b$, and return a 2D kernel at each source-detector distance. +3. `Operator`: called using a 2D meshgrid $(x,y)$, source-detector distances $d$, as well as an input $f$, and return the operation $\mathrm{PSF}(d) \left[f'(x,y,d)\right]$ -`Kernel1D` objects can be constructed using a variety of functions. For example, the `__init__` method of `FunctionKernel1D` requires a 1D function definition $k(x)$, an amplitude function $A(d,b_A)$ and its hyperparameters $b_A$, and a scaling function $\sigma(d,b_{\sigma})$ and its hyperparameters $b_{\sigma}$. The `__call__` method returns $A(d,b_A)k(x/\sigma(d,b_{\sigma})) \Delta x$ where $\Delta x$ is the spacing of the kernel. `Kernel1D` objects require a `normalization_constant(x,d)` method to be implemented that returns sum of the kernel from $x=-\infty$ to $x=\infty$ at each detector distance $d$ given $x$ input with constant spacing $\Delta x$. This is not as simple as summing over the kernel output since the range of $x$ provided might be less than the size of the kernel. `Kernel2D` objects are analogous to `Kernel1D` objects, except they take in a 2D input $(x,y)$ and return a corresponding 2D kernel at each detector distance $d$. +Various subclasses of `Kernel1D` have their own instantiation methods. For example, the `__init__` method of `FunctionKernel1D` requires a 1D function definition $k(x)$, an amplitude function $A(d,b_A)$ and its hyperparameters $b_A$, and a scaling function $\sigma(d,b_{\sigma})$ and its hyperparameters $b_{\sigma}$. The `__call__` method returns $A(d,b_A)k(x/\sigma(d,b_{\sigma})) \Delta x$ where $\Delta x$ is the spacing of the kernel. The `ArbitraryKernel1D` is similar except that it requires a 1D array $k$ in place of $k(x)$, and $k(x/\sigma(d,b_{\sigma}))$ is obtained via interpolation between array values. Subclasses of `Kernel1D` require a `normalization_constant(x,d)` method to be implemented that returns sum of the kernel from $x=-\infty$ to $x=\infty$ at each detector distance $d$ given $x$ input with constant spacing $\Delta x$. This is not as simple as summing over the kernel output since the range of $x$ provided might be less than the size of the kernel. The `Kernel2D` class and corresponding subclasses are analogous to `Kernel1D`, except they require a 2D input $(x,y)$ and return a corresponding 2D kernel at each detector distance $d$. -`Operator` objects are the main component of the library; specific subclasses of operators can be built using `Kernel1D` and `Kernel2D` objects. Currently, the library has support for linear shift invariant (LSI) operators, since these are nearly always used for SPECT PSF modeling. LSI operators can always be implemented via convolution with a 2D kernel, but often this is computationally expensive. In tutorial 5, the form of the SPECT PSF is exploited and a 2D LSI operator is built using 1D convolutions and rotations. In tutorial 7, this is shown to lead to faster reconstruction than application of a 2D convolution but with nearly the same results. Operators must also implement a `normalization_constant(xv,yv,d)` method. The `__add__` and `__mult__` methods of operators have been implemented so that multiple PSF operators can be chained together; adding operators together yields an operator that returns the sum of the two PSFs applied to the input data, while multiplying operators yields an operator that returns successive operation of the PSFs applied to the input data. Propagation of normalization is implemented to ensure the normalization of the chained operator is properly implemented. In a gamma camera, for example, there are two components of the PSF: (i) blurring induced from the collimator and (ii) blurring induced from the intrisic resolution of the scintillator crystals. Provided each operator is instantiated as `psf_coll` and `psf_scint` respectively, the chained PSF operator is `psf_tot=psf_scint*psf_coll`; the `__call__` method of this operator implements +Sublasses of the `Operator` class form the main components of the library, and are built using various `Kernel1D` and `Kernel2D` classes. Currently, the library supports linear shift invariant (LSI) operators, since these are sufficient for SPECT PSF modeling. LSI operators can always be implemented via convolution with a 2D kernel, but often this is computationally expensive. In tutorial 5 on the documentation website, the form of the SPECT PSF is exploited and a 2D LSI operator is built using 1D convolutions and rotations. In tutorial 7, this is shown to lead to faster reconstruction than application of a 2D convolution but with nearly identical results. Operators must also implement a `normalization_constant(xv,yv,d)` method. The `__add__` and `__mult__` methods of operators have been implemented so that multiple PSF operators can be chained together; adding operators together yields an operator that returns a linear operator sum, while multiplication yields the equivalent to the linear operator matrix product. Propagation of normalization is implemented to ensure the chained operator is also properly normalized. For example, if the response functions are implemented in operators with variable names `irf_op`, `grf_op`, `ssrf_op`, and `sprf_op`, then the total response would be defined as `psf_op=irf_op*(grf_op+ssrf_op+sprf_op)` and the `__call__` method would implement \begin{equation} - \mathrm{PSF}_{\mathrm{total}} \left[f \right] = \mathrm{PSF}_{\mathrm{scint}}\left[\mathrm{PSF}_{\mathrm{coll}} \left[f \right] \right] + \mathrm{PSF} \left[f \right] = \mathrm{IRF}\left(\mathrm{GRF}+\mathrm{SSRF}+\mathrm{SPRF}\right)\left[f \right] \label{eq:psf_tot} \end{equation} -The library is demonstrated using two use cases via reconstruction with the ordered subset expectation maximum (OSEM) algorithm [@osem]. The first use case considers reconstruction of MC ${}^{177}$Lu data. ${}^{177}$Lu is typically acquired using a medium energy collimator and the PSF is dominated by the GC. When acquired using a low energy collimator, there is significant SPC and SSC, and a more sophisticated PSF model is required during reconstruction. This use case considers a cylindrical phantom with standard NEMA sphere sizes filled at a 10:1 source to background concentration with a total activity of 1000 MBq. SPECT acquisition was simulated in SIMIND [@simind] using (i) low energy collimators and (ii) medium energy collimators with 96 projection angles at 0.48 cm $\times$ 0.48 cm resolution and a 128 $\times$ 128 matrix size. Firstly, each case was reconstructed with GC PSF modeling (Gaussian PSF) with OSEM(4it,8ss) (medium energy) and OSEM(40it8ss) (low energy). A MC based PSF model that encompasses GC, SPC, and SSC was then obtained by (i) simulating a point source at 1100 distances between 0 cm and 55cm, and normalizing the kernel data and (ii) using a `NearestKernelOperator` which convolves the PSF kernel closest to the source-detector distance of each plane. The low energy collimator data was then reconstructed using the MC PSF model using OSEM (40it8ss). \autoref{fig:fig1} shows the sample PSF at six sample distances (left), the reconstructed images (center) and sample 1D profiles of the reconstructed images (right). When the MC PSF kernel that includes GC+SSC+SPC is used, the activity in the spheres is significantly higher than when the GC only (Gaussian) kernel is used. +The library is presently demonstrated on two SPECT image reconstruction examples where the ordered subset expectation maximum (OSEM) [@osem] reconstruction algorithm is used. The first use case considers reconstruction of MC ${}^{177}$Lu data. ${}^{177}$Lu is typically acquired using a medium energy collimator and the PSF is dominated by the GRF. When acquired using a low energy collimator, there is significant SPRF and SSRF, and a more sophisticated PSF model is required during reconstruction. This use case considers a cylindrical phantom with standard NEMA sphere sizes filled at a 10:1 source to background concentration with a total activity of 1000 MBq. SPECT acquisition was simulated in SIMIND [@simind] using (i) low energy collimators and (ii) medium energy collimators with 96 projection angles at 0.48 cm $\times$ 0.48 cm resolution and a 128 $\times$ 128 matrix size. Firstly, each case was reconstructed with only the GRF (Gaussian PSF) with OSEM(4it,8ss) (medium energy) and OSEM(40it8ss) (low energy). A MC based PSF model that encompasses GRF, SPRF, and SSRF was then obtained by (i) simulating a point source at 1100 distances between 0 cm and 55cm, and normalizing the kernel data and (ii) using a `NearestKernelOperator` which convolves the PSF kernel closest to the source-detector distance of each plane. The low energy collimator data was then reconstructed using the MC PSF model using OSEM (40it8ss). \autoref{fig:fig1} shows the sample PSF at six sample distances (left), the reconstructed images (center) and sample 1D profiles of the reconstructed images (right). When the MC PSF kernel that includes GRF+SSRF+SPRF is used, the activity in the spheres is significantly higher than when the GRF only (Gaussian) kernel is used. -The second use case considers reconstruction of MC ${}^{225}$Ac data. ${}^{225}$Ac emits 440keV photons that have significant SPC and SSC even when a high energy collimator is used. This use case considers a cylindrical phantom with 3 spheres of diameters 60mm, 37mm, and 28mm filled at a 6.4:1 source to background ratio with 100MBq of total activity. 440keV point source data was simulated via SIMIND at 1100 positions between 0cm and 55cm. 12 of these positions were used for developing and fitting a PSF operator built using the `GaussianOperator`, `Rotate1DConvOperator`, and `RotateSeperable2DConvOperator`; each of these classes performs 2D shift invariant convolutions using only 1D convolutions and rotations -(1D-R). More details on this model and how it is fit are shown in tutorial 5 on the GitHub page. The developed model is compared to a MC based model (2D) that uses the `NearestKernelOperator` with the 1100 acquired PSFs acquired from SIMIND. Use of the 1D-R model in image reconstruction reduces the required computation time by a factor of 2.5, since rotations and 1D convolutions are significantly faster than direct 2D convolution, even when fast fourier transform techniques are used. +The second use case considers reconstruction of MC ${}^{225}$Ac data. ${}^{225}$Ac emits 440 keV photons that have significant SPRF and SSRF even when a high energy collimator is used. This use case considers a cylindrical phantom with 3 spheres of diameters 60mm, 37mm, and 28mm filled at a 6.4:1 source to background ratio with 100MBq of total activity. 440keV point source data was simulated via SIMIND at 1100 positions between 0cm and 55cm. 12 of these positions were used for developing and fitting a PSF operator built using the `GaussianOperator`, `Rotate1DConvOperator`, and `RotateSeperable2DConvOperator`; each of these classes performs 2D shift invariant convolutions using only 1D convolutions and rotations +(1D-R). More details on this model and how it is fit are shown in tutorial 5 on the documentation website. The developed model is compared to a MC based model (2D) that uses the `NearestKernelOperator` with the 1100 acquired PSFs acquired from SIMIND. Use of the 1D-R model in image reconstruction reduces the required computation time by more than a factor of two; this occurs since rotations and 1D convolutions are significantly faster than direct 2D convolution, even when fast fourier transform techniques are used. ![Upper: ${}^{177}$Lu reconstruction example. From left to right: MC PSF data at various source detector distances, axial slices from reconstructions, and central vertical 1D profile from shown axial slices. Lower: ${}^{225}$Ac reconstruction example. From left to right: MC PSF data and predicted 1D-R fit, axial slices from reconstructions, and central vertical 1D profile from shown axial slices.\label{fig:fig1}](fig1.png)