skimage.transform#
此模块包含用于转换图像和体积数据的工具。
几何变换：这些变换改变图像的形状或位置。它们对于图像配准、对齐和几何校正等任务很有用。示例：
AffineTransform、ProjectiveTransform、EuclideanTransform.图像缩放和重新缩放：这些变换改变图像的大小或分辨率。它们对于对图像进行降采样以减小其大小或对图像进行上采样以提高其分辨率等任务很有用。示例：
resize()、rescale().特征检测和提取：这些变换识别和提取图像中的特定特征或模式。它们对于物体检测、图像分割和特征匹配等任务很有用。示例：
hough_circle()、pyramid_expand()、radon().图像变换：这些变换改变图像的外观，但不改变其内容。它们对于创建图像马赛克、应用艺术效果和可视化图像数据等任务很有用。示例：
warp()、iradon().
通过局部平均对 N 维图像进行降采样。 |
|
估计 2D 几何变换参数。 |
|
计算输入数组的二维有限 Radon 变换 (FRT)。 |
|
执行圆形霍夫变换。 |
|
返回圆形霍夫变换中的峰值。 |
|
执行椭圆霍夫变换。 |
|
执行直线霍夫变换。 |
|
返回直线霍夫变换中的峰值。 |
|
计算输入数组的二维逆有限 Radon 变换 (iFRT)。 |
|
积分图像/累积区域表。 |
|
使用积分图像在给定窗口上进行积分。 |
|
逆 Radon 变换。 |
|
逆 Radon 变换。 |
|
应用 2D 矩阵变换。 |
|
对角度进行排序，以减少后续投影中相关信息的量。 |
|
从渐进式概率直线霍夫变换中返回直线。 |
|
上采样然后平滑图像。 |
|
生成由输入图像形成的高斯金字塔的图像。 |
|
生成由输入图像形成的拉普拉斯金字塔的图像。 |
|
平滑然后对图像进行降采样。 |
|
计算给定投影角度的图像的 Radon 变换。 |
|
按特定因子缩放图像。 |
|
调整图像大小以匹配特定大小。 |
|
使用局部平均/双线性缩放调整数组大小。 |
|
围绕其中心将图像旋转特定角度。 |
|
执行螺旋变换。 |
|
根据给定的坐标变换扭曲图像。 |
|
为二维图像扭曲的输出构建源坐标。 |
|
将图像重新映射到极坐标或对数极坐标空间。 |
|
仿射变换。 |
|
本质矩阵变换。 |
|
欧几里得变换，也称为刚性变换。 |
|
基础矩阵变换。 |
|
分段仿射变换。 |
|
二维多项式变换。 |
|
投影变换。 |
|
相似变换。 |
|
薄板样条变换。 |
- skimage.transform.downscale_local_mean(image, factors, cval=0, clip=True)[source]#
通过局部平均对 N 维图像进行降采样。
如果图像不能被整数因子完美地整除，则用 cval 填充图像。
与
skimage.transform.resize和skimage.transform.rescale中的插值不同，此函数计算输入图像中每个大小为 factors 的块的元素的局部平均值。- 参数：:
- image(M[, …]) ndarray
输入图像。
- factorsarray_like
包含沿每个轴的降采样整数因子的数组。
- cvalfloat, optional
如果图像不能被整数因子完美地整除，则为常量填充值。
- clipbool, optional
未用，但保留在此处以保持与该模块中其他变换的 API 一致。(假设提供的 cval 也在该范围内，局部平均值永远不会超出输入图像中值的范围。)
- 返回值：
- imagendarray
与输入图像具有相同维数的降采样图像。对于整数输入，输出 dtype 将为
float64。有关详细信息，请参见numpy.mean()。
示例
>>> 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]])
- skimage.transform.estimate_transform(ttype, src, dst, *args, **kwargs)[source]#
估计 2D 几何变换参数。
您可以使用总体最小二乘法确定超定、适定和欠定参数。
源和目标坐标的数量必须匹配。
- 参数：:
- ttype{‘euclidean’, similarity’, ‘affine’, ‘piecewise-affine’, ‘projective’, ‘polynomial’}
变换类型。
- kwargsarray_like 或 int
函数参数 (src, dst, n, angle)
NAME / TTYPE FUNCTION PARAMETERS 'euclidean' `src, `dst` 'similarity' `src, `dst` 'affine' `src, `dst` 'piecewise-affine' `src, `dst` 'projective' `src, `dst` 'polynomial' `src, `dst`, `order` (polynomial order, default order is 2)另请参见下面的示例。
- 返回值：
- tform
_GeometricTransform 变换对象，包含变换参数并提供对正向和逆变换函数的访问。
- tform
示例
>>> import numpy as np >>> import skimage as ski
>>> # estimate transformation parameters >>> src = np.array([0, 0, 10, 10]).reshape((2, 2)) >>> dst = np.array([12, 14, 1, -20]).reshape((2, 2))
>>> tform = ski.transform.estimate_transform('similarity', src, dst)
>>> np.allclose(tform.inverse(tform(src)), src) True
>>> # warp image using the estimated transformation >>> image = ski.data.camera()
>>> ski.transform.warp(image, inverse_map=tform.inverse)
>>> # create transformation with explicit parameters >>> tform2 = ski.transform.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
- skimage.transform.frt2(a)[source]#
计算输入数组的二维有限 Radon 变换 (FRT)。
- 参数：:
- andarray of int, shape (M, M)
输入数组。
- 返回值：
- FRTndarray of int, shape (M+1, M)
有限 Radon 变换系数数组。
另请参见
ifrt2二维逆 FRT。
备注
当且仅当 M 为素数时，FRT 具有唯一的逆。[FRT] 此算法的思想归功于 Vlad Negnevitski。
参考文献
[FRT]A. Kingston 和 I. Svalbe，“周期性离散图像数组上的投影变换”，P. Hawkes (Ed)，成像与电子物理学进展，139 (2006)
示例
生成测试图像：对数组维度使用素数
>>> SIZE = 59 >>> img = np.tri(SIZE, dtype=np.int32)
应用有限 Radon 变换
>>> f = frt2(img)
- skimage.transform.hough_circle(image, radius, normalize=True, full_output=False)[source]#
执行圆形霍夫变换。
- 参数：:
- imagendarray，形状 (M, N)
输入图像，其中非零值代表边缘。
- radius标量或标量序列
计算霍夫变换的半径。浮点数将转换为整数。
- normalize布尔值，可选
使用用于绘制半径的像素数量对累加器进行归一化。
- full_output布尔值，可选
将输出大小扩展到最大半径的两倍，以便检测输入图片外部的中心。
- 返回值：
- Hndarray，形状 (半径索引, M + 2R, N + 2R)
每个半径的霍夫变换累加器。如果 full_output 为 True，则 R 代表较大的半径。否则，R = 0。
示例
>>> from skimage.transform import hough_circle >>> from skimage.draw import circle_perimeter >>> img = np.zeros((100, 100), dtype=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)
- 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]#
返回圆形霍夫变换中的峰值。
识别给定霍夫空间中以一定距离隔开的最大圆形。在霍夫空间的第一维和第二维上分别应用不同尺寸的非极大值抑制来识别峰值。对于半径不同但距离接近的圆形，只保留峰值最高的圆形。
- 参数：:
- hspaces(M, N, P) 数组
由
hough_circle函数返回的霍夫空间。- radii(M,) 数组
对应于霍夫空间的半径。
- min_xdistance整数，可选
在 x 维度上分离中心的最小距离。
- min_ydistance整数，可选
在 y 维度上分离中心的最小距离。
- threshold浮点数，可选
每个霍夫空间中峰值的最小强度。默认值为 0.5 * max(hspace)。
- num_peaks整数，可选
每个霍夫空间中峰值的最大数量。当峰值数量超过 num_peaks 时，只考虑基于峰值强度的 num_peaks 个坐标，用于相应的半径。
- total_num_peaks整数，可选
峰值的最大数量。当峰值数量超过 num_peaks 时，返回基于峰值强度的 num_peaks 个坐标。
- normalize布尔值，可选
如果为 True，则根据半径对累加器进行归一化，以对突出的峰值进行排序。
- 返回值：
- accum, cx, cy, rad数组元组
霍夫空间中的峰值、x 和 y 中心坐标以及半径。
备注
半径更大的圆形在霍夫空间中具有更高的峰值。如果更大的圆形比更小的圆形更可取，则 normalize 应该为 False。否则，将按投票数量递减的顺序返回圆形。
示例
>>> from skimage import transform, 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 = transform.hough_circle(img, radius) >>> accum, cx, cy, rad = hough_circle_peaks(hspaces, [radius,])
- skimage.transform.hough_ellipse(image, threshold=4, accuracy=1, min_size=4, max_size=None)[source]#
执行椭圆霍夫变换。
- 参数：:
- image(M, N) ndarray
输入图像，其中非零值代表边缘。
- threshold整数，可选
累加器阈值。较低的值将返回更多的椭圆。
- accuracy双精度浮点数，可选
累加器中使用的短轴上的仓格大小。较高的值将返回更多的椭圆，但会导致对短轴长度的估计精度降低。
- min_size整数，可选
最小的长轴长度。
- max_size整数，可选
最大的短轴长度。如果为 None，则该值设置为较小图像尺寸的一半。
- 返回值：
- result具有字段 [(accumulator, yc, xc, a, b, orientation)] 的 ndarray。
其中
(yc, xc)是中心，(a, b)分别是长轴和短轴。 orientation 值遵循skimage.draw.ellipse_perimeter约定。
备注
图像中潜在的椭圆由它们的长轴和短轴长度来表征。对于图像中至少相隔 min_size 的一半的任何一对非零像素，累加器会跟踪使用所有其他非零像素形成的潜在椭圆的短轴长度。如果那些累积的短轴长度的直方图中的任何一个仓格（bin_size = accuracy * accuracy）高于 threshold，则将相应的椭圆添加到结果中。
因此，较高的 accuracy 将导致在图像中发现更多的椭圆，但会以对短轴长度的估计精度降低为代价。
参考文献
[1]Xie, Yonghong, and Qiang Ji. “A new efficient ellipse detection method.” Pattern Recognition, 2002. Proceedings. 16th International Conference on. Vol. 2. IEEE, 2002
示例
>>> 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)]
- skimage.transform.hough_line(image, theta=None)[source]#
执行直线霍夫变换。
- 参数：:
- image(M, N) ndarray
输入图像，其中非零值代表边缘。
- theta双精度浮点数的 ndarray，形状 (K,)，可选
计算变换的角度，以弧度表示。默认值为 [-pi/2, pi/2) 范围内均匀间隔的 180 个角度的向量。
- 返回值：
- hspaceuint64 的 ndarray，形状 (P, Q)
霍夫变换累加器。
- anglesndarray
计算变换的角度，以弧度表示。
- distancesndarray
距离值。
备注
原点是原始图像的左上角。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 >>> rng = np.random.default_rng() >>> img += rng.random(img.shape) > 0.95
应用霍夫变换
>>> out, angles, d = hough_line(img)
- skimage.transform.hough_line_peaks(hspace, angles, dists, min_distance=9, min_angle=10, threshold=None, num_peaks=inf)[source]#
返回直线霍夫变换中的峰值。
识别霍夫变换中以一定角度和距离隔开的最大直线。在霍夫空间的第一维（距离）和第二维（角度）上分别应用不同尺寸的非极大值抑制来识别峰值。
- 参数：:
- hspacendarray，形状 (M, N)
由
hough_line函数返回的霍夫空间。- angles数组，形状 (N,)
由
hough_line函数返回的角度。假设是连续的。(angles[-1] - angles[0] == PI)。- dists数组，形状 (M,)
由
hough_line函数返回的距离。- min_distance整数，可选
分离直线的最小距离（霍夫空间第一维的最大过滤器大小）。
- min_angle整数，可选
分离直线的最小角度（霍夫空间第二维的最大过滤器大小）。
- threshold浮点数，可选
峰值的最小强度。默认值为 0.5 * max(hspace)。
- num_peaks整数，可选
峰值的最大数量。当峰值数量超过 num_peaks 时，返回基于峰值强度的 num_peaks 个坐标。
- 返回值：
- accum, angles, dists数组元组
霍夫空间中的峰值、角度和距离。
示例
>>> from skimage.transform import hough_line, hough_line_peaks >>> from skimage.draw import line >>> img = np.zeros((15, 15), dtype=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
- skimage.transform.ifrt2(a)[source]#
计算输入数组的二维逆有限 Radon 变换 (iFRT)。
- 参数：:
- a整数的 ndarray，形状 (M+1, M)
输入数组。
- 返回值：
- iFRT整数的 ndarray，形状 (M, M)
逆有限Radon变换系数。
另请参见
frt2二维FRT
备注
当且仅当 M 为素数时，FRT 具有唯一的逆。有关概述，请参见 [1]。该算法的想法来自 Vlad Negnevitski。
参考文献
[1]A. Kingston 和 I. Svalbe，“周期性离散图像数组上的投影变换”，P. Hawkes (Ed)，成像与电子物理学进展，139 (2006)
示例
>>> 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
- skimage.transform.integral_image(image, *, dtype=None)[source]#
积分图像/累积区域表。
积分图像包含它上面和左边的所有元素的总和，即
\[S[m, n] = \sum_{i \leq m} \sum_{j \leq n} X[i, j]\]- 参数：:
- imagendarray
输入图像。
- 返回值：
- Sndarray
与输入图像形状相同的积分图像/累积区域表。
备注
为了获得更好的精度并避免潜在的溢出，当使用默认的 dtype 为 None 时，输出的数据类型可能与输入的不同。对于整数类型的输入，其行为与
numpy.cumsum()的行为一致。浮点输入将被提升到至少双精度。用户可以设置 dtype 来覆盖此行为。参考文献
[1]F.C. Crow, “Summed-area tables for texture mapping,” ACM SIGGRAPH Computer Graphics, vol. 18, 1984, pp. 207-212.
- skimage.transform.integrate(ii, start, end)[source]#
使用积分图像在给定窗口上进行积分。
- 参数：:
- iindarray
积分图像。
- start元组列表，每个元组的长度等于 ii 的维数
窗口(s)左上角的坐标。列表中的每个元组包含起始行、列、… 索引，即 [(row_win1, col_win1, …), (row_win2, col_win2,…), …]。
- end元组列表，每个元组的长度等于 ii 的维数
窗口(s)右下角的坐标。列表中的每个元组包含结束行、列、… 索引，即 [(row_win1, col_win1, …), (row_win2, col_win2, …), …]。
- 返回值：
- S标量或 ndarray
给定窗口(s)上的积分（总和）。
另请参见
integral_image创建积分图像/累积区域表。
示例
>>> arr = np.ones((5, 6), dtype=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_name='ramp', interpolation='linear', circle=True, preserve_range=True)[source]#
逆 Radon 变换。
使用过滤反投影算法从 Radon 变换重建图像。
- 参数：:
- radon_imagendarray
包含 Radon 变换（正弦图）的图像。图像的每一列对应于沿不同角度的投影。断层扫描旋转轴应位于像素索引
radon_image.shape[0] // 2处，沿着radon_image的第 0 维。- thetaarray, optional
重建角度（以度为单位）。默认值：m 个角度均匀分布在 0 到 180 之间（如果 radon_image 的形状为 (N, M)）。
- output_sizeint, optional
重建中行和列的数量。
- filter_namestr, optional
在频域滤波中使用的滤波器。默认使用斜坡滤波器。可用的滤波器：斜坡、shepp-logan、余弦、汉明、汉宁。分配 None 表示不使用滤波器。
- interpolationstr, optional
重建中使用的插值方法。可用的方法：‘linear’、‘nearest’ 和 ‘cubic’（‘cubic’ 很慢）。
- circleboolean, optional
假设重建图像在内切圆之外为零。还会更改默认的 output_size 以匹配使用
circle=True调用的radon的行为。- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- 返回值：
- reconstructedndarray
重建图像。旋转轴将位于索引为
(reconstructed.shape[0] // 2, reconstructed.shape[1] // 2)的像素中。
在版本 0.19 中更改: 在
iradon中，filter参数已被弃用，取而代之的是filter_name。
备注
它应用傅立叶切片定理，通过将滤波器的频域与投影数据的 FFT 相乘来重建图像。该算法称为过滤反投影。
参考文献
[1]AC Kak, M Slaney, “Principles of Computerized Tomographic Imaging”, IEEE Press 1988.
[2]B.R. Ramesh, N. Srinivasa, K. Rajgopal, “An Algorithm for Computing the Discrete Radon Transform With Some Applications”, Proceedings of the Fourth IEEE Region 10 International Conference, TENCON ‘89, 1989
- skimage.transform.iradon_sart(radon_image, theta=None, image=None, projection_shifts=None, clip=None, relaxation=0.15, dtype=None)[source]#
逆 Radon 变换。
使用一次 Simultaneous Algebraic Reconstruction Technique (SART) 算法迭代从 Radon 变换重建图像。
- 参数：:
- radon_imagendarray, shape (M, N)
包含 Radon 变换（正弦图）的图像。图像的每一列对应于沿不同角度的投影。断层扫描旋转轴应位于像素索引
radon_image.shape[0] // 2处，沿着radon_image的第 0 维。- thetaarray, shape (N,), optional
重建角度（以度为单位）。默认值：m 个角度均匀分布在 0 到 180 之间（如果 radon_image 的形状为 (N, M)）。
- imagendarray, shape (M, M), optional
包含初始重建估计的图像。默认值为零数组。
- projection_shiftsarray, shape (N,), optional
在重建图像之前，将
radon_image（正弦图）中包含的投影移动此处的像素数。第 i 个值定义radon_image的第 i 列的移动。- clip长度为 2 的浮点数序列，可选
强制重建断层扫描中所有值位于
[clip[0], clip[1]]范围内- relaxationfloat, optional
更新步骤的松弛参数。较高的值可以提高收敛速度，但会带来不稳定性的风险。接近或高于 1 的值不推荐使用。
- dtypedtype, optional
输出数据类型，必须是浮点数。默认情况下，如果输入数据类型不是浮点数，则将输入转换为双精度，否则将 dtype 设置为输入数据类型。
- 返回值：
- reconstructedndarray
重建图像。旋转轴将位于索引为
(reconstructed.shape[0] // 2, reconstructed.shape[1] // 2)的像素中。
备注
代数重建技术基于将断层扫描重建问题表述为一组线性方程。沿每条射线，投影值是沿射线的横截面所有值的总和。SART 的一个典型特征（以及一些其他变体的代数技术）是它使用横截面像素值的线性插值，沿射线以等距点对横截面进行采样。然后使用略微修改的 Kaczmarz 方法求解得到的线性方程组。
使用 SART 时，一次迭代通常足以获得良好的重建。进一步的迭代将倾向于增强高频信息，但也会经常增加噪声。
参考文献
[1]AC Kak, M Slaney, “Principles of Computerized Tomographic Imaging”, IEEE Press 1988.
[2]AH Andersen, AC Kak, “Simultaneous algebraic reconstruction technique (SART): a superior implementation of the ART algorithm”, Ultrasonic Imaging 6 pp 81–94 (1984)
[3]S Kaczmarz, “Angenäherte auflösung von systemen linearer gleichungen”, Bulletin International de l’Academie Polonaise des Sciences et des Lettres 35 pp 355–357 (1937)
[4]Kohler, T. “A projection access scheme for iterative reconstruction based on the golden section.” Nuclear Science Symposium Conference Record, 2004 IEEE. Vol. 6. IEEE, 2004.
[5]Kaczmarz’ 方法，维基百科，https://en.wikipedia.org/wiki/Kaczmarz_method
- skimage.transform.matrix_transform(coords, matrix)[source]#
应用 2D 矩阵变换。
- 参数：:
- coords(N, 2) array_like
要转换的 x, y 坐标
- matrix(3, 3) array_like
齐次变换矩阵。
- 返回值：
- coords(N, 2) array
变换后的坐标。
- skimage.transform.order_angles_golden_ratio(theta)[source]#
对角度进行排序，以减少后续投影中相关信息的量。
- 参数：:
- theta浮点数数组，形状 (M,)
投影角度，单位为度。不允许出现重复的角度。
- 返回值：
- indices_generator生成无符号整数的生成器
返回的生成器生成指向
theta的索引，使得theta[indices]给出投影的近似黄金分割排序。总共，生成len(theta)个索引。所有非负整数 <len(theta)恰好生成一次。
备注
这里使用的方法是 T. Kohler 提出的黄金分割法。
参考文献
[1]Kohler, T. “A projection access scheme for iterative reconstruction based on the golden section.” Nuclear Science Symposium Conference Record, 2004 IEEE. Vol. 6. IEEE, 2004.
[2]Winkelmann, Stefanie, et al. “An optimal radial profile order based on the Golden Ratio for time-resolved MRI.” Medical Imaging, IEEE Transactions on 26.1 (2007): 68-76.
- skimage.transform.probabilistic_hough_line(image, threshold=10, line_length=50, line_gap=10, theta=None, rng=None)[source]#
从渐进式概率直线霍夫变换中返回直线。
- 参数：:
- imagendarray，形状 (M, N)
输入图像，其中非零值代表边缘。
- threshold整数，可选
阈值
- line_lengthint，可选
检测到的线的最小接受长度。增加参数以提取更长的线。
- line_gapint，可选
像素之间形成一条线的最大间隙。增加参数以更积极地合并断裂的线。
- thetadtype 类型的 ndarray，形状 (K,)，可选
计算变换的角度，以弧度表示。默认值为 [-pi/2, pi/2) 范围内均匀间隔的 180 个角度的向量。
- rng{
numpy.random.Generator, int}，可选 伪随机数生成器。默认情况下，使用 PCG64 生成器（参见
numpy.random.default_rng()）。如果 rng 是一个整数，它将被用来为生成器设置种子。
- 返回值：
- lines列表
识别出的线列表，线格式为 ((x0, y0), (x1, y1))，表示线起点和终点。
参考文献
[1]C. Galamhos, J. Matas and J. Kittler, “Progressive probabilistic Hough transform for line detection”, in IEEE Computer Society Conference on Computer Vision and Pattern Recognition, 1999.
- skimage.transform.pyramid_expand(image, upscale=2, sigma=None, order=1, mode='reflect', cval=0, preserve_range=False, *, channel_axis=None)[source]#
上采样然后平滑图像。
- 参数：:
- imagendarray
输入图像。
- upscalefloat，可选
放大倍数。
- sigmafloat，可选
高斯滤波器的 sigma。默认为 2 * upscale / 6.0，它对应于一个大小为缩放因子两倍的滤波器掩码，该掩码覆盖了 99% 以上的高斯分布。
- orderint，可选
上采样插值中使用的样条曲线阶数。有关详细信息，请参阅
skimage.transform.warp。- mode{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}，可选
mode 参数决定如何处理数组边界，其中 cval 是 mode 等于 ‘constant’ 时的值。
- cvalfloat, optional
如果 mode 为 ‘constant’，则填充输入边缘之外的值。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- channel_axisint 或 None，可选
如果为 None，则图像被认为是灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
在版本 0.19 中添加：
channel_axis在 0.19 中添加。
- 返回值：
- out数组
上采样和平滑后的浮点图像。
参考文献
- skimage.transform.pyramid_gaussian(image, max_layer=-1, downscale=2, sigma=None, order=1, mode='reflect', cval=0, preserve_range=False, *, channel_axis=None)[source]#
生成由输入图像形成的高斯金字塔的图像。
递归地将
pyramid_reduce函数应用于图像，并生成下采样后的图像。注意金字塔的第一张图像是原始的，未缩放的图像。图像总数为 max_layer + 1。如果计算所有层，最后一幅图像是单像素图像或缩减不会改变其形状的图像。
- 参数：:
- imagendarray
输入图像。
- max_layerint，可选
金字塔的层数。第 0 层是原始图像。默认为 -1，它构建所有可能的层。
- downscalefloat，可选
缩小倍数。
- sigmafloat，可选
高斯滤波器的 sigma。默认为 2 * downscale / 6.0，它对应于一个大小为缩放因子两倍的滤波器掩码，该掩码覆盖了 99% 以上的高斯分布。
- orderint，可选
下采样插值中使用的样条曲线阶数。有关详细信息，请参阅
skimage.transform.warp。- mode{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}，可选
mode 参数决定如何处理数组边界，其中 cval 是 mode 等于 ‘constant’ 时的值。
- cvalfloat, optional
如果 mode 为 ‘constant’，则填充输入边缘之外的值。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- channel_axisint 或 None，可选
如果为 None，则图像被认为是灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
在版本 0.19 中添加：
channel_axis在 0.19 中添加。
- 返回值：
- pyramid生成器
生成金字塔层作为浮点图像的生成器。
参考文献
- skimage.transform.pyramid_laplacian(image, max_layer=-1, downscale=2, sigma=None, order=1, mode='reflect', cval=0, preserve_range=False, *, channel_axis=None)[source]#
生成由输入图像形成的拉普拉斯金字塔的图像。
每一层都包含下采样图像与其下采样、平滑图像之间的差异
layer = resize(prev_layer) - smooth(resize(prev_layer))
注意金字塔的第一张图像是原始的，未缩放的图像与其平滑版本之间的差异。图像总数为 max_layer + 1。如果计算所有层，最后一幅图像是单像素图像或缩减不会改变其形状的图像。
- 参数：:
- imagendarray
输入图像。
- max_layerint，可选
金字塔的层数。第 0 层是原始图像。默认为 -1，它构建所有可能的层。
- downscalefloat，可选
缩小倍数。
- sigmafloat，可选
高斯滤波器的 sigma。默认为 2 * downscale / 6.0，它对应于一个大小为缩放因子两倍的滤波器掩码，该掩码覆盖了 99% 以上的高斯分布。
- orderint，可选
下采样插值中使用的样条曲线阶数。有关详细信息，请参阅
skimage.transform.warp。- mode{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}，可选
mode 参数决定如何处理数组边界，其中 cval 是 mode 等于 ‘constant’ 时的值。
- cvalfloat, optional
如果 mode 为 ‘constant’，则填充输入边缘之外的值。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- channel_axisint 或 None，可选
如果为 None，则图像被认为是灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
在版本 0.19 中添加：
channel_axis在 0.19 中添加。
- 返回值：
- pyramid生成器
生成金字塔层作为浮点图像的生成器。
参考文献
- skimage.transform.pyramid_reduce(image, downscale=2, sigma=None, order=1, mode='reflect', cval=0, preserve_range=False, *, channel_axis=None)[source]#
平滑然后对图像进行降采样。
- 参数：:
- imagendarray
输入图像。
- downscalefloat，可选
缩小倍数。
- sigmafloat，可选
高斯滤波器的 sigma。默认为 2 * downscale / 6.0，它对应于一个大小为缩放因子两倍的滤波器掩码，该掩码覆盖了 99% 以上的高斯分布。
- orderint，可选
下采样插值中使用的样条曲线阶数。有关详细信息，请参阅
skimage.transform.warp。- mode{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}，可选
mode 参数决定如何处理数组边界，其中 cval 是 mode 等于 ‘constant’ 时的值。
- cvalfloat, optional
如果 mode 为 ‘constant’，则填充输入边缘之外的值。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- channel_axisint 或 None，可选
如果为 None，则图像被认为是灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
在版本 0.19 中添加：
channel_axis在 0.19 中添加。
- 返回值：
- out数组
平滑并下采样的浮点图像。
参考文献
- skimage.transform.radon(image, theta=None, circle=True, *, preserve_range=False)[source]#
计算给定投影角度的图像的 Radon 变换。
- 参数：:
- imagendarray
输入图像。旋转轴将位于索引为
(image.shape[0] // 2, image.shape[1] // 2)的像素处。- thetaarray, optional
投影角度（以度为单位）。如果为 None，则该值设置为 np.arange(180)。
- circleboolean, optional
假设图像在内切圆之外为零，使每个投影的宽度（正弦图的第一维）等于
min(image.shape)。- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- 返回值：
- radon_imagendarray
Radon 变换（正弦图）。断层扫描旋转轴将位于
radon_image.shape[0] // 2索引处的像素，沿着radon_image的第 0 维。
备注
基于 Justin K. Romberg 的代码 (https://www.clear.rice.edu/elec431/projects96/DSP/bpanalysis.html)
参考文献
[1]AC Kak, M Slaney, “Principles of Computerized Tomographic Imaging”, IEEE Press 1988.
[2]B.R. Ramesh, N. Srinivasa, K. Rajgopal, “An Algorithm for Computing the Discrete Radon Transform With Some Applications”, Proceedings of the Fourth IEEE Region 10 International Conference, TENCON ‘89, 1989
- skimage.transform.rescale(image, scale, order=None, mode='reflect', cval=0, clip=True, preserve_range=False, anti_aliasing=None, anti_aliasing_sigma=None, *, channel_axis=None)[source]#
按特定因子缩放图像。
对 N 维图像进行插值以进行上采样或下采样。注意，在缩小图像时应启用抗锯齿以避免锯齿状伪影。对于使用整数因子的下采样，另请参阅
skimage.transform.downscale_local_mean。- 参数：:
- image(M, N[, …][, C]) ndarray
输入图像。
- scale{float, tuple of floats}
空间维度的缩放因子。可以定义为 (m, n[, …]) 的单独缩放因子。
- 返回值：
- scaledndarray
输入的缩放版本。
- 其他参数：
- orderint，可选
样条插值的阶数，默认为 0（如果 image.dtype 为 bool）或 1（否则）。阶数必须在 0-5 范围内。有关详细信息，请参阅
skimage.transform.warp。- mode{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional
根据给定的模式填充输入边界之外的点。模式与
numpy.pad的行为相匹配。- cvalfloat, optional
与模式 'constant' 结合使用，图像边界之外的值。
- clipbool, optional
是否将输出剪切到输入图像的值范围内。默认情况下，此选项已启用，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- anti_aliasingbool, optional
是否在缩小图像之前应用高斯滤波器来平滑图像。在缩小图像时进行滤波对于避免出现锯齿状伪影至关重要。如果输入图像数据类型为 bool，则不应用抗锯齿。
- anti_aliasing_sigma{float, tuple of floats}, optional
用于避免锯齿状伪影的高斯滤波的标准差。默认情况下，此值选择为 (s - 1) / 2，其中 s 是缩小因子。
- channel_axisint 或 None，可选
如果为 None，则图像被认为是灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
在版本 0.19 中添加：
channel_axis在 0.19 中添加。
备注
模式 'reflect' 和 'symmetric' 类似，但在反射期间边缘像素是否被复制方面有所不同。例如，如果一个数组的值为 [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 rescale >>> image = data.camera() >>> rescale(image, 0.1).shape (51, 51) >>> rescale(image, 0.5).shape (256, 256)
- skimage.transform.resize(image, output_shape, order=None, mode='reflect', cval=0, clip=True, preserve_range=False, anti_aliasing=None, anti_aliasing_sigma=None)[source]#
调整图像大小以匹配特定大小。
对 N 维图像进行插值以进行上采样或下采样。注意，在缩小图像时应启用抗锯齿以避免锯齿状伪影。对于使用整数因子的下采样，另请参阅
skimage.transform.downscale_local_mean。- 参数：:
- imagendarray
输入图像。
- output_shapeiterable
生成的输出图像的大小 (rows, cols[, …][, dim])。如果未提供 dim，则通道数将保留。如果输入通道数不等于输出通道数，则将应用 N 维插值。
- 返回值：
- resizedndarray
输入的调整大小的版本。
- 其他参数：
- orderint，可选
样条插值的阶数，默认为 0（如果 image.dtype 为 bool）或 1（否则）。阶数必须在 0-5 范围内。有关详细信息，请参阅
skimage.transform.warp。- mode{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional
根据给定的模式填充输入边界之外的点。模式与
numpy.pad的行为相匹配。- cvalfloat, optional
与模式 'constant' 结合使用，图像边界之外的值。
- clipbool, optional
是否将输出剪切到输入图像的值范围内。默认情况下，此选项已启用，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- anti_aliasingbool, optional
是否在缩小采样之前应用高斯滤波器来平滑图像。在缩小采样图像时进行滤波对于避免出现锯齿状伪影至关重要。如果未指定，则在下采样数据类型不为 bool 的图像时将其设置为 True。在使用最近邻插值 (
order== 0) 且输入数据类型为整数的情况下，它也设置为 False。- anti_aliasing_sigma{float, tuple of floats}, optional
用于抗锯齿时的高斯滤波的标准差。默认情况下，此值选择为 (s - 1) / 2，其中 s 是缩小采样因子，其中 s > 1。对于上采样情况，s < 1，在缩放之前不执行抗锯齿。
备注
模式 'reflect' 和 'symmetric' 类似，但在反射期间边缘像素是否被复制方面有所不同。例如，如果一个数组的值为 [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)).shape (100, 100)
- skimage.transform.resize_local_mean(image, output_shape, grid_mode=True, preserve_range=False, *, channel_axis=None)[source]#
使用局部平均/双线性缩放调整数组大小。
- 参数：:
- imagendarray
输入图像。如果这是一个多通道图像，则应使用 channel_axis 指定与通道相对应的轴。
- output_shapeiterable
生成的输出图像的大小。当 channel_axis 不为 None 时，channel_axis 应从 output_shape 中省略，或者
output_shape[channel_axis]必须与image.shape[channel_axis]相匹配。如果 output_shape 的长度超过 image.ndim，则根据需要将额外的单元素维度追加到输入image。- grid_modebool, optional
定义
image像素位置：如果为 True，则假定像素位于网格交叉点，否则位于单元格中心。因此，例如，长度为 5 的一维信号在 grid_mode 为 False 时被认为长度为 4，但在 grid_mode 为 True 时长度为 5。请参见以下视觉说明| pixel 1 | pixel 2 | pixel 3 | pixel 4 | pixel 5 | |<-------------------------------------->| vs. |<----------------------------------------------->|上图中箭头起点对应于每种模式下的坐标位置 0。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- 返回值：
- resizedndarray
输入的调整大小的版本。
备注
此方法有时被称为“基于区域”插值或“像素混合”插值 [1]。当 grid_mode 为 True 时，它等效于使用 OpenCV 的 resize 且 INTER_AREA 插值模式。它通常用于图像缩小。如果缩小因子为整数，则应优先使用
downscale_local_mean。参考文献
示例
>>> from skimage import data >>> from skimage.transform import resize_local_mean >>> image = data.camera() >>> resize_local_mean(image, (100, 100)).shape (100, 100)
- skimage.transform.rotate(image, angle, resize=False, center=None, order=None, mode='constant', cval=0, clip=True, preserve_range=False)[source]#
围绕其中心将图像旋转特定角度。
- 参数：:
- imagendarray
输入图像。
- anglefloat
逆时针方向的旋转角度（单位为度）。
- resizebool, optional
确定输出图像的形状是否会自动计算，以便完整旋转的图像完全匹配。默认为 False。
- center长度为 2 的可迭代对象
旋转中心。如果
center=None，则图像绕其中心旋转，即center=(cols / 2 - 0.5, rows / 2 - 0.5)。请注意，此参数为 (cols, rows)，与正常的 skimage 排序相反。
- 返回值：
- rotatedndarray
输入的旋转版本。
- 其他参数：
- orderint，可选
样条插值的阶数，默认为 0（如果 image.dtype 为 bool）或 1（否则）。阶数必须在 0-5 范围内。有关详细信息，请参阅
skimage.transform.warp。- mode{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional
根据给定的模式填充输入边界之外的点。模式与
numpy.pad的行为相匹配。- cvalfloat, optional
与模式 'constant' 结合使用，图像边界之外的值。
- clipbool, optional
是否将输出剪切到输入图像的值范围内。默认情况下，此选项已启用，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
备注
模式 'reflect' 和 'symmetric' 类似，但在反射期间边缘像素是否被复制方面有所不同。例如，如果一个数组的值为 [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 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)
- skimage.transform.swirl(image, center=None, strength=1, radius=100, rotation=0, output_shape=None, order=None, mode='reflect', cval=0, clip=True, preserve_range=False)[source]#
执行螺旋变换。
- 参数：:
- imagendarray
输入图像。
- center(column, row) 元组或 (2,) ndarray，可选
变换的中心坐标。
- strengthfloat, optional
应用的旋转量。
- radiusfloat, optional
旋转的范围（以像素为单位）。超出 radius 范围的效果会迅速衰减。
- rotationfloat, optional
应用于图像的额外旋转。
- 返回值：
- swirledndarray
输入的旋转版本。
- 其他参数：
- output_shape元组 (rows, cols)，可选
生成的输出图像的形状。默认情况下保留输入图像的形状。
- orderint，可选
样条插值的阶数，默认为 0（如果 image.dtype 为 bool）或 1（否则）。阶数必须在 0-5 范围内。有关详细信息，请参阅
skimage.transform.warp。- mode{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional
输入边界之外的点将根据给定的模式填充，默认使用“reflect”。模式与
numpy.pad的行为匹配。- cvalfloat, optional
与模式 'constant' 结合使用，图像边界之外的值。
- clipbool, optional
是否将输出剪切到输入图像的值范围内。默认情况下，此选项已启用，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- skimage.transform.warp(image, inverse_map, map_args=None, output_shape=None, order=None, mode='constant', cval=0.0, clip=True, preserve_range=False)[source]#
根据给定的坐标变换扭曲图像。
- 参数：:
- imagendarray
输入图像。
- inverse_map变换对象、可调用函数
cr = f(cr, **kwargs)或 ndarray 逆坐标映射，它将输出图像中的坐标转换为输入图像中的对应坐标。
根据输入图像的维数，定义此映射有许多不同的选项。二维图像对于灰度图像可以具有 2 个维度，对于带颜色信息的图像可以具有 3 个维度。
对于二维图像，您可以直接传递一个变换对象，例如
skimage.transform.SimilarityTransform，或其逆。对于二维图像，您可以传递一个
(3, 3)齐次变换矩阵，例如 skimage.transform.SimilarityTransform.params。对于二维图像，一个函数，它将输出图像中
(M, 2)的(col, row)坐标数组转换为输入图像中的对应坐标。函数的额外参数可以通过 map_args 指定。对于 N 维图像，您可以直接传递一个坐标数组。第一个维度指定输入图像中的坐标，而后续维度则确定输出图像中的位置。例如，对于二维图像，您需要传递一个形状为
(2, rows, cols)的数组，其中 rows 和 cols 确定输出图像的形状，第一个维度包含输入图像中的(row, col)坐标。有关进一步文档，请参阅scipy.ndimage.map_coordinates。
请注意，一个
(3, 3)矩阵被解释为一个齐次变换矩阵，因此，如果您无法从 3D 输入插值值，那么输出的形状不能为(3,)。有关用法，请参阅示例部分。
- map_argsdict, optional
传递给 inverse_map 的关键字参数。
- output_shape元组 (rows, cols)，可选
生成的输出图像的形状。默认情况下保留输入图像的形状。请注意，即使对于多波段图像，也只需要指定行和列。
- orderint，可选
- 插值的顺序。顺序必须在 0-5 范围内
0：最近邻
1：双线性（默认）
2：双二次
3：双三次
4：双四次
5：双五次
如果 image.dtype 为 bool，则默认为 0，否则为 1。
- mode{‘constant’, ‘edge’, ‘symmetric’, ‘reflect’, ‘wrap’}, optional
根据给定的模式填充输入边界之外的点。模式与
numpy.pad的行为相匹配。- cvalfloat, optional
与模式 'constant' 结合使用，图像边界之外的值。
- clipbool, optional
是否将输出剪切到输入图像的值范围内。默认情况下，此选项已启用，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, optional
是否保留原始的值范围。否则，将根据 img_as_float 的约定转换输入图像。另请参见 https://scikit-image.cn/docs/dev/user_guide/data_types.html
- 返回值：
- warpeddouble ndarray
扭曲的输入图像。
备注
输入图像将转换为 double 图像。
在
SimilarityTransform、AffineTransform和ProjectiveTransform以及 order 在 [0, 3] 范围内的情况下，此函数使用底层的变换矩阵以更快的例程扭曲图像。
示例
>>> 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)
对于 N 维图像，您可以传递一个坐标数组，该数组为输出图像中的每个元素指定输入图像中的坐标。例如，如果您想重新调整 3D 立方体的比例，您可以执行以下操作
>>> cube_shape = np.array([30, 30, 30]) >>> rng = np.random.default_rng() >>> cube = rng.random(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)
- skimage.transform.warp_coords(coord_map, shape, dtype=<class 'numpy.float64'>)[source]#
为二维图像扭曲的输出构建源坐标。
- 参数：:
- coord_map类似于 GeometricTransform.inverse 的可调用对象
返回给定输出坐标的输入坐标。坐标形状为 (P, 2)，其中 P 是坐标数量，每个元素是一个
(row, col)对。- shape元组
输出图像的形状
(rows, cols[, bands])。- dtypenp.dtype 或字符串
返回值的 dtype（合理选择：float32 或 float64）。
- 返回值：
- coords(ndim, rows, cols[, bands]) 数组，dtype 为 dtype
用于
scipy.ndimage.map_coordinates的坐标，通过根据 coord_transform_fn 从源点绘制，将生成形状为 (orows, ocols, bands) 的图像。
备注
这是一个低级例程，它为 warp() 生成用于 2D 图像的源坐标。
它与
warp分开提供，以便为想要重用特定坐标映射、在图像扭曲过程中的不同点使用特定 dtype 或实现与warp不同的后处理逻辑的用户提供额外的灵活性，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)
- skimage.transform.warp_polar(image, center=None, *, radius=None, output_shape=None, scaling='linear', channel_axis=None, **kwargs)[source]#
将图像重新映射到极坐标或对数极坐标空间。
- 参数：:
- image(M, N[, C]) ndarray
输入图像。对于多通道图像，必须指定 channel_axis。
- center2 元组，可选
(row, col) 代表变换中心的 image 中的点坐标（即笛卡尔空间中的原点）。值可以是 float 类型。如果没有给出值，则假定中心是 image 的中心点。
- radiusfloat, optional
包围要变换区域的圆的半径。
- output_shape元组 (row, col)，可选
- scaling{‘linear’, ‘log’}，可选
指定图像扭曲是极坐标还是对数极坐标。默认为 ‘linear’。
- channel_axisint 或 None，可选
如果为 None，则图像被认为是灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
在版本 0.19 中添加：
channel_axis在 0.19 中添加。- **kwargs关键字参数
传递给 transform.warp。
- 返回值：
- warpedndarray
极坐标或对数极坐标扭曲的图像。
示例
对灰度图像执行基本的极坐标扭曲
>>> from skimage import data >>> from skimage.transform import warp_polar >>> image = data.checkerboard() >>> warped = warp_polar(image)
对灰度图像执行对数极坐标扭曲
>>> warped = warp_polar(image, scaling='log')
在指定中心、半径和输出形状的同时，对灰度图像执行对数极坐标扭曲
>>> warped = warp_polar(image, (100,100), radius=100, ... output_shape=image.shape, scaling='log')
对彩色图像执行对数极坐标扭曲
>>> image = data.astronaut() >>> warped = warp_polar(image, scaling='log', channel_axis=-1)
- class skimage.transform.AffineTransform(matrix=None, scale=None, rotation=None, shear=None, translation=None, *, dimensionality=2)[source]#
-
仿射变换。
具有以下形式
X = a0 * x + a1 * y + a2 = sx * x * [cos(rotation) + tan(shear_y) * sin(rotation)] - sy * y * [tan(shear_x) * cos(rotation) + sin(rotation)] + translation_x Y = b0 * x + b1 * y + b2 = sx * x * [sin(rotation) - tan(shear_y) * cos(rotation)] - sy * y * [tan(shear_x) * sin(rotation) - cos(rotation)] + translation_y
其中
sx和sy是 x 和 y 方向上的比例因子。这等效于按以下顺序应用操作
缩放
剪切
旋转
平移
齐次变换矩阵为
[[a0 a1 a2] [b0 b1 b2] [0 0 1]]
在 2D 中，变换参数可以作为上面的齐次变换矩阵给出，也可以作为隐式参数给出，即 x（a2）和 y（b2）方向上的缩放、旋转、剪切和平移。对于 3D 及更高维度，只允许矩阵形式。
在更窄的变换中，例如欧几里德变换（仅旋转和平移）或相似变换（旋转、平移和全局比例因子），可以使用隐式参数指定 3D 变换。
- 参数：:
- matrix(D+1, D+1) 数组，可选
齐次变换矩阵。如果提供了此矩阵，则提供任何缩放、旋转、剪切或平移都是错误的。
- scale{s 为浮点数或 (sx, sy) 为数组、列表或元组}，可选
比例因子。如果是一个单值，它将被分配给 sx 和 sy。仅适用于 2D。
版本 0.17 中添加： 添加了对提供单个标量值的支持。
- rotationfloat, optional
旋转角度，顺时针，以弧度为单位。仅适用于 2D。
- shear浮点数或 2 元组，可选
x 和 y 剪切角，顺时针，这些轴围绕原点旋转 [2]。如果给出一个单值，则将其视为 x 剪切角，y 角保持为 0。仅适用于 2D。
- translation(tx, ty) 作为数组、列表或元组，可选
平移参数。仅适用于 2D。
- dimensionality整数，可选
变换的维数。如果提供了任何其他参数，则不会使用此参数。
- 引发：
- ValueError
如果同时提供了
matrix和任何其他参数。
参考文献
[2]维基百科，“剪切映射”，https://en.wikipedia.org/wiki/Shear_mapping
示例
>>> import numpy as np >>> import skimage as ski >>> img = ski.data.astronaut()
定义源点和目标点
>>> src = np.array([[150, 150], ... [250, 100], ... [150, 200]]) >>> dst = np.array([[200, 200], ... [300, 150], ... [150, 400]])
估计变换矩阵
>>> tform = ski.transform.AffineTransform() >>> tform.estimate(src, dst) True
应用变换
>>> warped = ski.transform.warp(img, inverse_map=tform.inverse)
- 属性：
- params(D+1, D+1) 数组
齐次变换矩阵。
- __init__(matrix=None, scale=None, rotation=None, shear=None, translation=None, *, dimensionality=2)[source]#
- property dimensionality#
变换的维数。
- estimate(src, dst, weights=None)[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 归一化的最小奇异值。
权重可以应用于每对对应点，以指示，特别是在超定系统中，点对是否具有更高或更低的置信度或与之相关的误差。从最小二乘问题的矩阵处理来看，这些权重值被归一化、平方根，然后构建成对角矩阵，A 被此矩阵相乘。
在仿射变换的情况下，系数 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]
- 参数：:
- src(N, 2) array_like
源坐标。
- dst(N, 2) array_like
目标坐标。
- weights(N,) array_like, optional
每对点的相对权重值。
- 返回值：
- successbool
如果模型估计成功，则为 True。
- property inverse#
返回表示逆变换的变换对象。
- residuals(src, dst)[source]#
确定变换后的目标坐标的残差。
对于每个变换后的源坐标，确定到相应目标坐标的欧几里得距离。
- 参数：:
- src(N, 2) array
源坐标。
- dst(N, 2) array
目标坐标。
- 返回值：
- residuals(N,) array
坐标的残差。
- property rotation#
- property scale#
- property shear#
- property translation#
- class skimage.transform.EssentialMatrixTransform(rotation=None, translation=None, matrix=None, *, dimensionality=2)[source]#
Bases:
FundamentalMatrixTransform本质矩阵变换。
本质矩阵将一对校准图像之间的对应点联系起来。该矩阵将一个图像中的归一化齐次图像点变换到另一个图像中的极线。
本质矩阵仅针对捕获非平面场景的移动图像对定义。在纯旋转或平面场景的情况下，单应性描述了两个图像之间的几何关系 (
ProjectiveTransform)。如果图像的内在校准未知，则基础矩阵描述了两个图像之间的投影关系 (FundamentalMatrixTransform)。- 参数：:
- rotation(3, 3) array_like, optional
相对相机运动的旋转矩阵。
- translation(3, 1) array_like, optional
相对相机运动的平移向量。该向量必须具有单位长度。
- matrix(3, 3) array_like, optional
本质矩阵。
参考文献
[1]Hartley, Richard, and Andrew Zisserman. Multiple view geometry in computer vision. Cambridge university press, 2003.
示例
>>> import numpy as np >>> import skimage as ski >>> >>> tform_matrix = ski.transform.EssentialMatrixTransform( ... rotation=np.eye(3), translation=np.array([0, 0, 1]) ... ) >>> tform_matrix.params array([[ 0., -1., 0.], [ 1., 0., 0.], [ 0., 0., 0.]]) >>> src = np.array([[ 1.839035, 1.924743], ... [ 0.543582, 0.375221], ... [ 0.47324 , 0.142522], ... [ 0.96491 , 0.598376], ... [ 0.102388, 0.140092], ... [15.994343, 9.622164], ... [ 0.285901, 0.430055], ... [ 0.09115 , 0.254594]]) >>> dst = np.array([[1.002114, 1.129644], ... [1.521742, 1.846002], ... [1.084332, 0.275134], ... [0.293328, 0.588992], ... [0.839509, 0.08729 ], ... [1.779735, 1.116857], ... [0.878616, 0.602447], ... [0.642616, 1.028681]]) >>> tform_matrix.estimate(src, dst) True >>> tform_matrix.residuals(src, dst) array([0.42455187, 0.01460448, 0.13847034, 0.12140951, 0.27759346, 0.32453118, 0.00210776, 0.26512283])
- 属性：
- params(3, 3) array
本质矩阵。
- estimate(src, dst)[source]#
使用 8 点算法估计本质矩阵。
8 点算法至少需要 8 对对应点才能获得良好条件的解，否则将估计过定的解。
- 参数：:
- src(N, 2) array_like
源坐标。
- dst(N, 2) array_like
目标坐标。
- 返回值：
- successbool
如果模型估计成功，则为 True。
- property inverse#
返回表示逆变换的变换对象。
参见 Hartley & Zisserman，第 8 章：极线几何和基础矩阵，了解 F.T 为何给出逆变换的解释。
- class skimage.transform.EuclideanTransform(matrix=None, rotation=None, translation=None, *, dimensionality=2)[source]#
-
欧几里得变换，也称为刚性变换。
具有以下形式
X = a0 * x - b0 * y + a1 = = x * cos(rotation) - y * sin(rotation) + a1 Y = b0 * x + a0 * y + b1 = = x * sin(rotation) + y * cos(rotation) + b1
其中齐次变换矩阵为
[[a0 -b0 a1] [b0 a0 b1] [0 0 1 ]]
欧几里得变换是具有旋转和平移参数的刚性变换。相似变换通过单个缩放因子扩展欧几里得变换。
在 2D 和 3D 中，变换参数可以通过 matrix（齐次变换矩阵，如上所述）或通过隐式参数
rotation和/或translation（其中 a1 是沿 x 的平移，b1 是沿 y 的平移，等等）提供。在 3D 以上，如果变换仅为平移，则可以使用隐式参数translation；否则，必须使用 matrix。- 参数：:
- matrix(D+1, D+1) 数组，可选
齐次变换矩阵。
- rotationfloat 或 float 序列，可选
旋转角度，顺时针方向，以弧度表示。如果作为向量给出，则将其解释为欧拉旋转角 [1]。仅支持 2D（单个旋转）和 3D（欧拉旋转）值。对于更高维度，必须提供或估计变换矩阵。
- translation(x, y[, z, …]) float 序列，长度为 D，可选
每个轴的平移参数。
- dimensionality整数，可选
变换的维数。
参考文献
- 属性：
- params(D+1, D+1) 数组
齐次变换矩阵。
- property dimensionality#
变换的维数。
- estimate(src, dst)[source]#
从一组对应点估计变换。
您可以使用总体最小二乘法确定超定、适定和欠定参数。
源和目标坐标的数量必须匹配。
- 参数：:
- src(N, 2) array_like
源坐标。
- dst(N, 2) array_like
目标坐标。
- 返回值：
- successbool
如果模型估计成功，则为 True。
- property inverse#
返回表示逆变换的变换对象。
- residuals(src, dst)[source]#
确定变换后的目标坐标的残差。
对于每个变换后的源坐标，确定到相应目标坐标的欧几里得距离。
- 参数：:
- src(N, 2) array
源坐标。
- dst(N, 2) array
目标坐标。
- 返回值：
- residuals(N,) array
坐标的残差。
- property rotation#
- property translation#
- class skimage.transform.FundamentalMatrixTransform(matrix=None, *, dimensionality=2)[source]#
基础类：
_GeometricTransform基础矩阵变换。
基本矩阵将一对未校正图像之间的对应点相关联。该矩阵将一幅图像中的齐次图像点转换为另一幅图像中的极线。
基本矩阵仅针对一对运动图像定义。在纯旋转或平面场景的情况下，单应性描述了两幅图像之间的几何关系 (
ProjectiveTransform)。如果已知图像的内在校准，则本质矩阵描述两幅图像之间的度量关系 (EssentialMatrixTransform).- 参数：:
- matrix(3, 3) array_like, optional
基本矩阵。
参考文献
[1]Hartley, Richard, and Andrew Zisserman. Multiple view geometry in computer vision. Cambridge university press, 2003.
示例
>>> import numpy as np >>> import skimage as ski >>> tform_matrix = ski.transform.FundamentalMatrixTransform()
定义源点和目标点
>>> src = np.array([1.839035, 1.924743, ... 0.543582, 0.375221, ... 0.473240, 0.142522, ... 0.964910, 0.598376, ... 0.102388, 0.140092, ... 15.994343, 9.622164, ... 0.285901, 0.430055, ... 0.091150, 0.254594]).reshape(-1, 2) >>> dst = np.array([1.002114, 1.129644, ... 1.521742, 1.846002, ... 1.084332, 0.275134, ... 0.293328, 0.588992, ... 0.839509, 0.087290, ... 1.779735, 1.116857, ... 0.878616, 0.602447, ... 0.642616, 1.028681]).reshape(-1, 2)
估计变换矩阵
>>> tform_matrix.estimate(src, dst) True >>> tform_matrix.params array([[-0.21785884, 0.41928191, -0.03430748], [-0.07179414, 0.04516432, 0.02160726], [ 0.24806211, -0.42947814, 0.02210191]])
计算 Sampson 距离
>>> tform_matrix.residuals(src, dst) array([0.0053886 , 0.00526101, 0.08689701, 0.01850534, 0.09418259, 0.00185967, 0.06160489, 0.02655136])
应用逆变换
>>> tform_matrix.inverse(dst) array([[-0.0513591 , 0.04170974, 0.01213043], [-0.21599496, 0.29193419, 0.00978184], [-0.0079222 , 0.03758889, -0.00915389], [ 0.14187184, -0.27988959, 0.02476507], [ 0.05890075, -0.07354481, -0.00481342], [-0.21985267, 0.36717464, -0.01482408], [ 0.01339569, -0.03388123, 0.00497605], [ 0.03420927, -0.1135812 , 0.02228236]])
- 属性：
- params(3, 3) array
基本矩阵。
- estimate(src, dst)[source]#
使用 8 点算法估计基本矩阵。
8 点算法至少需要 8 对对应点才能获得良好条件的解，否则将估计过定的解。
- 参数：:
- src(N, 2) array_like
源坐标。
- dst(N, 2) array_like
目标坐标。
- 返回值：
- successbool
如果模型估计成功，则为 True。
- property inverse#
返回表示逆变换的变换对象。
参见 Hartley & Zisserman，第 8 章：极线几何和基础矩阵，了解 F.T 为何给出逆变换的解释。
- class skimage.transform.PiecewiseAffineTransform[source]#
基础类：
_GeometricTransform分段仿射变换。
控制点用于定义映射。变换基于点的 Delaunay 三角剖分来形成网格。每个三角形用于查找局部仿射变换。
- 属性：
- affinesAffineTransform 对象列表
网格中每个三角形的仿射变换。
- inverse_affinesAffineTransform 对象列表
网格中每个三角形的逆仿射变换。
- estimate(src, dst)[source]#
从一组对应点估计变换。
源和目标坐标的数量必须匹配。
- 参数：:
- src(N, D) array_like
源坐标。
- dst(N, D) array_like
目标坐标。
- 返回值：
- successbool
如果模型的所有部分都成功估计，则为 True。
- property inverse#
返回表示逆变换的变换对象。
- class skimage.transform.PolynomialTransform(params=None, *, dimensionality=2)[source]#
基础类：
_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 ))
- 参数：:
- params(2, N) array_like, 可选
多项式系数，其中 N * 2 = (order + 1) * (order + 2)。因此，a_ji 在 params[0, :] 中定义，b_ji 在 params[1, :] 中定义。
- 属性：
- params(2, N) array
多项式系数，其中 N * 2 = (order + 1) * (order + 2)。因此，a_ji 在 params[0, :] 中定义，b_ji 在 params[1, :] 中定义。
- estimate(src, dst, order=2, weights=None)[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 归一化的最小奇异值。
权重可以应用于每对对应点，以指示，特别是在超定系统中，点对是否具有更高或更低的置信度或与之相关的误差。从最小二乘问题的矩阵处理来看，这些权重值被归一化、平方根，然后构建成对角矩阵，A 被此矩阵相乘。
- 参数：:
- src(N, 2) array_like
源坐标。
- dst(N, 2) array_like
目标坐标。
- orderint，可选
多项式阶数（系数数量为 order + 1）。
- weights(N,) array_like, optional
每对点的相对权重值。
- 返回值：
- successbool
如果模型估计成功，则为 True。
- property inverse#
返回表示逆变换的变换对象。
- class skimage.transform.ProjectiveTransform(matrix=None, *, dimensionality=2)[source]#
基础类：
_GeometricTransform投影变换。
对坐标应用投影变换（单应性）。
对于每个齐次坐标 \(\mathbf{x} = [x, y, 1]^T\)，其目标位置通过与给定矩阵 \(H\) 相乘来计算，得到 \(H \mathbf{x}\)
[[a0 a1 a2] [b0 b1 b2] [c0 c1 1 ]].
例如，要顺时针旋转 theta 度，矩阵应该是
[[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 ]].
- 参数：:
- matrix(D+1, D+1) 数组，可选
齐次变换矩阵。
- dimensionality整数，可选
变换的维数。如果
matrix不是 None，则忽略此参数。
- 属性：
- params(D+1, D+1) 数组
齐次变换矩阵。
- property dimensionality#
变换的维数。
- estimate(src, dst, weights=None)[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 归一化的最小奇异值。
权重可以应用于每对对应点，以指示，特别是在超定系统中，点对是否具有更高或更低的置信度或与之相关的误差。从最小二乘问题的矩阵处理来看，这些权重值被归一化、平方根，然后构建成对角矩阵，A 被此矩阵相乘。
在仿射变换的情况下，系数 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]
- 参数：:
- src(N, 2) array_like
源坐标。
- dst(N, 2) array_like
目标坐标。
- weights(N,) array_like, optional
每对点的相对权重值。
- 返回值：
- successbool
如果模型估计成功，则为 True。
- property inverse#
返回表示逆变换的变换对象。
- class skimage.transform.SimilarityTransform(matrix=None, scale=None, rotation=None, translation=None, *, dimensionality=2)[source]#
-
相似变换。
在 2D 中具有以下形式
X = a0 * x - b0 * y + a1 = = s * x * cos(rotation) - s * y * sin(rotation) + a1 Y = b0 * x + a0 * y + b1 = = s * x * sin(rotation) + s * y * cos(rotation) + b1
其中
s是一个比例因子，齐次变换矩阵为[[a0 -b0 a1] [b0 a0 b1] [0 0 1 ]]
相似变换在欧几里得变换的基础上，除了旋转和平移参数外，还增加了一个比例因子。
- 参数：:
- matrix(dim+1, dim+1) array_like, 可选
齐次变换矩阵。
- scalefloat, 可选
比例因子。仅在 2D 和 3D 中实现。
- rotationfloat, optional
旋转角度，顺时针，以弧度表示。仅在 2D 和 3D 中实现。对于 3D，这在 ZYX 欧拉角中给出。
- translation(dim,) array_like, 可选
x, y[, z] 平移参数。仅在 2D 和 3D 中实现。
- 属性：
- params(dim+1, dim+1) array
齐次变换矩阵。
- property dimensionality#
变换的维数。
- estimate(src, dst)[source]#
从一组对应点估计变换。
您可以使用总体最小二乘法确定超定、适定和欠定参数。
源和目标坐标的数量必须匹配。
- 参数：:
- src(N, 2) array_like
源坐标。
- dst(N, 2) array_like
目标坐标。
- 返回值：
- successbool
如果模型估计成功，则为 True。
- property inverse#
返回表示逆变换的变换对象。
- residuals(src, dst)[source]#
确定变换后的目标坐标的残差。
对于每个变换后的源坐标，确定到相应目标坐标的欧几里得距离。
- 参数：:
- src(N, 2) array
源坐标。
- dst(N, 2) array
目标坐标。
- 返回值：
- residuals(N,) array
坐标的残差。
- property rotation#
- property scale#
- property translation#
- class skimage.transform.ThinPlateSplineTransform[source]#
基类：
object薄板样条变换。
给定两组匹配的点，源点和目标点，此类估计薄板样条 (TPS) 变换，该变换将源点中的每个点转换为其目标点对应点。
参考文献
[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
示例
>>> import skimage as ski
定义源点和目标点控制点，以便它们模拟旋转 90 度并从它们生成网格。
>>> src = np.array([[0, 0], [0, 5], [5, 5], [5, 0]]) >>> dst = np.array([[5, 0], [0, 0], [0, 5], [5, 5]])
估计变换
>>> tps = ski.transform.ThinPlateSplineTransform() >>> tps.estimate(src, dst) True
将变换应用于 src 近似 dst
>>> np.round(tps(src)) array([[5., 0.], [0., 0.], [0., 5.], [5., 5.]])
创建要应用变换的网格
>>> 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]])
- 属性：
- src(N, 2) array_like
源图像中控制点的坐标。
- estimate(src, dst)[source]#
估计源点和目标点之间的最佳样条映射。
- 参数：:
- src(N, 2) array_like
源坐标处的控制点。
- dst(N, 2) array_like
目标坐标处的控制点。
- 返回值：
- success: bool
True 表示估计成功。
备注
源点和目标点的数量 N 必须匹配。
- property inverse#