MAINT: Change examples to use default ray transform impl

examples/solvers/chambolle_pock_tomography.py

@@ -47,16 +47,8 @@
 detector_partition = odl.uniform_partition(-30, 30, 558)
 geometry = odl.tomo.Parallel2dGeometry(angle_partition, detector_partition)
 
-# The implementation of the ray transform to use, options:
-# 'scikit'                    Requires scikit-image (can be installed by
-#                             running ``pip install scikit-image``).
-# 'astra_cpu', 'astra_cuda'   Require astra tomography to be installed.
-#                             Astra is much faster than scikit. Webpage:
-#                             https://github.com/astra-toolbox/astra-toolbox
-impl = 'astra_cuda'
-
 # Create the forward operator
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl=impl)
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 
 # --- Generate artificial data --- #
@@ -88,7 +80,7 @@
 l2_norm = odl.solvers.L2NormSquared(ray_trafo.range).translated(data)
 
 # Isotropic TV-regularization i.e. the l1-norm
-l1_norm = 0.01 * odl.solvers.L1Norm(gradient.range)
+l1_norm = 0.015 * odl.solvers.L1Norm(gradient.range)
 
 # Combine functionals, order must correspond to the operator K
 f = odl.solvers.SeparableSum(l2_norm, l1_norm)
@@ -98,12 +90,12 @@
 
 
 # Estimated operator norm, add 10 percent to ensure ||K||_2^2 * sigma * tau < 1
-op_norm = 1.3 * odl.power_method_opnorm(op, maxiter=10)
+op_norm = 1.5 * odl.power_method_opnorm(op, maxiter=10)
 
-niter = 100  # Number of iterations
+niter = 200  # Number of iterations
 tau = 1.0 / op_norm  # Step size for the primal variable
 sigma = 1.0 / op_norm  # Step size for the dual variable
-gamma = 0.1
+gamma = 0.5
 
 # Optionally pass callback to the solver to display intermediate results
 callback = (odl.solvers.CallbackPrintIteration() &

examples/solvers/conjugate_gradient_tomography.py

@@ -45,16 +45,8 @@
 detector_partition = odl.uniform_partition(-30, 30, 300)
 geometry = odl.tomo.Parallel2dGeometry(angle_partition, detector_partition)
 
-# The implementation of the ray transform to use, options:
-# 'scikit'                    Requires scikit-image (can be installed by
-#                             running ``pip install scikit-image``).
-# 'astra_cpu', 'astra_cuda'   Require astra tomography to be installed.
-#                             Astra is much faster than scikit. Webpage:
-#                             https://github.com/astra-toolbox/astra-toolbox
-impl = 'scikit'
-
 # Create the forward operator
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl=impl)
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 
 # --- Generate artificial data --- #

examples/solvers/douglas_rachford_pd_tomography_tv.py

@@ -67,8 +67,8 @@
 detector_partition = odl.uniform_partition(-30, 30, 512)
 geometry = odl.tomo.Parallel2dGeometry(angle_partition, detector_partition)
 
-# Ray transform (= forward projection). We use ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(space, geometry)
 
 # Create sinogram
 phantom = odl.phantom.shepp_logan(space, modified=True)

examples/solvers/lbfgs_tomography.py

@@ -45,16 +45,8 @@
 detector_partition = odl.uniform_partition(-30, 30, 400)
 geometry = odl.tomo.Parallel2dGeometry(angle_partition, detector_partition)
 
-# The implementation of the ray transform to use, options:
-# 'scikit'                    Requires scikit-image (can be installed by
-#                             running ``pip install scikit-image``).
-# 'astra_cpu', 'astra_cuda'   Require astra tomography to be installed.
-#                             Astra is much faster than scikit. Webpage:
-#                             https://github.com/astra-toolbox/astra-toolbox
-impl = 'astra_cuda'
-
 # Create the forward operator
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl=impl)
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # --- Generate artificial data --- #
 

examples/solvers/lbfgs_tomography_tv.py

@@ -49,16 +49,8 @@
 detector_partition = odl.uniform_partition(-30, 30, 400)
 geometry = odl.tomo.Parallel2dGeometry(angle_partition, detector_partition)
 
-# The implementation of the ray transform to use, options:
-# 'scikit'                    Requires scikit-image (can be installed by
-#                             running ``pip install scikit-image``).
-# 'astra_cpu', 'astra_cuda'   Require astra tomography to be installed.
-#                             Astra is much faster than scikit. Webpage:
-#                             https://github.com/astra-toolbox/astra-toolbox
-impl = 'astra_cuda'
-
 # Create the forward operator
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl=impl)
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # --- Generate artificial data --- #
 

