pytme 0.1.6__cp311-cp311-macosx_14_0_arm64.whl → 0.1.8__cp311-cp311-macosx_14_0_arm64.whl

tme/matching_data.py

@@ -4,13 +4,14 @@
 
     Author: Valentin Maurer <valentin.maurer@embl-hamburg.de>
 """
-
+import warnings
 from typing import Tuple, List
 
 import numpy as np
 from numpy.typing import NDArray
 
 from . import Density
+from .types import ArrayLike
 from .backends import backend
 from .matching_utils import compute_full_convolution_index
 
@@ -80,7 +81,11 @@ class MatchingData:
         return arr
 
     def subset_array(
-        self, arr: NDArray, arr_slice: Tuple[slice], padding: NDArray
+        self,
+        arr: NDArray,
+        arr_slice: Tuple[slice],
+        padding: NDArray,
+        invert: bool = False,
     ) -> NDArray:
         """
         Extract a subset of the input array according to the given slice and
@@ -95,19 +100,22 @@ class MatchingData:
         padding : NDArray
             Padding values for each dimension. If the padding exceeds the array
             dimensions, the extra regions are filled with the mean of the array
-            values, otherwise, the
-            values in ``arr`` are used.
+            values, otherwise, the values in ``arr`` are used.
+        invert : bool, optional
+            Whether the returned array should be inverted and normalized to the interval
+            [0, 1]. If available, uses the metadata information of the Density object,
+            otherwise computes min and max on the extracted subset.
 
         Returns
         -------
         NDArray
             Subset of the input array with padding applied.
         """
-        padding = np.maximum(padding, 0)
+        padding = backend.to_numpy_array(padding)
+        padding = np.maximum(padding, 0).astype(int)
 
         slice_start = np.array([x.start for x in arr_slice], dtype=int)
         slice_stop = np.array([x.stop for x in arr_slice], dtype=int)
-        slice_shape = np.subtract(slice_stop, slice_start)
 
         padding = np.add(padding, np.mod(padding, 2))
         left_pad = right_pad = np.divide(padding, 2).astype(int)
@@ -117,20 +125,18 @@ class MatchingData:
             np.subtract(arr.shape, slice_stop), right_pad
         ).astype(int)
 
-        ret_shape = np.add(slice_shape, padding)
         arr_start = np.subtract(slice_start, data_voxels_left)
         arr_stop = np.add(slice_stop, data_voxels_right)
         arr_slice = tuple(slice(*pos) for pos in zip(arr_start, arr_stop))
         arr_mesh = self._slice_to_mesh(arr_slice, arr.shape)
 
-        subset_start = np.subtract(left_pad, data_voxels_left)
-        subset_stop = np.add(subset_start, np.subtract(arr_stop, arr_start))
-        subset_slice = tuple(slice(*prod) for prod in zip(subset_start, subset_stop))
-        subset_mesh = self._slice_to_mesh(subset_slice, ret_shape)
-
+        arr_min, arr_max = None, None
         if type(arr) == Density:
             if type(arr.data) == np.memmap:
-                arr = Density.from_file(arr.data.filename, subset=arr_slice).data
+                dens = Density.from_file(arr.data.filename, subset=arr_slice)
+                arr = dens.data
+                arr_min = dens.metadata.get("min", None)
+                arr_max = dens.metadata.get("max", None)
             else:
                 arr = np.asarray(arr.data[*arr_mesh])
         else:
@@ -139,10 +145,38 @@ class MatchingData:
                     arr.filename, mode="r", shape=arr.shape, dtype=arr.dtype
                 )
             arr = np.asarray(arr[*arr_mesh])
-        ret = np.full(
-            shape=np.add(slice_shape, padding), fill_value=arr.mean(), dtype=arr.dtype
+
+        def _warn_on_mismatch(
+            expectation: float, computation: float, name: str
+        ) -> float:
+            expectation, computation = float(expectation), float(computation)
+            if expectation is None:
+                expectation = computation
+
+            if abs(computation) > abs(expectation):
+                warnings.warn(
+                    f"Computed {name} value is more extreme than value specified in file"
+                    f" (|{computation}| > |{expectation}|). This may lead to issues"
+                    " with padding and contrast inversion."
+                )
+
+            return expectation
+
+        padding = tuple(
+            (left, right)
+            for left, right in zip(
+                np.subtract(left_pad, data_voxels_left),
+                np.subtract(right_pad, data_voxels_right),
+            )
         )
-        ret[*subset_mesh] = arr
+        ret = np.pad(arr, padding, mode="reflect")
+
+        if invert:
+            arr_min = _warn_on_mismatch(arr_min, arr.min(), "min")
+            arr_max = _warn_on_mismatch(arr_max, arr.max(), "max")
+
+            np.subtract(-ret, arr_min, out=ret)
+            np.divide(ret, arr_max - arr_min, out=ret)
 
         return ret
 
@@ -175,7 +209,7 @@ class MatchingData:
         MatchingData
             Newly allocated sliced class instance.
         """
