feature

blob_dog

skimage.feature.blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=2.0, overlap=0.5)[source]

在给定的灰度图像中查找斑点。

使用高斯差分（DoG）方法[R166]找到斑点。对于找到的每个blob，该方法返回其坐标以及检测到blob的高斯内核的标准偏差。

注意

每个斑点的半径大约是（\sqrt{2}sigma）。

参考

例子

>>> from skimage import data, feature
>>> feature.blob_dog(data.coins(), threshold=.5, max_sigma=40)
array([[ 267.      ,  359.      ,   16.777216],
       [ 267.      ,  115.      ,   10.48576 ],
       [ 263.      ,  302.      ,   16.777216],
       [ 263.      ,  245.      ,   16.777216],
       [ 261.      ,  173.      ,   16.777216],
       [ 260.      ,   46.      ,   16.777216],
       [ 198.      ,  155.      ,   10.48576 ],
       [ 196.      ,   43.      ,   10.48576 ],
       [ 195.      ,  102.      ,   16.777216],
       [ 194.      ,  277.      ,   16.777216],
       [ 193.      ,  213.      ,   16.777216],
       [ 185.      ,  347.      ,   16.777216],
       [ 128.      ,  154.      ,   10.48576 ],
       [ 127.      ,  102.      ,   10.48576 ],
       [ 125.      ,  208.      ,   10.48576 ],
       [ 125.      ,   45.      ,   16.777216],
       [ 124.      ,  337.      ,   10.48576 ],
       [ 120.      ,  272.      ,   16.777216],
       [  58.      ,  100.      ,   10.48576 ],
       [  54.      ,  276.      ,   10.48576 ],
       [  54.      ,   42.      ,   16.777216],
       [  52.      ,  216.      ,   16.777216],
       [  52.      ,  155.      ,   16.777216],
       [  45.      ,  336.      ,   16.777216]])

blob_doh

skimage.feature.blob_doh(image, min_sigma=1, max_sigma=30, num_sigma=10, threshold=0.01, overlap=0.5, log_scale=False)[source]

在给定的灰度图像中查找斑点。

使用Hessian方法的行列式[R167]找到斑点。对于找到的每个blob，该方法返回其坐标以及用于行列式检测到blob的Hessian矩阵的高斯内核的标准偏差。Hessians的决定因素用[R168]近似。

注意

每个斑点的半径大约是sigma。Hessians行列式的计算与标准差无关。因此检测较大的斑点不会花费更多时间。在方法线blob_dog()和blob_log()高斯较大的计算sigma需要更多的时间。缺点是这种方法不能用于检测半径小于3px由于在Hessian行列式的近似中使用的盒式滤波器而引起的斑点。

参考

例子

>>> from skimage import data, feature
>>> img = data.coins()
>>> feature.blob_doh(img)
array([[ 270.        ,  363.        ,   30.        ],
       [ 265.        ,  113.        ,   23.55555556],
       [ 262.        ,  243.        ,   23.55555556],
       [ 260.        ,  173.        ,   30.        ],
       [ 197.        ,  153.        ,   20.33333333],
       [ 197.        ,   44.        ,   20.33333333],
       [ 195.        ,  100.        ,   23.55555556],
       [ 193.        ,  275.        ,   23.55555556],
       [ 192.        ,  212.        ,   23.55555556],
       [ 185.        ,  348.        ,   30.        ],
       [ 156.        ,  302.        ,   30.        ],
       [ 126.        ,  153.        ,   20.33333333],
       [ 126.        ,  101.        ,   20.33333333],
       [ 124.        ,  336.        ,   20.33333333],
       [ 123.        ,  205.        ,   20.33333333],
       [ 123.        ,   44.        ,   23.55555556],
       [ 121.        ,  271.        ,   30.        ]])

blob_log

skimage.feature.blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=0.2, overlap=0.5, log_scale=False)[source]

在给定的灰度图像中查找斑点。

使用高斯拉普拉斯（LoG）方法[R169]找到斑点。对于找到的每个blob，该方法返回其坐标以及检测到blob的高斯内核的标准偏差。

注意

每个斑点的半径大约是（\sqrt{2}sigma）。

参考

示例

