transform

skimage.transform.downscale_local_mean（...）	通过局部平均下采样N维图像。
skimage.transform.estimate_transform（ttype，...）	估计2D几何变换参数。
skimage.transform.frt2（a）中	计算nxn整数阵列的二维有限氡变换（FRT）。
skimage.transform.hough_circle（图片，半径）	执行循环Hough变换。
skimage.transform.hough_circle_peaks（...，...）	在圆圈中返回峰值Hough变换。
skimage.transform.hough_ellipse（img，...）	执行椭圆Hough变换。
skimage.transform.hough_line（img，theta）	执行直线Hough变换。
skimage.transform.hough_line_peaks（hspace，...）	用直线Hough变换返回峰值。
skimage.transform.ifrt2（a）中	计算（n + 1）xn整数阵列的二维逆有限氡变换（iFRT）。
skimage.transform.integral_image（IMG）	积分图像/求和区域表。
skimage.transform.integrate（ii，开始，结束，...）	使用积分图像整合给定的窗口。
skimage.transform.iradon（radon_image，...）	逆氡变换。
skimage.transform.iradon_sart（radon_image，...）	逆氡变换
skimage.transform.matrix_transform（coords，...）	应用2D矩阵变换。
skimage.transform.order_angles_golden_ratio（THETA）	订购角度可减少后续投影中相关信息的数量。
skimage.transform.probabilistic_hough_line（IMG）	从渐进概率线Hough变换中返回线。
skimage.transform.pyramid_expand（image，...）	使用Upsample然后平滑图像。
skimage.transform.pyramid_gaussian（image，...）	由输入图像形成的高斯金字塔的产量图像。
skimage.transform.pyramid_laplacian（image，...）	由输入图像形成的拉普拉斯金字塔的产量图像。
skimage.transform.pyramid_reduce（image，...）	平滑然后下采样图像。
skimage.transform.radon（image，theta，circle）	计算指定投影角度下图像的氡变换。
skimage.transform.rescale（图片，比例，...）	按一定的因子缩放图像。
skimage.transform.resize（image，output_shape）	调整图像的大小以匹配一定的大小。
skimage.transform.rotate（图像，角度...）	围绕其中心旋转图像一定角度。
skimage.transform.seam_carve（img，...，...）	雕刻图像的垂直或水平接缝。
skimage.transform.swirl（图片，中心，...）	执行旋流转换。
skimage.transform.warp（image，inverse_map，...）	根据给定的坐标变换来变形图像。
skimage.transform.warp_coords（coord_map，shape）	构建二维图像扭曲输出的源坐标。
skimage.transform.AffineTransform（矩阵，...）	二维仿射变换的形式：
skimage.transform.EssentialMatrixTransform（...）	基本矩阵变换。
skimage.transform.EuclideanTransform（...）	二维欧几里德变换的形式：
skimage.transform.FundamentalMatrixTransform（...）	基本矩阵变换。
skimage.transform.PiecewiseAffineTransform（）	二维分段仿射变换。
skimage.transform.PolynomialTransform（PARAMS）	二维多项式的形式转换：
skimage.transform.ProjectiveTransform（基体）	射影变换。
skimage.transform.SimilarityTransform（...）	2D形式的相似变换：
skimage.transform.finite_radon_transform	作者：加里鲁本，2009	作者：	加里鲁本，2009
作者：	加里鲁本，2009
skimage.transform.hough_transform	​
skimage.transform.integral	​
skimage.transform.pyramids	​
skimage.transform.radon_transform	​
skimage.transform.seam_carving	​

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维图像，并计算输入图像中每个尺寸因子块中元素的局部平均值。

参数：	image：ndarray N维输入图像。因子：array_like包含沿每个轴的下采样整数因子的数组。cval：float，可选如果图像不能完全被整数因子整除，则为常量填充值。
返回：	image：与输入图像具有相同维数的下采样图像。

例子

>>> 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几何变换参数。

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

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

