transform

Module: transform

downscale_local_mean

skimage.transform.downscale_local_mean(image, factors, cval=0, clip=True)[source]

通过局部平均下采样N维图像。

如果图像cval不能被整数因子完全整除，则会填充图像。

与skimage.transform.resize和skimage.transform.rescale中的2-D插值相比，此功能可应用于N维图像，并计算输入图像中每个尺寸因子块中元素的局部平均值。

例子

>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> downscale_local_mean(a, (2, 3))
array([[ 3.5,  4. ],
       [ 5.5,  4.5]])

estimate_transform

skimage.transform.estimate_transform(ttype, src, dst, **kwargs)[source]

估计2D几何变换参数。

您可以使用总体最小二乘法确定过度，好和欠定参数。

源和目标坐标的数量必须匹配。

例子

>>> import numpy as np
>>> from skimage import transform as tf

>>> # estimate transformation parameters
>>> src = np.array([0, 0, 10, 10]).reshape((2, 2))
>>> dst = np.array([12, 14, 1, -20]).reshape((2, 2))

>>> tform = tf.estimate_transform('similarity', src, dst)

>>> np.allclose(tform.inverse(tform(src)), src)
True

>>> # warp image using the estimated transformation
>>> from skimage import data
>>> image = data.camera()

>>> warp(image, inverse_map=tform.inverse) 

>>> # create transformation with explicit parameters
>>> tform2 = tf.SimilarityTransform(scale=1.1, rotation=1,
...     translation=(10, 20))

>>> # unite transformations, applied in order from left to right
>>> tform3 = tform + tform2
>>> np.allclose(tform3(src), tform2(tform(src)))
True

frt2

skimage.transform.frt2(a)[source]

计算nxn整数阵列的二维有限氡变换（FRT）。

扩展内容

ifrt2 二维反转FRT。

笔记

当且仅当n是素数时，FRT才有唯一的逆。FRT这个算法的想法是归功于Vlad Negnevitski。

参考

例子

生成测试图像：使用素数作为数组维度

>>> SIZE = 59
>>> img = np.tri(SIZE, dtype=np.int32)

应用有限Radon变换：

>>> f = frt2(img)

hough_circle

skimage.transform.hough_circle(image, radius, normalize=True, full_output=False)[source]

执行循环Hough变换。

例子

>>> from skimage.transform import hough_circle
>>> from skimage.draw import circle_perimeter
>>> img = np.zeros((100, 100), dtype=np.bool_)
>>> rr, cc = circle_perimeter(25, 35, 23)
>>> img[rr, cc] = 1
>>> try_radii = np.arange(5, 50)
>>> res = hough_circle(img, try_radii)
>>> ridx, r, c = np.unravel_index(np.argmax(res), res.shape)
>>> r, c, try_radii[ridx]
(25, 35, 23)

hough_circle_peaks

skimage.transform.hough_circle_peaks(hspaces, radii, min_xdistance=1, min_ydistance=1, threshold=None, num_peaks=inf, total_num_peaks=inf, normalize=False)[source]

在圆圈中返回峰值Hough变换。

标识霍夫空间中以特定距离分隔的最显着的圆圈。在霍夫空间的第一维和第二维中分别应用具有不同大小的非最大抑制来识别峰。

例子

>>> from skimage import transform as tf
>>> from skimage import draw
>>> img = np.zeros((120, 100), dtype=int)
>>> radius, x_0, y_0 = (20, 99, 50)
>>> y, x = draw.circle_perimeter(y_0, x_0, radius)
>>> img[x, y] = 1
>>> hspaces = tf.hough_circle(img, radius)
>>> accum, cx, cy, rad = hough_circle_peaks(hspaces, [radius,])

hough_ellipse

skimage.transform.hough_ellipse(img, threshold=4, accuracy=1, min_size=4, max_size=None)[source]

执行椭圆Hough变换。

笔记

必须选择精度以在累加器分布中产生峰值。换句话说，一个低值的扁平蓄能器分配可能是由于箱体尺寸太小造成的。