>>> from skimage import data, feature, exposure
>>> img = data.coins()
>>> img = exposure.equalize_hist(img)  # improves detection
>>> feature.blob_log(img, threshold = .3)
array([[ 266.        ,  115.        ,   11.88888889],
       [ 263.        ,  302.        ,   17.33333333],
       [ 263.        ,  244.        ,   17.33333333],
       [ 260.        ,  174.        ,   17.33333333],
       [ 198.        ,  155.        ,   11.88888889],
       [ 198.        ,  103.        ,   11.88888889],
       [ 197.        ,   44.        ,   11.88888889],
       [ 194.        ,  276.        ,   17.33333333],
       [ 194.        ,  213.        ,   17.33333333],
       [ 185.        ,  344.        ,   17.33333333],
       [ 128.        ,  154.        ,   11.88888889],
       [ 127.        ,  102.        ,   11.88888889],
       [ 126.        ,  208.        ,   11.88888889],
       [ 126.        ,   46.        ,   11.88888889],
       [ 124.        ,  336.        ,   11.88888889],
       [ 121.        ,  272.        ,   17.33333333],
       [ 113.        ,  323.        ,    1.        ]])

canny

skimage.feature.canny(image, sigma=1.0, low_threshold=None, high_threshold=None, mask=None, use_quantiles=False)[source]

使用Canny算法边缘过滤图像。

另请参阅

skimage.sobel

注意

该算法的步骤如下：

• 使用sigma宽度高斯平滑图像。

• 应用水平和垂直Sobel算子来获取图像中的渐变。边缘强度是渐变的常态。

• 薄到1像素宽曲线的潜在边缘。首先，找到每个点的边缘法线。这是通过查看X-Sobel和Y-Sobel的符号和相对大小来将点分为4类：水平，垂直，对角线和反对角线。然后查看正常方向和反向方向，以查看这两个方向中的任何一个的值是否大于所讨论的点。使用插值来获得混合点，而不是选择最接近正常点的点。

• 执行滞后阈值：首先将高于阈值的所有点标记为边缘。然后递归地标记8个连接到带标记点的低阈值以上的点作为边。

参考

示例

>>> from skimage import feature
>>> # Generate noisy image of a square
>>> im = np.zeros((256, 256))
>>> im[64:-64, 64:-64] = 1
>>> im += 0.2 * np.random.rand(*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)

corner_fast

skimage.feature.corner_fast(image, n=12, threshold=0.15)[source]

提取给定图像的FAST角点。

参考

例子

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

corner_foerstner

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)

参考

例子

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

corner_harris

skimage.feature.corner_harris(image, method='k', k=0.05, eps=1e-06, sigma=1)[source]

计算哈里斯角度测量响应图像。

该角点检测器使用来自自相关矩阵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)

参考

示例

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

corner_kitchen_rosenfeld

skimage.feature.corner_kitchen_rosenfeld(image, mode='constant', cval=0)[source]

Compute Kitchen和Rosenfeld角落测量响应图像。

角落度量计算如下：

(imxx * imy**2 + imyy * imx**2 - 2 * imxy * imx * imy)
    / (imx**2 + imy**2)

imx和imy是第一个和imxx，imxy，imyy是第二个衍生物。

corner_moravec

skimage.feature.corner_moravec(image, window_size=1)[source]

计算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]])

corner_orientations

skimage.feature.corner_orientations(image, corners, mask)[source]

计算拐角的方向。

使用一阶中心矩即质量中心法计算拐角的方向。角定位是使用一阶中心矩计算的角点周围局部邻域中的角点坐标与强度矩心之间的角度。

参考

例子

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

corner_peaks

skimage.feature.corner_peaks(image, min_distance=1, threshold_abs=None, threshold_rel=0.1, exclude_border=True, indices=True, num_peaks=inf, footprint=None, labels=None)[source]

在角落测量响应图像中找到角点。

这不同于skimage.feature.peak_local_max它使用相同的累加器值抑制多个连接的峰值。

例子

>>> 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([[3, 3],
       [3, 2],
       [2, 3],
       [2, 2]])
>>> corner_peaks(response)
array([[2, 2]])

corner_shi_tomasi

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

参考

例子

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

corner_subpix

skimage.feature.corner_subpix(image, corners, window_size=11, alpha=0.99)[source]

确定拐角的亚像素位置。

统计测试决定角是否被定义为两个边或单个峰的交集。根据分类结果，子像素角位置基于灰度值的局部协方差来确定。如果统计测试的显着性水平不够，拐角不能被分类，并且输出子像素位置被设置为NaN。

参考

示例

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

daisy

skimage.feature.daisy(img, step=4, radius=15, rings=3, histograms=8, orientations=8, normalization='l1', sigmas=None, ring_radii=None, visualize=False)[source]

为给定图像密集提取DAISY特征描述符。

DAISY是一种类似于SIFT的特征描述符，其制定方式允许快速密集提取。通常，这对于袋特征图像表示是实用的。

实施遵循Tola等人。[R186]但偏离以下几点：

• 直方图箱的贡献在色调范围（角度范围）上用圆形高斯窗口平滑。

