`skimage.morphology`#

形态学算法，例如，闭运算、开运算、骨架化。

`area_closing`	执行图像的面积闭运算。
`area_opening`	执行图像的面积开运算。
`ball`	生成球形结构元素。
`binary_closing`	返回图像的快速二值形态学闭运算结果。
`binary_dilation`	返回图像的快速二值形态学膨胀结果。
`binary_erosion`	返回图像的快速二值形态学腐蚀结果。
`binary_opening`	返回图像的快速二值形态学开运算结果。
`black_tophat`	返回图像的黑顶帽变换结果。
`closing`	返回图像的灰度形态学闭运算结果。
`convex_hull_image`	计算二值图像的凸包图像。
`convex_hull_object`	计算二值图像中各个对象的凸包图像。
`diameter_closing`	执行图像的直径闭运算。
`diameter_opening`	执行图像的直径开运算。
`diamond`	生成平坦的菱形结构元素。
`dilation`	返回图像的灰度形态学膨胀结果。
`disk`	生成平坦的圆盘形结构元素。
`ellipse`	生成平坦的椭圆形结构元素。
`erosion`	返回图像的灰度形态学腐蚀结果。
`flood`	对应于漫水填充的掩码。
`flood_fill`	对图像执行漫水填充。
`footprint_from_sequence`	将结构元素序列转换为等效的ndarray。
`footprint_rectangle`	生成矩形或超矩形结构元素。
`h_maxima`	确定图像中所有高度 >= h 的极大值。
`h_minima`	确定图像中所有深度 >= h 的极小值。
`isotropic_closing`	返回图像的二值形态学闭运算结果。
`isotropic_dilation`	返回图像的二值形态学膨胀结果。
`isotropic_erosion`	返回图像的二值形态学腐蚀结果。
`isotropic_opening`	返回图像的二值形态学开运算结果。
`label`	标记整数数组的连通区域。
`local_maxima`	查找n维数组的局部极大值。
`local_minima`	查找n维数组的局部极小值。
`max_tree`	从图像构建最大树。
`max_tree_local_maxima`	确定图像的所有局部极大值。
`medial_axis`	计算二值图像的骨架变换。
`mirror_footprint`	镜像结构元素中的每个维度。
`octagon`	生成八边形结构元素。
`octahedron`	生成八面体形结构元素。
`opening`	返回图像的灰度形态学开运算结果。
`pad_footprint`	将结构元素沿每个维度填充为奇数大小。
`reconstruction`	对图像执行形态学重建。
`remove_objects_by_distance`	按指定顺序移除对象，直到剩余对象之间的最小距离满足要求。
`remove_small_holes`	移除小于指定大小的连续空洞。
`remove_small_objects`	移除小于指定大小的对象。
`skeletonize`	通过细化计算输入图像的骨架。
`star`	生成星形结构元素。
`thin`	对二值图像执行形态学细化。
`white_tophat`	返回图像的白顶帽变换结果。

skimage.morphology.area_closing(image, area_threshold=64, connectivity=1, parent=None, tree_traverser=None)[源代码]#

执行图像的面积闭运算。

面积闭运算会移除图像中所有表面小于 area_threshold 的暗结构。输出图像对于每个像素都大于或等于输入图像，并且所有局部最小值都至少具有 area_threshold 像素的表面积。

面积闭运算类似于形态学闭运算，但它们不使用固定的结构元素，而是使用可变形的结构元素，其表面积 = area_threshold。

在二值情况下，面积闭运算等效于 remove_small_holes；因此，此运算符扩展到灰度图像。

从技术上讲，此运算符基于图像的最大树表示。

参数:

imagendarray: 要计算面积闭运算的输入图像。此图像可以是任何类型。
area_threshold无符号整数: 大小参数（像素数）。默认值任意选择为 64。
connectivity无符号整数，可选: 邻域连通性。整数表示到达邻居的最大正交步数。在 2D 中，4 邻域为 1，8 邻域为 2。默认值为 1。
parentndarray，int64，可选: 表示反转图像最大树的父图像。每个像素的值是其在展开数组中的父级的索引。有关更多详细信息，请参阅注释。
tree_traverser1D 数组，int64，可选: 排序的像素索引（指的是展开数组）。像素的排序方式是，每个像素的前面都是其父级（根节点除外，它没有父级）。

返回:

outputndarray: 与输入图像形状和类型相同的输出图像。

另请参阅

skimage.morphology.area_opening
skimage.morphology.diameter_opening
skimage.morphology.diameter_closing
skimage.morphology.max_tree
skimage.morphology.remove_small_objects
skimage.morphology.remove_small_holes

注释

如果向函数提供最大树表示（parent 和 tree_traverser），则它们必须从此函数的反转图像计算，即：>>> P, S = max_tree(invert(f)) >>> closed = diameter_closing(f, 3, parent=P, tree_traverser=S)

参考文献

[1]

Vincent L., Proc. “Grayscale area openings and closings, their efficient implementation and applications”, EURASIP Workshop on Mathematical Morphology and its Applications to Signal Processing, Barcelona, Spain, pp.22-27, May 1993.

[2]

Soille, P., “Morphological Image Analysis: Principles and Applications” (Chapter 6), 2nd edition (2003), ISBN 3540429883. DOI:10.1007/978-3-662-05088-0

[3]

Salembier, P., Oliveras, A., & Garrido, L. (1998). Antiextensive Connected Operators for Image and Sequence Processing. IEEE Transactions on Image Processing, 7(4), 555-570. DOI:10.1109/83.663500

[4]

Najman, L., & Couprie, M. (2006). Building the component tree in quasi-linear time. IEEE Transactions on Image Processing, 15(11), 3531-3539. DOI:10.1109/TIP.2006.877518

[5]

Carlinet, E., & Geraud, T. (2014). A Comparative Review of Component Tree Computation Algorithms. IEEE Transactions on Image Processing, 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)[源代码]#

执行图像的面积开运算。

区域开运算会移除图像中表面积小于 area_threshold 的所有明亮结构。因此，输出图像是小于输入图像的最大图像，其中所有局部最大值的表面积都至少为 area_threshold 像素。

区域开运算类似于形态学开运算，但它们不使用固定的足迹，而是使用可变形的足迹，其表面积 = area_threshold。因此，area_threshold=1 的区域开运算是恒等运算。

在二值图像的情况下，区域开运算等效于 remove_small_objects；因此，此算子扩展到灰度图像。

从技术上讲，此运算符基于图像的最大树表示。

参数:

imagendarray: 要计算区域开运算的输入图像。此图像可以是任何类型。
area_threshold无符号整数: 大小参数（像素数）。默认值任意选择为 64。
connectivity无符号整数，可选: 邻域连通性。整数表示到达邻居的最大正交步数。在 2D 中，4 邻域为 1，8 邻域为 2。默认值为 1。
parentndarray，int64，可选: 表示图像最大树的父图像。每个像素的值是其在扁平数组中的父索引。
tree_traverser1D 数组，int64，可选: 排序的像素索引（指的是展开数组）。像素的排序方式是，每个像素的前面都是其父级（根节点除外，它没有父级）。

返回:

outputndarray: 与输入图像形状和类型相同的输出图像。

另请参阅

skimage.morphology.area_closing
skimage.morphology.diameter_opening
skimage.morphology.diameter_closing
skimage.morphology.max_tree
skimage.morphology.remove_small_objects
skimage.morphology.remove_small_holes

参考文献

[1]

Vincent L., Proc. “Grayscale area openings and closings, their efficient implementation and applications”, EURASIP Workshop on Mathematical Morphology and its Applications to Signal Processing, Barcelona, Spain, pp.22-27, May 1993.

[2]

Soille, P., “Morphological Image Analysis: Principles and Applications” (Chapter 6), 2nd edition (2003), ISBN 3540429883. DOI:10.1007/978-3-662-05088-0