参考

例子

>>> from skimage.transform import hough_ellipse
>>> from skimage.draw import ellipse_perimeter
>>> img = np.zeros((25, 25), dtype=np.uint8)
>>> rr, cc = ellipse_perimeter(10, 10, 6, 8)
>>> img[cc, rr] = 1
>>> result = hough_ellipse(img, threshold=8)
>>> result.tolist()
[(10, 10.0, 10.0, 8.0, 6.0, 0.0)]

hough_line

skimage.transform.hough_line(img, theta=None)[source]

执行直线Hough变换。

笔记

原点是原始图像的左上角。X和Y轴分别是水平和垂直边缘。距离是从原点到检测线的最小代数距离。通过减小theta阵列中的步长可以提高角度精度。

例子

生成测试图像：

>>> img = np.zeros((100, 150), dtype=bool)
>>> img[30, :] = 1
>>> img[:, 65] = 1
>>> img[35:45, 35:50] = 1
>>> for i in range(90):
...     img[i, i] = 1
>>> img += np.random.random(img.shape) > 0.95

应用霍夫变换：

>>> out, angles, d = hough_line(img)

import numpy as np
import matplotlib.pyplot as plt

from skimage.transform import hough_line
from skimage.draw import line

img = np.zeros((100, 150), dtype=bool)
img[30, :] = 1
img[:, 65] = 1
img[35:45, 35:50] = 1
rr, cc = line(60, 130, 80, 10)
img[rr, cc] = 1
img += np.random.random(img.shape) > 0.95

out, angles, d = hough_line(img)

fix, axes = plt.subplots(1, 2, figsize=(7, 4))

axes[0].imshow(img, cmap=plt.cm.gray)
axes[0].set_title('Input image')

axes[1].imshow(
    out, cmap=plt.cm.bone,
    extent=(np.rad2deg(angles[-1]), np.rad2deg(angles[0]), d[-1], d[0]))
axes[1].set_title('Hough transform')
axes[1].set_xlabel('Angle (degree)')
axes[1].set_ylabel('Distance (pixel)')

plt.tight_layout()
plt.show()

(Source code, png, pdf)

hough_line_peaks

skimage.transform.hough_line_peaks(hspace, angles, dists, min_distance=9, min_angle=10, threshold=None, num_peaks=inf)[source]

用直线Hough变换返回峰值。

标识Hough变换中以特定角度和距离分隔的最显着线条。在霍夫空间的第一（距离）和第二（角度）维度中分别应用具有不同尺寸的非最大抑制来识别峰值。

例子

>>> from skimage.transform import hough_line, hough_line_peaks
>>> from skimage.draw import line
>>> img = np.zeros((15, 15), dtype=np.bool_)
>>> rr, cc = line(0, 0, 14, 14)
>>> img[rr, cc] = 1
>>> rr, cc = line(0, 14, 14, 0)
>>> img[cc, rr] = 1
>>> hspace, angles, dists = hough_line(img)
>>> hspace, angles, dists = hough_line_peaks(hspace, angles, dists)
>>> len(angles)
2

ifrt2

skimage.transform.ifrt2(a)[source]

计算（n + 1）xn整数阵列的二维逆有限氡变换（iFRT）。

扩展内容

frt2 二维FRT

笔记

当且仅当n是素数时，FRT才有唯一的逆。有关概述，请参阅[R481]。这个算法的想法是归功于Vlad Negnevitski。

参考

例子

>>> SIZE = 59
>>> img = np.tri(SIZE, dtype=np.int32)

应用有限Radon变换：

>>> f = frt2(img)

应用逆有限Radon变换来恢复输入

>>> fi = ifrt2(f)

检查它是否与原件相同

>>> assert len(np.nonzero(img-fi)[0]) == 0

integral_image

skimage.transform.integral_image(img)[source]

积分图像/求和区域表。

积分图像包含上面和左边的所有元素的总和，即：