• 该代码中空间高斯平滑的西格玛值与Tola等人在原始代码中的西格玛值不匹配。[R187]。在他们的代码中，空间平滑应用于输入图像和中心直方图。但是，这种平滑在[R186]中没有记录，因此省略。

• 'l1'：L1标准化每个描述符。

• 'l2'：每个描述符的L2规范化。

• 'daisy'：个体直方图的L2归一化。

• 'off'：禁用标准化。

sigma：1D浮点数组，可选

中心直方图和每个直方图环的空间高斯平滑的标准偏差。这个sigma数组应该从中心和外面排序。即第一个西格马值定义中心直方图的空间平滑，最后一个西格玛值定义最外环的空间平滑。指定sigmas将覆盖以下参数。

rings = len(sigmas) - 1

ring_radii：int的1D数组，可选

每个环的半径（以像素为单位）。指定ring_radii将覆盖以下两个参数。

rings = len(ring_radii) radius = ring_radii[-1]

如果同时给出sigma和ring_radii，则它们必须满足以下谓词，因为中心直方图不需要半径。

len(ring_radii) == len(sigmas) + 1

可视化：bool, optional

生成DAISY描述符的可视化

Returns:  **descs** : array

给定图像的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) array (only if visualize==True)

DAISY描述符的可视化。

参考

draw_multiblock_lbp

skimage.feature.draw_multiblock_lbp(img, 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参数可以更改。

参考

greycomatrix

skimage.feature.greycomatrix(image, distances, angles, levels=None, symmetric=False, normed=False)[source]

计算灰度共生矩阵。

灰度级共生矩阵是图像上给定偏移处的共生灰度值的直方图。

参考

示例

计算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 = greycomatrix(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)

greycoprops

skimage.feature.greycoprops(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]

参考

例子

计算距离为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 = greycomatrix(image, [1, 2], [0, np.pi/2], levels=4,
...                  normed=True, symmetric=True)
>>> contrast = greycoprops(g, 'contrast')
>>> contrast
array([[ 0.58333333,  1.        ],
       [ 1.25      ,  2.75      ]])

hessian_matrix

skimage.feature.hessian_matrix(image, sigma=1, mode='constant', cval=0, order=None)[source]

计算Hessian矩阵。

Hessian矩阵定义如下：

H = [Hrr Hrc]
    [Hrc Hcc]

其是通过将图像与高斯内核的二阶导数在相应的x方向和y方向上卷积来计算的。

示例

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

hessian_matrix_det

skimage.feature.hessian_matrix_det(image, sigma=1)[source]

计算图像上的近似Hessian行列式。

该方法使用整体图像上的盒滤波器来计算近似的Hessian行列式，如[R193]中所述。

注意

此方法的运行时间仅取决于图像的大小。它sigma与人们所期望的无关。缺点是sigma小于的结果3不准确，即与计算Hessian并将其作为行列式的结果不相似。

参考

hessian_matrix_eigvals

skimage.feature.hessian_matrix_eigvals(Hxx, Hxy, Hyy)[source]

计算Hessian矩阵的特征值。

例子

>>> from skimage.feature import hessian_matrix, hessian_matrix_eigvals
>>> square = np.zeros((5, 5))
>>> square[2, 2] = 4
>>> Hxx, Hxy, Hyy = hessian_matrix(square, sigma=0.1, order='rc')
>>> hessian_matrix_eigvals(Hxx, Hxy, Hyy)[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.]])

hog

skimage.feature.hog(image, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(3, 3), block_norm='L1', visualise=False, transform_sqrt=False, feature_vector=True, normalise=None)[source]

提取给定图像的定向梯度直方图（HOG）。

计算面向梯度的直方图（HOG）

1. （可选）全局图像标准化

2. 在x和y中计算渐变图像

3. 计算梯度直方图

4. 正常化块

5. 展平成一个特征向量

注意

所提出的代码实现了从[R195]的HOG提取方法，其具有以下变化：（I）使用（3,3）单元的块（（2,2））;（II）单元内没有平滑（高斯空间窗口sigma = 8pix在论文中）;（III）使用L1块标准化（本文中的L2-Hys）。

幂律压缩也称为伽玛校正，用于减少阴影和光照变化的影响。压缩使黑暗区域变得更轻。当kwarg transform_sqrt设置为True，该函数计算每个颜色通道的平方根，然后将宏算法应用于图像。

参考

local_binary_pattern

skimage.feature.local_binary_pattern(image, P, R, method='default')[source]

灰度和旋转不变LBP（局部二元模式）。

LBP是一种可用于纹理分类的不变描述符。