-        target_shape = self.target.shape
+        target_shape = self._target.shape
         template_shape = self._template.shape
 
         if target_slice is None:
@@ -184,9 +218,9 @@ class MatchingData:
             template_slice = self._shape_to_slice(template_shape)
 
         if target_pad is None:
-            target_pad = np.zeros(len(self.target.shape), dtype=int)
+            target_pad = np.zeros(len(self._target.shape), dtype=int)
         if template_pad is None:
-            template_pad = np.zeros(len(self.target.shape), dtype=int)
+            template_pad = np.zeros(len(self._target.shape), dtype=int)
 
         indices = compute_full_convolution_index(
             outer_shape=self._target.shape,
@@ -196,12 +230,12 @@ class MatchingData:
         )
 
         target_subset = self.subset_array(
-            arr=self._target, arr_slice=target_slice, padding=target_pad
+            arr=self._target,
+            arr_slice=target_slice,
+            padding=target_pad,
+            invert=self._invert_target,
         )
-        if self._invert_target:
-            target_subset *= -1
-            target_min, target_max = target_subset.min(), target_subset.max()
-            target_subset = (target_subset - target_min) / (target_max - target_min)
+
         template_subset = self.subset_array(
             arr=self._template,
             arr_slice=template_slice,
@@ -230,6 +264,15 @@ class MatchingData:
                 padding=template_pad,
             )
 
+        target_dims, template_dims = None, None
+        if hasattr(self, "_target_dims"):
+            target_dims = self._target_dims
+
+        if hasattr(self, "_template_dims"):
+            template_dims = self._template_dims
+
+        ret._set_batch_dimension(target_dims=target_dims, template_dims=template_dims)
+
         return ret
 
     def to_backend(self) -> None:
@@ -244,20 +287,223 @@ class MatchingData:
         self._default_dtype = backend._default_dtype
         self._complex_dtype = backend._complex_dtype
 
