fix temperamental notebook progress thread errors (#2241)

- fixes TomographicImaging/CIL-Demos#260

Author: casperdcl

CHANGELOG.md

@@ -6,6 +6,7 @@
     - `PaganinProcessor` now correctly applies scaling with magnification for cone-beam geometry (#2225)
   - Dependencies:
     - olefile and dxchange are optional dependencies, instead of required (#2209)
+    - improve `tqdm` notebook support (#2241)
   - Documentation:
     - Render the user showcase notebooks in the documentation (#2189)
 

Wrappers/Python/cil/optimisation/utilities/callbacks.py

@@ -24,6 +24,8 @@
 from tqdm.std import tqdm as tqdm_std
 import numpy as np
 
+tqdm_std.monitor_interval = 0  # disable background monitoring thread
+
 
 class Callback(ABC):
     '''Base Callback to inherit from for use in :code:`Algorithm.run(callbacks: list[Callback])`.
@@ -154,56 +156,54 @@ class LogfileCallback(TextProgressCallback):
     def __init__(self, log_file, mode='a', **kwargs):
         self.fd = open(log_file, mode=mode)
         super().__init__(file=self.fd, **kwargs)
-        
+
 class EarlyStoppingObjectiveValue(Callback):
     '''Callback that stops iterations if the change in the objective value is less than a provided threshold value.
 
     Parameters
     ----------
-    threshold: float, default 1e-6 
+    threshold: float, default 1e-6
 
     Note
     -----
     This callback only compares the last two calculated objective values. If `update_objective_interval` is greater than 1, the objective value is not calculated at each iteration (which is the default behaviour), only every `update_objective_interval` iterations.
-    
+
     '''
     def __init__(self, threshold=1e-6):
         self.threshold=threshold
-    
-    
+
+
     def __call__(self, algorithm):
         if len(algorithm.loss)>=2:
             if np.abs(algorithm.loss[-1]-algorithm.loss[-2])<self.threshold:
                 raise StopIteration
-                
+
 class CGLSEarlyStopping(Callback):
-    '''Callback to work with CGLS. It causes the algorithm to terminate if  :math:`||A^T(Ax-b)||_2 < \epsilon||A^T(Ax_0-b)||_2` where `epsilon` is set to default as '1e-6', :math:`x` is the current iterate and :math:`x_0` is the initial value. 
-    It will also terminate if the algorithm begins to diverge i.e. if :math:`||x||_2> \omega`, where `omega` is set to default as 1e6. 
-    
+    '''Callback to work with CGLS. It causes the algorithm to terminate if  :math:`||A^T(Ax-b)||_2 < \epsilon||A^T(Ax_0-b)||_2` where `epsilon` is set to default as '1e-6', :math:`x` is the current iterate and :math:`x_0` is the initial value.
+    It will also terminate if the algorithm begins to diverge i.e. if :math:`||x||_2> \omega`, where `omega` is set to default as 1e6.
+
     Parameters
     ----------
-    epsilon: float, default 1e-6 
+    epsilon: float, default 1e-6
         Usually a small number: the algorithm to terminate if :math:`||A^T(Ax-b)||_2 < \epsilon||A^T(Ax_0-b)||_2`
-    omega: float, default 1e6 
+    omega: float, default 1e6
         Usually a large number: the algorithm will terminate if  :math:`||x||_2> \omega`
-        
+
     Note
     -----
-    This callback is implemented to replicate the automatic behaviour of CGLS in CIL versions <=24. It also replicates the behaviour of https://web.stanford.edu/group/SOL/software/cgls/. 
+    This callback is implemented to replicate the automatic behaviour of CGLS in CIL versions <=24. It also replicates the behaviour of https://web.stanford.edu/group/SOL/software/cgls/.
     '''
     def __init__(self, epsilon=1e-6, omega=1e6):
         self.epsilon=epsilon
         self.omega=omega
-    
-    
+
+
     def __call__(self, algorithm):
-        
+
         if (algorithm.norms <= algorithm.norms0 * self.epsilon):
             print('The norm of the residual is less than {} times the norm of the initial residual and so the algorithm is terminated'.format(self.epsilon))
             raise StopIteration
         self.normx = algorithm.x.norm()
         if algorithm.normx >= self.omega:
             print('The norm of the solution is greater than {} and so the algorithm is terminated'.format(self.omega))
             raise StopIteration
-            
-        

Wrappers/Python/cil/processors/PaganinProcessor.py

@@ -25,7 +25,7 @@
 from scipy.fft import ifft2
 from scipy.fft import ifftshift
 from scipy import constants
-from tqdm import tqdm
+from tqdm.auto import tqdm
 import logging
 
 log = logging.getLogger(__name__)
@@ -116,12 +116,12 @@ class PaganinProcessor(Processor):
         - :math:`T`, is the sample thickness,
         - :math:`\mu = \frac{4\pi\beta}{\lambda}` is the material linear
           attenuation coefficient where :math:`\beta` is the complex part of the
-          material refractive index [2] and :math:`\lambda=\frac{hc}{E}` is the 
+          material refractive index [2] and :math:`\lambda=\frac{hc}{E}` is the
           probe wavelength,
         - :math:`I_{norm}` is the input image which is expected to be the
           normalised transmission data,
-        - :math:`\Delta` is the propagation distance. In cone-beam geometry, 
-          :math:`\Delta` is scaled by the magnification :math:`M` as described 
+        - :math:`\Delta` is the propagation distance. In cone-beam geometry,
+          :math:`\Delta` is scaled by the magnification :math:`M` as described
           in [1],
         - :math:`\alpha = \frac{\Delta\delta}{\mu}` is a parameter determining
           the strength of the filter to be applied in Fourier space where
@@ -203,22 +203,22 @@ def __init__(self, delta=1, beta=1e-2, energy=40000,
     def check_input(self, data):
         if not isinstance(data, (AcquisitionData)):
             raise TypeError('Processor only supports AcquisitionData')
-        
+
         if data.geometry.geom_type & AcquisitionType.CONE_FLEX:
             raise NotImplementedError("Processor not implemented for CONE_FLEX geometry.")
-        
+
         if data.dtype!=np.float32:
             raise TypeError('Processor only support dtype=float32')
-        
+
         cil_order = tuple(AcquisitionDimension.get_order_for_engine('cil',data.geometry))
         if data.dimension_labels != cil_order:
             raise ValueError("This processor requires CIL data order, consider using `data.reorder('cil')`")
-    
+
         return True
 
     def process(self, out=None):
 
-        data  = self.get_input()            
+        data  = self.get_input()
         # set the geometry parameters to use from data.geometry unless the
         # geometry is overridden with an override_geometry
         self._set_geometry(data.geometry, self.override_geometry)
@@ -229,12 +229,12 @@ def process(self, out=None):
         target_shape = (
             data.get_dimension_size('channel')  if 'channel' in data.dimension_labels else 1,
             data.geometry.num_projections,
-            data.get_dimension_size('vertical') if 'vertical' in data.dimension_labels else 1, 
+            data.get_dimension_size('vertical') if 'vertical' in data.dimension_labels else 1,
             data.get_dimension_size('horizontal') if 'horizontal' in data.dimension_labels else 1)
-            
+
         data.array = np.reshape(data.array, target_shape)
         out.array = np.reshape(out.array, target_shape)
-        
+
         # create a filter based on the shape of the data
         proj_shape = data.array.shape[-2:]
         self.filter_Nx = proj_shape[0]+self.pad*2
@@ -243,12 +243,12 @@ def process(self, out=None):
 
         # allocate padded buffer
         padded_buffer = np.zeros((self.filter_Nx, self.filter_Ny), dtype=data.dtype)
-        buffer_slice = (slice(self.pad, self.pad + proj_shape[0]), 
+        buffer_slice = (slice(self.pad, self.pad + proj_shape[0]),
                     slice(self.pad, self.pad + proj_shape[1]))
-        
+
         # pre-calculate the scaling factor
         scaling_factor = -(1/self.mu)
-        
+
         # loop over the channels
         for j in range(data.geometry.channels):
             # loop over the projections
@@ -266,9 +266,9 @@ def process(self, out=None):
                     # apply the filter in fourier space
                     fI = fft2(padded_buffer)
                     padded_buffer[:] = ifft2(fI*self.filter).real
-                
+
                 out.array[j, i, :, :] = padded_buffer[buffer_slice]
-                        
+
         data.array = np.squeeze(data.array)
         out.array = np.squeeze(out.array)
         return out
@@ -469,7 +469,7 @@ def _create_filter(self, override_filter=None):
             self.alpha = override_filter['alpha']
         else:
             self._calculate_alpha()
-           
+
 	# calculate pixel size at sample plane, used for defining fourier mesh
         pixel_size_dmag = self.pixel_size/self.magnification
 

Wrappers/Python/cil/recon/FBP.py

@@ -23,7 +23,7 @@
 
 import numpy as np
 import ctypes
-from tqdm import tqdm
+from tqdm.auto import tqdm
 
 c_float_p = ctypes.POINTER(ctypes.c_float)
 c_double_p = ctypes.POINTER(ctypes.c_double)
@@ -488,7 +488,7 @@ def __init__ (self, input, image_geometry=None, filter='ram-lak', backend='tigre
 
         if not AcquisitionType.PARALLEL & input.geometry.geom_type:
             raise TypeError("This reconstructor is for parallel-beam data only.")
-        
+
         super().__init__(input, image_geometry, filter, backend)
         self.set_split_processing(False)