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

tme/matching_optimization.py

@@ -15,96 +15,306 @@ from scipy.optimize import (
     differential_evolution,
     LinearConstraint,
     basinhopping,
+    minimize,
 )
-from scipy.ndimage import laplace
+from scipy.ndimage import laplace, map_coordinates
 from scipy.spatial import KDTree
 
+from .types import ArrayLike
+from .backends import backend
+from .matching_data import MatchingData
 from .matching_utils import rigid_transform, euler_to_rotationmatrix
+from .matching_exhaustive import normalize_under_mask
 
 
-class MatchCoordinatesToDensity(ABC):
+def _format_rigid_transform(x: Tuple[float]) -> Tuple[ArrayLike, ArrayLike]:
     """
-    A class to template match coordinate sets.
+    Returns a formated rigid transform definition.
 
     Parameters
     ----------
-    target_coordinates : NDArray
-        The coordinates of the target.
+    x : tuple of float
+        Even-length tuple where the first half represents translations and the
+        second half Euler angles in zyx convention for each dimension.
+
+    Returns
+    -------
+    Tuple[ArrayLike, ArrayLike]
+        Translation of length [d, ] and rotation matrix with dimension [d x d].
+    """
+    split = len(x) // 2
+    translation, angles = x[:split], x[split:]
+
+    translation = backend.to_backend_array(translation)
+    rotation_matrix = euler_to_rotationmatrix(backend.to_numpy_array(angles))
+    rotation_matrix = backend.to_backend_array(rotation_matrix)
+
+    return translation, rotation_matrix
+
+
+class _MatchDensityToDensity(ABC):
+    """
+    Parameters
+    ----------
+    target : array_like
+        The target density array.
+    template : array_like
+        The template density array.
+    template_mask : array_like, optional
+        Mask array for the template density.
+    target_mask : array_like, optional
+        Mask array for the target density.
+    pad_target_edges : bool, optional
+        Whether to pad the edges of the target density array. Default is False.
+    pad_fourier : bool, optional
+        Whether to pad the Fourier transform of the target and template densities.
+    rotate_mask : bool, optional
+        Whether to rotate the mask arrays along with the densities. Default is True.
+    interpolation_order : int, optional
+        The interpolation order for rigid transforms. Default is 1.
+    negate_score : bool, optional
+        Whether the final score should be multiplied by negative one. Default is True.
+    **kwargs : Dict, optional
+        Keyword arguments propagated to downstream functions.
+    """
+
+    def __init__(
+        self,
+        target: ArrayLike,
+        template: ArrayLike,
+        template_mask: ArrayLike = None,
+        target_mask: ArrayLike = None,
+        pad_target_edges: bool = False,
+        pad_fourier: bool = False,
+        rotate_mask: bool = True,
+        interpolation_order: int = 1,
+        negate_score: bool = True,
+        **kwargs: Dict,
+    ):
+        self.rotate_mask = rotate_mask
+        self.interpolation_order = interpolation_order
+
+        matching_data = MatchingData(target=target, template=template)
+        if template_mask is not None:
+            matching_data.template_mask = template_mask
+        if target_mask is not None:
+            matching_data.target_mask = target_mask
+
+        target_pad = matching_data.target_padding(pad_target=pad_target_edges)
+        matching_data = matching_data.subset_by_slice(target_pad=target_pad)
+
+        fast_shape, fast_ft_shape, fourier_shift = matching_data.fourier_padding(
+            pad_fourier=pad_fourier
+        )
+
+        self.target = backend.topleft_pad(matching_data.target, fast_shape)
+        self.target_mask = matching_data.target_mask
+
+        self.template = matching_data.template
+        self.template_rot = backend.preallocate_array(
+            fast_shape, backend._default_dtype
+        )
+
+        self.template_mask, self.template_mask_rot = 1, 1
+        rotate_mask = False if matching_data.template_mask is None else rotate_mask
+        if matching_data.template_mask is not None:
+            self.template_mask = matching_data.template_mask
+            self.template_mask_rot = backend.topleft_pad(
+                matching_data.template_mask, fast_shape
+            )
+
+        self.score_sign = -1 if negate_score else 1
+
+        if hasattr(self, "_post_init"):
+            self._post_init(**kwargs)
+
+    @staticmethod
+    def rigid_transform(
+        arr,
+        rotation_matrix,
+        translation,
+        arr_mask=None,
+        out=None,
+        out_mask=None,
+        order: int = 1,
+        use_geometric_center: bool = False,
+    ):
+        rotate_mask = arr_mask is not None
+        return_type = (out is None) + 2 * rotate_mask * (out_mask is None)
+        translation = np.zeros(arr.ndim) if translation is None else translation
+
+        center = np.floor(np.array(arr.shape) / 2)[:, None]
+        grid = np.indices(arr.shape, dtype=np.float32).reshape(arr.ndim, -1)
+        np.subtract(grid, center, out=grid)
+        np.matmul(rotation_matrix.T, grid, out=grid)
+        np.add(grid, center, out=grid)
+
+        if out is None:
+            out = np.zeros_like(arr)
+
+        map_coordinates(arr, grid, order=order, output=out.ravel())
+
+        if out_mask is None and arr_mask is not None:
+            out_mask = np.zeros_like(arr_mask)
+
+        if arr_mask is not None:
+            map_coordinates(arr_mask, grid, order=order, output=out_mask.ravel())
+
+        match return_type:
+            case 0:
+                return None
+            case 1:
+                return out
+            case 2:
+                return out_mask
+            case 3:
+                return out, out_mask
+
+    def score_translation(self, x: Tuple[float]) -> float:
+        """
+        Computes the score after a given translation.
+
+        Parameters
+        ----------
+        x : tuple of float
+            Tuple representing the translation transformation in each dimension.
+
+        Returns
+        -------
+        float
+            The score obtained for the translation transformation.
+        """
+        return self.score((*x, *[0 for _ in range(len(x))]))
+
+    def score_angles(self, x: Tuple[float]) -> float:
+        """
+        Computes the score after a given rotation.
+
+        Parameters
+        ----------
+        x : tuple of float
+            Tuple of Euler angles in zyx convention for each dimension.
+
+        Returns
+        -------
+        float
+            The score obtained for the rotation transformation.
+        """
+        return self.score((*[0 for _ in range(len(x))], *x))
+
+    def score(self, x: Tuple[float]) -> float:
+        """
+        Compute the matching score for the given transformation parameters.
+
+        Parameters
+        ----------
+        x : tuple of float
+            Even-length tuple where the first half represents translations and the
+            second half Euler angles in zyx convention for each dimension.
+
+        Returns
+        -------
+        float
+            The matching score obtained for the transformation.
+        """
+        translation, rotation_matrix = _format_rigid_transform(x)
+        kw_dict = {
+            "arr": self.template,
+            "rotation_matrix": rotation_matrix,
+            "translation": translation,
+            "out": self.template_rot,
+            "use_geometric_center": False,
+            "order": self.interpolation_order,
+        }
+        if self.rotate_mask:
+            kw_dict["arr_mask"] = self.template_mask
+            kw_dict["out_mask"] = self.template_mask_rot
+
+        self.rigid_transform(**kw_dict)
+
+        return self()
+
+    @abstractmethod
+    def __call__(self) -> float:
+        """Returns the score of the current configuration."""
+
+
+class _MatchCoordinatesToDensity(_MatchDensityToDensity):
+    """
+    Parameters
+    ----------
+    target : NDArray
+        A d-dimensional target to match the template coordinate set to.
     template_coordinates : NDArray
-        The coordinates of the template.
-    target_weights : NDArray
-        The weights of the target.
+        Template coordinate array with shape [d x N].
     template_weights : NDArray
-        The weights of the template.
-    sampling_rate : NDArray
-        The size of the voxel.
+        Template weight array with shape [N].
     template_mask_coordinates : NDArray, optional
-        The coordinates of the template mask. Default is None.
-    target_mask_coordinates : NDArray, optional
-        The coordinates of the target mask. Default is None.
-    **kwargs : dict, optional
-        Other keyword arguments.
+        Template mask coordinates with shape [d x N].
+    target_mask : NDArray, optional
+        A d-dimensional mask to be applied to the target.
+    negate_score : bool, optional
+        Whether the final score should be multiplied by negative one. Default is True.
+    **kwargs : Dict, optional
+        Keyword arguments propagated to downstream functions.
     """
 
     def __init__(
         self,
-        target_coordinates: NDArray,
+        target: NDArray,
         template_coordinates: NDArray,
-        target_weights: NDArray,
         template_weights: NDArray,
-        sampling_rate: NDArray,
         template_mask_coordinates: NDArray = None,
-        target_mask_coordinates: NDArray = None,
-        **kwargs,
+        target_mask: NDArray = None,
+        negate_score: bool = True,
+        **kwargs: Dict,
     ):