+    def _set_batch_dimension(
+        self, target_dims: Tuple[int] = None, template_dims: Tuple[int] = None
+    ) -> None:
+        """
+        Sets the shapes of target and template for template matching considering
+        their corresponding batch dimensions.
+
+        Parameters
+        ----------
+        target_dims : Tuple[int], optional
+            A tuple of integers specifying the batch dimensions of the target. If None,
+            the target is assumed not to have batch dimensions.
+        template_dims : Tuple[int], optional
+            A tuple of integers specifying the batch dimensions of the template. If None,
+            the template is assumed not to have batch dimensions.
+
+        Notes
+        -----
+
+        If the target and template share a batch dimension, the target will
+        take precendence and the template dimension will be shifted to the right.
+        If target and template have the same dimension, but target specifies batch
+        dimensions, the leftmost template dimensions are assumed to be a collapse
+        dimension that operates on a measurement dimension.
+        """
+        self._target_dims = target_dims
+        self._template_dims = template_dims
+
+        target_ndim = len(self._target.shape)
+        self._is_target_batch, target_dims = self._compute_batch_dimension(
+            batch_dims=target_dims, ndim=target_ndim
+        )
+        template_ndim = len(self._template.shape)
+        self._is_template_batch, template_dims = self._compute_batch_dimension(
+            batch_dims=template_dims, ndim=template_ndim
+        )
+
+        batch_dims = len(target_dims) + len(template_dims)
+        target_measurement_dims = target_ndim - len(target_dims)
+
+        collapse_dims = max(
+            template_ndim - len(template_dims) - target_measurement_dims, 0
+        )
+
+        matching_dims = target_measurement_dims + batch_dims
+
+        target_shape = backend.full(
+            shape=(matching_dims,), fill_value=1, dtype=backend._default_dtype_int
+        )
+        template_shape = backend.full(
+            shape=(matching_dims,), fill_value=1, dtype=backend._default_dtype_int
+        )
+        batch_mask = backend.full(shape=(matching_dims,), fill_value=1, dtype=bool)
+
+        target_index, template_index = 0, 0
+        for k in range(matching_dims):
+            target_dim = k - target_index
+            template_dim = k - template_index
+
+            if target_dim in target_dims:
+                target_shape[k] = self._target.shape[target_dim]
+                if target_index == len(template_dims) and collapse_dims > 0:
+                    template_shape[k] = self._template.shape[template_dim]
+                    collapse_dims -= 1
+                template_index += 1
+                continue
+
+            if template_dim in template_dims:
+                template_shape[k] = self._template.shape[template_dim]
+                target_index += 1
+                continue
+
+            batch_mask[k] = 0
+            if target_dim < target_ndim:
+                target_shape[k] = self._target.shape[target_dim]
+            if template_dim < template_ndim:
+                template_shape[k] = self._template.shape[template_dim]
+
+        self._output_target_shape = target_shape
+        self._output_template_shape = template_shape
+        self._batch_mask = batch_mask
+
+    @staticmethod
+    def _compute_batch_dimension(
+        batch_dims: Tuple[int], ndim: int
+    ) -> Tuple[ArrayLike, Tuple]:
+        """
+        Computes a mask for the batch dimensions and the validated batch dimensions.
+
+        Parameters
+        ----------
+        batch_dims : Tuple[int]
+            A tuple of integers representing the batch dimensions.
+        ndim : int
+            The number of dimensions of the array.
+
+        Returns
+        -------
+        Tuple[ArrayLike, Tuple]
+            A tuple containing the mask (as an ArrayLike) and the validated batch dimensions.
+
+        Raises
+        ------
+        ValueError
+            If any dimension in batch_dims is not less than ndim.
+        """
+        mask = backend.zeros(ndim, dtype=bool)
+        if batch_dims is None:
+            return mask, ()
+
+        if isinstance(batch_dims, int):
+            batch_dims = (batch_dims,)
+
+        for dim in batch_dims:
+            if dim < ndim:
+                mask[dim] = 1
+                continue
+            raise ValueError(f"Batch indices needs to be < {ndim}, got {dim}.")
+
+        return mask, batch_dims
+
+    def target_padding(self, pad_target: bool = False) -> ArrayLike:
+        """
+        Computes padding for the target based on the template's shape.
+
+        Parameters
+        ----------
+        pad_target : bool, default False
+            If True, computes the padding required for the target. If False,
+            an array of zeros is returned.
+
+        Returns
+        -------
+        ArrayLike
+            An array indicating the padding for each dimension of the target.
+        """
+        target_padding = backend.zeros(
+            len(self.target.shape), dtype=backend._default_dtype_int
+        )
+
+        if pad_target:
+            backend.subtract(
+                self._template.shape,
+                backend.mod(self._template.shape, 2),
+                out=target_padding,
+            )
+            if hasattr(self, "_is_target_batch"):
+                target_padding[self._is_target_batch] = 0
+
+        return target_padding
+
+    def fourier_padding(
+        self, pad_fourier: bool = False
+    ) -> Tuple[ArrayLike, ArrayLike, ArrayLike]:
+        """
+        Computes an efficient shape for the forward Fourier transform, the
+        corresponding shape of the real-valued FFT, and the associated
+        translation shift.
+
+        Parameters
+        ----------
+        pad_fourier : bool, default False
+            If true, returns the shape of the full-convolution defined as sum of target
+            shape and template shape minus one. By default, returns unpadded transform.
+
+        Returns
+        -------
+        Tuple[ArrayLike, ArrayLike, ArrayLike]
+            A tuple containing the calculated fast shape, fast Fourier transform shape,
+            and the Fourier shift values, respectively.
+        """
+        template_shape = self._template.shape
+        if hasattr(self, "_output_template_shape"):
+            template_shape = self._output_template_shape
+        template_shape = backend.to_backend_array(template_shape)
+
+        target_shape = self._target.shape
+        if hasattr(self, "_output_target_shape"):
+            target_shape = self._output_target_shape
+        target_shape = backend.to_backend_array(target_shape)
+
+        fourier_pad = backend.to_backend_array(template_shape)
+        fourier_shift = backend.zeros(len(fourier_pad))
+
+        if not pad_fourier:
+            fourier_pad = backend.full(shape=len(fourier_pad), fill_value=1, dtype=int)
+
+        fourier_pad = backend.to_backend_array(fourier_pad)
+        if hasattr(self, "_batch_mask"):
+            batch_mask = backend.to_backend_array(self._batch_mask)
+            fourier_pad[batch_mask] = 1
+
+        ret = backend.compute_convolution_shapes(target_shape, fourier_pad)
+        convolution_shape, fast_shape, fast_ft_shape = ret
+        if not pad_fourier:
+            fourier_shift = 1 - backend.astype(backend.divide(template_shape, 2), int)
+            fourier_shift -= backend.mod(template_shape, 2)
+            shape_diff = backend.subtract(fast_shape, convolution_shape)
+            shape_diff = backend.astype(backend.divide(shape_diff, 2), int)
+            backend.add(fourier_shift, shape_diff, out=fourier_shift)
+
+        return fast_shape, fast_ft_shape, fourier_shift
+
     @property
     def rotations(self):