参数：	ttype：{'euclidean'，相似性'，'仿射'，'分段仿射'，'投影'，'多项式'}变换的类型。kwargs：阵列或者int功能参数（SRC，DST，N，角）：名称/ TTYPE为功能参数的欧几里德' src,dst的'similarity'SRC，dst'仿射' src,DST 'piecewise-affine'SRC，dst'投影' src,DST 'polynomial'SRC， ，dst（order多项式阶数，默认顺序为2）另请参阅下面的示例。
返回：	tform：GeometricTransform转换对象，包含转换参数并提供对正向和反向转换函数的访问。

例子

>>> 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）。

Parameters:	a : array_like A 2-D square n x n integer array.
Returns:	FRT : 2-D ndarray Finite Radon Transform array of (n+1) x n integer coefficients.

扩展内容

ifrt2 二维反转FRT。

笔记

当且仅当n是素数时，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)

应用有限Radon变换：

>>> f = frt2(img)

hough_circle

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

执行循环Hough变换。

参数：	图像：（M，N）ndarray用非零值表示边缘的输入图像。半径：用于计算霍夫变换的标量或标量序列。花车被转换为整数。normalize：布尔值，可选（默认值为True）使用用于绘制半径的像素数标准化累加器。full_output：布尔型，可选（默认为False）将输出尺寸扩大两倍最大半径，以检测输入图片之外的中心。
返回：	H：3D ndarray（半径指数，（M + 2R，N + 2R）ndarray）每个半径的Hough变换累加器。如果full_output为真，则R指定较大的半径。否则，R = 0。

例子

>>> 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变换。

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

参数：	hspaces：（N，M）数组hough_circle函数返回的Hough空间。半径：（M，）阵列半径对应于霍夫空间。min_xdistance：int，可选在x维中分隔中心的最小距离。min_ydistance：int，可选y维度中分隔中心的最小距离。阈值：浮点，可选每个霍夫空间中峰值的最小强度。默认值是0.5 * max（hspace）。num_peaks：int，可选每个Hough空间中的最大峰值数量。当峰值数量超过num_peaks时，对于相应的半径仅考虑基于峰值强度的num_peaks坐标。total_num_peaks：int，可选最大峰值数量。当峰值数量超过num_peaks时，返回基于峰值强度的num_peaks坐标。normalize：bool，可选如果为True，
返回：	accum，cx，cy，rad：阵列元组Hough空间中的峰值，x和y中心坐标和半径。

例子

>>> 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变换。

参数：	img：（M，N）ndarray用非零值表示边的输入图像。阈值：int，可选累加器阈值。准确度：双倍，在累加器中使用次轴上的可选分档大小。min_size：int，可选最小长轴长度。max_size：int，可选最大短轴长度。如果无，则该值设置为较小图像尺寸的一半。
返回：	结果：带有场的ndarray（累加器，y0，x0，a，b，方向）其中（yc，xc）是中心，（a，b）分别是主轴和次轴。方向值遵循skimage.draw.ellipse_perimeter约定。

笔记

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

参考

R480	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)]

hough_line

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

执行直线Hough变换。

参数：	img：（M，N）ndarray用非零值表示边的输入图像。theta：1D ndarray，以弧度表示可以计算变换的可选角度。默认为从-pi / 2到pi / 2均匀间隔的180个角度的矢量。
返回：	hspace：uint64 Hough变换累加器的2-D代码。角度：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
>>> 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变换中以特定角度和距离分隔的最显着线条。在霍夫空间的第一（距离）和第二（角度）维度中分别应用具有不同尺寸的非最大抑制来识别峰值。

参数：	hspace：（N，M）数组hough_line函数返回的Hough空间。角度：（M，）数组由hough_line函数返回的角度。假定是连续的。（角度-1-角度0 == PI）。dists：（N，）array hough_line函数返回的距离。min_distance：int，可选最小距离分隔线（霍夫空间第一维的最大过滤器大小）。min_angle：int，可选最小角度分隔线（霍夫空间第二维的最大滤波器大小）。阈值：浮点，可选最小峰值强度。默认值是0.5 * max（hspace）。num_peaks：int，可选最大数量的峰值。当峰值数量超过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=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）。

参数：	a：array_like A 2-D（n + 1）行xn列整数数组。
返回：	iFRT：二维nxn ndarray反向有限氡变换nxn整数系数阵列。

扩展内容

frt2 二维FRT

笔记

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

参考

R481	(1, 2) 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)

应用有限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]