examples/solvers/nuclear_norm_tomography.py

@@ -59,16 +59,8 @@
 detector_partition = odl.uniform_partition(-30, 30, 300)
 geometry = odl.tomo.Parallel2dGeometry(angle_partition, detector_partition)
 
-# The implementation of the ray transform to use, options:
-# 'scikit'                    Requires scikit-image (can be installed by
-#                             running ``pip install scikit-image``).
-# 'astra_cpu', 'astra_cuda'   Requires astra tomography to be installed.
-#                             Astra is much faster than scikit. Webpage:
-#                             https://github.com/astra-toolbox/astra-toolbox
-impl = 'astra_cuda'
-
 # Create the forward operator, and also the vectorial forward operator.
-ray_trafo = odl.tomo.RayTransform(space, geometry, impl=impl)
+ray_trafo = odl.tomo.RayTransform(space, geometry)
 forward_op = odl.DiagonalOperator(ray_trafo, 2)
 
 # Create phantom where the first component contains only part of the

examples/solvers/proximal_gradient_wavelet_tomography.py

@@ -46,16 +46,8 @@
 detector_partition = odl.uniform_partition(-30, 30, 300)
 geometry = odl.tomo.Parallel2dGeometry(angle_partition, detector_partition)
 
-# The implementation of the ray transform to use, options:
-# 'scikit'                    Requires scikit-image (can be installed by
-#                             running ``pip install scikit-image``).
-# 'astra_cpu', 'astra_cuda'   Requires astra tomography to be installed.
-#                             Astra is much faster than scikit. Webpage:
-#                             https://github.com/astra-toolbox/astra-toolbox
-impl = 'astra_cuda'
-
 # Create the forward operator, and also the vectorial forward operator.
-ray_trafo = odl.tomo.RayTransform(space, geometry, impl=impl)
+ray_trafo = odl.tomo.RayTransform(space, geometry)
 
 
 # --- Generate artificial data --- #

examples/solvers/proximal_lang_tomography.py

@@ -45,16 +45,8 @@
 detector_partition = odl.uniform_partition(-30, 30, 558)
 geometry = odl.tomo.Parallel2dGeometry(angle_partition, detector_partition)
 
-# The implementation of the ray transform to use, options:
-# 'scikit'                    Requires scikit-image (can be installed by
-#                             running ``pip install scikit-image``).
-# 'astra_cpu', 'astra_cuda'   Requires astra tomography to be installed.
-#                             Astra is much faster than scikit. Webpage:
-#                             https://github.com/astra-toolbox/astra-toolbox
-impl = 'astra_cuda'
-
 # Initialize the ray transform (forward projection).
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl=impl)
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Convert ray transform to proximal language operator
 proximal_lang_ray_trafo = odl.as_proximal_lang_operator(ray_trafo)

examples/tomo/filtered_backprojection_cone_2d.py

@@ -49,8 +49,8 @@
 # --- Create Filtered Back-Projection (FBP) operator --- #
 
 
-# Ray transform (= forward projection). We use the ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Create FBP operator using utility function
 # We select a Hann filter, and only use the lowest 80% of frequencies to avoid

examples/tomo/filtered_backprojection_cone_3d.py

@@ -50,8 +50,8 @@
 # --- Create Filteredback-projection (FBP) operator --- #
 
 
-# Ray transform (= forward projection). We use the ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Create FBP operator using utility function
 # We select a Shepp-Logan filter, and only use the lowest 80% of frequencies to

examples/tomo/filtered_backprojection_helical_3d.py

@@ -55,8 +55,8 @@
 # --- Create Filtered Back-Projection (FBP) operator --- #
 
 
-# Ray transform (= forward projection). We use the ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Unwindowed fbp
 # We select a Hamming filter, and only use the lowest 80% of frequencies to

examples/tomo/filtered_backprojection_parallel_2d.py

@@ -52,8 +52,8 @@
 # --- Create Filtered Back-Projection (FBP) operator --- #
 
 
-# Ray transform (= forward projection). We use the ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Fourier transform in detector direction
 fourier = odl.trafos.FourierTransform(ray_trafo.range, axes=[1])

examples/tomo/filtered_backprojection_parallel_3d.py

@@ -46,8 +46,8 @@
 # --- Create Filtered Back-Projection (FBP) operator --- #
 
 
