Pocket Guide to Solve Inverse Problems with GlobalBioIm

GlobalBioIm is an open-source MATLAB library for solving inverse problems. The library capitalizes on the strong commonalities between forward models to standardize the resolution of a wide range of imaging inverse problems. Endowed with an operator-algebra mechanism, GlobalBioIm allows one to easily solve inverse problems by combining elementary modules in a lego-like fashion. This user-friendly toolbox gives access to cutting-edge reconstruction algorithms, while its high modularity makes it easily extensible to new modalities and novel reconstruction methods. We expect GlobalBioIm to respond to the needs of imaging scientists looking for reliable and easy-to-use computational tools for solving their inverse problems. In this paper, we present in detail the structure and main features of the library. We also illustrate its flexibility with examples from multichannel deconvolution microscopy.


Inverse Problems in Imaging
Imaging is a fundamental tool for biological research, medicine, and astrophysics. Medical imaging systems are essential for modern diagnosis, while the latest generation of microscopes and telescopes provide images with unprecedented resolution. This imaging revolution is driven, in part, by the current shift towards computational imaging that sees optics and computing combine to bypass many limitations of conventional systems.
These computational imaging techniques rely on the deployment of sophisticated algorithms to reconstruct a d-dimensional continuously defined object of interest f ∈ L 2 (R d ) from discrete measurements g ∈ R M recorded by a given imaging system. These quantities are linked according to where H : L 2 (R d ) → R M is an operator that models the imaging system. This operator, which might be linear or not, maps the continuously defined object to Table 1: Broad class of imaging models defined as the composition of elementary operators.
Here, the basic constituents include weighting, windowing, or modulation (W), convolution (C), Fourier transform (F), integration (Σ), rotation (R θ ), and sampling (S). The Radon transform (for CT and cryo-EM) is written as the composition Σ • R θ of a rotation and an integration. Similarly, the Laplace transform (for TIRF) is expressed as the composition Σ • W of a weighting (decaying exponential) and an integration. Note that these elementary operators might differ for each modality (e.g., using different kernels for the convolution operators), but their construction stays identical. Magnetic resonance imaging (MRI) S • F • W discrete noiseless measurements. Finally, n ∈ R M is an error term, which is often considered to be random. To numerically solve the inverse problem and recover f , it is necessary to discretize both f and the operator H. This leads to the discrete imaging model g = H{f } + n, with f ∈ R N and H{ · } : R N → R M .

Imaging modality
The classical approach to address this inverse problem and recover an estimated solutionf consists in solvinĝ f = arg min f ∈R N D(H{f }, g) + λR(f ) .
There, D : R M × R M → R measures the discrepancy between the forward model H{f } and the measurements g (i.e., the data fidelity), while R : R N → R enforces specific regularity constraints on the solution (e.g., spatial smoothness, or nonnegativity). The balance between the data fidelity and regularization terms is controlled by the scalar parameter λ > 0.