• 'default'：原始的局部二值模式，它是灰度但不是旋转不变的。

• 'ror'：扩展灰度和旋转不变的默认实现。

• 'uniform'：改进的旋转不变性和均匀的模式以及角度空间的更精细的量化，灰度和旋转不变。

• 'nri_uniform'：非旋转不变统一模式变体，它只是灰度不变的[R199]。

• 'var'：旋转不变方差测量局部图像纹理的对比度，其是旋转但不是灰度不变的。

Returns:  **output** : (N, M) array

LBP图像。

参考

match_descriptors

skimage.feature.match_descriptors(descriptors1, descriptors2, metric=None, p=2, max_distance=inf, cross_check=True)[source]

描述符的蛮力匹配。

对于第一组中的每个描述符，该匹配器在第二组中找到最接近的描述符（在启用交叉检查的情况下反之亦然）。

match_template

skimage.feature.match_template(image, template, pad_input=False, mode='constant', constant_values=0)[source]

使用归一化相关将模板匹配到2-D或3-D图像。

输出是一个数值介于-1.0和1.0之间的数组。给定位置处的值对应于图像和模板之间的相关系数。

对于pad_input=True匹配对应于中心，否则对应于模板的左上角。要找到最佳匹配，您必须在响应（输出）图像中搜索峰值。

注意

有关互相关的细节在[R200]中介绍。该实现使用图像和模板的FFT卷积。参考文献[R201]提出了类似的推导，但本文中提供的近似值并未用于我们的实现。

参考

例子

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

multiblock_lbp

skimage.feature.multiblock_lbp(int_image, r, c, width, height)[source]

多块本地二进制模式（MB-LBP）。

这些特征的计算方式与局部二进制模式（LBPs）类似（local_binary_pattern()除了使用求和块代替单个像素值外）。

MB-LBP是LBP的一个扩展，可以使用积分图像在多个比例尺的恒定时间内进行计算。使用九个相同大小的矩形来计算特征。对于每个矩形，计算像素强度的总和。这些总和与中央矩形的总和的比较决定了该特征，类似于LBP。

参考

peak_local_max

skimage.feature.peak_local_max(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)[source]

在图像中查找峰值作为坐标列表或布尔掩模。

峰值是一个区域内的局部最大值2 * min_distance + 1（即峰值至少分开min_distance）。

如果峰值是平坦的（即多个相邻像素具有相同的强度），则返回所有这些像素的坐标。

如果同时threshold_abs并threshold_rel提供，最高的两个选择为峰的最小强度阈值。

• 如果indices = True：（row, column, …）坐标的峰值。

• 如果indices = False：布尔数组形状类似image，峰值由True值表示。

注意

峰值局部最大值函数返回图像中局部峰值（最大值）的坐标。最大过滤器用于查找局部最大值。该操作会扩大原始图像。比较扩张后的图像和原始图像后，该函数返回扩张图像等于原始图像的峰值的坐标或蒙版。

例子

>>> 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, 4],
       [3, 2]])

>>> peak_local_max(img1, min_distance=2)
array([[3, 2]])

>>> img2 = np.zeros((20, 20, 20))
>>> img2[10, 10, 10] = 1
>>> peak_local_max(img2, exclude_border=0)
array([[10, 10, 10]])

plot_matches

skimage.feature.plot_matches(ax, image1, image2, keypoints1, keypoints2, matches, keypoints_color='k', matches_color=None, only_matches=False)[source]

绘制匹配的功能。

register_translation

skimage.feature.register_translation(src_image, target_image, upsample_factor=1, space='real')[source]

通过互相关高效的子像素图像平移配准。

此代码在计算时间的一小部分中提供与FFT上采样互相关相同的精度，并且具有更低的存储器要求。它通过FFT获得互相关峰值的初始估计值，然后通过利用矩阵乘法DFT仅在该估计值的小邻域中对DFT进行上采样来提高移位估计。

参考

shape_index

skimage.feature.shape_index(image, sigma=1, mode='constant', cval=0)[source]

计算形状索引。

由Koenderink＆van Doorn [R205]定义的形状指数是局部曲率的单值测量，假设图像是一个强度代表高度的3D平面。

它来源于Hessian的特征值，它的取值范围从-1到1（在平坦区域中是未定义的（= NaN）），下面的范围表示以下形状：

参考

例子

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

structure_tensor

skimage.feature.structure_tensor(image, sigma=1, mode='constant', cval=0)[source]

使用平方差和计算结构张量。

结构张量A定义为：

A = [Axx Axy]
    [Axy Ayy]

其通过图像中每个像素周围的局部窗口中的差的平方加权和来近似。

