pytme 0.2.1__cp311-cp311-macosx_14_0_arm64.whl → 0.2.3__cp311-cp311-macosx_14_0_arm64.whl

{pytme-0.2.1.data → pytme-0.2.3.data}/scripts/match_template.py

@@ -1,5 +1,5 @@
 #!python
-""" CLI interface for basic pyTME template matching functions.
+""" CLI for basic pyTME template matching functions.
 
     Copyright (c) 2023 European Molecular Biology Laboratory
 
@@ -8,7 +8,6 @@
 import os
 import argparse
 import warnings
-import importlib.util
 from sys import exit
 from time import time
 from typing import Tuple
@@ -22,9 +21,7 @@ from tme.matching_utils import (
     get_rotation_matrices,
     get_rotations_around_vector,
     compute_parallelization_schedule,
-    euler_from_rotationmatrix,
     scramble_phases,
-    generate_tempfile_name,
     write_pickle,
 )
 from tme.matching_exhaustive import scan_subsets, MATCHING_EXHAUSTIVE_REGISTER
@@ -33,7 +30,7 @@ from tme.analyzer import (
     MaxScoreOverRotations,
     PeakCallerMaximumFilter,
 )
-from tme.backends import backend
+from tme.backends import backend as be
 from tme.preprocessing import Compose
 
 
@@ -52,7 +49,7 @@ def print_block(name: str, data: dict, label_width=20) -> None:
 
 def print_entry() -> None:
     width = 80
-    text = f" pyTME v{__version__} "
+    text = f" pytme v{__version__} "
     padding_total = width - len(text) - 2
     padding_left = padding_total // 2
     padding_right = padding_total - padding_left
@@ -101,7 +98,9 @@ def load_and_validate_mask(mask_target: "Density", mask_path: str, **kwargs):
                 f"Expected shape of {mask_path} was {mask_target.shape},"
                 f" got f{mask.shape}"
             )