[Sm, n = \sum_{i \leq m} \sum_{j \leq n} Xi, j]

参考

整合

skimage.transform.integrate(ii, start, end, *args)[source]

使用积分图像整合给定的窗口。

例子

>>> arr = np.ones((5, 6), dtype=np.float)
>>> ii = integral_image(arr)
>>> integrate(ii, (1, 0), (1, 2))  # sum from (1, 0) to (1, 2)
array([ 3.])
>>> integrate(ii, [(3, 3)], [(4, 5)])  # sum from (3, 3) to (4, 5)
array([ 6.])
>>> # sum from (1, 0) to (1, 2) and from (3, 3) to (4, 5)
>>> integrate(ii, [(1, 0), (3, 3)], [(1, 2), (4, 5)])
array([ 3.,  6.])

路径

skimage.transform.iradon(radon_image, theta=None, output_size=None, filter='ramp', interpolation='linear', circle=None)[source]

逆氡变换。

使用滤波反投影算法重建氡变换的图像。

笔记

它应用傅里叶切片定理通过将滤波器的频域与投影数据的FFT相乘来重建图像。这种算法被称为滤波反投影。

参考

iradon_sart

skimage.transform.iradon_sart(radon_image, theta=None, image=None, projection_shifts=None, clip=None, relaxation=0.15)[source]

逆氡变换

使用同时代数重建技术（SART）算法的单次迭代重建来自氡变换的图像。

笔记

代数重建技术是基于将层析成像重建问题制定为一组线性方程。沿着每条射线，投影值是沿射线横截面的所有值的总和。SART的一个典型特征（以及代数技术的一些其他变体）是，它使用横截面的像素值之间的线性插值对沿着射线的等距点处的横截面进行采样。然后使用稍微修改的Kaczmarz方法求解得到的一组线性方程组。

使用SART时，单次迭代通常足以获得良好的重建。进一步的迭代将趋于增强高频信息，但也会经常增加噪声。

参考

matrix_transform

skimage.transform.matrix_transform(coords, matrix)[source]

应用2D矩阵变换。

order_angles_golden_ratio

skimage.transform.order_angles_golden_ratio(theta)[source]

订购角度可减少后续投影中相关信息的数量。

笔记

这里使用的方法是由T. Kohler引入的黄金比例。

参考

probabilistic_hough_line

skimage.transform.probabilistic_hough_line(img, threshold=10, line_length=50, line_gap=10, theta=None)[source]

从渐进概率线Hough变换中返回线。

参考

pyramid_expand

skimage.transform.pyramid_expand(image, upscale=2, sigma=None, order=1, mode='reflect', cval=0)[source]

使用Upsample然后平滑图像。

参考

pyramid_gaussian

skimage.transform.pyramid_gaussian(image, max_layer=-1, downscale=2, sigma=None, order=1, mode='reflect', cval=0)[source]

由输入图像形成的高斯金字塔的产量图像。

递归地将该pyramid_reduce函数应用于图像，并生成缩小的图像。

请注意，金字塔的第一个图像将是原始的未缩放图像。图像的总数是max_layer + 1。在计算所有图层的情况下，最后的图像可以是单像素图像，也可以是缩小图形不会改变的图像。

参考

pyramid_laplacian

skimage.transform.pyramid_laplacian(image, max_layer=-1, downscale=2, sigma=None, order=1, mode='reflect', cval=0)[source]

由输入图像形成的拉普拉斯金字塔的产量图像。

每个图层包含下采样和下采样平滑图像之间的差异：

layer = resize(prev_layer) - smooth(resize(prev_layer))

请注意，金字塔的第一个图像将是原始未缩放图像与其平滑版本之间的差异。图像的总数是max_layer + 1。在计算所有图层的情况下，最后的图像可以是单像素图像，也可以是缩小图形不会改变的图像。

参考

pyramid_reduce

skimage.transform.pyramid_reduce(image, downscale=2, sigma=None, order=1, mode='reflect', cval=0)[source]