参数：	img：ndarray输入图像。
返回：	S：与输入图像相同形状的积分图像/求和面积表。

参考

R482	FC Crow，“用于纹理映射的总面积表”，ACM SIGGRAPH Computer Graphics，vol。18，1984，第207-212页。

整合

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

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

参数：	ii：ndarray整体图像。start：元组列表，每个元组的长度等于ii的维数窗口左上角的坐标。列表中的每个元组都包含起始行，列，...索引即（row_win1，col_win1，...），（row_win2，col_win2，...），...。end：元组列表，每个元组的长度等于ii的维度窗口右下角的坐标。列表中的每个元组包含结束行，列，...索引即（row_win1，col_win1，...），（row_win2，col_win2，...），...。参数：可选为了与0.12之前的版本向后兼容。较早的函数签名是集成（ii，r0，c0，r1，c1），其中r0，c0是指定要集成的窗口的起始坐标的int（列表），以及r1，c1是结束坐标。
返回：	S：标量或ndarray给定窗口上的积分（和）。

例子

>>> 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]

逆氡变换。

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

参数：

radon_image：array_like，dtype = float包含氡变换（正弦图）的图像。图像的每一列对应于沿不同角度的投影。层析成像旋转轴应该位于radon_image的第0维的像素索引radon_image.shape0 // 2处。theta：array_like，dtype = float，可选重建角度（以度为单位）。默认：m个角度均匀分布在0到180之间（如果radon_image的形状是（N，M））。output_size：int重建中的行数和列数。filter：str，可选（默认斜坡）用于频域滤波的滤波器。斜坡过滤器默认使用。可用过滤器：斜坡，shepp-logan，余弦，hamming，hann。指定None不使用过滤器。插值：str，可选（默认'线性'）重建中使用的插值方法。可用方法：'线性'，'最近的'和'立方体'（'立方体'很慢）。circle：布尔值，可选假设重建图像在内切圆外是零。还会更改默认的output_size以匹配使用circle = True调用的氡的行为。默认行为（无）相当于False。

返回：

重建：ndarray重建图像。旋转轴将位于具有索引的像素中（reconstructed.shape0 // 2，reconstructed.shape1 // 2）。

笔记

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

参考

R483	AC Kak，M Slaney，“电脑断层成像原理”，IEEE Press 1988。

R484	BR 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

iradon_sart

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

逆氡变换

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

参数：

radon_image：二维数组，dtype = float包含氡变换（正弦图）的图像。图像的每一列对应于沿不同角度的投影。层析成像旋转轴应该位于radon_image的第0维的像素索引radon_image.shape0 // 2处。theta：1D数组，dtype = float，可选重建角度（以度为单位）。默认：m个角度均匀分布在0到180之间（如果radon_image的形状是（N，M））。图像：二维数组，dtype = float，可选包含初始重建估计的图像。这个数组的形状应该是（radon_image.shape0，radon_image.shape0）。默认值是一个零数组。projection_shifts：1D array，dtype = float在重建图像之前，将radon_image（正弦图）中包含的投影移动这么多个像素。第i个值定义了radon_image第i列的移位。clip：长度为2的浮点序列强制重构断层图中的所有值位于[clip0，clip1]范围内relaxation：float更新步骤的松弛参数。较高的价值可以提高收敛速度，但其中一个会面临不稳定的风险。不建议使用接近或高于1的值。

返回：

重建：ndarray重建图像。旋转轴将位于具有索引的像素中（reconstructed.shape0 // 2，reconstructed.shape1 // 2）。

笔记

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

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

参考

R485	AC Kak，M Slaney，“电脑断层成像原理”，IEEE Press 1988。

R486	AH Andersen，AC Kak，“同时代数重建技术（SART）：ART算法的优越实现”，Ultrasonic Imaging 6 pp 81-94（1984）

R487	S Kaczmarz，“Linear Solution of Systems of Linear Equations”，Bulletin International de l'AcadémiePolonaise des Sciences et des Lettres 35 pp 355-357（1937）

R488	Kohler，T。“基于黄金分割的迭代重建的投影访问方案”，核科学研讨会会议记录，2004 IEEE。卷。6. IEEE，2004。

matrix_transform

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

应用2D矩阵变换。

