skimage.morphology#
处理图像形状的实用程序。
这些操作特别适合于二值图像，虽然有些操作对于其他类型的图像也可能很有用。
基本的形态学操作包括膨胀和侵蚀。
对图像执行区域闭合。 |
|
对图像执行区域开启。 |
|
生成球形足迹。 |
|
快速进行图像的二值形态学闭合。 |
|
快速进行图像的二值形态学膨胀。 |
|
快速进行图像的二值形态学侵蚀。 |
|
快速进行图像的二值形态学开启。 |
|
返回图像的黑顶帽。 |
|
返回图像的灰度形态学闭合。 |
|
计算二值图像的凸包图像。 |
|
计算二值图像中各个对象的凸包图像。 |
|
生成立方体形状的足迹。 |
|
对图像执行直径闭合。 |
|
对图像执行直径开启。 |
|
生成扁平菱形足迹。 |
|
返回图像的灰度形态学膨胀。 |
|
生成扁平的圆盘状足迹。 |
|
生成扁平的椭圆形足迹。 |
|
返回图像的灰度形态学侵蚀。 |
|
与泛洪填充相对应的掩模。 |
|
执行图像泛洪填充。 |
|
将足迹序列转换为等效的 ndarray。 |
|
确定图像中高度 >= h 的所有最大值。 |
|
确定图像中深度 >= h 的所有最小值。 |
|
返回图像的二值形态闭合。 |
|
返回图像的二值形态扩张。 |
|
返回图像的二值形态侵蚀。 |
|
返回图像的二值形态开操作。 |
|
标记整数数组的连接区域。 |
|
查找 n 维数组的局部最大值。 |
|
查找 n 维数组的局部最小值。 |
|
从图像构建最大树。 |
|
确定图像中所有局部最大值。 |
|
计算二值图像的骨架变换。 |
|
在足迹中镜像每个维度。 |
|
生成八角形形状的足迹。 |
|
生成八面体形状的足迹。 |
|
返回图像的灰度形态开操作。 |
|
沿着每个维度将足迹填充为奇数尺寸。 |
|
执行图像的形态重建。 |
|
生成平坦的矩形足迹。 |
|
按指定顺序移除对象，直到剩下的对象之间的最小距离。 |
|
去除小于指定大小的连续孔洞。 |
|
去除小于指定大小的对象。 |
|
计算二值图像的骨架。 |
|
生成平坦的方形足迹。 |
|
生成星形足迹。 |
|
执行二值图像的形态细化。 |
|
返回图像的白色礼帽。 |
- skimage.morphology.area_closing(image, area_threshold=64, connectivity=1, parent=None, tree_traverser=None)[source]#
对图像执行区域闭合。
区域闭运算会移除面积小于 area_threshold 的所有图像暗结构。输出图像大于或等于每个像素的输入图像，且所有局部最小值至少都有 area_threshold 像素的表面积。
区域闭运算类似于形态学闭运算，但区域闭运算不会使用固定结构，而是使用形变的结构，其面积 = area_threshold。
在二进制情况下，区域闭运算等效于去除小孔；因此此运算符已扩展到灰度图像。
从技术上讲，此运算符基于图像的最大树表示。
- 参数:
- imagendarray
要计算其区域闭运算的输入图像。此图像可以是任何类型。
- area_thresholdunsigned int
大小参数（像素数）。默认值被任意选择为 64。
- connectivityunsigned int，可选
邻域连接性。此整数表示到达邻居的最大学术步数。在 2D 中，它对于 4 邻域是 1，对于 8 邻域是 2。默认值为 1。
- parentndarray，int64，可选
表示已反相图像的最大树的父图像。每个像素的值是其在展开数组中的父级的索引。详情请参阅注释。
- tree_traverser一维数组，int64，可选
有序像素索引（引用展开数组）。各个像素的顺序为：每个像素前置其父像素（根除外，因为它没有父像素）。
- 返回:
- outputndarray
输出图像，其形状和类型与输入图像相同。
另请参阅
注释
如果最大树表示（parent 和 tree_traverser）已提供给该函数，则它们必须通过反相图像计算得到，即：>>> P, S = max_tree(invert(f)) >>> closed = diameter_closing(f, 3, parent=P, tree_traverser=S)
参考资料
[1]Vincent L.，“灰度区域开合、其有效实现与应用”，EURASIP 关于数学形态及其信号处理应用研讨会，西班牙巴塞罗那，第 22-27 页，1993 年 5 月。
[2]Soille，P.，“形态图像分析：原理和应用”（第 6 章），第 2 版（2003），ISBN 3540429883。 DOI：10.1007/978-3-662-05088-0
[3]Salembier，P.、Oliveras，A. 和 Garrido，L.，基于图像和序列处理的反扩张连通算子。IEEE 图像处理事务，7（4），555-570。 DOI：10.1109/83.663500
[4]Najman，L. 和 Couprie，M.（2006）。在准线性时间内构建组件树。IEEE 图像处理事务，15（11），3531-3539。 DOI：10.1109/TIP.2006.877518
[5]Carlinet，E. 和 Geraud，T.（2014）。组件树计算算法的比较评论。IEEE 图像处理事务，23（9），3885-3895。 DOI：10.1109/TIP.2014.2336551
示例
我们创建一个图像（中心处带有最小值并且另外有 4 个局部最小值的二次函数）。
>>> w = 12 >>> x, y = np.mgrid[0:w,0:w] >>> f = 180 + 0.2*((x - w/2)**2 + (y-w/2)**2) >>> f[2:3,1:5] = 160; f[2:4,9:11] = 140; f[9:11,2:4] = 120 >>> f[9:10,9:11] = 100; f[10,10] = 100 >>> f = f.astype(int)
我们可以计算区域闭合
>>> closed = area_closing(f, 8, connectivity=1)
所有小的最小值都会被移除，而剩余的最小值至少有 8 的大小。
- skimage.morphology.area_opening(image, area_threshold=64, connectivity=1, parent=None, tree_traverser=None)[source]#
对图像执行区域开启。
区域开合移除具有小于 area_threshold 表面的所有图像明亮结构。因此，输出图像比所有局部最大值至少具有面积阈值的像素表面的输入更小。
区域开合与形态开合类似，但它们不使用固定的基准，而是使用表面 = area_threshold的可变形基准。因此，具有 area_threshold=1 的 area_opening 是恒等式。
在二进制情况下，区域开合等效于移除小对象；因此，此运算符可扩展到灰度图像。
从技术上讲，此运算符基于图像的最大树表示。
- 参数:
- imagendarray
要计算区域开合的输入图像。此图像可以是任何类型。
- area_thresholdunsigned int
大小参数（像素数）。默认值被任意选择为 64。
- connectivityunsigned int，可选
邻域连接性。此整数表示到达邻居的最大学术步数。在 2D 中，它对于 4 邻域是 1，对于 8 邻域是 2。默认值为 1。
- parentndarray，int64，可选
表示图像最大树的父图像。每个像素的值都是其在展开数组中的父级的索引。
- tree_traverser一维数组，int64，可选
有序像素索引（引用展开数组）。各个像素的顺序为：每个像素前置其父像素（根除外，因为它没有父像素）。
- 返回:
- outputndarray
与原图像形状和类型相同的输出图像。
另请参阅
参考资料
[1]Vincent L.，“灰度区域开合、其有效实现与应用”，EURASIP 关于数学形态及其信号处理应用研讨会，西班牙巴塞罗那，第 22-27 页，1993 年 5 月。
[2]Soille，P.，“形态图像分析：原理和应用”（第 6 章），第 2 版（2003），ISBN 3540429883。 DOI：10.1007/978-3-662-05088-0
[3]Salembier，P.、Oliveras，A. 和 Garrido，L.，基于图像和序列处理的反扩张连通算子。IEEE 图像处理事务，7（4），555-570。 DOI：10.1109/83.663500
[4]Najman，L. 和 Couprie，M.（2006）。在准线性时间内构建组件树。IEEE 图像处理事务，15（11），3531-3539。 DOI：10.1109/TIP.2006.877518
[5]Carlinet，E. 和 Geraud，T.（2014）。组件树计算算法的比较评论。IEEE 图像处理事务，23（9），3885-3895。 DOI：10.1109/TIP.2014.2336551
示例
创建一个图像（具有一个中心最大值和 4 个附加局部最大值的二次函数）。
>>> w = 12 >>> x, y = np.mgrid[0:w,0:w] >>> f = 20 - 0.2*((x - w/2)**2 + (y-w/2)**2) >>> f[2:3,1:5] = 40; f[2:4,9:11] = 60; f[9:11,2:4] = 80 >>> f[9:10,9:11] = 100; f[10,10] = 100 >>> f = f.astype(int)
我们可以计算开孔面积。
>>> open = area_opening(f, 8, connectivity=1)
去除表面小于 8 的峰值。
- skimage.morphology.ball(radius, dtype=<class 'numpy.uint8'>, *, strict_radius=True, decomposition=None)[source]#
生成球形足迹。
这是圆盘的 3D 等效物。如果某个像素与原点之间的欧氏距离不高于 radius，则该像素位于邻域内。
- 参数:
- radius整型
球形足迹的半径。
- 返回:
- footprintndarray 或元组
邻域的元素为 1，否则为 0 的足迹。
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- strict_radius布尔值，可选
如果为 False，则半径扩大 0.5。这使得圆圈可以在每个轴上的尺寸保持
2 * radius + 1的情况下进一步扩大。如果 decomposition 不为 None，则忽略此参数。- decomposition{None, ‘sequence’}，可选
如果为 None，则返回一个数组。对于 ‘sequence’，则返回一个较小足迹的元组。应用这个较小足迹的序列将得到与单个较大正脚印等效的结果，但具有更好的计算性能。对于球形足迹，分解 decomposition 不完全等同于 decomposition=None。有关详细信息，请参阅注释。
注释
使用分解=’sequence’ 模式生成的圆盘与 decomposition=None 生成的圆盘不同。这里，我们扩展了 [1] 中对圆盘的处理方法，将其扩展到 3D 情况，使用该出版物中“正方形”、“菱形”和“T 形”元素的 3 维扩展。所有这些基本元素的大小均为
(3,) * ndim。我们通过数值计算，确定最接近使用关键字参数strict_radius=False, decomposition=None计算出的圆盘的每个元素的重复次数。根据经验，序列分解方法的等效复合印迹类似于菱形十二面体（26 面 [2]）。
参考资料
[1]Park，H 和 Chin R.T. 分离结构元以实现形态学运算的最佳执行。会议记录：1997 IEEE 非线性信号和图像处理研讨会，英国伦敦。 https://www.iwaenc.org/proceedings/1997/nsip97/pdf/scan/ns970226.pdf
- skimage.morphology.binary_closing(image, footprint=None, out=None, *, mode='ignore')[source]#
快速进行图像的二值形态学闭合。
此函数返回与灰度闭运算相同的结果，但对二进制图像执行速度更快。
对图像执行形态学闭运算被定义为膨胀后紧跟着腐蚀。闭运算可以去除较小的暗点（即“椒盐”）并连接较小的亮缝。这倾向于“闭合”（暗色）特征之间的（亮色）间隙。
- 参数:
- imagendarray
二进制输入图像。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray of bool，可选
存储形态结果的数组。如果传递 None，则将分配一个新数组。
- modestr，可选
mode 参数确定如何处理数组边界。有效的模式有：“max”、“min”、“ignore”。如果为“ignore”，则图像区域外部的像素对于腐蚀被认定为 True，对于膨胀被认定为 False，导致它们不影响结果。默认为“ignore”。
0.23 版本中已添加： 0.23 中已添加 mode。
- 返回:
- closingndarray of bool
形态学闭运算的结果。
注释
也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。
- skimage.morphology.binary_dilation(image, footprint=None, out=None, *, mode='ignore')[source]#
快速进行图像的二值形态学膨胀。
此函数返回的结果与灰度膨胀相同，但对二值图像的执行速度更快。
形态学膨胀将
(i,j)处的像素设置为以(i,j)为中心的邻域中所有像素的最大值。膨胀会扩大亮区域并缩小暗区域。- 参数:
- imagendarray
二进制输入图像。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray of bool，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- modestr，可选
mode 参数确定如何处理数组边框。有效模式为：‘max’、‘min’、‘ignore’。如果为‘min’或‘ignore’，则图像域外的像素将假定为 False，导致它们不影响结果。默认为“ignore”。
0.23 版本中已添加： 0.23 中已添加 mode。
- 返回:
- dilatedndarray of bool or uint
形态学膨胀的结果，其值在
[False, True]中。
注释
也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。对于非对称足迹，
skimage.morphology.binary_dilation()和skimage.morphology.dilation()产生的输出不同：binary_dilation会镜像足迹，但dilation不会。
- skimage.morphology.binary_erosion(image, footprint=None, out=None, *, mode='ignore')[source]#
快速进行图像的二值形态学侵蚀。
该函数返回与灰度侵蚀相同的结果，但对二进制图像执行起来更快。
形态学侵蚀将
(i,j)处的像素设置为以(i,j)为中心的邻域中所有像素的最小值为基础。侵蚀会收缩亮区域并扩大暗区域。- 参数:
- imagendarray
二进制输入图像。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray of bool，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- modestr，可选
mode 参数决定了数组边界的处理方式。有效模式为：'max'、'min'、'ignore'。如果为 'max' 或 'ignore'，那么图像域之外的像素将被假定为 True，这将导致它们不会对结果产生影响。默认值为 'ignore'。
0.23 版本中已添加： 0.23 中已添加 mode。
- 返回:
- eroded布尔或 uint ndarry
形态学侵蚀的结果，取值为
[False, True]。
注释
也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。对于偶数大小的足迹，
skimage.morphology.erosion()和该函数会产生不同的输出：一个与另一个相比较会偏移一个像素。
- skimage.morphology.binary_opening(image, footprint=None, out=None, *, mode='ignore')[源代码]#
快速进行图像的二值形态学开启。
此函数返回与灰度开运算相同的结果，但对二进制图像的执行速度更快。
图像上的形态学开运算定义为先腐蚀后膨胀。开运算可以移除小的亮斑（即“盐”），连接小的暗裂缝。这倾向于“打开”（暗）特征之间的（亮）空隙。
- 参数:
- imagendarray
二进制输入图像。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray of bool，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- modestr，可选
mode 参数确定如何处理数组边界。有效的模式有：“max”、“min”、“ignore”。如果为“ignore”，则图像区域外部的像素对于腐蚀被认定为 True，对于膨胀被认定为 False，导致它们不影响结果。默认为“ignore”。
0.23 版本中已添加： 0.23 中已添加 mode。
- 返回:
- opening布尔型 ndarray
形态学开运算的结果。
注释
也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。
- skimage.morphology.black_tophat(image, footprint=None, out=None, *, mode='reflect', cval=0.0)[源代码]#
返回图像的黑顶帽。
图像的黑顶帽定义为其形态学闭运算减去原始图像。此操作返回比脚印小的图像的暗斑。请注意，原始图像中的暗斑在黑顶帽后是亮斑。
- 参数:
- imagendarray
图像数组。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- modestr，可选
mode 参数确定如何处理数组边界。有效模式包括：‘reflect’、‘constant’、‘nearest’、‘mirror’、‘wrap’、‘max’、‘min’ 或 ‘ignore’。请参阅
skimage.morphology.closing()。默认值为 ‘reflect’。- cval标量，可选
如果mode是“constant”，填充输入的过去边缘的值。默认值为 0.0。
在 0.23 版本中添加： mode和cval在 0.23 中添加。
- 返回:
- outarray，与image相同形状和类型
形态学黑顶帽的结果。
另请参阅
注释
也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。参考资料
示例
>>> # Change dark peak to bright peak and subtract background >>> import numpy as np >>> from skimage.morphology import square >>> dark_on_gray = np.array([[7, 6, 6, 6, 7], ... [6, 5, 4, 5, 6], ... [6, 4, 0, 4, 6], ... [6, 5, 4, 5, 6], ... [7, 6, 6, 6, 7]], dtype=np.uint8) >>> black_tophat(dark_on_gray, square(3)) array([[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 1, 5, 1, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0]], dtype=uint8)
- skimage.morphology.closing(image, footprint=None, out=None, *, mode='reflect', cval=0.0)[source]#
返回图像的灰度形态学闭合。
图像的形态闭运算定义为膨胀后是腐蚀。闭运算可以移除小的暗斑（例如“噪声”）和连接小的亮缝隙。这会“关闭”（黑暗）的（光明）特征之间的间隙。
- 参数:
- imagendarray
图像数组。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray，可选
存储形态结果的数组。如果没有，将分配一个新数组。
- modestr，可选
mode参数决定如何处理数组边框。有效模式为：“reflect”、“constant”、“nearest”、“mirror”、“wrap”、“max”、“min”或“ignore”。如果为“ignore”，则假定图像域外的像素在腐蚀中为图像的 dtype 的最大值，在膨胀中为最小值，这会导致它们不会影响结果。默认值为“reflect”。
- cval标量，可选
如果mode是“constant”，填充输入的过去边缘的值。默认值为 0.0。
在 0.23 版本中添加： mode和cval在 0.23 中添加。
- 返回:
- closingarray，与image相同形状和类型
形态学闭运算的结果。
注释
也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。示例
>>> # Close a gap between two bright lines >>> import numpy as np >>> from skimage.morphology import square >>> broken_line = np.array([[0, 0, 0, 0, 0], ... [0, 0, 0, 0, 0], ... [1, 1, 0, 1, 1], ... [0, 0, 0, 0, 0], ... [0, 0, 0, 0, 0]], dtype=np.uint8) >>> closing(broken_line, square(3)) array([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], dtype=uint8)
- skimage.morphology.convex_hull_image(image, offset_coordinates=True, tolerance=1e-10, include_borders=True)[source]#
计算二值图像的凸包图像。
凸包是输入图像中所有白色像素的周围最小的凸多边形所包含的像素集。
- 参数:
- 图像数组
二进制输入图像。这个数组在处理前被转换成布尔类型。
- 偏移坐标布尔值，可选
如果
True，例如一个在坐标（4、7）处的像素将被表示为坐标（3.5、7）、（4.5、7）、（4、6.5）和（4、7.5）。在计算轮廓时，这会给某个像素增加一些“范围”。- 容差浮点数，可选
确定一个点是否在轮廓内的容差。由于浮点数的数值误差，容差 0 可能导致一些点错误地被分类为轮廓外。
- include_borders: 布尔值，可选
如果
False，顶点/边缘将被排除在最终的凸包掩码外。
- 返回:
- 轮廓(M，N) 布尔数组
具有凸包中像素设置为 True 的二进制图像。
参考资料
- skimage.morphology.convex_hull_object(image, *, connectivity=2)[source]#
计算二值图像中各个对象的凸包图像。
凸包是输入图像中所有白色像素的周围最小的凸多边形所包含的像素集。
- 参数:
- 图像(M，N) ndarray
二进制输入图像。
- 连通性{1，2}，整数，可选
确定每个像素的相邻像素。距离像素中心
connectivity距离内平方距离内的相邻元素被认为是相邻像素。1-connectivity 2-connectivity [ ] [ ] [ ] [ ] | \ | / [ ]--[x]--[ ] [ ]--[x]--[ ] | / | \ [ ] [ ] [ ] [ ]
- 返回:
- 轮廓布尔 ndarray
将凸包内的像素设置为
True的二进制图像。
注释
此函数使用
skimage.morphology.label定义唯一对象，使用convex_hull_image找到每个对象的凸包，并通过逻辑 OR 组合这些区域。请注意，未连接对象的外凸包在结果中可能重叠。如果怀疑这种情况，请考虑在每个对象上分别使用 convex_hull_image 或调整connectivity。
- skimage.morphology.cube(width, dtype=<class 'numpy.uint8'>, *, decomposition=None)[source]#
生成立方体形状的足迹。
这是正方形的 3D 等价物。外围每个像素的棋盘距离不超过半径（半径=floor(width/2)）像素。
- 参数:
- 宽度int
正方的宽度、高度和深度。
- 返回:
- footprintndarray 或元组
其邻域中为 1 的元素为 1，否则为 0。当decomposition 为 None 时，它只是一个 numpy.ndarray。否则，它将是一个元组，其长度等于要应用的唯一结构元素数（更多详情，请参见注释）
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- 分解{None, ‘separable’, ‘sequence’}，可选
如果为 None，则返回一个单数组。对于“序列”，返回一个较小脚印的元组。应用这一系列较小的脚印将产生与单个较大的脚印相同的结果，但通常具有更好的计算性能。更多详情，请参见注释。
注释
当decomposition 不是 None 时，footprint 元组的每个元素都是一个形式为
(ndarray, num_iter)的 2 元组，用于指定脚印数组和要应用该数组的迭代次数。对于二值形态，使用
decomposition='sequence'被观察到具有更好的性能，性能提升幅度会随着脚印大小的增大而迅速增加。对于具有方形脚印的灰度形态，由于已调用的内部 SciPy 函数已具有基于可分离 1D 滑动窗口的快速实现，因此建议使用decomposition=None。“序列”分解模式仅支持奇数width。如果width 为偶数，则使用的序列将与“可分离”模式相同。
- skimage.morphology.diameter_closing(image, diameter_threshold=8, connectivity=1, parent=None, tree_traverser=None)[source]#
对图像执行直径闭合。
Diameter_closing 删除图像中所有边界框最大宽度小于 diameter_threshold 的黑色结构。最大宽度定义为边界框的最大宽度。该算子也称为边界框闭合。实际上，结果类似于形态学闭合，但是并没有移除细长结构。
从技术上讲，此运算符基于图像的最大树表示。
- 参数:
- imagendarray
待计算 diameter_closing 的输入图像。该图像可以是任何类型。
- diameter_thresholdunsigned int
最大宽度参数（像素数）。默认值为 8。
- connectivityunsigned int，可选
邻域连接性。此整数表示到达邻居的最大学术步数。在 2D 中，它对于 4 邻域是 1，对于 8 邻域是 2。默认值为 1。
- parentndarray，int64，可选
表示反转图像的最大树的预计算 parent 图像。如果提供预计算的 parent 和 tree_traverser，这个函数的速度很快。参见附注以获取更多详细信息。
- tree_traverser一维数组，int64，可选
预计算的遍历器，其中的像素按顺序排列，每个像素之前都是其 parent（没有 parent 的根除外）。如果提供预计算的 parent 和 tree_traverser，这个函数的速度很快。参见附注以获取更多详细信息。
- 返回:
- outputndarray
输出图像，其形状和类型与输入图像相同。
另请参阅
注释
如果最大树表示（parent 和 tree_traverser）已提供给该函数，则它们必须通过反相图像计算得到，即：>>> P, S = max_tree(invert(f)) >>> closed = diameter_closing(f, 3, parent=P, tree_traverser=S)
参考资料
[1]Walter, T., & Klein, J.-C. (2002). Automatic Detection of Microaneurysms in Color Fundus Images of the Human Retina by Means of the Bounding Box Closing. In A. Colosimo, P. Sirabella, A. Giuliani (Eds.), Medical Data Analysis. Lecture Notes in Computer Science, vol 2526, pp. 210-220. Springer Berlin Heidelberg. DOI:10.1007/3-540-36104-9_23
[2]Carlinet，E. 和 Geraud，T.（2014）。组件树计算算法的比较评论。IEEE 图像处理事务，23（9），3885-3895。 DOI：10.1109/TIP.2014.2336551
示例
我们创建一个图像（中心处带有最小值并且另外有 4 个局部最小值的二次函数）。
>>> w = 12 >>> x, y = np.mgrid[0:w,0:w] >>> f = 180 + 0.2*((x - w/2)**2 + (y-w/2)**2) >>> f[2:3,1:5] = 160; f[2:4,9:11] = 140; f[9:11,2:4] = 120 >>> f[9:10,9:11] = 100; f[10,10] = 100 >>> f = f.astype(int)
我们可以计算 diameter_closing
>>> closed = diameter_closing(f, 3, connectivity=1)
所有最大宽度为 2 或更小的局部最小值均已移除。其余局部最小值的最大宽度至少为 3。
- skimage.morphology.diameter_opening(image, diameter_threshold=8, connectivity=1, parent=None, tree_traverser=None)[source]#
对图像执行直径开启。
直径内切去除图像中所有最大扩展小于 diameter_threshold 的明亮结构。最大扩展定义为包围框的最大扩展。该操作也被称为包围框内切。实际上，结果类似于形态内切，但不会去除长而细的结构。
从技术上讲，此运算符基于图像的最大树表示。
- 参数:
- imagendarray
要计算区域开合的输入图像。此图像可以是任何类型。
- diameter_thresholdunsigned int
最大宽度参数（像素数）。默认值为 8。
- connectivityunsigned int，可选
邻域连接性。此整数表示到达邻居的最大学术步数。在 2D 中，它对于 4 邻域是 1，对于 8 邻域是 2。默认值为 1。
- parentndarray，int64，可选
表示图像最大树的父图像。每个像素的值都是其在展开数组中的父级的索引。
- tree_traverser一维数组，int64，可选
有序像素索引（引用展开数组）。各个像素的顺序为：每个像素前置其父像素（根除外，因为它没有父像素）。
- 返回:
- outputndarray
与原图像形状和类型相同的输出图像。
另请参阅
参考资料
[1]Walter, T., & Klein, J.-C. (2002). Automatic Detection of Microaneurysms in Color Fundus Images of the Human Retina by Means of the Bounding Box Closing. In A. Colosimo, P. Sirabella, A. Giuliani (Eds.), Medical Data Analysis. Lecture Notes in Computer Science, vol 2526, pp. 210-220. Springer Berlin Heidelberg. DOI:10.1007/3-540-36104-9_23
[2]Carlinet，E. 和 Geraud，T.（2014）。组件树计算算法的比较评论。IEEE 图像处理事务，23（9），3885-3895。 DOI：10.1109/TIP.2014.2336551
示例
创建一个图像（具有一个中心最大值和 4 个附加局部最大值的二次函数）。
>>> w = 12 >>> x, y = np.mgrid[0:w,0:w] >>> f = 20 - 0.2*((x - w/2)**2 + (y-w/2)**2) >>> f[2:3,1:5] = 40; f[2:4,9:11] = 60; f[9:11,2:4] = 80 >>> f[9:10,9:11] = 100; f[10,10] = 100 >>> f = f.astype(int)
我们可以计算直径内切
>>> open = diameter_opening(f, 3, connectivity=1)
最大扩展为 2 或更小的峰值会被去除。剩余峰值的最大扩展均至少为 3。
- skimage.morphology.diamond(radius, dtype=<class 'numpy.uint8'>, *, decomposition=None)[source]#
生成扁平菱形足迹。
如果像素与邻域中心之间的城市街区/曼哈顿距离不大于 radius，则像素属于邻域（即标记为 1）。
- 参数:
- radius整型
菱形邻域半径。
- 返回:
- footprintndarray 或元组
其邻域中为 1 的元素为 1，否则为 0。当decomposition 为 None 时，它只是一个 numpy.ndarray。否则，它将是一个元组，其长度等于要应用的唯一结构元素数（更多详情，请参见注释）
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- decomposition{None, ‘sequence’}，可选
如果为 None，则返回一个数组。对于“序列”，返回一个小一些的邻域元组。应用这一系列较小的邻域将给出与单个、更大的邻域相同的结果，但具有更好的计算性能。请查看备注获取更多详细信息。
注释
当decomposition 不是 None 时，footprint 元组的每个元素都是一个形式为
(ndarray, num_iter)的 2 元组，用于指定脚印数组和要应用该数组的迭代次数。对于二进制或灰度形态，使用
decomposition='sequence'已观察到具有性能优势，优势幅度会随着邻域大小的增加而增加。
- skimage.morphology.dilation(image, footprint=None, out=None, shift_x=<DEPRECATED>, shift_y=<DEPRECATED>, *, mode='reflect', cval=0.0)[source]#
返回图像的灰度形态学膨胀。
形态学膨胀将局部邻域中心像素的值设置为其中所有像素最大值。footprint 中为 1 的值定义了此邻域。膨胀放大亮区，缩小暗区。
- 参数:
- imagendarray
图像数组。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- modestr，可选
mode 参数决定如何处理数组边界。有效模式包括：‘reflect’，‘constant’，‘nearest’，‘mirror’，‘wrap’，‘max’，‘min’ 或 ‘ignore’。如果是 ‘min’ 或 ‘ignore’，图像域外的像素被视为图像的 dtype 的最大值，这会导致它们不会对结果产生影响。默认值为 ‘reflect’。
- cval标量，可选
如果mode是“constant”，填充输入的过去边缘的值。默认值为 0.0。
在 0.23 版本中添加： mode和cval在 0.23 中添加。
- 返回:
- dilateduint8 数组，与 image 相同的形状和类型
形态学膨胀的结果。
- 其他参数:
- shift_x, shift_y已弃用
从 0.23 版本开始弃用。
注释
对于
uint8（和高达一定位深的uint16）数据，较低的算法复杂度使得skimage.filters.rank.maximum()函数对更大图像和 footprint 更有效。也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。对于非对称足迹，
skimage.morphology.binary_dilation()和skimage.morphology.dilation()产生的输出不同：binary_dilation会镜像足迹，但dilation不会。示例
>>> # Dilation enlarges bright regions >>> import numpy as np >>> from skimage.morphology import square >>> bright_pixel = np.array([[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]], dtype=np.uint8) >>> dilation(bright_pixel, square(3)) array([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]], dtype=uint8)
- skimage.morphology.disk(radius, dtype=<class 'numpy.uint8'>, *, strict_radius=True, decomposition=None)[source]#
生成扁平的圆盘状足迹。
如果像素到原点的欧几里德距离不超过半径，则该像素在邻域内。（仅在decomposition == ‘sequence’ 时近似为真）。
- 参数:
- radius整型
圆形印迹的半径。
- 返回:
- footprintndarray
邻域的元素为 1，否则为 0 的足迹。
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- strict_radius布尔值，可选
如果为 False，则半径扩大 0.5。这使得圆圈可以在每个轴上的尺寸保持
2 * radius + 1的情况下进一步扩大。如果 decomposition 不为 None，则忽略此参数。- 分解{None, ‘sequence’, ‘crosses’}，可选
如果为 None，则返回单个数组。对于 ‘sequence’，将返回一组较小的印迹。应用这一系列较小的印迹将获得与单个较大印迹等效的结果，但具有更好的计算性能。对于圆形印迹，‘sequence’ 或 ‘crosses’ 分解并不总是完全等效于
decomposition=None。有关更多详细信息，请参见注释。
注释
当decomposition 不是 None 时，footprint 元组的每个元素都是一个形式为
(ndarray, num_iter)的 2 元组，用于指定脚印数组和要应用该数组的迭代次数。由
decomposition='sequence'模式生成圆盘可能与decomposition=None所得圆盘不完全相同。可以通过沿每个轴应用一系列长度为 3 的较小印迹来近似圆形印迹。针对 2D 半径为 2 到 10 的圆盘，在 [1] 中给出了此问题的具体解决方案。在此，我们通过数字计算了每个元素的重复次数，该数字与使用关键字参数strict_radius=False, decomposition=None计算的圆盘最接近。根据经验，大半径的系列分解接近十六边形（十六边形 [2]）。在 [3] 中，作者证明对于使用 (3, 3) 形状的印迹进行分解，十六边形是与圆盘最接近的近似。
由
decomposition='crosses'生成的圆盘通常但不总是与decomposition=None相同。它通常会比decomposition='sequence'提供更接近的近似，性能相当。各个十字形元素的尺寸不限于 (3, 3)。与 ‘seqeuence’ 分解不同，‘crosses’ 分解还可以准确近似严格半径为strict_radius=True的圆盘的形状。该方法基于 [4] 中算法 1 的改编。参考资料
[1]Park，H 和 Chin R.T. 分离结构元以实现形态学运算的最佳执行。会议记录：1997 IEEE 非线性信号和图像处理研讨会，英国伦敦。 https://www.iwaenc.org/proceedings/1997/nsip97/pdf/scan/ns970226.pdf
[3]Vanrell, M 和 Vitrià, J. 用于形态转换的最佳可分解圆盘 3×3。Image and Vision Computing，第 15 卷，第 11 期，1997 年。DOI:10.1016/S0262-8856(97)00026-7
[4]李、D. 和 Ritter、G.X. 分离和对称凸模板的分解. Proc. SPIE 1350，《图像代数与形态学图像处理》，（1990 年 11 月 1 日）。DOI:10.1117/12.23608
- skimage.morphology.ellipse(width, height, dtype=<class 'numpy.uint8'>, *, decomposition=None)[source]#
生成扁平的椭圆形足迹。
椭圆周边上的每个像素均满足方程
(x/width+1)**2 + (y/height+1)**2 = 1。- 参数:
- 宽度int
椭圆形轮廓线步长的宽度。
- 高度int
椭圆形轮廓线步长的宽度。
- 返回:
- footprintndarray
社区元素为 1，否则为 0 的轮廓线。此轮廓线的形状为
(2 * height + 1, 2 * width + 1)。
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- decomposition{None, ‘crosses’}, 可选
如果为 None，则返回一个数组。对于“序列”，返回一个小一些的邻域元组。应用这一系列较小的邻域将给出与单个、更大的邻域相同的结果，但具有更好的计算性能。请查看备注获取更多详细信息。
注释
当decomposition 不是 None 时，footprint 元组的每个元素都是一个形式为
(ndarray, num_iter)的 2 元组，用于指定脚印数组和要应用该数组的迭代次数。由
decomposition='crosses'产生的椭圆通常但并非总是相同于由decomposition=None产生的椭圆。此方法基于 [1] 中给出的算法 1 的改编。参考资料
[1]李、D. 和 Ritter、G.X. 分离和对称凸模板的分解. Proc. SPIE 1350，《图像代数与形态学图像处理》，（1990 年 11 月 1 日）。DOI:10.1117/12.23608
示例
>>> from skimage.morphology import footprints >>> footprints.ellipse(5, 3) array([[0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0]], dtype=uint8)
- skimage.morphology.erosion(image, footprint=None, out=None, shift_x=<DEPRECATED>, shift_y=<DEPRECATED>, *, mode='reflect', cval=0.0)[source]#
返回图像的灰度形态学侵蚀。
形态学腐蚀针对 (i,j) 中心邻域内的所有像素设置 (i,j) 为最小值。腐蚀会收缩亮区域并扩大暗区域。
- 参数:
- imagendarray
图像数组。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- modestr，可选
mode 参数决定了如何处理数组边框。有效模式包括：‘reflect’，‘constant’，‘nearest’，‘mirror’，‘wrap’，‘max’，‘min’，或‘ignore’。如果为 ‘max’ 或 ‘ignore’，则认为图像域外的像素为图像 dtype 的最大值，导致它们不影响结果。默认为‘reflect’。
- cval标量，可选
如果mode是“constant”，填充输入的过去边缘的值。默认值为 0.0。
在 0.23 版本中添加： mode和cval在 0.23 中添加。
- 返回:
- erodedarray，与 image 形状相同
形态学腐蚀的结果。
- 其他参数:
- shift_x, shift_y已弃用
从 0.23 版本开始弃用。
注释
对于
uint8（以及达到特定位深的uint16）数据，更低的算法复杂性使skimage.filters.rank.minimum()函数对于更大的图像和足迹更高效。也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。对于偶数大小的足迹，
skimage.morphology.binary_erosion()和此函数生成的输出值不同：一个相对于另一个发生位移了一个像素。示例
>>> # Erosion shrinks bright regions >>> import numpy as np >>> from skimage.morphology import square >>> bright_square = np.array([[0, 0, 0, 0, 0], ... [0, 1, 1, 1, 0], ... [0, 1, 1, 1, 0], ... [0, 1, 1, 1, 0], ... [0, 0, 0, 0, 0]], dtype=np.uint8) >>> erosion(bright_square, square(3)) array([[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]], dtype=uint8)
- skimage.morphology.flood(image, seed_point, *, footprint=None, connectivity=None, tolerance=None)[source]#
与泛洪填充相对应的掩模。
从特定的 seed_point 开始，会找到种子值相等或介于 tolerance 范围内的连接点。
- 参数:
- imagendarray
N 维数组。
- seed_point元组或 int
image 中用作泛洪填充分量起点的一个点。如果图像为 1D，则此点可以给出为一个整数。
- footprintndarray，可选
足迹（结构元素）用于确定每个评估像素的邻域。它必须仅包含 1 和 0，与 image 具有相同的维度数。如果未给定，则所有相邻像素都被视为邻域的一部分（完全连接）。
- connectivityint，可选
用于确定每个评估的像素邻域的数字。平方距离小于或等于connectivity的邻近像素被视为邻居。如果footprint不为无，则忽略。
- tolerancefloat 或 int，可选
如果为无（默认值），则相邻值必须严格等于image在seed_point处的初始值。这是最快的。如果给定了值，则将在每个点进行比较，并且如果在初始值的容差范围内，则也会被填充（包括）。
- 返回:
- maskndarray
与image形状相同的布尔数组被返回，对于连接并等于（或在容差内）种子点的区域，值为真。所有其他值为假。
注释
此操作的概念类比是许多栅格图形程序中的“涂漆桶”工具。此函数仅返回表示填充的掩模。
如果由于内存原因而需要索引而不是掩码，则用户只需在结果上运行
numpy.nonzero，保存索引并丢弃此掩码。示例
>>> from skimage.morphology import flood >>> image = np.zeros((4, 7), dtype=int) >>> image[1:3, 1:3] = 1 >>> image[3, 0] = 1 >>> image[1:3, 4:6] = 2 >>> image[3, 6] = 3 >>> image array([[0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 2, 2, 0], [0, 1, 1, 0, 2, 2, 0], [1, 0, 0, 0, 0, 0, 3]])
用 5 填充已连接的数字，具有完全连通性（包括对角线）
>>> mask = flood(image, (1, 1)) >>> image_flooded = image.copy() >>> image_flooded[mask] = 5 >>> image_flooded array([[0, 0, 0, 0, 0, 0, 0], [0, 5, 5, 0, 2, 2, 0], [0, 5, 5, 0, 2, 2, 0], [5, 0, 0, 0, 0, 0, 3]])
用 5 填充已连接的数字，不包括对角线点（连通性 1）
>>> mask = flood(image, (1, 1), connectivity=1) >>> image_flooded = image.copy() >>> image_flooded[mask] = 5 >>> image_flooded array([[0, 0, 0, 0, 0, 0, 0], [0, 5, 5, 0, 2, 2, 0], [0, 5, 5, 0, 2, 2, 0], [1, 0, 0, 0, 0, 0, 3]])
根据容差进行填充
>>> mask = flood(image, (0, 0), tolerance=1) >>> image_flooded = image.copy() >>> image_flooded[mask] = 5 >>> image_flooded array([[5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 2, 2, 5], [5, 5, 5, 5, 2, 2, 5], [5, 5, 5, 5, 5, 5, 3]])
- skimage.morphology.flood_fill(image, seed_point, new_value, *, footprint=无, connectivity=无, tolerance=无, in_place=False)[source]#
执行图像泛洪填充。
从特定的seed_point开始，找到等于或在种子值tolerance以内的相连的点，然后将其设置为new_value。
- 参数:
- imagendarray
N 维数组。
- seed_point元组或 int
image 中用作泛洪填充分量起点的一个点。如果图像为 1D，则此点可以给出为一个整数。
- new_valueimage类型
可用于设置全部填充的新值。此值必须根据 图像 的数据类型进行选择。
- footprintndarray，可选
足迹（结构元素）用于确定每个评估像素的邻域。它必须仅包含 1 和 0，与 image 具有相同的维度数。如果未给定，则所有相邻像素都被视为邻域的一部分（完全连接）。
- connectivityint，可选
用于确定每个评估的像素邻域的数字。平方距离小于或等于connectivity的邻近像素被视为邻居。如果footprint不为无，则忽略。
- tolerancefloat 或 int，可选
如果为 None（默认值），则 种子点 处 图像 的值与邻接值必须严格相等才能进行填充。这是最快的。如果提供了容差，则填充 种子点 正负容差范围内的值的邻接点（包含）。
- 就地布尔值，可选
如果为 True，则就地对 图像 应用漫水填充。如果为 False，则返回漫水填充结果，而不修改输入 图像（默认值）。
- 返回:
- 填充ndarray
返回一个与 图像 形状相同的数组，其中连接到种子点（或在容差范围内）并与种子点相等的区域中的值将被 新值 替换。
注释
此操作的概念类比是许多栅格图形程序中的“油漆桶”工具。
示例
>>> from skimage.morphology import flood_fill >>> image = np.zeros((4, 7), dtype=int) >>> image[1:3, 1:3] = 1 >>> image[3, 0] = 1 >>> image[1:3, 4:6] = 2 >>> image[3, 6] = 3 >>> image array([[0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 2, 2, 0], [0, 1, 1, 0, 2, 2, 0], [1, 0, 0, 0, 0, 0, 3]])
用 5 填充已连接的数字，具有完全连通性（包括对角线）
>>> flood_fill(image, (1, 1), 5) array([[0, 0, 0, 0, 0, 0, 0], [0, 5, 5, 0, 2, 2, 0], [0, 5, 5, 0, 2, 2, 0], [5, 0, 0, 0, 0, 0, 3]])
用 5 填充已连接的数字，不包括对角线点（连通性 1）
>>> flood_fill(image, (1, 1), 5, connectivity=1) array([[0, 0, 0, 0, 0, 0, 0], [0, 5, 5, 0, 2, 2, 0], [0, 5, 5, 0, 2, 2, 0], [1, 0, 0, 0, 0, 0, 3]])
根据容差进行填充
>>> flood_fill(image, (0, 0), 5, tolerance=1) array([[5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 2, 2, 5], [5, 5, 5, 5, 2, 2, 5], [5, 5, 5, 5, 5, 5, 3]])
- skimage.morphology.footprint_from_sequence(footprints)[source]#
将足迹序列转换为等效的 ndarray。
- 参数:
- footprints2-元组的元组
一序列足迹元组，其中每个元组的第一个元素对应于一个足迹的数组，第二个元素是应用该足迹的次数。目前，所有足迹大小都应为奇数。
- 返回:
- footprintndarray
等同于应用
footprints序列单一数组。
- skimage.morphology.h_maxima(image, h, footprint=None)[source]#
确定图像中高度 >= h 的所有最大值。
局部最大值定义为灰度值严格大于集合直接邻域中所有像素灰度值的相连像素集合。
高度为 h 的局部最大值 M 是局部最大值，对于该局部最大值，至少存在一条连接 M 与等于或大于局部最大值的路径，其最小值为 f(M) - h（也就是说，路径中的值不会相对于最大值下降超过 h），且不存在到等于或大于局部最大值的路径其最小值更大。
此函数还可以找出图像的全局最大值。
- 参数:
- imagendarray
要计算局部最大值的输入图像。
- hunsigned integer
所有提取的局部最大值的最小高度。
- footprintndarray，可选
以 n 维 1 和 0 阵列表示的邻域。默认值是根据最大范数（即 2D 图像的 3x3 正方形、3D 图像的 3x3x3 立方体等）半径为 1 的球形。
- 返回:
- h_maxndarray
高度 >= h 的局部最大值和全局最大值。结果图像是一个二值图像，其中属于已确定局部最大值的像素取值 1，其他像素取值 0。
参考资料
[1]Soille, P., “Morphological Image Analysis: Principles and Applications” (第 6 章)，第 2 版（2003），ISBN 3540429883。
示例
>>> import numpy as np >>> from skimage.morphology import extrema
我们创建一个图像（以中心点为最大值的二次函数和 4 个额外的常数最大值。最大值的高度为：1、21、41、61、81
>>> w = 10 >>> x, y = np.mgrid[0:w,0:w] >>> f = 20 - 0.2*((x - w/2)**2 + (y-w/2)**2) >>> f[2:4,2:4] = 40; f[2:4,7:9] = 60; f[7:9,2:4] = 80; f[7:9,7:9] = 100 >>> f = f.astype(int)
我们能够计算高度至少为 40 的所有最大值
>>> maxima = extrema.h_maxima(f, 40)
结果图像将包含 3 个局部最大值。
- skimage.morphology.h_minima(image, h, footprint=None)[source]#
确定图像中深度 >= h 的所有最小值。
局部最小值定义为具有相等灰度值且严格小于集合中某个像素邻域中灰度值的像素的连通集。
深度为 h 的局部最小值 M 是一个局部最小值，存在至少一条连接 M 与局部最小值（可以相等，也可以更低）的路径，且该路径上的最大值为 f(M) + h（即沿路径上的值相对于最小值都未增加 h 以上），且不存在任何连接 M 与局部最小值（可以相等，也可以更低）的路径，且该路径的最大值更小。
该函数还会找到图像的全局最小值。
- 参数:
- imagendarray
要计算局部最小值的输入图像。
- hunsigned integer
所有提取的局部最小值的最小深度。
- footprintndarray，可选
以 n 维 1 和 0 阵列表示的邻域。默认值是根据最大范数（即 2D 图像的 3x3 正方形、3D 图像的 3x3x3 立方体等）半径为 1 的球形。
- 返回:
- h_minndarray
深度 >= h 的局部最小值和全局最小值。结果图像是一个二值图像，其中属于已确定局部最小值的像素取值 1，其他像素取值 0。
参考资料
[1]Soille, P., “Morphological Image Analysis: Principles and Applications” (第 6 章)，第 2 版（2003），ISBN 3540429883。
示例
>>> import numpy as np >>> from skimage.morphology import extrema
我们创建一个图像（以中心点为最小值的二次函数和 4 个额外的常数最大值。最小值的深度为：1、21、41、61、81
>>> w = 10 >>> x, y = np.mgrid[0:w,0:w] >>> f = 180 + 0.2*((x - w/2)**2 + (y-w/2)**2) >>> f[2:4,2:4] = 160; f[2:4,7:9] = 140; f[7:9,2:4] = 120; f[7:9,7:9] = 100 >>> f = f.astype(int)
我们能够计算深度至少为 40 的所有最小值
>>> minima = extrema.h_minima(f, 40)
结果图像将包含 3 个局部最小值。
- skimage.morphology.isotropic_closing(image, radius, out=None, spacing=None)[源代码]#
返回图像的二值形态闭合。
此函数返回与二值化
skimage.morphology.binary_closing()相同的结果，但对大型圆形结构元素执行较快。这通过对精确的欧几里得距离图 [1]、[2] 进行阀值处理来实现。实现基于：函数：scipy.ndimage.distance_transform_edt。- 参数:
- imagendarray
二进制输入图像。
- radiusfloat
应封闭区域的半径。
- outndarray of bool，可选
存储形态结果的数组。如果传递 None，则将分配一个新数组。
- spacingfloat 或 float 序列，可选
沿每个维度元素的间距。如果是序列，则其长度必须等于输入的维度（轴的数量）。如果是单个数字，则此值将用于所有轴。如果未指定，则隐含单位网格间距。
- 返回:
- closedbool 数组
形态学闭运算的结果。
参考资料
[1]Cuisenaire、O. 和 Macq、B.，“使用局部距离变换和传播以及应用对快欧式形态学算子进行传播”，“图像处理及其应用”，第七届国际会议（会议出版号 465），1999 年，第 856-860 页，第 2 卷。 DOI:10.1049/cp:19990446
[2]Ingemar Ragnemalm，通过轮廓处理和距离图阈值处理快速腐蚀和膨胀，模式识别快报，第 13 卷，第 3 期，1992 年，第 161-166 页。 DOI:10.1016/0167-8655(92)90055-5
- skimage.morphology.isotropic_dilation(image, radius, out=None, spacing=None)[源码]#
返回图像的二值形态扩张。
此函数返回与
skimage.morphology.binary_dilation()相同的结果，但对于大型圆形结构元素执行速度更快。这通过对倒置图像 [1]、[2] 的精确欧几里德距离图应用阈值来实现。此实现基于：func:scipy.ndimage.distance_transform_edt。- 参数:
- imagendarray
二进制输入图像。
- radiusfloat
区域应膨胀的半径。
- outndarray of bool，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- spacingfloat 或 float 序列，可选
沿每个维度元素的间距。如果是序列，则其长度必须等于输入的维度（轴的数量）。如果是单个数字，则此值将用于所有轴。如果未指定，则隐含单位网格间距。
- 返回:
- 膨胀bool 型 ndarray
形态学膨胀的结果，其值在
[False, True]中。
参考资料
[1]Cuisenaire、O. 和 Macq、B.，“使用局部距离变换和传播以及应用对快欧式形态学算子进行传播”，“图像处理及其应用”，第七届国际会议（会议出版号 465），1999 年，第 856-860 页，第 2 卷。 DOI:10.1049/cp:19990446
[2]Ingemar Ragnemalm，通过轮廓处理和距离图阈值处理快速腐蚀和膨胀，模式识别快报，第 13 卷，第 3 期，1992 年，第 161-166 页。 DOI:10.1016/0167-8655(92)90055-5
- skimage.morphology.isotropic_erosion(image, radius, out=None, spacing=None)[源码]#
返回图像的二值形态侵蚀。
此函数返回与
skimage.morphology.binary_erosion()相同的结果，但对于大型圆形结构元素执行速度更快。这通过对图像 [1]、[2] 的精确欧几里德距离图应用阈值来实现。此实现基于：func:scipy.ndimage.distance_transform_edt。- 参数:
- imagendarray
二进制输入图像。
- radiusfloat
区域应腐蚀的半径。
- outndarray of bool，可选
存储形态结果的数组。如果没有，将分配一个新数组。
- spacingfloat 或 float 序列，可选
沿每个维度元素的间距。如果是序列，则其长度必须等于输入的维度（轴的数量）。如果是单个数字，则此值将用于所有轴。如果未指定，则隐含单位网格间距。
- 返回:
- 侵蚀布尔值 ndarray
形态学侵蚀的结果，取值为
[False, True]。
参考资料
[1]Cuisenaire、O. 和 Macq、B.，“使用局部距离变换和传播以及应用对快欧式形态学算子进行传播”，“图像处理及其应用”，第七届国际会议（会议出版号 465），1999 年，第 856-860 页，第 2 卷。 DOI:10.1049/cp:19990446
[2]Ingemar Ragnemalm，通过轮廓处理和距离图阈值处理快速腐蚀和膨胀，模式识别快报，第 13 卷，第 3 期，1992 年，第 161-166 页。 DOI:10.1016/0167-8655(92)90055-5
- skimage.morphology.isotropic_opening(image, radius, out=None, spacing=None)[source]#
返回图像的二值形态开操作。
此函数返回的结果与
skimage.morphology.binary_opening()相同，但对于大型圆形结构元素，执行速度更快。这是通过对精确的 Euclidean 距离图 [1]、[2] 进行阈值确定的。此实现基于以下内容：func:scipy.ndimage.distance_transform_edt。- 参数:
- imagendarray
二进制输入图像。
- radiusfloat
用于开启区域的半径。
- outndarray of bool，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- spacingfloat 或 float 序列，可选
沿每个维度元素的间距。如果是序列，则其长度必须等于输入的维度（轴的数量）。如果是单个数字，则此值将用于所有轴。如果未指定，则隐含单位网格间距。
- 返回:
- 已开启布尔值 ndarray
形态学开运算的结果。
参考资料
[1]Cuisenaire、O. 和 Macq、B.，“使用局部距离变换和传播以及应用对快欧式形态学算子进行传播”，“图像处理及其应用”，第七届国际会议（会议出版号 465），1999 年，第 856-860 页，第 2 卷。 DOI:10.1049/cp:19990446
[2]Ingemar Ragnemalm，通过轮廓处理和距离图阈值处理快速腐蚀和膨胀，模式识别快报，第 13 卷，第 3 期，1992 年，第 161-166 页。 DOI:10.1016/0167-8655(92)90055-5
- skimage.morphology.label(label_image, background=None, return_num=False, connectivity=None)[source]#
标记整数数组的连接区域。
两个像素在是邻居并具有相同的值时连接。在 2D 中，它们既可以是 1 连接意义上的邻居，也可以是 2 连接意义上的邻居。该值表示将像素/体素视为邻居的考虑最大正交跳点数。
1-connectivity 2-connectivity diagonal connection close-up [ ] [ ] [ ] [ ] [ ] | \ | / | <- hop 2 [ ]--[x]--[ ] [ ]--[x]--[ ] [x]--[ ] | / | \ hop 1 [ ] [ ] [ ] [ ]
- 参数:
- label_imagedtype 为 int 的 ndarray
要标记的图像。
- backgroundint，可选
认为具有此值的所有像素都是背景像素，且将它们标记为 0。默认情况下，将 0 值像素视为背景像素。
- return_numbool，可选
是否返回已分派标签的数目。
- connectivityint，可选
最大数量的正交点将像素/体素视为邻居。可以接受的范围从 1 到 input.ndim。如果
None，将全连接input.ndim。
- 返回:
- 标签ndarray 数据类型为 int
标记的排列，其中所有相连区域指定的是相同整数值。
- 数字int，可选
标签的数量，等于最大标签索引，仅在 return_num 为 True 时返回。
参考资料
[1]克里斯托弗·菲奥里奥和延斯·古斯特德，“两种线性时间联合-查找图像处理策略”，理论计算机科学，154 (1996)，页 165-181。
[2]肯森·吴，埃科夫·奥图和艾瑞·肖沙尼，“优化连接分量标记算法”，论文 LBNL-56864，2005 年，劳伦斯伯克利国家实验室（加利福尼亚大学），http://repositories.cdlib.org/lbnl/LBNL-56864
示例
>>> import numpy as np >>> x = np.eye(3).astype(int) >>> print(x) [[1 0 0] [0 1 0] [0 0 1]] >>> print(label(x, connectivity=1)) [[1 0 0] [0 2 0] [0 0 3]] >>> print(label(x, connectivity=2)) [[1 0 0] [0 1 0] [0 0 1]] >>> print(label(x, background=-1)) [[1 2 2] [2 1 2] [2 2 1]] >>> x = np.array([[1, 0, 0], ... [1, 1, 5], ... [0, 0, 0]]) >>> print(label(x)) [[1 0 0] [1 1 2] [0 0 0]]
- skimage.morphology.local_maxima(image, footprint=None, connectivity=None, indices=False, allow_borders=True)[source]#
查找 n 维数组的局部最大值。
局部极大值定义为连接的像素集，灰度等级（平坦区域）严格大于邻居中所有像素的灰度等级。
- 参数:
- imagendarray
N 维数组。
- footprintndarray，可选
用于确定每个评估像素邻域的点阵（结构元素）（
True表示连接的像素）。它必须是一个布尔型数组，并且维度数目与 image 相同。如果 footprint 和 connectivity 都没给出，则将所有相邻像素视为邻域的一部分。- connectivityint，可选
用于确定每个评估的像素邻域的数字。平方距离小于或等于connectivity的邻近像素被视为邻居。如果footprint不为无，则忽略。
- indicesbool，可选
如果为 True，输出将是一维数组的元组，表示每个维度中局部极大值的索引。如果为 False，则输出将是与 image 形状相同的布尔数组。
- allow_bordersbool，可选
如果为真，则与图像边界相切的平台有效极小值。
- 返回:
- minimand-array 或 tuple[nd-array]
如果indices为 false，则返回与image形状相同的布尔数组，其中
True指示局部极小值的位置（否则为False）。如果indices为 true，则返回包含所找到全部极小值坐标（索引）的一维数组元组。
- 警告：
- UserWarning
如果allow_borders为 false，且给定image的任何维度都短于 3 个样本，则极小值不存在，将显示警告。
注释
该函数在以下思路指导下运行
遍历图像的最后维度，仅通过比较一个方向的像素来标记局部极小值候选。如果像素未在最后维度连接在一起，则将其全部标记为候选。
针对每个候选
执行覆盖填充，找出具有相同灰度值并属于平台的所有相连像素。
考虑平台的相连邻域：如果没有边界样本具有更高的灰度级别，则将平台标记为明确的局部极小值。
示例
>>> from skimage.morphology import local_maxima >>> image = np.zeros((4, 7), dtype=int) >>> image[1:3, 1:3] = 1 >>> image[3, 0] = 1 >>> image[1:3, 4:6] = 2 >>> image[3, 6] = 3 >>> image array([[0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 2, 2, 0], [0, 1, 1, 0, 2, 2, 0], [1, 0, 0, 0, 0, 0, 3]])
通过与所有相邻像素比较（最大连接）来查找局部极小值
>>> local_maxima(image) array([[False, False, False, False, False, False, False], [False, True, True, False, False, False, False], [False, True, True, False, False, False, False], [ True, False, False, False, False, False, True]]) >>> local_maxima(image, indices=True) (array([1, 1, 2, 2, 3, 3]), array([1, 2, 1, 2, 0, 6]))
查找局部极小值，而不必与对角线像素进行比较（连接数 1）
>>> local_maxima(image, connectivity=1) array([[False, False, False, False, False, False, False], [False, True, True, False, True, True, False], [False, True, True, False, True, True, False], [ True, False, False, False, False, False, True]])
排除边界图像边缘的极小值
>>> local_maxima(image, connectivity=1, allow_borders=False) array([[False, False, False, False, False, False, False], [False, True, True, False, True, True, False], [False, True, True, False, True, True, False], [False, False, False, False, False, False, False]])
- skimage.morphology.local_minima(image, footprint=None, connectivity=None, indices=False, allow_borders=True)[source]#
查找 n 维数组的局部最小值。
局部极小值被定义为灰度级相等的相连像素集（平台），严格小于邻域中所有像素的灰度级。
- 参数:
- imagendarray
N 维数组。
- footprintndarray，可选
用于确定每个评估像素邻域的点阵（结构元素）（
True表示连接的像素）。它必须是一个布尔型数组，并且维度数目与 image 相同。如果 footprint 和 connectivity 都没给出，则将所有相邻像素视为邻域的一部分。- connectivityint，可选
用于确定每个评估的像素邻域的数字。平方距离小于或等于connectivity的邻近像素被视为邻居。如果footprint不为无，则忽略。
- indicesbool，可选
如果为 True，输出将是表示每个维度中局部最小值的索引的一维数组组成的元组。如果为 False，输出将是与image 相同形状的布尔数组。
- allow_bordersbool，可选
如果为 True，则接触图像边界的平坦区域是有效的局部最小值。
- 返回:
- minimandarray 或 tuple[ndarray]
如果indices 为 False，则返回一个与image 相同形状的布尔数组，其中
True表示局部最小值的位置（否则为False）。如果indices 为 True，则返回一个包含所有找到的局部最小值坐标（索引）的一维数组组成的元组。
注释
该函数在以下思路指导下运行
对图像的最后一个维度进行第一次遍历，并通过仅在一个方向上比较像素来标记局部最小值候选。如果像素在最后一个维度中没有连接，则将所有像素标记为候选。
针对每个候选
执行覆盖填充，找出具有相同灰度值并属于平台的所有相连像素。
考虑平坦区域的连接邻域：如果没有相邻样本的灰度更低，则将平坦区域标记为明确的局部最小值。
示例
>>> from skimage.morphology import local_minima >>> image = np.zeros((4, 7), dtype=int) >>> image[1:3, 1:3] = -1 >>> image[3, 0] = -1 >>> image[1:3, 4:6] = -2 >>> image[3, 6] = -3 >>> image array([[ 0, 0, 0, 0, 0, 0, 0], [ 0, -1, -1, 0, -2, -2, 0], [ 0, -1, -1, 0, -2, -2, 0], [-1, 0, 0, 0, 0, 0, -3]])
通过与所有相邻像素比较来查找局部最小值（最大连通性）
>>> local_minima(image) array([[False, False, False, False, False, False, False], [False, True, True, False, False, False, False], [False, True, True, False, False, False, False], [ True, False, False, False, False, False, True]]) >>> local_minima(image, indices=True) (array([1, 1, 2, 2, 3, 3]), array([1, 2, 1, 2, 0, 6]))
在不与对角线像素比较的情况下查找局部最小值（连通性 1）
>>> local_minima(image, connectivity=1) array([[False, False, False, False, False, False, False], [False, True, True, False, True, True, False], [False, True, True, False, True, True, False], [ True, False, False, False, False, False, True]])
并排除与图像边缘相接的局部最小值
>>> local_minima(image, connectivity=1, allow_borders=False) array([[False, False, False, False, False, False, False], [False, True, True, False, True, True, False], [False, True, True, False, True, True, False], [False, False, False, False, False, False, False]])
- skimage.morphology.max_tree(image, connectivity=1)[source]#
从图像构建最大树。
组件树表示应用于图像的顺序阈值化操作所得连通分量的层次结构。如果后者包含在前者中，则一个级别的连通分量是更高级别上某个分量的父分量。最大树是组件树的高效表示形式。一个级别的连通分量由该级别上的一个参考像素表示，该像素是该级别上所有其他像素的父元素，也是上一级别上参考像素的父元素。最大树是许多形态学算子的基础，即连通算子。
- 参数:
- imagendarray
要计算其最大树的输入图像。该图像可以是任何类型。
- connectivityunsigned int，可选
邻域连接性。此整数表示到达邻居的最大学术步数。在 2D 中，它对于 4 邻域是 1，对于 8 邻域是 2。默认值为 1。
- 返回:
- parentndarray，int64
形状与图像相同的数组。每个像素的值是其在拉伸数组中的父像素的索引。
- tree_traverser1D 数组，int64
有序像素索引（引用展开数组）。各个像素的顺序为：每个像素前置其父像素（根除外，因为它没有父像素）。
参考资料
[1]Salembier，P.、Oliveras，A. 和 Garrido，L.，基于图像和序列处理的反扩张连通算子。IEEE 图像处理事务，7（4），555-570。 DOI：10.1109/83.663500
[2]Berger, C.、Geraud, T.、Levillain, R.、Widynski, N.、Baillard, A. 和 Bertin, E. (2007)。有效的组件树计算以及在天文图像中应用于模式识别的计算。在国际图像处理会议 (ICIP)（第 41-44 页）中。DOI:10.1109/ICIP.2007.4379949
[3]Najman，L. 和 Couprie，M.（2006）。在准线性时间内构建组件树。IEEE 图像处理事务，15（11），3531-3539。 DOI：10.1109/TIP.2006.877518
[4]Carlinet，E. 和 Geraud，T.（2014）。组件树计算算法的比较评论。IEEE 图像处理事务，23（9），3885-3895。 DOI：10.1109/TIP.2014.2336551
示例
我们创建一个小型样本图像（[4] 中的图 1）并构建 max 树。
>>> image = np.array([[15, 13, 16], [12, 12, 10], [16, 12, 14]]) >>> P, S = max_tree(image, connectivity=2)
- skimage.morphology.max_tree_local_maxima(image, connectivity=1, parent=None, tree_traverser=None)[源代码]#
确定图像中所有局部最大值。
局部最大值定义为一组相连的像素，其灰度值等于或高于集合的直接邻域内的所有像素的灰度值。该函数对局部最大值进行标记。
从技术上讲，该实现基于图像的最大树表示形式。如果已经计算出最大树表示形式，该函数非常有效。否则，最好使用 local_maxima 函数。
- 参数:
- imagendarray
要计算局部最大值的输入图像。
- connectivityunsigned int，可选
邻域连接性。此整数表示到达邻居的最大学术步数。在 2D 中，它对于 4 邻域是 1，对于 8 邻域是 2。默认值为 1。
- parentndarray，int64，可选
每个像素的值都是其在 ravelled 数组中的父节点的索引。
- tree_traverser一维数组，int64，可选
有序像素索引（引用展开数组）。各个像素的顺序为：每个像素前置其父像素（根除外，因为它没有父像素）。
- 返回:
- local_maxndarray，uint64
图像的标记局部最大值。
参考资料
[1]Vincent L.，“灰度区域开合、其有效实现与应用”，EURASIP 关于数学形态及其信号处理应用研讨会，西班牙巴塞罗那，第 22-27 页，1993 年 5 月。
[2]Soille，P.，“形态图像分析：原理和应用”（第 6 章），第 2 版（2003），ISBN 3540429883。 DOI：10.1007/978-3-662-05088-0
[3]Salembier，P.、Oliveras，A. 和 Garrido，L.，基于图像和序列处理的反扩张连通算子。IEEE 图像处理事务，7（4），555-570。 DOI：10.1109/83.663500
[4]Najman，L. 和 Couprie，M.（2006）。在准线性时间内构建组件树。IEEE 图像处理事务，15（11），3531-3539。 DOI：10.1109/TIP.2006.877518
[5]Carlinet，E. 和 Geraud，T.（2014）。组件树计算算法的比较评论。IEEE 图像处理事务，23（9），3885-3895。 DOI：10.1109/TIP.2014.2336551
示例
我们创建了一个图像（包含中心最大值的二次函数和 4 个附加常量最大值）。
>>> w = 10 >>> x, y = np.mgrid[0:w,0:w] >>> f = 20 - 0.2*((x - w/2)**2 + (y-w/2)**2) >>> f[2:4,2:4] = 40; f[2:4,7:9] = 60; f[7:9,2:4] = 80; f[7:9,7:9] = 100 >>> f = f.astype(int)
我们可以计算出所有局部最大值
>>> maxima = max_tree_local_maxima(f)
结果图像包含标记的局部最大值。
- skimage.morphology.medial_axis(image, mask=None, return_distance=False, *, rng=None)[源代码]#
计算二值图像的骨架变换。
- 参数:
- image binary ndarray，形状为 (M，N)
需细化的图像形状。如果此输入不是二值图像，则会转换成为二值图像：在这种情况下，零值被视为背景 (False)，非零值被视为前景 (True)。
- mask binary ndarray，形状为 (M，N)，可选
如果给出了掩码，则 image 中只有 mask 中值为 true 的那些元素才用于计算骨架线。
- return_distance bool，可选
如果为 true，则会返回距离变换和骨架线。
- rng {
numpy.random.Generator，int}，可选 伪随机数生成器。默认情况下使用 PCG64 生成器（请参阅
numpy.random.default_rng()）。如果 rng 为 int，则用于播种生成器。PRNG 确定了处理像素的顺序以打破平局。
添加到 0.19 版本。
- 返回:
- out 布尔 ndarray
图像的骨架线变换
- dist int ndarray，可选
图像的距离变换（仅当 return_distance 为 True 时返回）
另请参阅
注释
此算法将图像的骨架线变换计算为其距离变换的脊线。
- 算法的不同步骤如下
使用查找表，将 0 或 1 分配给 3x3 二进制正方形的每种配置，这些配置表示是移除还是保留中心像素。如果一个点有多个相邻点，并且移除它不会更改连接分量的数量，我们希望移除该点。
计算到背景的距离变换，以及像素的拐角度。
按距离变换对前景（值为 1）点进行排序，然后按拐角度进行排序。
调用 Cython 函数将图像简化为其骨架线。它按照前一步确定的顺序处理像素，并根据查找表移除或保留像素。由于进行了排序，因此只需一趟即可处理所有像素。
示例
>>> square = np.zeros((7, 7), dtype=bool) >>> square[1:-1, 2:-2] = 1 >>> square.view(np.uint8) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0]], dtype=uint8) >>> medial_axis(square).view(np.uint8) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
- skimage.morphology.mirror_footprint(footprint)[source]#
在足迹中镜像每个维度。
- 参数:
- footprintndarray 或元组
输入足迹或一系列足迹
- 返回:
- invertedndarray 或 tuple
沿着每个维度镜像的足迹。
示例
>>> footprint = np.array([[0, 0, 0], ... [0, 1, 1], ... [0, 1, 1]], np.uint8) >>> mirror_footprint(footprint) array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=uint8)
- skimage.morphology.octagon(m, n, dtype=<class 'numpy.uint8'>, *, decomposition=None)[source]#
生成八角形形状的足迹。
对于一个给定的水平和垂直边尺寸 (m) 以及斜边给定的 (n) 高度或宽度，会生成八边形。斜边与水平轴成 45 度或 135 度，因此宽度和高度相等。沿单个轴的足迹总体尺寸将为
m + 2 * n。- 参数:
- mint
水平和垂直边长度。
- nint
斜边的高度或宽度。
- 返回:
- footprintndarray 或元组
其邻域中为 1 的元素为 1，否则为 0。当decomposition 为 None 时，它只是一个 numpy.ndarray。否则，它将是一个元组，其长度等于要应用的唯一结构元素数（更多详情，请参见注释）
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- decomposition{None, ‘sequence’}，可选
如果为 None，则返回一个数组。对于“序列”，返回一个小一些的邻域元组。应用这一系列较小的邻域将给出与单个、更大的邻域相同的结果，但具有更好的计算性能。请查看备注获取更多详细信息。
注释
当decomposition 不是 None 时，footprint 元组的每个元素都是一个形式为
(ndarray, num_iter)的 2 元组，用于指定脚印数组和要应用该数组的迭代次数。对于二进制或灰度形态，使用
decomposition='sequence'已观察到具有性能优势，优势幅度会随着邻域大小的增加而增加。
- skimage.morphology.octahedron(radius, dtype=<class 'numpy.uint8'>, *, decomposition=None)[source]#
生成八面体形状的足迹。
这是菱形的 3D 等效项。如果一个像素与此邻域中心之间的城市街区/曼哈顿距离不大于 radius，则此像素属于此邻域（即标记为 1）。
- 参数:
- radius整型
八面体形状足迹的半径。
- 返回:
- footprintndarray 或元组
其邻域中为 1 的元素为 1，否则为 0。当decomposition 为 None 时，它只是一个 numpy.ndarray。否则，它将是一个元组，其长度等于要应用的唯一结构元素数（更多详情，请参见注释）
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- decomposition{None, ‘sequence’}，可选
如果为 None，则返回一个数组。对于“序列”，返回一个小一些的邻域元组。应用这一系列较小的邻域将给出与单个、更大的邻域相同的结果，但具有更好的计算性能。请查看备注获取更多详细信息。
注释
当decomposition 不是 None 时，footprint 元组的每个元素都是一个形式为
(ndarray, num_iter)的 2 元组，用于指定脚印数组和要应用该数组的迭代次数。对于二进制或灰度形态，使用
decomposition='sequence'已观察到具有性能优势，优势幅度会随着邻域大小的增加而增加。
- skimage.morphology.opening(image, footprint=None, out=None, *, mode='reflect', cval=0.0)[source]#
返回图像的灰度形态开操作。
图像的形态学开运算定义为先腐蚀后膨胀。开运算可以去除小亮斑（即“盐”）并连接小暗裂缝。这往往会“打开”（黑暗）特征间的（明亮）间隙。
- 参数:
- imagendarray
图像数组。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- modestr，可选
mode参数决定如何处理数组边框。有效模式为：“reflect”、“constant”、“nearest”、“mirror”、“wrap”、“max”、“min”或“ignore”。如果为“ignore”，则假定图像域外的像素在腐蚀中为图像的 dtype 的最大值，在膨胀中为最小值，这会导致它们不会影响结果。默认值为“reflect”。
- cval标量，可选
如果mode是“constant”，填充输入的过去边缘的值。默认值为 0.0。
在 0.23 版本中添加： mode和cval在 0.23 中添加。
- 返回:
- opening数组，形状和类型与image相同
形态学开运算的结果。
注释
也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。示例
>>> # Open up gap between two bright regions (but also shrink regions) >>> import numpy as np >>> from skimage.morphology import square >>> bad_connection = np.array([[1, 0, 0, 0, 1], ... [1, 1, 0, 1, 1], ... [1, 1, 1, 1, 1], ... [1, 1, 0, 1, 1], ... [1, 0, 0, 0, 1]], dtype=np.uint8) >>> opening(bad_connection, square(3)) array([[0, 0, 0, 0, 0], [1, 1, 0, 1, 1], [1, 1, 0, 1, 1], [1, 1, 0, 1, 1], [0, 0, 0, 0, 0]], dtype=uint8)
- skimage.morphology.pad_footprint(footprint, *, pad_end=True)[source]#
沿着每个维度将足迹填充为奇数尺寸。
- 参数:
- footprintndarray 或元组
输入足迹或一系列足迹
- pad_endbool，可选
如果为
True，在每个维度末端填充（右侧），否则在前端填充（左侧）。
- 返回:
- paddedndarray 或元组
footprint，沿每个维度填充为奇数。
示例
>>> footprint = np.array([[0, 0], ... [1, 1], ... [1, 1]], np.uint8) >>> pad_footprint(footprint) array([[0, 0, 0], [1, 1, 0], [1, 1, 0]], dtype=uint8)
- skimage.morphology.reconstruction(seed, mask, method='dilation', footprint=None, offset=None)[source]#
执行图像的形态重建。
通过膨胀进行形态学重建类似于基本的形态学膨胀：高强度值将替换附近低强度值。但是，基本膨胀算子使用一个轮廓来确定输入图像中的值能够传播多远。相比之下，重建使用两幅图像：一幅“种子图像”，指定传播的值，和一幅“掩模图像”，给出每个像素的最大允许值。掩模图像与轮廓类似，限制了高强度值的传播。通过腐蚀进行重建恰好是相反的过程：低强度值从种子图像中传播并受掩模图像的限制，后者代表最小允许值。
另外，你可以认为重建是为了隔离图像的连接区域。对于膨胀，重建连接由种子图像中的局部最大值标记的区域：小于或等于这些种子的相邻像素连接到种子区域。值大于种子图像的局部最大值将被截断到种子值。
- 参数:
- 种子ndarray
种子图像（也称为标记图像），指定膨胀或腐蚀的值。
- maskndarray
每个像素处允许的最大值（膨胀）/最小值（腐蚀）。
- 方法{‘dilation’|’erosion’}, 选项
通过膨胀或腐蚀执行重建。在膨胀（或腐蚀）中，种子图像会膨胀（或腐蚀），直至受掩模图像限制。对于膨胀，每个种子值必须小于或等于相应的掩模值；对于腐蚀，反之亦然。默认值为“dilation”。
- footprintndarray，可选
以 n 维 1 和 0 数组表示的邻域。默认为半径等于 1 的 n 维正方形（例如，对于 2D 图像为 3x3 正方形，对于 3D 图像为 3x3x3 立方体，依此类推）
- 偏移ndarray, 选项
轮廓中心的坐标。默认位于轮廓的几何中心，在这种情况下，轮廓尺寸必须为奇数。
- 返回:
- 重建ndarray
形态学重建的结果。
注释
该算法取自 [1]。在 [2] 和 [3] 中讨论了灰度重建的应用。
参考资料
[1]罗宾逊，“有效的形态学重建：一个下坡滤波器”，模式识别信件 25（2004）1759-1767。
[2]文森特，L.，“图像分析中的形态学灰度重建：应用和高效算法”，IEEE 图像处理事务（1993）
[3]苏耶，P.，“形态学图像分析：原理和应用”，第 6 章，第 2 版（2003 年），ISBN 3540429883。
示例
>>> import numpy as np >>> from skimage.morphology import reconstruction
首先，我们创建一个正弦掩模图像，其峰值位于中间和末端。
>>> x = np.linspace(0, 4 * np.pi) >>> y_mask = np.cos(x)
接着，我们创建一个种子图像，将其初始化为最小掩码值（用于通过膨胀进行重建，最小强度值不会传播），并在峰值的左峰值和右峰值添加“种子”，但峰值范围在峰值的某个部分 (1)。
>>> y_seed = y_mask.min() * np.ones_like(x) >>> y_seed[0] = 0.5 >>> y_seed[-1] = 0 >>> y_rec = reconstruction(y_seed, y_mask)
重建后的图像（或曲线，在该例中）与掩码图像完全相同，但峰值被截断为 0.5 和 0。中间峰值完全消失：由于此峰值区域中没有种子值，因此其重建后的值被截断为周围值 (-1)。
作为一个更实用的示例，我们尝试通过减去由重建创建的背景图像来提取图像的明亮特征。
>>> y, x = np.mgrid[:20:0.5, :20:0.5] >>> bumps = np.sin(x) + np.sin(y)
要创建背景图像，请将掩码图像设置为原始图像，并将种子图像设置为具有强度偏移量的原始图像，h。
>>> h = 0.3 >>> seed = bumps - h >>> background = reconstruction(seed, bumps)
生成的重建后图像看起来完全像原始图像，但颠簸的峰值被削掉了。从原始图像减去此重建后的图像，只留下颠簸的峰值
>>> hdome = bumps - background
该操作称为图像的 h-dome，并在减后的图像中留下高出 h 的特征。
- skimage.morphology.rectangle(nrows, ncols, dtype=<class 'numpy.uint8'>, *, decomposition=None)[source]#
生成平坦的矩形足迹。
针对给定宽度和给定高度生成的矩形中的每个像素都属于邻域。
- 参数:
- nrowsint
矩形的行数。
- ncolsint
矩形的列数。
- 返回:
- footprintndarray 或元组
仅由 1 组成的足迹，即每个像素都属于邻域。当 decomposition 为 None 时，这只是一个 numpy.ndarray。否则，这将是一个元组，其长度等于要应用的唯一结构元素的数量（有关更多详细信息，请参阅备注）
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- 分解{None, ‘separable’, ‘sequence’}，可选
如果为 None，则返回一个数组。对于“序列”，将返回一个较小足迹的元组。应用这个较小足迹的系列将给出与单个较大足迹相同的结果，但通常具有更好的计算性能。有关更多详细信息，请参阅备注。对于“可分离”，此函数对每个轴使用可分离的 1D 足迹。是“序列”还是“可分离”计算得更快可能依赖架构。
注释
当decomposition 不是 None 时，footprint 元组的每个元素都是一个形式为
(ndarray, num_iter)的 2 元组，用于指定脚印数组和要应用该数组的迭代次数。使用
decomposition='sequence'已观测到对二值形态学的性能有提升，且性能提升的幅度会随着足迹大小的增加而迅速增加。对于具有矩形足迹的灰度形态学，建议您使用decomposition=None，因为所调用的内部 SciPy 函数已采用基于可分离的一维滑动窗口快速实现。sequence 分解模式仅支持奇数的 nrows 和 ncols。如果任一 nrows 或 ncols 为偶数，则所用的序列将与
decomposition='separable'相同。在版本 0.18.0 中弃用了
width和height。请改用nrows和ncols。
- skimage.morphology.remove_objects_by_distance(label_image, min_distance, *, priority=None, p_norm=2, spacing=None, out=None)[source]#
按指定顺序移除对象，直到剩下的对象之间的最小距离。
从图像中移除标记对象，直至剩余对象彼此之间的间隔大于某个给定距离。默认情况下，首先移除较小的对象。
- 参数:
- label_image整数 ndarray
包含对象标记的 n 维数组，例如由
label()返回的对象。零值被视为背景，所有其他对象 ID 必须为正整数。- min_distanceint 或 float
移除距离其他物体不超过此正值的对象。优先级较低的对象将首先被移除。
- priorityndarray，可选
定义移除对象的优先级。需要一个长度为
np.amax(label_image) + 1的一维数组，其中包含各个对象在各自索引处的优先级。值较低的对象将首先被移除，直至所有剩余对象都满足距离要求。如果没有给出，优先级将给予样本数量较多的对象，其次是它们的标签值。- p_normint 或 float，可选
p 阶闵可夫斯基距离，用于计算对象之间的距离。默认
2对应于欧几里德距离，1对应于“曼哈顿”距离，而np.inf对应于切比雪夫距离。- spacingfloat 序列，可选
label_image 中各个轴的像素间距。如果不指定，隐含单位网格间距 (1)。
- outndarray，可选
形状和数据类型与 label_image 相同的数组，其中放置输出。默认情况下，创建一个新数组。
- 返回:
- outndarray
形状与 label_image 相同的数组，其中违反min_distance条件的对象已被移除。
另请参阅
skimage.morphology.remove_small_objects去除小于指定大小的对象。
注释
此算法的基本步骤如下
查找所有给定对象的索引，并根据它们指向的是否为某个对象的边界来对它们进行分离。
按标签值对索引进行排序，确保指向同一对象的索引彼此相邻。此优化程序允许用户只需跨至相邻索引，就能找到对象的所有部分。
按priority对边界索引进行排序。使用稳定排序以保留前一排序步骤中的顺序。如果未给出priority，则使用
numpy.bincount()作为备选方案。根据边界索引构建一个
scipy.spatial.cKDTree。以优先级排序顺序在边界索引间迭代，查询距离过近的 k-d 树对象。将其移除并评估后续其他对象时不再考虑。
此算法性能取决于属于对象边界的 label_image 中的采样数量。
示例
>>> import skimage as ski >>> ski.morphology.remove_objects_by_distance(np.array([2, 0, 1, 1]), 2) array([0, 0, 1, 1]) >>> ski.morphology.remove_objects_by_distance( ... np.array([2, 0, 1, 1]), 2, priority=np.array([0, 1, 9]) ... ) array([2, 0, 0, 0]) >>> label_image = np.array( ... [[8, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9], ... [8, 8, 8, 0, 0, 0, 0, 0, 0, 9, 9], ... [0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0], ... [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... [0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0], ... [2, 0, 0, 0, 0, 1, 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, 7, 7]] ... ) >>> ski.morphology.remove_objects_by_distance( ... label_image, min_distance=3 ... ) array([[8, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9], [8, 8, 8, 0, 0, 0, 0, 0, 0, 9, 9], [0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 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, 7, 7]])
- skimage.morphology.remove_small_holes(ar, area_threshold=64, connectivity=1, *, out=None)[source]#
去除小于指定大小的连续孔洞。
- 参数:
- arndarray（任意形状，int 或 bool 类型）
包含相关联通分量的数组。
- area_thresholdint，可选（默认值：64）
要填补的连续孔洞（以像素为单位）的最大面积。替换 min_size。
- connectivityint，{1, 2, …, ar.ndim}，可选（默认值：1）
定义像素邻域的连通性。
- outndarray
与 ar 形状相同，且 bool 类型数组，输出结果被放入其中。默认情况下，将创建一个新数组。
- 返回:
- outndarray，与输入 ar 相同的形状和类型
已移除关联分量中孔洞的输入数组。
- 引发:
- TypeError
如果输入数组类型无效，例如浮点或字符串。
- ValueError
如果输入数组包含负值。
注释
如果数组类型为 int，则假定其中包含已标记的对象。输出图像中不会保留标签（此函数始终输出 bool 图像）。建议在此函数使用后完成标记。
示例
>>> from skimage import morphology >>> a = np.array([[1, 1, 1, 1, 1, 0], ... [1, 1, 1, 0, 1, 0], ... [1, 0, 0, 1, 1, 0], ... [1, 1, 1, 1, 1, 0]], bool) >>> b = morphology.remove_small_holes(a, 2) >>> b array([[ True, True, True, True, True, False], [ True, True, True, True, True, False], [ True, False, False, True, True, False], [ True, True, True, True, True, False]]) >>> c = morphology.remove_small_holes(a, 2, connectivity=2) >>> c array([[ True, True, True, True, True, False], [ True, True, True, False, True, False], [ True, False, False, True, True, False], [ True, True, True, True, True, False]]) >>> d = morphology.remove_small_holes(a, 2, out=a) >>> d is a True
- skimage.morphology.remove_small_objects(ar, min_size=64, connectivity=1, *, out=None)[源码]#
去除小于指定大小的对象。
期望 ar 是一个带有已标记对象的数组，并移除小于 min_size 的对象。如果 ar 是布尔值，则先给图像贴上标签。这会导致布尔值和 0 与 1 数组产生不同的行为。
- 参数:
- arndarray（任意形状，int 或 bool 类型）
包含关注对象的数组。如果数组类型为 int，则 int 必须是非负数。
- min_sizeint，可选（默认值为：64）
最小允许的对象大小。
- connectivityint，{1, 2, …, ar.ndim}，可选（默认值：1）
定义像素邻域的连接性。如果 ar 为布尔值，则在贴标签期间使用。
- outndarray
与 ar 形状相同的数组，从中放置输出。默认情况下，会创建一个新数组。
- 返回:
- outndarray，与输入 ar 相同的形状和类型
删除了很小的连接组件的输入数组。
- 引发:
- TypeError
如果输入数组类型无效，例如浮点或字符串。
- ValueError
如果输入数组包含负值。
示例
>>> from skimage import morphology >>> a = np.array([[0, 0, 0, 1, 0], ... [1, 1, 1, 0, 0], ... [1, 1, 1, 0, 1]], bool) >>> b = morphology.remove_small_objects(a, 6) >>> b array([[False, False, False, False, False], [ True, True, True, False, False], [ True, True, True, False, False]]) >>> c = morphology.remove_small_objects(a, 7, connectivity=2) >>> c array([[False, False, False, True, False], [ True, True, True, False, False], [ True, True, True, False, False]]) >>> d = morphology.remove_small_objects(a, 6, out=a) >>> d is a True
- skimage.morphology.skeletonize(image, *, method=None)[源码]#
计算二值图像的骨架。
细化用于将二值图像中的每个连接组件缩减为一个单位像素宽的骨架。
- 参数:
- 返回:
- skeletonndarray of bool
细化的图像。
另请参阅
参考资料
[Lee94]T.C. Lee、R.L. Kashyap 和 C.N. Chu，通过 3D 媒体表面/轴细化算法构建骨架模型。计算机视觉、图形和图像处理，56(6):462-478，1994。
[Zha84]细化数字模式的快速并行算法，T. Y. Zhang 和 C. Y. Suen，ACM 通讯，1984 年 3 月，第 27 卷，第 3 期。
示例
>>> X, Y = np.ogrid[0:9, 0:9] >>> ellipse = (1./3 * (X - 4)**2 + (Y - 4)**2 < 3**2).astype(bool) >>> ellipse.view(np.uint8) array([[0, 0, 0, 1, 1, 1, 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, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0]], dtype=uint8) >>> skel = skeletonize(ellipse) >>> skel.view(np.uint8) 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, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 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]], dtype=uint8)
- skimage.morphology.square(width, dtype=<class 'numpy.uint8'>, *, decomposition=None)[source]#
生成平坦的方形足迹。
沿着周边的每个像素都具有一个棋盘格距离，不超过半径（半径=floor(width/2)）像素。
- 参数:
- 宽度int
正方形的宽度和高度。
- 返回:
- footprintndarray 或元组
其邻域中为 1 的元素为 1，否则为 0。当decomposition 为 None 时，它只是一个 numpy.ndarray。否则，它将是一个元组，其长度等于要应用的唯一结构元素数（更多详情，请参见注释）
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- 分解{None, ‘separable’, ‘sequence’}，可选
如果为 None，则返回单个数组。对于‘sequence’，则返回较小的足迹元组。应用此系列较小的足迹将与单个较大的足迹获得相同的结果，但通常具有更好的计算性能。更多详细信息请参阅注释。使用“separable”，此函数为每个轴使用可分离的 1D 足迹。“sequence”或“separable”哪种计算更快可能取决于架构。
注释
当decomposition 不是 None 时，footprint 元组的每个元素都是一个形式为
(ndarray, num_iter)的 2 元组，用于指定脚印数组和要应用该数组的迭代次数。对于二进制形态，观察到使用
decomposition='sequence'或decomposition='separable'的性能优于decomposition=None，性能提升幅度随着足迹大小的增加而迅速增大。对于具有方形足迹的灰度形态，建议使用decomposition=None，因为所调用的内部 SciPy 函数已经基于可分离的 1D 滑动窗口实现了快速实现。“序列”分解模式仅支持奇数width。如果width 为偶数，则使用的序列将与“可分离”模式相同。
- skimage.morphology.star(a, dtype=<class 'numpy.uint8'>)[source]#
生成星形足迹。
Start 具有 8 个顶点，是大小为 2*a + 1 的正方形与其 45 度旋转版本重叠。倾斜的一侧相对于水平轴倾斜 45 或 135 度。
- 参数:
- aint
决定星形结构元素大小的参数。返回的正方形阵列一侧的大小为 2*a + 1 + 2*floor(a / 2)。
- 返回:
- footprintndarray
邻域的元素为 1，否则为 0 的足迹。
- 其他参数:
- dtype数据类型，可选
足迹的数据类型。
- skimage.morphology.thin(image, max_num_iter=None)[source]#
执行二值图像的形态细化。
- 参数:
- image二进制 (M, N) ndarray
需要细化的图像。如果此输入并非已经为二进制图像，它将被转换为二进制图像：在这种情况下，零值被视为背景（False），非零值被视为前景（True）。
- max_num_iterint，迭代次数，可选
无论此参数的值为何，如果某次迭代没有产生变化，将立即返回细化的图像。如果指定此参数，它因此对执行的迭代次数设置了上限。
- 返回:
- out布尔 ndarray
细化的图像。
另请参阅
注释
此算法 [1] 通过多次遍历图像，删除与一组标准相匹配的像素而发挥其作用，此组标准旨在细化连通区域，同时保留八连通组件和 2 x 2 正方形 [2]。在每个两个子迭代中，算法将中间骨架图像与邻域掩码进行关联，然后在查找表中查找每个邻域，该查找表指示在该子迭代中是否应删除中心像素。
参考资料
[1]Z. Guo 和 R. W. Hall，“具有两个子迭代算法的并行细化”，Comm. ACM，第 32 卷，第 3 期，第 359-373 页，1989 年。 DOI:10.1145/62065.62074
[2]Lam、L.、Seong-Whan Lee 和 Ching Y. Suen，“细化方法——全面调查”，IEEE 模式分析和机器智能事务，第 14 卷，第 9 期，第 879 页，1992 年。 DOI:10.1109/34.161346
示例
>>> square = np.zeros((7, 7), dtype=bool) >>> square[1:-1, 2:-2] = 1 >>> square[0, 1] = 1 >>> square.view(np.uint8) array([[0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0]], dtype=uint8) >>> skel = thin(square) >>> skel.view(np.uint8) array([[0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
- skimage.morphology.白顶帽(图像, 足迹=无, 输出=无, *, 模式='反射', cval=0.0)[源代码]#
返回图像的白色礼帽。
图像的白顶帽被定义为图像减去其形态学开运算。此操作返回比足迹小的图像中的亮点。
- 参数:
- imagendarray
图像数组。
- footprintndarray 或 tuple，可选
用 1 和 0 的二维数组表示的邻域。如果为 None，则使用十字形印迹（连接性 = 1）。还可用小型印迹序列的形式提供印迹，如以下注释中所述。
- outndarray，可选
用于存储形态学结果的数组。如果传递 None，则会分配一个新的数组。
- modestr，可选
模式参数确定如何处理数组边框。有效模式为：'reflect'、'constant'、'nearest'、'mirror'、'wrap'、'max'、'min' 或 'ignore'。请参见
skimage.morphology.开运算()。默认值为 'reflect'。- cval标量，可选
如果mode是“constant”，填充输入的过去边缘的值。默认值为 0.0。
在 0.23 版本中添加： mode和cval在 0.23 中添加。
- 返回:
- outarray，与image相同形状和类型
形态学白顶帽的结果。
另请参阅
注释
也可以提供足迹作为由 2 元数组成的序列，其中每个 2 元数组的第一个元素是足迹 ndarray，第二个元素是描述应该迭代该元素的次数的整数。例如
footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)]将应用 9x1 足迹，然后应用 1x9 足迹，产生的净效应与footprint=np.ones((9, 9))相同，但计算成本更低。大多数内置足迹（例如skimage.morphology.disk()）提供了自动生成这种类型的足迹序列的选项。参考资料
示例
>>> # Subtract gray background from bright peak >>> import numpy as np >>> from skimage.morphology import square >>> bright_on_gray = np.array([[2, 3, 3, 3, 2], ... [3, 4, 5, 4, 3], ... [3, 5, 9, 5, 3], ... [3, 4, 5, 4, 3], ... [2, 3, 3, 3, 2]], dtype=np.uint8) >>> white_tophat(bright_on_gray, square(3)) array([[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 1, 5, 1, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0]], dtype=uint8)