平滑然后下采样图像。

参考

氡

skimage.transform.radon(image, theta=None, circle=None)[source]

计算指定投影角度下图像的氡变换。

笔记

根据Justin K. Romberg的代码（http://www.clear.rice.edu/elec431/projects96/DSP/bpanalysis.html）

参考

重新调整

skimage.transform.rescale(image, scale, order=1, mode=None, cval=0, clip=True, preserve_range=False)[source]

按一定的因子缩放图像。

对高档或低档图像执行插值。要通过应用函数或算术平均值对具有整数因子的N维图像进行下采样，请分别参阅skimage.measure.block_reduce和skimage.transform.downscale_local_mean。

| 其他参数：|

| | 顺序：int，可选样条插补的顺序，默认为1.顺序必须在0-5范围内。有关详细信息，请参阅skimage.transform.warp。模式：{'constant'，'edge'，'symmetric'，'reflect'，'wrap'}，可选的输入边界外的点根据给定的模式填充。模式与numpy.pad的行为相匹配。默认模式是'常量'。cval：float，可选与模式“常​​量”一起使用，即图像边界外的值。clip：bool，可选是否将输出剪切到输入图像的值范围。这是默认启用的，因为更高阶插值可能产生超出给定输入范围的值。preserve_range：bool，可选是否保留原始值的范围。除此以外，输入图像按照img_as_float的惯例转换。|

例子

>>> from skimage import data
>>> from skimage.transform import rescale
>>> image = data.camera()
>>> rescale(image, 0.1, mode='reflect').shape
(51, 51)
>>> rescale(image, 0.5, mode='reflect').shape
(256, 256)

调整

skimage.transform.resize(image, output_shape, order=1, mode=None, cval=0, clip=True, preserve_range=False)[source]

调整图像的大小以匹配一定的大小。

对最大尺寸或最小尺寸的图像执行插值。对于通过应用函数或算术平均值下采样N维图像，分别参见skimage.measure.block_reduce和skimage.transform.downscale_local_mean。

| 其他参数：|

| | 顺序：int，可选样条插补的顺序，默认为1.顺序必须在0-5范围内。有关详细信息，请参阅skimage.transform.warp。模式：{'constant'，'edge'，'symmetric'，'reflect'，'wrap'}，可选的输入边界外的点根据给定的模式填充。模式与numpy.pad的行为相匹配。默认模式是'常量'。cval：float，可选与模式“常​​量”一起使用，即图像边界外的值。clip：bool，可选是否将输出剪切到输入图像的值范围。这是默认启用的，因为更高阶插值可能产生超出给定输入范围的值。preserve_range：bool，可选是否保留原始值的范围。除此以外，输入图像按照img_as_float的惯例转换。|

笔记

模式的“反射”和“对称”是相似的，但在反射期间边缘像素是否重复有所不同。作为一个例子，如果一个数组的值为0,1,2，并且使用对称填充到右边的四个值，结果将是0,1,2,2,1,0,0，而为了反映它将是0，1，2，1，0，1，2。

例子

>>> from skimage import data
>>> from skimage.transform import resize
>>> image = data.camera()
>>> resize(image, (100, 100), mode='reflect').shape
(100, 100)

回转

skimage.transform.rotate(image, angle, resize=False, center=None, order=1, mode='constant', cval=0, clip=True, preserve_range=False)[source]

围绕其中心旋转图像一定角度。

| 其他参数：|

| | 顺序：int，可选样条插补的顺序，默认为1.顺序必须在0-5范围内。有关详细信息，请参阅skimage.transform.warp。模式：{'constant'，'edge'，'symmetric'，'reflect'，'wrap'}，可选的输入边界外的点根据给定的模式填充。模式与numpy.pad的行为相匹配。cval：float，可选与模式“常​​量”一起使用，即图像边界外的值。clip：bool，可选是否将输出剪切到输入图像的值范围。这是默认启用的，因为更高阶插值可能产生超出给定输入范围的值。preserve_range：bool，可选是否保留原始值的范围。否则，输入图像将根据img_as_float的惯例进行转换。|