参数：	坐标：（N，2）数组x，y坐标变换矩阵：（3，3）数组齐次变换矩阵。
返回：	坐标：（N，2）数组转换后的坐标。

order_angles_golden_ratio

skimage.transform.order_angles_golden_ratio(theta)[source]

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

参数：	Theta：一维浮点数组投影角度（度）。不允许重复的角度。
返回：	indices_generator：生成器生成无符号整数返回的生成器将索引转换为theta，使得这些指示符给出投影的近似黄金比率排序。总的来说，len（θ）指数已经产生。所有非负整数<len（theta）都只产生一次。

笔记

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

参考

R490	Kohler，T。“基于黄金分割的迭代重建的投影访问方案”，核科学研讨会会议记录，2004 IEEE。卷。6. IEEE，2004。

R491	Winkelmann，Stefanie等。“基于黄金比率时间分辨MRI的最佳径向轮廓顺序”Medical Imaging，IEEE Transactions on 26.1（2007）：68-76。

probabilistic_hough_line

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

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

参数：	img：（M，N）ndarray用非零值表示边的输入图像。阈值：int，可选阈值line_length：int，可选最小可接受的检测行长度。增加参数以提取更长的行。line_gap：int，可选最大的像素间距仍然形成一条线。增加参数更积极地合并虚线。theta：1D ndarray，dtype = double，可选角度，以弧度计算变换。如果没有，请使用从-pi / 2到pi / 2的范围。
返回：	lines：list列出标识的行，格式为（（x0，y0），（x1，y1））的行，表示行的开始和结束。

参考

R492	C.Galamhos，J.Matas和J.Kitler，“Progressive probabilistic Hough transform for line detection”，IEEE Computer Society Conference on Computer Vision and Pattern Recognition，1999。

pyramid_expand

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

使用Upsample然后平滑图像。

参数：	image：数组输入图像。高档：浮动，可选高档系数。西格玛：浮点数，高斯滤波器的可选西格玛。默认值是2 * upscale / 6.0，它对应于覆盖超过99％高斯分布的比例因子大小的两倍的滤波器掩码。order：int，可选用于上采样插值的样条曲线的顺序。有关详细信息，请参阅skimage.transform.warp。mode：{'reflect'，'constant'，'edge'，'symmetric'，'wrap'}，可选模式参数确定如何处理数组边界，其中cval是mode等于'constant'时的值。cval：float，可选值，用于在模式为“常量”时填充输入的边界。
返回：	out：数组上采样和平滑的浮点图像。

参考

R493	http://web.mit.edu/persci/people/adelson/pub_pdfs/pyramid83.pdf

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。在计算所有图层的情况下，最后的图像可以是单像素图像，也可以是缩小图形不会改变的图像。

参数：	image：数组输入图像。max_layer：int金字塔的层数。第0层是原始图像。默认值是-1，它构建了所有可能的图层。缩减比例：浮动，可选的缩尺因子。西格玛：浮点数，高斯滤波器的可选西格玛。默认值为2 *缩放比例/ 6.0，对应于覆盖超过99％高斯分布的比例因子大小的两倍的滤波器掩码。order：int，可选的下采样插值中使用的样条曲线的顺序。有关详细信息，请参阅skimage.transform.warp。mode：{'reflect'，'constant'，'edge'，'symmetric'，'wrap'}，可选模式参数确定如何处理数组边界，其中cval是mode等于'constant'时的值。cval：float，可选值，用于在模式为“常量”时填充输入的边界。
返回：	金字塔：发电机发电机产生金字塔层作为浮动图像。

参考

R494	http://web.mit.edu/persci/people/adelson/pub_pdfs/pyramid83.pdf

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。在计算所有图层的情况下，最后的图像可以是单像素图像，也可以是缩小图形不会改变的图像。

参数：	image：数组输入图像。max_layer：int金字塔的层数。第0层是原始图像。默认值是-1，它构建了所有可能的图层。缩减比例：浮动，可选的缩尺因子。西格玛：浮点数，高斯滤波器的可选西格玛。默认值为2 *缩放比例/ 6.0，对应于覆盖超过99％高斯分布的比例因子大小的两倍的滤波器掩码。order：int，可选的下采样插值中使用的样条曲线的顺序。有关详细信息，请参阅skimage.transform.warp。mode：{'reflect'，'constant'，'edge'，'symmetric'，'wrap'}，可选模式参数确定如何处理数组边界，其中cval是mode等于'constant'时的值。cval：float，可选值，用于在模式为“常量”时填充输入的边界。
返回：	金字塔：发电机发电机产生金字塔层作为浮动图像。