[3]

Salembier, P., Oliveras, A., & Garrido, L. (1998). Antiextensive Connected Operators for Image and Sequence Processing. IEEE Transactions on Image Processing, 7(4), 555-570. DOI:10.1109/83.663500

[4]

Najman, L., & Couprie, M. (2006). Building the component tree in quasi-linear time. IEEE Transactions on Image Processing, 15(11), 3531-3539. DOI:10.1109/TIP.2006.877518

[5]

Carlinet, E., & Geraud, T. (2014). A Comparative Review of Component Tree Computation Algorithms. IEEE Transactions on Image Processing, 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 等效物。如果像素与原点之间的欧几里得距离不大于半径，则该像素位于邻域内。

参数:

radiusfloat: 球形足迹的半径。

返回:

footprintndarray 或 tuple: 邻域元素为 1，否则为 0 的足迹。

其他参数:

dtype数据类型，可选: 足迹的数据类型。
strict_radiusbool，可选: 如果为 False，则将半径延长 0.5。这允许圆在沿每个轴尺寸仍为 2 * radius + 1 的立方体内进一步扩展。如果 decomposition 不为 None，则忽略此参数。
decomposition{None, ‘sequence’}, 可选: 如果为 None，则返回单个数组。对于 ‘sequence’，将返回较小足迹的元组。应用这一系列较小的足迹将得到与单个较大足迹等效的结果，但具有更好的计算性能。对于球形足迹，序列分解与 decomposition=None 不完全等效。有关更多详细信息，请参见“注释”。

注释

通过 decomposition='sequence' 模式生成的圆盘与 decomposition=None 的圆盘不相同。在这里，我们将 [1] 中针对圆盘采用的方法扩展到 3D 情况，使用该出版物中“正方形”、“菱形”和“T 形”元素的 3 维扩展。所有这些基本元素的大小均为 (3,) * ndim。我们数值计算了每个元素的重复次数，这些重复次数给出的结果与使用 kwargs strict_radius=False, decomposition=None 计算的球最接近。

根据经验，序列分解的等效复合足迹接近菱形二十面体（26 个面 [2]）。

参考文献

[1]

Park, H and Chin R.T. Decomposition of structuring elements for optimal implementation of morphological operations. In Proceedings: 1997 IEEE Workshop on Nonlinear Signal and Image Processing, London, UK. https://www.iwaenc.org/proceedings/1997/nsip97/pdf/scan/ns970226.pdf

[2]

https://en.wikipedia.org/wiki/Rhombicuboctahedron

skimage.morphology.binary_closing(image, footprint=None, out=None, *, mode='ignore')[source]#

返回图像的快速二值形态学闭运算结果。

此函数返回与灰度闭运算相同的结果，但对二值图像执行速度更快。

图像的形态学闭运算定义为先膨胀后腐蚀。闭运算可以去除小的暗点（即“胡椒”）并连接小的明亮裂缝。这往往会“闭合”特征之间的（暗）间隙。

参数:

imagendarray: 二值输入图像。
footprintndarray 或 tuple，可选: 表示为 1 和 0 的二维数组的邻域。如果为 None，则使用十字形足迹（connectivity=1）。也可以按以下注释中所述，将足迹作为较小足迹的序列提供。
outbool 的 ndarray，可选: 用于存储形态学结果的数组。如果传递 None，将分配一个新数组。
modestr，可选: mode 参数确定如何处理数组边界。有效模式为：“max”、“min”、“ignore”。如果为“ignore”，则假设图像域外的像素对于腐蚀为 True，对于膨胀为 False，这会导致它们不影响结果。默认为“ignore”。

在 0.23 版本中添加：mode 在 0.23 中添加。

返回:

closingbool 的 ndarray: 形态学闭运算的结果。

另请参阅

skimage.morphology.isotropic_closing

注释

足迹也可以作为 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，则使用十字形足迹（connectivity=1）。也可以按以下注释中所述，将足迹作为较小足迹的序列提供。
outbool 的 ndarray，可选: 用于存储形态学结果的数组。如果传递 None，将分配一个新数组。
modestr，可选: mode 参数确定如何处理数组边界。有效模式为：“max”、“min”、“ignore”。如果为“min”或“ignore”，则假设图像域外的像素为 False，这会导致它们不影响结果。默认为“ignore”。

在 0.23 版本中添加：mode 在 0.23 中添加。

返回:

dilatedbool 或 uint 的 ndarray: 形态学膨胀的结果，其值在 [False, True] 中。

另请参阅

skimage.morphology.isotropic_dilation

注释

足迹也可以作为 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，则使用十字形足迹（connectivity=1）。也可以按以下注释中所述，将足迹作为较小足迹的序列提供。
outbool 的 ndarray，可选: 用于存储形态学结果的数组。如果传递 None，将分配一个新数组。
modestr，可选: mode 参数决定如何处理数组边界。有效模式为：'max'、'min'、'ignore'。如果为 'max' 或 'ignore'，则假设图像域之外的像素为 True，这会导致它们不影响结果。默认为 'ignore'。

在 0.23 版本中添加：mode 在 0.23 中添加。

返回:

腐蚀结果bool 或 uint 的 ndarray: 形态学腐蚀的结果，取值范围为 [False, True]。

另请参阅

skimage.morphology.isotropic_erosion

注释

足迹也可以作为 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')[source]#

返回图像的快速二值形态学开运算结果。

此函数返回与灰度开运算相同的结果，但对于二值图像执行速度更快。

图像的形态学开运算定义为先腐蚀后膨胀。开运算可以去除小的亮点（即“盐”）并连接小的暗裂缝。这倾向于“打开”（暗）特征之间的间隙。

参数:

imagendarray: 二值输入图像。
footprintndarray 或 tuple，可选: 表示为 1 和 0 的二维数组的邻域。如果为 None，则使用十字形足迹（connectivity=1）。也可以按以下注释中所述，将足迹作为较小足迹的序列提供。
outbool 的 ndarray，可选: 用于存储形态学结果的数组。如果传递 None，将分配一个新数组。
modestr，可选: mode 参数确定如何处理数组边界。有效模式为：“max”、“min”、“ignore”。如果为“ignore”，则假设图像域外的像素对于腐蚀为 True，对于膨胀为 False，这会导致它们不影响结果。默认为“ignore”。

在 0.23 版本中添加：mode 在 0.23 中添加。

返回:

开运算结果bool 的 ndarray: 形态学开运算的结果。

另请参阅

skimage.morphology.isotropic_opening

注释

足迹也可以作为 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)[source]#

返回图像的黑顶帽变换结果。

图像的黑顶帽定义为其形态学闭运算减去原始图像。此操作返回图像中比足迹小的暗点。请注意，原始图像中的暗点在黑顶帽之后是亮点。

参数:

imagendarray: 图像数组。
footprintndarray 或 tuple，可选: 表示为 1 和 0 的二维数组的邻域。如果为 None，则使用十字形足迹（connectivity=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 中添加。

返回:

out数组，与 image 具有相同的形状和类型: 形态学黑顶帽的结果。

另请参阅

white_tophat

注释

足迹也可以作为 2 元组的序列提供，其中每个 2 元组的第一个元素是足迹 ndarray，第二个元素是描述应迭代次数的整数。例如，footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)] 将应用一个 9x1 足迹，然后应用一个 1x9 足迹，最终效果与 footprint=np.ones((9, 9)) 相同，但计算成本较低。大多数内置足迹（例如 skimage.morphology.disk()）都提供一个选项来自动生成这种类型的足迹序列。

参考文献

[1]

https://en.wikipedia.org/wiki/Top-hat_transform

示例