例子

>>> from skimage import data
>>> from skimage.transform import rotate
>>> image = data.camera()
>>> rotate(image, 2).shape
(512, 512)
>>> rotate(image, 2, resize=True).shape
(530, 530)
>>> rotate(image, 90, resize=True).shape
(512, 512)

seam_carve

skimage.transform.seam_carve(img, energy_map, mode, num, border=1, force_copy=True)[source]

雕刻图像的垂直或水平接缝。

从图像中挖出垂直/水平接缝，同时使用给定的能量图来确定每个像素的重要性。

参考

漩涡

skimage.transform.swirl(image, center=None, strength=1, radius=100, rotation=0, output_shape=None, order=1, mode=None, cval=0, clip=True, preserve_range=False)[source]

执行旋流转换。

| 其他参数：|

| | output_shape：元组（行，列），可选生成输出图像的形状。默认情况下，输入图像的形状被保留。顺序：int，可选样条插补的顺序，默认为1.顺序必须在0-5范围内。有关详细信息，请参阅skimage.transform.warp。模式：{'constant'，'edge'，'symmetric'，'reflect'，'wrap'}，可选的输入边界外的点根据给定的模式填充，'constant'用作默认值。模式与numpy.pad的行为相匹配。cval：float，可选与模式“常​​量”一起使用，即图像边界外的值。clip：bool，可选是否将输出剪切到输入图像的值范围。这是默认启用的，因为更高阶插值可能产生超出给定输入范围的值。preserve_range：bool，可选是否保留原始值的范围。否则，输入图像将根据img_as_float的惯例进行转换。|

warp

skimage.transform.warp(image, inverse_map, map_args={}, output_shape=None, order=1, mode='constant', cval=0.0, clip=True, preserve_range=False)[source]

根据给定的坐标变换来变形图像。

• 对于二维图像，您可以直接传递一个转换对象，例如skimage.transform.SimilarityTransform或其逆。

• 对于二维图像，可以传递一个(3, 3)齐次变换矩阵，例如skimage.transform.SimilarityTransform.params。

• 对于二维图像，将输出图像中(M, 2)的(col, row)坐标数组转换为输入图像中相应坐标的函数。通过指定函数的额外参数map_args。

• 对于ND图像，您可以直接传递一组坐标。第一个维度指定输入图像中的坐标，后续维度则确定输出图像中的位置。例如在二维图像的情况下，您需要传递一个形状数组(2, rows, cols)，rows并cols确定输出图像的形状，第一个维度包含(row, col)输入图像中的坐标。查看scipy.ndimage.map_coordinates更多文档。

请注意，(3, 3)矩阵被解释为齐次变换矩阵，因此如果输出是形状的，则不能从3D输入中插值(3,)。

查看使用示例部分。

map_args : dict, optional

关键字参数传递给inverse_map。

output_shape : tuple (rows, cols), optional

生成输出图像的形状。默认情况下，输入图像的形状被保留。请注意，即使对于多波段图像，也只需要指定行和列。

order : int, optional

插值的顺序。订单必须在0-5的范围内：

• 0：最近邻居

• 1：双线性（默认）

• 2：双二次方

• 3：双立方

• 4：双四次

• 5：双五次

模式：{'常量'，'边缘'，'对称'，'反射'，'包'}，可选

根据给定的模式填充输入边界外的点。模式匹配的行为numpy.pad。

cval : float, optional

与模式“常​​量”一起使用，即图像边界外的值。

clip : bool, optional

是否将输出剪切到输入图像的值范围。这是默认启用的，因为更高阶插值可能产生超出给定输入范围的值。

preserve_range : bool, optional

是否保持原有的价值范围。否则，输入图像按照惯例转换img_as_float。

Returns:  **warped** : double ndarray

扭曲的输入图像。

笔记

• 输入图像被转换为double图像。