-        """Return rotation matrices used for fitting."""
+        """Return stored rotation matrices.."""
         return self._rotations
 
     @rotations.setter
     def rotations(self, rotations: NDArray):
         """
-        Set and reshape the rotation matrices for fitting.
+        Set and reshape the rotation matrices for template matching.
 
         Parameters
         ----------
         rotations : NDArray
-            Rotations in shape (3 x 3), (1 x 3 x 3), or (n x k x k).
+            Rotations in shape (k x k), or (n x k x k).
         """
         if rotations.__class__ != np.ndarray:
             raise ValueError("Rotation set has to be of type numpy ndarray.")
@@ -273,14 +519,14 @@ class MatchingData:
     @property
     def target(self):
         """Returns the target NDArray."""
-        if type(self._target) == Density:
+        if isinstance(self._target, Density):
             return self._target.data
         return self._target
 
     @property
     def template(self):
         """Returns the reversed template NDArray."""
-        if type(self._template) == Density:
+        if isinstance(self._template, Density):
             return backend.reverse(self._template.data)
         return backend.reverse(self._template)
 
@@ -309,7 +555,7 @@ class MatchingData:
     @property
     def target_mask(self):
         """Returns the target mask NDArray."""
-        if type(self._target_mask) == Density:
+        if isinstance(self._target_mask, Density):
             return self._target_mask.data
         return self._target_mask
 
@@ -324,6 +570,7 @@ class MatchingData:
             self._target_mask = mask
             self._targetmaskshape = self._target_mask.shape[::-1]
             return None
+
         self._target_mask = mask.astype(self._default_dtype, copy=False)
         self._targetmaskshape = self._target_mask.shape
 
