pytme 0.2.9__cp311-cp311-macosx_15_0_arm64.whl → 0.3.0__cp311-cp311-macosx_15_0_arm64.whl

pytme-0.2.9.data/scripts/match_template.py → scripts/match_template_filters.py

@@ -1,5 +1,5 @@
-#!python
-""" CLI for basic pyTME template matching functions.
+#!python3
+""" CLI interface for basic pyTME template matching functions.
 
     Copyright (c) 2023 European Molecular Biology Laboratory
 
@@ -12,34 +12,28 @@ from sys import exit
 from time import time
 from typing import Tuple
 from copy import deepcopy
-from os.path import exists
-from tempfile import gettempdir
+from os.path import abspath, exists
 
 import numpy as np
 
-from tme.backends import backend as be
 from tme import Density, __version__
-from tme.matching_utils import scramble_phases, write_pickle
-from tme.matching_exhaustive import scan_subsets, MATCHING_EXHAUSTIVE_REGISTER
-from tme.rotations import (
-    get_cone_rotations,
+from tme.matching_utils import (
     get_rotation_matrices,
+    get_rotations_around_vector,
+    compute_parallelization_schedule,
+    scramble_phases,
+    generate_tempfile_name,
+    write_pickle,
 )
+from tme.matching_exhaustive import scan_subsets, MATCHING_EXHAUSTIVE_REGISTER
 from tme.matching_data import MatchingData
 from tme.analyzer import (
     MaxScoreOverRotations,
     PeakCallerMaximumFilter,
 )
-from tme.filters import (
-    CTF,
-    Wedge,
-    Compose,
-    BandPassFilter,
-    WedgeReconstructed,
-    ReconstructFromTilt,
-    LinearWhiteningFilter,
-)
-
+from tme.backends import backend as be
+from tme.preprocessing import Compose
+from tme.scoring import flc_scoring2
 
 def get_func_fullname(func) -> str:
     """Returns the full name of the given function, including its module."""
@@ -50,8 +44,6 @@ def print_block(name: str, data: dict, label_width=20) -> None:
     """Prints a formatted block of information."""
     print(f"\n> {name}")
     for key, value in data.items():
-        if isinstance(value, np.ndarray):
-            value = value.shape
         formatted_value = str(value)
         print(f"  - {key + ':':<{label_width}} {formatted_value}")
 
@@ -107,9 +99,7 @@ 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(
-            np.round(mask.sampling_rate, 2), np.round(mask_target.sampling_rate, 2)
-        ):
+        if not np.allclose(mask.sampling_rate, mask_target.sampling_rate):
             raise ValueError(
                 f"Expected sampling_rate of {mask_path} was {mask_target.sampling_rate}"
                 f", got f{mask.sampling_rate}"
@@ -117,6 +107,50 @@ 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(
@@ -131,66 +165,34 @@ def parse_rotation_logic(args, ndim):
     if args.axis_sampling is None:
         args.axis_sampling = args.cone_sampling
 
-    rotations = get_cone_rotations(
+    rotations = get_rotations_around_vector(
         cone_angle=args.cone_angle,
         cone_sampling=args.cone_sampling,
         axis_angle=args.axis_angle,
         axis_sampling=args.axis_sampling,
         n_symmetry=args.axis_symmetry,
-        axis=[0 if i != args.cone_axis else 1 for i in range(ndim)],
-        reference=[0, 0, -1],
     )
     return rotations
 
 
-def compute_schedule(
-    args,
-    matching_data: MatchingData,
-    callback_class,
-    pad_edges: bool = False,
-):
-    # User requested target padding
-    if args.pad_edges is True:
-        pad_edges = True
-
-    splits, schedule = matching_data.computation_schedule(
-        matching_method=args.score,
-        analyzer_method=callback_class.__name__,
-        use_gpu=args.use_gpu,
-        pad_fourier=False,
-        pad_target_edges=pad_edges,
-        available_memory=args.memory,
-        max_cores=args.cores,
+# 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 setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Compose]:
+    from tme.preprocessing import LinearWhiteningFilter, BandPassFilter
+    from tme.preprocessing.tilt_series import (
+        Wedge,
+        WedgeReconstructed,
+        ReconstructFromTilt,
     )
 
-    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 len(matching_data._target_dim) == 0 and n_splits > 1:
-        args.pad_edges = True
-        return compute_schedule(args, matching_data, callback_class, True)
-    return splits, schedule
-
-
-def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Compose]:
-    needs_reconstruction = False
     template_filter, target_filter = [], []
     if args.tilt_angles is not None:
-        needs_reconstruction = args.tilt_weighting is not None
         try:
             wedge = Wedge.from_file(args.tilt_angles)
             wedge.weight_type = args.tilt_weighting
             if args.tilt_weighting in ("angle", None) and args.ctf_file is None:
                 wedge = WedgeReconstructed(
-                    angles=wedge.angles,
-                    weight_wedge=args.tilt_weighting == "angle",
-                    opening_axis=args.wedge_axes[0],
-                    tilt_axis=args.wedge_axes[1],
+                    angles=wedge.angles, weight_wedge=args.tilt_weighting == "angle"
                 )
         except FileNotFoundError:
             tilt_step, create_continuous_wedge = None, True
@@ -229,29 +231,23 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
                     angles=tilt_angles,
                     weight_wedge=args.tilt_weighting == "angle",
                     create_continuous_wedge=create_continuous_wedge,
-                    reconstruction_filter=args.reconstruction_filter,
-                    opening_axis=args.wedge_axes[0],
-                    tilt_axis=args.wedge_axes[1],
-                )
-                wedge_target = WedgeReconstructed(
-                    angles=(np.abs(np.min(tilt_angles)), np.abs(np.max(tilt_angles))),
-                    weight_wedge=False,
-                    create_continuous_wedge=True,
-                    opening_axis=args.wedge_axes[0],
-                    tilt_axis=args.wedge_axes[1],
                 )
-                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):
-            reconstruction_filter = ReconstructFromTilt(
-                reconstruction_filter=args.reconstruction_filter,
-                interpolation_order=args.reconstruction_interpolation_order,
+            template_filter.append(
+                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
+
         needs_reconstruction = True
         if args.ctf_file is not None:
             ctf = CTF.from_file(args.ctf_file)
@@ -263,7 +259,6 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
                     "per micrograph."
                 )
             ctf.angles = wedge.angles
-            ctf.no_reconstruction = False
             ctf.opening_axis, ctf.tilt_axis = args.wedge_axes
         else:
             needs_reconstruction = False
@@ -322,13 +317,18 @@ 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()
         template_filter.append(whitening_filter)
         target_filter.append(whitening_filter)
 
+    needs_reconstruction = any(
+        [isinstance(t, ReconstructFromTilt) for t in template_filter]
+    )
     if needs_reconstruction and args.reconstruction_filter is None:
         warnings.warn(
             "Consider using a --reconstruction_filter such as 'ramp' to avoid artifacts."
@@ -336,8 +336,6 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
 
     template_filter = Compose(template_filter) if len(template_filter) else None
     target_filter = Compose(target_filter) if len(target_filter) else None
-    if args.no_filter_target:
-        target_filter = None
 
     return template_filter, target_filter
 
@@ -345,7 +343,7 @@ def setup_filter(args, template: Density, target: Density) -> Tuple[Compose, Com
 def parse_args():
     parser = argparse.ArgumentParser(
         description="Perform template matching.",
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
     )
 
     io_group = parser.add_argument_group("Input / Output")
@@ -395,7 +393,8 @@ def parse_args():
         dest="invert_target_contrast",
         action="store_true",
         default=False,
-        help="Invert the target's contrast for cases where templates to-be-matched have "
+        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 "
         "negative values, e.g. tomograms.",
     )
     io_group.add_argument(
@@ -435,19 +434,6 @@ def parse_args():
         help="Half-angle of the cone to be sampled in degrees. Allows to sample a "
         "narrow interval around a known orientation, e.g. for surface oversampling.",
     )
-    angular_group.add_argument(
-        "--cone_axis",
-        dest="cone_axis",
-        type=check_positive,
-        default=2,
-        help="Principal axis to build cone around.",
-    )
-    angular_group.add_argument(
-        "--invert_cone",
-        dest="invert_cone",
-        action="store_true",
-        help="Invert cone handedness.",
-    )
     angular_group.add_argument(
         "--cone_sampling",
         dest="cone_sampling",
@@ -529,7 +515,7 @@ def parse_args():
         required=False,
         type=float,
         default=0.85,
-        help="Fraction of available memory to be used. Ignored if --ram is set.",
+        help="Fraction of available memory to be used. Ignored if --ram is set."
     )
     computation_group.add_argument(
         "--temp_directory",
@@ -544,6 +530,7 @@ def parse_args():
         choices=be.available_backends(),
         help="[Expert] Overwrite default computation backend.",
     )
+
     filter_group = parser.add_argument_group("Filters")
     filter_group.add_argument(
         "--lowpass",
@@ -590,8 +577,8 @@ def parse_args():
         type=str,
         required=False,
         default=None,
-        help="Indices of wedge opening and tilt axis, e.g. '2,0' for a wedge open "
-        "in z and tilted over the x-axis.",
+        help="Indices of wedge opening and tilt axis, e.g. 0,2 for a wedge that is open "
+        "in z-direction and tilted over the x axis.",
     )
     filter_group.add_argument(
         "--tilt_angles",
@@ -698,7 +685,7 @@ def parse_args():
         dest="no_flip_phase",
         action="store_false",
         required=False,
-        help="Do not perform phase-flipping CTF correction.",
+        help="Perform phase-flipping CTF correction.",
     )
     ctf_group.add_argument(
         "--correct_defocus_gradient",
@@ -710,6 +697,22 @@ 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",
@@ -717,20 +720,30 @@ def parse_args():
         help="Assumes the template is already centered and omits centering.",
     )
     performance_group.add_argument(
-        "--pad_edges",
-        dest="pad_edges",
+        "--no_edge_padding",
+        dest="no_edge_padding",
+        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.",
+    )
+    performance_group.add_argument(
+        "--no_fourier_padding",
+        dest="no_fourier_padding",
         action="store_true",
         default=False,
-        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.",
+        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.",
     )
     performance_group.add_argument(
-        "--pad_filter",
-        dest="pad_filter",
+        "--no_filter_padding",
+        dest="no_filter_padding",
         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.",
+        help="Omits padding of optional template filters. Particularly effective when "
+        "the target is much larger than the template. However, for fast osciliating "
+        "filters setting this flag can introduce aliasing effects.",
     )
     performance_group.add_argument(
         "--interpolation_order",
@@ -777,7 +790,7 @@ def parse_args():
         dest="number_of_peaks",
         action="store_true",
         default=1000,
-        help="Number of peaks to call, 1000 by default.",
+        help="Number of peaks to call, 1000 by default..",
     )
     args = parser.parse_args()
     args.version = __version__
@@ -786,9 +799,16 @@ def parse_args():
         args.interpolation_order = None
 
     if args.temp_directory is None:
-        args.temp_directory = gettempdir()
+        default = abspath(".")
+        if os.environ.get("TMPDIR", None) is not None:
+            default = os.environ.get("TMPDIR")
+        args.temp_directory = default
 
     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())}"
@@ -837,15 +857,15 @@ def main():
     try:
         template = Density.from_file(args.template)
     except Exception:
+        drop = target.metadata.get("batch_dimension", ())
+        keep = [i not in drop for i in range(target.data.ndim)]
         template = Density.from_structure(
             filename_or_structure=args.template,
-            sampling_rate=target.sampling_rate,
+            sampling_rate=target.sampling_rate[keep],
         )
 
     if target.sampling_rate.size == template.sampling_rate.size:
-        if not np.allclose(
-            np.round(target.sampling_rate, 2), np.round(template.sampling_rate, 2)
-        ):
+        if not np.allclose(target.sampling_rate, template.sampling_rate):
             print(
                 f"Resampling template to {target.sampling_rate}. "
                 "Consider providing a template with the same sampling rate as the target."
@@ -860,6 +880,9 @@ 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={
@@ -868,6 +891,13 @@ 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(
@@ -880,6 +910,8 @@ 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)
@@ -927,7 +959,7 @@ def main():
 
     if args.scramble_phases:
         template.data = scramble_phases(
-            template.data, noise_proportion=1.0, normalize_power=False
+            template.data, noise_proportion=1.0, normalize_power=True
         )
 
     # Determine suitable backend for the selected operation
@@ -935,8 +967,10 @@ def main():
     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]
+            raise ValueError(
+                "Requested backend is not available."
+            )
+        available_backends = [req_backend,]
 
     be_selection = ("numpyfftw", "pytorch", "jax", "mlx")
     if args.use_gpu:
@@ -951,21 +985,23 @@ def main():
             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"]
+            if args.interpolation_order == 3:
+                raise NotImplementedError(
+                    "Pytorch does not support --interpolation_order 3, 1 is supported."
+                )
+    ndim = len(template.shape)
+    if len(target.shape) == ndim and ndim <= 3 and args.use_gpu:
+        available_backends = ["jax", ]
 
     backend_preference = ("numpyfftw", "pytorch", "jax", "mlx")
     if args.use_gpu:
-        backend_preference = ("cupy", "pytorch", "jax")
+        backend_preference = ("cupy", "jax", "pytorch")
     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")
+            be.change_backend(pref, device = "cuda" if args.use_gpu else "cpu")
 
         if args.use_mixed_precision:
             be.change_backend(
@@ -976,12 +1012,6 @@ def main():
             )
         break
 
-    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)
@@ -999,17 +1029,49 @@ def main():
         rotations=parse_rotation_logic(args=args, ndim=template.data.ndim),
     )
 
-    matching_setup, matching_score = MATCHING_EXHAUSTIVE_REGISTER[args.score]
-    matching_data.template_filter, matching_data.target_filter = setup_filter(
+    matching_data.template_filter, matching_data.target_filter  = setup_filter(
         args, template, target
     )
 
-    matching_data.set_matching_dimension(
-        target_dim=target.metadata.get("batch_dimension", None),
-        template_dim=template.metadata.get("batch_dimension", None),
+    target_dims = target.metadata.get("batch_dimension", None)
+    matching_data._set_matching_dimension(target_dims=target_dims, template_dims=None)
+    args.score = "FLC" if target_dims is not None else args.score
+    args.target_batch, args.template_batch = target_dims, None
+
+    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 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=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),
+        split_axes=target_dims,
     )
-    splits, schedule = compute_schedule(args, matching_data, callback_class)
 
+    if splits is None:
+        print(
+            "Found no suitable parallelization schedule. Consider increasing"
+            " available RAM or decreasing number of cores."
+        )
+        exit(-1)
+
+    matching_setup, matching_score = MATCHING_EXHAUSTIVE_REGISTER[args.score]
+    if target_dims is not None:
+        matching_score = flc_scoring2
     n_splits = np.prod(list(splits.values()))
     target_split = ", ".join(
         [":".join([str(x) for x in axis]) for axis in splits.items()]
@@ -1021,7 +1083,8 @@ def main():
         "Center Template": not args.no_centering,
         "Scramble Template": args.scramble_phases,
         "Invert Contrast": args.invert_target_contrast,
-        "Extend Target Edges": args.pad_edges,
+        "Extend Fourier Grid": not args.no_fourier_padding,
+        "Extend Target Edges": not args.no_edge_padding,
         "Interpolation Order": args.interpolation_order,
         "Setup Function": f"{get_func_fullname(matching_setup)}",
         "Scoring Function": f"{get_func_fullname(matching_score)}",
@@ -1034,8 +1097,8 @@ def main():
     )
 
     compute_options = {
-        "Backend": be._BACKEND_REGISTRY[be._backend_name],
-        "Compute Devices": f"CPU [{args.cores}], GPU [{gpus_used}]",
+        "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,
@@ -1057,7 +1120,6 @@ 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
@@ -1080,7 +1142,8 @@ def main():
     analyzer_args = {
         "score_threshold": args.score_threshold,
         "number_of_peaks": args.number_of_peaks,
-        "min_distance": max(template.shape) // 3,
+        "min_distance" : max(template.shape) // 2,
+        "min_boundary_distance" : max(template.shape) // 2,
         "use_memmap": args.use_memmap,
     }
     print_block(
@@ -1105,13 +1168,14 @@ def main():
         callback_class=callback_class,
         callback_class_args=analyzer_args,
         target_splits=splits,
-        pad_target_edges=args.pad_edges,
-        pad_template_filter=args.pad_filter,
+        pad_target_edges=args.pad_target_edges,
+        pad_fourier=args.pad_fourier,
+        pad_template_filter=not args.no_filter_padding,
         interpolation_order=args.interpolation_order,
     )
 
     candidates = list(candidates) if candidates is not None else []
-    if issubclass(callback_class, MaxScoreOverRotations):
+    if callback_class == MaxScoreOverRotations:
         if target_mask is not None and args.score != "MCC":
             candidates[0] *= target_mask.data
         with warnings.catch_warnings():
@@ -1123,6 +1187,7 @@ def main():
                 x: np.frombuffer(i, dtype=dtype).reshape(rot_dim, rot_dim)
                 for i, x in candidates[3].items()
             }
+    print(np.where(candidates[0] == candidates[0].max()), candidates[0].max())
     candidates.append((target.origin, template.origin, template.sampling_rate, args))
     write_pickle(data=candidates, filename=args.output)