• 在相似变换，AffineTransform和ProjectiveTransform的情况下，此函数使用基础变换矩阵以更快的例程扭曲图像。

例子

>>> from skimage.transform import warp
>>> from skimage import data
>>> image = data.camera()

以下图像扭曲都相同，但执行时间差异很大。图像转移到底部。

使用几何变换翘曲图像（快速）：

>>> from skimage.transform import SimilarityTransform
>>> tform = SimilarityTransform(translation=(0, -10))
>>> warped = warp(image, tform)

使用可调用（缓慢）：

>>> def shift_down(xy):
...     xy[:, 1] -= 10
...     return xy
>>> warped = warp(image, shift_down)

使用变换矩阵扭曲图像（快速）：

>>> matrix = np.array([[1, 0, 0], [0, 1, -10], [0, 0, 1]])
>>> warped = warp(image, matrix)
>>> from skimage.transform import ProjectiveTransform
>>> warped = warp(image, ProjectiveTransform(matrix=matrix))

您也可以使用几何变换（快速）的倒数：

>>> warped = warp(image, tform.inverse)

对于ND图像，您可以传递坐标数组，该坐标数组指定输出图像中每个元素的输入图像中的坐标。例如，如果你想重新调整3D立方体，你可以这样做：

>>> cube_shape = np.array([30, 30, 30])
>>> cube = np.random.rand(*cube_shape)

设置定义缩放的坐标数组：

>>> scale = 0.1
>>> output_shape = (scale * cube_shape).astype(int)
>>> coords0, coords1, coords2 = np.mgrid[:output_shape[0],
...                    :output_shape[1], :output_shape[2]]
>>> coords = np.array([coords0, coords1, coords2])

假设立方体包含空间数据，其中第一个数组元素中心位于实际空间中的坐标（0.5,0.5,0.5）处，即在缩放图像时我们必须考虑这个额外的偏移量：

>>> coords = (coords + 0.5) / scale - 0.5
>>> warped = warp(cube, coords)

warp_coords

skimage.transform.warp_coords(coord_map, shape, dtype=<class 'numpy.float64'>)[source]

构建二维图像扭曲输出的源坐标。

笔记

这是一个较低级别的例程，用于生成2维图像的源坐标warp()。

warp与用户分开提供，以便为希望例如重新使用特定坐标映射的用户提供额外的灵活性，以便在图像变形过程中的各个点上使用特定的dtype，或者实现不同的后处理逻辑比warp在调用之后执行ndi.map_coordinates。

例子

生成一张坐标图，将图像上下移动到右侧：

>>> from skimage import data
>>> from scipy.ndimage import map_coordinates
>>>
>>> def shift_up10_left20(xy):
...     return xy - np.array([-20, 10])[None, :]
>>>
>>> image = data.astronaut().astype(np.float32)
>>> coords = warp_coords(shift_up10_left20, image.shape)
>>> warped_image = map_coordinates(image, coords)

AffineTransform

class skimage.transform.AffineTransform(matrix=None, scale=None, rotation=None, shear=None, translation=None)[source]

Bases: skimage.transform._geometric.ProjectiveTransform

二维仿射变换的形式：

X = a0*x + a1*y + a2 == sx*x*cos(rotation) - sy*y*sin(rotation + shear) + a2Y = b0*x + b1*y + b2 == sx*x*sin(rotation) + sy*y*cos(rotation + shear) + b2

其中sx和sy是x和y方向上的比例因子，并且齐次变换矩阵是：

[[a0  a1  a2]
 [b0  b1  b2]
 [0   0    1]]

属性

__init__(matrix=None, scale=None, rotation=None, shear=None, translation=None)[source]rotationscalesheartranslation

EssentialMatrixTransform

class skimage.transform.EssentialMatrixTransform(rotation=None, translation=None, matrix=None)[source]

Bases: skimage.transform._geometric.FundamentalMatrixTransform

基本矩阵变换。

基本矩阵与一对校准图像之间的对应点相关联。该矩阵将一幅图像中的归一化，均匀图像点转换为另一幅图像中的核线。