>>> # Change dark peak to bright peak and subtract background
>>> import numpy as np
>>> from skimage.morphology import footprint_rectangle
>>> 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, footprint_rectangle((3, 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，则使用十字形足迹（connectivity=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 中添加。

返回:

闭运算结果数组，与 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 footprint_rectangle
>>> 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, footprint_rectangle((3, 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]#

计算二值图像的凸包图像。

凸包是包含在围绕输入图像中所有白色像素的最小凸多边形中的一组像素。

参数:

image数组: 二值输入图像。此数组在处理之前被转换为 bool。
offset_coordinatesbool，可选: 如果为 True，则坐标处的像素（例如，(4, 7)）将由坐标 (3.5, 7)、(4.5, 7)、(4, 6.5) 和 (4, 7.5) 表示。这在计算凸包时为像素添加了一些“范围”。
tolerancefloat，可选: 确定点是否在凸包内部时的容差。由于数值浮点错误，容差为 0 可能导致某些点被错误地分类为在凸包外部。
include_borders: bool，可选: 如果为 False，则最终凸包掩码中将排除顶点/边。

返回:

hull(M, N) bool 数组: 凸包中像素设置为 True 的二值图像。

参考文献

[1]

https://blogs.mathworks.com/steve/2011/10/04/binary-image-convex-hull-algorithm-notes/

凸包

形态学滤波

skimage.morphology.convex_hull_object(image, *, connectivity=2)[source]#

计算二值图像中各个对象的凸包图像。

凸包是包含在围绕输入图像中所有白色像素的最小凸多边形中的一组像素。

参数:

image(M, N) ndarray

二值输入图像。

connectivity{1, 2}, int, optional

确定每个像素的邻居。距像素中心平方距离在 connectivity 内的相邻元素被认为是邻居。

1-connectivity      2-connectivity
      [ ]           [ ]  [ ]  [ ]
       |               \  |  /
 [ ]--[x]--[ ]      [ ]--[x]--[ ]
       |               /  |  \
      [ ]           [ ]  [ ]  [ ]

返回:

hullbool 的 ndarray: 二值图像，凸包内的像素设置为 True。

注释

此函数使用 skimage.morphology.label 定义唯一对象，使用 convex_hull_image 查找每个对象的凸包，并通过逻辑 OR 组合这些区域。请注意，不相连的对象的凸包可能会在结果中重叠。如果怀疑出现这种情况，请考虑分别对每个对象使用 convex_hull_image 或调整 connectivity。

skimage.morphology.diameter_closing(image, diameter_threshold=8, connectivity=1, parent=None, tree_traverser=None)[source]#

执行图像的直径闭运算。

直径闭合会移除图像中最大延伸小于 diameter_threshold 的所有暗结构。最大延伸定义为边界框的最大延伸。此算子也称为边界框闭合。实际上，结果类似于形态学闭合，但不会移除长而细的结构。

从技术上讲，此运算符基于图像的最大树表示。

参数:

imagendarray: 要计算直径闭合的输入图像。此图像可以是任何类型。
diameter_threshold无符号整数: 最大延伸参数（像素数）。默认值为 8。
connectivity无符号整数，可选: 邻域连通性。整数表示到达邻居的最大正交步数。在 2D 中，4 邻域为 1，8 邻域为 2。默认值为 1。
parentndarray，int64，可选: 预先计算的父图像，表示反转图像的最大树。如果提供了预先计算的父级和 tree_traverser，则此函数会很快。有关更多详细信息，请参见注意。
tree_traverser1D 数组，int64，可选: 预先计算的遍历器，其中像素的顺序使得每个像素在其父级之前（除了没有父级的根像素）。如果提供了预先计算的父级和 tree_traverser，则此函数会很快。有关更多详细信息，请参见注意。

返回:

outputndarray: 与输入图像形状和类型相同的输出图像。

另请参阅

skimage.morphology.area_opening
skimage.morphology.area_closing
skimage.morphology.diameter_opening
skimage.morphology.max_tree

注释

如果向函数提供最大树表示（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). 通过边界框闭合自动检测人视网膜彩色眼底图像中的微动脉瘤。在 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). A Comparative Review of Component Tree Computation Algorithms. IEEE Transactions on Image Processing, 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 = 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_threshold无符号整数: 最大延伸参数（像素数）。默认值为 8。
connectivity无符号整数，可选: 邻域连通性。整数表示到达邻居的最大正交步数。在 2D 中，4 邻域为 1，8 邻域为 2。默认值为 1。
parentndarray，int64，可选: 表示图像最大树的父图像。每个像素的值是其在扁平数组中的父索引。
tree_traverser1D 数组，int64，可选: 排序的像素索引（指的是展开数组）。像素的排序方式是，每个像素的前面都是其父级（根节点除外，它没有父级）。

返回:

outputndarray: 与输入图像形状和类型相同的输出图像。

另请参阅

skimage.morphology.area_opening
skimage.morphology.area_closing
skimage.morphology.diameter_closing
skimage.morphology.max_tree

参考文献

[1]

Walter, T., & Klein, J.-C. (2002). 通过边界框闭合自动检测人视网膜彩色眼底图像中的微动脉瘤。在 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). A Comparative Review of Component Tree Computation Algorithms. IEEE Transactions on Image Processing, 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]#

生成平坦的菱形结构元素。

如果像素与邻域中心的城市街区/曼哈顿距离不大于半径，则该像素是邻域的一部分（即标记为 1）。

参数:

radius整数: 菱形足迹的半径。

返回:

footprintndarray 或 tuple: 邻域元素为 1，其他元素为 0 的足迹。当 decomposition 为 None 时，这只是一个 numpy.ndarray。否则，这将是一个元组，其长度等于要应用的唯一结构元素的数量（有关更多详细信息，请参见注释）

其他参数:

dtype数据类型，可选: 足迹的数据类型。
decomposition{None, ‘sequence’}, 可选: 如果为 None，则返回单个数组。对于“sequence”，则返回较小足迹的元组。应用这一系列较小的足迹将产生与单个较大足迹相同的结果，但具有更好的计算性能。有关更多详细信息，请参见注释。

注释

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

返回图像的灰度形态学膨胀结果。

形态学膨胀将像素的值设置为以其为中心的局部邻域内的所有像素值的最大值。足迹为 1 的值定义了此邻域。膨胀会扩大亮区域并缩小暗区域。

参数:

imagendarray: 图像数组。
footprintndarray 或 tuple，可选: 表示为 1 和 0 的二维数组的邻域。如果为 None，则使用十字形足迹（connectivity=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() 函数对于较大的图像和足迹更有效。

