nabu 2024.2.14__py3-none-any.whl → 2025.1.0__py3-none-any.whl

nabu/estimation/cor.py

@@ -132,7 +132,7 @@ class CenterOfRotation(AlignmentBase):
         img_2 = self._prepare_image(img_2, roi_yxhw=roi_yxhw, median_filt_shape=median_filt_shape)
 
         cc = self._compute_correlation_fft(img_1, img_2, padding_mode, high_pass=high_pass, low_pass=low_pass)
-        img_shape = img_2.shape
+        img_shape = cc.shape  # Because cc.shape can differ from img_2.shape (e.g. in case of odd nb of cols)
         cc_vs = np.fft.fftfreq(img_shape[-2], 1 / img_shape[-2])
         cc_hs = np.fft.fftfreq(img_shape[-1], 1 / img_shape[-1])
 
@@ -269,10 +269,9 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
         win_ind_max = np.argmax(diffs_mean)
 
         diffs_std = diffs_std.min() - diffs_std
-        if not win_ind_max == np.argmax(diffs_std):
+        if win_ind_max != np.argmax(diffs_std):
             self.logger.warning(
-                "Minimum mean difference and minimum std-dev of differences do not coincide. "
-                + "This means that the validity of the found solution might be questionable."
+                "Minimum mean difference and minimum std-dev of differences do not coincide. This means that the validity of the found solution might be questionable."
             )
             validity_check_result = cor_result_validity["questionable"]
         else:
@@ -435,10 +434,9 @@ class CenterOfRotationGrowingWindow(CenterOfRotation):
         win_ind_max = np.argmax(diffs_mean)
 
         diffs_std = diffs_std.min() - diffs_std
-        if not win_ind_max == np.argmax(diffs_std):
+        if win_ind_max != np.argmax(diffs_std):
             self.logger.warning(
-                "Minimum mean difference and minimum std-dev of differences do not coincide. "
-                + "This means that the validity of the found solution might be questionable."
+                "Minimum mean difference and minimum std-dev of differences do not coincide. This means that the validity of the found solution might be questionable."
             )
             validity_check_result = cor_result_validity["questionable"]
         else:
@@ -578,8 +576,7 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
 
         if lim_2 <= lim_1:
             message = (
-                "Image shape or cropped selection too small for global search."
-                + " After removal of the margins the search limits collide."
+                "Image shape or cropped selection too small for global search. After removal of the margins the search limits collide."
                 + " The cropped size is %d\n" % (dim_radio)
             )
             raise ValueError(message)
@@ -616,11 +613,11 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
                 if "positions are outside the input margins" in str(err):
                     x_cor = min(x_cor + x_cor * self.step_fraction, x_cor + (dim_radio - x_cor) * self.step_fraction)
                     continue
-            except:
-                message = "Unexpected error from base class CenterOfRotation.find_shift in CenterOfRotationAdaptiveSearch.find_shift  : {err}".format(
-                    err=err
+            except Exception as err:
+                self.logger.error(
+                    "Unexpected error from base class CenterOfRotation.find_shift in CenterOfRotationAdaptiveSearch.find_shift: %s"
+                    % (str(err))
                 )
-                self.logger.error(message)
                 raise
 
             p_1 = cor_position * 2
@@ -643,8 +640,8 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
                 * self.sigma_fraction
             )
 