例子

>>> from skimage.feature import structure_tensor
>>> square = np.zeros((5, 5))
>>> square[2, 2] = 1
>>> Axx, Axy, Ayy = structure_tensor(square, sigma=0.1)
>>> Axx
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.]])

structure_tensor_eigvals

skimage.feature.structure_tensor_eigvals(Axx, Axy, Ayy)[source]

计算结构张量的特征值。

示例

>>> from skimage.feature import structure_tensor, structure_tensor_eigvals
>>> square = np.zeros((5, 5))
>>> square[2, 2] = 1
>>> Axx, Axy, Ayy = structure_tensor(square, sigma=0.1)
>>> structure_tensor_eigvals(Axx, Axy, Ayy)[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.]])

BRIEF

class skimage.feature.BRIEF(descriptor_size=256, patch_size=49, mode='normal', sigma=1, sample_seed=1)[source]

Bases: skimage.feature.util.DescriptorExtractor

简单二进制描述符提取器。

简述（二进制稳健独立基本特征）是一种高效的特征点描述符。即使使用相对较少的位，它也具有高度区分性，并且使用简单的强度差异测试进行计算。

对于每个关键点，对特定分布数量的N个像素对进行强度比较，得到长度为N的二进制描述符。对于二进制描述符，可以使用汉明距离进行特征匹配，这导致与L2规范。

示例

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

属性

__init__(descriptor_size=256, patch_size=49, mode='normal', sigma=1, sample_seed=1)[source]extract(image, keypoints)[source]

为图像中的给定关键点提取简要二进制描述符。

CENSURE

class skimage.feature.CENSURE(min_scale=1, max_scale=7, mode='DoB', non_max_threshold=0.15, line_threshold=10)[source]

Bases: skimage.feature.util.FeatureDetector

CENSURE关键点检测器。

min_scale : int, optional从中提取关键点的最小比例。max_scale : int, optional从中提取关键点的最大比例。除了第一个和最后一个，即从范围min_scale + 1，max_scale - 1中的标度中，关键点将从所有标度中提取。不同标度的过滤器尺寸使得两个相邻标度包含一个八度。mode : {‘DoB’, ‘Octagon’, ‘STAR’}, optional用于获取输入图像比例的双层过滤器类型。可能的值是'DoB'，'Octagon'和'STAR'。这三种模式分别表示双层滤光片的形状，即盒子（方形），八边形和星形。例如，双层八角形滤波器由较小的内八边形和较大的外八边形组成，其中内部八边形的滤波器权重均匀为负，而在差异区域中均匀为正。使用STAR和Octagon以获得更好的功能，使用DoB以获得更好的性能。non_max_threshold : float, optional阈值用于抑制非最大抑制后获得的弱幅度响应的最大值和最小值。line_threshold : float, optional拒绝具有大于此值的主曲率比率的兴趣点的阈值。

参考

例子

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

属性

__init__(min_scale=1, max_scale=7, mode='DoB', non_max_threshold=0.15, line_threshold=10)[source]detect(image)[source]

检测CENSURE关键点以及相应的比例尺。

ORB

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]

Bases: skimage.feature.util.FeatureDetector, skimage.feature.util.DescriptorExtractor

面向快速和旋转的简要特征检测器和二进制描述符提取器。

参考

例子

>>> from skimage.feature import ORB, match_descriptors
>>> img1 = np.zeros((100, 100))
>>> img2 = np.zeros_like(img1)
>>> np.random.seed(1)
>>> square = np.random.rand(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, 3],
       [4, 4]])
>>> detector_extractor1.keypoints[matches[:, 0]]
array([[ 42.,  40.],
       [ 47.,  58.],
       [ 44.,  40.],
       [ 59.,  42.],
       [ 45.,  44.]])
>>> detector_extractor2.keypoints[matches[:, 1]]
array([[ 55.,  53.],
       [ 60.,  71.],
       [ 57.,  53.],
       [ 72.,  55.],
       [ 58.,  57.]])

属性

__init__(downscale=1.2, n_scales=8, n_keypoints=500, fast_n=9, fast_threshold=0.08, harris_k=0.04)[source]detect(image)[source]

检测面向FAST的关键点以及相应的比例尺。

detect_and_extract(image)[source]

检测面向FAST的关键点并提取rBRIEF描述符。

请注意，这是不是第一次调用更快detect，然后extract。

extract(image, keypoints, scales, orientations)[source]

为图像中给定的关键点提取rBRIEF二进制描述符。

需要注意的是关键点必须使用相同的提取downscale和n_scales参数。另外，如果你想提取关键点和描述符，你应该使用更快的detect_and_extract。