足迹也可以作为 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 footprint_rectangle
>>> 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, footprint_rectangle((3, 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' 时，此值才近似为 True）。

参数:

radius整数: 磁盘形足迹的半径。

返回:

footprintndarray: 邻域元素为 1，否则为 0 的足迹。

其他参数:

dtype数据类型，可选: 足迹的数据类型。
strict_radiusbool，可选: 如果为 False，则将半径延长 0.5。这允许圆在沿每个轴尺寸仍为 2 * radius + 1 的立方体内进一步扩展。如果 decomposition 不为 None，则忽略此参数。
decomposition{None, ‘sequence’, ‘crosses’}, 可选: 如果为 None，则返回单个数组。对于“sequence”，则返回较小足迹的元组。应用这一系列较小的足迹将产生与单个较大足迹等效的结果，但具有更好的计算性能。对于磁盘足迹，“sequence”或“crosses”分解并不总是与 decomposition=None 完全等效。有关更多详细信息，请参见注释。

注释

当 decomposition 不为 None 时，footprint 元组的每个元素都是 (ndarray, num_iter) 形式的 2 元组，它指定了足迹数组及其要应用的迭代次数。

decomposition='sequence' 模式产生的磁盘可能与 decomposition=None 的磁盘不完全相同。磁盘足迹可以通过沿每个轴应用一系列范围为 3 的较小足迹来近似。 [1] 中给出了半径为 2 到 10 的 2D 磁盘的具体解决方案。在此处，我们以数值方式计算了每个元素的重复次数，该重复次数与使用 kwargs strict_radius=False, decomposition=None 计算的磁盘最匹配。

根据经验，大半径的序列分解接近于十六边形（一个 16 边的多边形[2]）。在[3]中，作者证明十六边形是使用形状为 (3, 3) 的足迹进行分解时可以实现的与磁盘最接近的近似值。

decomposition='crosses' 产生的磁盘通常但不总是与 decomposition=None 的磁盘相同。它往往比 decomposition='sequence' 给出更接近的近似值，并且性能相当。单个十字形元素的尺寸不限于范围 (3, 3)。与“sequence”分解不同，“crosses”分解还可以准确地近似使用 strict_radius=True 的磁盘形状。该方法基于对[4] 中给出的算法 1 的修改。

参考文献

[1]

Park, H and Chin R.T. Decomposition of structuring elements for optimal implementation of morphological operations. In Proceedings: 1997 IEEE Workshop on Nonlinear Signal and Image Processing, London, UK. https://www.iwaenc.org/proceedings/1997/nsip97/pdf/scan/ns970226.pdf

[2]

https://en.wikipedia.org/wiki/Hexadecagon

[3]

Vanrell, M and Vitrià, J. 用于形态变换的最佳 3 × 3 可分解磁盘。Image and Vision Computing, Vol. 15, Issue 11, 1997. DOI:10.1016/S0262-8856(97)00026-7

[4]

Li, D. 和 Ritter, G.X. 可分离和对称凸模板的分解。SPIE 会议论文集 1350, 图像代数和形态图像处理，(1990 年 11 月 1 日)。DOI:10.1117/12.23608

skimage.morphology.ellipse(width, height, dtype=<class 'numpy.uint8'>, *, decomposition=None)[源代码]#

生成平坦的椭圆形结构元素。

椭圆周长上的每个像素都满足方程 (x/width+1)**2 + (y/height+1)**2 = 1。

参数:

widthint: 椭圆形足迹的宽度。
heightint: 椭圆形足迹的高度。

返回:

footprintndarray: 邻域元素为 1，否则为 0 的足迹。足迹的形状为 (2 * height + 1, 2 * width + 1)。

其他参数:

dtype数据类型，可选: 足迹的数据类型。
decomposition{None, ‘crosses’}, optional: 如果为 None，则返回单个数组。对于“sequence”，则返回较小足迹的元组。应用这一系列较小的足迹将产生与单个较大足迹相同的结果，但具有更好的计算性能。有关更多详细信息，请参见注释。

注释

当 decomposition 不为 None 时，footprint 元组的每个元素都是 (ndarray, num_iter) 形式的 2 元组，它指定了足迹数组及其要应用的迭代次数。

decomposition='crosses' 生成的椭圆通常（但并非总是）与 decomposition=None 生成的椭圆相同。该方法基于 [1] 中给出的算法 1 的改编。

参考文献

[1]

Li, D. 和 Ritter, G.X. 可分离和对称凸模板的分解。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)[源代码]#

返回图像的灰度形态学腐蚀结果。

形态学腐蚀将 (i,j) 处的像素设置为以 (i,j) 为中心的邻域中所有像素的最小值。腐蚀会缩小明亮区域并扩大黑暗区域。

参数:

imagendarray: 图像数组。
footprintndarray 或 tuple，可选: 表示为 1 和 0 的二维数组的邻域。如果为 None，则使用十字形足迹（connectivity=1）。也可以按以下注释中所述，将足迹作为较小足迹的序列提供。
outndarrays，可选: 用于存储形态学结果的数组。如果传递 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 中添加。

返回:

eroded数组，与 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 footprint_rectangle
>>> 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, footprint_rectangle((3, 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)[源代码]#

对应于漫水填充的掩码。

从特定的 seed_point 开始，找到与种子值相等或在 tolerance 范围内的连接点。

参数:

imagendarray: 一个 n 维数组。
seed_point元组或整数: 在 image 中用作洪水填充起点的点。如果图像是一维的，则此点可以作为整数给出。
footprintndarray，可选: 用于确定每个评估像素的邻域的足迹（结构元素）。它必须仅包含 1 和 0，并且与 image 具有相同的维数。如果未给出，则所有相邻像素都将视为邻域的一部分（完全连接）。
connectivity整数，可选: 一个用于确定每个评估像素的邻域的数字。与中心的平方距离小于或等于 connectivity 的相邻像素被视为邻居。如果 footprint 不为 None，则忽略。
tolerance浮点数或整数，可选: 如果为 None（默认值），则相邻值必须严格等于 seed_point 处 image 的初始值。这是最快的。如果给出一个值，则将在每个点进行比较，如果与初始值的偏差在容差范围内，则也会填充（包括）。

返回:

maskndarray: 返回一个与 image 形状相同的布尔数组，其中与种子点连接且相等（或在容差范围内）的区域为 True 值。所有其他值为 False。

注释

此操作的概念类比是许多栅格图形程序中的“油漆桶”工具。此函数仅返回表示填充的掩码。

如果出于内存原因需要索引而不是掩码，则用户可以简单地在结果上运行 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 填充连接的 1，具有完全连接性（包括对角线）

>>> 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，不包括对角线点（连接性 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=None, connectivity=None, tolerance=None, in_place=False)[源代码]#

对图像执行漫水填充。

从特定的 seed_point 开始，找到与种子值相等或在 tolerance 范围内的连接点，然后将其设置为 new_value。

参数:

imagendarray: 一个 n 维数组。
seed_point元组或整数: 在 image 中用作洪水填充起点的点。如果图像是一维的，则此点可以作为整数给出。
new_valueimage 类型: 设置整个填充的新值。必须根据 image 的 dtype 选择此值。
footprintndarray，可选: 用于确定每个评估像素的邻域的足迹（结构元素）。它必须仅包含 1 和 0，并且与 image 具有相同的维数。如果未给出，则所有相邻像素都将视为邻域的一部分（完全连接）。
connectivity整数，可选: 一个用于确定每个评估像素的邻域的数字。与中心的平方距离小于或等于 connectivity 的相邻像素被视为邻居。如果 footprint 不为 None，则忽略。
tolerance浮点数或整数，可选: 如果为 None（默认值），则相邻值必须严格等于 seed_point 处的 image 的值才能进行填充。这是最快的。如果提供了容差，则会填充与种子点的偏差在正负容差范围内的相邻点（包括）。
in_place布尔值，可选: 如果为 True，则将洪水填充就地应用于 image。如果为 False，则返回洪水填充的结果，而不修改输入 image（默认值）。

返回:

filledndarray: 返回一个与 image 形状相同的数组，其中与种子点连接且相等（或在容差范围内）的区域中的值将替换为 new_value。

注释

此操作的概念类比是许多栅格图形程序中的“油漆桶”工具。

示例

>>> 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 填充连接的 1，具有完全连接性（包括对角线）

>>> 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，不包括对角线点（连接性 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)[源代码]#

将结构元素序列转换为等效的ndarray。

参数:

footprints2 元组的元组: 足迹元组序列，其中每个元组的第一个元素是对应于足迹的数组，第二个元素是要应用它的次数。目前，所有足迹都应具有奇数大小。

返回:

footprintndarray: 一个等效于应用 footprints 序列的单数组。

分解平面足迹（结构元素）

skimage.morphology.footprint_rectangle(shape, *, dtype=<class 'numpy.uint8'>, decomposition=None)[源代码]#

生成矩形或超矩形结构元素。

根据请求的长度和维度，使用 shape 生成正方形、矩形、立方体、长方体，甚至是这些形状的更高维度版本。

参数:

