skimage.feature#
在给定的灰度图像中查找斑点。 |
|
在给定的灰度图像中查找斑点。 |
|
在给定的灰度图像中查找斑点。 |
|
使用 Canny 算法对图像进行边缘滤波。 |
|
为给定图像提取 FAST 角点。 |
|
计算 Foerstner 角点测度响应图像。 |
|
计算 Harris 角点测度响应图像。 |
|
计算 Kitchen 和 Rosenfeld 角点测度响应图像。 |
|
计算 Moravec 角点测度响应图像。 |
|
计算角点的方向。 |
|
在角点测度响应图像中查找峰值。 |
|
计算 Shi-Tomasi（Kanade-Tomasi）角点测度响应图像。 |
|
确定角点的亚像素位置。 |
|
为给定图像密集地提取 DAISY 特征描述符。 |
|
Haar-like 特征的可视化。 |
|
多块局部二进制模式可视化。 |
|
给定一些描述符/向量和关联的估计 GMM，计算 Fisher 向量。 |
|
计算灰度共生矩阵。 |
|
计算 GLCM 的纹理属性。 |
|
为积分图像的感兴趣区域 (ROI) 计算 Haar-like 特征。 |
|
计算 Haar-like 特征的坐标。 |
|
计算 Hessian 矩阵。 |
|
计算图像上的近似 Hessian 行列式。 |
|
计算 Hessian 矩阵的特征值。 |
|
为给定图像提取方向梯度直方图 (HOG)。 |
|
给定一组描述符和模式数量（即高斯分布），估计高斯混合模型 (GMM)。 |
|
计算图像的局部二进制模式 (LBP)。 |
|
描述符的暴力匹配。 |
|
使用归一化相关性将模板匹配到 2D 或 3D 图像。 |
|
多块局部二进制模式 (MB-LBP)。 |
|
单个或多通道 nd 图像的局部特征。 |
|
将图像中的峰值作为坐标列表查找。 |
|
已弃用： |
|
计算形状指数。 |
|
使用平方差之和计算结构张量。 |
|
计算结构张量的特征值。 |
|
BRIEF 二进制描述符提取器。 |
|
CENSURE 关键点检测器。 |
|
用于对象检测的分类器级联类。 |
|
面向 FAST 和旋转 BRIEF 特征检测器和二进制描述符提取器。 |
|
SIFT 特征检测和描述符提取。 |
- skimage.feature.blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=0.5, overlap=0.5, *, threshold_rel=None, exclude_border=False)[source]#
在给定的灰度图像中查找斑点。
使用高斯差 (DoG) 方法 [1]、[2] 查找斑点。对于找到的每个斑点，该方法返回其坐标和检测到斑点的 Gaussian 核的标准差。
- 参数：
- imagendarray
输入灰度图像，斑点被假定为亮背景上的暗色（白色在黑色上）。
- min_sigma标量或标量序列，可选
Gaussian 核的最小标准差。保持此值较低以检测较小的斑点。Gaussian 滤波器的标准差以序列的形式给出，或以单个数字的形式给出，在这种情况下，所有轴都相等。
- max_sigma标量或标量序列，可选
Gaussian 核的最大标准差。保持此值较高以检测较大的斑点。Gaussian 滤波器的标准差以序列的形式给出，或以单个数字的形式给出，在这种情况下，所有轴都相等。
- sigma_ratio浮点数，可选
用于计算高斯差的 Gaussian 核的标准差之间的比率
- threshold浮点数或 None，可选
尺度空间最大值的绝对下限。小于 threshold 的局部最大值将被忽略。降低此值以检测强度较低的斑点。如果也指定了 threshold_rel，则将使用较大的阈值。如果为 None，则改为使用 threshold_rel。
- overlap浮点数，可选
介于 0 到 1 之间的值。如果两个斑点的面积重叠部分大于 threshold，则较小的斑点将被消除。
- threshold_rel浮点数或 None，可选
峰值的最小强度，计算为
max(dog_space) * threshold_rel，其中dog_space指的是内部计算的高斯差 (DoG) 图像堆栈。此值应介于 0 到 1 之间。如果为 None，则改为使用 threshold。- exclude_border整数元组、整数或 False，可选
如果为整数元组，则元组的长度必须与输入数组的维数匹配。元组的每个元素将排除图像边界沿该维度的 exclude_border 像素内的峰值。如果为非零整数，则 exclude_border 将排除图像边界 exclude_border 像素内的峰值。如果为零或 False，则无论峰值距离边界多远，都将识别它们。
- 返回：
- A(n, image.ndim + sigma) ndarray
一个二维数组，其中每一行表示 2D 图像的 2 个坐标值，或 3D 图像的 3 个坐标值，加上使用的 sigma(s)。当传递单个 sigma 时，输出为：
(r, c, sigma)或(p, r, c, sigma)，其中(r, c)或(p, r, c)是斑点的坐标，sigma是检测到斑点的 Gaussian 核的标准差。当使用各向异性高斯（每个维度上的 sigma）时，会为每个维度返回检测到的 sigma。
备注
每个斑点的半径约为 \(\sqrt{2}\sigma\)（对于 2D 图像）和 \(\sqrt{3}\sigma\)（对于 3D 图像）。
参考
[2]Lowe, D. G. “来自尺度不变关键点的独特图像特征”。计算机视觉国际期刊 60, 91–110 (2004)。https://www.cs.ubc.ca/~lowe/papers/ijcv04.pdf DOI:10.1023/B:VISI.0000029664.99615.94
示例
>>> from skimage import data, feature >>> coins = data.coins() >>> feature.blob_dog(coins, threshold=.05, min_sigma=10, max_sigma=40) array([[128., 155., 10.], [198., 155., 10.], [124., 338., 10.], [127., 102., 10.], [193., 281., 10.], [126., 208., 10.], [267., 115., 10.], [197., 102., 10.], [198., 215., 10.], [123., 279., 10.], [126., 46., 10.], [259., 247., 10.], [196., 43., 10.], [ 54., 276., 10.], [267., 358., 10.], [ 58., 100., 10.], [259., 305., 10.], [185., 347., 16.], [261., 174., 16.], [ 46., 336., 16.], [ 54., 217., 10.], [ 55., 157., 10.], [ 57., 41., 10.], [260., 47., 16.]])
- skimage.feature.blob_doh(image, min_sigma=1, max_sigma=30, num_sigma=10, threshold=0.01, overlap=0.5, log_scale=False, *, threshold_rel=None)[source]#
在给定的灰度图像中查找斑点。
使用Hessian矩阵行列式方法 [1] 查找斑点。对于每个找到的斑点，该方法返回其坐标和用于Hessian矩阵的Gaussian核的标准差，该矩阵的行列式检测到斑点。Hessian行列式使用 [2] 近似。
- 参数：
- image2D ndarray
输入灰度图像。斑点可以是亮色在暗色背景上，也可以是反过来。
- min_sigmafloat, optional
用于计算Hessian矩阵的Gaussian核的最小标准差。将此值保持较低以检测较小的斑点。
- max_sigmafloat, optional
用于计算Hessian矩阵的Gaussian核的最大标准差。将此值保持较高以检测较大的斑点。
- num_sigmaint, optional
要考虑的标准差中间值的个数，介于 min_sigma 和 max_sigma 之间。
- threshold浮点数或 None，可选
尺度空间最大值的绝对下限。小于 threshold 的局部最大值将被忽略。降低此值以检测强度较低的斑点。如果也指定了 threshold_rel，则将使用较大的阈值。如果为 None，则改为使用 threshold_rel。
- overlap浮点数，可选
介于 0 到 1 之间的值。如果两个斑点的面积重叠部分大于 threshold，则较小的斑点将被消除。
- log_scalebool, optional
如果设置为True，则标准差的中间值将使用以 10 为底的对数刻度进行插值。否则，将使用线性插值。
- threshold_rel浮点数或 None，可选
峰值的最小强度，计算方法为
max(doh_space) * threshold_rel，其中doh_space指的是内部计算的Hessian行列式（DoH）图像堆栈。该值应介于 0 和 1 之间。如果为 None，则使用 threshold 代替。
- 返回：
- A(n, 3) ndarray
一个二维数组，其中每行代表 3 个值，
(y,x,sigma)，其中(y,x)是斑点的坐标，sigma是Hessian矩阵的Gaussian核的标准差，该矩阵的行列式检测到斑点。
备注
每个斑点的半径约为 sigma。Hessian行列式的计算与标准差无关。因此，检测更大的斑点不会花费更多时间。在像
blob_dog()和blob_log()这样的方法中，计算较大的 sigma 的高斯函数会花费更多时间。缺点是，由于在Hessian行列式近似中使用了盒子滤波器，因此该方法不能用于检测半径小于 3px 的斑点。参考
[2]Herbert Bay, Andreas Ess, Tinne Tuytelaars, Luc Van Gool, “SURF: Speeded Up Robust Features” ftp://ftp.vision.ee.ethz.ch/publications/articles/eth_biwi_00517.pdf
示例
>>> from skimage import data, feature >>> img = data.coins() >>> feature.blob_doh(img) array([[197. , 153. , 20.33333333], [124. , 336. , 20.33333333], [126. , 153. , 20.33333333], [195. , 100. , 23.55555556], [192. , 212. , 23.55555556], [121. , 271. , 30. ], [126. , 101. , 20.33333333], [193. , 275. , 23.55555556], [123. , 205. , 20.33333333], [270. , 363. , 30. ], [265. , 113. , 23.55555556], [262. , 243. , 23.55555556], [185. , 348. , 30. ], [156. , 302. , 30. ], [123. , 44. , 23.55555556], [260. , 173. , 30. ], [197. , 44. , 20.33333333]])
- skimage.feature.blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=0.2, overlap=0.5, log_scale=False, *, threshold_rel=None, exclude_border=False)[source]#
在给定的灰度图像中查找斑点。
使用高斯-拉普拉斯 (LoG) 方法 [1] 查找斑点。对于每个找到的斑点，该方法返回其坐标和检测到该斑点的 Gaussian 核的标准差。
- 参数：
- imagendarray
输入灰度图像，斑点被假定为亮背景上的暗色（白色在黑色上）。
- min_sigma标量或标量序列，可选
Gaussian 核的最小标准差。将此值保持较低以检测较小的斑点。Gaussian 滤波器的标准差以序列的形式为每个轴给出，或者以单个数字的形式给出，在这种情况下，它对所有轴都相等。
- max_sigma标量或标量序列，可选
Gaussian 核的最大标准差。保持此值较高以检测较大的斑点。Gaussian 滤波器的标准差以序列的形式给出，或以单个数字的形式给出，在这种情况下，所有轴都相等。
- num_sigmaint, optional
要考虑的标准差中间值的个数，介于 min_sigma 和 max_sigma 之间。
- threshold浮点数或 None，可选
尺度空间最大值的绝对下限。小于 threshold 的局部最大值将被忽略。降低此值以检测强度较低的斑点。如果也指定了 threshold_rel，则将使用较大的阈值。如果为 None，则改为使用 threshold_rel。
- overlap浮点数，可选
介于 0 到 1 之间的值。如果两个斑点的面积重叠部分大于 threshold，则较小的斑点将被消除。
- log_scalebool, optional
如果设置为True，则标准差的中间值将使用以 10 为底的对数刻度进行插值。否则，将使用线性插值。
- threshold_rel浮点数或 None，可选
峰值的最小强度，计算方法为
max(log_space) * threshold_rel，其中log_space指的是内部计算的高斯-拉普拉斯 (LoG) 图像堆栈。该值应介于 0 和 1 之间。如果为 None，则使用 threshold 代替。- exclude_border整数元组、整数或 False，可选
如果为整数元组，则元组的长度必须与输入数组的维数匹配。元组的每个元素将排除图像边界沿该维度的 exclude_border 像素内的峰值。如果为非零整数，则 exclude_border 将排除图像边界 exclude_border 像素内的峰值。如果为零或 False，则无论峰值距离边界多远，都将识别它们。
- 返回：
- A(n, image.ndim + sigma) ndarray
一个二维数组，其中每一行表示 2D 图像的 2 个坐标值，或 3D 图像的 3 个坐标值，加上使用的 sigma(s)。当传递单个 sigma 时，输出为：
(r, c, sigma)或(p, r, c, sigma)，其中(r, c)或(p, r, c)是斑点的坐标，sigma是检测到斑点的 Gaussian 核的标准差。当使用各向异性高斯（每个维度上的 sigma）时，会为每个维度返回检测到的 sigma。
备注
每个斑点的半径约为 \(\sqrt{2}\sigma\)（对于 2D 图像）和 \(\sqrt{3}\sigma\)（对于 3D 图像）。
参考
示例
>>> from skimage import data, feature, exposure >>> img = data.coins() >>> img = exposure.equalize_hist(img) # improves detection >>> feature.blob_log(img, threshold = .3) array([[124. , 336. , 11.88888889], [198. , 155. , 11.88888889], [194. , 213. , 17.33333333], [121. , 272. , 17.33333333], [263. , 244. , 17.33333333], [194. , 276. , 17.33333333], [266. , 115. , 11.88888889], [128. , 154. , 11.88888889], [260. , 174. , 17.33333333], [198. , 103. , 11.88888889], [126. , 208. , 11.88888889], [127. , 102. , 11.88888889], [263. , 302. , 17.33333333], [197. , 44. , 11.88888889], [185. , 344. , 17.33333333], [126. , 46. , 11.88888889], [113. , 323. , 1. ]])
- skimage.feature.canny(image, sigma=1.0, low_threshold=None, high_threshold=None, mask=None, use_quantiles=False, *, mode='constant', cval=0.0)[source]#
使用 Canny 算法对图像进行边缘滤波。
- 参数：
- image2D array
用于检测边缘的灰度输入图像；可以是任何数据类型。
- sigmafloat, optional
Gaussian 滤波器的标准差。
- low_thresholdfloat, optional
滞后阈值处理（连接边缘）的下限。如果为 None，则 low_threshold 设置为数据类型最大值的 10%。
- high_thresholdfloat, optional
滞后阈值处理（连接边缘）的上限。如果为 None，则 high_threshold 设置为数据类型最大值的 20%。
- maskarray, dtype=bool, optional
掩码，用于将 Canny 的应用限制在某个区域。
- use_quantilesbool, optional
如果为
True，则将 low_threshold 和 high_threshold 视为边缘幅度图像的百分位数，而不是绝对边缘幅度值。如果为True，则阈值必须在 [0, 1] 范围内。- modestr, {‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}
参数
mode决定了在 Gaussian 滤波期间如何处理数组边界，其中cval是 mode 等于 ‘constant’ 时的值。- cvalfloat, optional
如果 mode 为 ‘constant’，则用于填充输入边缘之外的值。
- 返回：
- output2D array (image)
二进制边缘图。
备注
算法步骤如下：
使用宽度为
sigma的 Gaussian 对图像进行平滑处理。应用水平和垂直 Sobel 算子以获得图像中的梯度。边缘强度是梯度的范数。
将潜在的边缘细化为 1 像素宽的曲线。首先，在每个点找到边缘的法线。这是通过查看 X-Sobel 和 Y-Sobel 的符号和相对大小来完成的，将这些点分为 4 类：水平、垂直、对角线和反对角线。然后查看法线方向和反方向，以查看这两个方向中的任何一个方向上的值是否大于该点。使用插值来混合点，而不是选择最接近法线的点。
执行滞后阈值处理：首先将所有高于高阈值的点标记为边缘。然后递归地标记所有高于低阈值且与标记点 8 连通的点为边缘。
参考
[1]Canny, J., A Computational Approach To Edge Detection, IEEE Trans. Pattern Analysis and Machine Intelligence, 8:679-714, 1986 DOI:10.1109/TPAMI.1986.4767851
[2]William Green’s Canny tutorial https://en.wikipedia.org/wiki/Canny_edge_detector
示例
>>> from skimage import feature >>> rng = np.random.default_rng() >>> # Generate noisy image of a square >>> im = np.zeros((256, 256)) >>> im[64:-64, 64:-64] = 1 >>> im += 0.2 * rng.random(im.shape) >>> # First trial with the Canny filter, with the default smoothing >>> edges1 = feature.canny(im) >>> # Increase the smoothing for better results >>> edges2 = feature.canny(im, sigma=3)
- skimage.feature.corner_fast(image, n=12, threshold=0.15)[source]#
为给定图像提取 FAST 角点。
- 参数：
- image(M, N) ndarray
输入图像。
- nint, optional
圆形上 16 个像素中至少应有 n 个连续像素，这些像素相对于测试像素都应该更亮或更暗。如果 Ic < Ip - threshold，则圆形上的点 c 相对于测试像素 p 更暗，如果 Ic > Ip + threshold，则更亮。它也代表 FAST-n 角点检测器中的 n。
- thresholdfloat, optional
用于决定圆形上的像素是更亮、更暗还是与测试像素相似时使用的阈值。当需要更多角点时，降低阈值，反之亦然。
- 返回：
- responsendarray
FAST 角点响应图像。
参考
[1]Rosten, E., & Drummond, T. (2006, May). Machine learning for high-speed corner detection. In European conference on computer vision (pp. 430-443). Springer, Berlin, Heidelberg. DOI:10.1007/11744023_34 http://www.edwardrosten.com/work/rosten_2006_machine.pdf
[2]Wikipedia, “Features from accelerated segment test”, https://en.wikipedia.org/wiki/Features_from_accelerated_segment_test
示例
>>> from skimage.feature import corner_fast, corner_peaks >>> square = np.zeros((12, 12)) >>> square[3:9, 3:9] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> corner_peaks(corner_fast(square, 9), min_distance=1) array([[3, 3], [3, 8], [8, 3], [8, 8]])
- skimage.feature.corner_foerstner(image, sigma=1)[source]#
计算 Foerstner 角点测度响应图像。
此角点检测器使用来自自相关矩阵 A 的信息
A = [(imx**2) (imx*imy)] = [Axx Axy] [(imx*imy) (imy**2)] [Axy Ayy]
其中 imx 和 imy 是用高斯滤波器平均的一阶导数。然后，角点度量定义为
w = det(A) / trace(A) (size of error ellipse) q = 4 * det(A) / trace(A)**2 (roundness of error ellipse)
- 参数：
- image(M, N) ndarray
输入图像。
- sigmafloat, optional
用于高斯核的标准差，该高斯核用作自相关矩阵的加权函数。
- 返回：
- wndarray
误差椭圆大小。
- qndarray
误差椭圆的圆度。
参考
[1]Förstner, W., & Gülch, E. (1987, June). A fast operator for detection and precise location of distinct points, corners and centres of circular features. In Proc. ISPRS intercommission conference on fast processing of photogrammetric data (pp. 281-305). https://cseweb.ucsd.edu/classes/sp02/cse252/foerstner/foerstner.pdf
示例
>>> from skimage.feature import corner_foerstner, corner_peaks >>> square = np.zeros([10, 10]) >>> square[2:8, 2:8] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> w, q = corner_foerstner(square) >>> accuracy_thresh = 0.5 >>> roundness_thresh = 0.3 >>> foerstner = (q > roundness_thresh) * (w > accuracy_thresh) * w >>> corner_peaks(foerstner, min_distance=1) array([[2, 2], [2, 7], [7, 2], [7, 7]])
- skimage.feature.corner_harris(image, method='k', k=0.05, eps=1e-06, sigma=1)[source]#
计算 Harris 角点测度响应图像。
此角点检测器使用来自自相关矩阵 A 的信息
A = [(imx**2) (imx*imy)] = [Axx Axy] [(imx*imy) (imy**2)] [Axy Ayy]
其中 imx 和 imy 是用高斯滤波器平均的一阶导数。然后，角点度量定义为
det(A) - k * trace(A)**2
或
2 * det(A) / (trace(A) + eps)
- 参数：
- image(M, N) ndarray
输入图像。
- method{‘k’, ‘eps’}, optional
从自相关矩阵计算响应图像的方法。
- kfloat, optional
用于将角点与边缘区分开的敏感度因子，通常在范围 [0, 0.2] 内。k 的小值会导致锐角的检测。
- epsfloat, optional
归一化因子（诺贝尔角点度量）。
- sigmafloat, optional
用于高斯核的标准差，该高斯核用作自相关矩阵的加权函数。
- 返回：
- responsendarray
Harris 响应图像。
参考
示例
>>> from skimage.feature import corner_harris, corner_peaks >>> square = np.zeros([10, 10]) >>> square[2:8, 2:8] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> corner_peaks(corner_harris(square), min_distance=1) array([[2, 2], [2, 7], [7, 2], [7, 7]])
- skimage.feature.corner_kitchen_rosenfeld(image, mode='constant', cval=0)[source]#
计算 Kitchen 和 Rosenfeld 角点测度响应图像。
角点度量计算如下
(imxx * imy**2 + imyy * imx**2 - 2 * imxy * imx * imy) / (imx**2 + imy**2)
其中 imx 和 imy 是第一阶导数，imxx、imxy 和 imyy 是二阶导数。
- 参数：
- image(M, N) ndarray
输入图像。
- mode{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional
如何处理图像边界之外的值。
- cvalfloat, optional
与模式 ‘constant’ 结合使用时，图像边界之外的值。
- 返回：
- responsendarray
Kitchen 和 Rosenfeld 响应图像。
参考
[1]Kitchen, L., & Rosenfeld, A. (1982). Gray-level corner detection. Pattern recognition letters, 1(2), 95-102. DOI:10.1016/0167-8655(82)90020-4
- skimage.feature.corner_moravec(image, window_size=1)[source]#
计算 Moravec 角点测度响应图像。
这是最简单的角点检测器之一，速度相对较快，但有一些局限性（例如，不是旋转不变的）。
- 参数：
- image(M, N) ndarray
输入图像。
- window_sizeint, optional
窗口大小。
- 返回：
- responsendarray
Moravec 响应图像。
参考
示例
>>> from skimage.feature import corner_moravec >>> square = np.zeros([7, 7]) >>> square[3, 3] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> corner_moravec(square).astype(int) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 2, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]])
- skimage.feature.corner_orientations(image, corners, mask)[source]#
计算角点的方向。
角点的方向使用一阶中心矩计算，即质心方法。角点方向是从角点坐标到角点周围局部邻域中使用一阶中心矩计算的强度质心的向量的角度。
- 参数：
- image(M, N) array
输入灰度图像。
- corners(K, 2) array
角点坐标为
(row, col)。- mask2D array
定义用于计算中心矩的角点局部邻域的掩码。
- 返回：
- orientations(K, 1) array
角点方向，范围为 [-pi, pi]。
参考
[1]Ethan Rublee, Vincent Rabaud, Kurt Konolige 和 Gary Bradski “ORB : An efficient alternative to SIFT and SURF” http://www.vision.cs.chubu.ac.jp/CV-R/pdf/Rublee_iccv2011.pdf
[2]Paul L. Rosin, “Measuring Corner Properties” http://users.cs.cf.ac.uk/Paul.Rosin/corner2.pdf
示例
>>> from skimage.morphology import octagon >>> from skimage.feature import (corner_fast, corner_peaks, ... corner_orientations) >>> square = np.zeros((12, 12)) >>> square[3:9, 3:9] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> corners = corner_peaks(corner_fast(square, 9), min_distance=1) >>> corners array([[3, 3], [3, 8], [8, 3], [8, 8]]) >>> orientations = corner_orientations(square, corners, octagon(3, 2)) >>> np.rad2deg(orientations) array([ 45., 135., -45., -135.])
- skimage.feature.corner_peaks(image, min_distance=1, threshold_abs=None, threshold_rel=None, exclude_border=True, indices=True, num_peaks=inf, footprint=None, labels=None, *, num_peaks_per_label=inf, p_norm=inf)[source]#
在角点测度响应图像中查找峰值。
这与
skimage.feature.peak_local_max不同，因为它会抑制具有相同累加器值的多个连接的峰值。- 参数：
- image(M, N) ndarray
输入图像。
- min_distanceint, optional
允许的最小峰值分离距离。
- **
- p_normfloat
要使用的闵可夫斯基 p 范数。应该在 [1, inf] 范围内。如果可能发生溢出，有限的较大 p 可能会导致 ValueError。
inf对应于切比雪夫距离，2 对应于欧几里得距离。
- 返回：
- outputndarray 或 ndarray of bools
如果 indices = True : 峰值的 (行，列，...) 坐标。
如果 indices = False : 形状与 image 相同的布尔数组，峰值用 True 值表示。
备注
Changed in version 0.18: threshold_rel 的默认值已更改为 None，这对应于让
skimage.feature.peak_local_max决定默认值。这等效于 threshold_rel=0。num_peaks 限制在抑制连接峰值之前应用。要限制抑制后峰值的数量，请将 num_peaks=np.inf 并对该函数的输出进行后处理。
示例
>>> from skimage.feature import peak_local_max >>> response = np.zeros((5, 5)) >>> response[2:4, 2:4] = 1 >>> response array([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 1., 1., 0.], [0., 0., 1., 1., 0.], [0., 0., 0., 0., 0.]]) >>> peak_local_max(response) array([[2, 2], [2, 3], [3, 2], [3, 3]]) >>> corner_peaks(response) array([[2, 2]])
- skimage.feature.corner_shi_tomasi(image, sigma=1)[source]#
计算 Shi-Tomasi（Kanade-Tomasi）角点测度响应图像。
此角点检测器使用来自自相关矩阵 A 的信息
A = [(imx**2) (imx*imy)] = [Axx Axy] [(imx*imy) (imy**2)] [Axy Ayy]
其中 imx 和 imy 是用高斯滤波器平均的一阶导数。然后，角点度量定义为 A 的较小特征值
((Axx + Ayy) - sqrt((Axx - Ayy)**2 + 4 * Axy**2)) / 2
- 参数：
- image(M, N) ndarray
输入图像。
- sigmafloat, optional
用于高斯核的标准差，该高斯核用作自相关矩阵的加权函数。
- 返回：
- responsendarray
Shi-Tomasi 响应图像。
参考
示例
>>> from skimage.feature import corner_shi_tomasi, corner_peaks >>> square = np.zeros([10, 10]) >>> square[2:8, 2:8] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> corner_peaks(corner_shi_tomasi(square), min_distance=1) array([[2, 2], [2, 7], [7, 2], [7, 7]])
- skimage.feature.corner_subpix(image, corners, window_size=11, alpha=0.99)[source]#
确定角点的亚像素位置。
一个统计检验决定角点是定义为两条边的交点还是单个峰值。根据分类结果，亚像素角点位置是根据灰度值的局部协方差确定的。如果任一统计检验的显著性水平不足，则角点无法分类，输出亚像素位置设置为 NaN。
- 参数：
- image(M, N) ndarray
输入图像。
- corners(K, 2) ndarray
角点坐标 (row, col)。
- window_sizeint, optional
用于亚像素估计的搜索窗口大小。
- alphafloat, optional
角点分类的显著性水平。
- 返回：
- positions(K, 2) ndarray
亚像素角点位置。NaN 表示“未分类”角点。
参考
[1]Förstner, W., & Gülch, E. (1987, June). A fast operator for detection and precise location of distinct points, corners and centres of circular features. In Proc. ISPRS intercommission conference on fast processing of photogrammetric data (pp. 281-305). https://cseweb.ucsd.edu/classes/sp02/cse252/foerstner/foerstner.pdf
示例
>>> from skimage.feature import corner_harris, corner_peaks, corner_subpix >>> img = np.zeros((10, 10)) >>> img[:5, :5] = 1 >>> img[5:, 5:] = 1 >>> img.astype(int) array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]) >>> coords = corner_peaks(corner_harris(img), min_distance=2) >>> coords_subpix = corner_subpix(img, coords, window_size=7) >>> coords_subpix array([[4.5, 4.5]])
- skimage.feature.daisy(image, step=4, radius=15, rings=3, histograms=8, orientations=8, normalization='l1', sigmas=None, ring_radii=None, visualize=False)[source]#
为给定图像密集地提取 DAISY 特征描述符。
DAISY 是一种类似于 SIFT 的特征描述符，以允许快速密集提取的方式制定。通常，这对于 bag-of-features 图像表示非常实用。
该实现遵循 Tola 等人的方法 [1]，但在以下几点上有所不同
直方图 bin 贡献通过圆形高斯窗口在色调范围（角度范围）上进行平滑。
此代码中的空间高斯平滑的 sigma 值与 Tola 等人 [2] 中的原始代码中的 sigma 值不匹配。在他们的代码中，空间平滑应用于输入图像和中心直方图。但是，此平滑在 [1] 中没有记录，因此被省略了。
- 参数：
- image(M, N) array
输入图像（灰度）。
- stepint，可选
描述符采样点之间的距离。
- radiusint，可选
最外环的半径（以像素为单位）。
- ringsint，可选
环数。
- histogramsint，可选
每个环采样的直方图数。
- orientationsint，可选
每个直方图的方向数（bin 数）。
- normalization[‘l1’ | ‘l2’ | ‘daisy’ | ‘off’]，可选
如何规范化描述符
‘l1’：每个描述符的 L1 规范化。
‘l2’：每个描述符的 L2 规范化。
‘daisy’：单个直方图的 L2 规范化。
‘off’：禁用规范化。
- sigmas1D float 数组，可选
中心直方图和每个直方图环的空间高斯平滑的标准差。sigma 数组应从中心向外排序。即，第一个 sigma 值定义中心直方图的空间平滑，最后一个 sigma 值定义最外环的空间平滑。指定 sigmas 将覆盖以下参数。
rings = len(sigmas) - 1- ring_radii1D int 数组，可选
每个环的半径（以像素为单位）。指定 ring_radii 将覆盖以下两个参数。
rings = len(ring_radii)radius = ring_radii[-1]如果同时给出 sigmas 和 ring_radii，则它们必须满足以下谓词，因为中心直方图不需要半径。
len(ring_radii) == len(sigmas) + 1- visualize布尔值，可选
生成 DAISY 描述符的可视化。
- 返回：
- descs数组
给定图像的 DAISY 描述符网格，作为维度 (P, Q, R) 的数组，其中
P = ceil((M - radius*2) / step)Q = ceil((N - radius*2) / step)R = (rings * histograms + 1) * orientations- descs_img(M, N, 3) 数组（仅当 visualize==True 时）
DAISY 描述符的可视化。
参考
- skimage.feature.draw_haar_like_feature(image, r, c, width, height, feature_coord, color_positive_block=(1.0, 0.0, 0.0), color_negative_block=(0.0, 1.0, 0.0), alpha=0.5, max_n_features=None, rng=None)[source]#
Haar-like 特征的可视化。
- 参数：
- image(M, N) ndarray
需要计算特征的积分图像区域。
- rint
检测窗口左上角的行列坐标。
- cint
检测窗口左上角的列坐标。
- widthint
检测窗口的宽度。
- heightint
检测窗口的高度。
- feature_coord元组列表的 ndarray 或 None，可选
要提取的坐标数组。当您只想重新计算特征子集时，这很有用。在这种情况下，feature_type 需要是一个包含每个特征类型的数组，由
haar_like_feature_coord()返回。默认情况下，计算所有坐标。- color_positive_block3 个浮点数的元组
指定正块颜色的浮点数。相应的值定义 (R, G, B) 值。默认值为红色 (1, 0, 0)。
- color_negative_block3 个浮点数的元组
指定负块颜色的浮点数。相应的值定义 (R, G, B) 值。默认值为蓝色 (0, 1, 0)。
- alpha浮点数
介于 [0, 1] 范围内的值，指定可视化的不透明度。1 - 完全透明，0 - 不透明。
- max_n_featuresint，默认值为 None
要返回的特征的最大数量。默认情况下，返回所有特征。
- rng{
numpy.random.Generator, int}，可选 伪随机数生成器。默认情况下，使用 PCG64 生成器（参见
numpy.random.default_rng()）。如果 rng 是一个整数，则它用于为生成器设置种子。当生成一组小于可用特征总数的特征时，会使用 rng。
- 返回：
- features(M, N), ndarray
将添加不同特征的图像。
示例
>>> import numpy as np >>> from skimage.feature import haar_like_feature_coord >>> from skimage.feature import draw_haar_like_feature >>> feature_coord, _ = haar_like_feature_coord(2, 2, 'type-4') >>> image = draw_haar_like_feature(np.zeros((2, 2)), ... 0, 0, 2, 2, ... feature_coord, ... max_n_features=1) >>> image array([[[0. , 0.5, 0. ], [0.5, 0. , 0. ]], [[0.5, 0. , 0. ], [0. , 0.5, 0. ]]])
- skimage.feature.draw_multiblock_lbp(image, r, c, width, height, lbp_code=0, color_greater_block=(1, 1, 1), color_less_block=(0, 0.69, 0.96), alpha=0.5)[source]#
多块局部二进制模式可视化。
具有较高总和的块将以 alpha 混合的白色矩形着色，而具有较低总和的块将以 alpha 混合的青色着色。颜色和 alpha 参数可以更改。
- 参数：
- imagefloat 或 uint 的 ndarray
要显示模式的图像。
- rint
包含特征的矩形的左上角的行坐标。
- cint
包含特征的矩形的左上角的列坐标。
- widthint
将用于计算特征的 9 个相等矩形之一的宽度。
- heightint
将用于计算特征的 9 个相等矩形之一的高度。
- lbp_codeint
要显示的特征描述符。如果没有提供，将使用值为 0 的描述符。
- color_greater_block3 个浮点数的元组
指定具有较高强度值的块的颜色的浮点数。它们应在 [0, 1] 范围内。相应的值定义 (R, G, B) 值。默认值为白色 (1, 1, 1)。
- color_greater_block3 个浮点数的元组
指定具有较高强度值的块的颜色的浮点数。它们应在 [0, 1] 范围内。相应的值定义 (R, G, B) 值。默认值为青色 (0, 0.69, 0.96)。
- alpha浮点数
介于 [0, 1] 范围内的值，指定可视化的不透明度。1 - 完全透明，0 - 不透明。
- 返回：
- outputfloat 的 ndarray
具有 MB-LBP 可视化的图像。
参考
[1]L. 张，R. 楚，S. 向，S. 廖，S.Z. 李。“基于多块 LBP 表示的人脸检测”，生物识别进展国际会议论文集，ICB 2007，韩国首尔。 http://www.cbsr.ia.ac.cn/users/scliao/papers/Zhang-ICB07-MBLBP.pdf DOI:10.1007/978-3-540-74549-5_2
- skimage.feature.fisher_vector(descriptors, gmm, *, improved=False, alpha=0.5)[source]#
给定一些描述符/向量和关联的估计 GMM，计算 Fisher 向量。
- 参数：
- descriptorsnp.ndarray, shape=(n_descriptors, descriptor_length)
要计算 Fisher 向量表示的描述符的 NumPy 数组。
- gmm
sklearn.mixture.GaussianMixture 一个估计的 GMM 对象，其中包含计算 Fisher 向量所需的必要参数。
- improvedbool, default=False
标志表示是否计算改进的 Fisher 向量。改进的 Fisher 向量是 L2 和功率归一化的。功率归一化只是 f(z) = sign(z) pow(abs(z), alpha) 对于某个 0 <= alpha <= 1。
- alphafloat, default=0.5
功率归一化步骤的参数。如果 improved=False，则忽略。
- 返回：
- fisher_vectornp.ndarray
计算的 Fisher 向量，它由 GMM 关于其参数（混合权重、均值和协方差矩阵）的梯度的串联给出。对于 D 维输入描述符或向量，以及 K 模 GMM，Fisher 向量的维数将为 2KD + K。因此，它的维数与描述符/向量的数量无关。
参考
[1]Perronnin, F. 和 Dance, C. 用于图像分类的视觉词汇上的 Fisher 内核，IEEE 计算机视觉与模式识别会议，2007
[2]Perronnin, F. 和 Sanchez, J. 以及 Mensink T. 改善 Fisher 内核用于大规模图像分类，ECCV，2010
示例
>>> from skimage.feature import fisher_vector, learn_gmm >>> sift_for_images = [np.random.random((10, 128)) for _ in range(10)] >>> num_modes = 16 >>> # Estimate 16-mode GMM with these synthetic SIFT vectors >>> gmm = learn_gmm(sift_for_images, n_modes=num_modes) >>> test_image_descriptors = np.random.random((25, 128)) >>> # Compute the Fisher vector >>> fv = fisher_vector(test_image_descriptors, gmm)
- skimage.feature.graycomatrix(image, distances, angles, levels=None, symmetric=False, normed=False)[source]#
计算灰度共生矩阵。
灰度共生矩阵是图像中给定偏移量处共生灰度值的直方图。
Changed in version 0.19: greymatrix was renamed to graymatrix in 0.19.
- 参数：
- imagearray_like
整数类型的输入图像。仅支持正值图像。如果类型不是 uint8，则需要设置参数 levels。
- distancesarray_like
像素对距离偏移量的列表。
- anglesarray_like
以弧度表示的像素对角度列表。
- levelsint, optional
输入图像应包含 [0, levels-1] 中的整数，其中 levels 表示计数的灰度级数（对于 8 位图像通常为 256）。此参数对于 16 位图像或更高版本是必需的，通常是图像的最大值。由于输出矩阵至少为 levels x levels，因此最好对输入图像进行分箱，而不是对 levels 使用较大的值。
- symmetricbool, optional
如果为 True，则输出矩阵 P[:, :, d, theta] 是对称的。这是通过忽略值对的顺序来实现的，因此在遇到 (i, j) 时，(i, j) 和 (j, i) 都被累积，以用于给定的偏移量。默认值为 False。
- normedbool, optional
如果为 True，则通过除以给定偏移量的累积共生总数来归一化每个矩阵 P[:, :, d, theta]。结果矩阵的元素总和为 1。默认值为 False。
- 返回：
- P4-D ndarray
灰度共生直方图。值 P[i,j,d,theta] 是灰度级 j 在距离 d 处且与灰度级 i 相对于角度 theta 出现的次数。如果 normed 为 False，则输出类型为 uint32，否则为 float64。尺寸为：levels x levels x 距离数 x 角度数。
参考
[1]M. Hall-Beyer，2007。GLCM 纹理：教程 https://prism.ucalgary.ca/handle/1880/51900 DOI:10.11575/PRISM/33280
[2]R.M. Haralick, K. Shanmugam 和 I. Dinstein，“用于图像分类的纹理特征”，IEEE 系统、人机与控制论汇刊，第 SMC-3 卷，第 6 期，第 610-621 页，1973 年 11 月。 DOI:10.1109/TSMC.1973.4309314
[3]M. Nadler 和 E.P. Smith，模式识别工程，Wiley-Interscience，1993。
示例
计算 2 个 GLCM：一个用于向右偏移 1 像素，另一个用于向上偏移 1 像素。
>>> image = np.array([[0, 0, 1, 1], ... [0, 0, 1, 1], ... [0, 2, 2, 2], ... [2, 2, 3, 3]], dtype=np.uint8) >>> result = graycomatrix(image, [1], [0, np.pi/4, np.pi/2, 3*np.pi/4], ... levels=4) >>> result[:, :, 0, 0] array([[2, 2, 1, 0], [0, 2, 0, 0], [0, 0, 3, 1], [0, 0, 0, 1]], dtype=uint32) >>> result[:, :, 0, 1] array([[1, 1, 3, 0], [0, 1, 1, 0], [0, 0, 0, 2], [0, 0, 0, 0]], dtype=uint32) >>> result[:, :, 0, 2] array([[3, 0, 2, 0], [0, 2, 2, 0], [0, 0, 1, 2], [0, 0, 0, 0]], dtype=uint32) >>> result[:, :, 0, 3] array([[2, 0, 0, 0], [1, 1, 2, 0], [0, 0, 2, 1], [0, 0, 0, 0]], dtype=uint32)
- skimage.feature.graycoprops(P, prop='contrast')[source]#
计算 GLCM 的纹理属性。
计算灰度共生矩阵的特征，以作为矩阵的紧凑摘要。属性按如下方式计算
‘contrast’: \(\sum_{i,j=0}^{levels-1} P_{i,j}(i-j)^2\)
‘dissimilarity’: \(\sum_{i,j=0}^{levels-1}P_{i,j}|i-j|\)
‘homogeneity’: \(\sum_{i,j=0}^{levels-1}\frac{P_{i,j}}{1+(i-j)^2}\)
‘ASM’: \(\sum_{i,j=0}^{levels-1} P_{i,j}^2\)
‘energy’: \(\sqrt{ASM}\)
- ‘correlation’
- \[\sum_{i,j=0}^{levels-1} P_{i,j}\left[\frac{(i-\mu_i) \ (j-\mu_j)}{\sqrt{(\sigma_i^2)(\sigma_j^2)}}\right]\]
在计算纹理属性之前，每个 GLCM 都被归一化为总和为 1。
Changed in version 0.19: greycoprops was renamed to
graycopropsin 0.19.- 参数：
- Pndarray
输入数组。 P 是要计算指定属性的灰度共生直方图。值 P[i,j,d,theta] 是灰度级 j 在距离 d 处且与灰度级 i 相对于角度 theta 出现的次数。
- prop{‘contrast’, ‘dissimilarity’, ‘homogeneity’, ‘energy’, ‘correlation’, ‘ASM’}, optional
要计算的 GLCM 的属性。默认值为“contrast”。
- 返回：
- results2-D ndarray
二维数组。 results[d, a] 是第 d 个距离和第 a 个角度的属性“prop”。
参考
[1]M. Hall-Beyer，2007。GLCM 纹理：教程 v. 1.0 到 3.0。GLCM 教程主页，https://prism.ucalgary.ca/handle/1880/51900 DOI:10.11575/PRISM/33280
示例
计算具有距离 [1, 2] 和角度 [0 度，90 度] 的 GLCM 的对比度
>>> image = np.array([[0, 0, 1, 1], ... [0, 0, 1, 1], ... [0, 2, 2, 2], ... [2, 2, 3, 3]], dtype=np.uint8) >>> g = graycomatrix(image, [1, 2], [0, np.pi/2], levels=4, ... normed=True, symmetric=True) >>> contrast = graycoprops(g, 'contrast') >>> contrast array([[0.58333333, 1. ], [1.25 , 2.75 ]])
- skimage.feature.haar_like_feature(int_image, r, c, width, height, feature_type=None, feature_coord=None)[source]#
为积分图像的感兴趣区域 (ROI) 计算 Haar-like 特征。
Haar 类特征已成功用于图像分类和目标检测 [1]。它已被用于 [2] 中提出的实时人脸检测算法。
- 参数：
- int_image(M, N) ndarray
需要计算特征的积分图像。
- rint
检测窗口左上角的行列坐标。
- cint
检测窗口左上角的列坐标。
- widthint
检测窗口的宽度。
- heightint
检测窗口的高度。
- feature_typestr or list of str or None, optional
要考虑的特征类型
‘type-2-x’: 沿 x 轴变化的 2 个矩形；
‘type-2-y’: 沿 y 轴变化的 2 个矩形；
‘type-3-x’: 沿 x 轴变化的 3 个矩形；
‘type-3-y’: 沿 y 轴变化的 3 个矩形；
‘type-4’: 沿 x 和 y 轴变化的 4 个矩形。
默认情况下提取所有特征。
如果与 feature_coord 一起使用，则它应对应于每个关联坐标特征的特征类型。
- feature_coord元组列表的 ndarray 或 None，可选
要提取的坐标数组。当您只想重新计算特征子集时，这很有用。在这种情况下，feature_type 需要是一个包含每个特征类型的数组，由
haar_like_feature_coord()返回。默认情况下，计算所有坐标。
- 返回：
- haar_features(n_features,) ndarray of int or float
结果 Haar 类特征。每个值都等于正矩形和负矩形的总和之差。数据类型取决于 int_image 的数据类型：当 int_image 的数据类型为 uint 或 int 时为 int，而当 int_image 的数据类型为 float 时为 float。
备注
当并行提取这些特征时，请注意后端的选择（例如多进程与多线程）会影响性能。经验法则是：在为图像中所有可能的 ROI 提取特征时使用多进程；在为有限数量的 ROI 提取特定位置的特征时使用多线程。有关更多见解，请参阅示例 使用 Haar 特征描述符的人脸分类。
参考
[2]Oren, M., Papageorgiou, C., Sinha, P., Osuna, E., & Poggio, T. (1997, June). Pedestrian detection using wavelet templates. In Computer Vision and Pattern Recognition, 1997. Proceedings., 1997 IEEE Computer Society Conference on (pp. 193-199). IEEE. http://tinyurl.com/y6ulxfta DOI:10.1109/CVPR.1997.609319
[3]Viola, Paul, and Michael J. Jones. “Robust real-time face detection.” International journal of computer vision 57.2 (2004): 137-154. https://www.merl.com/publications/docs/TR2004-043.pdf DOI:10.1109/CVPR.2001.990517
示例
>>> import numpy as np >>> from skimage.transform import integral_image >>> from skimage.feature import haar_like_feature >>> img = np.ones((5, 5), dtype=np.uint8) >>> img_ii = integral_image(img) >>> feature = haar_like_feature(img_ii, 0, 0, 5, 5, 'type-3-x') >>> feature array([-1, -2, -3, -4, -5, -1, -2, -3, -4, -5, -1, -2, -3, -4, -5, -1, -2, -3, -4, -1, -2, -3, -4, -1, -2, -3, -4, -1, -2, -3, -1, -2, -3, -1, -2, -3, -1, -2, -1, -2, -1, -2, -1, -1, -1])
您可以为一些预先计算的坐标计算特征。
>>> from skimage.feature import haar_like_feature_coord >>> feature_coord, feature_type = zip( ... *[haar_like_feature_coord(5, 5, feat_t) ... for feat_t in ('type-2-x', 'type-3-x')]) >>> # only select one feature over two >>> feature_coord = np.concatenate([x[::2] for x in feature_coord]) >>> feature_type = np.concatenate([x[::2] for x in feature_type]) >>> feature = haar_like_feature(img_ii, 0, 0, 5, 5, ... feature_type=feature_type, ... feature_coord=feature_coord) >>> feature array([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -3, -5, -2, -4, -1, -3, -5, -2, -4, -2, -4, -2, -4, -2, -1, -3, -2, -1, -1, -1, -1, -1])
- skimage.feature.haar_like_feature_coord(width, height, feature_type=None)[source]#
计算 Haar-like 特征的坐标。
- 参数：
- widthint
检测窗口的宽度。
- heightint
检测窗口的高度。
- feature_typestr or list of str or None, optional
要考虑的特征类型
‘type-2-x’: 沿 x 轴变化的 2 个矩形；
‘type-2-y’: 沿 y 轴变化的 2 个矩形；
‘type-3-x’: 沿 x 轴变化的 3 个矩形；
‘type-3-y’: 沿 y 轴变化的 3 个矩形；
‘type-4’: 沿 x 和 y 轴变化的 4 个矩形。
默认情况下提取所有特征。
- 返回：
- feature_coord(n_features, n_rectangles, 2, 2), ndarray of list of tuple coord
每个特征的矩形的坐标。
- feature_type(n_features,), ndarray of str
每个特征的对应类型。
示例
>>> import numpy as np >>> from skimage.transform import integral_image >>> from skimage.feature import haar_like_feature_coord >>> feat_coord, feat_type = haar_like_feature_coord(2, 2, 'type-4') >>> feat_coord array([ list([[(0, 0), (0, 0)], [(0, 1), (0, 1)], [(1, 1), (1, 1)], [(1, 0), (1, 0)]])], dtype=object) >>> feat_type array(['type-4'], dtype=object)
- skimage.feature.hessian_matrix(image, sigma=1, mode='constant', cval=0, order='rc', use_gaussian_derivatives=None)[source]#
计算 Hessian 矩阵。
在二维中，Hessian 矩阵定义为
H = [Hrr Hrc] [Hrc Hcc]
它通过用高斯核的二阶导数在相应的 r 和 c 方向上对图像进行卷积来计算。
此处的实现也支持 n 维数据。
- 参数：
- imagendarray
输入图像。
- sigmafloat
用于高斯核的标准差，该高斯核用作自相关矩阵的加权函数。
- mode{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional
如何处理图像边界之外的值。
- cvalfloat, optional
与模式 ‘constant’ 结合使用时，图像边界之外的值。
- order{‘rc’, ‘xy’}, optional
对于二维图像，此参数允许在梯度计算中使用图像轴的逆序或正序。‘rc’ 表示最初使用第一个轴（Hrr、Hrc、Hcc），而 ‘xy’ 表示最初使用最后一个轴（Hxx、Hxy、Hyy）。维度更高的图像必须始终使用 ‘rc’ 顺序。
- use_gaussian_derivativesboolean, optional
指示 Hessian 是通过用高斯导数进行卷积计算，还是通过简单的有限差分运算计算。
- 返回：
- H_elemslist of ndarray
输入图像中每个像素的 Hessian 矩阵的上对角线元素。在二维中，这将是一个包含三个元素的列表，其中包含 [Hrr、Hrc、Hcc]。在 nD 中，列表将包含
(n**2 + n) / 2个数组。
备注
导数和卷积的分配性质允许我们将用高斯核 G 平滑的图像 I 的导数重新表述为图像与 G 的导数的卷积。
\[\frac{\partial }{\partial x_i}(I * G) = I * \left( \frac{\partial }{\partial x_i} G \right)\]当
use_gaussian_derivatives为True时，此属性用于计算构成 Hessian 矩阵的二阶导数。当
use_gaussian_derivatives为False时，使用对经过高斯平滑的图像的简单有限差分。示例
>>> from skimage.feature import hessian_matrix >>> square = np.zeros((5, 5)) >>> square[2, 2] = 4 >>> Hrr, Hrc, Hcc = hessian_matrix(square, sigma=0.1, order='rc', ... use_gaussian_derivatives=False) >>> Hrc array([[ 0., 0., 0., 0., 0.], [ 0., 1., 0., -1., 0.], [ 0., 0., 0., 0., 0.], [ 0., -1., 0., 1., 0.], [ 0., 0., 0., 0., 0.]])
- skimage.feature.hessian_matrix_det(image, sigma=1, approximate=True)[source]#
计算图像上的近似 Hessian 行列式。
二维近似方法使用积分图像上的框滤波器来计算近似 Hessian 行列式。
- 参数：
- imagendarray
要计算 Hessian 行列式的图像。
- sigmafloat, optional
用于 Hessian 矩阵的高斯核的标准差。
- approximatebool, optional
如果
True且图像为二维，则使用速度更快的近似计算。此参数对 3D 和更高维度的图像没有影响。
- 返回：
- outarray
Hessian 行列式的数组。
备注
对于二维图像，当
approximate=True时，此方法的运行时间仅取决于图像的大小。它与预期一样，与 sigma 无关。缺点是 sigma 小于 3 的结果不准确，即与有人计算 Hessian 并取其行列式获得的结果不相似。参考
[1]Herbert Bay, Andreas Ess, Tinne Tuytelaars, Luc Van Gool, “SURF: Speeded Up Robust Features” ftp://ftp.vision.ee.ethz.ch/publications/articles/eth_biwi_00517.pdf
- skimage.feature.hessian_matrix_eigvals(H_elems)[source]#
计算 Hessian 矩阵的特征值。
- 参数：
- H_elemslist of ndarray
Hessian 矩阵的上对角线元素，由
hessian_matrix返回。
- 返回：
- eigsndarray
Hessian 矩阵的特征值，按降序排列。特征值是主维度。也就是说，
eigs[i, j, k]包含位置 (j, k) 的第 i 个最大特征值。
示例
>>> from skimage.feature import hessian_matrix, hessian_matrix_eigvals >>> square = np.zeros((5, 5)) >>> square[2, 2] = 4 >>> H_elems = hessian_matrix(square, sigma=0.1, order='rc', ... use_gaussian_derivatives=False) >>> hessian_matrix_eigvals(H_elems)[0] array([[ 0., 0., 2., 0., 0.], [ 0., 1., 0., 1., 0.], [ 2., 0., -2., 0., 2.], [ 0., 1., 0., 1., 0.], [ 0., 0., 2., 0., 0.]])
- skimage.feature.hog(image, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(3, 3), block_norm='L2-Hys', visualize=False, transform_sqrt=False, feature_vector=True, *, channel_axis=None)[source]#
为给定图像提取方向梯度直方图 (HOG)。
通过以下方法计算梯度方向直方图 (HOG)
(可选) 全局图像归一化
在 row 和 col 中计算梯度图像
计算梯度直方图
跨块进行归一化
将数据扁平化为特征向量
- 参数：
- image(M, N[, C]) ndarray
输入图像。
- orientationsint，可选
方向箱的数量。
- pixels_per_cell2-tuple (int, int), optional
单元格的大小（以像素为单位）。
- cells_per_block2-tuple (int, int), optional
每个块中的单元格数量。
- block_normstr {‘L1’, ‘L1-sqrt’, ‘L2’, ‘L2-Hys’}, optional
块归一化方法
- visualize布尔值，可选
还返回 HOG 的图像。对于每个单元格和方向箱，图像包含一条线段，该线段以单元格中心为中心，垂直于方向箱所跨的角度范围的中点，并且强度与相应的直方图值成正比。
- transform_sqrtbool, optional
应用幂律压缩来对图像进行归一化，然后再进行处理。如果图像包含负值，请勿使用此方法。另请参阅下面的 notes 部分。
- feature_vectorbool, optional
在返回之前，通过对结果调用 .ravel() 将数据作为特征向量返回。
- channel_axisint or None, optional
如果为 None，则假定图像为灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
Added in version 0.19: channel_axis was added in 0.19.
- 返回：
- out(n_blocks_row, n_blocks_col, n_cells_row, n_cells_col, n_orient) ndarray
图像的 HOG 描述符。如果 feature_vector 为 True，则返回一维（扁平化）数组。
- hog_image(M, N) ndarray, optional
HOG 图像的可视化。仅在 visualize 为 True 时提供。
- Raises:
- ValueError
如果给定 pixels_per_cell 和 cells_per_block 的值，图像太小。
备注
提供的代码实现了来自[2] 的 HOG 提取方法，并进行了以下更改：（I）使用 (3, 3) 个单元格的块（论文中为 (2, 2)）；（II）在单元格内不进行平滑处理（论文中为具有 sigma=8pix 的高斯空间窗口）；（III）使用 L1 块归一化（论文中为 L2-Hys）。
幂律压缩，也称为伽马校正，用于减少阴影和光照变化的影响。压缩使黑暗区域变亮。当 kwarg transform_sqrt 设置为
True时，该函数计算每个颜色通道的平方根，然后将 hog 算法应用于图像。参考
[2]Dalal, N 和 Triggs, B，用于人脸检测的定向梯度直方图，IEEE 计算机学会计算机视觉与模式识别会议 2005 年圣地亚哥，加利福尼亚州，美国，https://lear.inrialpes.fr/people/triggs/pubs/Dalal-cvpr05.pdf，DOI:10.1109/CVPR.2005.177
[3]Lowe, D.G.，来自尺度不变关键点的独特图像特征，国际计算机视觉杂志 (2004) 60: 91，http://www.cs.ubc.ca/~lowe/papers/ijcv04.pdf，DOI:10.1023/B:VISI.0000029664.99615.94
[4]Dalal, N，在图像和视频中查找人脸，人机交互 [cs.HC]，格勒诺布尔国立理工学院 - INPG，2006 年，https://tel.archives-ouvertes.fr/tel-00390303/file/NavneetDalalThesis.pdf
- skimage.feature.learn_gmm(descriptors, *, n_modes=32, gm_args=None)[source]#
根据一组描述符和模式数量（即高斯分布）估计高斯混合模型 (GMM)。此函数本质上是 scikit-learn GMM 实现的包装器，即
sklearn.mixture.GaussianMixture类。由于 Fisher 向量的性质，底层 scikit-learn 类的唯一强制参数是 covariance_type，它必须为 'diag'。
没有简单的方法来事先知道要为 n_modes 使用什么值。通常，该值通常是
{16, 32, 64, 128}中的一个。可以训练几个 GMM 并选择使 GMM 对数概率最大化的那个，或者选择 n_modes，以便在生成的 Fisher 向量上训练的下游分类器的性能最大化。- 参数：
- descriptorsnp.ndarray (N, M) 或列表 [(N1, M), (N2, M), …]
NumPy 数组列表，或单个 NumPy 数组，用于估计 GMM 的描述符。允许使用 NumPy 数组列表的原因是，通常在使用 Fisher 向量编码时，会为数据集中的每个样本/图像分别计算描述符/向量，例如每个图像的 SIFT 向量。如果传递的是列表，则每个元素必须是一个 NumPy 数组，其中行数可能不同（例如，每个图像的 SIFT 向量数量不同），但每个元素的列数必须相同（即维数必须相同）。
- n_modesint
在 GMM 估计过程中估计的模式/高斯分布的数量。
- gm_argsdict
可以传递到底层 scikit-learn
sklearn.mixture.GaussianMixture类的关键字参数。
- 返回：
- gmm
sklearn.mixture.GaussianMixture 估计的 GMM 对象，其中包含计算 Fisher 向量所需的必要参数。
- gmm
参考
示例
>>> from skimage.feature import fisher_vector >>> rng = np.random.Generator(np.random.PCG64()) >>> sift_for_images = [rng.standard_normal((10, 128)) for _ in range(10)] >>> num_modes = 16 >>> # Estimate 16-mode GMM with these synthetic SIFT vectors >>> gmm = learn_gmm(sift_for_images, n_modes=num_modes)
- skimage.feature.local_binary_pattern(image, P, R, method='default')[source]#
计算图像的局部二进制模式 (LBP)。
LBP 是一种视觉描述符，常用于纹理分类。
- 参数：
- image(M, N) array
2D 灰度图像。
- Pint
圆对称邻域点集的数量（角空间量化）。
- Rfloat
圆的半径（运算符的空间分辨率）。
- methodstr {‘default’, ‘ror’, ‘uniform’, ‘nri_uniform’, ‘var’}, 可选
确定模式的方法
- 返回：
- output(M, N) 数组
LBP 图像。
参考
[1]T. Ojala、M. Pietikainen、T. Maenpaa，“使用局部二值模式的多分辨率灰度和旋转不变纹理分类”，IEEE 模式分析与机器智能汇刊，第 24 卷，第 7 期，第 971-987 页，2002 年 7 月 DOI:10.1109/TPAMI.2002.1017623
[2]T. Ahonen、A. Hadid 和 M. Pietikainen。“使用局部二值模式的人脸识别”，在第八届欧洲计算机视觉会议论文集中，捷克共和国布拉格，2004 年 5 月 11-14 日，第 469-481 页，2004 年。 http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.214.6851 DOI:10.1007/978-3-540-24670-1_36
[3]T. Ahonen、A. Hadid 和 M. Pietikainen，“使用局部二值模式的人脸描述：应用于人脸识别”，IEEE 模式分析与机器智能汇刊，第 28 卷，第 12 期，第 2037-2041 页，2006 年 12 月 DOI:10.1109/TPAMI.2006.244
- skimage.feature.match_descriptors(descriptors1, descriptors2, metric=None, p=2, max_distance=inf, cross_check=True, max_ratio=1.0)[source]#
描述符的暴力匹配。
对于第一组中的每个描述符，此匹配器在第二组中找到最接近的描述符（在启用交叉检查的情况下，反之亦然）。
- 参数：
- descriptors1(M, P) 数组
第一张图像中关于 M 个关键点的 P 个大小的描述符。
- descriptors2(N, P) 数组
第二张图像中关于 N 个关键点的 P 个大小的描述符。
- metric{‘euclidean’, ‘cityblock’, ‘minkowski’, ‘hamming’, …} , 可选
用于计算两个描述符之间距离的指标。有关所有可能的类型，请参见
scipy.spatial.distance.cdist。汉明距离应用于二进制描述符。默认情况下，对于数据类型为 float 或 double 的所有描述符，使用 L2 范数，对于二进制描述符，自动使用汉明距离。- pint, 可选
用于
metric='minkowski'的 p 范数。- max_distancefloat, 可选
两张不同图像的关键点描述符之间允许的最大距离，以视为匹配。
- cross_checkbool, 可选
如果为 True，则在交叉检查后返回匹配的关键点，即仅当关键点 2 是第二张图像中关键点 1 的最佳匹配，而关键点 1 是第一张图像中关键点 2 的最佳匹配时，才会返回匹配对（关键点 1，关键点 2）。
- max_ratiofloat, 可选
第二组描述符中第一和第二最近描述符之间距离的最大比率。此阈值对于过滤两组描述符之间的模糊匹配很有用。此值的选择取决于所选描述符的统计数据，例如，对于 SIFT 描述符，通常选择 0.8 的值，请参见 D.G. Lowe，“来自尺度不变关键点的独特图像特征”，国际计算机视觉杂志，2004 年。
- 返回：
- matches(Q, 2) 数组
第一组和第二组描述符中对应匹配的索引，其中
matches[:, 0]表示第一组描述符中的索引，而matches[:, 1]表示第二组描述符中的索引。
- skimage.feature.match_template(image, template, pad_input=False, mode='constant', constant_values=0)[source]#
使用归一化相关性将模板匹配到 2D 或 3D 图像。
输出是一个值介于 -1.0 和 1.0 之间的数组。给定位置的值对应于图像和模板之间的相关系数。
对于 pad_input=True，匹配对应于模板的中心，否则对应于模板的左上角。要找到最佳匹配，您必须在响应（输出）图像中搜索峰值。
- 参数：
- image(M, N[, P]) 数组
二维或三维输入图像。
- template(m, n[, p]) 数组
要定位的模板。它必须是 (m <= M, n <= N[, p <= P])。
- pad_input布尔值
如果为 True，则填充 image 以使输出与图像大小相同，并且输出值对应于模板中心。否则，输出数组的形状为 (M - m + 1, N - n + 1)，用于 (M, N) 图像和 (m, n) 模板，匹配对应于模板的原点（左上角）。
- mode参见
numpy.pad，可选 填充模式。
- constant_values参见
numpy.pad，可选 与
mode='constant'结合使用的常量值。
- 返回：
- output数组
具有相关系数的响应图像。
备注
有关互相关的详细信息，请参见 [1]。此实现使用图像和模板的 FFT 卷积。参考 [2] 呈现了类似的推导，但本参考中提出的近似值未在我们的实现中使用。
参考
[1]J. P. Lewis， “快速归一化互相关”，工业光魔。
[2]Briechle 和 Hanebeck，“使用快速归一化互相关的模板匹配”，SPIE 会议论文集 (2001)。DOI:10.1117/12.421129
示例
>>> template = np.zeros((3, 3)) >>> template[1, 1] = 1 >>> template array([[0., 0., 0.], [0., 1., 0.], [0., 0., 0.]]) >>> image = np.zeros((6, 6)) >>> image[1, 1] = 1 >>> image[4, 4] = -1 >>> image array([[ 0., 0., 0., 0., 0., 0.], [ 0., 1., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., 0., 0.], [ 0., 0., 0., 0., -1., 0.], [ 0., 0., 0., 0., 0., 0.]]) >>> result = match_template(image, template) >>> np.round(result, 3) array([[ 1. , -0.125, 0. , 0. ], [-0.125, -0.125, 0. , 0. ], [ 0. , 0. , 0.125, 0.125], [ 0. , 0. , 0.125, -1. ]]) >>> result = match_template(image, template, pad_input=True) >>> np.round(result, 3) array([[-0.125, -0.125, -0.125, 0. , 0. , 0. ], [-0.125, 1. , -0.125, 0. , 0. , 0. ], [-0.125, -0.125, -0.125, 0. , 0. , 0. ], [ 0. , 0. , 0. , 0.125, 0.125, 0.125], [ 0. , 0. , 0. , 0.125, -1. , 0.125], [ 0. , 0. , 0. , 0.125, 0.125, 0.125]])
- skimage.feature.multiblock_lbp(int_image, r, c, width, height)[source]#
多块局部二进制模式 (MB-LBP)。
特征的计算方式类似于局部二值模式 (LBP)，（参见
local_binary_pattern()），只是使用求和的块而不是单个像素值。MB-LBP 是 LBP 的扩展，它可以在使用积分图像的恒定时间内在多个尺度上计算。使用九个大小相等的矩形来计算特征。对于每个矩形，计算像素强度的总和。这些总和与中心矩形的总和进行比较以确定特征，类似于 LBP。
- 参数：
- int_image(N, M) 数组
积分图像。
- rint
包含特征的矩形的左上角的行坐标。
- cint
包含特征的矩形的左上角的列坐标。
- widthint
将用于计算特征的 9 个相等矩形之一的宽度。
- heightint
将用于计算特征的 9 个相等矩形之一的高度。
- 返回：
- output整数
8 位 MB-LBP 特征描述符。
参考
[1]L. 张，R. 楚，S. 向，S. 廖，S.Z. 李。“基于多块 LBP 表示的人脸检测”，生物识别进展国际会议论文集，ICB 2007，韩国首尔。 http://www.cbsr.ia.ac.cn/users/scliao/papers/Zhang-ICB07-MBLBP.pdf DOI:10.1007/978-3-540-74549-5_2
- skimage.feature.multiscale_basic_features(image, intensity=True, edges=True, texture=True, sigma_min=0.5, sigma_max=16, num_sigma=None, num_workers=None, *, channel_axis=None)[source]#
单个或多通道 nd 图像的局部特征。
由于高斯模糊，强度、梯度强度和局部结构在不同的尺度上计算。
- 参数：
- imagendarray
输入图像，可以是灰度图像或多通道图像。
- intensity布尔值，默认值为 True
如果为 True，则将不同尺度上平均的像素强度添加到特征集中。
- edges布尔值，默认值为 True
如果为 True，则将不同尺度上平均的局部梯度的强度添加到特征集中。
- texture布尔值，默认值为 True
如果为 True，则将不同尺度上高斯模糊后的 Hessian 矩阵的特征值添加到特征集中。
- sigma_min浮点数，可选
用于在提取特征之前对局部邻域进行平均的高斯核的最小值。
- sigma_max浮点数，可选
用于在提取特征之前对局部邻域进行平均的高斯核的最大值。
- num_sigmaint, optional
sigma_min 和 sigma_max 之间的高斯核值的数量。如果为 None，则使用 sigma_min 乘以 2 的幂。
- num_workers整数或 None，可选
要使用的并行线程数。如果设置为
None，则使用所有可用的核心。- channel_axisint or None, optional
如果为 None，则假定图像为灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
Added in version 0.19:
channel_axiswas added in 0.19.
- 返回：
- featuresnp.ndarray
形状为
image.shape + (n_features,)的数组。当 channel_axis 不为 None 时，所有通道沿特征维度连接。（即n_features == n_features_singlechannel * n_channels）
- skimage.feature.peak_local_max(image, min_distance=1, threshold_abs=None, threshold_rel=None, exclude_border=True, num_peaks=inf, footprint=None, labels=None, num_peaks_per_label=inf, p_norm=inf)[source]#
将图像中的峰值作为坐标列表查找。
峰值是 2 * min_distance + 1 区域内的局部最大值（即峰值至少相隔 min_distance）。
如果同时提供 threshold_abs 和 threshold_rel，则选择两者中较大的值作为峰值的最小强度阈值。
Changed in version 0.18: 在 0.18 版本之前，在 min_distance 半径内的相同高度的峰值都会被返回，但这可能会导致意外行为。从 0.18 版本开始，将在该区域内返回一个任意峰值。参见问题 gh-2592。
- 参数：
- imagendarray
输入图像。
- min_distanceint, optional
分离峰值的最小允许距离。要找到最大数量的峰值，请使用 min_distance=1。
- threshold_abs浮点数或 None，可选
峰值的最小强度。默认情况下，绝对阈值为图像的最小强度。
- threshold_rel浮点数或 None，可选
峰值的最小强度，计算为
max(image) * threshold_rel。- exclude_border整数、整数元组或布尔值，可选
如果为正整数，则 exclude_border 会排除图像边界内 exclude_border 像素范围内的峰值。如果为非负整数的元组，则元组的长度必须与输入数组的维数匹配。元组的每个元素都会排除图像边界内 exclude_border 像素范围内的峰值，沿该维度。如果为 True，则将 min_distance 参数作为值。如果为零或 False，则无论峰值与边界的距离如何，都会识别峰值。
- num_peaks整数，可选
峰值的最大数量。当峰值数量超过 num_peaks 时，返回基于最高峰值强度的 num_peaks 个峰值。
- footprint布尔值数组，可选
如果提供，则 footprint == 1 表示在 image 中的每个点处搜索峰值的局部区域。
- labels整数数组，可选
如果提供，则每个唯一区域 labels == value 表示要搜索峰值的唯一区域。零保留给背景。
- num_peaks_per_label整数，可选
每个标签的峰值最大数量。
- p_normfloat
要使用的闵可夫斯基 p 范数。应该在 [1, inf] 范围内。如果可能发生溢出，有限的较大 p 可能会导致 ValueError。
inf对应于切比雪夫距离，2 对应于欧几里得距离。
- 返回：
- output数组
峰值的坐标。
备注
峰值局部最大值函数返回图像中局部峰值（最大值）的坐标。在内部，使用最大值滤波器来查找局部最大值。此操作会膨胀原始图像。在比较膨胀图像和原始图像之后，该函数将返回峰值的坐标，其中膨胀图像等于原始图像。
示例
>>> img1 = np.zeros((7, 7)) >>> img1[3, 4] = 1 >>> img1[3, 2] = 1.5 >>> img1 array([[0. , 0. , 0. , 0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0. , 0. , 0. , 0. ], [0. , 0. , 1.5, 0. , 1. , 0. , 0. ], [0. , 0. , 0. , 0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0. , 0. , 0. , 0. ]])
>>> peak_local_max(img1, min_distance=1) array([[3, 2], [3, 4]])
>>> peak_local_max(img1, min_distance=2) array([[3, 2]])
>>> img2 = np.zeros((20, 20, 20)) >>> img2[10, 10, 10] = 1 >>> img2[15, 15, 15] = 1 >>> peak_idx = peak_local_max(img2, exclude_border=0) >>> peak_idx array([[10, 10, 10], [15, 15, 15]])
>>> peak_mask = np.zeros_like(img2, dtype=bool) >>> peak_mask[tuple(peak_idx.T)] = True >>> np.argwhere(peak_mask) array([[10, 10, 10], [15, 15, 15]])
- skimage.feature.plot_matches(ax, image1, image2, keypoints1, keypoints2, matches, keypoints_color='k', matches_color=None, only_matches=False, alignment='horizontal')[source]#
已弃用：
plot_matches自版本 0.23 起已弃用，将在版本 0.25 中删除。请改用 skimage.feature.plot_matched_features。绘制匹配的特征。
自版本 0.23 起已弃用。
- 参数：
- axmatplotlib.axes.Axes
匹配和图像将在此轴上绘制。
- image1(N, M [, 3]) 数组
第一个灰度或彩色图像。
- image2(N, M [, 3]) 数组
第二个灰度或彩色图像。
- keypoints1(K1, 2) 数组
第一个关键点坐标，表示为
(row, col)。- keypoints2(K2, 2) 数组
第二个关键点坐标，表示为
(row, col)。- matches(Q, 2) 数组
第一组和第二组描述符中对应匹配的索引，其中
matches[:, 0]表示第一组描述符中的索引，而matches[:, 1]表示第二组描述符中的索引。- keypoints_colormatplotlib 颜色，可选
关键点位置的颜色。
- matches_colormatplotlib 颜色，可选
连接关键点匹配的线的颜色。默认情况下，颜色将随机选择。
- only_matches布尔值，可选
是否只绘制匹配，而不绘制关键点位置。
- alignment{‘horizontal’, ‘vertical’}，可选
是否将图像并排显示，
'horizontal'，或一个在上一个在下，'vertical'。
- skimage.feature.shape_index(image, sigma=1, mode='constant', cval=0)[source]#
计算形状指数。
形状指数，由 Koenderink & van Doorn [1] 定义，是局部曲率的单值度量，假设图像为 3D 平面，其中强度代表高度。
它从 Hessian 的特征值推导而来，其值范围从 -1 到 1（在平坦区域未定义 (=NaN)），以下范围代表以下形状
形状指数的范围及其对应的形状。# 区间 (s in …)
形状
[ -1, -7/8)
球形杯
[-7/8, -5/8)
通过
[-5/8, -3/8)
车辙
[-3/8, -1/8)
鞍形车辙
[-1/8, +1/8)
鞍形
[+1/8, +3/8)
鞍形脊
[+3/8, +5/8)
脊
[+5/8, +7/8)
圆顶
[+7/8, +1]
球形帽
- 参数：
- image(M, N) ndarray
输入图像。
- sigmafloat, optional
用于计算 Hessian 特征值之前平滑输入数据的 Gaussian 核的标准差。
- mode{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional
如何处理图像边界之外的值
- cvalfloat, optional
与模式 ‘constant’ 结合使用时，图像边界之外的值。
- 返回：
- sndarray
形状指数
参考
[1]Koenderink, J. J. & van Doorn, A. J., “Surface shape and curvature scales”, Image and Vision Computing, 1992, 10, 557-564. DOI:10.1016/0262-8856(92)90076-F
示例
>>> from skimage.feature import shape_index >>> square = np.zeros((5, 5)) >>> square[2, 2] = 4 >>> s = shape_index(square, sigma=0.1) >>> s array([[ nan, nan, -0.5, nan, nan], [ nan, -0. , nan, -0. , nan], [-0.5, nan, -1. , nan, -0.5], [ nan, -0. , nan, -0. , nan], [ nan, nan, -0.5, nan, nan]])
- skimage.feature.structure_tensor(image, sigma=1, mode='constant', cval=0, order='rc')[source]#
使用平方差之和计算结构张量。
(二维) 结构张量 A 定义为
A = [Arr Arc] [Arc Acc]
它由图像中每个像素周围局部窗口内平方差的加权和近似。该公式可以扩展到更高维数（参见 [1]）。
- 参数：
- imagendarray
输入图像。
- sigma浮点数或浮点数数组，可选
用于 Gaussian 核的标准差，用作局部平方差求和的加权函数。如果 sigma 是一个可迭代对象，则其长度必须等于 image.ndim，并且每个元素用于沿其各自轴应用的 Gaussian 核。
- mode{‘constant’, ‘reflect’, ‘wrap’, ‘nearest’, ‘mirror’}, optional
如何处理图像边界之外的值。
- cvalfloat, optional
与模式 ‘constant’ 结合使用时，图像边界之外的值。
- order{‘rc’, ‘xy’}, optional
注意：‘xy’ 仅适用于二维图像，更高维图像始终必须使用 ‘rc’ 顺序。此参数允许在梯度计算中使用图像轴的逆序或正序。‘rc’ 表示最初使用第一个轴（Arr、Arc、Acc），而 ‘xy’ 表示最初使用最后一个轴（Axx、Axy、Ayy）。
- 返回：
- A_elemsndarray 列表
输入图像中每个像素的结构张量上对角线元素。
参考
示例
>>> from skimage.feature import structure_tensor >>> square = np.zeros((5, 5)) >>> square[2, 2] = 1 >>> Arr, Arc, Acc = structure_tensor(square, sigma=0.1, order='rc') >>> Acc array([[0., 0., 0., 0., 0.], [0., 1., 0., 1., 0.], [0., 4., 0., 4., 0.], [0., 1., 0., 1., 0.], [0., 0., 0., 0., 0.]])
- skimage.feature.structure_tensor_eigenvalues(A_elems)[source]#
计算结构张量的特征值。
- 参数：
- A_elemsndarray 列表
结构张量的上对角线元素，如
structure_tensor所返回。
- 返回：
- ndarray
结构张量的特征值，按降序排列。特征值是主维度。也就是说，坐标 [i, j, k] 对应于位置 (j, k) 的第 i 个最大特征值。
另请参见
示例
>>> from skimage.feature import structure_tensor >>> from skimage.feature import structure_tensor_eigenvalues >>> square = np.zeros((5, 5)) >>> square[2, 2] = 1 >>> A_elems = structure_tensor(square, sigma=0.1, order='rc') >>> structure_tensor_eigenvalues(A_elems)[0] array([[0., 0., 0., 0., 0.], [0., 2., 4., 2., 0.], [0., 4., 0., 4., 0.], [0., 2., 4., 2., 0.], [0., 0., 0., 0., 0.]])
- class skimage.feature.BRIEF(descriptor_size=256, patch_size=49, mode='normal', sigma=1, rng=1)[source]#
Bases:
DescriptorExtractorBRIEF 二进制描述符提取器。
BRIEF（二进制鲁棒独立基本特征）是一种高效的特征点描述符。即使使用相对较少的位，它也具有很高的辨别力，并且可以使用简单的强度差测试来计算。
对于每个关键点，对特定分布数量 N 的像素对执行强度比较，从而产生长度为 N 的二进制描述符。对于二进制描述符，可以使用汉明距离进行特征匹配，与 L2 范数相比，这会导致更低的计算成本。
- 参数：
- descriptor_size整数，可选
每个关键点的 BRIEF 描述符的大小。作者推荐的大小为 128、256 和 512。默认值为 256。
- patch_size整数，可选
关键点周围二维方形补丁采样区域的长度。默认值为 49。
- mode{‘normal’, ‘uniform’}，可选
关键点周围决策像素对采样位置的概率分布。
- rng{
numpy.random.Generator, int}，可选 伪随机数生成器 (RNG)。默认情况下，使用 PCG64 生成器（参见
numpy.random.default_rng()）。如果 rng 是一个整数，它将用于为生成器设置种子。PRNG 用于决策像素对的随机采样。从长度为 patch_size 的方形窗口中，使用 mode 参数对像素对进行采样，以使用强度比较构建描述符。
为了跨图像匹配，应使用相同的 rng 来构建描述符。为了方便这一点
rng 默认值为 1
extract方法的后续调用将使用相同的 rng/seed。
- sigmafloat, optional
应用于图像的 Gaussian 低通滤波器的标准差，以减轻噪声敏感性，这强烈建议以获得具有辨别力的良好描述符。
示例
>>> from skimage.feature import (corner_harris, corner_peaks, BRIEF, ... match_descriptors) >>> import numpy as np >>> square1 = np.zeros((8, 8), dtype=np.int32) >>> square1[2:6, 2:6] = 1 >>> square1 array([[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]], dtype=int32) >>> square2 = np.zeros((9, 9), dtype=np.int32) >>> square2[2:7, 2:7] = 1 >>> square2 array([[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=int32) >>> keypoints1 = corner_peaks(corner_harris(square1), min_distance=1) >>> keypoints2 = corner_peaks(corner_harris(square2), min_distance=1) >>> extractor = BRIEF(patch_size=5) >>> extractor.extract(square1, keypoints1) >>> descriptors1 = extractor.descriptors >>> extractor.extract(square2, keypoints2) >>> descriptors2 = extractor.descriptors >>> matches = match_descriptors(descriptors1, descriptors2) >>> matches array([[0, 0], [1, 1], [2, 2], [3, 3]]) >>> keypoints1[matches[:, 0]] array([[2, 2], [2, 5], [5, 2], [5, 5]]) >>> keypoints2[matches[:, 1]] array([[2, 2], [2, 6], [6, 2], [6, 6]])
- 属性：
- descriptors(Q, descriptor_size) 类型为 bool 的数组
2D ndarray，包含 Q 个关键点的 descriptor_size 大小的二进制描述符，在过滤掉边界关键点后，边界关键点在索引
(i, j)处的值为True或False，表示对第 i 个关键点在第 j 个决策像素对上的强度比较的结果。它为Q == np.sum(mask)。- mask(N,) 布尔型数组
掩码，指示关键点是否已被过滤掉 (
False) 或在 descriptors 数组中描述 (True)。
- class skimage.feature.CENSURE(min_scale=1, max_scale=7, mode='DoB', non_max_threshold=0.15, line_threshold=10)[source]#
继承自：
FeatureDetectorCENSURE 关键点检测器。
- min_scaleint，可选
提取关键点的最小尺度。
- max_scaleint，可选
提取关键点的最大尺度。关键点将从所有尺度中提取，除了第一个和最后一个，即从范围为 [min_scale + 1, max_scale - 1] 的尺度中提取。不同尺度的滤波器大小使得两个相邻尺度构成一个八度。
- mode{‘DoB’, ‘Octagon’, ‘STAR’}，可选
用于获取输入图像尺度的双层滤波器类型。可能的值为 'DoB'、'Octagon' 和 'STAR'。这三种模式分别代表双层滤波器的形状，即方框（正方形）、八边形和星形。例如，一个双层八边形滤波器由一个较小的内八边形和一个较大的外八边形组成，滤波器权重在内八边形中均匀为负值，而在差异区域中均匀为正值。使用 STAR 和 Octagon 可以获得更好的特征，而 DoB 可以获得更好的性能。
- non_max_thresholdfloat，可选
阈值，用于抑制非最大值抑制后获得的具有较弱幅度响应的极大值和极小值。
- line_thresholdfloat，可选
用于拒绝主曲率比大于此值的兴趣点的阈值。
参考
[1]Motilal Agrawal, Kurt Konolige and Morten Rufus Blas “CENSURE: Center Surround Extremas for Realtime Feature Detection and Matching”, https://link.springer.com/chapter/10.1007/978-3-540-88693-8_8 DOI:10.1007/978-3-540-88693-8_8
[2]Adam Schmidt, Marek Kraft, Michal Fularz and Zuzanna Domagala “Comparative Assessment of Point Feature Detectors and Descriptors in the Context of Robot Navigation” http://yadda.icm.edu.pl/yadda/element/bwmeta1.element.baztech-268aaf28-0faf-4872-a4df-7e2e61cb364c/c/Schmidt_comparative.pdf DOI:10.1.1.465.1117
示例
>>> from skimage.data import astronaut >>> from skimage.color import rgb2gray >>> from skimage.feature import CENSURE >>> img = rgb2gray(astronaut()[100:300, 100:300]) >>> censure = CENSURE() >>> censure.detect(img) >>> censure.keypoints array([[ 4, 148], [ 12, 73], [ 21, 176], [ 91, 22], [ 93, 56], [ 94, 22], [ 95, 54], [100, 51], [103, 51], [106, 67], [108, 15], [117, 20], [122, 60], [125, 37], [129, 37], [133, 76], [145, 44], [146, 94], [150, 114], [153, 33], [154, 156], [155, 151], [184, 63]]) >>> censure.scales array([2, 6, 6, 2, 4, 3, 2, 3, 2, 6, 3, 2, 2, 3, 2, 2, 2, 3, 2, 2, 4, 2, 2])
- 属性：
- keypoints(N, 2) 数组
关键点坐标，格式为
(row, col)。- scales(N,) 数组
相应的尺度。
- class skimage.feature.Cascade#
继承自：
object用于对象检测的分类器级联类。
级联分类器的基本思想是创建中等精度的分类器，并将它们组合成一个强大的分类器，而不是只创建一个强大的分类器。级联分类器的第二个优点是，可以通过评估级联中的部分分类器来对简单示例进行分类，这使得该过程比评估一个强大的分类器要快得多。
备注
级联方法最早由 Viola 和 Jones [1]、[2] 描述，尽管这些最初的出版物使用了一组 Haar 特征。而此实现使用的是多尺度块局部二值模式 (MB-LBP) 特征 [3]。
参考
[1]Viola, P. and Jones, M. “Rapid object detection using a boosted cascade of simple features,” In: Proceedings of the 2001 IEEE Computer Society Conference on Computer Vision and Pattern Recognition. CVPR 2001, pp. I-I. DOI:10.1109/CVPR.2001.990517
[2]Viola, P. and Jones, M.J, “Robust Real-Time Face Detection”, International Journal of Computer Vision 57, 137–154 (2004). DOI:10.1023/B:VISI.0000013087.49260.fb
[3]Liao, S. et al. Learning Multi-scale Block Local Binary Patterns for Face Recognition. International Conference on Biometrics (ICB), 2007, pp. 828-837. In: Lecture Notes in Computer Science, vol 4642. Springer, Berlin, Heidelberg. DOI:10.1007/978-3-540-74549-5_87
- 属性：
- epscnp.float32_t
精度参数。增加它会使分类器检测到更少的误报，但同时误报率也会增加。
- stages_numberPy_ssize_t
级联中的阶段数。每个级联包含树桩，即训练过的特征。
- stumps_numberPy_ssize_t
级联所有阶段中树桩的总数。
- features_numberPy_ssize_t
级联使用不同特征的总数。两个树桩可以使用相同的特征，但训练的值不同。
- window_widthPy_ssize_t
检测窗口的宽度。小于此窗口的对象无法检测到。
- window_heightPy_ssize_t
检测窗口的高度。
- stagesStage*
指向 C 数组的指针，该数组使用 Stage 结构存储阶段信息。
- featuresMBLBP*
指向 C 数组的指针，该数组使用 MBLBP 结构存储 MBLBP 特征。
- LUTscnp.uint32_t*
指向 C 数组的指针，该数组包含查找表，这些表由训练过的 MBLBP 特征（MBLBPStumps）用于评估特定区域。
- __init__()#
初始化级联分类器。
- 参数：
- xml_file文件的路径或文件的对象
以 OpenCv 格式保存的文件，从中加载所有级联分类器的参数。
- epscnp.float32_t
精度参数。增加它会使分类器检测到更少的误报，但同时误报率也会增加。
- detect_multi_scale(img, scale_factor, step_ratio, min_size, max_size, min_neighbor_number=4, intersection_score_threshold=0.5)#
在输入图像的多尺度上搜索对象。
该函数接收输入图像、搜索窗口在每个步骤中乘以的比例因子、最小窗口大小和最大窗口大小，它们指定应用于输入图像以检测对象的搜索窗口的范围。
- 参数：
- img2-D 或 3-D ndarray
表示输入图像的 Ndarray。
- scale_factorcnp.float32_t
搜索窗口在每个步骤中乘以的比例。
- step_ratiocnp.float32_t
图像每层级搜索步长的倍数。1 表示穷举搜索，通常速度很慢。通过将此参数设置为更高的值，结果会更差，但计算速度会快得多。通常，[1, 1.5] 区间内的值会产生良好的结果。
- min_size元组 (int, int)
搜索窗口的最小尺寸。
- max_size元组 (int, int)
搜索窗口的最大尺寸。
- min_neighbor_numberint
为了使检测结果得到函数的认可，检测结果必须具有的最小相交检测数量。
- intersection_score_thresholdcnp.float32_t
为了将两个检测结果合并成一个检测结果，比率 (相交区域) / (小矩形比率) 的最小值。
- 返回：
- output字典列表
字典格式为 {‘r’: int, ‘c’: int, ‘width’: int, ‘height’: int}，其中 ‘r’ 表示检测到的窗口左上角的横坐标位置，‘c’ 表示纵坐标位置，‘width’ 表示检测到的窗口的宽度，‘height’ 表示检测到的窗口的高度。
- eps#
- features_number#
- stages_number#
- stumps_number#
- window_height#
- window_width#
- class skimage.feature.ORB(downscale=1.2, n_scales=8, n_keypoints=500, fast_n=9, fast_threshold=0.08, harris_k=0.04)[source]#
基类：
FeatureDetector，DescriptorExtractor面向 FAST 和旋转 BRIEF 特征检测器和二进制描述符提取器。
- 参数：
- n_keypointsint，可选
要返回的关键点数量。如果检测到的关键点数量超过 n_keypoints，则该函数将返回根据 Harris 角点响应的最佳 n_keypoints。如果不是，则返回所有检测到的关键点。
- fast_nint，可选
在
skimage.feature.corner_fast中的 n 参数。圆周上 16 个像素中至少连续 n 个像素都比测试像素亮或暗。如果Ic < Ip - threshold，则圆周上的点 c 比测试像素 p 暗，如果Ic > Ip + threshold，则比测试像素 p 亮。它也代表FAST-n角点检测器中的 n。- fast_thresholdfloat，可选
在
feature.corner_fast中的threshold参数。用于确定圆周上的像素比测试像素亮、暗还是相似的阈值。当需要更多角点时，降低阈值，反之亦然。- harris_kfloat，可选
在
skimage.feature.corner_harris中的 k 参数。区分角点和边缘的灵敏度因子，通常在[0, 0.2]范围内。 k 的较小值会导致检测到更尖锐的角点。- downscalefloat，可选
图像金字塔的降采样因子。默认值 1.2 被选中，以便有更多密集的尺度，从而为随后的特征描述提供强大的尺度不变性。
- n_scalesint，可选
从图像金字塔底部开始提取特征的最大尺度数量。
参考
[1]Ethan Rublee、Vincent Rabaud、Kurt Konolige 和 Gary Bradski“ORB：一种比 SIFT 和 SURF 更高效的替代方法”http://www.vision.cs.chubu.ac.jp/CV-R/pdf/Rublee_iccv2011.pdf
示例
>>> from skimage.feature import ORB, match_descriptors >>> img1 = np.zeros((100, 100)) >>> img2 = np.zeros_like(img1) >>> rng = np.random.default_rng(19481137) # do not copy this value >>> square = rng.random((20, 20)) >>> img1[40:60, 40:60] = square >>> img2[53:73, 53:73] = square >>> detector_extractor1 = ORB(n_keypoints=5) >>> detector_extractor2 = ORB(n_keypoints=5) >>> detector_extractor1.detect_and_extract(img1) >>> detector_extractor2.detect_and_extract(img2) >>> matches = match_descriptors(detector_extractor1.descriptors, ... detector_extractor2.descriptors) >>> matches array([[0, 0], [1, 1], [2, 2], [3, 4], [4, 3]]) >>> detector_extractor1.keypoints[matches[:, 0]] array([[59. , 59. ], [40. , 40. ], [57. , 40. ], [46. , 58. ], [58.8, 58.8]]) >>> detector_extractor2.keypoints[matches[:, 1]] array([[72., 72.], [53., 53.], [70., 53.], [59., 71.], [72., 72.]])
- 属性：
- keypoints(N, 2) 数组
关键点坐标，格式为
(row, col)。- scales(N,) 数组
相应的尺度。
- orientations(N,) 数组
相应的以弧度表示的方向。
- responses(N,) 数组
相应的 Harris 角点响应。
- descriptors(Q, descriptor_size) 类型为 bool 的数组
大小为 descriptor_size 的二进制描述符二维数组，用于过滤掉边界关键点后的 Q 个关键点，其中索引处的
(i, j)值要么是True，要么是False，表示对第 i 个关键点在第 j 个决策像素对上的强度比较结果。它是Q == np.sum(mask)。
- __init__(downscale=1.2, n_scales=8, n_keypoints=500, fast_n=9, fast_threshold=0.08, harris_k=0.04)[source]#
- detect_and_extract(image)[source]#
检测定向 FAST 关键点并提取 rBRIEF 描述符。
请注意，这比先调用
detect然后调用extract更快。- 参数：
- image2D array
输入图像。
- extract(image, keypoints, scales, orientations)[source]#
为图像中的给定关键点提取 rBRIEF 二进制描述符。
请注意，关键点必须使用相同的 downscale 和 n_scales 参数提取。此外，如果您想要同时提取关键点和描述符，则应使用更快的
detect_and_extract。- 参数：
- image2D array
输入图像。
- keypoints(N, 2) 数组
关键点坐标，格式为
(row, col)。- scales(N,) 数组
相应的尺度。
- orientations(N,) 数组
相应的以弧度表示的方向。
- class skimage.feature.SIFT(upsampling=2, n_octaves=8, n_scales=3, sigma_min=1.6, sigma_in=0.5, c_dog=0.013333333333333334, c_edge=10, n_bins=36, lambda_ori=1.5, c_max=0.8, lambda_descr=6, n_hist=4, n_ori=8)[source]#
基类：
FeatureDetector，DescriptorExtractorSIFT 特征检测和描述符提取。
- 参数：
- upsamplingint，可选
在进行特征检测之前，图像将按 1 倍（不进行上采样）、2 倍或 4 倍进行上采样。方法：双三次插值。
- n_octavesint，可选
最大八度数。每进行一次八度运算，图像大小就会减半，sigma 就会加倍。八度数将根据需要减少，以确保在最小尺度下每个维度上至少有 12 个像素。
- n_scalesint，可选
每个八度中的最大尺度数量。
- sigma_min浮点数，可选
种子图像的模糊程度。如果启用了上采样，则 sigma_min 将按 1/upsampling 因子进行缩放
- sigma_infloat，可选
输入图像的假设模糊程度。
- c_dogfloat, 可选
用于丢弃 DoG 中低对比度极值的阈值。其最终值取决于 n_scales，关系为：final_c_dog = (2^(1/n_scales)-1) / (2^(1/3)-1) * c_dog
- c_edgefloat, 可选
用于丢弃位于边缘的极值的阈值。如果 H 是极值的 Hessian 矩阵，其“边缘性”由 tr(H)²/det(H) 描述。如果边缘性高于 (c_edge + 1)²/c_edge，则丢弃该极值。
- n_binsint, 可选
描述关键点周围梯度方向的直方图中的箱子数量。
- lambda_orifloat, 可选
用于查找关键点参考方向的窗口宽度为 6 * lambda_ori * sigma，并以 2 * lambda_ori * sigma 的标准差加权。
- c_maxfloat, 可选
方向直方图中接受次峰作为方向的阈值。
- lambda_descrfloat, 可选
用于定义关键点描述符的窗口宽度为 2 * lambda_descr * sigma * (n_hist+1)/n_hist，并以 lambda_descr * sigma 的标准差加权。
- n_histint, 可选
用于定义关键点描述符的窗口由 n_hist * n_hist 个直方图组成。
- n_oriint, 可选
描述符补丁直方图中的箱子数量。
备注
SIFT 算法由 David Lowe 开发 [1], [2]，后来由不列颠哥伦比亚大学获得专利。由于该专利于 2020 年到期，现在可以免费使用。这里的实现严格遵循 [3] 中的详细描述，包括使用相同的默认参数。
参考
[1]D.G. Lowe. “Object recognition from local scale-invariant features”, Proceedings of the Seventh IEEE International Conference on Computer Vision, 1999, vol.2, pp. 1150-1157. DOI:10.1109/ICCV.1999.790410
[2]D.G. Lowe. “Distinctive Image Features from Scale-Invariant Keypoints”, International Journal of Computer Vision, 2004, vol. 60, pp. 91–110. DOI:10.1023/B:VISI.0000029664.99615.94
[3]I. R. Otero and M. Delbracio. “Anatomy of the SIFT Method”, Image Processing On Line, 4 (2014), pp. 370–396. DOI:10.5201/ipol.2014.82
示例
>>> from skimage.feature import SIFT, match_descriptors >>> from skimage.data import camera >>> from skimage.transform import rotate >>> img1 = camera() >>> img2 = rotate(camera(), 90) >>> detector_extractor1 = SIFT() >>> detector_extractor2 = SIFT() >>> detector_extractor1.detect_and_extract(img1) >>> detector_extractor2.detect_and_extract(img2) >>> matches = match_descriptors(detector_extractor1.descriptors, ... detector_extractor2.descriptors, ... max_ratio=0.6) >>> matches[10:15] array([[ 10, 412], [ 11, 417], [ 12, 407], [ 13, 411], [ 14, 406]]) >>> detector_extractor1.keypoints[matches[10:15, 0]] array([[ 95, 214], [ 97, 211], [ 97, 218], [102, 215], [104, 218]]) >>> detector_extractor2.keypoints[matches[10:15, 1]] array([[297, 95], [301, 97], [294, 97], [297, 102], [293, 104]])
- 属性：
- delta_minfloat
第一个八度的采样距离。其最终值为 1/upsampling。
- float_dtypetype
图像的数据类型。
- scalespace_sigmas(n_octaves, n_scales + 3) 数组
所有八度中所有尺度的 sigma 值。
- keypoints(N, 2) 数组
关键点坐标，格式为
(row, col)。- positions(N, 2) 数组
亚像素精度关键点坐标，以
(row, col)格式表示。- sigmas(N,) 数组
关键点的对应 sigma（模糊）值。
- scales(N,) 数组
关键点的对应尺度。
- orientations(N,) 数组
每个关键点周围梯度的方向。
- octaves(N,) 数组
关键点的对应八度。
- descriptors(N, n_hist*n_hist*n_ori) 数组
关键点的描述符。
- __init__(upsampling=2, n_octaves=8, n_scales=3, sigma_min=1.6, sigma_in=0.5, c_dog=0.013333333333333334, c_edge=10, n_bins=36, lambda_ori=1.5, c_max=0.8, lambda_descr=6, n_hist=4, n_ori=8)[source]#
- property deltas#
所有八度的采样距离