-# Ray transform (= forward projection). We use the ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Create FBP operator using utility function
 # We select a Hann filter, and only use the lowest 80% of frequencies to

examples/tomo/ray_trafo_circular_cone.py

@@ -35,8 +35,8 @@
     angle_partition, detector_partition, src_radius=1000, det_radius=100,
     axis=[1, 0, 0])
 
-# Ray transform (= forward projection). We use the ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Create a discrete Shepp-Logan phantom (modified version)
 phantom = odl.phantom.shepp_logan(reco_space, True)

examples/tomo/ray_trafo_fanflat.py

@@ -33,8 +33,8 @@
 geometry = odl.tomo.FanFlatGeometry(angle_partition, detector_partition,
                                     src_radius=1000, det_radius=100)
 
-# Ray transform (= forward projection). We use the ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Create a discrete Shepp-Logan phantom (modified version)
 phantom = odl.phantom.shepp_logan(reco_space, modified=True)

examples/tomo/ray_trafo_helical.py

@@ -36,8 +36,8 @@
     angle_partition, detector_partition, src_radius=100, det_radius=100,
     pitch=5.0)
 
-# Ray transform (= forward projection). We use ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Create a discrete Shepp-Logan phantom (modified version)
 phantom = odl.phantom.shepp_logan(reco_space, modified=True)

examples/tomo/ray_trafo_parallel_2d.py

@@ -32,8 +32,8 @@
 detector_partition = odl.uniform_partition(-30, 30, 558)
 geometry = odl.tomo.Parallel2dGeometry(angle_partition, detector_partition)
 
-# Ray transform (= forward projection). We use ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Create a discrete Shepp-Logan phantom (modified version)
 phantom = odl.phantom.shepp_logan(reco_space, modified=True)

examples/tomo/ray_trafo_parallel_3d.py

@@ -39,8 +39,8 @@
 # give a zero result.
 geometry = odl.tomo.Parallel3dAxisGeometry(angle_partition, detector_partition)
 
-# Ray transform (= forward projection). We use ASTRA CUDA backend.
-ray_trafo = odl.tomo.RayTransform(reco_space, geometry, impl='astra_cuda')
+# Ray transform (= forward projection).
+ray_trafo = odl.tomo.RayTransform(reco_space, geometry)
 
 # Create a discrete Shepp-Logan phantom (modified version)
 phantom = odl.phantom.shepp_logan(reco_space, modified=True)

odl/tomo/operators/ray_trafo.py

@@ -62,10 +62,10 @@ def __init__(self, discr_domain, geometry, **kwargs):
         ----------------
         impl : {`None`, 'astra_cuda', 'astra_cpu', 'scikit'}, optional
             Implementation back-end for the transform. Supported back-ends:
-            * 'astra_cuda': ASTRA toolbox, using CUDA, 2D or 3D
-            * 'astra_cpu': ASTRA toolbox using CPU, only 2D
-            * 'scikit': scikit-image, only 2D parallel with square domain
-            If `None` is given, prefers the fastest available backend.
+            * ``'astra_cuda'``: ASTRA toolbox, using CUDA, 2D or 3D
+            * ``'astra_cpu'``: ASTRA toolbox using CPU, only 2D
+            * ``'scikit'``: scikit-image, only 2D parallel with square domain
+            If ``None`` is given, the fastest available back-end is used.
         interp : {'nearest', 'linear'}
             Interpolation type for the discretization of the operator
             range.
@@ -265,10 +265,10 @@ def __init__(self, discr_range, geometry, **kwargs):
         ----------------
         impl : {'astra_cpu', 'astra_cuda', 'scikit'}, optional
             Implementation back-end for the transform. Supported back-ends:
-            * 'astra_cuda': ASTRA toolbox, using CUDA, 2D or 3D
-            * 'astra_cpu': ASTRA toolbox using CPU, only 2D
-            * 'scikit': scikit-image, only 2D parallel with square domain
-            If `None` is given, prefers the fastest available backend.
+            * ``'astra_cuda'``: ASTRA toolbox, using CUDA, 2D or 3D
+            * ``'astra_cpu'``: ASTRA toolbox using CPU, only 2D
+            * ``'scikit'``: scikit-image, only 2D parallel with square domain
+            If ``None`` is given, the fastest available back-end is used.
         interp : {'nearest', 'linear'}
             Interpolation type for the discretization of the operator range.
             Default: 'nearest'