shapetuple[int, …]: 每个维度上的足迹长度。序列的长度决定了足迹的维度数量。
dtype数据类型，可选: 足迹的数据类型。
decomposition{None, ‘separable’, ‘sequence’}, optional: 如果为 None，则返回单个数组。对于 ‘sequence’，返回较小的足迹元组。应用这一系列较小的足迹将产生与单个较大足迹相同的结果，但通常具有更好的计算性能。有关更多详细信息，请参阅“注释”。对于 ‘separable’，此函数为每个轴使用可分离的 1D 足迹。‘sequence’ 或 ‘separable’ 在计算上更快可能取决于架构。

返回:

footprintarray 或 tuple[tuple[ndarray, int], …]: 一个仅由 1 组成的足迹，即每个像素都属于邻域。当 decomposition 为 None 时，这只是一个数组。否则，这将是一个元组，其长度等于要应用的唯一结构元素的数量（有关更多详细信息，请参阅“示例”）。

示例

>>> import skimage as ski
>>> ski.morphology.footprint_rectangle((3, 5))
array([[1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1]], dtype=uint8)

分解将返回多个足迹，这些足迹组合成请求形状的简单足迹。

>>> ski.morphology.footprint_rectangle((9, 9), decomposition="sequence")
((array([[1, 1, 1],
         [1, 1, 1],
         [1, 1, 1]], dtype=uint8),
  4),)

"sequence" 确保分解仅返回 1D 足迹。

>>> ski.morphology.footprint_rectangle((3, 5), decomposition="separable")
((array([[1],
         [1],
         [1]], dtype=uint8),
  1),
 (array([[1, 1, 1, 1, 1]], dtype=uint8), 1))

生成一个在每个维度上有 3 个样本的 5 维超立方体

>>> ski.morphology.footprint_rectangle((3,) * 5).shape
(3, 3, 3, 3, 3)

生成足迹（结构元素）

分解平面足迹（结构元素）

标记图像区域

skimage.morphology.h_maxima(image, h, footprint=None)[源代码]#

确定图像中所有高度 >= h 的极大值。

局部最大值定义为具有相等等级且严格大于该集合直接邻域中所有像素的灰度级的像素的连接集。

高度为 h 的局部最大值 M 是一个局部最大值，对于该局部最大值，至少存在一条将 M 与相等或更高的局部最大值连接的路径，在该路径上，最小值是 f(M) - h（即沿路径的值相对于最大值而言不会减小超过 h），并且没有通往相等或更高局部最大值的路径，其中最小值更大。

此函数还会找到图像的全局最大值。

参数:

imagendarray: 要计算最大值的输入图像。
h无符号整数: 所有提取的最大值的最小高度。
footprintndarray，可选: 以 1 和 0 的 n 维数组表示的邻域。默认值是根据最大范数（即 2D 图像为 3x3 正方形，3D 图像为 3x3x3 立方体等）的半径为 1 的球。

返回:

h_maxndarray: 高度 >= h 的局部最大值和全局最大值。结果图像是二进制图像，其中属于确定的最大值的像素的值为 1，其他像素的值为 0。

另请参阅

skimage.morphology.h_minima
skimage.morphology.local_maxima
skimage.morphology.local_minima

参考文献

[1]

Soille, P., “形态学图像分析：原理与应用”（第 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)[源代码]#

确定图像中所有深度 >= h 的极小值。

局部最小值定义为具有相等等级且严格小于该集合直接邻域中所有像素的灰度级的像素的连接集。

深度为 h 的局部最小值 M 是一个局部最小值，对于该局部最小值，至少存在一条将 M 与相等或更低的局部最小值连接的路径，在该路径上，最大值是 f(M) + h（即沿路径的值相对于最小值而言不会增加超过 h），并且没有通往相等或更低局部最小值的路径，其中最大值更小。

此函数还会找到图像的全局最小值。

参数:

imagendarray: 要计算最小值的输入图像。
h无符号整数: 所有提取的最小值的最小深度。
footprintndarray，可选: 以 1 和 0 的 n 维数组表示的邻域。默认值是根据最大范数（即 2D 图像为 3x3 正方形，3D 图像为 3x3x3 立方体等）的半径为 1 的球。

返回:

h_minndarray: 深度 >= h 的局部最小值和全局最小值。结果图像是二进制图像，其中属于确定的最小值的像素的值为 1，其他像素的值为 0。

另请参阅

skimage.morphology.h_maxima
skimage.morphology.local_maxima
skimage.morphology.local_minima

参考文献

[1]

Soille, P., “形态学图像分析：原理与应用”（第 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]来实现的。该实现基于：func:scipy.ndimage.distance_transform_edt。

参数:

imagendarray: 二值输入图像。
radiusfloat: 应该闭合区域的半径。
outbool 的 ndarray，可选: 用于存储形态学结果的数组。如果传递 None，将分配一个新数组。
spacingfloat，或 float 序列，可选: 沿每个维度的元素的间距。如果是一个序列，则长度必须等于输入的维度（轴数）。如果是一个数字，则此值用于所有轴。如果未指定，则表示单位网格间距。

返回:

closed布尔值的 ndarray: 形态学闭运算的结果。

参考文献

[1]

Cuisenaire, O. 和 Macq, B., “使用局部距离传播转换的快速欧几里得形态学算子及应用”，图像处理及其应用，1999 年。第七届国际会议（会议出版物编号 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: 应该膨胀区域的半径。
outbool 的 ndarray，可选: 用于存储形态学结果的数组。如果传递 None，将分配一个新数组。
spacingfloat，或 float 序列，可选: 沿每个维度的元素的间距。如果是一个序列，则长度必须等于输入的维度（轴数）。如果是一个数字，则此值用于所有轴。如果未指定，则表示单位网格间距。

返回:

dilated布尔值的 ndarray: 形态学膨胀的结果，其值在 [False, True] 中。

参考文献

[1]

Cuisenaire, O. 和 Macq, B., “使用局部距离传播转换的快速欧几里得形态学算子及应用”，图像处理及其应用，1999 年。第七届国际会议（会议出版物编号 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: 应该腐蚀区域的半径。
outbool 的 ndarray，可选: 用于存储形态学结果的数组。如果为 None，则将分配一个新数组。
spacingfloat，或 float 序列，可选: 沿每个维度的元素的间距。如果是一个序列，则长度必须等于输入的维度（轴数）。如果是一个数字，则此值用于所有轴。如果未指定，则表示单位网格间距。

返回:

eroded布尔值的 ndarray: 形态学腐蚀的结果，取值范围为 [False, True]。

参考文献

[1]

Cuisenaire, O. 和 Macq, B., “使用局部距离传播转换的快速欧几里得形态学算子及应用”，图像处理及其应用，1999 年。第七届国际会议（会议出版物编号 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() 相同的结果，但对于大型圆形结构元素执行速度更快。它的工作原理是对精确的欧几里得距离图进行阈值处理 [1], [2]。该实现基于：func:scipy.ndimage.distance_transform_edt。

参数:

imagendarray: 二值输入图像。
radiusfloat: 区域应被开运算的半径。
outbool 的 ndarray，可选: 用于存储形态学结果的数组。如果传递 None，将分配一个新数组。
spacingfloat，或 float 序列，可选: 沿每个维度的元素的间距。如果是一个序列，则长度必须等于输入的维度（轴数）。如果是一个数字，则此值用于所有轴。如果未指定，则表示单位网格间距。

返回:

opened布尔型 ndarray: 形态学开运算的结果。

参考文献

[1]

Cuisenaire, O. 和 Macq, B., “使用局部距离传播转换的快速欧几里得形态学算子及应用”，图像处理及其应用，1999 年。第七届国际会议（会议出版物编号 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_imageint 类型的 ndarray: 要标记的图像。
backgroundint, 可选: 将所有具有此值的像素视为背景像素，并将它们标记为 0。默认情况下，将 0 值像素视为背景像素。
return_numbool, 可选: 是否返回分配的标签数。
connectivity整数，可选: 将像素/体素视为邻居的最大正交跳数。接受的值范围为 1 到 input.ndim。如果 None，则使用 input.ndim 的完整连接。