-        target, _, origin = FitRefinement.array_from_coordinates(
-            target_coordinates, target_weights, sampling_rate
-        )
         self.target_density = target
-        self.target_origin = origin
-        self.sampling_rate = sampling_rate
+        self.target_mask_density = target_mask
 
         self.template_weights = template_weights
         self.template_coordinates = template_coordinates
-        self.template_coordinates_rotated = np.empty(
-            self.template_coordinates.shape, dtype=np.float32
+        self.template_coordinates_rotated = np.copy(self.template_coordinates).astype(
+            np.float32
         )
 
-        self.target_mask_density = None
-        if target_mask_coordinates is not None:
-            target_mask, *_ = FitRefinement.array_from_coordinates(
-                coordinates=target_mask_coordinates.astype(np.float32),
-                weights=np.ones(target_mask_coordinates.shape[1]),
-                shape=self.target_density.shape,
-                origin=self.target_origin,
-                sampling_rate=self.sampling_rate,
-            )
-            self.target_mask_density = target_mask
-
-        self.template_mask_coordinates = None
-        self.template_mask_coordinates_rotated = None
+        self.template_mask_coordinates = template_mask_coordinates
+        self.template_mask_coordinates_rotated = template_mask_coordinates
         if template_mask_coordinates is not None:
-            self.template_mask_coordinates = template_mask_coordinates
-            self.template_mask_coordinates_rotated = np.empty(
-                self.template_mask_coordinates.shape, dtype=np.float32
-            )
+            self.template_mask_coordinates_rotated = np.copy(
+                self.template_mask_coordinates
+            ).astype(np.float32)
+
+        self.denominator = 1
+        self.score_sign = -1 if negate_score else 1
+
+        self.in_volume, self.in_volume_mask = self.map_coordinates_to_array(
+            coordinates=self.template_coordinates_rotated,
+            coordinates_mask=self.template_mask_coordinates_rotated,
+            array_origin=backend.zeros(target.ndim),
+            array_shape=self.target_density.shape,
+            sampling_rate=backend.full(target.ndim, fill_value=1),
+        )
 
-    def __call__(self, x: NDArray):
+        if hasattr(self, "_post_init"):
+            self._post_init(**kwargs)
+
+    def score(self, x: Tuple[float]):
         """
-        Return the score for a given transformation.
+        Compute the matching score for the given transformation parameters.
 
         Parameters
         ----------
-        x : NDArray
-            The input transformation parameters.
+        x : tuple of float
+            Even-length tuple where the first half represents translations and the
+            second half Euler angles in zyx convention for each dimension.
 
         Returns
         -------
         float
-            The negative score from the scoring function.
+            The matching score obtained for the transformation.
         """
-        translation, rotation = x[:3], x[3:]
-        rotation_matrix = euler_to_rotationmatrix(rotation)
+        translation, rotation_matrix = _format_rigid_transform(x)
 
         rigid_transform(
             coordinates=self.template_coordinates,
@@ -116,54 +326,132 @@ class MatchCoordinatesToDensity(ABC):
             use_geometric_center=False,
         )
 
-        mapping = FitRefinement.map_coordinates_to_array(
+        self.in_volume, self.in_volume_mask = self.map_coordinates_to_array(
             coordinates=self.template_coordinates_rotated,
             coordinates_mask=self.template_mask_coordinates_rotated,
-            array_origin=self.target_origin,
+            array_origin=backend.zeros(rotation_matrix.shape[0]),
             array_shape=self.target_density.shape,
-            sampling_rate=self.sampling_rate,
+            sampling_rate=backend.full(rotation_matrix.shape[0], fill_value=1),
         )
 
-        return -self.scoring_function(
-            transformed_coordinates=mapping[0],
-            transformed_coordinates_mask=mapping[1],
-            in_volume=mapping[2],
-            in_volume_mask=mapping[3],
-        )
+        return self()
 
-    @abstractmethod
-    def scoring_function(*args, **kwargs):
+    @staticmethod
+    def array_from_coordinates(
+        coordinates: NDArray,
+        weights: NDArray,
+        sampling_rate: NDArray,
+        origin: NDArray = None,
+        shape: NDArray = None,
+    ) -> Tuple[NDArray, NDArray, NDArray]:
         """
-        Computes a scoring metric for a given set of coordinates.
+        Create a volume from coordinates, using given weights and voxel size.
+
+        Parameters
+        ----------
+        coordinates : NDArray
+            An array representing the coordinates [d x N].
+        weights : NDArray
+            An array representing the weights for each coordinate [N].
+        sampling_rate : NDArray
+            The size of a voxel in the volume.
+        origin : NDArray, optional
+            The origin of the volume.
+        shape : NDArray, optional
+            The shape of the volume.
 
-        This function is not intended to be called directly, but should rather be
-        defined by classes inheriting from :py:class:`MatchCoordinatesToDensity`
-        to parse a given file format.
+        Returns
+        -------
+        tuple
+            Returns the generated volume, positions of coordinates, and origin.
         """
+        if origin is None:
+            origin = coordinates.min(axis=1)
 
+        positions = np.divide(coordinates - origin[:, None], sampling_rate[:, None])
+        positions = positions.astype(int)
 
-class MatchCoordinatesToCoordinates(ABC):
-    """
-    A class to template match coordinate sets.
+        if shape is None:
+            shape = positions.max(axis=1) + 1
 
+        arr = np.zeros(shape, dtype=np.float32)
+        np.add.at(arr, tuple(positions), weights)
+        return arr, positions, origin
+
+    @staticmethod
+    def map_coordinates_to_array(
+        coordinates: NDArray,
+        array_shape: NDArray,
+        array_origin: NDArray,
+        sampling_rate: NDArray,
+        coordinates_mask: NDArray = None,
+    ) -> Tuple[NDArray, NDArray]:
+        """
+        Map coordinates to a volume based on given voxel size and origin.
+
+        Parameters
+        ----------
+        coordinates : NDArray
+            An array representing the coordinates to be mapped [d x N].
+        array_shape : NDArray
+            The shape of the array to which the coordinates are mapped.
+        array_origin : NDArray
+            The origin of the array to which the coordinates are mapped.
+        sampling_rate : NDArray
+            The size of a voxel in the array.
+        coordinates_mask : NDArray, optional
+            An array representing the mask for the coordinates [d x T].
+
+        Returns
+        -------
+        tuple
+            Returns transformed coordinates, transformed coordinates mask,
+            mask for in_volume points, and mask for in_volume points in mask.
+        """
+        np.divide(
+            coordinates - array_origin[:, None], sampling_rate[:, None], out=coordinates
+        )
+
+        in_volume = np.logical_and(
+            coordinates < np.array(array_shape)[:, None],
+            coordinates >= 0,
+        ).min(axis=0)
+
+        in_volume_mask = None
+        if coordinates_mask is not None:
+            np.divide(
+                coordinates_mask - array_origin[:, None],
+                sampling_rate[:, None],
+                out=coordinates_mask,
+            )
+            in_volume_mask = np.logical_and(
+                coordinates_mask < np.array(array_shape)[:, None],
+                coordinates_mask >= 0,
+            ).min(axis=0)
+
+        return in_volume, in_volume_mask
+
+
+class _MatchCoordinatesToCoordinates(_MatchDensityToDensity):
+    """
     Parameters
     ----------
     target_coordinates : NDArray
-        The coordinates of the target.
+        The coordinates of the target with shape [d x N].
     template_coordinates : NDArray
-        The coordinates of the template.
+        The coordinates of the template with shape [d x T].
     target_weights : NDArray
-        The weights of the target.
+        The weights of the target with shape [N].
     template_weights : NDArray
-        The weights of the template.
-    sampling_rate : NDArray
-        The size of the voxel.
+        The weights of the template with shape [T].
     template_mask_coordinates : NDArray, optional
-        The coordinates of the template mask. Default is None.
+        The coordinates of the template mask with shape [d x T]. Default is None.
     target_mask_coordinates : NDArray, optional
-        The coordinates of the target mask. Default is None.
-    **kwargs : dict, optional
-        Other keyword arguments.
+        The coordinates of the target mask with shape [d X N]. Default is None.
+    negate_score : bool, optional
+        Whether the final score should be multiplied by negative one. Default is True.
+    **kwargs : Dict, optional
+        Keyword arguments propagated to downstream functions.
     """
 
     def __init__(
@@ -174,6 +462,7 @@ class MatchCoordinatesToCoordinates(ABC):
         template_weights: NDArray,
         template_mask_coordinates: NDArray = None,
         target_mask_coordinates: NDArray = None,
+        negate_score: bool = True,
         **kwargs,
     ):
         self.target_weights = target_weights
@@ -193,23 +482,27 @@ class MatchCoordinatesToCoordinates(ABC):
             self.template_mask_coordinates_rotated = np.empty(
                 self.template_mask_coordinates.shape, dtype=np.float32
             )
+        self.score_sign = -1 if negate_score else 1
+
+        if hasattr(self, "_post_init"):
+            self._post_init(**kwargs)
 
-    def __call__(self, x: NDArray):
+    def score(self, x: Tuple[float]) -> float:
         """
-        Return the score for a given transformation.
+        Compute the matching score for the given transformation parameters.
 
         Parameters
         ----------
-        x : NDArray
-            The input transformation parameters.
+        x : tuple of float
+            Even-length tuple where the first half represents translations and the
+            second half Euler angles in zyx convention for each dimension.
 
         Returns
         -------
         float
-            The negative score from the scoring function.
+            The matching score obtained for the transformation.
         """
-        translation, rotation = x[:3], x[3:]
-        rotation_matrix = euler_to_rotationmatrix(rotation)
+        translation, rotation_matrix = _format_rigid_transform(x)
 
         rigid_transform(
             coordinates=self.template_coordinates,
@@ -221,106 +514,161 @@ class MatchCoordinatesToCoordinates(ABC):
             use_geometric_center=False,
         )
 
-        return -self.scoring_function(
+        return self(
             transformed_coordinates=self.template_coordinates_rotated,
             transformed_coordinates_mask=self.template_mask_coordinates_rotated,
         )
 
-    @abstractmethod
-    def scoring_function(*args, **kwargs):
-        """
-        Computes a scoring metric for a given set of coordinates.
 
-        This function is not intended to be called directly, but should rather be
-        defined by classes inheriting from :py:class:`MatchCoordinatesToDensity`
-        to parse a given file format.
-        """
+class FLC(_MatchDensityToDensity):
+    """
+    Computes a normalized cross-correlation score of a target f a template g
+    and a mask m:
 
+    .. math::
 
-class CrossCorrelation(MatchCoordinatesToDensity):
-    """
-    Class representing the Cross-Correlation matching score.
+        \\frac{CC(f, \\frac{g*m - \\overline{g*m}}{\\sigma_{g*m}})}
+        {N_m * \\sqrt{
+            \\frac{CC(f^2, m)}{N_m} - (\\frac{CC(f, m)}{N_m})^2}
+        }
 
-    Cross-Correlation score formula:
+    Where:
 
     .. math::
 
-        \\text{score} = \\text{target_weights} \\cdot \\text{template_weights}
+        CC(f,g) = \\mathcal{F}^{-1}(\\mathcal{F}(f) \\cdot \\mathcal{F}(g)^*)
+
+    and Nm is the number of voxels within the template mask m.
 
+    References
+    ----------
+    .. [1]  W. Wan, S. Khavnekar, J. Wagner, P. Erdmann, and W. Baumeister
+            Microsc. Microanal. 26, 2516 (2020)
+    .. [2]  T. Hrabe, Y. Chen, S. Pfeffer, L. Kuhn Cuellar, A.-V. Mangold,
+            and F. Förster, J. Struct. Biol. 178, 177 (2012).
     """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.denominator = 1
+    __doc__ += _MatchDensityToDensity.__doc__
 
-    def scoring_function(
-        self,
-        transformed_coordinates: NDArray,
-        transformed_coordinates_mask: NDArray,
-        in_volume: NDArray,
-        in_volume_mask: NDArray,
-    ) -> float:
-        """
-        Compute the Cross-Correlation score.
+    def _post_init(self, **kwargs: Dict):
+        if self.target_mask is not None:
+            backend.multiply(self.target, self.target_mask, out=self.target)
 
-        Parameters
-        ----------
-        transformed_coordinates : NDArray
-            Transformed coordinates.
-        transformed_coordinates_mask : NDArray
-            Mask for the transformed coordinates.
-        in_volume : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target volume.
-        in_volume_mask : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target mask volume.
+        self.target_square = backend.square(self.target)
 
-        Returns
-        -------
-        float
-            The Cross-Correlation score.
-        """
-        score = np.dot(
-            self.target_density[tuple(transformed_coordinates[:, in_volume])],
-            self.template_weights[in_volume],
+        normalize_under_mask(
+            template=self.template,
+            mask=self.template_mask,
+            mask_intensity=backend.sum(self.template_mask),
         )
-        score /= self.denominator
+
+        self.template = backend.reverse(self.template)
+        self.template_mask = backend.reverse(self.template_mask)
+
+    def __call__(self) -> float:
+        """Returns the score of the current configuration."""
+        n_observations = backend.sum(self.template_mask_rot)
+
+        normalize_under_mask(
+            template=self.template_rot,
+            mask=self.template_mask_rot,
+            mask_intensity=n_observations,
+        )
+
+        ex2 = backend.sum(
+            backend.divide(
+                backend.sum(
+                    backend.multiply(self.target_square, self.template_mask_rot),
+                ),
+                n_observations,
+            )
+        )
+        e2x = backend.square(
+            backend.divide(
+                backend.sum(backend.multiply(self.target, self.template_mask_rot)),
+                n_observations,
+            )
+        )
+
+        denominator = backend.maximum(backend.subtract(ex2, e2x), 0.0)
+        denominator = backend.sqrt(denominator)
+        denominator = backend.multiply(denominator, n_observations)
+
+        overlap = backend.sum(backend.multiply(self.template_rot, self.target))
+
+        score = backend.divide(overlap, denominator) * self.score_sign
         return score
 
 
-class LaplaceCrossCorrelation(CrossCorrelation):
+class CrossCorrelation(_MatchCoordinatesToDensity):
+    """
+    Computes the Cross-Correlation score as:
+
+    .. math::
+
+        \\text{score} = \\text{target_weights} \\cdot \\text{template_weights}
     """
-    Class representing the Laplace Cross-Correlation matching score.
 
-    The score is computed like CrossCorrelation, but with Laplace filtered
-    weights, indicated by the Laplace operator :math:`\\nabla^{2}`.
+    __doc__ += _MatchCoordinatesToDensity.__doc__
+
+    def __call__(self) -> float:
+        """Returns the score of the current configuration."""
+        try:
+            score = np.dot(
+                self.target_density[
+                    tuple(
+                        self.template_coordinates_rotated[:, self.in_volume].astype(int)
+                    )
+                ],
+                self.template_weights[self.in_volume],
+            )
+        except:
+            print(self.template_coordinates_rotated[:, self.in_volume].astype(int))
+            print(self.target_density.shape)
+            print(self.in_volume)
+            coordinates = self.template_coordinates_rotated[:, self.in_volume].astype(
+                int
+            )
+            in_volume = np.logical_and(
+                coordinates < np.array(self.target_density.shape)[:, None],
+                coordinates >= 0,
+            ).min(axis=0)
+            print(in_volume)
+
+            raise ValueError()
+        score /= self.denominator
+        return score * self.score_sign
+
+
+class LaplaceCrossCorrelation(CrossCorrelation):
+    """
+    Uses the same formalism as :py:class:`CrossCorrelation` but with Laplace
+    filtered weights (:math:`\\nabla^{2}`):
 
     .. math::
 
         \\text{score} = \\nabla^{2} \\text{target_weights} \\cdot
                         \\nabla^{2} \\text{template_weights}
-
     """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+    __doc__ += _MatchCoordinatesToDensity.__doc__
+
+    def _post_init(self, **kwargs):
         self.target_density = laplace(self.target_density)
 
-        arr, positions, _ = FitRefinement.array_from_coordinates(
-            self.template_coordinates, self.template_weights, self.sampling_rate
+        arr, positions, _ = self.array_from_coordinates(
+            self.template_coordinates,
+            self.template_weights,
+            np.ones(self.template_coordinates.shape[0]),
         )
         self.template_weights = laplace(arr)[tuple(positions)]
 
 
 class NormalizedCrossCorrelation(CrossCorrelation):
     """
-    Class representing the Normalized Cross-Correlation matching score.
-
-    The score is computed by normalizing the dot product of `target_weights` and
-    `template_weights` with the product of their norms. This normalization ensures
-    the score lies between -1 and 1, providing a measure of similarity that's invariant
-    to scale.
+    Computes a normalized version of the :py:class:`CrossCorrelation` score based
+    on the dot product of `target_weights` and `template_weights`, in order to
+    reduce bias to regions of high local energy.
 
     .. math::
 
@@ -338,11 +686,11 @@ class NormalizedCrossCorrelation(CrossCorrelation):
         \\text{template_norm} = ||\\text{template_weights}||
 
     Here, :math:`||.||` denotes the L2 (Euclidean) norm.
-
     """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+    __doc__ += _MatchCoordinatesToDensity.__doc__
+
+    def _post_init(self, **kwargs):
         target_norm = np.linalg.norm(self.target_density[self.target_density != 0])
         template_norm = np.linalg.norm(self.template_weights)
         self.denominator = np.fmax(target_norm * template_norm, np.finfo(float).eps)
@@ -350,14 +698,8 @@ class NormalizedCrossCorrelation(CrossCorrelation):
 
 class NormalizedCrossCorrelationMean(NormalizedCrossCorrelation):
     """
-    Class representing the Mean Normalized Cross-Correlation matching score.
-
-    This class extends the Normalized Cross-Correlation by computing the score
-    after subtracting the mean from both `target_weights` and `template_weights`.
-    This modification enhances the matching score's sensitivity to patterns
-    over flat regions in the data.
-
-    Mathematically, the Mean Normalized Cross-Correlation score is computed as:
+    Computes a similar score than :py:class:`NormalizedCrossCorrelation`, but
+    additionally factors in the mean of template and target.
 
     .. math::
 
@@ -381,21 +723,21 @@ class NormalizedCrossCorrelationMean(NormalizedCrossCorrelation):
     computes the mean of the respective weights.
     """
 
+    __doc__ += _MatchCoordinatesToDensity.__doc__
+
     def __init__(self, **kwargs):
-        print(kwargs["target_weights"].mean())
-        kwargs["target_weights"] -= kwargs["target_weights"].mean()
-        kwargs["template_weights"] -= kwargs["template_weights"].mean()
+        kwargs["target"] = np.subtract(kwargs["target"], kwargs["target"].mean())
+        kwargs["template_weights"] = np.subtract(
+            kwargs["template_weights"], kwargs["template_weights"].mean()
+        )
         super().__init__(**kwargs)
 
 
-class MaskedCrossCorrelation(MatchCoordinatesToDensity):
+class MaskedCrossCorrelation(_MatchCoordinatesToDensity):
     """
-    Class representing the Masked Cross-Correlation matching score.
-
     The Masked Cross-Correlation computes the similarity between `target_weights`
-    and `template_weights` under respective masks. The score is normalized and lies
-    between -1 and 1, providing a measure of similarity even in the presence of
-    missing or masked data.
+    and `template_weights` under respective masks. The score provides a measure of
+    similarity even in the presence of missing or masked data.
 
     The formula for the Masked Cross-Correlation is:
 
@@ -437,54 +779,37 @@ class MaskedCrossCorrelation(MatchCoordinatesToDensity):
     .. [1]  Masked FFT registration, Dirk Padfield, CVPR 2010 conference
     """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def scoring_function(
-        self,
-        transformed_coordinates: NDArray,
-        transformed_coordinates_mask: NDArray,
-        in_volume: NDArray,
-        in_volume_mask: NDArray,
-    ) -> float:
-        """
-        Compute the Masked Cross-Correlation score.
-
-        Parameters
-        ----------
-        transformed_coordinates : NDArray
-            Transformed coordinates.
-        transformed_coordinates_mask : NDArray
-            Mask for the transformed coordinates.
-        in_volume : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target volume.
-        in_volume_mask : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target mask volume.
+    __doc__ += _MatchCoordinatesToDensity.__doc__
 
-        Returns
-        -------
-        float
-            The Masked Cross-Correlation score.
-        """
+    def __call__(self) -> float:
+        """Returns the score of the current configuration."""
         mask_overlap = np.sum(
             self.target_mask_density[
-                tuple(transformed_coordinates_mask[:, in_volume_mask])
+                tuple(
+                    self.template_mask_coordinates_rotated[
+                        :, self.in_volume_mask
+                    ].astype(int)
+                )
             ],
         )
         mask_overlap = np.fmax(mask_overlap, np.finfo(float).eps)
 
         mask_target = self.target_density[
-            tuple(transformed_coordinates_mask[:, in_volume_mask])
+            tuple(
+                self.template_mask_coordinates_rotated[:, self.in_volume_mask].astype(
+                    int
+                )
+            )
         ]
         denominator1 = np.subtract(
             np.sum(mask_target**2),
             np.divide(np.square(np.sum(mask_target)), mask_overlap),
         )
         mask_template = np.multiply(
-            self.template_weights[in_volume],
-            self.target_mask_density[tuple(transformed_coordinates[:, in_volume])],
+            self.template_weights[self.in_volume],
+            self.target_mask_density[
+                tuple(self.template_coordinates_rotated[:, self.in_volume].astype(int))
+            ],
         )
         denominator2 = np.subtract(
             np.sum(mask_template**2),
@@ -496,8 +821,10 @@ class MaskedCrossCorrelation(MatchCoordinatesToDensity):
         denominator = np.sqrt(np.multiply(denominator1, denominator2))
 
         numerator = np.dot(
-            self.target_density[tuple(transformed_coordinates[:, in_volume])],
-            self.template_weights[in_volume],
+            self.target_density[
+                tuple(self.template_coordinates_rotated[:, self.in_volume].astype(int))
+            ],
+            self.template_weights[self.in_volume],
         )
 
         numerator -= np.divide(
@@ -505,16 +832,14 @@ class MaskedCrossCorrelation(MatchCoordinatesToDensity):
         )
 
         if denominator == 0:
-            return 0
+            return 0.0
 
         score = numerator / denominator
-        return score
+        return float(score * self.score_sign)
 
 
-class PartialLeastSquareDifference(MatchCoordinatesToDensity):
+class PartialLeastSquareDifference(_MatchCoordinatesToDensity):
     """
-    Class representing the Partial Least Square Difference matching score.
-
     The Partial Least Square Difference (PLSQ) between the target :math:`f` and the
     template :math:`g` is calculated as:
 
@@ -529,109 +854,32 @@ class PartialLeastSquareDifference(MatchCoordinatesToDensity):
             pp. 333--343, 2011. DOI: https://doi.org/10.1016/j.jsb.2011.01.012
     """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def scoring_function(
-        self,
-        transformed_coordinates: NDArray,
-        transformed_coordinates_mask: NDArray,
-        in_volume: NDArray,
-        in_volume_mask: NDArray,
-    ) -> float:
-        """
-        Compute the Partial Least Square Difference score.
-
-        Given the transformed coordinates and their associated mask, this function
-        computes the difference between target and template densities.
+    __doc__ += _MatchCoordinatesToDensity.__doc__
 
-        Parameters
-        ----------
-        transformed_coordinates : NDArray
-            Transformed coordinates.
-        transformed_coordinates_mask : NDArray
-            Mask for the transformed coordinates.
-        in_volume : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target volume.
-        in_volume_mask : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target mask volume.
-
-        Returns
-        -------
-        float
-            The negative of the Partial Least Square Difference score.
-        """
+    def __call__(self) -> float:
+        """Returns the score of the current configuration."""
         score = np.sum(
             np.square(
                 np.subtract(
-                    self.target_density[tuple(transformed_coordinates[:, in_volume])],
-                    self.template_weights[in_volume],
+                    self.target_density[
+                        tuple(
+                            self.template_coordinates_rotated[:, self.in_volume].astype(
+                                int
+                            )
+                        )
+                    ],
+                    self.template_weights[self.in_volume],
                 )
             )
         )
-        score += np.sum(np.square(self.template_weights[np.invert(in_volume)]))
-
-        return -score
-
-
-class Chamfer(MatchCoordinatesToCoordinates):
-    """
-    Class representing the Chamfer matching score.
-
-    The Chamfer distance is computed as:
-
-    .. math::
-
-        \\text{d(f,g)} = \\frac{1}{|X|} \\sum_{\\mathbf{f}_i \\in X}
-        \\inf_{\\mathbf{g} \\in Y} ||\\mathbf{f}_i - \\mathbf{g}||_2
+        score += np.sum(np.square(self.template_weights[np.invert(self.in_volume)]))
+        return score * self.score_sign
 
-    References
-    ----------
-    .. [1]  Daven Vasishtan and Maya Topf, "Scoring functions for cryoEM density
-            fitting", Journal of Structural Biology, vol. 174, no. 2,
-            pp. 333--343, 2011. DOI: https://doi.org/10.1016/j.jsb.2011.01.012
-    """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.target_tree = KDTree(self.target_coordinates.T)
-
-    def scoring_function(
-        self,
-        transformed_coordinates: NDArray,
-        transformed_coordinates_mask: NDArray,
-        **kwargs,
-    ) -> float:
-        """
-        Compute the Chamfer distance score.
-
-        Given the transformed coordinates and their associated mask, this function
-        calculates the average distance between the rotated template coordinates
-        and the nearest target coordinates.
-
-        Parameters
-        ----------
-        transformed_coordinates : NDArray
-            Transformed coordinates.
-
-        Returns
-        -------
-        float
-            The negative of the Chamfer distance score.
-
-        """
-        dist, _ = self.target_tree.query(self.template_coordinates_rotated.T)
-        score = np.mean(dist)
-        return -score
-
-
-class MutualInformation(MatchCoordinatesToDensity):
+class MutualInformation(_MatchCoordinatesToDensity):
     """
-    Class representing the Mutual Information matching score.
-
-    The Mutual Information (MI) score is calculated as:
+    The Mutual Information (MI) score between the target :math:`f` and the
+    template :math:`g` is calculated as:
 
     .. math::
 
@@ -645,43 +893,15 @@ class MutualInformation(MatchCoordinatesToDensity):
 
     """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def scoring_function(
-        self,
-        transformed_coordinates: NDArray,
-        transformed_coordinates_mask: NDArray,
-        in_volume: NDArray,
-        in_volume_mask: NDArray,
-    ) -> float:
-        """
-        Compute the Mutual Information score.
-
-        Given the transformed coordinates and their associated mask, this function
-        computes the mutual information between the target and template densities.
+    __doc__ += _MatchCoordinatesToDensity.__doc__
 
-        Parameters
-        ----------
-        transformed_coordinates : NDArray
-            Transformed coordinates.
-        transformed_coordinates_mask : NDArray
-            Mask for the transformed coordinates.
-        in_volume : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target volume.
-        in_volume_mask : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target mask volume.
-
-        Returns
-        -------
-        float
-            The Mutual Information score.
-        """
+    def __call__(self) -> float:
+        """Returns the score of the current configuration."""
         p_xy, target, template = np.histogram2d(
-            self.target_density[tuple(transformed_coordinates[:, in_volume])],
-            self.template_weights[in_volume],
+            self.target_density[
+                tuple(self.template_coordinates_rotated[:, self.in_volume].astype(int))
+            ],
+            self.template_weights[self.in_volume],
         )
         p_x, p_y = np.sum(p_xy, axis=1), np.sum(p_xy, axis=0)
 
@@ -692,14 +912,13 @@ class MutualInformation(MatchCoordinatesToDensity):
         logprob = np.divide(p_xy, p_x[:, None] * p_y[None, :] + np.finfo(float).eps)
         score = np.nansum(p_xy * logprob)
 
-        return score
+        return score * self.score_sign
 
 
-class Envelope(MatchCoordinatesToDensity):
+class Envelope(_MatchCoordinatesToDensity):
     """
-    Class representing the Envelope matching score.
-
-    The Envelope score (ENV) is calculated as:
+    The Envelope score (ENV) between the target :math:`f` and the
+    template :math:`g` is calculated as:
 
     .. math::
 
@@ -713,59 +932,64 @@ class Envelope(MatchCoordinatesToDensity):
             pp. 333--343, 2011. DOI: https://doi.org/10.1016/j.jsb.2011.01.012
     """
 
-    def __init__(self, target_threshold: float, **kwargs):
+    __doc__ += _MatchCoordinatesToDensity.__doc__
+
+    def __init__(self, target_threshold: float = None, **kwargs):
         super().__init__(**kwargs)
+        if target_threshold is None:
+            target_threshold = np.mean(self.target_density)
         self.target_density = np.where(self.target_density > target_threshold, -1, 1)
         self.target_density_present = np.sum(self.target_density == -1)
         self.target_density_absent = np.sum(self.target_density == 1)
         self.template_weights = np.ones_like(self.template_weights)
 
-    def scoring_function(
-        self,
-        transformed_coordinates: NDArray,
-        transformed_coordinates_mask: NDArray,
-        in_volume: NDArray,
-        in_volume_mask: NDArray,
-    ) -> float:
-        """
-        Compute the Envelope score.
-
-        Given the transformed coordinates and their associated mask, this function
-        computes the envelope score based on target density thresholds.
-
-        Parameters
-        ----------
-        transformed_coordinates : NDArray
-            Transformed coordinates.
-        transformed_coordinates_mask : NDArray
-            Mask for the transformed coordinates.
-        in_volume : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target volume.
-        in_volume_mask : NDArray
-            Binary mask indicating which ``transformed_coordinates`` are in the
-            target mask volume.
-
-        Returns
-        -------
-        float
-            The Envelope score.
-        """
-        score = self.target_density[tuple(transformed_coordinates[:, in_volume])]
+    def __call__(self) -> float:
+        """Returns the score of the current configuration."""
+        score = self.target_density[
+            tuple(self.template_coordinates_rotated[:, self.in_volume].astype(int))
+        ]
         unassigned_density = self.target_density_present - (score == -1).sum()
 
-        score = score.sum() - unassigned_density - 2 * np.sum(np.invert(in_volume))
+        score = score.sum() - unassigned_density - 2 * np.sum(np.invert(self.in_volume))
         min_score = -self.target_density_present - 2 * self.target_density_absent
         score = (score - 2 * min_score) / (2 * self.target_density_present - min_score)
 
-        return score
+        return score * self.score_sign
+
+
+class Chamfer(_MatchCoordinatesToCoordinates):
+    """
+    The Chamfer distance between the target :math:`f` and the template :math:`g`
+    is calculated as:
+
+    .. math::
 
+        \\text{d(f,g)} = \\frac{1}{|X|} \\sum_{\\mathbf{f}_i \\in X}
+        \\inf_{\\mathbf{g} \\in Y} ||\\mathbf{f}_i - \\mathbf{g}||_2
 
-class NormalVectorScore(MatchCoordinatesToCoordinates):
+    References
+    ----------
+    .. [1]  Daven Vasishtan and Maya Topf, "Scoring functions for cryoEM density
+            fitting", Journal of Structural Biology, vol. 174, no. 2,
+            pp. 333--343, 2011. DOI: https://doi.org/10.1016/j.jsb.2011.01.012
     """
-    Class representing the Normal Vector matching score.
 
-    The Normal Vector Score (NVS) is calculated as:
+    __doc__ += _MatchCoordinatesToDensity.__doc__
+
+    def _post_init(self, **kwargs):
+        self.target_tree = KDTree(self.target_coordinates.T)
+
+    def __call__(self) -> float:
+        """Returns the score of the current configuration."""
+        dist, _ = self.target_tree.query(self.template_coordinates_rotated.T)
+        score = np.mean(dist)
+        return score * self.score_sign
+
+
+class NormalVectorScore(_MatchCoordinatesToCoordinates):
+    """
+    The Normal Vector Score (NVS) between the target's :math:`f` and the template
+    :math:`g`'s normal vectors is calculated as:
 
     .. math::
 
@@ -784,35 +1008,14 @@ class NormalVectorScore(MatchCoordinatesToCoordinates):
 
     """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+    __doc__ += _MatchCoordinatesToDensity.__doc__
 
-    def scoring_function(
-        self,
-        transformed_coordinates: NDArray,
-        transformed_coordinates_mask: NDArray,
-        **kwargs,
-    ) -> float:
-        """
-        Compute the Normal Vector Score.
-
-        Given the template and target vectors, this function computes the average
-        cosine similarity between the two sets of vectors.
-
-        Parameters
-        ----------
-        template_vectors : NDArray
-            Normal vectors derived from the template.
-        target_vectors : NDArray
-            Normal vectors derived from the target.
-
-        Returns
-        -------
-        float
-            The Normal Vector Score.
-        """
-        numerator = np.multiply(transformed_coordinates, self.target_coordinates)
-        denominator = np.linalg.norm(transformed_coordinates)
+    def __call__(self) -> float:
+        """Returns the score of the current configuration."""
+        numerator = np.multiply(
+            self.template_coordinates_rotated, self.target_coordinates
+        )
+        denominator = np.linalg.norm(self.template_coordinates_rotated)
         denominator *= np.linalg.norm(self.target_coordinates)
         score = np.mean(numerator / denominator)
         return score
@@ -829,12 +1032,13 @@ MATCHING_OPTIMIZATION_REGISTER = {
     "Chamfer": Chamfer,
     "MutualInformation": MutualInformation,
     "NormalVectorScore": NormalVectorScore,
+    "FLC": FLC,
 }
 
 
 def register_matching_optimization(match_name: str, match_class: type):
     """
-    Registers a class to be used by :py:class:`FitRefinement`.
+    Registers a new mtaching method.
 
     Parameters
     ----------
@@ -848,7 +1052,7 @@ def register_matching_optimization(match_name: str, match_class: type):
     ValueError
         If any of the required methods is not defined.
     """
-    methods_to_check = ["__init__", "__call__", "scoring_function"]
+    methods_to_check = ["__init__", "__call__"]
 
     for method in methods_to_check:
         if not hasattr(match_class, method):
@@ -858,266 +1062,166 @@ def register_matching_optimization(match_name: str, match_class: type):
     MATCHING_OPTIMIZATION_REGISTER[match_name] = match_class
 
 
-class FitRefinement:
-    """
-    A class to refine the fit between target and template coordinates.
-
-    Notes
-    -----
-    By default scipy.optimize.differential_evolution or scipy.optimize.basinhopping
-    are used which can be unreliable if the initial alignment is very poor. Other
-    optimizers can be implemented by subclassing :py:class:`FitRefinement` and
-    overwriting the :py:meth:`FitRefinement.refine` function.
-
+def create_score_object(score: str, **kwargs) -> object:
     """
+    Initialize score object with name ``score`` using `**kwargs``.
 
-    @staticmethod
-    def map_coordinates_to_array(
-        coordinates: NDArray,
-        array_shape: NDArray,
-        array_origin: NDArray,
-        sampling_rate: NDArray,
-        coordinates_mask: NDArray = None,
-    ) -> Tuple[NDArray, NDArray]:
-        """
-        Map coordinates to a volume based on given voxel size and origin.
+    Parameters
+    ----------
+    score: str
+        Name of the score.
+    **kwargs: Dict
+        Keyword arguments passed to the __init__ method of the score object.
 
-        Parameters
-        ----------
-        coordinates : NDArray
-            An array representing the coordinates to be mapped [d x N].
-        array_shape : NDArray
-            The shape of the array to which the coordinates are mapped.
-        array_origin : NDArray
-            The origin of the array to which the coordinates are mapped.
-        sampling_rate : NDArray
-            The size of a voxel in the array.
-        coordinates_mask : NDArray, optional
-            An array representing the mask for the coordinates [d x T].
+    Returns
+    -------
+    object
+        Initialized score object.
 
-        Returns
-        -------
-        tuple
-            Returns transformed coordinates, transformed coordinates mask,
-            mask for in_volume points, and mask for in_volume points in mask.
-        """
-        coordinates = coordinates.astype(sampling_rate.dtype)
-        np.divide(
-            coordinates - array_origin[:, None], sampling_rate[:, None], out=coordinates
-        )
-        transformed_coordinates = coordinates.astype(int)
-        in_volume = np.logical_and(
-            transformed_coordinates < np.array(array_shape)[:, None],
-            transformed_coordinates >= 0,
-        ).min(axis=0)
+    Raises
+    ------
+    ValueError
+        If ``score`` is not a key in MATCHING_OPTIMIZATION_REGISTER.
 
-        transformed_coordinates_mask, in_volume_mask = None, None
+    See Also
+    --------
+    :py:meth:`register_matching_optimization`
+    """
 
-        if coordinates_mask is not None:
-            coordinates_mask = coordinates_mask.astype(sampling_rate.dtype)
-            np.divide(
-                coordinates_mask - array_origin[:, None],
-                sampling_rate[:, None],
-                out=coordinates_mask,
-            )
-            transformed_coordinates_mask = coordinates_mask.astype(int)
-            in_volume_mask = np.logical_and(
-                transformed_coordinates_mask < np.array(array_shape)[:, None],
-                transformed_coordinates_mask >= 0,
-            ).min(axis=0)
+    score_object = MATCHING_OPTIMIZATION_REGISTER.get(score, None)
 
-        return (
-            transformed_coordinates,
-            transformed_coordinates_mask,
-            in_volume,
-            in_volume_mask,
+    if score_object is None:
+        raise ValueError(
+            f"{score} is not defined. Please pick from "
+            f" {', '.join(list(MATCHING_OPTIMIZATION_REGISTER.keys()))}."
         )
 
-    @staticmethod
-    def array_from_coordinates(
-        coordinates: NDArray,
-        weights: NDArray,
-        sampling_rate: NDArray,
-        origin: NDArray = None,
-        shape: NDArray = None,
-    ) -> Tuple[NDArray, NDArray, NDArray]:
-        """
-        Create a volume from coordinates, using given weights and voxel size.
-
-        Parameters
-        ----------
-        coordinates : NDArray
-            An array representing the coordinates [d x N].
-        weights : NDArray
-            An array representing the weights for each coordinate [N].
-        sampling_rate : NDArray
-            The size of a voxel in the volume.
-        origin : NDArray, optional
-            The origin of the volume.
-        shape : NDArray, optional
-            The shape of the volume.
-
-        Returns
-        -------
-        tuple
-            Returns the generated volume, positions of coordinates, and origin.
-        """
-        if origin is None:
-            origin = coordinates.min(axis=1)
-
-        positions = np.divide(coordinates - origin[:, None], sampling_rate[:, None])
-        positions = positions.astype(int)
-
-        if shape is None:
-            shape = positions.max(axis=1) + 1
-
-        arr = np.zeros(shape, dtype=np.float32)
-        np.add.at(arr, tuple(positions), weights)
-        return arr, positions, origin
-
-    def refine(
-        self,
-        target_coordinates: NDArray,
-        target_weights: NDArray,
-        template_coordinates: NDArray,
-        template_weights: NDArray,
-        sampling_rate: float = None,
-        translational_uncertainty: Tuple[float] = None,
-        rotational_uncertainty: Tuple[float] = None,
-        scoring_class: str = "CrossCorrelation",
-        scoring_class_parameters: Dict = dict(),
-        local_optimization: bool = True,
-        maxiter: int = 100,
-    ) -> (NDArray, NDArray):
-        """
-        Refines the alignment of template coordinates to target coordinates.
-
-        Parameters
-        ----------
-        target_coordinates : NDArray
-            The coordinates of the target.
-
-        target_weights : NDArray
-            The weights of the target.
+    score_object = score_object(**kwargs)
+    return score_object
 
-        template_coordinates : NDArray
-            The coordinates of the template.
 
-        template_weights : NDArray
-            The weights of the template.
+def optimize_match(
+    score_object: object,
+    bounds_translation: Tuple[Tuple[float]] = None,
+    bounds_rotation: Tuple[Tuple[float]] = None,
+    optimization_method: str = "basinhopping",
+    maxiter: int = 500,
+) -> Tuple[ArrayLike, ArrayLike, float]:
+    """
+    Find the translation and rotation optimizing the score returned by `score_object`
+    with respect to provided bounds.
 
-        sampling_rate : float, optional
-            The size of the voxel. Default is None.
+    Parameters
+    ----------
+    score_object: object
+        Class object that defines a score method, which returns a floating point
+        value given a tuple of floating points where the first half describes a
+        translation and the second a rotation. The score will be minimized, i.e.
+        it has to be negated if similarity should be optimized.
+    bounds_translation : tuple of tuple float, optional
+        Bounds on the evaluated translations. Has to be specified per dimension
+        as tuple of (min, max). Default is None.
+    bounds_rotation : tuple of tuple float, optional
+        Bounds on the evaluated zyx Euler angles. Has to be specified per dimension
+        as tuple of (min, max). Default is None.
+    optimization_method : str, optional
+        Optimizer that will be used, by default basinhopping. For further
+        information refer to :doc:`scipy:reference/optimize`.
+
+        +--------------------------+-----------------------------------------+
+        | 'differential_evolution' | Highest accuracy but long runtime.      |
+        |                          | Requires bounds on translation.         |
+        +--------------------------+-----------------------------------------+
+        | 'basinhopping'           | Decent accuracy, medium runtime.        |
+        +--------------------------+-----------------------------------------+
+        | 'minimize'               | If initial values are closed to optimum |
+        |                          | decent performance, short runtime.      |
+        +--------------------------+-----------------------------------------+
+    maxiter : int, optional
+        The maximum number of iterations. Default is 500. Not considered for
+        `optimization_method` 'minimize'.
+
+    Returns
+    -------
+    Tuple[ArrayLike, ArrayLike, float]
+        Translation and rotation matrix yielding final score.
 
-        translational_uncertainty : (float,), optional
-            The translational uncertainty. Default is None.
+    Raises
+    ------
+    ValueError
+        If `optimization_method` is not supported.
 
-        rotational_uncertainty : (float,), optional
-            The rotational uncertainty. Default is None.
+    Notes
+    -----
+    This function currently only supports three-dimensional optimization and
+    `score_object` will be modified during this operation.
+    """
+    ndim = 3
+    _optimization_method = {
+        "differential_evolution": differential_evolution,
+        "basinhopping": basinhopping,
+        "minimize": minimize,
+    }
+    if optimization_method not in _optimization_method:
+        raise ValueError(
+            f"{optimization_method} is not supported. "
+            f"Pick from {', '.join(list(_optimization_method.keys()))}"
+        )
 
-        scoring_class : str, optional
-            The scoring class to be used. Default is "CC".
+    finfo = np.finfo(np.float32)
 
-        scoring_class_parameters : dict, optional
-            The parameters for the scoring class. Default is an empty dictionary.
+    # DE always requires bounds
+    if optimization_method == "differential_evolution" and bounds_translation is None:
+        bounds_translation = tuple((finfo.min, finfo.max) for _ in range(ndim))
 
-        local_optimization : bool, optional
-            Whether to use local optimization. Default is True.
+    if bounds_translation is None and bounds_rotation is not None:
+        bounds_translation = tuple((finfo.min, finfo.max) for _ in range(ndim))
 
-        maxiter : int, optional
-            The maximum number of iterations. Default is 100.
+    if bounds_rotation is None and bounds_translation is not None:
+        bounds_rotation = tuple((-180, 180) for _ in range(ndim))
 
-        Returns
-        -------
-        tuple
-            A tuple containing the translation and rotation matrix of the refinement,
-            as well as the score of the refinement.
-
-        Raises
-        ------
-        NotNotImplementedError
-            If scoring class is not a part of `MATCHING_OPTIMIZATION_REGISTER`.
-            Individual scores can be added via
-            :py:meth:`register_matching_optimization`.
-
-        See Also
-        --------
-        :py:meth:`register_matching_optimization`
-        """
-        if scoring_class not in MATCHING_OPTIMIZATION_REGISTER:
-            raise NotImplementedError(
-                f"Parameter score has to be one of "
-                f"{', '.join(MATCHING_OPTIMIZATION_REGISTER.keys())}."
-            )
-        scoring_class = MATCHING_OPTIMIZATION_REGISTER.get(scoring_class, None)
-
-        if sampling_rate is None:
-            sampling_rate = np.ones(1)
-        sampling_rate = np.repeat(
-            sampling_rate, target_coordinates.shape[0] // sampling_rate.size
+    bounds, linear_constraint = None, ()
+    if bounds_rotation is not None and bounds_translation is not None:
+        uncertainty = (*bounds_translation, *bounds_rotation)
+        bounds = [
+            bound if bound != (0, 0) else (-finfo.resolution, finfo.resolution)
+            for bound in uncertainty
+        ]
+        linear_constraint = LinearConstraint(
+            np.eye(len(bounds)), np.min(bounds, axis=1), np.max(bounds, axis=1)
         )
 
-        score = scoring_class(
-            target_coordinates=target_coordinates,
-            template_coordinates=template_coordinates,
-            target_weights=target_weights,
-            template_weights=template_weights,
-            sampling_rate=sampling_rate,
-            **scoring_class_parameters,
+    initial_score = score_object()
+    if optimization_method == "basinhopping":
+        result = basinhopping(
+            x0=np.zeros(2 * ndim),
+            func=score_object.score,
+            niter=maxiter,
+            minimizer_kwargs={"method": "COBYLA", "constraints": linear_constraint},
         )
-
-        initial_score = score(np.zeros(6))
-
-        mass_center_target = np.dot(target_coordinates, target_weights)
-        mass_center_target /= target_weights.sum()
-        mass_center_template = np.dot(template_coordinates, template_weights)
-        mass_center_template /= template_weights.sum()
-
-        if translational_uncertainty is None:
-            mass_center_difference = np.ceil(
-                np.subtract(mass_center_target, mass_center_template)
-            ).astype(int)
-            target_range = np.ceil(
-                np.divide(
-                    np.subtract(
-                        target_coordinates.max(axis=1), target_coordinates.min(axis=1)
-                    ),
-                    2,
-                )
-            ).astype(int)
-            translational_uncertainty = tuple(
-                (center - start, center + start)
-                for center, start in zip(mass_center_difference, target_range)
-            )
-        if rotational_uncertainty is None:
-            rotational_uncertainty = tuple(
-                (-90, 90) for _ in range(target_coordinates.shape[0])
-            )
-
-        uncertainty = (*translational_uncertainty, *rotational_uncertainty)
-        bounds = [bound if bound != (0, 0) else (-1e-9, 1e-9) for bound in uncertainty]
-        linear_constraint = LinearConstraint(
-            np.eye(len(bounds)), np.min(bounds, axis=1), np.max(bounds, axis=1)
+    elif optimization_method == "differential_evolution":
+        result = differential_evolution(
+            func=score_object.score,
+            bounds=bounds,
+            constraints=linear_constraint,
+            maxiter=maxiter,
         )
+    elif optimization_method == "minimize":
+        result = minimize(
+            x0=np.zeros(2 * ndim),
+            fun=score_object.score,
+            bounds=bounds,
+            constraints=linear_constraint,
+        )
+    print(f"Niter: {result.nit}, success : {result.success} ({result.message}).")
+    print(f"Initial score: {initial_score} - Refined score: {result.fun}")
+    if initial_score < result.fun:
+        print("Initial score better than refined score. Returning identity.")
+        result.x = np.zeros_like(result.x)
+    translation, rotation = result.x[:ndim], result.x[ndim:]
+    rotation_matrix = euler_to_rotationmatrix(rotation)
+    return translation, rotation_matrix, result.fun
 
-        if local_optimization:
-            result = basinhopping(
-                x0=np.zeros(6),
-                func=score,
-                niter=maxiter,
-                minimizer_kwargs={"method": "COBYLA", "constraints": linear_constraint},
-            )
-        else:
-            result = differential_evolution(
-                func=score,
-                bounds=bounds,
-                constraints=linear_constraint,
-                maxiter=maxiter,
-            )
 
-        print(f"Initial score: {-initial_score} - Refined score: {-result.fun}")
-        if initial_score < result.fun:
-            result.x = np.zeros_like(result.x)
-        translation, rotation = result.x[:3], result.x[3:]
-        rotation_matrix = euler_to_rotationmatrix(rotation)
-        return translation, rotation_matrix, -result.fun
+class FitRefinement:
+    pass