nabu 2024.2.4__py3-none-any.whl → 2025.1.0.dev5__py3-none-any.whl

nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.2.4"
+__version__ = "2025.1.0-dev5"
 __nabu_modules__ = [
     "app",
     "cuda",

nabu/app/bootstrap_stitching.py

@@ -23,12 +23,14 @@ def guess_tomo_objects(my_str: str) -> tuple:
     try:
         # create_tomo_object_from_identifier will raise an exception is the string does not match an identifier
         return (Factory.create_tomo_object_from_identifier(my_str),)
-    except Exception:
+    except Exception as exc:
+        print("Error:", str(exc))
         pass
 
     try:
         volumes = guess_volumes(my_str)
-    except Exception:
+    except Exception as exc:
+        print("Error:", str(exc))
         pass
     else:
         if len(volumes) > 0:

nabu/app/cast_volume.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
 import argparse
 import os
 import sys
@@ -49,7 +46,7 @@ def main(argv=None):
 
     volume_help = f"""To define a volume you can either provide: \n
     * an url (recommanded way) - see details lower \n
-    * a path. For hdf5 and multitiff we expect a file path. For edf, tif and jp2k we expect a folder path. In this case we will try to deduce the Volume from it. \n 
+    * a path. For hdf5 and multitiff we expect a file path. For edf, tif and jp2k we expect a folder path. In this case we will try to deduce the Volume from it. \n
     url must be defined like: \n{_volume_url_helps}
     """
 
@@ -150,16 +147,13 @@ def main(argv=None):
             except Exception as e:
                 raise ValueError(f"Fail to build output volume from {options.output_volume}") from e
 
+            # ruff: noqa: SIM102
             if output_format is not None:
                 if not (
-                    isinstance(output_volume, EDFVolume)
-                    and output_format == "edf"
-                    or isinstance(output_format, HDF5Volume)
-                    and output_format == "hdf5"
-                    or isinstance(output_format, JP2KVolume)
-                    and output_format == "jp2"
-                    or isinstance(output_format, (TIFFVolume, MultiTIFFVolume))
-                    and output_format == "tiff"
+                    (isinstance(output_volume, EDFVolume) and output_format == "edf")
+                    or (isinstance(output_format, HDF5Volume) and output_format == "hdf5")
+                    or (isinstance(output_format, JP2KVolume) and output_format == "jp2")
+                    or (isinstance(output_format, (TIFFVolume, MultiTIFFVolume)) and output_format == "tiff")
                 ):
                     raise ValueError(
                         "Requested 'output_type' and output volume url are incoherent. 'output_type' is optional when url provided"
@@ -264,7 +258,7 @@ def main(argv=None):
     # update output volume from options
     output_volume.overwrite = options.overwrite
     if options.compression_ratios is not None:
-        output_volume.cratios = list([int(value) for value in convert_str_to_tuple(options.compression_ratios)])
+        output_volume.cratios = [int(value) for value in convert_str_to_tuple(options.compression_ratios)]
 
     # do volume casting
     cast_volume(

nabu/app/cli_configs.py

@@ -462,11 +462,6 @@ DiagToRotConfig = {
     "--diag_file": dict(
         required=True, help="The reconstruction file obtained by nabu-helical using the diag_zpro_run option", type=str
     ),
-    "--entry_name": dict(
-        required=False,
-        help="entry_name. Defauls is entry0000",
-        default="entry0000",
-    ),
     "--near": dict(
         required=False,
         help="This is a relative offset respect to the center of the radios. The cor will be searched around the provided value. If not given the optinal parameter original_scan must be the original nexus file; and the estimated core will be taken there. The netry_name parameter also must be provided in this case",

nabu/app/compare_volumes.py

@@ -61,7 +61,7 @@ def compare_volumes(fname1, fname2, h5_path, chunk_size, do_stats, stop_at_thres
     finally:
         f1.close()
         f2.close()
-        return result
+    return result
 
 
 def compare_volumes_cli():

nabu/app/composite_cor.py

@@ -1,14 +1,12 @@
-import logging
 import os
 import sys
 import numpy as np
 import re
 
 from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
-from nabu.pipeline.estimators import CompositeCOREstimator, estimate_cor
+from nabu.pipeline.estimators import CompositeCOREstimator
 from nabu.resources.nxflatfield import update_dataset_info_flats_darks
 from nabu.resources.utils import extract_parameters
-from nxtomo.application.nxtomo import NXtomo
 from .. import version
 from .cli_configs import CompositeCorConfig
 from .utils import parse_params_values
@@ -24,7 +22,7 @@ class NumpyArrayEncoder(json.JSONEncoder):
 
 
 def main(user_args=None):
-    "Application to extract with the composite cor finder the center of rotation for a scan or a series of scans"
+    """Application to extract with the composite cor finder the center of rotation for a scan or a series of scans"""
 
     if user_args is None:
         user_args = sys.argv[1:]

nabu/app/correct_rot.py

@@ -1,23 +1,15 @@
 from .. import version
-from os import environ
 
-import argparse
-import shutil
-import os
 import sys
-import re
-import h5py
 import numpy as np
 
 
-from ..resources.logger import LoggerOrPrint
 from .utils import parse_params_values
 from .cli_configs import CorrectRotConfig
 from silx.io.dictdump import h5todict
 
 from nxtomo.application.nxtomo import NXtomo
 
-import h5py
 from nabu.utils import DictToObj
 
 

nabu/app/diag_to_pix.py

@@ -31,7 +31,7 @@ from ..pipeline.estimators import oversample
   we must bring to the pixel size
 
   An example of collection is this :
-    
+
    |_____ diagnostics
    |               |  
                   |__ 0
@@ -72,10 +72,10 @@ def transform_images(diag, ovs):
 
 def detailed_merit(diag, shift):
     # res will become the merit summed over all the pairs theta, theta+180
-    res = 0.0
+    # res = 0.0
 
     # need to account for the weight also. So this will become the used weight for the pairs theta, theta+180
-    res_w = 0.0
+    # res_w = 0.0
 
     ## The following two variables are very important information to be collected.
     ## On the the z translation over a 360 turn
@@ -149,7 +149,7 @@ def build_total_merit_list(diag, oversample_factor, args):
     # calculats the merit at all the tested extra adjustment shifts.
 
     transform_images(diag, [oversample_factor, 1])
-    h_ima = diag.radios[0].shape[0]
+    # h_ima = diag.radios[0].shape[0]
     # search_radius_v = min(oversample_factor * args.search_radius_v, h_ima - 1)
     search_radius_v = oversample_factor * args.search_radius_v
 
@@ -233,7 +233,6 @@ def main(user_args=None):
     # For each key there is a sequence of radio, the corresponding sequence of weights map, the corresponding z translation, and angles
 
     zpix_mm = None
-    observed_oneturn_total_shift_zpix = None
 
     argument_list = [
         (DictToObj(h5todict(args.diag_file, os.path.join(diag_url, my_key))), oversample_factor, args)
@@ -244,7 +243,7 @@ def main(user_args=None):
     with Pool(processes=ncpus) as pool:
         all_res_plus_infos = pool.starmap(build_total_merit_list, argument_list)
 
-    observed_oneturn_total_shift_zpix, zpix_mm = None, None
+    _, zpix_mm = None, None
 
     # needs to flatten the result of pool.map
     for_all_pairs_detailed_merit_lists = []

nabu/app/diag_to_rot.py

@@ -31,7 +31,7 @@ from .cli_configs import DiagToRotConfig
   The collection is not done here. Here we exploit the result of a previous collection to deduce, looking at the correlations, the cor
 
   An example of collection is this :
-    
+
    |_____ diagnostics
    |               |  
                   |__ 0
@@ -68,7 +68,8 @@ def transform_images(diag, args):
     But beforehand it is beneficial to remove low spatial frequencies.
     And we do oversampling on the fly.
 
-    Parameters:
+    Parameters
+    ----------
        diag: object
          used member of diag are radios and weights
        args: object
@@ -196,7 +197,6 @@ def find_best_interpolating_line(args):
     z_b = np.nanmax(all_z_transl)
 
     best_error = np.nan
-    best_off_pair = None
 
     for index_ovlp_a in index_overlap_list_a:
         for index_ovlp_b in index_overlap_list_b:
@@ -204,7 +204,7 @@ def find_best_interpolating_line(args):
             indexes = (np.arange(all_energies.shape[0]))[~np.isnan(index_ovlps)].astype("i")
 
             index_ovlps = index_ovlps[~np.isnan(index_ovlps)]
-            index_ovlps = np.round_(index_ovlps).astype("i")
+            index_ovlps = np.round(index_ovlps).astype("i")
 
             diff_enes = all_res[(indexes, index_ovlps)]
             orig_enes = all_energies[(indexes, index_ovlps)]
@@ -313,13 +313,12 @@ def main(user_args=None):
             and this is not enough to do correlation + interpolation between sections
             """
             raise RuntimeError(message)
-    else:
-        if n_pairings_with_data < 1:
-            message = f""" The diagnostics collection has probably been run over a too thin section of the scan
+    elif n_pairings_with_data < 1:
+        message = f""" The diagnostics collection has probably been run over a too thin section of the scan
             or you scan does not allow to form pairs of theta, theta+360. I only found {n_pairings_with_data}
             pairings
             """
-            raise RuntimeError(message)
+        raise RuntimeError(message)
 
     # all_merits, all_energies, all_z_transls = zip( result_list )
 
@@ -345,15 +344,15 @@ def main(user_args=None):
 
 def do_height_by_height(args, overlap_list, all_diff, all_energies, all_z_transl):
     # now we find the best cor for each chunk, or nan if no overlap is found
-    z_a = np.min(all_z_transl)
-    z_b = np.max(all_z_transl)
+    # z_a = np.min(all_z_transl)
+    # z_b = np.max(all_z_transl)
 
     grouped_diff = {}
     grouped_energy = {}
 
     for diff, energy, z in zip(all_diff, all_energies, all_z_transl):
         found = z
-        for key in grouped_diff.keys():
+        for key in grouped_diff:
             if abs(key - z) < 2.0:  # these are in pixel units
                 found = key
                 break

nabu/app/multicor.py

@@ -51,6 +51,7 @@ def main():
     #####
     # Remove the first reconstructed file (not used here)
     last_file = list(pipeline.writer.writer.browse_data_files())[-1]
+    # ruff: noqa: SIM105, S110
     try:
         remove(last_file)
     except:
@@ -59,7 +60,6 @@ def main():
 
     cors = get_user_cors(args["cor"])
 
-    all_recs = []
     rec_instance = pipeline.reconstruction
 
     for cor in cors:

nabu/app/parse_reconstruction_log.py

@@ -1,3 +1,4 @@
+# ruff: noqa
 import numpy as np
 from os import path
 from datetime import datetime

nabu/app/prepare_weights_double.py

@@ -4,7 +4,6 @@ from scipy.special import erf  # pylint: disable=all
 import sys
 import os
 from scipy.ndimage import gaussian_filter
-from nxtomo.nxobject.nxdetector import ImageKey
 from nabu.resources.nxflatfield import update_dataset_info_flats_darks
 from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
 from ..io.reader import load_images_from_dataurl_dict
@@ -57,7 +56,7 @@ def main(argv=None):
     beam_profile = 0
     my_flats = load_images_from_dataurl_dict(dataset_info.flats)
 
-    for key, flat in my_flats.items():
+    for flat in my_flats.values():
         beam_profile += flat
     beam_profile = beam_profile / len(list(dataset_info.flats.keys()))
 

nabu/app/reconstruct_helical.py

@@ -1,7 +1,6 @@
 from .. import version
 from ..resources.utils import is_hdf5_extension
 from ..pipeline.config import parse_nabu_config_file
-from ..pipeline.config_validators import convert_to_int
 from .cli_configs import ReconstructConfig
 from .utils import parse_params_values
 from .reconstruct import update_reconstruction_start_end, get_log_file
@@ -39,7 +38,7 @@ def main_helical():
         try:
             from silx.math.fft.cufft import CUFFT
         except:  # can't catch narrower - cublasNotInitialized requires cublas !
-            CUFFT = None
+            CUFFT = None  # noqa: F841
     #
 
     logfile = get_log_file(args["logfile"], args["log_file"], forbidden=[args["input_file"]])
@@ -58,9 +57,6 @@ def main_helical():
 
     # Determine which reconstructor to use
     reconstructor_cls = None
-    phase_method = None
-    if "phase" in proc.processing_steps:
-        phase_method = proc.processing_options["phase"]["method"]
 
     # fix the reconstruction roi if not given
     if "reconstruction" in proc.processing_steps:

nabu/app/reduce_dark_flat.py

@@ -1,6 +1,4 @@
 import sys
-import logging
-import argparse
 from typing import Optional
 
 from nabu.app.cli_configs import ReduceDarkFlatConfig

nabu/app/rotate.py

@@ -7,6 +7,8 @@ from multiprocessing.pool import ThreadPool
 import numpy as np
 from tomoscan.io import HDF5File
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
+
+from nabu.utils import first_generator_item
 from ..io.utils import get_first_hdf5_entry
 from ..processing.rotation import Rotation
 from ..resources.logger import Logger, LoggerOrPrint
@@ -61,7 +63,7 @@ class HDF5ImagesStackRotation:
         self.output_file = output_file
         copy(self.input_file, output_file)
 
-        first_proj_url = self.dataset_info.projections[list(self.dataset_info.projections.keys())[0]]
+        first_proj_url = self.dataset_info.projections[first_generator_item(self.dataset_info.projections.keys())]
         self.data_path = first_proj_url.data_path()
         dirname, basename = posixpath.split(self.data_path)
         self._data_path_dirname = dirname

nabu/app/tests/test_reduce_dark_flat.py

@@ -9,7 +9,7 @@ except ImportError:
     from tomoscan.test.utils import NXtomoMockContext
 
 
-@pytest.fixture(scope="function")
+@pytest.fixture
 def hdf5_scan(tmp_path):
     """simple fixture to create a scan and provide it to another function"""
     test_dir = tmp_path / "my_hdf5_scan"
@@ -26,7 +26,7 @@ def hdf5_scan(tmp_path):
 
 @pytest.mark.parametrize("dark_method", (None, "first", "mean"))
 @pytest.mark.parametrize("flat_method", (None, "last", "median"))
-def test_reduce_dark_flat_hdf5(tmp_path, hdf5_scan, dark_method, flat_method):  # noqa F811
+def test_reduce_dark_flat_hdf5(tmp_path, hdf5_scan, dark_method, flat_method):
     """simply test output - processing is tested at tomoscan side"""
     # test with default url
     default_darks_path = os.path.join(hdf5_scan.path, hdf5_scan.get_dataset_basename() + "_darks.hdf5")

nabu/app/validator.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
 import argparse
 import sys
 import os
@@ -19,7 +16,7 @@ def get_scans(path, entries: str):
         if entries == "__all__":
             entries = NXtomoScan.get_valid_entries(path)
         for entry in entries:
-            res.append(NXtomoScan(path, entry))
+            res.append(NXtomoScan(path, entry))  # noqa: PERF401
     else:
         raise TypeError(f"{path} does not looks like a folder containing .EDF or a valid nexus file ")
     return res

nabu/cuda/convolution.py

@@ -1,4 +1,4 @@
-from ..processing.convolution_cuda import *
+from ..processing.convolution_cuda import *  # noqa: F403
 from ..utils import deprecation_warning
 
 deprecation_warning(

nabu/cuda/fft.py

@@ -1,4 +1,4 @@
-from ..processing.fft_cuda import *
+from ..processing.fft_cuda import *  # noqa: F403
 from ..utils import deprecation_warning
 
 deprecation_warning("nabu.cuda.fft has been moved to nabu.processing.fft_cuda", do_print=True, func_name="fft_cuda")

nabu/cuda/medfilt.py

@@ -1,4 +1,4 @@
-from ..processing.medfilt_cuda import *
+from ..processing.medfilt_cuda import *  # noqa: F403
 from ..utils import deprecation_warning
 
 deprecation_warning(

nabu/cuda/padding.py

@@ -1,4 +1,4 @@
-from ..processing.padding_cuda import *
+from ..processing.padding_cuda import *  # noqa: F403
 from ..utils import deprecation_warning
 
 deprecation_warning(

nabu/cuda/src/cone.cu

@@ -26,23 +26,33 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
 */
 
 
-static const unsigned int g_anglesPerWeightBlock = 16;
-static const unsigned int g_detBlockU = 32;
-static const unsigned int g_detBlockV = 32;
+// static const unsigned int g_anglesPerWeightBlock = 16;
+// static const unsigned int g_detBlockU = 32;
+// static const unsigned int g_detBlockV = 32;
 
 
 __global__ void devFDK_preweight(void* D_projData, unsigned int projPitch, unsigned int startAngle, unsigned int endAngle, float fSrcOrigin, float fDetOrigin, float fZShift, float fDetUSize, float fDetVSize, unsigned int iProjAngles, unsigned int iProjU, unsigned int iProjV)
 {
     float* projData = (float*)D_projData;
-    int angle = startAngle + blockIdx.y * g_anglesPerWeightBlock + threadIdx.y;
+
+    const uint angle = blockDim.y * blockIdx.y + threadIdx.y + startAngle;
+
     if (angle >= endAngle)
         return;
 
-    const int detectorU = (blockIdx.x%((iProjU+g_detBlockU-1)/g_detBlockU)) * g_detBlockU + threadIdx.x;
-    const int startDetectorV = (blockIdx.x/((iProjU+g_detBlockU-1)/g_detBlockU)) * g_detBlockV;
-    int endDetectorV = startDetectorV + g_detBlockV;
-    if (endDetectorV > iProjV)
-        endDetectorV = iProjV;
+    // Astra FDK kernel used this indexing (with the appropriate grid)
+    // const int detectorU = (blockIdx.x%((iProjU+g_detBlockU-1)/g_detBlockU)) * g_detBlockU + threadIdx.x;
+    // const int startDetectorV = (blockIdx.x/((iProjU+g_detBlockU-1)/g_detBlockU)) * g_detBlockV;
+    // Instead we choose a simpler scheme which does not assume pitch memory allocation
+
+    const uint detectorU = blockDim.x * blockIdx.x + threadIdx.x;
+    const int startDetectorV = 0;
+
+    int endDetectorV = iProjV; // startDetectorV + g_detBlockV;
+    // if (endDetectorV > iProjV)
+        // endDetectorV = iProjV;
+    if (detectorU >= iProjU) return;
+
 
     // We need the length of the central ray and the length of the ray(s) to
     // our detector pixel(s).

nabu/cuda/src/hierarchical_backproj.cu

@@ -6,6 +6,20 @@
     Please cite :
        reference to be added...
 
+
+
+    # Generalized Hierarchical Backprojection (GHBP)
+    # for fast tomographic reconstruction from ultra high resolution images at non-negligible fan angles.
+    #
+    # Authors/Contributions:
+    # - Jonas Graetz, Fraunhofer IIS / Universitat Wurzburg: Algorithm Design and original OpenCL/Python implementation.
+    # - Alessandro Mirone, ESRF: CUDA translation, ESRF / BM18 integration, testing <mirone@esrf.fr>
+    # - Pierre Paleo, ESRF: ESRF / BM18 integration, testing <pierre.paleo@esrf.fr>
+    #
+    # JG was funded by the German Federal Ministry of Education and Research (BMBF), grant 05E2019,
+    # funding the development of BM18 at ESRF in collaboration with the Fraunhofer Gesellschaft,
+    # the Julius-Maximilians-Universitat Wurzburg, and the University of Passau
+
 """
  */
 

nabu/cuda/utils.py

@@ -197,12 +197,12 @@ def cuarray_shape_dtype(cuarray):
 
 
 def get_shape_dtype(arr):
-    if isinstance(arr, garray.GPUArray) or isinstance(arr, np.ndarray):
+    if isinstance(arr, garray.GPUArray | np.ndarray):
         return arr.shape, arr.dtype
     elif isinstance(arr, cuda.Array):
         return cuarray_shape_dtype(arr)
     else:
-        raise ValueError("Unknown array type %s" % str(type(arr)))
+        raise TypeError("Unknown array type %s" % str(type(arr)))
 
 
 def copy_array(dst, src, check=False, src_dtype=None, dst_x_in_bytes=0, dst_y=0):

nabu/estimation/alignment.py

@@ -87,20 +87,20 @@ class AlignmentBase:
         if not len(shape_stack) == 3:
             raise ValueError(
                 "A stack of 2-dimensional images is required. Shape of stack: %s"
-                % (" ".join(("%d" % x for x in shape_stack)))
+                % (" ".join("%d" % x for x in shape_stack))
             )
         if not len(shape_pos) == 1:
             raise ValueError(
                 "Positions need to be a 1-dimensional array. Shape of the positions variable: %s"
-                % (" ".join(("%d" % x for x in shape_pos)))
+                % (" ".join("%d" % x for x in shape_pos))
             )
         if not shape_stack[0] == shape_pos[0]:
             raise ValueError(
                 "The same number of images and positions is required."
                 + " Shape of stack: %s, shape of positions variable: %s"
                 % (
-                    " ".join(("%d" % x for x in shape_stack)),
-                    " ".join(("%d" % x for x in shape_pos)),
+                    " ".join("%d" % x for x in shape_stack),
+                    " ".join("%d" % x for x in shape_pos),
                 )
             )
 
@@ -110,18 +110,18 @@ class AlignmentBase:
         shape_2 = np.squeeze(img_2).shape
         if not len(shape_1) == 2:
             raise ValueError(
-                "Images need to be 2-dimensional. Shape of image #1: %s" % (" ".join(("%d" % x for x in shape_1)))
+                "Images need to be 2-dimensional. Shape of image #1: %s" % (" ".join("%d" % x for x in shape_1))
             )
         if not len(shape_2) == 2:
             raise ValueError(
-                "Images need to be 2-dimensional. Shape of image #2: %s" % (" ".join(("%d" % x for x in shape_2)))
+                "Images need to be 2-dimensional. Shape of image #2: %s" % (" ".join("%d" % x for x in shape_2))
             )
         if not np.all(shape_1 == shape_2):
             raise ValueError(
                 "Images need to be of the same shape. Shape of image #1: %s, image #2: %s"
                 % (
-                    " ".join(("%d" % x for x in shape_1)),
-                    " ".join(("%d" % x for x in shape_2)),
+                    " ".join("%d" % x for x in shape_1),
+                    " ".join("%d" % x for x in shape_2),
                 )
             )
 
@@ -153,7 +153,7 @@ class AlignmentBase:
         if not (len(f_vals.shape) == 2):
             raise ValueError(
                 "The fitted values should form a 2-dimensional array. Array of shape: [%s] was given."
-                % (" ".join(("%d" % s for s in f_vals.shape)))
+                % (" ".join("%d" % s for s in f_vals.shape))
             )
         if fy is None:
             fy_half_size = (f_vals.shape[0] - 1) / 2
@@ -161,7 +161,7 @@ class AlignmentBase:
         elif not (len(fy.shape) == 1 and np.all(fy.size == f_vals.shape[0])):
             raise ValueError(
                 "Vertical coordinates should have the same length as values matrix. Sizes of fy: %d, f_vals: [%s]"
-                % (fy.size, " ".join(("%d" % s for s in f_vals.shape)))
+                % (fy.size, " ".join("%d" % s for s in f_vals.shape))
             )
         if fx is None:
             fx_half_size = (f_vals.shape[1] - 1) / 2
@@ -169,7 +169,7 @@ class AlignmentBase:
         elif not (len(fx.shape) == 1 and np.all(fx.size == f_vals.shape[1])):
             raise ValueError(
                 "Horizontal coordinates should have the same length as values matrix. Sizes of fx: %d, f_vals: [%s]"
-                % (fx.size, " ".join(("%d" % s for s in f_vals.shape)))
+                % (fx.size, " ".join("%d" % s for s in f_vals.shape))
             )
 
         fy, fx = np.meshgrid(fy, fx, indexing="ij")
@@ -190,14 +190,7 @@ class AlignmentBase:
         vertex_max_yx = [np.max(fy), np.max(fx)]
         if np.any(vertex_yx < vertex_min_yx) or np.any(vertex_yx > vertex_max_yx):
             raise ValueError(
-                "Fitted (y: {}, x: {}) positions are outside the input margins y: [{}, {}], and x: [{}, {}]".format(
-                    vertex_yx[0],
-                    vertex_yx[1],
-                    vertex_min_yx[0],
-                    vertex_max_yx[0],
-                    vertex_min_yx[1],
-                    vertex_max_yx[1],
-                )
+                f"Fitted (y: {vertex_yx[0]}, x: {vertex_yx[1]}) positions are outside the input margins y: [{vertex_min_yx[0]}, {vertex_max_yx[0]}], and x: [{vertex_min_yx[1]}, {vertex_max_yx[1]}]"
             )
         return vertex_yx
 
@@ -225,10 +218,10 @@ class AlignmentBase:
         float
             Estimated function max, according to the coordinates in fx.
         """
-        if not len(f_vals.shape) in (1, 2):
+        if len(f_vals.shape) not in (1, 2):
             raise ValueError(
                 "The fitted values should be either one or a collection of 1-dimensional arrays. Array of shape: [%s] was given."
-                % (" ".join(("%d" % s for s in f_vals.shape)))
+                % (" ".join("%d" % s for s in f_vals.shape))
             )
         num_vals = f_vals.shape[0]
 
@@ -264,16 +257,9 @@ class AlignmentBase:
         upper_bound_ok = vertex_x < vertex_max_x
         if not np.all(lower_bound_ok * upper_bound_ok):
             if len(f_vals.shape) == 1:
-                message = "Fitted position {} is outide the input margins [{}, {}]".format(
-                    vertex_x, vertex_min_x, vertex_max_x
-                )
+                message = f"Fitted position {vertex_x} is outide the input margins [{vertex_min_x}, {vertex_max_x}]"
             else:
-                message = "Fitted positions outside the input margins [{}, {}]: {} below and {} above".format(
-                    vertex_min_x,
-                    vertex_max_x,
-                    np.sum(1 - lower_bound_ok),
-                    np.sum(1 - upper_bound_ok),
-                )
+                message = f"Fitted positions outside the input margins [{vertex_min_x}, {vertex_max_x}]: {np.sum(1 - lower_bound_ok)} below and {np.sum(1 - upper_bound_ok)} above"
             raise ValueError(message)
         if return_vertex_val:
             vertex_val = coeffs[0, :] + vertex_x * coeffs[1, :] / 2
@@ -354,7 +340,7 @@ class AlignmentBase:
         if not (len(img_shape) == 2):
             raise ValueError(
                 "The input image should be either a 1 or 2-dimensional array. Array of shape: [%s] was given."
-                % (" ".join(("%d" % s for s in cc.shape)))
+                % (" ".join("%d" % s for s in cc.shape))
             )
         other_axis = (axis + 1) % 2
         # get pixel having the maximum value of the correlation array