基本矩阵仅限于捕获非平面场景的一对运动图像。在纯旋转或平面场景的情况下，单应性描述两个图像（ProjectiveTransform）之间的几何关系。如果图像的内在校准是未知的，则基本矩阵描述两幅图像（FundamentalMatrixTransform）之间的投影关系。

参考

属性

__init__(rotation=None, translation=None, matrix=None)[source]estimate(src, dst)[source]

使用8点算法估算基本矩阵。

8点算法需要至少8个相应的点对用于良好条件的解，否则估计出超定解。

EuclideanTransform

class skimage.transform.EuclideanTransform(matrix=None, rotation=None, translation=None)[source]

Bases: skimage.transform._geometric.ProjectiveTransform

二维欧几里德变换的形式：

X = a0 * x - b0 * y + a1 == x * cos(rotation) - y * sin(rotation) + a1Y = b0 * x + a0 * y + b1 == x * sin(rotation) + y * cos(rotation) + b1

齐次变换矩阵是：

[[a0  b0  a1]
 [b0  a0  b1]
 [0   0    1]]

欧几里德变换是一种具有旋转和平移参数的刚性变换。相似变换扩展了欧几里德变换的单一比例因子。

属性

__init__(matrix=None, rotation=None, translation=None)[source]estimate(src, dst)[source]

估计一组相应点的转换。

您可以使用总体最小二乘法确定过度，好和欠定参数。

源和目标坐标的数量必须匹配。

rotationtranslation

FundamentalMatrixTransform

class skimage.transform.FundamentalMatrixTransform(matrix=None)[source]

Bases: skimage.transform._geometric.GeometricTransform

基本矩阵变换。

基本矩阵与一对未校准图像之间的对应点相关联。该矩阵将一幅图像中的同质像点转换为另一幅图像中的核线。

基本矩阵仅为一对运动图像定义。在纯旋转或平面场景的情况下，单应性描述两个图像（ProjectiveTransform）之间的几何关系。如果图像的固有校准是已知的，则基本矩阵描述两个图像（EssentialMatrixTransform）之间的度量关系。

参考

属性

__init__(matrix=None)[source]estimate(src, dst)[source]

使用8点算法估计基本矩阵。

8点算法需要至少8个相应的点对用于良好条件的解，否则估计出超定解。

inverse(coords)[source]

应用逆变换。

residuals(src, dst)[source]

计算桑普森距离。

桑普森距离是几何误差的第一个近似值。

PiecewiseAffineTransform

class skimage.transform.PiecewiseAffineTransform[source]

Bases: skimage.transform._geometric.GeometricTransform

二维分段仿射变换。

控制点用于定义映射。该变换基于形成网格的点的Delaunay三角剖分。每个三角形用于查找局部仿射变换。

属性

__init__()[source]estimate(src, dst)[source]

估计一组相应点的转换。

源和目标坐标的数量必须匹配。

inverse(coords)[source]

应用逆变换。

网格外部的坐标将被设置为- 1。

PolynomialTransform

class skimage.transform.PolynomialTransform(params=None)[source]

Bases: skimage.transform._geometric.GeometricTransform

二维多项式的形式转换：

X = sum[j=0:order]( sum[i=0:j]( a_ji * x**(j - i) * y**i ))
Y = sum[j=0:order]( sum[i=0:j]( b_ji * x**(j - i) * y**i ))

属性

__init__(params=None)[source]estimate(src, dst, order=2)[source]

估计一组相应点的转换。

您可以使用总体最小二乘法确定过度，好和欠定参数。

源和目标坐标的数量必须匹配。

转换被定义为：

X = sum[j=0:order]( sum[i=0:j]( a_ji * x**(j - i) * y**i ))
Y = sum[j=0:order]( sum[i=0:j]( b_ji * x**(j - i) * y**i ))

这些等式可以转换为以下形式：

