| from typing import Self |
|
|
| import numpy as np |
| from scipy.spatial import distance_matrix |
|
|
| from .._shared.utils import check_nD, _deprecate_estimate, FailedEstimation |
|
|
|
|
| class ThinPlateSplineTransform: |
| """Thin-plate spline transformation. |
| |
| Given two matching sets of points, source and destination, this class |
| estimates the thin-plate spline (TPS) transformation which transforms |
| each point in source into its destination counterpart. |
| |
| Attributes |
| ---------- |
| src : (N, 2) array_like |
| Coordinates of control points in source image. |
| |
| References |
| ---------- |
| .. [1] Bookstein, Fred L. "Principal warps: Thin-plate splines and the |
| decomposition of deformations," IEEE Transactions on pattern analysis |
| and machine intelligence 11.6 (1989): 567–585. |
| DOI:`10.1109/34.24792` |
| https://user.engineering.uiowa.edu/~aip/papers/bookstein-89.pdf |
| |
| Examples |
| -------- |
| >>> import skimage as ski |
| |
| Define source and destination control points such that they simulate |
| rotating by 90 degrees and generate a meshgrid from them: |
| |
| >>> src = np.array([[0, 0], [0, 5], [5, 5], [5, 0]]) |
| >>> dst = np.array([[5, 0], [0, 0], [0, 5], [5, 5]]) |
| |
| Estimate the transformation: |
| |
| >>> tps = ski.transform.ThinPlateSplineTransform.from_estimate(src, dst) |
| |
| Appyling the transformation to `src` approximates `dst`: |
| |
| >>> np.round(tps(src), 4) # doctest: +FLOAT_CMP |
| array([[5., 0.], |
| [0., 0.], |
| [0., 5.], |
| [5., 5.]]) |
| |
| Create a meshgrid to apply the transformation to: |
| |
| >>> grid = np.meshgrid(np.arange(5), np.arange(5)) |
| >>> grid[1] |
| array([[0, 0, 0, 0, 0], |
| [1, 1, 1, 1, 1], |
| [2, 2, 2, 2, 2], |
| [3, 3, 3, 3, 3], |
| [4, 4, 4, 4, 4]]) |
| |
| >>> coords = np.vstack([grid[0].ravel(), grid[1].ravel()]).T |
| >>> transformed = tps(coords) |
| >>> np.round(transformed[:, 1]).reshape(5, 5).astype(int) |
| array([[0, 1, 2, 3, 4], |
| [0, 1, 2, 3, 4], |
| [0, 1, 2, 3, 4], |
| [0, 1, 2, 3, 4], |
| [0, 1, 2, 3, 4]]) |
| |
| The estimation can fail - for example, if all the input or output points |
| are the same. If this happens, you will get a transform that is not |
| "truthy" - meaning that ``bool(tform)`` is ``False``: |
| |
| >>> if tps: |
| ... print("Estimation succeeded.") |
| Estimation succeeded. |
| |
| Not so for a degenerate transform with identical points. |
| |
| >>> bad_src = np.ones((4, 2)) |
| >>> bad_tps = ski.transform.ThinPlateSplineTransform.from_estimate( |
| ... bad_src, dst) |
| >>> if not bad_tps: |
| ... print("Estimation failed.") |
| Estimation failed. |
| |
| Trying to use this failed estimation transform result will give a suitable |
| error: |
| |
| >>> bad_tps.params # doctest: +IGNORE_EXCEPTION_DETAIL |
| Traceback (most recent call last): |
| ... |
| FailedEstimationAccessError: No attribute "params" for failed estimation ... |
| """ |
|
|
| def __init__(self): |
| self._estimated = False |
| self._spline_mappings = None |
| self.src = None |
|
|
| def __call__(self, coords): |
| """Estimate the transformation from a set of corresponding points. |
| |
| Parameters |
| ---------- |
| coords : (N, 2) array_like |
| x, y coordinates to transform |
| |
| Returns |
| ------- |
| transformed_coords: (N, D) array |
| Destination coordinates |
| """ |
| if self._spline_mappings is None: |
| msg = ( |
| "Transformation is undefined, define it by calling `estimate` " |
| "before applying it" |
| ) |
| raise ValueError(msg) |
| coords = np.array(coords) |
|
|
| if coords.ndim != 2 or coords.shape[1] != 2: |
| msg = "Input `coords` must have shape (N, 2)" |
| raise ValueError(msg) |
|
|
| radial_dist = self._radial_distance(coords) |
| transformed_coords = self._spline_function(coords, radial_dist) |
|
|
| return transformed_coords |
|
|
| @property |
| def inverse(self): |
| raise NotImplementedError("Not supported") |
|
|
| @classmethod |
| def from_estimate(cls, src, dst) -> Self | FailedEstimation: |
| """Estimate optimal spline mappings between source and destination points. |
| |
| Parameters |
| ---------- |
| src : (N, 2) array_like |
| Control points at source coordinates. |
| dst : (N, 2) array_like |
| Control points at destination coordinates. |
| |
| Returns |
| ------- |
| tform : Self or ``FailedEstimation`` |
| An instance of the transformation if the estimation succeeded. |
| Otherwise, we return a special ``FailedEstimation`` object to |
| signal a failed estimation. Testing the truth value of the failed |
| estimation object will return ``False``. E.g. |
| |
| .. code-block:: python |
| |
| tform = ThinPlateSplineTransform.from_estimate(...) |
| if not tform: |
| raise RuntimeError(f"Failed estimation: {tf}") |
| |
| Notes |
| ----- |
| The number N of source and destination points must match. |
| """ |
| tf = cls() |
| msg = tf._estimate(src, dst) |
| return tf if msg is None else FailedEstimation(f'{cls.__name__}: {msg}') |
|
|
| def _estimate(self, src, dst): |
| """Try to estimate and return reason if estimation fails.""" |
| check_nD(src, 2, arg_name="src") |
| check_nD(dst, 2, arg_name="dst") |
|
|
| if src.shape[0] < 3 or dst.shape[0] < 3: |
| msg = "Need at least 3 points in in `src` and `dst`" |
| raise ValueError(msg) |
| if src.shape != dst.shape: |
| msg = f"Shape of `src` and `dst` didn't match, {src.shape} != {dst.shape}" |
| raise ValueError(msg) |
|
|
| self.src = src |
| n, d = src.shape |
|
|
| dist = distance_matrix(src, src) |
| K = self._radial_basis_kernel(dist) |
| P = np.hstack([np.ones((n, 1)), src]) |
| n_plus_3 = n + 3 |
| L = np.zeros((n_plus_3, n_plus_3), dtype=np.float32) |
| L[:n, :n] = K |
| L[:n, -3:] = P |
| L[-3:, :n] = P.T |
| V = np.vstack([dst, np.zeros((d + 1, d))]) |
| try: |
| self._spline_mappings = np.linalg.solve(L, V) |
| except np.linalg.LinAlgError: |
| return 'Unable to solve for spline mappings' |
| return None |
|
|
| def _radial_distance(self, coords): |
| """Compute the radial distance between input points and source points.""" |
| dists = distance_matrix(coords, self.src) |
| return self._radial_basis_kernel(dists) |
|
|
| def _spline_function(self, coords, radial_dist): |
| """Estimate the spline function in X and Y directions.""" |
| n = self.src.shape[0] |
| w = self._spline_mappings[:n] |
| a = self._spline_mappings[n:] |
| transformed_coords = a[0] + np.dot(coords, a[1:]) + np.dot(radial_dist, w) |
| return transformed_coords |
|
|
| @staticmethod |
| def _radial_basis_kernel(r): |
| """Compute the radial basis function for thin-plate splines. |
| |
| Parameters |
| ---------- |
| r : (4, N) ndarray |
| Input array representing the Euclidean distance between each pair of |
| two collections of control points. |
| |
| Returns |
| ------- |
| U : (4, N) ndarray |
| Calculated kernel function U. |
| """ |
| _small = 1e-8 |
| r_sq = r**2 |
| U = np.where(r == 0.0, 0.0, r_sq * np.log(r_sq + _small)) |
| return U |
|
|
| @_deprecate_estimate |
| def estimate(self, src, dst): |
| """Estimate optimal spline mappings between source and destination points. |
| |
| Parameters |
| ---------- |
| src : (N, 2) array_like |
| Control points at source coordinates. |
| dst : (N, 2) array_like |
| Control points at destination coordinates. |
| |
| Returns |
| ------- |
| success: bool |
| True indicates that the estimation was successful. |
| |
| Notes |
| ----- |
| The number N of source and destination points must match. |
| """ |
| return self._estimate(src, dst) is None |
|
|
