skimage.transform#
此模块包含用于转换图像和体积数据的工具。
几何变换：这些变换改变图像的形状或位置。它们对于图像配准、对齐和几何校正等任务非常有用。示例：
AffineTransform，ProjectiveTransform，EuclideanTransform。图像调整大小和重采样：这些变换改变图像的大小或分辨率。它们对于诸如缩小图像以减小其大小或放大图像以增加其分辨率等任务非常有用。示例：
resize()，rescale()。特征检测与提取：这些变换识别并提取图像中的特定特征或模式。它们对于物体检测、图像分割和特征匹配等任务非常有用。示例：
hough_circle()、pyramid_expand()、radon()。图像变换：这些变换在不改变图像内容的情况下改变图像的外观。它们对于创建图像马赛克、应用艺术效果和可视化图像数据等任务非常有用。示例：
warp()，iradon()。
通过局部平均值对N维图像进行下采样。 |
|
估计二维几何变换参数。 |
|
计算输入数组的二维有限Radon变换（FRT）。 |
|
执行圆形Hough变换。 |
|
返回圆形Hough变换中的峰值。 |
|
执行椭圆霍夫变换。 |
|
执行直线霍夫变换。 |
|
返回直线霍夫变换中的峰值。 |
|
计算输入数组的二维逆有限Radon变换（iFRT）。 |
|
积分图像 / 累加区域表。 |
|
使用积分图像在给定窗口上进行积分。 |
|
逆拉东变换。 |
|
逆拉东变换。 |
|
应用二维矩阵变换。 |
|
排序角度以减少后续投影中的相关信息量。 |
|
从渐进概率线霍夫变换中返回线条。 |
|
上采样然后平滑图像。 |
|
生成由输入图像形成的高斯金字塔的图像。 |
|
生成由输入图像形成的拉普拉斯金字塔的图像。 |
|
平滑然后下采样图像。 |
|
计算给定投影角度的图像的拉东变换。 |
|
按一定比例缩放图像。 |
|
调整图像大小以匹配特定尺寸。 |
|
使用局部均值/双线性缩放调整数组大小。 |
|
围绕其中心将图像旋转一定角度。 |
|
执行旋转变换。 |
|
根据给定的坐标变换扭曲图像。 |
|
构建用于2-D图像扭曲输出的源坐标。 |
|
将图像重新映射到极坐标或对数极坐标空间。 |
|
仿射变换。 |
|
基本矩阵变换。 |
|
欧几里得变换，也称为刚性变换。 |
|
基本矩阵变换。 |
|
分段仿射变换。 |
|
二维多项式变换。 |
|
投影变换。 |
|
相似变换。 |
|
薄板样条变换。 |
- skimage.transform.downscale_local_mean(image, factors, cval=0, clip=True)[源代码][源代码]#
通过局部平均值对N维图像进行下采样。
如果图像不能被整数因子完美整除，则使用 cval 进行填充。
与
skimage.transform.resize和skimage.transform.rescale中的插值不同，此函数计算输入图像中每个大小为 factors 的块中元素的局部平均值。- 参数:
- 图像(M[, …]) ndarray
输入图像。
- 因素array_like
包含沿每个轴的下采样整数因子的数组。
- cvalfloat, 可选
如果图像不能被整数因子完美整除，则使用常量填充值。
- 剪辑bool, 可选
未使用，但为了与本模块中的其他转换保持API一致性而保留在此。（假设提供的 cval 也在该范围内，局部均值永远不会超出输入图像中值的范围。）
- 返回:
- 图像ndarray
下采样图像，其维度与输入图像相同。对于整数输入，输出数据类型将为
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)[源代码][源代码]#
估计二维几何变换参数。
你可以使用总体最小二乘法来确定过定、适定和欠定参数。
源坐标和目标坐标的数量必须匹配。
- 参数:
- ttype{‘欧几里得’, ‘相似性’, ‘仿射’, ‘分段仿射’, ‘投影’, ‘多项式’}
变换的类型。
- kwargs类数组 或 整数
函数参数 (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_几何变换
包含变换参数并提供访问正向和逆变换函数功能的变换对象。
示例
>>> 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)[源代码][源代码]#
计算输入数组的二维有限Radon变换（FRT）。
- 参数:
- a整数类型的 ndarray，形状为 (M, M)
输入数组。
- 返回:
- FRTint 类型的 ndarray，形状为 (M+1, M)
有限Radon变换系数数组。
参见
ifrt2二维逆FRT。
注释
当且仅当 M 是素数时，FRT 具有唯一的逆。[FRT] 该算法的思想归功于 Vlad Negnevitski。
参考文献
[FRT]A. Kingston and I. Svalbe, “Projective transforms on periodic discrete image arrays,” in P. Hawkes (Ed), Advances in Imaging and Electron Physics, 139 (2006)
示例
生成测试图像：使用质数作为数组维度
>>> SIZE = 59 >>> img = np.tri(SIZE, dtype=np.int32)
应用有限拉东变换：
>>> f = frt2(img)
- skimage.transform.hough_circle(image, radius, normalize=True, full_output=False)[源代码][源代码]#
执行圆形Hough变换。
- 参数:
- 图像ndarray, 形状 (M, N)
输入图像，其中非零值表示边缘。
- 半径标量或标量序列
计算Hough变换的半径。浮点数将被转换为整数。
- 规范化布尔值，可选
用绘制半径所使用的像素数来归一化累加器。
- 完整输出布尔值，可选
通过将输出尺寸扩展为最大半径的两倍，以便检测输入图片外部的中心。
- 返回:
- Hndarray, 形状 (半径索引, M + 2R, N + 2R)
每个半径的Hough变换累加器。如果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)[源代码][源代码]#
返回圆形Hough变换中的峰值。
在给定的Hough空间中识别出由特定距离分隔的最显著的圆。在Hough空间的第一和第二维度上分别应用不同大小的非最大值抑制来识别峰值。对于不同半径但距离相近的圆，只保留峰值最高的那一个。
- 参数:
- hspaces(M, N, P) 数组
hough_circle函数返回的 Hough 空间。- 半径(M,) 数组
对应于Hough空间的半径。
- min_xdistanceint, 可选
x 维度中中心之间的最小距离。
- min_ydistanceint, 可选
在y维度上分离中心的最低距离。
- 阈值float, 可选
每个Hough空间中峰值的最小强度。默认值为 0.5 * max(hspace)。
- num_peaksint, 可选
每个Hough空间中的最大峰值数。当峰值数量超过 num_peaks 时，仅根据峰值强度考虑相应的半径的 num_peaks 个坐标。
- total_num_peaksint, 可选
最大峰数。当峰数超过 num_peaks 时，根据峰强度返回 num_peaks 个坐标。
- 规范化bool, 可选
如果为 True，则通过半径归一化累加器以排序显著峰值。
- 返回:
- accum, cx, cy, rad数组的元组
Hough空间中的峰值，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)[源代码][源代码]#
执行椭圆霍夫变换。
- 参数:
- 图像(M, N) ndarray
输入图像，其中非零值表示边缘。
- 阈值int, 可选
累加器阈值。较低的值将返回更多的椭圆。
- 准确性双精度，可选
累加器中使用的小轴上的箱尺寸。较高的值将返回更多的椭圆，但会导致小轴长度估计的精度降低。
- min_sizeint, 可选
最小主轴长度。
- max_sizeint, 可选
最大次轴长度。如果为 None，则该值设置为图像较小尺寸的一半。
- 返回:
- 结果带有字段的 ndarray [(accumulator, yc, xc, a, b, orientation)]。
其中
(yc, xc)是中心，(a, b)分别是长轴和短轴。orientation 值遵循skimage.draw.ellipse_perimeter的约定。
注释
图像中的潜在椭圆由它们的长轴和短轴长度来表征。对于图像中任何一对距离至少为 min_size 一半的非零像素，累加器会跟踪由所有其他非零像素形成的潜在椭圆的短轴长度。如果这些累积的短轴长度直方图中的任何箱（bin_size = accuracy * accuracy）高于 threshold，则相应的椭圆将被添加到结果中。
因此，更高的 准确度 将导致在图像中发现更多的椭圆，但代价是短轴长度的估计精度降低。
参考文献
[1]Xie, Yonghong, 和 Qiang Ji. “一种新的高效椭圆检测方法.” 模式识别, 2002. 第16届国际会议论文集. 第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)[源代码][源代码]#
执行直线霍夫变换。
- 参数:
- 图像(M, N) ndarray
输入图像，其中非零值表示边缘。
- theta双精度数组，形状为 (K,)，可选
计算变换的角度，以弧度为单位。默认为在范围 [-π/2, π/2) 内均匀分布的 180 个角度的向量。
- 返回:
- hspaceuint64 的 ndarray，形状为 (P, Q)
Hough 变换累加器。
- 角度ndarray
计算变换的角度，以弧度为单位。
- 距离ndarray
距离值。
注释
原点是原始图像的左上角。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)[源代码][源代码]#
返回直线霍夫变换中的峰值。
识别霍夫变换中以一定角度和距离分隔的最显著线条。在霍夫空间的第一维（距离）和第二维（角度）分别应用不同大小的非最大值抑制来识别峰值。
- 参数:
- hspacendarray, 形状 (M, N)
hough_line函数返回的 Hough 空间。- 角度数组，形状 (N,)
hough_line函数返回的角度。假设是连续的。(angles[-1] - angles[0] == PI)。- dists数组，形状 (M,)
hough_line函数返回的距离。- min_distanceint, 可选
最小行间距（霍夫空间第一维度的最大滤波器尺寸）。
- min_angleint, 可选
分离线条的最小角度（霍夫空间第二维度的最大过滤器尺寸）。
- 阈值float, 可选
峰的最小强度。默认值为 0.5 * max(hspace)。
- num_peaksint, 可选
最大峰数。当峰数超过 num_peaks 时，根据峰强度返回 num_peaks 个坐标。
- 返回:
- accum, angles, dists数组的元组
Hough空间中的峰值、角度和距离。
示例
>>> 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)[源代码][源代码]#
计算输入数组的二维逆有限Radon变换（iFRT）。
- 参数:
- aint 类型的 ndarray，形状为 (M+1, M)
输入数组。
- 返回:
- iFRT整数类型的 ndarray，形状为 (M, M)
逆有限Radon变换系数。
参见
frt2二维 FRT
注释
当且仅当 M 是素数时，FRT 具有唯一的逆。概述请参见 [1]。此算法的想法归功于 Vlad Negnevitski。
参考文献
[1]A. Kingston and I. Svalbe, “Projective transforms on periodic discrete image arrays,” in P. Hawkes (Ed), Advances in Imaging and Electron Physics, 139 (2006)
示例
>>> SIZE = 59 >>> img = np.tri(SIZE, dtype=np.int32)
应用有限拉东变换：
>>> f = frt2(img)
应用逆有限拉东变换以恢复输入
>>> fi = ifrt2(f)
检查它是否与原始内容完全相同
>>> assert len(np.nonzero(img-fi)[0]) == 0
- skimage.transform.integral_image(image, *, dtype=None)[源代码][源代码]#
积分图像 / 累加区域表。
积分图像包含了其上方和左侧所有元素的和，即：
\[S[m, n] = \sum_{i \leq m} \sum_{j \leq n} X[i, j]\]- 参数:
- 图像ndarray
输入图像。
- 返回:
- Sndarray
与输入图像形状相同的积分图像/求和区域表。
注释
为了提高准确性并避免潜在的溢出，当使用默认的 None 数据类型时，输出的数据类型可能与输入的不同。对于整数数据类型的输入，其行为与
numpy.cumsum()相匹配。浮点输入将被提升至至少双精度。用户可以通过设置 dtype 来覆盖此行为。参考文献
[1]F.C. Crow, “用于纹理映射的求和面积表,” ACM SIGGRAPH 计算机图形学, 第18卷, 1984年, 第207-212页.
- skimage.transform.integrate(ii, start, end)[源代码][源代码]#
使用积分图像在给定窗口上进行积分。
- 参数:
- iindarray
积分图像。
- 开始 : 元组列表，每个元组的长度等于 ii 的维度元组列表，每个元组的长度等于维度
窗口左上角坐标的列表。列表中的每个元组包含起始行、列等索引，例如 [(row_win1, col_win1, …), (row_win2, col_win2,…), …]。
- end : 元组列表，每个元组的长度等于 ii 的维度元组列表，每个元组的长度等于维度
窗口(s)右下角的坐标。列表中的每个元组包含结束行、列、… 索引，即 [(row_win1, col_win1, …), (row_win2, col_win2, …), …]。
- 返回:
- S标量或ndarray
在给定的窗口上进行积分（求和）。
参见
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)[源代码][源代码]#
逆拉东变换。
使用滤波反投影算法从拉东变换中重建图像。
- 参数:
- radon_imagendarray
包含拉东变换（正弦图）的图像。图像的每一列对应于不同角度的投影。断层扫描旋转轴应位于
radon_image的第0维度的像素索引radon_image.shape[0] // 2处。- theta数组，可选
重建角度（以度为单位）。默认值：m 个角度均匀分布在 0 到 180 之间（如果 radon_image 的形状为 (N, M)）。
- 输出大小int, 可选
重建中的行数和列数。
- filter_namestr, 可选
在频域滤波中使用的滤波器。默认使用斜坡滤波器。可用滤波器：斜坡、谢普-洛根、余弦、汉明、汉恩。指定 None 以不使用滤波器。
- 插值str, 可选
用于重建的插值方法。可用方法：’线性’、’最近邻’ 和 ‘立方’（’立方’ 速度较慢）。
- 圆布尔值，可选
假设重建图像在内切圆外为零。同时将默认的 output_size 更改为与调用
radon时使用circle=True的行为相匹配。- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- 返回:
- 重建的ndarray
重建图像。旋转轴将位于索引为
(reconstructed.shape[0] // 2, reconstructed.shape[1] // 2)的像素中。
在 0.19 版本发生变更: 在
iradon中，filter参数已被弃用，取而代之的是filter_name。
注释
它应用傅里叶切片定理通过将滤波器的频率域与投影数据的FFT相乘来重建图像。这种算法称为滤波反投影。
参考文献
[1]AC Kak, M Slaney, “计算机断层成像原理”, IEEE Press 1988.
[2]B.R. Ramesh, N. Srinivasa, K. Rajgopal, “一种用于计算离散Radon变换及其应用的算法”, 第四届IEEE区域10国际会议论文集, TENCON ‘89, 1989
- skimage.transform.iradon_sart(radon_image, theta=None, image=None, projection_shifts=None, clip=None, relaxation=0.15, dtype=None)[源代码][源代码]#
逆拉东变换。
使用Simultaneous Algebraic Reconstruction Technique (SART) 算法的单次迭代，从拉东变换中重建图像。
- 参数:
- radon_imagendarray, 形状 (M, N)
包含拉东变换（正弦图）的图像。图像的每一列对应于不同角度的投影。断层扫描旋转轴应位于
radon_image的第0维度的像素索引radon_image.shape[0] // 2处。- theta数组，形状 (N,)，可选
重建角度（以度为单位）。默认值：m 个角度均匀分布在 0 到 180 之间（如果 radon_image 的形状为 (N, M)）。
- 图像ndarray，形状 (M, M)，可选
包含初始重建估计的图像。默认是一个零数组。
- 投影偏移数组，形状 (N,)，可选
在重建图像之前，将
radon_image``（正弦图）中包含的投影按此像素数进行移位。第 i 个值定义了 ``radon_image第 i 列的移位。- 剪辑长度为2的浮点数序列，可选
强制重建的断层图像中的所有值位于范围
[clip[0], clip[1]]内- 放松float, 可选
更新步骤的松弛参数。较高的值可以提高收敛速度，但会增加不稳定性的风险。不建议使用接近或高于1的值。
- dtypedtype, 可选
输出数据类型，必须是浮点型。默认情况下，如果输入数据类型不是浮点型，则输入被转换为双精度浮点型，否则数据类型设置为输入数据类型。
- 返回:
- 重建的ndarray
重建图像。旋转轴将位于索引为
(reconstructed.shape[0] // 2, reconstructed.shape[1] // 2)的像素中。
注释
代数重建技术基于将断层重建问题公式化为一组线性方程。沿每条射线，投影值是沿射线所有横截面值的总和。SART（以及代数技术的一些其他变体）的一个典型特征是，它沿射线在等距点上对横截面进行采样，使用线性插值法在横截面的像素值之间进行插值。然后使用稍微修改过的Kaczmarz方法求解由此产生的线性方程组。
在使用SART时，通常一次迭代就足以获得良好的重建效果。进一步的迭代往往会增强高频信息，但也会经常增加噪声。
参考文献
[1]AC Kak, M Slaney, “计算机断层成像原理”, IEEE Press 1988.
[2]AH Andersen, AC Kak, “同时代数重建技术 (SART): ART 算法的优越实现”, 超声成像 6 页 81–94 (1984)
[3]S Kaczmarz, “近似解线性方程组”, Bulletin International de l’Academie Polonaise des Sciences et des Lettres 35 pp 355–357 (1937)
[4]Kohler, T. “基于黄金分割的迭代重建投影访问方案。” 核科学研讨会会议记录，2004年IEEE。第6卷。IEEE, 2004年。
[5]Kaczmarz 方法, Wikipedia, https://en.wikipedia.org/wiki/Kaczmarz_method
- skimage.transform.matrix_transform(coords, matrix)[源代码][源代码]#
应用二维矩阵变换。
- 参数:
- 坐标(N, 2) 数组类
x, y 坐标以进行变换
- 矩阵(3, 3) array_like
齐次变换矩阵。
- 返回:
- 坐标(N, 2) 数组
变换后的坐标。
- skimage.transform.order_angles_golden_ratio(theta)[源代码][源代码]#
排序角度以减少后续投影中的相关信息量。
- 参数:
- theta浮点数数组，形状为 (M,)
投影角度（以度为单位）。不允许重复角度。
- 返回:
- 索引生成器生成器生成无符号整数
返回的生成器生成
theta的索引，使得theta[indices]给出投影的近似黄金比例排序。总共生成len(theta)个索引。所有非负整数 <len(theta)都恰好生成一次。
注释
这里使用的方法是由T. Kohler引入的黄金比例。
参考文献
[1]Kohler, T. “基于黄金分割的迭代重建投影访问方案。” 核科学研讨会会议记录，2004年IEEE。第6卷。IEEE, 2004年。
[2]Winkelmann, Stefanie, 等人。“基于黄金分割的最佳径向剖面顺序用于时间分辨MRI。” 医学影像，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)[源代码][源代码]#
从渐进概率线霍夫变换中返回线条。
- 参数:
- 图像ndarray, 形状 (M, N)
输入图像，其中非零值表示边缘。
- 阈值int, 可选
阈值
- line_lengthint, 可选
检测到的行接受的最小长度。增加参数以提取更长的行。
- line_gapint, 可选
像素之间仍能形成线的最大间隙。增加该参数以更积极地合并断线。
- thetadtype 的 ndarray，形状为 (K,)，可选
计算变换的角度，以弧度为单位。默认为在范围 [-π/2, π/2) 内均匀分布的 180 个角度的向量。
- rng : {
numpy.random.Generator, int}, 可选toctree是一个 reStructuredText 指令 ，这是一个非常多功能的标记。指令可以有参数、选项和内容。 伪随机数生成器。默认情况下，使用 PCG64 生成器（参见
numpy.random.default_rng()）。如果 rng 是整数，则用于为生成器设定种子。
- 返回:
- 行列表
识别的线条列表，线条格式为 ((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)[源代码][源代码]#
上采样然后平滑图像。
- 参数:
- 图像ndarray
输入图像。
- 放大float, 可选
放大因子。
- sigmafloat, 可选
高斯滤波器的Sigma值。默认值为 2 * 放大倍数 / 6.0，这对应于一个滤波器掩码，其大小是缩放因子的两倍，覆盖了超过99%的高斯分布。
- 顺序int, 可选
在上采样插值中使用的样条顺序。详见
skimage.transform.warp。- 模式{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}, 可选
mode 参数决定了如何处理数组边界，当 mode 等于 ‘constant’ 时，cval 是该值。
- cvalfloat, 可选
如果模式是 ‘constant’，则填充输入边缘之外的值。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- channel_axisint 或 None, 可选
如果为 None，则假定图像是灰度图像（单通道）。否则，此参数指示数组的哪个轴对应于通道。
Added in version 0.19:
channel_axis在 0.19 版本中被添加。
- 返回:
- 出数组
上采样和平滑后的浮点图像。
参考文献
- skimage.transform.pyramid_gaussian(image, max_layer=-1, downscale=2, sigma=None, order=1, mode='reflect', cval=0, preserve_range=False, *, channel_axis=None)[源代码][源代码]#
生成由输入图像形成的高斯金字塔的图像。
递归地应用
pyramid_reduce函数到图像上，并生成缩小后的图像。请注意，金字塔的第一张图像是原始的、未缩放的图像。图像的总数是 max_layer + 1。如果计算了所有层，最后一张图像要么是单像素图像，要么是缩减后形状不变的图像。
- 参数:
- 图像ndarray
输入图像。
- max_layerint, 可选
金字塔的层数。第0层是原始图像。默认值为-1，表示构建所有可能的层。
- 缩小float, 可选
降采样因子。
- sigmafloat, 可选
高斯滤波器的Sigma值。默认值为 2 * 下采样 / 6.0，这对应于一个滤波器掩码，其大小是比例因子的两倍，覆盖了超过99%的高斯分布。
- 顺序int, 可选
用于下采样插值的样条顺序。详见
skimage.transform.warp。- 模式{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}, 可选
mode 参数决定了如何处理数组边界，当 mode 等于 ‘constant’ 时，cval 是该值。
- cvalfloat, 可选
如果模式是 ‘constant’，则填充输入边缘之外的值。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- channel_axisint 或 None, 可选
如果为 None，则假定图像是灰度图像（单通道）。否则，此参数指示数组的哪个轴对应于通道。
Added in version 0.19:
channel_axis在 0.19 版本中被添加。
- 返回:
- 金字塔生成器
生成器生成金字塔层作为浮点图像。
参考文献
- skimage.transform.pyramid_laplacian(image, max_layer=-1, downscale=2, sigma=None, order=1, mode='reflect', cval=0, preserve_range=False, *, channel_axis=None)[源代码][源代码]#
生成由输入图像形成的拉普拉斯金字塔的图像。
每一层包含下采样图像与下采样、平滑图像之间的差异:
layer = resize(prev_layer) - smooth(resize(prev_layer))
注意，金字塔的第一张图像是原始未缩放图像与其平滑版本之间的差异。图像总数为 max_layer + 1。如果计算了所有层，则最后一张图像要么是单像素图像，要么是缩减后形状不变的图像。
- 参数:
- 图像ndarray
输入图像。
- max_layerint, 可选
金字塔的层数。第0层是原始图像。默认值为-1，表示构建所有可能的层。
- 缩小float, 可选
降采样因子。
- sigmafloat, 可选
高斯滤波器的Sigma值。默认值为 2 * 下采样 / 6.0，这对应于一个滤波器掩码，其大小是比例因子的两倍，覆盖了超过99%的高斯分布。
- 顺序int, 可选
用于下采样插值的样条顺序。详见
skimage.transform.warp。- 模式{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}, 可选
mode 参数决定了如何处理数组边界，当 mode 等于 ‘constant’ 时，cval 是该值。
- cvalfloat, 可选
如果模式是 ‘constant’，则填充输入边缘之外的值。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- channel_axisint 或 None, 可选
如果为 None，则假定图像是灰度图像（单通道）。否则，此参数指示数组的哪个轴对应于通道。
Added in version 0.19:
channel_axis在 0.19 版本中被添加。
- 返回:
- 金字塔生成器
生成器生成金字塔层作为浮点图像。
参考文献
- skimage.transform.pyramid_reduce(image, downscale=2, sigma=None, order=1, mode='reflect', cval=0, preserve_range=False, *, channel_axis=None)[源代码][源代码]#
平滑然后下采样图像。
- 参数:
- 图像ndarray
输入图像。
- 缩小float, 可选
降采样因子。
- sigmafloat, 可选
高斯滤波器的Sigma值。默认值为 2 * 下采样 / 6.0，这对应于一个滤波器掩码，其大小是比例因子的两倍，覆盖了超过99%的高斯分布。
- 顺序int, 可选
用于下采样插值的样条顺序。详见
skimage.transform.warp。- 模式{‘reflect’, ‘constant’, ‘edge’, ‘symmetric’, ‘wrap’}, 可选
mode 参数决定了如何处理数组边界，当 mode 等于 ‘constant’ 时，cval 是该值。
- cvalfloat, 可选
如果模式是 ‘constant’，则填充输入边缘之外的值。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- channel_axisint 或 None, 可选
如果为 None，则假定图像是灰度图像（单通道）。否则，此参数指示数组的哪个轴对应于通道。
Added in version 0.19:
channel_axis在 0.19 版本中被添加。
- 返回:
- 出数组
平滑和降采样的浮点图像。
参考文献
- skimage.transform.radon(image, theta=None, circle=True, *, preserve_range=False)[源代码][源代码]#
计算给定投影角度的图像的拉东变换。
- 参数:
- 图像ndarray
输入图像。旋转轴将位于索引为
(image.shape[0] // 2, image.shape[1] // 2)的像素中。- theta数组，可选
投影角度（以度为单位）。如果为 None，则值设置为 np.arange(180)。
- 圆布尔值，可选
假设图像在内切圆外为零，使得每个投影的宽度（正弦图的第一维度）等于
min(image.shape)。- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- 返回:
- radon_imagendarray
Radon 变换（正弦图）。断层扫描的旋转轴将位于
radon_image的第 0 维度的像素索引radon_image.shape[0] // 2处。
注释
基于Justin K. Romberg的代码（https://www.clear.rice.edu/elec431/projects96/DSP/bpanalysis.html）
参考文献
[1]AC Kak, M Slaney, “计算机断层成像原理”, IEEE Press 1988.
[2]B.R. Ramesh, N. Srinivasa, K. Rajgopal, “一种用于计算离散Radon变换及其应用的算法”, 第四届IEEE区域10国际会议论文集, 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)[源代码][源代码]#
按一定比例缩放图像。
执行插值以放大或缩小 N 维图像。请注意，在缩小图像时应启用抗锯齿功能以避免锯齿伪影。对于使用整数因子进行下采样，另请参见
skimage.transform.downscale_local_mean。- 参数:
- 图像(M, N[, …][, C]) ndarray
输入图像。
- 比例{浮点数, 浮点数元组}
空间维度的比例因子。可以分别定义为 (m, n[, …])。
- 返回:
- 缩放ndarray
输入的缩放版本。
- 其他参数:
- 顺序int, 可选
样条插值的顺序，如果 image.dtype 是 bool 则默认为 0，否则为 1。顺序必须在 0-5 范围内。详情请参见
skimage.transform.warp。- 模式{‘常量’, ‘边缘’, ‘对称’, ‘反射’, ‘包裹’}, 可选
超出输入边界外的点根据给定的模式进行填充。模式与
numpy.pad的行为相匹配。- cvalfloat, 可选
与模式 ‘constant’ 结合使用时，图像边界外的值。
- 剪辑bool, 可选
是否将输出裁剪到输入图像的值范围。默认情况下启用此功能，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- 抗锯齿bool, 可选
是否在缩小图像之前应用高斯滤波器来平滑图像。在对图像进行下采样时，滤波是至关重要的，以避免混叠伪影。如果输入图像数据类型为布尔值，则不应用抗锯齿。
- anti_aliasing_sigma{浮点数, 浮点数元组}, 可选
高斯滤波的标准差，以避免混叠伪影。默认情况下，此值选择为 (s - 1) / 2，其中 s 是下采样因子。
- channel_axisint 或 None, 可选
如果为 None，则假定图像是灰度图像（单通道）。否则，此参数指示数组的哪个轴对应于通道。
Added in version 0.19:
channel_axis在 0.19 版本中被添加。
注释
模式 ‘reflect’ 和 ‘symmetric’ 相似，但区别在于在反射过程中边缘像素是否被复制。例如，如果一个数组的值为 [0, 1, 2] 并且使用 symmetric 向右填充四个值，结果将是 [0, 1, 2, 2, 1, 0, 0]，而使用 reflect 的结果将是 [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)[源代码][源代码]#
调整图像大小以匹配特定尺寸。
执行插值以放大或缩小 N 维图像。请注意，在缩小图像时应启用抗锯齿功能，以避免锯齿伪影。对于使用整数因子进行下采样，另请参见
skimage.transform.downscale_local_mean。- 参数:
- 图像ndarray
输入图像。
- 输出形状可迭代对象
生成的输出图像的大小 (行, 列[, …][, 维度])。如果未提供 维度，则通道数保持不变。如果输入通道数不等于输出通道数，则应用 n 维插值。
- 返回:
- 调整大小ndarray
输入的调整大小版本。
- 其他参数:
- 顺序int, 可选
样条插值的顺序，如果 image.dtype 是 bool 则默认为 0，否则为 1。顺序必须在 0-5 范围内。详情请参见
skimage.transform.warp。- 模式{‘常量’, ‘边缘’, ‘对称’, ‘反射’, ‘包裹’}, 可选
超出输入边界外的点根据给定的模式进行填充。模式与
numpy.pad的行为相匹配。- cvalfloat, 可选
与模式 ‘constant’ 结合使用时，图像边界外的值。
- 剪辑bool, 可选
是否将输出裁剪到输入图像的值范围。默认情况下启用此功能，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- 抗锯齿bool, 可选
是否在降采样之前对图像应用高斯滤波器以平滑图像。在降采样图像时进行滤波至关重要，以避免混叠伪影。如果未指定，当降采样数据类型不是布尔值的图像时，它会被设置为 True。当使用最近邻插值（
order== 0）且输入数据类型为整数时，它也会被设置为 False。- anti_aliasing_sigma{浮点数, 浮点数元组}, 可选
用于抗锯齿的高斯滤波的标准差。默认情况下，该值选择为 (s - 1) / 2，其中 s 是下采样因子，且 s > 1。对于上采样情况，s < 1，在重缩放之前不执行抗锯齿。
注释
模式 ‘reflect’ 和 ‘symmetric’ 相似，但区别在于在反射过程中边缘像素是否被复制。例如，如果一个数组的值为 [0, 1, 2] 并且使用 symmetric 向右填充四个值，结果将是 [0, 1, 2, 2, 1, 0, 0]，而使用 reflect 的结果将是 [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)[源代码][源代码]#
使用局部均值/双线性缩放调整数组大小。
- 参数:
- 图像ndarray
输入图像。如果这是一个多通道图像，应使用 channel_axis 指定对应通道的轴。
- 输出形状可迭代对象
生成的输出图像的大小。当 channel_axis 不为 None 时，channel_axis 应从 output_shape 中省略，或者
output_shape[channel_axis]必须与image.shape[channel_axis]匹配。如果 output_shape 的长度超过 image.ndim，将根据需要向输入image追加额外的单一维度。- 网格模式bool, 可选
定义
image像素位置：如果为 True，则假定像素位于网格交点处，否则位于单元格中心。因此，例如，长度为 5 的 1D 信号在 grid_mode 为 False 时被认为长度为 4，而在 grid_mode 为 True 时长度为 5。请参见以下视觉示例：| pixel 1 | pixel 2 | pixel 3 | pixel 4 | pixel 5 | |<-------------------------------------->| vs. |<----------------------------------------------->|上图中的箭头起点对应于每种模式中的坐标位置0。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- 返回:
- 调整大小ndarray
输入的调整大小版本。
注释
这种方法有时被称为“基于区域的”插值或“像素混合”插值 [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)[源代码][源代码]#
围绕其中心将图像旋转一定角度。
- 参数:
- 图像ndarray
输入图像。
- 角度浮动
逆时针方向的旋转角度（以度为单位）。
- 调整大小bool, 可选
确定输出图像的形状是否将自动计算，以使完整的旋转图像完全适合。默认值为 False。
- 中心长度为2的可迭代对象
旋转中心。如果
center=None，图像围绕其中心旋转，即center=(cols / 2 - 0.5, rows / 2 - 0.5)。请注意，此参数是 (cols, rows)，与常规的 skimage 顺序相反。
- 返回:
- 旋转ndarray
输入的旋转版本。
- 其他参数:
- 顺序int, 可选
样条插值的顺序，如果 image.dtype 是 bool 则默认为 0，否则为 1。顺序必须在 0-5 范围内。详情请参见
skimage.transform.warp。- 模式{‘常量’, ‘边缘’, ‘对称’, ‘反射’, ‘包裹’}, 可选
超出输入边界外的点根据给定的模式进行填充。模式与
numpy.pad的行为相匹配。- cvalfloat, 可选
与模式 ‘constant’ 结合使用时，图像边界外的值。
- 剪辑bool, 可选
是否将输出裁剪到输入图像的值范围。默认情况下启用此功能，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
注释
模式 ‘reflect’ 和 ‘symmetric’ 相似，但区别在于在反射过程中边缘像素是否被复制。例如，如果一个数组的值为 [0, 1, 2] 并且使用 symmetric 向右填充四个值，结果将是 [0, 1, 2, 2, 1, 0, 0]，而使用 reflect 的结果将是 [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)[源代码][源代码]#
执行旋转变换。
- 参数:
- 图像ndarray
输入图像。
- 中心(列, 行) 元组或 (2,) ndarray, 可选
变换的中心坐标。
- 强度float, 可选
应用的旋转量。
- 半径float, 可选
漩涡的像素范围。效果在超过 radius 后迅速消失。
- 旋转float, 可选
应用于图像的额外旋转。
- 返回:
- 旋涡状的ndarray
输入的旋转版本。
- 其他参数:
- 输出形状元组 (行, 列), 可选
生成的输出图像的形状。默认情况下，保留输入图像的形状。
- 顺序int, 可选
样条插值的顺序，如果 image.dtype 是 bool 则默认为 0，否则为 1。顺序必须在 0-5 范围内。详情请参见
skimage.transform.warp。- 模式{‘常量’, ‘边缘’, ‘对称’, ‘反射’, ‘包裹’}, 可选
超出输入边界外的点根据给定的模式填充，默认使用’reflect’。模式与`numpy.pad`的行为匹配。
- cvalfloat, 可选
与模式 ‘constant’ 结合使用时，图像边界外的值。
- 剪辑bool, 可选
是否将输出裁剪到输入图像的值范围。默认情况下启用此功能，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/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)[源代码][源代码]#
根据给定的坐标变换扭曲图像。
- 参数:
- 图像ndarray
输入图像。
- inverse_map : 变换对象，可调用
cr = f(cr, **kwargs)，或 ndarray转换对象, 可调用 逆坐标映射，将输出图像中的坐标转换为其在输入图像中对应的坐标。
定义此映射有多种不同的选项，具体取决于输入图像的维度。二维图像可以有2个维度用于灰度图像，或者3个维度包含颜色信息。
对于2-D图像，你可以直接传递一个变换对象，例如
skimage.transform.SimilarityTransform，或其逆变换。对于2D图像，你可以传递一个
(3, 3)齐次变换矩阵，例如 skimage.transform.SimilarityTransform.params。对于2D图像，一个将输出图像中的
(M, 2)数组(列, 行)坐标转换为其在输入图像中相应坐标的函数。可以通过 map_args 指定函数的额外参数。对于N维图像，您可以直接传递一个坐标数组。第一个维度指定输入图像中的坐标，而后续维度确定输出图像中的位置。例如，在2维图像的情况下，您需要传递一个形状为``(2, 行, 列)``的数组，其中`行`和`列`确定输出图像的形状，第一个维度包含输入图像中的``(行, 列)``坐标。有关更多文档，请参阅`scipy.ndimage.map_coordinates`。
注意，一个
(3, 3)矩阵被解释为一个齐次变换矩阵，因此如果输出形状为(3,)，则无法从 3-D 输入中插值值。查看示例部分以了解用法。
- map_argsdict, 可选
传递给 inverse_map 的关键字参数。
- 输出形状元组 (行, 列), 可选
生成的输出图像的形状。默认情况下，保留输入图像的形状。请注意，即使是多波段图像，也只需要指定行和列。
- 顺序int, 可选
- 插值的顺序。顺序必须在 0-5 的范围内：
0: 最近邻
1: 双线性（默认）
2: 双二次
3: 双三次
4: 双四次
5: 双五次
如果 image.dtype 是 bool 类型，则默认值为 0，否则为 1。
- 模式{‘常量’, ‘边缘’, ‘对称’, ‘反射’, ‘包裹’}, 可选
超出输入边界外的点根据给定的模式进行填充。模式与
numpy.pad的行为相匹配。- cvalfloat, 可选
与模式 ‘constant’ 结合使用时，图像边界外的值。
- 剪辑bool, 可选
是否将输出裁剪到输入图像的值范围。默认情况下启用此功能，因为高阶插值可能会产生超出给定输入范围的值。
- preserve_rangebool, 可选
是否保留原始值范围。否则，输入图像将根据 img_as_float 的约定进行转换。另请参见 https://scikit-image.org/docs/dev/user_guide/data_types.html
- 返回:
- 扭曲的双精度 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'>)[源代码][源代码]#
构建用于2-D图像扭曲输出的源坐标。
- 参数:
- coord_map类似 GeometricTransform.inverse 的可调用对象
返回给定输出坐标的输入坐标。坐标形状为 (P, 2)，其中 P 是坐标的数量，每个元素是一个
(行, 列)对。- 形状元组
输出图像的形状
(行, 列[, 波段])。- dtypenp.dtype 或字符串
返回值的dtype（合理选择：float32 或 float64）。
- 返回:
- coords : (ndim, 行, 列[, 波段]) 的 dtype 类型的数组(ndim, rows, cols[, bands]) dtype 类型的数组
scipy.ndimage.map_coordinates的坐标，将根据 coord_transform_fn 从源点绘制，生成形状为 (orows, ocols, bands) 的图像。
注释
这是一个较低级别的例程，用于生成 warp() 使用的二维图像的源坐标。
它与
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)[源代码][源代码]#
将图像重新映射到极坐标或对数极坐标空间。
- 参数:
- 图像(M, N[, C]) ndarray
输入图像。对于多通道图像，必须指定 channel_axis。
- 中心2-元组，可选
(row, col) 坐标表示 image 中代表变换中心（即笛卡尔空间中的原点）的点的位置。值可以是 float 类型。如果没有给出值，则中心点默认为 image 的中心。
- 半径float, 可选
要变换区域的边界圆的半径。
- 输出形状tuple (行, 列), 可选
- 缩放{‘线性’, ‘对数’}, 可选
指定图像扭曲是极坐标还是对数极坐标。默认为 ‘linear’。
- channel_axisint 或 None, 可选
如果为 None，则假定图像是灰度图像（单通道）。否则，此参数指示数组的哪个轴对应于通道。
Added in version 0.19:
channel_axis在 0.19 版本中被添加。- **kwargs关键字参数
传递给 transform.warp。
- 返回:
- 扭曲的ndarray
极坐标或对数极坐标变换后的图像。
示例
对灰度图像执行基本极坐标变换：
>>> 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)[源代码][源代码]#
-
仿射变换。
具有以下形式:
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]]
在二维中，变换参数可以作为齐次变换矩阵给出，如上所述，或者作为隐式参数，即缩放、旋转、剪切以及在 x (a2) 和 y (b2) 中的平移。对于三维及以上，只允许使用矩阵形式。
在更窄的变换中，例如欧几里得变换（仅旋转和平移）或相似变换（旋转、平移和全局比例因子），也可以使用隐式参数指定3D变换。
- 参数:
- 矩阵(D+1, D+1) 数组类，可选
齐次变换矩阵。如果提供了此矩阵，则提供任何比例、旋转、剪切或平移都是错误的。
- 比例{s 作为浮点数或 (sx, sy) 作为数组、列表或元组}, 可选
缩放因子。如果是一个单一值，它将被同时分配给 sx 和 sy。仅适用于二维。
Added in version 0.17: 增加了对提供单个标量值的支持。
- 旋转float, 可选
旋转角度，顺时针，以弧度为单位。仅适用于2D。
- 剪切浮点数或浮点数的2元组，可选
x 和 y 的剪切角度，顺时针方向，这些轴围绕原点旋转的角度 [2]。如果给定一个单一值，则将其视为 x 剪切角度，y 角度保持为 0。仅在 2D 中可用。
- 翻译(tx, ty) 作为数组、列表或元组，可选
翻译参数。仅适用于2D。
- 维度int, 可选
变换的维度。如果提供了任何其他参数，则不使用此参数。
- 属性:
- 参数(D+1, D+1) 数组
齐次变换矩阵。
- Raises:
- ValueError
如果同时提供了
matrix和其他任一参数。
参考文献
[1]Wikipedia, “仿射变换”, https://en.wikipedia.org/wiki/Affine_transformation#Image_transformation
[2]Wikipedia, “剪切映射”, 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)
- __init__(matrix=None, scale=None, rotation=None, shear=None, translation=None, *, dimensionality=2)[源代码][源代码]#
- property dimensionality#
变换的维度。
- estimate(src, dst, weights=None)[源代码]#
估计一组对应点之间的变换。
你可以使用总体最小二乘法来确定过定、适定和欠定参数。
源坐标和目标坐标的数量必须匹配。
转换定义为:
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) 数组类
源坐标。
- dst(N, 2) 数组类
目标坐标。
- 权重(N,) 数组类，可选
每对点之间的相对权重值。
- 返回:
- 成功布尔
如果模型估计成功，则为真。
- property inverse#
返回一个表示逆的变换对象。
- residuals(src, dst)[源代码]#
确定变换后的目标坐标的残差。
对于每个转换后的源坐标，确定其到相应目标坐标的欧几里得距离。
- 参数:
- src(N, 2) 数组
源坐标。
- dst(N, 2) 数组
目标坐标。
- 返回:
- 残差(N,) 数组
坐标残差。
- property rotation#
!! 由 numpydoc 处理 !!
- property scale#
!! 由 numpydoc 处理 !!
- property shear#
!! 由 numpydoc 处理 !!
- property translation#
!! 由 numpydoc 处理 !!
- class skimage.transform.EssentialMatrixTransform(rotation=None, translation=None, matrix=None, *, dimensionality=2)[源代码][源代码]#
-
基本矩阵变换。
基本矩阵关联一对校准图像之间的对应点。该矩阵将一个图像中的归一化齐次图像点转换为另一个图像中的极线。
基本矩阵仅针对捕捉非平面场景的一对移动图像定义。在纯旋转或平面场景的情况下，单应性描述了两幅图像之间的几何关系（
ProjectiveTransform）。如果图像的内在校准未知，基本矩阵描述了两幅图像之间的投影关系（FundamentalMatrixTransform）。- 参数:
- 旋转(3, 3) 数组类型，可选
相对相机运动的旋转矩阵。
- 翻译(3, 1) 数组类，可选
相对相机运动的平移向量。该向量必须具有单位长度。
- 矩阵(3, 3) 数组类型，可选
本质矩阵。
- 属性:
- 参数(3, 3) 数组
本质矩阵。
参考文献
[1]Hartley, Richard, 和 Andrew Zisserman. 《计算机视觉中的多视图几何》. 剑桥大学出版社, 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])
- estimate(src, dst)[源代码][源代码]#
使用8点算法估计本质矩阵。
8点算法需要至少8对对应点对以获得良好条件下的解，否则将估计超定解。
- 参数:
- src(N, 2) 数组类
源坐标。
- dst(N, 2) 数组类
目标坐标。
- 返回:
- 成功布尔
如果模型估计成功，则为真。
- property inverse#
返回一个表示逆的变换对象。
参见 Hartley & Zisserman, Ch. 8: 极几何与基本矩阵，以解释为什么 F.T 给出逆。
- class skimage.transform.EuclideanTransform(matrix=None, rotation=None, translation=None, *, dimensionality=2)[源代码][源代码]#
-
欧几里得变换，也称为刚性变换。
具有以下形式:
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。
- 参数:
- 矩阵(D+1, D+1) 数组类，可选
齐次变换矩阵。
- 旋转浮点数或浮点数序列，可选
旋转角度，顺时针方向，以弧度表示。如果给定为一个向量，它将被解释为欧拉旋转角度 [1]。仅支持2D（单次旋转）和3D（欧拉旋转）值。对于更高维度，您必须提供或估计变换矩阵。
- 翻译(x, y[, z, …]) 浮点数序列，长度为 D，可选
每个轴的翻译参数。
- 维度int, 可选
变换的维度。
- 属性:
- 参数(D+1, D+1) 数组
齐次变换矩阵。
参考文献
- property dimensionality#
变换的维度。
- estimate(src, dst)[源代码][源代码]#
估计一组对应点之间的变换。
你可以使用总体最小二乘法来确定过定、适定和欠定参数。
源坐标和目标坐标的数量必须匹配。
- 参数:
- src(N, 2) 数组类
源坐标。
- dst(N, 2) 数组类
目标坐标。
- 返回:
- 成功布尔
如果模型估计成功，则为真。
- property inverse#
返回一个表示逆的变换对象。
- residuals(src, dst)[源代码]#
确定变换后的目标坐标的残差。
对于每个转换后的源坐标，确定其到相应目标坐标的欧几里得距离。
- 参数:
- src(N, 2) 数组
源坐标。
- dst(N, 2) 数组
目标坐标。
- 返回:
- 残差(N,) 数组
坐标残差。
- property rotation#
!! 由 numpydoc 处理 !!
- property translation#
!! 由 numpydoc 处理 !!
- class skimage.transform.FundamentalMatrixTransform(matrix=None, *, dimensionality=2)[源代码][源代码]#
基类：
_GeometricTransform基本矩阵变换。
基本矩阵关联一对未校准图像之间的对应点。该矩阵将一个图像中的齐次图像点转换为另一个图像中的极线。
基本矩阵仅针对一对移动图像定义。在纯旋转或平面场景的情况下，单应性描述了两幅图像之间的几何关系（
ProjectiveTransform）。如果图像的内在校准已知，则本质矩阵描述了两幅图像之间的度量关系（EssentialMatrixTransform）。- 参数:
- 矩阵(3, 3) 数组类型，可选
基本矩阵。
- 属性:
- 参数(3, 3) 数组
基本矩阵。
参考文献
[1]Hartley, Richard, 和 Andrew Zisserman. 《计算机视觉中的多视图几何》. 剑桥大学出版社, 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]])
- estimate(src, dst)[源代码][源代码]#
使用8点算法估计基本矩阵。
8点算法需要至少8对对应点对以获得良好条件下的解，否则将估计超定解。
- 参数:
- src(N, 2) 数组类
源坐标。
- dst(N, 2) 数组类
目标坐标。
- 返回:
- 成功布尔
如果模型估计成功，则为真。
- property inverse#
返回一个表示逆的变换对象。
参见 Hartley & Zisserman, Ch. 8: 极几何与基本矩阵，以解释为什么 F.T 给出逆。
- class skimage.transform.PiecewiseAffineTransform[源代码][源代码]#
基类：
_GeometricTransform分段仿射变换。
控制点用于定义映射。变换基于点的Delaunay三角剖分来形成网格。每个三角形用于找到一个局部仿射变换。
- 属性:
- 仿射变换AffineTransform 对象列表
网格中每个三角形的仿射变换。
- inverse_affinesAffineTransform 对象列表
网格中每个三角形的逆仿射变换。
- estimate(src, dst)[源代码][源代码]#
估计一组对应点之间的变换。
源坐标和目标坐标的数量必须匹配。
- 参数:
- src(N, D) array_like
源坐标。
- dst(N, D) array_like
目标坐标。
- 返回:
- 成功布尔
如果模型的所有部分都成功估计，则为真。
- property inverse#
返回一个表示逆的变换对象。
- class skimage.transform.PolynomialTransform(params=None, *, dimensionality=2)[源代码][源代码]#
基类：
_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 ))
- 参数:
- 参数(2, N) 数组类，可选
多项式系数，其中 N * 2 = (order + 1) * (order + 2)。因此，a_ji 定义在 params[0, :] 中，b_ji 定义在 params[1, :] 中。
- 属性:
- 参数(2, N) 数组
多项式系数，其中 N * 2 = (order + 1) * (order + 2)。因此，a_ji 定义在 params[0, :] 中，b_ji 定义在 params[1, :] 中。
- estimate(src, dst, order=2, weights=None)[源代码][源代码]#
估计一组对应点之间的变换。
你可以使用总体最小二乘法来确定过定、适定和欠定参数。
源坐标和目标坐标的数量必须匹配。
转换定义为:
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) 数组类
源坐标。
- dst(N, 2) 数组类
目标坐标。
- 顺序int, 可选
多项式阶数（系数数量为阶数 + 1）。
- 权重(N,) 数组类，可选
每对点之间的相对权重值。
- 返回:
- 成功布尔
如果模型估计成功，则为真。
- property inverse#
返回一个表示逆的变换对象。
- class skimage.transform.ProjectiveTransform(matrix=None, *, dimensionality=2)[源代码][源代码]#
基类：
_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 ]].
- 参数:
- 矩阵(D+1, D+1) 数组类，可选
齐次变换矩阵。
- 维度int, 可选
变换的维度数量。如果
matrix不是 None，则忽略此项。
- 属性:
- 参数(D+1, D+1) 数组
齐次变换矩阵。
- property dimensionality#
变换的维度。
- estimate(src, dst, weights=None)[源代码][源代码]#
估计一组对应点之间的变换。
你可以使用总体最小二乘法来确定过定、适定和欠定参数。
源坐标和目标坐标的数量必须匹配。
转换定义为:
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) 数组类
源坐标。
- dst(N, 2) 数组类
目标坐标。
- 权重(N,) 数组类，可选
每对点之间的相对权重值。
- 返回:
- 成功布尔
如果模型估计成功，则为真。
- property inverse#
返回一个表示逆的变换对象。
- class skimage.transform.SimilarityTransform(matrix=None, scale=None, rotation=None, translation=None, *, dimensionality=2)[源代码][源代码]#
-
相似变换。
在二维中具有以下形式:
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 ]]
相似变换在欧几里得变换的基础上，除了旋转和平移参数外，还增加了一个单一的缩放因子。
- 参数:
- 矩阵(dim+1, dim+1) 数组类型, 可选
齐次变换矩阵。
- 比例float, 可选
缩放因子。仅对2D和3D实现。
- 旋转float, 可选
旋转角度，顺时针，以弧度表示。仅在2D和3D中实现。对于3D，这是以ZYX欧拉角给出的。
- 翻译(dim,) 数组类，可选
x, y[, z] 平移参数。仅对2D和3D实现。
- 属性:
- 参数(dim+1, dim+1) 数组
齐次变换矩阵。
- property dimensionality#
变换的维度。
- estimate(src, dst)[源代码][源代码]#
估计一组对应点之间的变换。
你可以使用总体最小二乘法来确定过定、适定和欠定参数。
源坐标和目标坐标的数量必须匹配。
- 参数:
- src(N, 2) 数组类
源坐标。
- dst(N, 2) 数组类
目标坐标。
- 返回:
- 成功布尔
如果模型估计成功，则为真。
- property inverse#
返回一个表示逆的变换对象。
- residuals(src, dst)[源代码]#
确定变换后的目标坐标的残差。
对于每个转换后的源坐标，确定其到相应目标坐标的欧几里得距离。
- 参数:
- src(N, 2) 数组
源坐标。
- dst(N, 2) 数组
目标坐标。
- 返回:
- 残差(N,) 数组
坐标残差。
- property rotation#
!! 由 numpydoc 处理 !!
- property scale#
!! 由 numpydoc 处理 !!
- property translation#
!! 由 numpydoc 处理 !!
- class skimage.transform.ThinPlateSplineTransform[源代码][源代码]#
基类：
object薄板样条变换。
给定两个匹配的点集，源点和目标点，此类估计薄板样条（TPS）变换，该变换将源点中的每个点转换为其目标点对应点。
- 属性:
- src(N, 2) 数组类
源图像中控制点的坐标。
参考文献
[1]Bookstein, Fred L. “主扭曲：薄板样条和平滑变形的分解,” 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]])
- estimate(src, dst)[源代码][源代码]#
估计源点和目标点之间的最佳样条映射。
- 参数:
- src(N, 2) 数组类
控制点位于源坐标。
- dst(N, 2) 数组类
目标坐标处的控制点。
- 返回:
- 成功: bool
True 表示估计成功。
注释
源点和目标点的数量 N 必须匹配。
- property inverse#
!! 由 numpydoc 处理 !!