参考

R495	http://web.mit.edu/persci/people/adelson/pub_pdfs/pyramid83.pdf

R496	http://sepwww.stanford.edu/data/media/public/sep/morgan/texturematch/paper_html/node3.html

pyramid_reduce

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

平滑然后下采样图像。

参数：	image：数组输入图像。缩减比例：浮动，可选的缩尺因子。西格玛：浮点数，高斯滤波器的可选西格玛。默认值为2 *缩放比例/ 6.0，对应于覆盖超过99％高斯分布的比例因子大小的两倍的滤波器掩码。order：int，可选的下采样插值中使用的样条曲线的顺序。有关详细信息，请参阅skimage.transform.warp。mode：{'reflect'，'constant'，'edge'，'symmetric'，'wrap'}，可选模式参数确定如何处理数组边界，其中cval是mode等于'constant'时的值。cval：float，可选值，用于在模式为“常量”时填充输入的边界。
返回：	out：array平滑和降采样的浮点图像。

参考

R497	http://web.mit.edu/persci/people/adelson/pub_pdfs/pyramid83.pdf

氡

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

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

参数：	image：array_like，dtype = float输入图像。旋转轴将位于具有索引的像素中（image.shape0 // 2，image.shape1 // 2）。theta：array_like，dtype = float，可选（默认np.arange（180））投影角度（以度为单位）。circle：boolean，可选假设图像在内切圆外是零，使得每个投影的宽度（sinogram的第一维）等于min（image.shape）。默认行为（无）相当于False。
返回：	radon_image：ndarray Radon变换（正弦图）。层析成像旋转轴将位于沿着radon_image的第0维的像素索引radon_image.shape0 // 2处。

笔记

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

参考

R498	AC Kak，M Slaney，“电脑断层成像原理”，IEEE Press 1988。

R499	BR 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=1, mode=None, cval=0, clip=True, preserve_range=False)[source]

按一定的因子缩放图像。

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

参数：	图像：ndarray输入图像。比例尺：{float，浮动元组}比例因子。单独的比例因子可以定义为（row_scale，col_scale）。
返回：	缩放：ndarray输入的缩放版本。

| 其他参数：|

| | 顺序：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。

参数：	图像：ndarray输入图像。output_shape：元组或ndarray生成的输出图像的大小（行，列，暗）。如果不提供暗淡，通道数量将被保留。如果输入通道的数量不等于输出通道的数量，则应用三维插值。
返回：	调整大小：ndarray输入的调整大小版本。

| 其他参数：|

| | 顺序：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]

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

参数：	图像：ndarray输入图像。角度：浮点以逆时针方向以度数旋转的角度。resize：bool，optional确定输出图像的形状是否会自动计算，因此完全旋转的图像完全适合。默认值是False。中心：长度为2的iterable旋转中心。如果中心=无，则图像围绕其中心旋转，即center =（rows / 2 - 0.5，cols / 2 - 0.5）。
返回：	旋转：ndarray输入的旋转版本。

| 其他参数：|

| | 顺序：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]

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

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

参数：	图像：（M，N）或（M，N，3）ndarray要删除接缝的输入图像。energy_map：（M，N）ndarray确定每个像素重要性的数组。与像素相对应的值越高，算法尝试将其保留在图像中的越多。模式：str {'horizo​​ntal'，'vertical'}指示接缝是垂直还是水平移除。水平移除接缝会降低高度，而垂直移除会减小宽度。num：int接缝的数量将被删除。border：int，可选在图像的右侧，左侧和底端的像素数量被排除在接缝之外。这是很重要的，因为某些过滤器只是忽略图像边界并将它们设置为0.默认情况下，边框设置为1. force_copy：bool，可选如果设置，图像和energy_map在被修改它的方法使用之前被复制。如果在此操作之后不再需要原始图像和能量图，则将其设置为False。
返回：	out：ndarray删除接缝后裁切的图像。