@@ -337,7 +584,7 @@ class MatchingData:
         template : NDArray
             Array to set as the template.
         """
-        if type(self._template_mask) == Density:
+        if isinstance(self._template_mask, Density):
             return backend.reverse(self._template_mask.data)
         return backend.reverse(self._template_mask)
 

tme/matching_exhaustive.py

@@ -308,6 +308,49 @@ def cam_setup(**kwargs):
     return corr_setup(**kwargs)
 
 
+def _normalize_under_mask(template: NDArray, mask: NDArray, mask_intensity) -> None:
+    """
+    Standardizes the values in in template by subtracting the mean and dividing by the
+    standard deviation based on the elements in mask. Subsequently, the template is
+    multiplied by the mask.
+
+    Parameters
+    ----------
+    template : NDArray
+        The data array to be normalized. This array is modified in-place.
+    mask : NDArray
+        A boolean array of the same shape as `template`. True values indicate the positions in `template`
+        to consider for normalization.
+    mask_intensity : float
+        Mask intensity used to compute expectations.
+
+    References
+    ----------
+    .. [1]  T. Hrabe, Y. Chen, S. Pfeffer, L. Kuhn Cuellar, A.-V. Mangold,
+            and F. Förster, J. Struct. Biol. 178, 177 (2012).
+    .. [2]  M. L. Chaillet, G. van der Schot, I. Gubins, S. Roet,
+            R. C. Veltkamp, and F. Förster, Int. J. Mol. Sci. 24,
+            13375 (2023)
+
+    Returns
+    -------
+    None
+        This function modifies `template` in-place and does not return any value.
+    """
+    masked_mean = backend.sum(backend.multiply(template, mask))
+    masked_mean = backend.divide(masked_mean, mask_intensity)
+    masked_std = backend.sum(backend.multiply(backend.square(template), mask))
+    masked_std = backend.subtract(
+        masked_std / mask_intensity, backend.square(masked_mean)
+    )
+    masked_std = backend.sqrt(backend.maximum(masked_std, 0))
+
+    backend.subtract(template, masked_mean, out=template)
+    backend.divide(template, masked_std, out=template)
+    backend.multiply(template, mask, out=template)
+    return None
+
+
 def flc_setup(
     rfftn: Callable,
     irfftn: Callable,
@@ -359,7 +402,8 @@ def flc_setup(
     ft_target = backend.preallocate_array(fast_ft_shape, complex_dtype)
     ft_target2 = backend.preallocate_array(fast_ft_shape, complex_dtype)
     rfftn(target_pad, ft_target)
-    rfftn(backend.square(target_pad), ft_target2)
+    backend.square(target_pad, out=target_pad)
+    rfftn(target_pad, ft_target2)
 
     # Convert arrays used in subsequent fitting to SharedMemory objects
     ft_target = backend.arr_to_sharedarr(
@@ -369,13 +413,9 @@ def flc_setup(
         arr=ft_target2, shared_memory_handler=shared_memory_handler
     )
 
-    template_mask = template_mask > 0
-    template_mean = backend.mean(template[template_mask])
-    template_std = backend.std(template[template_mask])
-    template_mask = backend.astype(template_mask, real_dtype)
-
-    backend.divide(template - template_mean, template_std, out=template)
-    backend.multiply(template, template_mask, out=template)
+    _normalize_under_mask(
+        template=template, mask=template_mask, mask_intensity=backend.sum(template_mask)
+    )
 
     template_buffer = backend.arr_to_sharedarr(
         arr=template, shared_memory_handler=shared_memory_handler
@@ -455,7 +495,6 @@ def flcSphericalMask_setup(
     :py:meth:`corr_scoring`
     """
     target_pad = backend.topleft_pad(target, fast_shape)
-    template_mask_pad = backend.topleft_pad(template_mask, fast_shape)
 
     # Target and squared target window sums
     ft_target = backend.preallocate_array(fast_ft_shape, complex_dtype)