-        if not np.allclose(mask.sampling_rate, mask_target.sampling_rate):
+        if not np.allclose(
+            np.round(mask.sampling_rate, 2), np.round(mask_target.sampling_rate, 2)
+        ):
             raise ValueError(
                 f"Expected sampling_rate of {mask_path} was {mask_target.sampling_rate}"
                 f", got f{mask.sampling_rate}"
@@ -109,50 +108,6 @@ def load_and_validate_mask(mask_target: "Density", mask_path: str, **kwargs):
     return mask
 
 
-def crop_data(data: Density, cutoff: float, data_mask: Density = None) -> bool:
-    """
-    Crop the provided data and mask to a smaller box based on a cutoff value.
-
-    Parameters
-    ----------
-    data : Density
-        The data that should be cropped.
-    cutoff : float
-        The threshold value to determine which parts of the data should be kept.
-    data_mask : Density, optional
-        A mask for the data that should be cropped.
-
-    Returns
-    -------
-    bool
-        Returns True if the data was adjusted (cropped), otherwise returns False.
-
-    Notes
-    -----
-    Cropping is performed in place.
-    """
-    if cutoff is None:
-        return False
-
-    box = data.trim_box(cutoff=cutoff)
-    box_mask = box
-    if data_mask is not None:
-        box_mask = data_mask.trim_box(cutoff=cutoff)
-    box = tuple(
-        slice(min(arr.start, mask.start), max(arr.stop, mask.stop))
-        for arr, mask in zip(box, box_mask)
-    )
-    if box == tuple(slice(0, x) for x in data.shape):
-        return False
-
-    data.adjust_box(box)
-
-    if data_mask:
-        data_mask.adjust_box(box)
-
-    return True
-
-
 def parse_rotation_logic(args, ndim):
     if args.angular_sampling is not None:
         rotations = get_rotation_matrices(
@@ -177,8 +132,52 @@ def parse_rotation_logic(args, ndim):
     return rotations
 
 
-# TODO: Think about whether wedge mask should also be added to target
-# For now leave it at the cost of incorrect upper bound on the scores
+def compute_schedule(
+    args,
+    target: Density,
+    matching_data: MatchingData,
+    callback_class,
+    pad_edges: bool = False,
+):
+    # User requested target padding
+    if args.pad_edges is True:
+        pad_edges = True
+    template_box = matching_data._output_template_shape
+    if not args.pad_fourier:
+        template_box = tuple(0 for _ in range(len(template_box)))
+
+    target_padding = tuple(0 for _ in range(len(template_box)))
+    if pad_edges:
+        target_padding = matching_data._output_template_shape
+
+    splits, schedule = compute_parallelization_schedule(
+        shape1=target.shape,
+        shape2=tuple(int(x) for x in template_box),
+        shape1_padding=tuple(int(x) for x in target_padding),
+        max_cores=args.cores,
+        max_ram=args.memory,
+        split_only_outer=args.use_gpu,
+        matching_method=args.score,
+        analyzer_method=callback_class.__name__,
+        backend=be._backend_name,
+        float_nbytes=be.datatype_bytes(be._float_dtype),
+        complex_nbytes=be.datatype_bytes(be._complex_dtype),
+        integer_nbytes=be.datatype_bytes(be._int_dtype),
+    )
+
+    if splits is None:
+        print(
+            "Found no suitable parallelization schedule. Consider increasing"
+            " available RAM or decreasing number of cores."
+        )
+        exit(-1)
+    n_splits = np.prod(list(splits.values()))
+    if pad_edges is False and n_splits > 1:
+        args.pad_edges = True
+        return compute_schedule(args, target, matching_data, callback_class, True)
+    return splits, schedule
+
+
 def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Compose]:
     from tme.preprocessing import LinearWhiteningFilter, BandPassFilter
     from tme.preprocessing.tilt_series import (
@@ -234,18 +233,23 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
                     weight_wedge=args.tilt_weighting == "angle",
                     create_continuous_wedge=create_continuous_wedge,
                 )
+                wedge_target = WedgeReconstructed(
+                    angles=tilt_angles,
+                    weight_wedge=False,
+                    create_continuous_wedge=create_continuous_wedge,
+                )
+                target_filter.append(wedge_target)
 
         wedge.opening_axis = args.wedge_axes[0]
         wedge.tilt_axis = args.wedge_axes[1]
         wedge.sampling_rate = template.sampling_rate
         template_filter.append(wedge)
         if not isinstance(wedge, WedgeReconstructed):
-            template_filter.append(
-                ReconstructFromTilt(
-                    reconstruction_filter=args.reconstruction_filter,
-                    interpolation_order=args.reconstruction_interpolation_order,
-                )
+            reconstruction_filter = ReconstructFromTilt(
+                reconstruction_filter=args.reconstruction_filter,
+                interpolation_order=args.reconstruction_interpolation_order,
             )
+            template_filter.append(reconstruction_filter)
 
     if args.ctf_file is not None or args.defocus is not None:
         from tme.preprocessing.tilt_series import CTF
@@ -273,7 +277,7 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
                 return_real_fourier=True,
             )
         ctf.sampling_rate = template.sampling_rate
-        ctf.flip_phase = not args.no_flip_phase
+        ctf.flip_phase = args.no_flip_phase
         ctf.amplitude_contrast = args.amplitude_contrast
         ctf.spherical_aberration = args.spherical_aberration
         ctf.acceleration_voltage = args.acceleration_voltage * 1e3
@@ -306,6 +310,12 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
             if highpass is not None:
                 highpass = np.max(np.divide(template.sampling_rate, highpass))
 
+        try:
+            if args.lowpass >= args.highpass:
+                warnings.warn("--lowpass should be smaller than --highpass.")
+        except Exception:
+            pass
+
         bandpass = BandPassFilter(
             use_gaussian=args.no_pass_smooth,
             lowpass=lowpass,
@@ -313,7 +323,9 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
             sampling_rate=template.sampling_rate,
         )
         template_filter.append(bandpass)
-        target_filter.append(bandpass)
+
+        if not args.no_filter_target:
+            target_filter.append(bandpass)
 
     if args.whiten_spectrum:
         whitening_filter = LinearWhiteningFilter()
@@ -335,7 +347,10 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
 
 
 def parse_args():
-    parser = argparse.ArgumentParser(description="Perform template matching.")
+    parser = argparse.ArgumentParser(
+        description="Perform template matching.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
 
     io_group = parser.add_argument_group("Input / Output")
     io_group.add_argument(
@@ -384,8 +399,7 @@ def parse_args():
         dest="invert_target_contrast",
         action="store_true",
         default=False,
-        help="Invert the target's contrast and rescale linearly between zero and one. "
-        "This option is intended for targets where templates to-be-matched have "
+        help="Invert the target's contrast for cases where templates to-be-matched have "
         "negative values, e.g. tomograms.",
     )
     io_group.add_argument(
@@ -405,13 +419,6 @@ def parse_args():
         choices=list(MATCHING_EXHAUSTIVE_REGISTER.keys()),
         help="Template matching scoring function.",
     )
-    scoring_group.add_argument(
-        "-p",
-        dest="peak_calling",
-        action="store_true",
-        default=False,
-        help="Perform peak calling instead of score aggregation.",
-    )
 
     angular_group = parser.add_argument_group("Angular Sampling")
     angular_exclusive = angular_group.add_mutually_exclusive_group(required=True)
@@ -445,7 +452,7 @@ def parse_args():
         type=check_positive,
         default=360.0,
         required=False,
-        help="Sampling angle along the z-axis of the cone. Defaults to 360.",
+        help="Sampling angle along the z-axis of the cone.",
     )
     angular_group.add_argument(
         "--axis_sampling",
@@ -513,8 +520,7 @@ def parse_args():
         required=False,
         type=float,
         default=0.85,
-        help="Fraction of available memory that can be used. Defaults to 0.85 and is "
-        "ignored if --ram is set",
+        help="Fraction of available memory to be used. Ignored if --ram is set.",
     )
     computation_group.add_argument(
         "--temp_directory",
@@ -522,7 +528,13 @@ def parse_args():
         default=None,
         help="Directory for temporary objects. Faster I/O improves runtime.",
     )
-
+    computation_group.add_argument(
+        "--backend",
+        dest="backend",
+        default=None,
+        choices=be.available_backends(),
+        help="[Expert] Overwrite default computation backend.",
+    )
     filter_group = parser.add_argument_group("Filters")
     filter_group.add_argument(
         "--lowpass",
@@ -552,9 +564,9 @@ def parse_args():
         dest="pass_format",
         type=str,
         required=False,
+        default="sampling_rate",
         choices=["sampling_rate", "voxel", "frequency"],
-        help="How values passed to --lowpass and --highpass should be interpreted. "
-        "By default, they are assumed to be in units of sampling rate, e.g. Ångstrom.",
+        help="How values passed to --lowpass and --highpass should be interpreted. ",
     )
     filter_group.add_argument(
         "--whiten_spectrum",
@@ -613,6 +625,13 @@ def parse_args():
         required=False,
         help="Analogous to --interpolation_order but for reconstruction.",
     )
+    filter_group.add_argument(
+        "--no_filter_target",
+        dest="no_filter_target",
+        action="store_true",
+        default=False,
+        help="Whether to not apply potential filters to the target.",
+    )
 
     ctf_group = parser.add_argument_group("Contrast Transfer Function")
     ctf_group.add_argument(
@@ -647,7 +666,7 @@ def parse_args():
         type=float,
         required=False,
         default=300,
-        help="Acceleration voltage in kV, defaults to 300.",
+        help="Acceleration voltage in kV.",
     )
     ctf_group.add_argument(
         "--spherical_aberration",
@@ -663,14 +682,14 @@ def parse_args():
         type=float,
         required=False,
         default=0.07,
-        help="Amplitude contrast, defaults to 0.07.",
+        help="Amplitude contrast.",
     )
     ctf_group.add_argument(
         "--no_flip_phase",
         dest="no_flip_phase",
         action="store_false",
         required=False,
-        help="Whether the phase of the computed CTF should not be flipped.",
+        help="Do not perform phase-flipping CTF correction.",
     )
     ctf_group.add_argument(
         "--correct_defocus_gradient",
@@ -682,22 +701,6 @@ def parse_args():
     )
 
     performance_group = parser.add_argument_group("Performance")
-    performance_group.add_argument(
-        "--cutoff_target",
-        dest="cutoff_target",
-        type=float,
-        required=False,
-        default=None,
-        help="Target contour level (used for cropping).",
-    )
-    performance_group.add_argument(
-        "--cutoff_template",
-        dest="cutoff_template",
-        type=float,
-        required=False,
-        default=None,
-        help="Template contour level (used for cropping).",
-    )
     performance_group.add_argument(
         "--no_centering",
         dest="no_centering",
@@ -705,21 +708,28 @@ def parse_args():
         help="Assumes the template is already centered and omits centering.",
     )
     performance_group.add_argument(
-        "--no_edge_padding",
-        dest="no_edge_padding",
+        "--pad_edges",
+        dest="pad_edges",
         action="store_true",
         default=False,
-        help="Whether to not pad the edges of the target. Can be set if the target"
-        " has a well defined bounding box, e.g. a masked reconstruction.",
+        help="Whether to pad the edges of the target. Useful if the target does not "
+        "a well-defined bounding box. Defaults to True if splitting is required.",
     )
     performance_group.add_argument(
-        "--no_fourier_padding",
-        dest="no_fourier_padding",
+        "--pad_fourier",
+        dest="pad_fourier",
         action="store_true",
         default=False,
         help="Whether input arrays should not be zero-padded to full convolution shape "
-        "for numerical stability. When working with very large targets, e.g. tomograms, "
-        "it is safe to use this flag and benefit from the performance gain.",
+        "for numerical stability. Typically only useful when working with small data.",
+    )
+    performance_group.add_argument(
+        "--pad_filter",
+        dest="pad_filter",
+        action="store_true",
+        default=False,
+        help="Pads the filter to the shape of the target. Particularly useful for fast "
+        "oscilating filters to avoid aliasing effects.",
     )
     performance_group.add_argument(
         "--interpolation_order",
@@ -727,8 +737,7 @@ def parse_args():
         required=False,
         type=int,
         default=3,
-        help="Spline interpolation used for template rotations. If less than zero "
-        "no interpolation is performed.",
+        help="Spline interpolation used for rotations.",
     )
     performance_group.add_argument(
         "--use_mixed_precision",
@@ -755,7 +764,20 @@ def parse_args():
         default=0,
         help="Minimum template matching scores to consider for analysis.",
     )
-
+    analyzer_group.add_argument(
+        "-p",
+        dest="peak_calling",
+        action="store_true",
+        default=False,
+        help="Perform peak calling instead of score aggregation.",
+    )
+    analyzer_group.add_argument(
+        "--number_of_peaks",
+        dest="number_of_peaks",
+        action="store_true",
+        default=1000,
+        help="Number of peaks to call, 1000 by default.",
+    )
     args = parser.parse_args()
     args.version = __version__
 
@@ -770,9 +792,6 @@ def parse_args():
 
     os.environ["TMPDIR"] = args.temp_directory
 
-    args.pad_target_edges = not args.no_edge_padding
-    args.pad_fourier = not args.no_fourier_padding
-
     if args.score not in MATCHING_EXHAUSTIVE_REGISTER:
         raise ValueError(
             f"score has to be one of {', '.join(MATCHING_EXHAUSTIVE_REGISTER.keys())}"
@@ -827,7 +846,9 @@ def main():
         )
 
     if target.sampling_rate.size == template.sampling_rate.size:
-        if not np.allclose(target.sampling_rate, template.sampling_rate):
+        if not np.allclose(
+            np.round(target.sampling_rate, 2), np.round(template.sampling_rate, 2)
+        ):
             print(
                 f"Resampling template to {target.sampling_rate}. "
                 "Consider providing a template with the same sampling rate as the target."
@@ -842,9 +863,6 @@ def main():
     )
 
     initial_shape = target.shape
-    is_cropped = crop_data(
-        data=target, data_mask=target_mask, cutoff=args.cutoff_target
-    )
     print_block(
         name="Target",
         data={
@@ -853,13 +871,6 @@ def main():
             "Final Shape": target.shape,
         },
     )
-    if is_cropped:
-        args.target = generate_tempfile_name(suffix=".mrc")
-        target.to_file(args.target)
-
-        if target_mask:
-            args.target_mask = generate_tempfile_name(suffix=".mrc")
-            target_mask.to_file(args.target_mask)
 
     if target_mask:
         print_block(
@@ -872,8 +883,6 @@ def main():
         )
 
     initial_shape = template.shape
-    _ = crop_data(data=template, data_mask=template_mask, cutoff=args.cutoff_template)
-
     translation = np.zeros(len(template.shape), dtype=np.float32)
     if not args.no_centering:
         template, translation = template.centered(0)
@@ -921,47 +930,62 @@ def main():
 
     if args.scramble_phases:
         template.data = scramble_phases(
-            template.data, noise_proportion=1.0, normalize_power=True
+            template.data, noise_proportion=1.0, normalize_power=False
         )
 
-    available_memory = backend.get_available_memory()
+    # Determine suitable backend for the selected operation
+    available_backends = be.available_backends()
+    if args.backend is not None:
+        req_backend = args.backend
+        if req_backend not in available_backends:
+            raise ValueError("Requested backend is not available.")
+        available_backends = [req_backend]
+
+    be_selection = ("numpyfftw", "pytorch", "jax", "mlx")
     if args.use_gpu:
         args.cores = len(args.gpu_indices)
-        has_torch = importlib.util.find_spec("torch") is not None
-        has_cupy = importlib.util.find_spec("cupy") is not None
+        be_selection = ("pytorch", "cupy", "jax")
+    if args.use_mixed_precision:
+        be_selection = tuple(x for x in be_selection if x in ("cupy", "numpyfftw"))
 
-        if not has_torch and not has_cupy:
-            raise ValueError(
-                "Found neither CuPy nor PyTorch installation. You need to install"
-                " either to enable GPU support."
+    available_backends = [x for x in available_backends if x in be_selection]
+    if args.peak_calling:
+        if "jax" in available_backends:
+            available_backends.remove("jax")
+        if args.use_gpu and "pytorch" in available_backends:
+            available_backends = ("pytorch",)
+
+    # dim_match = len(template.shape) == len(target.shape) <= 3
+    # if dim_match and args.use_gpu and "jax" in available_backends:
+    #     args.interpolation_order = 1
+    #     available_backends = ["jax"]
+
+    backend_preference = ("numpyfftw", "pytorch", "jax", "mlx")
+    if args.use_gpu:
+        backend_preference = ("cupy", "pytorch", "jax")
+    for pref in backend_preference:
+        if pref not in available_backends:
+            continue
+        be.change_backend(pref)
+        if pref == "pytorch":
+            be.change_backend(pref, device="cuda" if args.use_gpu else "cpu")
+
+        if args.use_mixed_precision:
+            be.change_backend(
+                backend_name=pref,
+                default_dtype=be._array_backend.float16,
+                complex_dtype=be._array_backend.complex64,
+                default_dtype_int=be._array_backend.int16,
             )
+        break
 
-        if args.peak_calling:
-            preferred_backend = "pytorch"
-            if not has_torch:
-                preferred_backend = "cupy"
-            backend.change_backend(backend_name=preferred_backend, device="cuda")
-        else:
-            preferred_backend = "cupy"
-            if not has_cupy:
-                preferred_backend = "pytorch"
-            backend.change_backend(backend_name=preferred_backend, device="cuda")
-            if args.use_mixed_precision and preferred_backend == "pytorch":
-                raise NotImplementedError(
-                    "pytorch backend does not yet support mixed precision."
-                    " Consider installing CuPy to enable this feature."
-                )
-            elif args.use_mixed_precision:
-                backend.change_backend(
-                    backend_name="cupy",
-                    default_dtype=backend._array_backend.float16,
-                    complex_dtype=backend._array_backend.complex64,
-                    default_dtype_int=backend._array_backend.int16,
-                )
-        available_memory = backend.get_available_memory() * args.cores
-        if preferred_backend == "pytorch" and args.interpolation_order == 3:
-            args.interpolation_order = 1
+    if pref == "pytorch" and args.interpolation_order == 3:
+        warnings.warn(
+            "Pytorch does not support --interpolation_order 3, setting it to 1."
+        )
+        args.interpolation_order = 1
 
+    available_memory = be.get_available_memory() * be.device_count()
     if args.memory is None:
         args.memory = int(args.memory_scaling * available_memory)
 
@@ -978,70 +1002,49 @@ def main():
         rotations=parse_rotation_logic(args=args, ndim=template.data.ndim),
     )
 
-    template_filter, target_filter = setup_filter(args, template, target)
-    matching_data.template_filter = template_filter
-    matching_data.target_filter = target_filter
-
-    template_box = matching_data._output_template_shape
-    if not args.pad_fourier:
-        template_box = np.ones(len(template_box), dtype=int)
-
-    target_padding = np.zeros(
-        (backend.size(matching_data._output_template_shape)), dtype=int
-    )
-    if args.pad_target_edges:
-        target_padding = matching_data._output_template_shape
-
-    splits, schedule = compute_parallelization_schedule(
-        shape1=target.shape,
-        shape2=tuple(int(x) for x in template_box),
-        shape1_padding=tuple(int(x) for x in target_padding),
-        max_cores=args.cores,
-        max_ram=args.memory,
-        split_only_outer=args.use_gpu,
-        matching_method=args.score,
-        analyzer_method=callback_class.__name__,
-        backend=backend._backend_name,
-        float_nbytes=backend.datatype_bytes(backend._float_dtype),
-        complex_nbytes=backend.datatype_bytes(backend._complex_dtype),
-        integer_nbytes=backend.datatype_bytes(backend._int_dtype),
+    matching_setup, matching_score = MATCHING_EXHAUSTIVE_REGISTER[args.score]
+    matching_data.template_filter, matching_data.target_filter = setup_filter(
+        args, template, target
     )
 
-    if splits is None:
-        print(
-            "Found no suitable parallelization schedule. Consider increasing"
-            " available RAM or decreasing number of cores."
-        )
-        exit(-1)
+    splits, schedule = compute_schedule(args, target, matching_data, callback_class)
 
-    matching_setup, matching_score = MATCHING_EXHAUSTIVE_REGISTER[args.score]
     n_splits = np.prod(list(splits.values()))
     target_split = ", ".join(
         [":".join([str(x) for x in axis]) for axis in splits.items()]
     )
     gpus_used = 0 if args.gpu_indices is None else len(args.gpu_indices)
     options = {
-        "CPU Cores": args.cores,
-        "Run on GPU": f"{args.use_gpu} [N={gpus_used}]",
-        "Use Mixed Precision": args.use_mixed_precision,
-        "Assigned Memory [MB]": f"{args.memory // 1e6} [out of {available_memory//1e6}]",
-        "Temporary Directory": args.temp_directory,
-        "Extend Fourier Grid": not args.no_fourier_padding,
-        "Extend Target Edges": not args.no_edge_padding,
-        "Interpolation Order": args.interpolation_order,
-        "Score": f"{args.score}",
-        "Setup Function": f"{get_func_fullname(matching_setup)}",
-        "Scoring Function": f"{get_func_fullname(matching_score)}",
         "Angular Sampling": f"{args.angular_sampling}"
         f" [{matching_data.rotations.shape[0]} rotations]",
+        "Center Template": not args.no_centering,
         "Scramble Template": args.scramble_phases,
-        "Target Splits": f"{target_split} [N={n_splits}]",
+        "Invert Contrast": args.invert_target_contrast,
+        "Extend Fourier Grid": args.pad_fourier,
+        "Extend Target Edges": args.pad_edges,
+        "Interpolation Order": args.interpolation_order,
+        "Setup Function": f"{get_func_fullname(matching_setup)}",
+        "Scoring Function": f"{get_func_fullname(matching_score)}",
     }
 
     print_block(
-        name="Template Matching Options",
+        name="Template Matching",
         data=options,
-        label_width=max(len(key) for key in options.keys()) + 2,
+        label_width=max(len(key) for key in options.keys()) + 3,
+    )
+
+    compute_options = {
+        "Backend": be._BACKEND_REGISTRY[be._backend_name],
+        "Compute Devices": f"CPU [{args.cores}], GPU [{gpus_used}]",
+        "Use Mixed Precision": args.use_mixed_precision,
+        "Assigned Memory [MB]": f"{args.memory // 1e6} [out of {available_memory//1e6}]",
+        "Temporary Directory": args.temp_directory,
+        "Target Splits": f"{target_split} [N={n_splits}]",
+    }
+    print_block(
+        name="Computation",
+        data=compute_options,
+        label_width=max(len(key) for key in options.keys()) + 3,
     )
 
     filter_args = {
@@ -1054,12 +1057,13 @@ def main():
         "Tilt Angles": args.tilt_angles,
         "Tilt Weighting": args.tilt_weighting,
         "Reconstruction Filter": args.reconstruction_filter,
+        "Extend Filter Grid": args.pad_filter,
     }
     if args.ctf_file is not None or args.defocus is not None:
         filter_args["CTF File"] = args.ctf_file
         filter_args["Defocus"] = args.defocus
         filter_args["Phase Shift"] = args.phase_shift
-        filter_args["No Flip Phase"] = args.no_flip_phase
+        filter_args["Flip Phase"] = args.no_flip_phase
         filter_args["Acceleration Voltage"] = args.acceleration_voltage
         filter_args["Spherical Aberration"] = args.spherical_aberration
         filter_args["Amplitude Contrast"] = args.amplitude_contrast
@@ -1070,20 +1074,19 @@ def main():
         print_block(
             name="Filters",
             data=filter_args,
-            label_width=max(len(key) for key in options.keys()) + 2,
+            label_width=max(len(key) for key in options.keys()) + 3,
         )
 
     analyzer_args = {
         "score_threshold": args.score_threshold,
-        "number_of_peaks": 1000,
-        "convolution_mode": "valid",
+        "number_of_peaks": args.number_of_peaks,
+        "min_distance": max(template.shape) // 3,
         "use_memmap": args.use_memmap,
     }
-    analyzer_args = {"Analyzer": callback_class, **analyzer_args}
     print_block(
-        name="Score Analysis Options",
-        data=analyzer_args,
-        label_width=max(len(key) for key in options.keys()) + 2,
+        name="Analyzer",
+        data={"Analyzer": callback_class, **analyzer_args},
+        label_width=max(len(key) for key in options.keys()) + 3,
     )
     print("\n" + "-" * 80)
 
@@ -1102,8 +1105,9 @@ def main():
         callback_class=callback_class,
         callback_class_args=analyzer_args,
         target_splits=splits,
-        pad_target_edges=args.pad_target_edges,
+        pad_target_edges=args.pad_edges,
         pad_fourier=args.pad_fourier,
+        pad_template_filter=args.pad_filter,
         interpolation_order=args.interpolation_order,
     )
 
@@ -1113,19 +1117,18 @@ def main():
             candidates[0] *= target_mask.data
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", category=UserWarning)
-            nbytes = backend.datatype_bytes(backend._float_dtype)
+            nbytes = be.datatype_bytes(be._float_dtype)
             dtype = np.float32 if nbytes == 4 else np.float16
             rot_dim = matching_data.rotations.shape[1]
             candidates[3] = {
-                x: euler_from_rotationmatrix(
-                    np.frombuffer(i, dtype=dtype).reshape(rot_dim, rot_dim)
-                )
+                x: np.frombuffer(i, dtype=dtype).reshape(rot_dim, rot_dim)
                 for i, x in candidates[3].items()
             }
     candidates.append((target.origin, template.origin, template.sampling_rate, args))
     write_pickle(data=candidates, filename=args.output)
 
     runtime = time() - start
+    print("\n" + "-" * 80)
     print(f"\nRuntime real: {runtime:.3f}s user: {(runtime * args.cores):.3f}s.")