Unifying Framework for Solving Inverse Problems
The forward models associated with most of the commonly used imaging modalities share important structural properties. This similarity is not surprising since many imaging systems are governed by the same physical principles (e.g., the wave equation). We express in Table 1 the forward models of a wide range of imaging modalities in terms of a limited number of elementary constituents. By capitalizing on these strong commonalities, the open-source MATLAB ® library GlobalBioIm simplifies, unifies, and standardizes the resolution of inverse problems given by (2). Hence, the GlobalBioIm toolbox gives access to state-of-the-art reconstruction algorithms usable in a wide range of imaging applications. Its design is modular, with three main types of entities: forward models, cost functions, and solvers. This permits the user to modify each component independently, which is crucial for the handling of a variety of imaging models and solvers within a common framework. This modularity also makes GlobalBioIm easily extensible to new modalities and novel reconstruction methods.
GlobalBioIm is distributed as an open-source MATLAB ® software. We expect it to respond to the needs of imaging scientists looking for reliable and easy-touse computational tools for the reconstruction of their images. We also believe that GlobalBioIm will be of interest to developers of algorithms who focus on the mathematical and algorithmic details of the reconstruction methods.
The present paper provides a functional description of the structure and the key components of the GlobalBioIm library. It completes and extends our previous brief communication [38]. For a detailed technical documentation, we refer the reader to an online documentation (http://bigwww.epfl.ch/algorithms/globalbioim/).

Related Work
The development of open-source libraries/toolboxes in imaging sciences has received considerable attention during the past two decades. The majority of existing softwares for solving inverse problems are dedicated to specific modalities, with various degrees of sophistication. Moreover, they cover the whole panel of programming languages.
For fluorescence microscopy, DeconvolutionLab [31] provides a set of deconvolution methods that range from naive inverse filters to more sophisticated iterative approaches. The emergence of superresolution fluorescence microscopy techniques has also promoted the development of toolboxes tailored for their specific inverse problems. For instance, FairSIM [26] and Simtoolbox [18] are dedicated to the reconstruction of structured-illumination microscopy data. For single-molecule localization microscopy, one can find dedicated localization plugins such as SMAP [21] and Thun-derSTORM [27].
Although dedicated to specific physical models, the aforementioned toolboxes generally rely on similar reconstruction methods, ranging from Wiener filtering to advanced regularized iterative algorithms. Conversely, libraries that are generic have recently also been designed to handle multiple imaging modalities. The LazyAlgebra toolbox [35] provides an operator-algebra mechanism in Julia that can be combined with optimization packages for solving inverse problems. More complete libraries such as AIR Tools (MATLAB ® ) [17], IR Tools (MATLAB ® ) [15], or TiPi (Java ™ ) [36] provide elements for the implementation of forward models, as well as iterative solvers to tackle the associated inverse problems. The disadvantage of these toolboxes is that the optimization algorithms they provide are generally implemented to minimize a specific functional, thus limiting their modularity.
In contrast, GlobalBioIm provides a fully modular environment where one can not only easily combine functionals and operators to define the loss to be minimized in (2), but also benefit from a variety of solvers. This philosophy is shared by a few other toolboxes with different programming languages, such as the Operator Discretization Library (in Python) [1] and the Rice Vector Library (in C++) [28].

General Philosophy and Organization
When tasked with the design of a reconstruction algorithm for a new imaging problem, the common practice follows a three steps process.
(i) Modelization of the acquisition system ⇒ Implementation of H.
(ii) Formulation of the reconstruction as an optimization problem (i.e., the cost function) ⇒ Choice of D and R in (2). (iii) Deployment of an optimization method ⇒ Choice of a solver for (2).
This standard pipeline motivates the organization of GlobalBioIm around three dedicated main abstract classes: LinOp, Cost, and Opti. Because linear operators and cost functions both belong to the larger mathematical class of maps, the LinOp and Cost classes are defined as particular instances of a generic abstract class Map. The latter also allows for a proper inclusion of nonlinear operators. The organization of the library is illustrated in Figure 1. It is guided by five general principles.
• Modularity. All objects are defined as individual modules that can be combined to generate a particular reconstruction workflow. Each building block can thus be easily changed to define new reconstruction pipelines. • Flexibility. The constraints to fulfill during implementation are few. New objects can easily be plugged into the framework of GlobalBioIm. • Abstraction. The four abstract classes (LinOp, Cost, Opti, Map) define a limited set of attributes and methods that are shared by their derived classes (i.e., subclasses). This constitutes a common guideline for the implementation of subclasses. Moreover, generic concepts-basically, interactions between classesare implemented at the level of the abstract classes and benefit directly to all subclasses. • Readability. Reconstruction scripts are written in a way that mimics equations in scientific papers, hence keeping a simple connection between theory and implementation. • User-friendliness. The definition (or update) of a new subclass only requires one to create (or edit) a single file. Moreover, the usage of GlobalBioIm does not require one to understand advanced computing concepts.

Abstract Classes
We now present the four abstract classes that build up the skeleton of the GlobalBioIm library. The methods within these abstract classes are prototypes that have to be implemented in derived classes. There are exceptions for some generic concepts (e.g., the chain rule) that are directly implemented in the abstract classes. For the sake of conciseness, we only review here the key attributes and methods of those classes. An exhaustive list of those features can be found in the online documentation (http://bigwww.epfl.ch/algorithms/globalbioim/) within the sections "List of Methods" and "List of Properties".

Map Class
The abstract Map class defines the basic attributes and methods of an operator H : R N → R M . These include, at the very minimum, the input size N , the output size M , and the method apply that computes g = H{f } for a given f ∈ R N . In addition, because optimization algorithms may require the differentiation of the objective function in (2), the Map class defines the method applyJacobianT.
is the Jacobian matrix of H (assuming that the latter is differentiable). It is formed out of the first-order partial derivatives of the operator H, with where Similarly, for invertible maps, the method applyInverse allows one to compute f = H −1 {g} for g ∈ R M . In addition to the "apply"-type methods, the Map class provides prototype methods prefixed by "make". These can be implemented in derived classes to create new instances of Map objects that are related to H. For instance, the method makeInversion returns a Map object that corresponds to H −1 .
The prototype methods are also used to overload the MATLAB ® operators " * " (mtimes), "+" (plus), and "−" (minus). Hence, the composition between two Map objects can be specified easily as H = H1 * H2. This will execute the method makeComposition of H1 with H2 as its argument. By default, the resulting H will be a MapComposition object that benefits from the generic implementations (e.g., successive calls for apply, chain rule for applyJacobianT) provided in the MapComposition class.
Similarly, the operators "+" and "−" are associated to the MapSummation class. It is noteworthy to mention that this default behavior can be specialized in derived classes with a proper implementation of the "make" methods. This results in automatic simplifications, as described in Section 4.2.

LinOp Class
A particular class of map objects contains linear operators H : R N → R M that satisfy for all scalar α and vectors f ∈ R N and g ∈ R N . Linear operators are generally represented as a matrix H ∈ R M ×N . They are widely used in practice to model imaging systems. In addition to being good approximators, they lead to convex optimization problems for which there exist efficient solvers. An important subclass is formed by the convolution operators that are implemented very efficiently using FFTs. All this motivates the definition of the LinOp class, which inherits from the attributes and the methods of Map while defining novel ones. For linear operators, the transposed Jacobian matrix [J H {f }] T is independent of f and is equal to the adjoint operator H T . Thus, the LinOp class provides the method applyAdjoint that computes u = H T v for v ∈ R M and is directly used to implement the method applyJacobianT. Hence, to allow a LinOp to be differentiated only requires implementation of applyAdjoint, rather than applyJacobianT. In keeping with the aforementioned philosophy, the companion method makeAdjoint allows one to instantiate a new LinOp corresponding to the adjoint H T .
For least-squares minimization, the normal operators H T H and HH T are at the core of many optimization algorithms. Hence, the methods applyHtH and applyHHt as well as their "make" counterparts are defined in the LinOp class. They can be implemented in derived classes to provide implementations that are faster than the default successive application of H and H T . This is particularly useful when H T H turns out to be a convolution, as is the case for deconvolution, cryo-electron microscopy [13,41], and x-ray computed tomography [23].

Cost Class
Cost functions are mappings for which M = 1 (i.e., J : R N → R). Hence, the abstract Cost class inherits from all the attributes and methods defined by the Map class. However, the Cost class also defines new attributes and methods that are specific to cost functions. For instance, the method applyProx is dedicated to the computation of the proximity operator of J , which is required for a broad range of optimization algorithms. It is defined by [25] as The method applyGrad computes the gradient ∇J of the functional J . Similarly to the method applyAdjoint for LinOp, applyGrad can be seen as an alias for the method applyJacobianT. This ensures consistency with the standard terminology employed in scientific publications.

Opti Class
The last abstract class Opti is a prototype for optimization algorithms. Given a cost function J resulting from the composition/addition of Map, LinOp, and Cost objects, the run method of the Opti class implements a general iterative scheme to minimize J . It includes calls to the methods initialize, doIteration, and updateParams, which are implemented in every derived class.
The method initialize performs the computations required prior to starting the main loop of the iterative scheme. Then, doIteration is executed at each iteration, preceded by a call to updateParams that modifies the parameters of the algorithm (e.g., by modifying the step size in a descent method).
The convergence of the algorithm is monitored during the optimization using a TestCvg object (set as an attribute of the Opti object).
GlobalBioIm contains various TestCvg classes that implement different convergence criteria (e.g., TestCvgStepRelative, TestCvgCostRelative). They can also be combined using the class TestCvgCombine. Finally, the verbose output is controlled by an OutputOpti object (again, set as an attribute of the Opti object). Hence, one can easily tune the information displayed and saved during iteration by defining a custom OutputOpti class.

Key Features of the Library
In this section, we highlight some of the most remarkable features of GlobalBioIm, which are intended to simplify the development process.

Interface and Core Methods
Map, LinOp, and Cost classes contain two types of methods, which come in pairs. Interface methods are only implemented in abstract classes and cannot be overridden in derived classes (sealed methods). However, they can be executed by an instantiated object of the class. On the other hand, core methods are not implemented in abstract classes, but in derived classes only. In addition, they cannot be executed by an instantiated object (private methods).
This scheme allows for the separation of preprocessing computations, which are common to all derived classes, from the core computations of the method, which are class-dependent. When executed, an interface method checks that inputs are the correct size prior to executing the associated core method. Interface methods are also used to manage the memoize mechanism (see Section 4.3).
From a user viewpoint, only core methods matter. They have to be implemented in derived classes without having to deal with input checking and the memoize mechanism. In the library, the core methods differ from the interface methods by the suffix " " (e.g., apply versus apply).

Composition of Operators and Automatic Simplification
Up to now, the reader may wonder why it is useful to allow "make"-type methods to be overloaded in derived classes. Actually, these methods are the key ingredients for the automatic simplification mechanism deployed by GlobalBioIm. When compositions between maps occur, they allow for the instantiation of specific classes instead of the default generic classes such as MapComposition, MapInversion, or MapSummation. Consequently, the resulting object generally enjoys faster implementations.
To illustrate this feature, let us consider a convolution operator H. Its adjoint H T and the normal operator H T H turn out to be convolution operators as well, whose kernels can be precomputed from that of H. Hence, the LinOpConv class implements the makeAdjoint and makeHtH methods by instantiating a new LinOpConv with the adequate kernel. Because makeAdjoint and makeHtH are used to overload the operators " " and " * ", respectively, we obtain the following automatic simplification. There are many more examples of "make" methods in GlobalBioIm (see also the methods plus and mpower ). For instance, the LinOpConv class provides the following implementation for the method plus (which is used to overload "+"). We conclude this section with two examples that demonstrate the relevance of this automatic simplification mechanism. Example 4.1 (Proximity operator with semiorthogonal linear transform). Let J be a lower semicontinuous convex functional and L be a semiorthogonal linear operator (i.e., LL T = νI for ν > 0). Then, as demonstrated in [11,Lemma 2.4], the proximity operator of J (L · ) is given by Due to the automatic simplification mechanism of GlobalBioIm, one can easily verify whether L is semiorthogonal in the constructor of the CostComposition class (L → this.H2).
function x=applyProx (this,z,alpha) if this .isConvex && this.isH2LinOp && this.isH2SemiOrtho H2z=this.H2 * z; x = z + 1/this.nu * this.H2.applyAdjoint(this.H1.applyProx(H2z,alpha * this.nu)−H2z); else x = applyProx @Cost(this,z,alpha); end end As a result, the composition of a Cost object that has an implementation of its proximity operator with a semi-orthogonal LinOp object automatically leads to a CostComposition object that has an implementation of the applyProx method. Example 4.2 (Woodbury matrix identity). Let J (f ) = 1 2 SHf − g 2 2 , where S is a downsampling operator and H is a convolution operator. It follows from (5) where the Woodbury matrix identity [16] is used to get (7). Moreover, it turns out that αSHH T S T is a convolution operator [33,Lemma A.3] and, thus, that I + αSHH T S T can easily be inverted in the Fourier domain. In order to apply (7), the specification of αSHH T S T as a convolution is implemented in GlobalBioIm. This is done in the makeComposition method of LinOpDownsample, which returns a LinOpConv object when appropriate.  (7) can be directly implemented as follows.

The Memory versus Computational Cost Dilemma
The computation and storage of fixed quantities can significantly accelerate iterative reconstruction methods. For instance, let us consider the least-squares functional where H is a convolution operator. Then, the minimization of J by a gradient-descent algorithm requires the evaluation of at each iteration. The computational burden of this operation is directly related to the implementation strategy. The formulation in (8) requires the evaluation of both H and H T , leading to the overall cost of two FFTs plus two iFFTs. Instead, since H T H turns out to be a convolution in this example, the formulation in (9) opens the door to a faster computation of ∇J . The price to pay, however, is storage for the quantity H T g. Imposing one of the above implementations to users could lead to severe memory issues or extremely slow computations, depending on the considered problem and the available hardware resources. Therefore, in GlobalBioIm, the choice between speed and memory consumption is left to the user by means of the Boolean attribute doPrecomputation of the abstract class Map. When activated, the instanciated object is allowed to store relevant quantities for acceleration purposes, at the expense of larger memory consumption. For instance, consider the Cost object corresponding to J = 1 2 H · − g 2 2 for which the doPrecomputation option is activated. Then, we evaluate the gradient of J at the two random points f 1 and f 2 .
We observe that the second gradient computation is twice as fast as the first one. This is because the quantity H T g is computed and stored at the first call of the applyGrad method. For all subsequent calls, the computational burden is reduced to the application of H T H in (9).
Another feature that allows for faster computations at the expense of larger memory consumption is provided by the structure attribute memoizeOpts of the abstract class Map. When this attribute is activated, both the input and the result of the evaluation are stored whenever the corresponding Map object is evaluated. Hence, if the object is subsequently evaluated with the same input, the stored result is returned without any computation.  This option proves to be particularly useful to avoid multiple computations within iterative methods. For instance, at each iteration of OptiVMLMB, both the cost J and its gradient ∇J need to be evaluated at the same point f . For least-squares minimization, this involves computing J (f ) = 1 2 Hf −g 2 2 and ∇J (f ) = H T (Hf −g), which both call for the quantity Hf . Hence, activating the memoize option for the apply method of H allows for the savings of one evaluation of Hf per iteration.

GPU Computing
GlobalBioIm provides two functions that allow the user to easily run any reconstruction pipeline on the GPU for faster computation.
The function useGPU, which is typically called at the beginning of the script, allows selection of the computation mode: CPU computation (default), GPU computation with the MATLAB ® Parallel Computing Toolbox ™ , or GPU computation with CudaMat (https://github.com/RainerHeintzmann/CudaMat). Next, the function gpuCpuConverter converts the input variable to the appropriate data type as specified by useGPU. A typical use of these functions is presented below.

Simulation Setting
We consider the sample depicted in Figure 2a. It has been extracted from the neuronal culture acquisition shared by Schmoranzer on the Cell Image Library website (http://cellimagelibrary.org/images/41649). It contains three channels that we process independently. Our simulation pipeline is illustrated in Figure 2. It encompasses several steps to account for the fact that, for real-world experiments, (i) the underlying sample is generally not supported within the field-of-view of the microscope; (ii) the sample is not periodic (contrary to what is implicitly assumed when using FFTs to perform the convolution). The three point-spread functions (PSF) have been generated in the Fourier domain. They are related to the classical Airy disk model, which is a radial function with the profile where ρ c = 2NA/λ exc is the cutoff frequency which depends on the numerical aperture NA and the excitation wavelength λ exc . Here, we set NA = 1.4 and λ exc to 654nm (CY3 dye, red), 542nm (FITC dye, green), and 477nm (DAPI dye, blue) a b c d Figure 2: Simulation of multichannel blurred data. a) Input image (512 × 512 × 3). b) The image is zero-padded. c) Each channel is convolved with its corresponding PSF and a central region of size (460 × 460 × 3) is extracted (simulated field-of-view). d) Data are corrupted by additive Gaussian noise so that the resulting signal-to-noise ratio (SNR) is equal to 10dB.
for the three channels, respectively. Finally, the spatial sampling step (i.e., the camera pixel size) is set to 64.5nm. Note that the data generated with this pipeline contain contributions from structures that lie outside the field-of-view.

Deconvolution
Given the blurred and noisy data {g k ∈ R M } 3 k=1 , we formulate the deconvolution task as the optimization problem where H k ∈ R N ×N , k ∈ {1, 2, 3}, is the convolution operator for the kth channel, and S ∈ R M ×N selects the region of Hf that corresponds to the field-of-view. Indeed, since the sample is not fully included in the field-of-view, we seek a wider reconstruction that is larger than the field-of-view (i.e., N > M ) in order to avoid reconstruction artifacts [3,31].
With GlobalBioIm, the construction of the operators H k , k ∈ {1, . . . , 3}, and S is done as follows. Here, the three PSFs are stacked within the same LinOpConv operator which is set by the argument [1 2] to apply a convolution only to the first two dimensions. Hence, it performs independent 2D convolutions for each channel. The selector operator S then extracts a region that has the same size as the data.
• The total-variation (TV) [8,9,30] combines the gradient operator L = [D 1 D 2 ] T with the ( 2 , 1 )-mixed norm R = · 2,1 . More precisely, for f ∈ R N , we have that where D 1 (D 2 , respectively) is the finite-difference operator along the first (second, respectively) dimension. • The Hessian-Schatten-norm (HS) [19,20] computes the ( * , 1 )-mixed norm R = · * ,1 of the Hessian operator L = [D ij ] 1≤i,j≤2 applied to f ∈ R N as where · * denotes the nuclear norm (i.e., the first-order Schatten norm). It is defined as the 1 -norm of the singular values of its argument. Finally, D ij denotes the operator of second-order finite difference along the dimensions i and j. • The smoothed total-variation (S-TV) [4,8] is defined, for ε > 0, by • The Good's roughness (GR) [40] is defined, for ε > 0, by Since the TV and HS regularizers are not differentiable, gradient-based methods cannot be used to minimize the objective function (11). However, for both these regularizers, the proximity operator of R( · ) can be efficiently computed (see [11] for · 2,1 and [10,19] for · S1,1 ). Hence, the optimization problem can be tackled using proximal-splitting algorithms such as the alternating direction method of multipliers (ADMM) [2,7,14,32] or the primal-dual method proposed in [12]. These algorithms are designed to minimize cost functions of the form J = P p=1 J p (T p · ), where {T p } P p=1 are linear operators and the {J p } P p=1 are "simple" functions in the sense that their proximity operator can be evaluated efficiently.
The scripts provided in Figure 3 illustrate how these two algorithms can be implemented within the framework of GlobalBioIm to solve Problem (11) with TV or HS regularization. The modified lines of code between each setting have been Total-variation [8,9,30] ADMM [2,7,14,32] Hessian-Schatten [19,20] Primal-dual [12] Figure 3: GlobalBioIm scripts for minimizing (11) with non-differentiable regularizers R(L · ). Differences with respect to the script corresponding to ADMM with TV are highlighted.
highlighted-observe that very few modifications are needed. This underlines the simplicity of changing the regularizer and/or the algorithm within the GlobalBioIm framework.
For both algorithms, the splitting strategy is specified by the two cell arrays Fn and Hn. Note that, since S is a semi-orthogonal linear operator, the composition L2*S results in a Cost object that has an implementation of the proximity operator (see Example 4.1). Moreover, the two scripts that use the primal-dual method illustrate the relevance of the automatic simplification features described in Section 4.2. In order to ensure the convergence of the algorithm, the two parameters σ > 0 and τ > 0 have to be chosen so that τ σ P p=1 T T p T p ≤ 1 holds true [12]. The norm which is involved in this inequality is easily obtained with GlobalBioIm by building the operator T=H'*H + L'*L + LinOpIdentity(szin) explicitly and computing its norm T.norm. The key is that the composition used to build T is automatically simplified to a convolution operator with the proper kernel. Finally, observe that, as for the convolution operator, the gradient and Hessian operators are defined using the argument [1 2], which implies that these operators are applied independently to each channel.
As opposed to TV and HS, the S-TV and the GR regularizers are differentiable. Hence, the optimization problem in (11) can be addressed through gradient-based methods. In Figure 4, we present scripts in which the objective function in (11) with S-TV or GR regularization is minimized using either the variable-metric limitedmemory-bounded (VMLMB) algorithm [34] or the fast iterative shrinkage-thresholding algorithm (FISTA) [5]. For these two minimization algorithms, each iteration requires the evaluation of the gradient of 3 k=1 SH k · − g k 2 2 + λR(L · ) as well as a projection onto the set of nonnegative vectors. Once again, changing the regularizer or the optimization method only requires the modification of very few lines, as highlighted in Figure 4.

Numerical Comparisons
The modularity of GlobalBioIm, which was demonstrated in the scripts presented in Section 5.2, offers a simple way to compare the effect of regularizers as well as the efficiency of optimization algorithms.
We first present the quality of the deconvolution obtained with the four regularizers TV, HS, S-TV, and GR. Here, we used ADMM to minimize (11) with non-differentiable regularizers (i.e., TV and HS), and FISTA to minimize (11) with differentiable regularizers (i.e., S-TV and GR). The SNR of the deconvolved image as a function of the regularization parameter λ is depicted in Figure 5, while the deconvolved images that maximize the SNR are presented in Figure 6. As expected, HS and GR lead to better results by avoiding the well-known staircasing effect of TV and S-TV. Although GR is slightly below HS in terms of SNR, it provides comparable qualitative (i.e., visual) results. We now fix the parameter λ to the value that maximizes the SNR in Figure 5 for TV and S-TV. The convergence curves generated by ADMM and the primal-dual method for the minimization of (11) with TV, as well as those generated by FISTA and VMLMB when the regularizer is set to be S-TV, are presented in Figure 7. We would like to emphasize that the parameters of the algorithms have not been tuned to obtain the fastest convergence. Hence, these results constitute more an illustration of the kind of comparisons that can be easily performed with GlobalBioIm rather than an empirical demonstration of the convergence speed of these algorithms. Moreover, both ADMM and the primal-dual method offer alternative splitting strategies that may lead to improved convergence speed. Note that the adaptation of the scripts in Figure 3 to these variations is straightforward with GlobalBioIm. We refer the reader to the online documentation of the corresponding two Opti classes for more details on how to establish such adaptations.

Discussion
Open-source software is an essential component of modern research. Not only does it shape theoretical developments, but it also turns out to be a critical tool to bridge the gap that separates researchers specialized in computer science/mathematics from scientists versed in biophysical sciences/medicine. Moreover, open-source software can act as a catalyst for engaging in new collaborations by promoting external contributions.
Motivated by the observation that the image-formation models of most of the commonly used biomedical imaging systems can be expressed as a composition of a limited number of elementary operators, we developed the open-source MATLAB

Ground Truth Data
Total Variation Hessian-Schatten Smoothed-TV Good's Roughness    library GlobalBioIm. This library provides a unified and user-friendly framework for the resolution of inverse problems. It is designed around three entities, namely, forward models, cost functions, and optimization algorithms, which constitute the building blocks of any inverse problem. This organization gives GlobalBioIm a modularity that greatly facilitates the comparison between regularizers and or solvers, as illustrated in Section 5. Moreover, GlobalBioIm enjoys an operator-algebra mechanism able to perform automatic simplification of composed operators. Finally, new modalities, cost functions, or solvers are easily added to the framework of GlobalBioIm. Reference papers that use GlobalBioIm is provided in the Section "Related Papers" of the online documentation http://bigwww.epfl.ch/algorithms/globalbioim/.