-            M1 = int(round(cor_position + img_1.shape[1] // 2)) - int(round(tmp_sigma))
-            M2 = int(round(cor_position + img_1.shape[1] // 2)) + int(round(tmp_sigma))
+            M1 = round(cor_position + img_1.shape[1] // 2) - round(tmp_sigma)
+            M2 = round(cor_position + img_1.shape[1] // 2) + round(tmp_sigma)
 
             piece_1 = img_filtered_1[:, M1:M2]
             piece_2 = img_filtered_2[:, img_1.shape[1] - M2 : img_1.shape[1] - M1]
@@ -656,16 +653,13 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
                 diff_energy = np.array((piece_1 - piece_2) * (piece_1 - piece_2), "d").sum()
                 cost = diff_energy / energy
 
-                if not np.isnan(cost):
-                    if tmp_sigma * 2 > abs(x_cor_rel - cor_position):
-                        found_centers.append([cost, abs(x_cor_rel - cor_position), cor_position, energy])
+                if not np.isnan(cost) and tmp_sigma * 2 > abs(x_cor_rel - cor_position):
+                    found_centers.append([cost, abs(x_cor_rel - cor_position), cor_position, energy])
 
             x_cor = min(x_cor + x_cor * self.step_fraction, x_cor + (dim_radio - x_cor) * self.step_fraction)
 
         if len(found_centers) == 0:
-            message = "Unable to find any valid CoR candidate in {my_class}.find_shift ".format(
-                my_class=self.__class__.__name__
-            )
+            message = f"Unable to find any valid CoR candidate in {self.__class__.__name__}.find_shift "
             raise ValueError(message)
 
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -674,6 +668,7 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
 
         filtered_found_centers = []
         for i in range(len(found_centers)):
+            # ruff: noqa: SIM102
             if i > 0:
                 if abs(found_centers[i][2] - found_centers[i - 1][2]) < 0.5:
                     filtered_found_centers.append(found_centers[i])
@@ -683,7 +678,7 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
                     filtered_found_centers.append(found_centers[i])
                     continue
 
-        if len(filtered_found_centers):
+        if len(filtered_found_centers) > 0:
             found_centers = filtered_found_centers
 
         min_choice = min(found_centers)
@@ -711,8 +706,7 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
             validity_check_result = cor_result_validity["sound"]
         else:
             self.logger.warning(
-                "Minimum mean difference and minimum std-dev of differences do not coincide. "
-                + "This means that the validity of the found solution might be questionable."
+                "Minimum mean difference and minimum std-dev of differences do not coincide. This means that the validity of the found solution might be questionable."
             )
             validity_check_result = cor_result_validity["questionable"]
 
@@ -802,7 +796,7 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
                 return res
         return res
 
-    def _interpolate(self, input, shift, mode="mean", interpolation_method="linear"):
+    def _interpolate(self, input_, shift, mode="mean", interpolation_method="linear"):
         """Applies to the input a translation by a vector `shift`. Based on
         `scipy.ndimage.affine_transform` function.
         JL: This Octave function was initially used in the refine clause of the local_correlation (Octave find_shift).
@@ -811,7 +805,7 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
 
         Parameters
         ----------
-        input : array
+        input_ : array
             Array to which the translation is applied.
         shift : tuple, list or array of length 2.
         mode : str
@@ -862,19 +856,19 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
 
         if mode == "mean":
             mode = "constant"
-            cval = input.mean()
-            return affine_transform(input, matrix, mode=mode, order=order, cval=cval)
+            cval = input_.mean()
+            return affine_transform(input_, matrix, mode=mode, order=order, cval=cval)
         elif mode not in admissible_modes:
             raise ValueError(f"Pad method is {mode} and should be in {admissible_modes}.")
 
-        return affine_transform(input, matrix, mode=mode, order=order)
+        return affine_transform(input_, matrix, mode=mode, order=order)
 
     def _local_correlation(
         self,
         z1,
         z2,
-        maxsize=[5, 5],
-        cor_estimate=[0, 0],
+        maxsize=(5, 5),
+        cor_estimate=(0, 0),
         refine=None,
         pmcc=False,
         normalize=True,
@@ -1005,7 +999,7 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
                 z1p /= z1p.mean()
 
             for k in range(cc.shape[0]):
-                for l in range(cc.shape[1]):
+                for l in range(cc.shape[1]):  # noqa: E741
                     if pmcc:
                         z2p = z2[z2beg[0] - k : z2end[0] - k, z2beg[1] - l : z2end[1] - l].flatten()
                         std_z2p = z2p.std()
@@ -1096,7 +1090,7 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
         padding_mode=None,
         low_pass=0.01,
         high_pass=None,
-        maxsize=[5, 5],
+        maxsize=(5, 5),
         refine=None,
         pmcc=False,
         normalize=True,

nabu/estimation/cor_sino.py

@@ -21,12 +21,10 @@ class SinoCor:
     """
 
     def __init__(self, img_1, img_2, logger=None):
-        """ """
         self.logger = LoggerOrPrint(logger)
         self.sx = img_1.shape[1]
 
         # algorithm cannot accept odd number of projs. This is handled in the SinoCORFinder class.
-        nproj2 = img_1.shape[0]
 
         # extract upper and lower part of sinogram, flipping H the upper part
         self.data1 = img_1
@@ -141,9 +139,6 @@ class SinoCor:
         xc1 = self.rcor_abs - int(xwin / 2)
         xc2 = self.sx - self.rcor_abs - int(xwin / 2) - 1
 
-        im1 = self.data1[:, xc1 : xc1 + xwin]
-        im2 = self.data2[:, xc2 : xc2 + xwin]
-
         pixs = p_sign * (np.arange(neighborhood) - ng2)
         diff0 = 1000000000.0
 
@@ -289,9 +284,8 @@ class CenterOfRotationFourierAngles:
 
     def _px(self, detector_width, abs_pos, near_width, near_std, crop_around_cor, near_step):
         sym_range = None
-        if abs_pos is not None:
-            if crop_around_cor:
-                sym_range = int(abs_pos - near_std * 2), int(abs_pos + near_std * 2)
+        if abs_pos is not None and crop_around_cor:
+            sym_range = int(abs_pos - near_std * 2), int(abs_pos + near_std * 2)
 
         window = near_width
         if sym_range is not None:

nabu/estimation/focus.py

@@ -159,10 +159,8 @@ class CameraFocus(CenterOfRotation):
 
         if self.verbose:
             self.logger.info(
-                "Fitted focus motor position:",
-                focus_pos,
-                "and corresponding image position:",
-                focus_ind,
+                "Fitted focus motor position: %s and corresponding image position: %s"
+                % (str(focus_pos), str(focus_ind))
             )
             f, ax = plt.subplots(1, 1)
             self._add_plot_window(f, ax=ax)
@@ -383,10 +381,8 @@ class CameraFocus(CenterOfRotation):
 
         if self.verbose:
             self.logger.info(
-                "Fitted focus motor position:",
-                focus_pos,
-                "and corresponding image position:",
-                focus_ind,
+                "Fitted focus motor position: %s and corresponding image position: %s"
+                % (str(focus_pos), str(focus_ind))
             )
             self.logger.info("Fitted tilts (to be divided by pixel size, and converted to deg): (v, h) %s" % tilts_vh)
             fig = plt.figure()