参考

R500	Shai Avidan and Ariel Shamir “Seam Carving for Content-Aware Image Resizing” http://www.cs.jhu.edu/~misha/ReadingSeminar/Papers/Avidan07.pdf

漩涡

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]

执行旋流转换。

参数：	图像：ndarray输入图像。中心:(行，列）元组或（2，）ndarray，可选的转换中心坐标。strength：float，可选应用的旋转量。radius：float，可选旋涡的范围（以像素为单位）。效果迅速消失超出半径。rotation：float，可选用于图像的附加旋转。
返回：	漩涡：ndarray输入的旋转版本。

| 其他参数：|

| | 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]

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

参数：

图像：ndarray输入图像。inverse_map：变换对象，可调用cr = f（cr，** kwargs）或ndarray逆向坐标图，它将输出图像中的坐标转换为输入图像中相应的坐标。根据输入图像的维度，定义此地图有多种不同的选项。二维图像可以具有用于灰度图像的2维或具有颜色信息的3维。对于二维图像，可以直接传递变形对象，例如skimage.transform.SimilarityTransform或其逆。对于二维图像，可以传递一个（3，3）齐次变换矩阵，例如skimage.transform.SimilarityTransform.params。对于二维图像，将输出图像中（col，row）坐标的（M，2）数组转换为输入图像中相应坐标的函数。该函数的额外参数可以通过map_args指定。对于ND图像，您可以直接传递一组坐标。第一个维度指定输入图像中的坐标，后续维度则确定输出图像中的位置。例如，对于二维图像，您需要传递一个形状数组（2，行，列），其中行和列决定输出图像的形状，第一个维度包含（row，col）坐标输入图像。有关更多文档，请参阅scipy.ndimage.map_coordinates。请注意，（3，3）矩阵被解释为齐次变换矩阵，所以如果输出为形状（3，），则不能从3D输入中插值。查看使用示例部分。map_args：dict，可选的关键字参数传递给inverse_map。output_shape：元组（行，列），生成输出图像的可选形状。默认情况下，输入图像的形状被保留。请注意，即使对于多波段图像，也只需要指定行和列。顺序：int，可选插值顺序。顺序必须在0-5之间：0：最近邻居1：双线性（默认）2：双二次3：双立方4：双四次5：双五次模式：{'常数'，'边缘'，'对称'，'反射'，'包裹'}，根据给定模式填充输入边界外的可选点。模式与numpy.pad的行为相匹配。cval：float，可选与模式“常​​量”一起使用，即图像边界外的值。clip：bool，可选是否将输出剪切到输入图像的值范围。这是默认启用的，因为更高阶内插可能产生给定输入范围之外的值。preserve_range：bool，可选是否保留原始值的范围。否则，输入图像将根据img_as_float的惯例进行转换。

返回：

warped：double ndarray扭曲的输入图像。

• 对于二维图像，您可以直接传递一个转换对象，例如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]

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

参数：	coord_map：类似GeometricTransform.inverse的可调用返回给定输出坐标的输入坐标。坐标的形状是（P，2），其中P是坐标数，每个元素是（行，列）对。形状：元组输出图像的形状（行，列，带）。dtype：np.dtype或字符串dtype返回值（理性选择：float32或float64）。
返回：	坐标：（ndim，rows，cols，bands）dtype dtype数组坐标scipy.ndimage.map_coordinates，通过根据coord_transform_fn从源点中绘制，生成一个形状图像（orows，ocols，bands）。

笔记

这是一个较低级别的例程，用于生成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]]

参数：	矩阵：（3，3）数组，可选的齐次变换矩阵。比例尺：（sx，sy）作为数组，列表或元组，可选比例因子。旋转：浮动，可选逆时针旋转角度，弧度。剪切：浮动，可选逆时针剪切角度，弧度。翻译：（tx，ty）作为数组，列表或元组，可选Translation参数。

属性

params	((3, 3) array) Homogeneous transformation matrix.

__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）之间的投影关系。

参数：	旋转：（3，3）阵列，可选的相对运动的旋转矩阵。翻译：（3,1）数组，可选的相对运动的平移矢量。矢量必须有单位长度。矩阵：（3，3）数组，可选的基本矩阵。