@@ -467,16 +506,17 @@ def flcSphericalMask_setup(
     numerator2 = backend.preallocate_array(1, real_dtype)
 
     eps = backend.eps(real_dtype)
-    n_observations = backend.sum(template_mask_pad > np.exp(-2))
+    n_observations = backend.sum(template_mask)
+
+    template_mask_pad = backend.topleft_pad(template_mask, fast_shape)
     rfftn(template_mask_pad, ft_template_mask)
 
-    # Variance part denominator
+    # Denominator E(X^2) - E(X)^2
     rfftn(backend.square(target_pad), ft_target)
     backend.multiply(ft_target, ft_template_mask, out=ft_temp)
     irfftn(ft_temp, temp2)
     backend.divide(temp2, n_observations, out=temp2)
 
-    # Mean part denominator
     rfftn(target_pad, ft_target)
     backend.multiply(ft_target, ft_template_mask, out=ft_temp)
     irfftn(ft_temp, temp)
@@ -495,14 +535,10 @@ def flcSphericalMask_setup(
     backend.fill(temp2, 0)
     temp2[nonzero_indices] = 1 / temp[nonzero_indices]
 
-    template_mask = template_mask > np.exp(-2)
-    template_mean = backend.mean(template[template_mask])
-    template_std = backend.std(template[template_mask])
-
-    template = backend.divide(backend.subtract(template, template_mean), template_std)
-    backend.multiply(template, template_mask, out=template)
+    _normalize_under_mask(
+        template=template, mask=template_mask, mask_intensity=backend.sum(template_mask)
+    )
 
-    # Convert arrays used in subsequent fitting to SharedMemory objects
     template_buffer = backend.arr_to_sharedarr(
         arr=template, shared_memory_handler=shared_memory_handler
     )
@@ -773,6 +809,7 @@ def corr_scoring(
     fourier_shift = callback_class_args.get("fourier_shift", backend.zeros(arr.ndim))
     fourier_shift_scores = backend.sum(fourier_shift != 0) != 0
 
+    template_sum = backend.sum(template)
     for index in range(rotations.shape[0]):
         rotation = rotations[index]
         backend.fill(arr, 0)
@@ -783,6 +820,9 @@ def corr_scoring(
             use_geometric_center=False,
             order=interpolation_order,
         )
+        rotation_norm = template_sum / backend.sum(arr)
+        backend.multiply(arr, rotation_norm, out=arr)
+
         rfftn(arr, ft_temp)
         template_filter_func(ft_temp, template_filter, out=ft_temp)
 
@@ -905,6 +945,7 @@ def flc_scoring(
     fourier_shift = callback_class_args.get("fourier_shift", backend.zeros(arr.ndim))
     fourier_shift_scores = backend.sum(fourier_shift != 0) != 0
 
+    unpadded_slice = tuple(slice(0, stop) for stop in template.shape)
     for index in range(rotations.shape[0]):
         rotation = rotations[index]
         backend.fill(arr, 0)
@@ -918,8 +959,15 @@ def flc_scoring(
             use_geometric_center=False,
             order=interpolation_order,
         )
+        # Given the amount of FFTs, might aswell normalize properly
         n_observations = backend.sum(temp)
 
+        _normalize_under_mask(
+            template=arr[unpadded_slice],
+            mask=temp[unpadded_slice],
+            mask_intensity=n_observations,
+        )
+
         rfftn(temp, ft_temp)
 
         backend.multiply(ft_target, ft_temp, out=ft_denom)
@@ -1244,7 +1292,7 @@ def scan(
         The merged results from callback_class if provided otherwise None.
     """
     shape_diff = backend.subtract(
-        matching_data.target.shape, matching_data._template.shape
+        matching_data._target.shape, matching_data._template.shape
     )
     if backend.sum(shape_diff < 0) and not pad_fourier:
         warnings.warn(
@@ -1254,22 +1302,10 @@ def scan(
         )
 
     matching_data.to_backend()
-    fourier_pad = matching_data.template.shape
-    fourier_shift = backend.zeros(len(fourier_pad))
-    if not pad_fourier:
-        fourier_pad = backend.full(shape=fourier_shift.shape, fill_value=1, dtype=int)
 
-    convolution_shape, fast_shape, fast_ft_shape = backend.compute_convolution_shapes(
-        matching_data._target.shape, fourier_pad
+    fast_shape, fast_ft_shape, fourier_shift = matching_data.fourier_padding(
+        pad_fourier=pad_fourier
     )
-    if not pad_fourier:
-        fourier_shift = 1 - backend.astype(
-            backend.divide(matching_data._template.shape, 2), int
-        )
-        fourier_shift -= backend.mod(matching_data._template.shape, 2)
-        shape_diff = backend.subtract(fast_shape, convolution_shape)
-        shape_diff = backend.astype(backend.divide(shape_diff, 2), int)
-        backend.add(fourier_shift, shape_diff, out=fourier_shift)
 
     callback_class_args["fourier_shift"] = fourier_shift
     rfftn, irfftn = backend.build_fft(
@@ -1354,7 +1390,7 @@ def scan(
 
     setup["fftargs"] = fftargs.copy()
     convolution_mode = "same"
-    if backend.sum(matching_data._target_pad) > 0:
+    if backend.sum(backend.to_backend_array(matching_data._target_pad)) > 0:
         convolution_mode = "valid"
     setup["convolution_mode"] = convolution_mode
     setup["interpolation_order"] = interpolation_order
@@ -1459,17 +1495,13 @@ def scan_subsets(
         The merged results from callback_class if provided otherwise None.
     """
     target_splits = split_numpy_array_slices(
-        matching_data.target.shape, splits=target_splits
+        matching_data._target.shape, splits=target_splits
     )
     template_splits = split_numpy_array_slices(
         matching_data._template.shape, splits=template_splits
     )
+    target_pad = matching_data.target_padding(pad_target=pad_target_edges)
 
-    target_pad = np.zeros(len(matching_data.target.shape), dtype=int)
-    if pad_target_edges:
-        target_pad = np.subtract(
-            matching_data._template.shape, np.mod(matching_data._template.shape, 2)
-        )
     outer_jobs, inner_jobs = job_schedule
     results = Parallel(n_jobs=outer_jobs)(
         delayed(_run_inner)(