返回:

labelsint 类型的 ndarray: 标记数组，其中所有连通区域都分配了相同的整数值。
numint, 可选: 标签数，等于最大标签索引，只有当 return_num 为 True 时才返回。

另请参阅

skimage.measure.regionprops
skimage.measure.regionprops_table

参考文献

[1]

Christophe Fiorio 和 Jens Gustedt，“用于图像处理的两种线性时间 Union-Find 策略”，《理论计算机科学》154 (1996)，第 165-181 页。

[2]

Kensheng Wu、Ekow Otoo 和 Arie Shoshani，“优化连通分量标记算法”，论文 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，则将所有相邻像素视为邻域的一部分。
connectivity整数，可选: 一个用于确定每个评估像素的邻域的数字。与中心的平方距离小于或等于 connectivity 的相邻像素被视为邻居。如果 footprint 不为 None，则忽略。
indicesbool, 可选: 如果为 True，则输出将是一个一维数组的元组，表示每个维度中局部最大值的索引。如果为 False，则输出将是与 image 形状相同的布尔数组。
allow_bordersbool, 可选: 如果为 true，则接触图像边界的平台是有效的最大值。

返回:

maximandarray 或 tuple[ndarray]: 如果 indices 为 false，则返回一个与 image 形状相同的布尔数组，其中 True 表示局部最大值的位置（否则为 False）。如果 indices 为 true，则返回一个包含所有找到的最大值的坐标（索引）的一维数组元组。

发出警告:

UserWarning: 如果 allow_borders 为 false 并且给定 image 的任何维度短于 3 个样本，则最大值不存在，并且会显示警告。

另请参阅

skimage.morphology.local_minima
skimage.morphology.h_maxima
skimage.morphology.h_minima

注释

此函数基于以下思想运行

首次遍历图像的最后一个维度，并通过仅在一个方向上比较像素来标记局部最大值的候选像素。如果像素在最后一个维度中未连接，则所有像素都将标记为候选像素。

对于每个候选像素

执行洪水填充以查找所有具有相同灰度值并且是平台一部分的连通像素。
考虑平台的连通邻域：如果没有相邻样本具有更高的灰度级，则将平台标记为确定的局部最大值。

示例

>>> 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，则将所有相邻像素视为邻域的一部分。
connectivity整数，可选: 一个用于确定每个评估像素的邻域的数字。与中心的平方距离小于或等于 connectivity 的相邻像素被视为邻居。如果 footprint 不为 None，则忽略。
indicesbool, 可选: 如果为 True，则输出将是一个一维数组的元组，表示每个维度中局部最小值的索引。如果为 False，则输出将是与 image 形状相同的布尔数组。
allow_bordersbool, 可选: 如果为 true，则接触图像边界的平台是有效的最小值。

返回:

minimandarray 或 tuple[ndarray]: 如果 indices 为 false，则返回一个与 image 形状相同的布尔数组，其中 True 表示局部最小值的位置（否则为 False）。如果 indices 为 true，则返回一个包含所有找到的最小值的坐标（索引）的一维数组元组。

另请参阅

skimage.morphology.local_maxima
skimage.morphology.h_maxima
skimage.morphology.h_minima

注释

此函数基于以下思想运行

首次遍历图像的最后一个维度，并通过仅在一个方向上比较像素来标记局部最小值的候选像素。如果像素在最后一个维度中未连接，则所有像素都将标记为候选像素。

对于每个候选像素

执行洪水填充以查找所有具有相同灰度值并且是平台一部分的连通像素。
考虑平台的连通邻域：如果没有相邻样本具有更小的灰度级，则将平台标记为确定的局部最小值。

示例

>>> 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)[源代码]#

从图像构建最大树。

组件树表示对图像应用顺序阈值操作所产生的连通组件的层次结构。如果一个较高层级的连通组件包含在较低层级的连通组件中，则较低层级的组件是较高层级的组件的父组件。最大树是组件树的一种高效表示形式。一个层级的连通组件在该层级由一个参考像素表示，该参考像素是该层级所有其他像素以及上一层级参考像素的父像素。最大树是许多形态学算子的基础，尤其是连通算子。

参数:

imagendarray: 要计算最大树的输入图像。此图像可以是任何类型。
connectivity无符号整数，可选: 邻域连通性。整数表示到达邻居的最大正交步数。在 2D 中，4 邻域为 1，8 邻域为 2。默认值为 1。

返回:

parentndarray, int64: 与图像形状相同的数组。每个像素的值是其在展平数组中的父节点的索引。
tree_traverser1D 数组, int64: 排序的像素索引（指的是展开数组）。像素的排序方式是，每个像素的前面都是其父级（根节点除外，它没有父级）。

参考文献

[1]

Salembier, P., Oliveras, A., & Garrido, L. (1998). Antiextensive Connected Operators for Image and Sequence Processing. IEEE Transactions on Image Processing, 7(4), 555-570. DOI:10.1109/83.663500

[2]

Berger, C., Geraud, T., Levillain, R., Widynski, N., Baillard, A., Bertin, E. (2007). Effective Component Tree Computation with Application to Pattern Recognition in Astronomical Imaging. In International Conference on Image Processing (ICIP) (pp. 41-44). DOI:10.1109/ICIP.2007.4379949

[3]

Najman, L., & Couprie, M. (2006). Building the component tree in quasi-linear time. IEEE Transactions on Image Processing, 15(11), 3531-3539. DOI:10.1109/TIP.2006.877518

[4]

Carlinet, E., & Geraud, T. (2014). A Comparative Review of Component Tree Computation Algorithms. IEEE Transactions on Image Processing, 23(9), 3885-3895. DOI:10.1109/TIP.2014.2336551

示例

我们创建一个小的示例图像（来自 [4] 的图 1）并构建最大树。

>>> 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: 要计算最大值的输入图像。
connectivity无符号整数，可选: 邻域连通性。整数表示到达邻居的最大正交步数。在 2D 中，4 邻域为 1，8 邻域为 2。默认值为 1。
parentndarray，int64，可选: 每个像素的值是其在展平数组中的父节点的索引。
tree_traverser1D 数组，int64，可选: 排序的像素索引（指的是展开数组）。像素的排序方式是，每个像素的前面都是其父级（根节点除外，它没有父级）。

返回:

local_maxndarray, uint64: 图像的标记局部最大值。

另请参阅

skimage.morphology.local_maxima
skimage.morphology.max_tree

参考文献

[1]

Vincent L., Proc. “Grayscale area openings and closings, their efficient implementation and applications”, EURASIP Workshop on Mathematical Morphology and its Applications to Signal Processing, Barcelona, Spain, pp.22-27, May 1993.

[2]

Soille, P., “Morphological Image Analysis: Principles and Applications” (Chapter 6), 2nd edition (2003), ISBN 3540429883. DOI:10.1007/978-3-662-05088-0

[3]

Salembier, P., Oliveras, A., & Garrido, L. (1998). Antiextensive Connected Operators for Image and Sequence Processing. IEEE Transactions on Image Processing, 7(4), 555-570. DOI:10.1109/83.663500

[4]

Najman, L., & Couprie, M. (2006). Building the component tree in quasi-linear time. IEEE Transactions on Image Processing, 15(11), 3531-3539. DOI:10.1109/TIP.2006.877518

[5]

Carlinet, E., & Geraud, T. (2014). A Comparative Review of Component Tree Computation Algorithms. IEEE Transactions on Image Processing, 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二值 ndarray, 形状 (M, N)

要骨骼化的形状的图像。如果此输入不是二值图像，则会将其转换为二值图像：在这种情况下，零值被视为背景（False），非零值被视为前景（True）。

mask二值 ndarray, 形状 (M, N), 可选

如果给定掩码，则仅使用 mask 中具有 true 值的 image 中的那些元素来计算中轴。

