Refactor geometric transforms.

2026-08-12 12:30:16 +08:00 · 2012-07-20 17:57:15 -04:00
parent 8e8e2b99a0
commit a130b8d2d9
6 changed files with 830 additions and 914 deletions
@@ -0,0 +1,160 @@
+from ._geometric import warp, ProjectiveTransform
+import numpy as np
+
+def _swirl_mapping(xy, center, rotation, strength, radius):
+    x, y = xy.T
+    x0, y0 = center
+    rho = np.sqrt((x - x0) ** 2 + (y - y0) ** 2)
+
+    # Ensure that the transformation decays to approximately 1/1000-th
+    # within the specified radius.
+    radius = radius / 5 * np.log(2)
+
+    theta = rotation + strength * \
+            np.exp(-rho / radius) + \
+            np.arctan2(y - y0, x - x0)
+
+    xy[..., 0] = x0 + rho * np.cos(theta)
+    xy[..., 1] = y0 + rho * np.sin(theta)
+
+    return xy
+
+
+def swirl(image, center=None, strength=1, radius=100, rotation=0,
+          output_shape=None, order=1, mode='constant', cval=0):
+    """Perform a swirl transformation.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    center : (x,y) tuple or (2,) ndarray
+        Center coordinate of transformation.
+    strength : float
+        The amount of swirling applied.
+    radius : float
+        The extent of the swirl in pixels.  The effect dies out
+        rapidly beyond `radius`.
+    rotation : float
+        Additional rotation applied to the image.
+
+    Returns
+    -------
+    swirled : ndarray
+        Swirled version of the input.
+
+    Other parameters
+    ----------------
+    output_shape : tuple or ndarray
+        Size of the generated output image.
+    order : int
+        Order of splines used in interpolation.  See
+        `scipy.ndimage.map_coordinates` for detail.
+    mode : string
+        How to handle values outside the image borders.  See
+        `scipy.ndimage.map_coordinates` for detail.
+    cval : string
+        Used in conjunction with mode 'constant', the value outside
+        the image boundaries.
+
+    """
+
+    if center is None:
+        center = np.array(image.shape)[:2] / 2
+
+    warp_args = {'center': center,
+                 'rotation': rotation,
+                 'strength': strength,
+                 'radius': radius}
+
+    return warp(image, _swirl_mapping, map_args=warp_args,
+                output_shape=output_shape,
+                order=order, mode=mode, cval=cval)
+
+
+def homography(image, H, output_shape=None, order=1,
+               mode='constant', cval=0.):
+    """Perform a projective transformation (homography) on an image.
+
+    For each pixel, given its homogeneous coordinate :math:`\mathbf{x}
+    = [x, y, 1]^T`, its target position is calculated by multiplying
+    with the given matrix, :math:`H`, to give :math:`H \mathbf{x}`.
+    E.g., to rotate by theta degrees clockwise, the matrix should be
+
+    ::
+
+      [[cos(theta) -sin(theta) 0]
+       [sin(theta)  cos(theta) 0]
+       [0            0         1]]
+
+    or, to translate x by 10 and y by 20,
+
+    ::
+
+      [[1 0 10]
+       [0 1 20]
+       [0 0 1 ]].
+
+    Parameters
+    ----------
+    image : 2-D array
+        Input image.
+    H : array of shape ``(3, 3)``
+        Transformation matrix H that defines the homography.
+    output_shape : tuple (rows, cols)
+        Shape of the output image generated.
+    order : int
+        Order of splines used in interpolation.
+    mode : string
+        How to handle values outside the image borders.  Passed as-is
+        to ndimage.
+    cval : string
+        Used in conjunction with mode 'constant', the value outside
+        the image boundaries.
+
+    Examples
+    --------
+    >>> # rotate by 90 degrees around origin and shift down by 2
+    >>> x = np.arange(9, dtype=np.uint8).reshape((3, 3)) + 1
+    >>> x
+    array([[1, 2, 3],
+           [4, 5, 6],
+           [7, 8, 9]], dtype=uint8)
+    >>> theta = -np.pi/2
+    >>> M = np.array([[np.cos(theta),-np.sin(theta),0],
+    ...               [np.sin(theta), np.cos(theta),2],
+    ...               [0,             0,            1]])
+    >>> x90 = homography(x, M, order=1)
+    >>> x90
+    array([[3, 6, 9],
+           [2, 5, 8],
+           [1, 4, 7]], dtype=uint8)
+    >>> # translate right by 2 and down by 1
+    >>> y = np.zeros((5,5), dtype=np.uint8)
+    >>> y[1, 1] = 255
+    >>> y
+    array([[  0,   0,   0,   0,   0],
+           [  0, 255,   0,   0,   0],
+           [  0,   0,   0,   0,   0],
+           [  0,   0,   0,   0,   0],
+           [  0,   0,   0,   0,   0]], dtype=uint8)
+    >>> M = np.array([[ 1.,  0.,  2.],
+    ...               [ 0.,  1.,  1.],
+    ...               [ 0.,  0.,  1.]])
+    >>> y21 = homography(y, M, order=1)
+    >>> y21
+    array([[  0,   0,   0,   0,   0],
+           [  0,   0,   0,   0,   0],
+           [  0,   0,   0, 255,   0],
+           [  0,   0,   0,   0,   0],
+           [  0,   0,   0,   0,   0]], dtype=uint8)
+
+    """
+    import warnings
+    warnings.warn('the homography function is deprecated; '
+                  'use the `warp` and `tform` function instead',
+                  category=DeprecationWarning)
+
+    tform = ProjectiveTransform(H)
+    return warp(image, inverse_map=tform.inverse, output_shape=output_shape,
+                order=order, mode=mode, cval=cval)