computer programs
Integration of TomoPy and the ASTRA toolbox for advanced processing and reconstruction of tomographic synchrotron data
^{a}Centrum Wiskunde and Informatica, Science Park 123, 1098 XG Amsterdam, The Netherlands, ^{b}Advanced Photon Source, Argonne National Laboratory, 9700 South Cass Avenue, Argonne, IL 604394837, USA, ^{c}iMinds–Vision Lab, University of Antwerp, Universiteitsplein 1, B2610 Antwerp, Belgium, and ^{d}Mathematical Institute, Leiden University, Niels Bohrweg 1, 2333 CA Leiden, The Netherlands
^{*}Correspondence email: d.m.pelt@cwi.nl
The processing of tomographic synchrotron data requires advanced and efficient software to be able to produce accurate results in reasonable time. In this paper, the integration of two software toolboxes, TomoPy and the ASTRA toolbox, which, together, provide a powerful framework for processing tomographic data, is presented. The integration combines the advantages of both toolboxes, such as the userfriendliness and CPUefficient methods of TomoPy and the flexibility and optimized GPUbased reconstruction methods of the ASTRA toolbox. It is shown that both toolboxes can be easily installed and used together, requiring only minor changes to existing TomoPy scripts. Furthermore, it is shown that the efficient GPUbased reconstruction methods of the ASTRA toolbox can significantly decrease the time needed to reconstruct large datasets, and that advanced reconstruction methods can improve reconstruction quality compared with TomoPy's standard reconstruction method.
Keywords: tomography; TomoPy; ASTRA toolbox.
1. Introduction
In transmission Xray tomography experiments performed at synchrotron facilities, large amounts of projection data are produced in a short time. Current detector technology allows one to collect projections at kHz frame rate, enabling threedimensional imaging of dynamic systems (Gibbs et al., 2015), in situ studies of materials (Patterson et al., 2016) and monitoring the evolution of biological systems (Moosmann et al., 2013).
Processing these datasets in a time comparable with data collection is essential to properly capture the sample evolution and adjust the instrument settings during the experiment; this requires algorithms optimized for highperformance computing (HPC), which have to be easily available and usable by the beamline users. Furthermore, many advanced experiments, such as those with extremely high spatial or temporal resolutions (Sakdinawat & Attwood, 2010; Mokso et al., 2013) and of dosesensitive objects (Lovric et al., 2013), require a variety of preprocessing, postprocessing and reconstruction algorithms to reduce artifacts in the final reconstruction.
In this paper, we present the integration of two Python toolboxes which, together, allow users to easily apply advanced tomographic algorithms on largescale experimental datasets in an efficient way: the TomoPy toolbox (Gürsoy et al., 2014) and the ASTRA toolbox (van Aarle et al., 2015). By combining both toolboxes, we are able to leverage the advantages of both to create an improved workflow for beamline users.
The TomoPy toolbox is specifically designed to be easy to use and deploy at a synchrotron facility beamline. It supports reading many common synchrotron data formats from disk (De Carlo et al., 2014), and includes several preprocessing and postprocessing algorithms commonly used for synchrotron data. TomoPy also includes several reconstruction algorithms, which can be run on multicore workstations and largescale computing facilities. The algorithms in TomoPy are all CPUbased, however, which can make them prohibitively slow in the case of iterative methods, which are often required for advanced tomographic experiments.
The ASTRA toolbox provides highly efficient tomographic reconstruction methods by implementing them on graphic processing units (GPUs). It includes advanced iterative methods and allows for very flexible scanning geometries. The ASTRA toolbox also includes building blocks which can be used to develop new reconstruction methods, allowing for easy and efficient implementation and modification of advanced reconstruction methods. However, the toolbox is only focused on reconstruction, and does not include preprocessing or postprocessing methods that are typically required for correctly processing synchrotron data. Furthermore, no routines to read data from disk are provided by the toolbox.
By integrating the ASTRA toolbox in the TomoPy framework, the optimized GPUbased reconstruction methods become easily available for synchrotron beamline users, and users of the ASTRA toolbox can more easily read data and use TomoPy's preprocessing and postprocessing methods.
This paper is structured as follows: in §2, we give a more detailed explanation of TomoPy and the ASTRA toolbox, and explain how we integrated them. In §3, we give general instructions on how to install and use the combined toolboxes in practice. An example for a specific dataset in given in §4, and we conclude the paper in §5.
2. Integrating TomoPy and the ASTRA toolbox
2.1. TomoPy
TomoPy is an opensource Python toolbox to perform tomographic data processing and image reconstruction tasks, developed at the Advanced Photon Source of Argonne National Laboratory (Gürsoy et al., 2014). The toolbox is available for Linux and OS X operating systems, and is aimed at providing a highlevel interface for processing and tomographic reconstruction of datasets at synchrotron light sources. TomoPy relies on standard scientific packages like NumPy, SciPy and Scikit, and offers a free, opensource, modular, readable and manageable framework that researchers can use and contribute to easily. Python also offers easy integration with C or Fortran code through shared libraries in situations where computation speed is critical. In addition, the native control software running at several synchrotron facilities, EPICS (https://www.aps.anl.gov/epics), is accessible via Python (https://pyepics.github.io/pyepics/), allowing simultaneous data analysis and realtime feedback on the instrumentation status. So far, TomoPy has been employed in reconstructions for various techniques from microCT (Duke et al., 2015) to tomography (Gürsoy et al., 2015a), Xray scattering tomography (Gürsoy et al., 2015b), Lorentz (Phatak & Gürsoy, 2015) and deployed on largescale computing facilities (Biçer et al., 2015).
TomoPy includes a plethora of processing functions from preprocessing to image reconstruction of synchrotron tomographic data. It includes ring removal algorithms, such as the generalized Titarenko's algorithm (Miqueles et al., 2014) and a Fourier wavelet approach (Münch et al., 2009), and a zinger correction algorithm based on median filters. The estimation of the rotation center can be calculated using the image calculation based method (Donath et al., 2006) or Vo's Fourier method (Vo et al., 2014). A singlestep Xray phaseretrieval algorithm based on Paganin filtering is available for phasecontrast datasets (Paganin et al., 2002). TomoPy also includes algorithms for postprocessing reconstructed images, such as Gaussian filtering and median filtering to reduce noise artifacts.
In addition to Gridrec (Dowd et al., 1999), which is the traditionally used analytical image reconstruction algorithm, TomoPy also offers variants of algebraic reconstruction methods (ART, BART, SIRT) (Kak & Slaney, 2001), and expectation maximization (MLEM) approaches (Dempster et al., 1977), as well as their regularized variations (PML) (Chang et al., 2004). Orderedsubset implementation of all algorithms are also available for efficient calculations; for example, the well known orderedsubset expectation maximization (OSEM) algorithm (Hudson & Larkin, 1994). An overview of all algorithms included in TomoPy, along with their parameters and usage examples, can be found on the documentation website of TomoPy (https://tomopy.readthedocs.org).
Another important property of TomoPy is that it provides Xray matter interaction simulation tools, such as Xray transmission or wave propagation, that can be used to evaluate the efficiency of various coding scenarios or as a platform for modeling. The standard installation package of TomoPy is optimized for use at a workstation, but TomoPy algorithms are also suitable for gridcomputing and massive parallelization when needed. Experiments with MPI implementations of iterative algorithms and tomography datasets with 1K projections of 2K by 2K pixels show that TomoPy's iterative methods can scale up to thousands of cores on an IBM BG/Q supercomputer with almost perfect speedup and can reduce total reconstruction times for such datasets by more than 95.4% on 32K cores relative to 1K cores. Moreover, the average reconstruction times are improved from 2 hours (256 cores) to 1 minute (32K cores), thus enabling nearrealtime use (Biçer et al., 2015).
2.2. The ASTRA toolbox
The ASTRA toolbox is an opensource software toolbox developed at the University of Antwerp, Belgium, and at the Centrum Wiskunde & Informatica (CWI), Amsterdam, The Netherlands, that is focused on the reconstruction of twodimensional (slicebased) and threedimensional tomographic datasets (van Aarle et al., 2015). The toolbox is available for Linux and Windows operating systems, and is aimed at providing a fast and flexible development platform for tomographic reconstruction algorithms. Because of its flexibility, it can be applied to various scanning geometries and acquisition modes, such as (bio)medical and industrial µCT (Plantagie et al., 2015), electron tomography (Roelandts et al., 2012), neutron tomography (Peetermans & Lehmann, 2013; Van Eyndhoven et al., 2015) and synchrotron tomography (Reischig et al., 2013). The toolbox uses CUDA for NVIDIA GPUs to perform accelerated parallel computations, reducing the computation time of many tomographic operations (Palenstijn et al., 2011). Most twodimensional slicebased operations can also be run on standard CPUs, in which case the toolbox supports different projection kernels, i.e. ways of discretizing the projection operations. A comparison of various projection kernels can be found in the paper by Xu & Mueller (2006). When using GPUs, only a single set of projection kernels is supported for optimal performance. Through either a MATLAB or Python interface, the tomographic operations can be easily used and combined with other numerical code or software for preprocessing, postprocessing or analysis of the acquired data. The toolbox also provides a matrixlike interface to linear tomography operators, allowing them to be easily used in existing and new code (Bleichrodt et al., 2015). A version of the ASTRA toolbox with MPI support for highperformance computing is available as a separate package (Palenstijn et al., 2015).
The ASTRA toolbox includes many popular tomographic reconstruction methods (see Table 1), such as the analytic filtered backprojection (FBP) method and the iterative SIRT method (Kak & Slaney, 2001) and CGLS method (Hansen, 1998). These methods support various parameters that can help improve reconstruction quality; for example, the choice of filter to use in the FBP method, and additional nonnegativity constraints in the SIRT method. An important feature of the ASTRA toolbox is that it also provides building blocks that can be used to develop advanced tomographic reconstruction methods. For example, using the optimized methods for the forward projection of objects and the backprojection of sinograms, it is possible to develop efficient advanced iterative methods, such as total variation regularized methods, using the ASTRA toolbox. A recent addition to the toolbox is a plugin system, which enables algorithm developers to easily distribute new tomographic reconstruction methods, and ASTRA users to easily install and use them with minimal changes in production scripts. With the TomoPy integration presented in this paper, these ASTRA plugins will automatically be usable in TomoPy as well.

2.3. Implementation
The code to integrate TomoPy and the ASTRA toolbox is written in the Python language, since TomoPy is mainly written in Python and the ASTRA toolbox includes a Python interface as well. Specifically, a first step was to add code to TomoPy that enables the use of other Python libraries to perform tomographic reconstruction instead of TomoPy's included algorithms. Using this new feature, code was added which enables the use of the ASTRA toolbox to perform the reconstruction. By integrating the ASTRA toolbox into TomoPy in this way, synchrotron users that are familiar with TomoPy will be able to use the ASTRA toolbox with minimal effort. Note that other tomographic reconstruction libraries that include a Python interface can be integrated in TomoPy in the same way. Since the integration requires both toolboxes to be installed on the same machine, it is only supported on operating systems in which both TomoPy and the ASTRA toolbox can be installed. Currently, this is only the case for modern Linux operating systems, but other operating systems will be supported once both TomoPy and the ASTRA toolbox support them.
In the interfacing code, the parallelbeam geometry defined by TomoPy (i.e. the number of detector pixels, the angles for which projections are acquired, and the center of rotation) is translated to a corresponding ASTRA geometry, and the chosen ASTRA reconstruction method is performed. Afterwards, the result of the reconstruction is stored in TomoPy memory, and all ASTRA objects are cleaned up. In this way, the reconstruction step is completely selfcontained and independent of any preprocessing or postprocessing step. An advantage of this independence is that user scripts do not have to be rewritten to use the ASTRA toolbox: only the reconstruction function call has to be modified. Also, changing between different reconstruction methods, between CPU and GPU implementations, and between different reconstruction parameters usually only requires changes in a single line of the user script. Examples of these minimal changes are shown in §3.2. A schematic overview of the full processing workflow from loading the raw data to analysis is shown in Fig. 1.
3. Installation and usage
3.1. Installation
Both TomoPy and the ASTRA toolbox can be installed using the Conda package management system (https://conda.pydata.org). The advantage of using Conda over other Python package management systems is that Conda allows for the inclusion of nonPython library dependencies, which are commonly needed for numerical toolboxes such as TomoPy and the ASTRA toolbox. Since the goal of both toolboxes is to be easily installable at the various workstations and computational clusters available at synchrotrons, which may each be running a different environment of installed libraries and library versions, the ability to tightly control the library dependencies is important to create a userfriendly installation process. To install TomoPy in a Conda environment, the following command can be used:
A similar command can be used to install the ASTRA toolbox:
Note that both toolboxes can be installed and used independently from each other. TomoPy will automatically detect whether the ASTRA toolbox is available, and enables the use of ASTRA methods if this is the case. Both toolboxes can also be compiled and installed from source code, which can be downloaded from their respective git repositories (https://github.com/tomopy/tomopy and https://github.com/astratoolbox/astratoolbox). Compared with installing using Conda, it is easier to make modifications and contribute to the development of the toolboxes when installing from source code, but the compilation step requires the availability of several library dependencies on the workstation.
3.2. Usage
We will now show how the new features can be used after installation of both toolboxes. The following example script shows a simple standard TomoPy workflow, loading data from disk, normalizing the data using the flatfield and darkfield images, and finally reconstructing with the standard TomoPy gridrec method (all scripts shown in this paper are available in the supporting information):
To modify this script to reconstruct using the ASTRA toolbox instead, only line 13 has to be changed, replacing gridrec with tomopy.astra, specifying which method to reconstruct with in the method option, and specifying which type of projection kernel to use in the proj_type option. An overview of common options that are used when reconstructing with the ASTRA toolbox is given in Table 2. For example, to reconstruct with FBP using a voxeldriven kernel, we change the final part of the above script to:

When running on a machine with a GPU with CUDA capabilities, the same reconstruction can be performed using optimized GPU code, greatly decreasing the needed computation time. This can be realised by specifying cuda as the projection kernel, and use a GPUenabled method (FBP_CUDA):
Iterative methods can be used by specifying the corresponding ASTRA method (e.g. CGLS_CUDA for a GPUenabled CGLS method), and the number of iterations to use in the num_iter option:
Most reconstruction methods in the ASTRA toolbox support several parameters that can help improve reconstruction quality. In the TomoPy integration, these parameters are specified by supplying them in the extra_options setting. For example, to add a nonnegativity constraint to the GPUenabled SIRT method, we add MinConstraint to the extra_options setting (note that lower bounds other than zero can also be used):
An overview of the various parameters that are supported by the reconstruction methods can be found on the website of the ASTRA toolbox (https://www.astratoolbox.com).
If multiple GPUs are installed in the workstation running TomoPy and the ASTRA toolbox, the computations can be distributed over multiple GPUs by specifying a list of GPU indices in the gpu_list option. Since each slice of the reconstruction can be computed independently from the other slices, a significant reduction of computation time can be achieved by distributing the computations in this way. For example, to use four installed GPUs, labeled 0 through 3, we use [0, 1, 2, 3] as the gpu_list:
Finally, ASTRA plugins can be used by first registering them with the ASTRA toolbox itself, and using the method name defined by the plugin as the method option. Extra parameters for the reconstruction can be specified using the extra_options setting, similar to standard ASTRA methods. An ASTRA plugin is typically distributed as a Python class within a Python package, which has to be imported separately. After importing, the astra.plugin.register method is used to register a plugin with the ASTRA toolbox. For example, suppose that there is a plugin class tvtomo.plugin within the tvtomo package, with the method name TVFISTA and an additional parameter tv_reg. To use this plugin in TomoPy, the following code can be used:
3.3. Computation time
In Fig. 2, a comparison is shown between the computation times per slice of reconstructions computed with different methods of both TomoPy and the ASTRA toolbox, for a single slice of a dataset with 1200 detector pixels and 1024 projections. All reconstructions were computed on a workstation with 128 GB of memory, two Intel Xeon E52623 v3 CPUs (four cores each, running at 3.0 GHz) and two Geforce GTX Titan Z cards (running at their default clock speeds). Each Titan Z card contains two GPUs, with 15 multiprocessors (2880 cores) and 6 GB of memory per GPU. The workstation was using the Fedora 21 operating system, with the official CUDA 7.0 drivers provided by NVIDIA. We compare the computation times of gridrec computed using TomoPy, FBP computed using the ASTRA toolbox, and 100 iterations of SIRT computed using both TomoPy and the ASTRA toolbox. For the CPUbased methods of TomoPy and the ASTRA toolbox, computation times are shown for using both a single core and all eight cores of the machine. For the GPUbased methods of the ASTRA toolbox, computation times are shown for using both a single GPU and all four installed GPUs.
The results of Fig. 2 show that for the SIRT method a significant reduction of computation time can be achieved by using GPUs instead of CPUs for computation, with the computation time per slice when using TomoPy and eight CPU cores being roughly 600 times the computation time when using the ASTRA toolbox and four GPUs. Note that this reduction of computation time can be important in practice, since, in this case, computing the SIRT reconstruction of 200 slices would take less than 4 minutes with four GPUs, compared with more than 32 hours with eight CPU cores. Therefore, by using GPUbased methods, it is possible to compute iterative reconstructions during experiments, enabling direct inspection of the reconstructions and the possibility of making adjustments to improve the experimental results during the experiment itself.
In contrast to the iterative SIRT method, TomoPy's CPUbased gridrec method takes less time to compute compared with the GPUbased FBP method, especially when using multiple CPU cores. This is expected for problems with a relatively large number of projections, since the most costly computations of the gridrec method are the twodimensional Fourier transforms, for which the computation time is independent of the number of projections. On the other hand, in the FBP method the most costly computation is the backprojection operation, for which the computation time scales linearly with the number of projections. Note that the reconstruction quality of gridrec and FBP reconstructions are usually similar (Marone & Stampanoni, 2012).
4. Example
In this section, we give an example of the full processing workflow of reconstructing a tomographic synchrotron dataset, acquired at the 32ID beamline of the Advanced Photon Source of Argonne National Laboratory. We compare the resulting reconstructions of a single slice using various reconstruction methods, both with and without ringremoval preprocessing applied. The dataset is of a sample under pressure in a diamond anvil cell, whose frame blocks part of the acquired projections, rendering them unusable. The result is a limitedangle tomographic problem, where the acquired projections do not span the entire 180° range. Specifically, projections of 2160×2560 pixels were acquired in 0.5° intervals over a 137° range, for a total of 273 projections. It is typically difficult to obtain accurate reconstructions for limitedangle problems, with standard methods producing wedge artifacts in the direction of the missing projection angles (Delaney & Bresler, 1998).
In Fig. 3, reconstructions are shown of a single slice of the sample, reconstructed with various reconstruction methods. In each reconstruction except for the one shown in Fig. 3(b), a ringremoval preprocessing method that is included in TomoPy (Münch et al., 2009) was used to suppress ring artifacts. In Fig. 3(a), the reconstruction computed with TomoPy's gridrec method is shown. In Figs. 3(b) and 3(c), ASTRA's GPUenabled SIRT method was used to compute the reconstructions. Finally, a reconstruction regularized with total variation minimization is shown in Fig. 3(d), computed using an ASTRA plugin that implements the FISTA method (Beck & Teboulle, 2009). The Python script used to compute the reconstruction of Fig. 3(c) is given below. Note that the scripts used to compute the other reconstructions are similar, only requiring minimal changes like the ones given in §3.2:
The results of Fig. 3 show that the gridrec reconstruction includes large amounts of noise artifacts, especially visible in the line profile, as well as wedge artifacts resulting from the missing projection angles. These artifacts can make further analysis, such as volume estimation, difficult or impossible, even with further postprocessing. The iterative reconstructions, which can be computed efficiently using the GPUenabled methods of the ASTRA toolbox, include fewer artifacts, significantly reducing noise in the reconstructed image. Note, however, that significant ring artifacts are present in Fig. 3(b), where we did not use one of TomoPy's ringremoval preprocessing methods. In the reconstruction of Fig. 3(c), the ring artifacts are significantly reduced, which shows that TomoPy's advanced preprocessing methods can be used to improve the reconstruction quality of ASTRA's reconstruction methods. Finally, the total variation minimization reconstruction of Fig. 3(d) shows that advanced regularized reconstruction methods can be distributed as ASTRA plugins and be used in combination with TomoPy to minimize artifacts in the final reconstruction.
5. Conclusions
In this paper, we presented the integration of two Python toolboxes used for processing tomographic data: TomoPy and the ASTRA toolbox. The integration allows for combining the advanced I/O, preprocessing and postprocessing capabilities of TomoPy with the advanced tomographic reconstruction methods of the ASTRA toolbox. One advantage of the integration is that it enables the use of GPUenabled methods included in the ASTRA toolbox to significantly improve computation time, especially for iterative reconstruction methods. Another advantage is that advanced iterative methods can be written and distributed as ASTRA plugins and subsequently used within TomoPy. Code has been added to TomoPy that automatically creates the necessary ASTRA objects, cleaning them up after computation has finished. As a result, only minimal changes are needed in user scripts to use the ASTRA toolbox within TomoPy.
We have shown how to install both toolboxes on a single machine, and how to use the various features of the integrated software. In particular, we have shown how to adjust an existing TomoPy script to reconstruct with the ASTRA toolbox, how to change between different ASTRA reconstruction methods and between CPU and GPU implementations, and how to specify options for each method. Furthermore, an example was given where an ASTRA plugin was used to reconstruct the acquired data. For a specific dataset, we compared the computation time of various methods included in TomoPy and the ASTRA toolbox, which showed that the GPUenabled iterative SIRT method of the ASTRA toolbox significantly reduced computation time compared with the CPUbased SIRT method of TomoPy. Finally, we computed reconstructions using different reconstruction methods for a single slice of experimental data, showing how ASTRA's advanced reconstruction methods in combination with TomoPy's advanced preprocessing methods can help reduce artifacts in reconstructions of tomographic synchrotron data, in particular in challenging scenarios where only a limited set of projections are available.
Supporting information
Code for all scripts given in main paper. DOI: https://doi.org/10.1107/S1600577516005658/pp5084sup1.txt
Acknowledgements
We thank Luhong Wang and Haohe Liu, Harbin Institute of Technology, for sharing the data reported in Fig. 3. This research used resources of the US Department of Energy (DOE) Office of Science User Facilities operated for the DOE Office of Science by Argonne National Laboratory under Contract No. DEAC0206CH11357, and was also funded by the Netherlands Organization for Scientific Research (NWO), project number 639.072.005. We acknowledge COST Action MP1207 for networking support.
References
Aarle, W. van, Palenstijn, W. J., De Beenhouwer, J., Altantzis, T., Bals, S., Batenburg, K. J. & Sijbers, J. (2015). Ultramicroscopy, 157, 35–47. Web of Science PubMed Google Scholar
Beck, A. & Teboulle, M. (2009). IEEE Trans. Image Processing, 18, 2419–2434. CrossRef Google Scholar
Biçer, T., Gürsoy, D., Kettimuthu, R., De Carlo, F., Agrawal, G. & Foster, I. T. (2015). EuroPar 2015: Parallel Processing, edited by J. L. Trff, S. Hunold and F. Versaci, Vol. 9233 of Lecture Notes in Computer Science, pp. 289–302. Berlin/Heidelberg: Springer. Google Scholar
Bleichrodt, F., van Leeuwen, T., Palenstijn, W. J., van Aarle, W., Sijbers, J. & Batenburg, K. J. (2015). Numer. Algor. 71, 673–697. CrossRef Google Scholar
Chang, J.H., Anderson, J. M. M. & Votaw, J. R. (2004). IEEE Trans. Med. Imaging, 23, 1165–1175. CrossRef PubMed Google Scholar
De Carlo, F., Gürsoy, D., Marone, F., Rivers, M., Parkinson, D. Y., Khan, F., Schwarz, N., Vine, D. J., Vogt, S., Gleber, S.C., Narayanan, S., Newville, M., Lanzirotti, T., Sun, Y., Hong, Y. P. & Jacobsen, C. (2014). J. Synchrotron Rad. 21, 1224–1230. Web of Science CrossRef CAS IUCr Journals Google Scholar
Delaney, A. H. & Bresler, Y. (1998). IEEE Trans. Image Processing, 7, 204–221. CrossRef CAS Google Scholar
Dempster, A. P., Laird, N. M. & Rubin, D. B. (1977). J. R. Stat. Soc. Ser. B (Methodological), 39, 1–38. Google Scholar
Donath, T., Beckmann, F. & Schreyer, A. (2006). J. Opt. Soc. Am. A, 23, 1048–1057. Web of Science CrossRef Google Scholar
Dowd, B. A., Campbell, G. H., Marr, R. B., Nagarkar, V. V., Tipnis, S. V., Axe, L. & Siddons, D. P. (1999). Proc. SPIE, 3772, 224–236. CrossRef Google Scholar
Duke, D. J., Swantek, A. B., Sovis, N. M., Tilocco, F. Z., Powell, C. F., Kastengren, A. L., Gürsoy, D. & Biçer, T. (2015). SAE Int. J. Eng. 9, 2015–01–1873. CrossRef Google Scholar
Gibbs, J. W., Mohan, K. A., Gulsoy, E. B., Shahani, A. J., Xiao, X., Bouman, C. A., De Graef, M. & Voorhees, P. W. (2015). Sci. Rep. 5, 11824. CrossRef PubMed Google Scholar
Gürsoy, D., Biçer, T., Almer, J. D., Kettimuthu, R., Stock, S. R. & De Carlo, F. (2015b). Philos. Trans. R. Soc. London A, 373, 20140392. Google Scholar
Gürsoy, D., Biçer, T., Lanzirotti, A., Newville, M. G. & De Carlo, F. (2015a). Opt. Express, 23, 9014–9023. PubMed Google Scholar
Gürsoy, D., De Carlo, F., Xiao, X. & Jacobsen, C. (2014). J. Synchrotron Rad. 21, 1188–1193. Web of Science CrossRef IUCr Journals Google Scholar
Hansen, P. (1998). RankDeficient and Discrete IllPosed Problems. Society for Industrial and Applied Mathematics. Google Scholar
Hudson, H. M. & Larkin, R. S. (1994). IEEE Trans. Med. Imaging, 13, 601–609. CrossRef PubMed CAS Web of Science Google Scholar
Kak, A. C. & Slaney, M. (2001). Principles of Computerized Tomographic Imaging. Society for Industrial and Applied Mathematics. Google Scholar
Lovric, G., Barré, S. F., Schittny, J. C., RothKleiner, M., Stampanoni, M. & Mokso, R. (2013). J. Appl. Cryst. 46, 856–860. Web of Science CrossRef CAS IUCr Journals Google Scholar
Marone, F. & Stampanoni, M. (2012). J. Synchrotron Rad. 19, 1029–1037. Web of Science CrossRef CAS IUCr Journals Google Scholar
Miqueles, E. X., Rinkel, J., O'Dowd, F. & Bermúdez, J. S. V. (2014). J. Synchrotron Rad. 21, 1333–1346. Web of Science CrossRef CAS IUCr Journals Google Scholar
Mokso, R., Marone, F., Irvine, S., Nyvlt, M., Schwyn, D., Mader, K., Taylor, G. K., Krapp, H. G., Skeren, M. & Stampanoni, M. (2013). J. Phys. D, 46, 494004. Web of Science CrossRef Google Scholar
Moosmann, J., Ershov, A., Altapova, V., Baumbach, T., Prasad, M. S., LaBonne, C., Xiao, X., Kashef, J. & Hofmann, R. (2013). Nature (London), 497, 374–377. Web of Science CrossRef CAS PubMed Google Scholar
Münch, B., Trtik, P., Marone, F. & Stampanoni, M. (2009). Opt. Express, 17, 8567–8591. Web of Science PubMed Google Scholar
Paganin, D., Mayo, S. C., Gureyev, T. E., Miller, P. R. & Wilkins, S. W. (2002). J. Microsc. 206, 33–40. Web of Science CrossRef PubMed CAS Google Scholar
Palenstijn, W. J., Batenburg, K. J. & Sijbers, J. (2011). J. Struct. Biol. 176, 250–253. Web of Science CrossRef CAS PubMed Google Scholar
Palenstijn, W. J., Bédorf, J. & Batenburg, K. J. (2015). Proceedings of the 13th International Meeting on Fully ThreeDimensional Image Reconstruction in Radiology and Nuclear Medicine, pp. 166–169. Google Scholar
Patterson, B. M., Cordes, N. L., Henderson, K., Williams, J. J., Stannard, T., Singh, S. S., Ovejero, A. R., Xiao, X., Robinson, M. & Chawla, N. (2016). J. Mater. Sci. 51, 171–187. CrossRef CAS Google Scholar
Peetermans, S. & Lehmann, E. H. (2013). J. Appl. Phys. 114, 124905. Web of Science CrossRef Google Scholar
Phatak, C. & Gürsoy, D. (2015). Ultramicroscopy, 150, 54–64. CrossRef CAS PubMed Google Scholar
Plantagie, L., van Aarle, W., Sijbers, J. & Batenburg, K. J. (2015). 2015 IEEE 12th International Symposium on Biomedical Imaging (ISBI), pp. 1596–1599. IEEE. Google Scholar
Reischig, P., King, A., Nervo, L., Viganó, N., Guilhem, Y., Palenstijn, W. J., Batenburg, K. J., Preuss, M. & Ludwig, W. (2013). J. Appl. Cryst. 46, 297–311. Web of Science CrossRef CAS IUCr Journals Google Scholar
Roelandts, T., Batenburg, K. J., Biermans, E., Kübel, C., Bals, S. & Sijbers, J. (2012). Ultramicroscopy, 114, 96–105. CrossRef CAS PubMed Google Scholar
Sakdinawat, A. & Attwood, D. (2010). Nat. Photon. 4, 840–848. Web of Science CrossRef CAS Google Scholar
Van Eyndhoven, G., Batenburg, K. J., Kazantsev, D., Van Nieuwenhove, V., Lee, P. D., Dobson, K. J. & Sijbers, J. (2015). IEEE Trans. Image Processing, 24, 4446–4458. CrossRef Google Scholar
Vo, N. T., Drakopoulos, M., Atwood, R. C. & Reinhard, C. (2014). Opt. Express, 22, 19078–19086. Web of Science CrossRef PubMed Google Scholar
Xu, F. & Mueller, K. (2006). 3rd IEEE International Symposium on Biomedical Imaging: Nano to Macro 2006, pp. 12521255. IEEE. Google Scholar
This is an openaccess article distributed under the terms of the Creative Commons Attribution (CCBY) Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original authors and source are cited.