return_distancebool, 可选

如果为 true，则返回距离变换和骨骼。

rng{numpy.random.Generator, int}, 可选

伪随机数生成器。默认情况下，使用 PCG64 生成器（请参阅 numpy.random.default_rng()）。如果 rng 是一个整数，则它用于为生成器设定种子。

PRNG 确定像素被处理以进行打破平局的顺序。

在版本 0.19 中添加。

返回:

out布尔值 ndarray: 图像的中轴变换
dist整数 ndarray, 可选: 图像的距离变换（仅当 return_distance 为 True 时才返回）

另请参阅

skeletonize, thin

注释

此算法计算图像的中轴变换，作为其距离变换的脊线。

该算法的不同步骤如下

使用查找表，该表将 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)[源代码]#

镜像结构元素中的每个维度。

参数:

footprintndarray 或 tuple: 输入足迹或足迹序列

返回:

invertedndarray 或元组: 足迹，沿每个维度镜像。

示例

>>> 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)[源代码]#

生成八边形结构元素。

对于给定的水平和垂直边尺寸 (m) 和倾斜边的高度或宽度 (n)，将生成八边形。倾斜边与水平轴成 45 或 135 度角，因此宽度和高度相等。足迹沿单个轴的总大小将为 m + 2 * n。

参数:

mint: 水平和垂直边的尺寸。
nint: 倾斜边的高度或宽度。

返回:

footprintndarray 或 tuple: 邻域元素为 1，其他元素为 0 的足迹。当 decomposition 为 None 时，这只是一个 numpy.ndarray。否则，这将是一个元组，其长度等于要应用的唯一结构元素的数量（有关更多详细信息，请参见注释）

其他参数:

dtype数据类型，可选: 足迹的数据类型。
decomposition{None, ‘sequence’}, 可选: 如果为 None，则返回单个数组。对于“sequence”，则返回较小足迹的元组。应用这一系列较小的足迹将产生与单个较大足迹相同的结果，但具有更好的计算性能。有关更多详细信息，请参见注释。

注释

当 decomposition 不为 None 时，footprint 元组的每个元素都是 (ndarray, num_iter) 形式的 2 元组，它指定了足迹数组及其要应用的迭代次数。

对于二值或灰度形态学，观察到使用 decomposition='sequence' 会带来性能优势，并且优势的大小随着足迹尺寸的增加而增加。

生成足迹（结构元素）

分解平面足迹（结构元素）

skimage.morphology.octahedron(radius, dtype=<class 'numpy.uint8'>, *, decomposition=None)[源代码]#

生成八面体形结构元素。

这是金刚石的 3D 等效物。如果像素与邻域中心的城市街区/曼哈顿距离不大于半径，则该像素是邻域的一部分（即标记为 1）。

参数:

radius整数: 八面体形状足迹的半径。

返回:

footprintndarray 或 tuple: 邻域元素为 1，其他元素为 0 的足迹。当 decomposition 为 None 时，这只是一个 numpy.ndarray。否则，这将是一个元组，其长度等于要应用的唯一结构元素的数量（有关更多详细信息，请参见注释）

其他参数:

dtype数据类型，可选: 足迹的数据类型。
decomposition{None, ‘sequence’}, 可选: 如果为 None，则返回单个数组。对于“sequence”，则返回较小足迹的元组。应用这一系列较小的足迹将产生与单个较大足迹相同的结果，但具有更好的计算性能。有关更多详细信息，请参见注释。

注释

当 decomposition 不为 None 时，footprint 元组的每个元素都是 (ndarray, num_iter) 形式的 2 元组，它指定了足迹数组及其要应用的迭代次数。

对于二值或灰度形态学，观察到使用 decomposition='sequence' 会带来性能优势，并且优势的大小随着足迹尺寸的增加而增加。

生成足迹（结构元素）

分解平面足迹（结构元素）

skimage.morphology.opening(image, footprint=None, out=None, *, mode='reflect', cval=0.0)[源代码]#

返回图像的灰度形态学开运算结果。

图像的形态学开运算定义为先腐蚀后膨胀。开运算可以去除小的亮点（即“盐”）并连接小的暗裂缝。这往往会“打开”（暗）特征之间的（亮）间隙。

参数:

imagendarray: 图像数组。
footprintndarray 或 tuple，可选: 表示为 1 和 0 的二维数组的邻域。如果为 None，则使用十字形足迹（connectivity=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 footprint_rectangle
>>> 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, footprint_rectangle((3, 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)

应用掩码SLIC 与 SLIC

形态学滤波

使用图像修复来恢复有斑点的角膜图像

skimage.morphology.pad_footprint(footprint, *, pad_end=True)[source]#

将结构元素沿每个维度填充为奇数大小。

参数:

footprintndarray 或 tuple: 输入足迹或足迹序列
pad_endbool, 可选: 如果为 True，则在每个维度的末尾（右侧）进行填充，否则在前端（左侧）进行填充。

返回:

paddedndarray 或 tuple: 沿每个维度填充为奇数大小的足迹。

示例

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

对图像执行形态学重建。

通过膨胀进行的形态学重建类似于基本的形态学膨胀：高强度值将替换附近的低强度值。然而，基本的膨胀算子使用足迹来确定输入图像中的值可以扩散多远。相反，重建使用两个图像：“种子”图像，指定扩散的值，以及“掩模”图像，给出每个像素允许的最大值。像足迹一样，掩模图像限制了高强度值的扩散。通过侵蚀进行的重建只是相反的：低强度值从种子图像扩散，并受到掩模图像的限制，该图像表示允许的最小值。

或者，您可以将重建视为隔离图像的连接区域的一种方法。对于膨胀，重建连接由种子图像中的局部最大值标记的区域：小于或等于这些种子的相邻像素连接到种子区域。值大于种子图像的局部最大值将被截断为种子值。

参数:

seedndarray: 种子图像（也称为标记图像），指定要膨胀或侵蚀的值。
maskndarray: 每个像素允许的最大值（膨胀）/最小值（侵蚀）。
method{‘dilation’|’erosion’}, 可选: 通过膨胀或侵蚀执行重建。在膨胀（或侵蚀）中，种子图像膨胀（或侵蚀）直到受到掩模图像的限制。对于膨胀，每个种子值必须小于或等于相应的掩模值；对于侵蚀，则相反。默认值为“dilation”。
footprintndarray，可选: 邻域表示为由 1 和 0 组成的 n 维数组。默认值是半径等于 1 的 n 维正方形（即，对于 2D 图像，为 3x3 正方形，对于 3D 图像，为 3x3x3 立方体等）。
offsetndarray, 可选: 足迹中心的坐标。默认情况下位于足迹的几何中心，在这种情况下，足迹尺寸必须是奇数。

返回:

reconstructedndarray: 形态学重建的结果。

注释

该算法取自 [1]。灰度重建的应用在 [2] 和 [3] 中讨论。

参考文献

[1]

Robinson，“高效形态学重建：下坡滤波器”，Pattern Recognition Letters 25 (2004) 1759-1767。

[2]

Vincent, L.，“图像分析中的形态学灰度重建：应用和高效算法”，IEEE Transactions on Image Processing (1993)

[3]

Soille, P.，“形态图像分析：原理和应用”，第 6 章，第二版 (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.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: 删除与其他对象的距离不大于此正值的对象。首先删除具有较低 priority 的对象。
priorityndarray, 可选: 定义删除对象的优先级。需要一个长度为 np.amax(label_image) + 1 的一维数组，该数组在相应的索引处包含每个对象的标签的优先级。首先删除值较低的对象，直到所有剩余对象都满足距离要求。如果未给出，则优先考虑具有较多样本数的对象，其次是它们的标签值。
p_normint 或 float, 可选: 用于计算对象之间距离的 p 阶闵可夫斯基距离。默认值 2 对应于欧几里得距离，1 对应于“曼哈顿”距离，np.inf 对应于切比雪夫距离。
spacingfloat 序列, 可选: label_image 每个轴的像素间距。如果未指定，则意味着单位 (1) 网格间距。
outndarray，可选: 与 image 具有相同形状和 dtype 的数组，其中放置输出。默认情况下，会创建一个新数组。

返回:

outndarray: 与 label_image 具有相同形状的数组，其中删除了违反 min_distance 条件的对象。

另请参阅

skimage.morphology.remove_small_objects: 移除小于指定大小的对象。

注释

该算法的基本步骤如下

查找所有给定对象的索引，并根据它们是否指向对象的边界来分隔它们。
按其标签值对索引进行排序，确保指向同一对象的索引彼此相邻。此优化允许通过简单地步进到相邻索引来查找对象的所有部分。
按 priority 对边界索引进行排序。使用稳定排序来保留上一个排序步骤的顺序。如果未给出 priority，则使用 numpy.bincount() 作为后备。
从边界索引构造一个 scipy.spatial.cKDTree。
按优先级排序的顺序迭代边界索引，并查询 kd 树以查找太近的对象。删除那些太近的对象，并在稍后评估其他对象时不要考虑它们。

此算法的性能取决于 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)[源代码]#

移除小于指定大小的连续空洞。

参数:

arndarray (任意形状，int 或 bool 类型): 包含感兴趣的连通分量的数组。
area_thresholdint，可选 (默认值: 64): 将被填充的连续孔洞的最大面积（以像素为单位）。替换 min_size。
connectivityint, {1, 2, …, ar.ndim}, 可选 (默认值: 1): 定义像素邻域的连通性。
outndarray: 与 ar 形状相同且数据类型为 bool 的数组，输出将放置在该数组中。默认情况下，将创建一个新数组。

返回:

outndarray，与输入 ar 形状和类型相同: 输入数组，其中已移除连通分量内的小孔洞。

引发:

TypeError: 如果输入数组类型无效，例如 float 或 string。
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

应用掩码SLIC 与 SLIC

测量区域属性

skimage.morphology.remove_small_objects(ar, min_size=64, connectivity=1, *, out=None)[源代码]#

移除小于指定大小的对象。

期望 ar 是一个带有标记对象的数组，并移除小于 min_size 的对象。如果 ar 是 bool 类型，则会先标记图像。这会导致 bool 和 0-and-1 数组的潜在不同行为。

参数:

arndarray (任意形状，int 或 bool 类型): 包含感兴趣对象的数组。如果数组类型为 int，则这些整数必须是非负数。
min_sizeint，可选 (默认值: 64): 允许的最小对象大小。
connectivityint, {1, 2, …, ar.ndim}, 可选 (默认值: 1): 定义像素邻域的连通性。如果 ar 为 bool 类型，则在标记期间使用。
outndarray: 与 ar 形状相同的数组，输出将放置在该数组中。默认情况下，将创建一个新数组。

返回:

outndarray，与输入 ar 形状和类型相同: 输入数组，其中已移除小的连通分量。

引发:

TypeError: 如果输入数组类型无效，例如 float 或 string。
ValueError: 如果输入数组包含负值。

另请参阅

skimage.morphology.remove_objects_by_distance

示例

>>> 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)[源代码]#