0 = sum[j=0:order]( sum[i=0:j]( a_ji * x**(j - i) * y**i )) - X
0 = sum[j=0:order]( sum[i=0:j]( b_ji * x**(j - i) * y**i )) - Y

对于每组对应的点都存在，所以我们有一组N * 2个方程。系数呈线性，所以我们可以写出A x = 0，其中：

A   = [[1 x y x**2 x*y y**2 ... 0 ...             0 -X]
       [0 ...                 0 1 x y x**2 x*y y**2 -Y]
        ...
        ...
      ]
x.T = [a00 a10 a11 a20 a21 a22 ... ann
       b00 b10 b11 b20 b21 b22 ... bnn c3]

在总最小二乘的情况下，这个齐次系统方程组的解是A的右奇异向量，其对应于系数c3规定的最小奇异值。

inverse(coords)[source]

ProjectiveTransform

class skimage.transform.ProjectiveTransform(matrix=None)[source]

Bases: skimage.transform._geometric.GeometricTransform

射影变换。

在坐标上应用投影变换（单应性）。

对于每个齐次坐标（\ mathbf {x} = x，y，1 ^ T），其目标位置通过与给定矩阵（H）相乘来计算得到（H \ mathbf {x}）：

[[a0 a1 a2]
 [b0 b1 b2]
 [c0 c1 1 ]].

例如，要顺时针旋转θ度，矩阵应该是：

[[cos(theta) -sin(theta) 0]
 [sin(theta)  cos(theta) 0]
 [0            0         1]]

或者，将x翻译10和y 20：

[[1 0 10]
 [0 1 20]
 [0 0 1 ]].

属性

__init__(matrix=None)[source]estimate(src, dst)[source]

估计一组相应点的转换。

您可以使用总体最小二乘法确定过度，好和欠定参数。

源和目标坐标的数量必须匹配。

转换被定义为：

X = (a0*x + a1*y + a2) / (c0*x + c1*y + 1)
Y = (b0*x + b1*y + b2) / (c0*x + c1*y + 1)

这些等式可以转换为以下形式：

0 = a0*x + a1*y + a2 - c0*x*X - c1*y*X - X
0 = b0*x + b1*y + b2 - c0*x*Y - c1*y*Y - Y

对于每组对应的点都存在，所以我们有一组N * 2个方程。系数呈线性，所以我们可以写出A x = 0，其中：

A   = [[x y 1 0 0 0 -x*X -y*X -X]
       [0 0 0 x y 1 -x*Y -y*Y -Y]
        ...
        ...
      ]
x.T = [a0 a1 a2 b0 b1 b2 c0 c1 c3]

在总最小二乘的情况下，这个齐次系统方程组的解是A的右奇异向量，其对应于系数c3规定的最小奇异值。

在仿射变换的情况下，系数c0和c1是0.因此方程组是：

A   = [[x y 1 0 0 0 -X]
       [0 0 0 x y 1 -Y]
        ...
        ...
      ]
x.T = [a0 a1 a2 b0 b1 b2 c3]

inverse(coords)[source]

应用逆变换。

SimilarityTransform

class skimage.transform.SimilarityTransform(matrix=None, scale=None, rotation=None, translation=None)[source]

Bases: skimage.transform._geometric.EuclideanTransform

2D形式的相似变换：

X = a0 * x - b0 * y + a1 == s * x * cos(rotation) - s * y * sin(rotation) + a1Y = b0 * x + a0 * y + b1 == s * x * sin(rotation) + s * y * cos(rotation) + b1

其中s是比例因子，齐次变换矩阵是：

[[a0  b0  a1]
 [b0  a0  b1]
 [0   0    1]]

除了旋转和平移参数外，相似变换还扩展了欧几里德变换的单一比例因子。

属性

__init__(matrix=None, scale=None, rotation=None, translation=None)[source]estimate(src, dst)[source]

估计一组相应点的转换。

您可以使用总体最小二乘法确定过度，好和欠定参数。

源和目标坐标的数量必须匹配。

scale