参考

R501	Hartley, Richard, and Andrew Zisserman. Multiple view geometry in computer vision. Cambridge university press, 2003.

属性

params	((3, 3) array) Essential matrix.

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

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

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

参数：	src：（N，2）数组源坐标。dst：（N，2）数组目标坐标。
返回：	成功：布尔如果模型估计成功，则为真。

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]]

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

参数：	矩阵：（3，3）数组，可选的齐次变换矩阵。旋转：浮动，可选逆时针旋转角度，弧度。翻译：（tx，ty）作为数组，列表或元组，可选的x，y翻译参数。

属性

params	((3, 3) array) Homogeneous transformation matrix.

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

估计一组相应点的转换。

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

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

参数：	src：（N，2）数组源坐标。dst：（N，2）数组目标坐标。
返回：	成功：布尔如果模型估计成功，则为真。

rotationtranslation

FundamentalMatrixTransform

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

Bases: skimage.transform._geometric.GeometricTransform

基本矩阵变换。

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

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

参数：	矩阵：（3，3）数组，可选的基本矩阵。

参考

R502	Hartley, Richard, and Andrew Zisserman. Multiple view geometry in computer vision. Cambridge university press, 2003.

属性

params	((3, 3) array) Fundamental matrix.

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

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

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

参数：	src：（N，2）数组源坐标。dst：（N，2）数组目标坐标。
返回：	成功：布尔如果模型估计成功，则为真。

inverse(coords)[source]

应用逆变换。

参数：	坐标：（N，2）数组目标坐标。
返回：	坐标：（N，3）阵列在源图像中的对极线。

residuals(src, dst)[source]

计算桑普森距离。

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

参数：	src：（N，2）数组源坐标。dst：（N，2）数组目标坐标。
返回：	残差：（N，）阵列桑普森距离。

PiecewiseAffineTransform

class skimage.transform.PiecewiseAffineTransform[source]

Bases: skimage.transform._geometric.GeometricTransform

二维分段仿射变换。

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

属性

仿射	（AffineTransform对象列表）网格中每个三角形的仿射变换。
inverse_affines	（AffineTransform对象列表）网格中每个三角形的逆仿射变换。

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

估计一组相应点的转换。

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

参数：	src：（N，2）数组源坐标。dst：（N，2）数组目标坐标。
返回：	成功：布尔如果模型估计成功，则为真。

inverse(coords)[source]

应用逆变换。

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

参数：	坐标：（N，2）数组源坐标。
返回：	坐标：（N，2）数组转换后的坐标。

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 ))

参数：	参数：（2，N）数组，可选的多项式系数，其中N * 2 =（order + 1）*（order + 2）。所以，a_ji在params0，：和b_ji中定义在params1，：中。

属性

params	((2, N) array) Polynomial coefficients where N * 2 = (order + 1) * (order + 2). So, a_ji is defined in params0, : and b_ji in params1, :.

__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规定的最小奇异值。

参数：	src：（N，2）数组源坐标。dst：（N，2）数组目标坐标。顺序：int，可选多项式顺序（系数数量为order + 1）。
返回：	成功：布尔如果模型估计成功，则为真。

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 ]].

参数：	matrix : (3, 3) array，可选的齐次变换矩阵。

属性

params	（ (3, 3) array）均匀变换矩阵。

__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]

参数：	src : (N, 2) array 源坐标。 dst : (N, 2) array 目标坐标。
返回：	成功：布尔如果模型估计成功，则为真。

inverse(coords)[source]

应用逆变换。

参数：	坐标：（N，2）数组目标坐标。
返回：	坐标：（N，2）数组源坐标。

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]]

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

参数：	矩阵：（3，3）数组，可选的齐次变换矩阵。scale：float，可选比例因子。旋转：浮动，可选逆时针旋转角度，弧度。翻译：（tx，ty）作为数组，列表或元组，可选的x，y翻译参数。

属性

PARAMS	((3, 3) array) 均匀变换矩阵。

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

估计一组相应点的转换。

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

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

参数：	src：（N，2）数组源坐标。dst：（N，2）数组目标坐标。
返回：	成功：布尔如果模型估计成功，则为真。

scale