通过细化计算输入图像的骨架。

参数:

image(M, N[, P]) bool 或 int 类型的 ndarray: 包含要骨骼化的对象的图像。图像中的每个连通分量都将缩减为单像素宽的骨骼。在细化之前对图像进行二值化处理；因此，会将不同强度的相邻对象视为一个。零值或 False 值表示背景，非零值或 True 值表示前景。
method{‘zhang’, ‘lee’}, 可选: 要使用的算法。Zhang 算法 [Zha84] 仅适用于 2D 图像，并且是 2D 图像的默认算法。Lee 算法 [Lee94] 适用于 2D 或 3D 图像，并且是 3D 图像的默认算法。

返回:

skeleton(M, N[, P]) bool 类型的 ndarray: 细化后的图像。

另请参阅

medial_axis

参考文献

[Lee94]

T.-C. Lee, R.L. Kashyap 和 C.-N. Chu, Building skeleton models via 3-D medial surface/axis thinning algorithms. 计算机视觉、图形和图像处理, 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.star(a, dtype=<class 'numpy.uint8'>)[源代码]#

生成星形结构元素。

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)[源代码]#

对二值图像执行形态学细化。

参数:

image二进制 (M, N) ndarray: 要细化的图像。如果此输入还不是二进制图像，它将被转换为二进制图像：在这种情况下，零值被视为背景 (False)，非零值被视为前景 (True)。
max_num_iterint, 迭代次数，可选: 无论此参数的值如何，如果某次迭代没有产生任何更改，则会立即返回细化后的图像。因此，如果指定此参数，则它会设置执行的迭代次数的上限。

返回:

outbool 类型的 ndarray: 细化后的图像。

另请参阅

skeletonize, medial_axis

注释

此算法 [1] 通过多次遍历图像来实现，删除符合一组旨在细化连接区域的条件的像素，同时保留八连接分量和 2 x 2 正方形 [2]。在两个子迭代中的每一个子迭代中，该算法都会将中间骨骼图像与邻域掩码相关联，然后在查找表中查找每个邻域，该查找表指示是否应在该子迭代中删除中心像素。

参考文献

[1]

Z. Guo 和 R. W. Hall，“Parallel thinning with two-subiteration algorithms,” Comm. ACM, vol. 32, no. 3, pp. 359-373, 1989. DOI:10.1145/62065.62074

[2]

Lam, L., Seong-Whan Lee, 和 Ching Y. Suen，“Thinning Methodologies-A Comprehensive Survey,” IEEE Transactions on Pattern Analysis and Machine Intelligence, Vol 14, No. 9, p. 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.white_tophat(image, footprint=None, out=None, *, mode='reflect', cval=0.0)[源代码]#

返回图像的白顶帽变换结果。

图像的白色顶帽定义为图像减去其形态学开运算的结果。此操作返回图像中比足迹小的亮点。

参数:

imagendarray: 图像数组。
footprintndarray 或 tuple，可选: 表示为 1 和 0 的二维数组的邻域。如果为 None，则使用十字形足迹（connectivity=1）。也可以按以下注释中所述，将足迹作为较小足迹的序列提供。
outndarray，可选: 用于存储形态学结果的数组。如果传递 None，将分配一个新数组。
modestr，可选: mode 参数确定如何处理数组边界。有效的模式为：‘reflect’、‘constant’、‘nearest’、‘mirror’、‘wrap’、‘max’、‘min’ 或 ‘ignore’。请参阅 skimage.morphology.opening()。默认值为 ‘reflect’。
cval标量，可选: 如果 mode 为 'constant'，则填充输入边缘的值。默认为 0.0。

在 0.23 版本中添加: mode 和 cval 在 0.23 中添加。

返回:

out数组，与 image 具有相同的形状和类型: 形态学白色顶帽的结果。

另请参阅

black_tophat

注释

足迹也可以作为 2 元组的序列提供，其中每个 2 元组的第一个元素是足迹 ndarray，第二个元素是描述应迭代次数的整数。例如，footprint=[(np.ones((9, 1)), 1), (np.ones((1, 9)), 1)] 将应用一个 9x1 足迹，然后应用一个 1x9 足迹，最终效果与 footprint=np.ones((9, 9)) 相同，但计算成本较低。大多数内置足迹（例如 skimage.morphology.disk()）都提供一个选项来自动生成这种类型的足迹序列。

参考文献

[1]

https://en.wikipedia.org/wiki/Top-hat_transform

示例

>>> # Subtract gray background from bright peak
>>> import numpy as np
>>> from skimage.morphology import footprint_rectangle
>>> 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, footprint_rectangle((3, 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#

`skimage.morphology`#