在线文档教程
首页 技术教程 开发文档 觅分类 ICON图标
技术教程 开发文档 觅分类 ICON图标

morphology

模块：形态

skimage.morphology.ball（radius，dtype）生成一个球形结构元素。
skimage.morphology.binary_closing（image，...）快速返回图像的二元形态闭合。
skimage.morphology.binary_dilation（image，...）快速返回图像的二进制形态膨胀。
skimage.morphology.binary_erosion（image，...）快速返回图像的二元形态学侵蚀。
skimage.morphology.binary_opening（image，...）快速返回图像的二进制形态开放。
skimage.morphology.black_tophat（image，...）返回图像的黑色礼帽。
skimage.morphology.closing（image，selem，out）返回图像的灰度形态闭合。
skimage.morphology.convex_hull_image（图像）计算二值图像的凸包图像。
skimage.morphology.convex_hull_object（图像）计算二进制图像中单个对象的凸包图像。
skimage.morphology.cube（宽度，dtype）生成立方体形状的结构元素。
skimage.morphology.diamond（radius，dtype）生成平坦的菱形结构元素。
skimage.morphology.dilation（image，selem，...）返回图像的灰度形态膨胀。
skimage.morphology.disk（radius，dtype）生成扁平的盘状结构元素。
skimage.morphology.erosion（图像，selem，...）返回图像的灰度形态学侵蚀。
skimage.morphology.h_maxima（img，h，selem）确定高度> = h的图像的所有最大值。
skimage.morphology.h_minima（img，h，selem）确定深度> = h的图像的所有最小值。
skimage.morphology.label（输入，邻居，...）标记整数数组的连接区域。
skimage.morphology.local_maxima（img，selem）确定图像的所有局部最大值。
skimage.morphology.local_minima（img，selem）确定图像的所有局部最小值。
skimage.morphology.medial_axis（image，...）计算二值图像的中轴变换
skimage.morphology.octagon（m，n，dtype）生成八角形结构元素。
skimage.morphology.octahedron（半径，dtype）生成八面体形结构元素。
skimage.morphology.opening（image，selem，out）返回图像的灰度形态开放。
skimage.morphology.reconstruction（种子，面具）执行图像的形态重建。
skimage.morphology.rectangle（宽度，高度）生成扁平的矩形结构元素。
skimage.morphology.remove_small_holes（ar，...）去除小于指定尺寸的连续孔。
skimage.morphology.remove_small_objects（AR）移除小于指定尺寸的连接组件。
skimage.morphology.skeletonize（图像）返回二进制图像的骨架。
skimage.morphology.skeletonize_3d（IMG）计算二进制图像的骨架。
skimage.morphology.square（宽度，dtype）生成扁平的方形结构元素。
skimage.morphology.star（a，dtype）生成一个星形结构元素。
skimage.morphology.thin（image，max_iter）执行二值图像的形态细化。
skimage.morphology.watershed（图像，标记）从给定的标记中发现图像中的流域盆地。
skimage.morphology.white_tophat（image，...）返回图像的白色礼帽。
skimage.morphology.binary二进制形态学操作
skimage.morphology.convex_hull凸面船体。
skimage.morphology.extremaextrema.py - 局部最小值和最大值
skimage.morphology.grey灰度形态学操作
skimage.morphology.greyreconstruct此形态重建程序改编自CellProfiler，代码以GPL和BSD许可证授权。
skimage.morphology.misc​
skimage.morphology.selem​

球形

skimage.morphology.ball(radius, dtype=<class 'numpy.uint8'>)[资源]

生成一个球形结构元素。

这是一个磁盘的3D等价物。如果像素与原点之间的欧氏距离不大于半径，则像素位于邻域内。

参数：radius：int球形结构元素的半径。
返回：selem：ndarray结构元素，其中邻域的元素为1，否则为0。

| 其他参数：|

| | dtype：data-type结构元素的数据类型。|

binary_closing

skimage.morphology.binary_closing(image, selem=None, out=None)[source]

快速返回图像的二元形态闭合。

该函数返回与灰度关闭相同的结果，但对二进制图像执行速度更快。

图像上的形态闭合被定义为膨胀，然后是侵蚀。关闭可以去除小黑点（即“pepper”）并连接小的明亮裂缝。这往往会“关闭”（明亮）特征之间的（黑暗）间隙。

参数：图像：ndarray二进制输入图像。selem：ndarray，可选该邻域表示为1和0的二维数组。如果无，则使用十字形结构元素（连通性= 1）。out：bool的ndarray，可选用于存储形态结果的数组。如果没有，传递一个新的数组将被分配。
返回：关闭：bool的ndarray形态关闭的结果。

binary_dilation

skimage.morphology.binary_dilation(image, selem=None, out=None)[资源]

快速返回图像的二进制形态膨胀。

该函数返回与灰度扩大相同的结果，但对二值图像执行速度更快。

形态膨胀将(i,j)居中的所有像素的像素设置为最大(i,j)。扩张放大明亮区域并缩小黑暗区域。

参数：图像：ndarray二进制输入图像。selem：ndarray，可选该邻域表示为1和0的二维数组。如果无，则使用十字形结构元素（连通性= 1）。out：bool的ndarray，可选用于存储形态结果的数组。如果没有，传递一个新的数组将被分配。
返回：扩张：bool或uint的ndarray形态扩张的结果，其值为False，True。

binary_erosion

skimage.morphology.binary_erosion(image, selem=None, out=None)[资源]

快速返回图像的二元形态学侵蚀。

该函数返回与灰度侵蚀相同的结果，但对二值图像执行速度更快。

形态侵蚀将(i,j)居中的所有像素的像素设置为最小(i,j)。侵蚀会缩小明亮区域并扩大黑暗区域。

参数：图像：ndarray二进制输入图像。selem：ndarray，可选该邻域表示为1和0的二维数组。如果无，则使用十字形结构元素（连通性= 1）。out：bool的ndarray，可选用于存储形态结果的数组。如果None传递，将分配一个新的数组。
返回：侵蚀：bool或uint的ndarray形态侵蚀的结果以False，True为准。

binary_opening

skimage.morphology.binary_opening(image, selem=None, out=None)[资源]

快速返回图像的二进制形态开放。

该函数返回与灰度打开相同的结果，但对二进制图像执行速度更快。

图像上的形态学开放被定义为侵蚀和扩张。打开可以消除小亮点（即“盐”）并连接小的黑暗裂缝。这倾向于“打开”（明亮）特征之间的（暗）间隙。

参数：图像：ndarray二进制输入图像。selem：ndarray，可选该邻域表示为1和0的二维数组。如果无，则使用十字形结构元素（连通性= 1）。out：bool的ndarray，可选用于存储形态结果的数组。如果None传递，将分配一个新的数组。
返回：开幕：布尔的ndarray形态开放的结果。

black_tophat

skimage.morphology.black_tophat(image, selem=None, out=None)[source]

返回图像的黑色top hat。

图像的黑色top hat被定义为其形态闭幕减去原始图像。该操作返回比结构化元素更小的图像的黑点。请注意，原始图像中的黑点是黑色top hat之后的亮点。

参数：图像：ndarray图像数组。selem：ndarray，可选该邻域表示为1和0的二维数组。如果无，则使用十字形结构元素（连通性= 1）。out：ndarray，可选用于存储形态结果的数组。如果None传递，将分配一个新的数组。
返回：out：数组，与图像相同的形状和类型形态黑色 top hat的结果。

例子

>>> # Change dark peak to bright peak and subtract background
>>> import numpy as np
>>> from skimage.morphology import square
>>> dark_on_grey = 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_grey, 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, selem=None, out=None)[资源]

返回图像的灰度形态闭合。

图像上的形态闭合被定义为膨胀，然后是侵蚀。关闭可以去除小黑点（即“胡椒”）并连接小的明亮裂缝。这往往会“关闭”（明亮）特征之间的（黑暗）间隙。

参数：图像：ndarray图像数组。selem：ndarray，可选该邻域表示为1和0的数组。如果无，则使用十字形结构元素（连通性= 1）。out：ndarray，可选用于存储形态结果的数组。如果没有，传递一个新的数组将被分配。
返回：闭：数组，与图像形状和类型相同形态闭合的结果。

例子

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

convex_hull_image

skimage.morphology.convex_hull_image(image)[资源]

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

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

参数：图像：（M，N）数组二进制输入图像。这个数组在处理之前被转换为bool。
返回：hull：（M，N）bool二元图像阵列，凸像素像素设置为True。

参考

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

convex_hull_object

skimage.morphology.convex_hull_object(image, neighbors=8)[资源]

计算二进制图像中单个对象的凸包图像。

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

参数：图像：（M，N）数组二进制输入图像。邻居：{4，8}，int是否使用4-或8-连接。
返回：hull：ndarray of bool将凸包中像素设置为True的二进制图像。

注意

该函数使用skimage.morphology.label定义唯一对象，使用convex_hull_image查找每个对象的凸包，并将这些区域与逻辑OR组合。请注意，未连接对象的凸包可能会在结果中重叠。如果怀疑这种情况，请考虑在每个对象上分别使用convex_hull_image。

立方体

skimage.morphology.cube(width, dtype=<class 'numpy.uint8'>)[资源]

生成立方体形状的结构元素。

这是一个正方形的3D等价物。沿着周边的每个像素都具有不大于半径（半径= floor（width / 2））像素的棋盘距离。

参数：width：int立方体的宽度，高度和深度。
返回：selem：结构元素只包含一个结构元素，即每个像素都属于邻域。

| 其他参数：|

| | dtype：data-type结构元素的数据类型。|

菱形

skimage.morphology.diamond(radius, dtype=<class 'numpy.uint8'>)[资源]

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

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

参数：radius：int菱形结构元素的半径。
返回：selem：ndarray结构元素，其中邻域的元素为1，否则为0。

| 其他参数：|

| | dtype：data-type结构元素的数据类型。|

扩张

skimage.morphology.dilation(image, selem=None, out=None, shift_x=False, shift_y=False)[资源]

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

形态膨胀将（i，j）处的像素设置为以（i，j）为中心的邻域中的所有像素的最大值。扩张放大明亮区域并缩小黑暗区域。

参数：图像：ndarray图像数组。selem：ndarray，可选该邻域表示为1和0的二维数组。如果无，则使用十字形结构元素（连通性= 1）。out：ndarray，可选用于存储形态结果的数组。如果没有，传递一个新的数组将被分配。shift_x，shift_y：bool，关于中心点的可选移位结构元素。这只影响偏心结构元素（即偶数边的selem）。
返回：扩张：uint8数组，与图像相同的形状和类型形态扩张的结果。

注意

对于uint8（并且uint16达到某个位深度）的数据，较低的算法复杂度使该skimage.filters.rank.maximum功能对于较大的图像和结构元素更有效。

例子

>>> # 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'>)[资源]

生成扁平的盘状结构元素。

如果像素与原点之间的欧氏距离不大于半径，则像素位于邻域内。

参数：radius：int圆盘形结构元素的半径。
返回：selem：ndarray结构元素，其中邻域的元素为1，否则为0。

| 其他参数：|

| | dtype：data-type结构元素的数据类型。|

侵蚀

skimage.morphology.erosion(image, selem=None, out=None, shift_x=False, shift_y=False)[资源]

返回图像的灰度形态学侵蚀。

形态侵蚀将（i，j）处的像素设置为以（i，j）为中心的邻域中的所有像素的最小值。侵蚀会缩小明亮区域并扩大黑暗区域。

参数：图像：ndarray图像数组。selem：ndarray，可选该邻域表示为1和0的数组。如果无，则使用十字形结构元素（连通性= 1）。out：ndarrays，可选用于存储形态结果的数组。如果None传递，将分配一个新的数组。shift_x，shift_y：bool，关于中心点的可选移位结构元素。这只影响偏心结构元素（即偶数边的selem）。
返回：侵蚀：阵列，与图像形状相同形态侵蚀的结果。

注意

对于uint8（并且uint16达到某个位深度）的数据，较低的算法复杂度使该skimage.filters.rank.minimum功能对于较大的图像和结构元素更有效。

例子

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

h_maxima

skimage.morphology.h_maxima(img, h, selem=None)[资源]

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

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

高度h的局部最大值M是局部最大值，对于该局部最大值，存在至少一条连接M的路径，其中最小值为f（M）-h（即，沿着路径的值未减少超过h相对于最大值）并且不存在最小值更大的路径。

参数：img：ndarray要为其计算最大值的输入图像。h：无符号整数所有提取的最大值的最小高度。selem：ndarray，可选该邻域表示为1和0的nD数组。默认值是半径为1的球根据最大范数（即2D图像为3x3平方，3D图像为3x3x3立方体等）
返回：h_max：ndarray高度> = h的最大值。结果图像是一个二值图像，其中属于所选最大值的像素取值1，其他值取0。

扩展内容

skimage.morphology.extrema.h_minima, skimage.morphology.extrema.local_maxima, skimage.morphology.extrema.local_minima

参考

R382Soille，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,101

>>> 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(np.int)

我们可以计算所有最大高度至少为40的最大值：

>>> maxima = extrema.h_maxima(f, 40)

生成的图像将包含4个局部最大值。

h_minima

skimage.morphology.h_minima(img, h, selem=None)[资源]

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

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

深度h的局部最小值M是局部最小值，对于该局部最小值，存在至少一条连接M的路径，其中最大值为f（M）+ h的更深的最小值（即，沿着路径的值未增加超过h相对于最小值）并且没有最大值较小的路径。

参数：img：ndarray要计算最小值的输入图像。h：无符号整数所有提取的最小值的最小深度。selem：ndarray，可选该邻域表示为1和0的nD数组。默认值是半径为1的球根据最大范数（即2D图像为3x3平方，3D图像为3x3x3立方体等）
返回：h_min：ndarray深度的最小值> = h。结果图像是一个二值图像，其中属于选定最小值的像素取值为1，其他像素取值为0。

扩展内容

skimage.morphology.extrema.h_maxima, skimage.morphology.extrema.local_maxima, skimage.morphology.extrema.local_minima

参考

R383Soille，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,101

>>> 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(np.int)

我们可以计算深度至少为40的所有最小值：

>>> minima = extrema.h_minima(f, 40)

生成的图像将包含4个局部最小值。

标签

skimage.morphology.label(input, neighbors=None, background=None, return_num=False, connectivity=None)[资源]

标记整数数组的连接区域。

两个像素是相邻的，并且具有相同的值。在2D中，它们可以是1或2连接意义上的邻居。该值是指考虑像素/体素邻居的正交跳跃的最大数量：

1-connectivity      2-connectivity     diagonal connection close-up

     [ ]           [ ]  [ ]  [ ]         [ ]
      |               \  |  /             |  <- hop 2
[ ]--[x]--[ ]      [ ]--[x]--[ ]    [x]--[ ]
      |               /  |  \         hop 1
     [ ]           [ ]  [ ]  [ ]

参数：输入：dtype int的ndarray要标记的图像。邻居：{4,8}，int，可选是否使用4-或8-“连接”。在3D中，4-“连接”意味着连接的像素必须共享面，而使用8-“连接”时，它们必须仅共享边或顶点。已弃用，请connectivity改用。背景：int，可选将所有具有此值的像素作为背景像素，并将它们标记为0.默认情况下，0值像素被视为背景像素。return_num：bool，可选是否返回已分配标签的数量。connectivity：int，可选最大正交跳数，用于将像素/体素视为邻居。接受的值范围从1到input.ndim。如果没有，则使用input.ndim的完整连接。
返回：标签：dtype int的ndarray标签数组，其中所有连接区域都分配了相同的整数值。num：int，可选数量的标签，它等于最大标签索引，并且只有在return_num为True时才会返回。

扩展内容

regionprops

参考

R384Christophe Fiorio和Jens Gustedt，“用于图像处理的两种线性时间联合发现策略”，理论计算机科学154（1996），第165-181页。

R385Kensheng Wu，Ekow Otoo和Arie Shoshani，“Optimizing connected component labeling algorithms”，论文LBNL-56864,2005，劳伦斯伯克利国家实验室（University of California），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]]

local_maxima

skimage.morphology.local_maxima(img, selem=None)[资源]

确定图像的所有局部最大值。

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

对于整数类型的图像，这对应于h = 1的h-最大值。对于浮点型图像，h被确定为灰度级之间的最小差异。

参数：img：ndarray要为其计算最大值的输入图像。selem：ndarray，可选该邻域表示为1和0的nD数组。默认值是半径为1的球根据最大范数（即2D图像为3x3平方，3D图像为3x3x3立方体等）
返回：local_max：ndarray图像的所有局部最大值。结果图像是一个二值图像，其中属于局部最大值的像素取值1，其他像素取值0。

扩展内容

skimage.morphology.extrema.h_minima, skimage.morphology.extrema.h_maxima, skimage.morphology.extrema.local_minima

参考

R386Soille，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,101

>>> 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(np.int)

我们可以计算所有本地最大值：

>>> maxima = extrema.local_maxima(f)

生成的图像将包含全部6个局部最大值。

local_minima

skimage.morphology.local_minima(img, selem=None)[资源]

确定图像的所有局部最小值。

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

对于整数类型的图像，这对应于h = 1的h-minima。对于浮点型图像，h被确定为灰度级之间的最小差异。

参数：img：ndarray要计算最小值的输入图像。selem：ndarray，可选该邻域表示为1和0的nD数组。默认值是半径为1的球根据最大范数（即2D图像为3x3平方，3D图像为3x3x3立方体等）
返回：local_min：ndarray图像的所有局部最小值。结果图像是一个二值图像，其中属于局部最小值的像素值为1，其他像素值为0。

扩展内容

skimage.morphology.extrema.h_minima, skimage.morphology.extrema.h_maxima, skimage.morphology.extrema.local_maxima

参考

R387Soille，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,101

>>> 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(np.int)

我们可以计算所有的局部最小值：

>>> minima = extrema.local_minima(f)

生成的图像将包含全部6个局部最小值。

medial_axis

skimage.morphology.medial_axis(image, mask=None, return_distance=False)[资源]

计算二值图像的中轴变换

参数：image：binary ndarray，shape（M，N）要镂空的形状的图像。mask：binary ndarray，shape（M，N），可选如果给出了蒙板，那么只有图像中蒙板中具有真实值的那些元素用于计算中轴。return_distance：bool，可选如果为true，则返回距离转换以及骨架。
返回：out：bools的ndarray图像的中轴变换dist：ints的ndarray，可选图像的距离变换（仅当return_distance为True时才会返回）

扩展内容

skeletonize

注意

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

算法的不同步骤如下

  • 使用一个查找表，它将0或1分配给3x3二进制正方形的每个配置，不管中心像素是否应该被移除或保留。我们希望删除一个点，如果它有多个邻居，并且删除它不会改变连接组件的数量。

  • 计算到背景的距离变换以及像素的角点。

  • 前景（1的值）点由距离变换排序，然后是角点。

  • 调用一个cython函数来将图像缩小到其骨架。它按照上一步确定的顺序处理像素，并根据查找表移除或维护一个像素。由于排序，所以只能一次处理所有像素。

例子

>>> square = np.zeros((7, 7), dtype=np.uint8)
>>> square[1:-1, 2:-2] = 1
>>> square
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).astype(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)

octagon

skimage.morphology.octagon(m, n, dtype=<class 'numpy.uint8'>)[资源]

生成八角形结构元素。

对于给定尺寸的（m）水平和垂直边以及给定（n）高度或宽度的斜面八角形产生。倾斜的边与水平轴成45或135度，因此宽度和高度相等。

参数：m：int水平和垂直边的大小。n：int倾斜边的高度或宽度。
返回：selem：ndarray结构元素，其中邻域的元素为1，否则为0。

| 其他参数：|

| | dtype：data-type结构元素的数据类型。|

八面体

skimage.morphology.octahedron(radius, dtype=<class 'numpy.uint8'>)[资源]

生成八面体形结构元素。

这是菱形的3D等价物。如果城市街区/曼哈顿与街区中心之间的距离不大于半径，则像素是街区的一部分（即标记为1）。

参数：radius：int八面体结构元素的半径。
返回：selem：ndarray结构元素，其中邻域的元素为1，否则为0。

| 其他参数：|

| | dtype：data-type结构元素的数据类型。|

开始

skimage.morphology.opening(image, selem=None, out=None)[资源]

返回图像的灰度形态开放。

图像上的形态学开放被定义为侵蚀和扩张。打开可以消除小亮点（即“salt”）并连接小的黑暗裂缝。这倾向于“打开”（明亮）特征之间的（暗）间隙。

参数：图像：ndarray图像数组。selem：ndarray，可选该邻域表示为1和0的数组。如果无，则使用十字形结构元素（连通性= 1）。out：ndarray，可选用于存储形态结果的数组。如果None传递，将分配一个新的数组。
返回：开放：数组，与图像相同的形状和类型形态开放的结果。

例子

>>> # 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.reconstruction(seed, mask, method='dilation', selem=None, offset=None)[资源]

执行图像的形态重建。

通过扩张进行形态学重建类似于基本的形态学扩张：高强度值将取代附近的低强度值。然而，基本膨胀算子使用结构元素来确定输入图像中的值可以传播多远。相比之下，重建使用两个图像：指定传播值的“种子”图像和提供每个像素处最大允许值的“蒙版”图像。掩模图像与结构元素一样，限制了高强度值的传播。通过侵蚀进行重建只不过是相反的情况：从种子图像传播的低强度值受掩模图像的限制，该掩模图像表示最小允许值。

或者，您可以将重建视为隔离图像连通区域的一种方法。对于扩张，重建将种子图像中由局部极大值标记的区域连接起来：小于或等于那些种子的相邻像素与种子区域相连。值大于种子图像的局部最大值将被截断为种子值。

参数：种子：ndarray种子图像（aka标记图像），指定扩大或侵蚀的值。mask：ndarray每个像素的最大（膨胀）/最小（侵蚀）允许值。方法：{'dilation'|'erosion'}通过扩张或侵蚀进行重建。在扩张（或侵蚀）中，种子图像会扩张（或侵蚀），直到蒙版图像受到限制。对于膨胀，每个种子值必须小于或等于相应的屏蔽值; 对于侵蚀，情况正好相反。selem：ndarray邻域表示为1和0的nD数组。默认值是半径为1的球根据最大范数（即2D图像为3x3平方，3D图像为3x3x3立方体等）
返回：重建：ndarray形态重建的结果。

注意

该算法取自[R388]。在[R389]和[R390]中讨论了灰度重构的应用。

参考

R388（1,2）Robinson，“Efficient morphological reconstruction：a downhill filter”，Pattern Recognition Letters 25（2004）1759-1767。

R389（1,2）Vincent，L。，“图像分析中的形态学灰度重构：应用和高效算法”，IEEE Transactions on Image Processing（1993）

R390（1,2）Soille，P。，“Morphological Image Analysis：Principles and Applications”，第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圆顶，并h在减去的图像中留下高度特征。

长方形

skimage.morphology.rectangle(width, height, dtype=<class 'numpy.uint8'>)[资源]

生成扁平的矩形结构元素。

为给定宽度和给定高度生成的矩形中的每个像素都属于邻域。

参数：width：int矩形的宽度。height：int矩形的高度。
返回：selem：结构元素只包含一个结构元素，即每个像素都属于邻域。

| 其他参数：|

| | dtype：data-type结构元素的数据类型。|

remove_small_holes

skimage.morphology.remove_small_holes(ar, min_size=64, connectivity=1, in_place=False)[资源]

去除小于指定尺寸的连续孔。

参数：ar：ndarray（任意形状，int或bool类型）包含感兴趣的连接组件的数组。min_size：int，可选（默认值：64）孔组件大小。连通性：int，{1，2，...，ar.ndim}，可选（默认值：1）定义像素邻域的连通性。in_place：bool，可选（默认值：False）如果为True，则删除输入数组本身中的连接组件。否则，请复印一份。
返回：out：ndarray，与输入ar相同的形状和类型在连接组件中移除具有小孔的输入数组。
举：TypeError如果输入数组的类型是无效的，例如float或string。ValueError如果输入数组包含负值。

注意

如果数组类型为int，则假定它包含已标记的对象。标签不保存在输出图像中（该功能始终输出一个布尔图像）。建议使用此功能后完成标记。

例子

>>> 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]], dtype=bool)
>>> 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]], dtype=bool)
>>> d = morphology.remove_small_holes(a, 2, in_place=True)
>>> d is a
True

remove_small_objects

skimage.morphology.remove_small_objects(ar, min_size=64, connectivity=1, in_place=False)[资源]

移除小于指定尺寸的连接组件。

参数：ar：ndarray（任意形状，int或bool类型）包含感兴趣的连接组件的数组。如果数组类型为int，则假定它包含已标记的对象。整数必须是非负的。min_size：int，可选（默认值：64）允许的最小连接组件大小。连通性：int，{1，2，...，ar.ndim}，可选（默认值：1）定义像素邻域的连通性。in_place：bool，可选（默认值：False）如果为True，则删除输入数组本身中的连接组件。否则，请复印一份。
返回：out：ndarray，与输入ar相同的形状和类型具有小连接组件的输入数组被删除。
举：TypeError如果输入数组的类型是无效的，例如float或string。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]], dtype=bool)
>>> 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]], dtype=bool)
>>> d = morphology.remove_small_objects(a, 6, in_place=True)
>>> d is a
True

缩略

skimage.morphology.skeletonize(image)[资源]

返回二进制图像的骨架。

细化用于将二进制图像中的每个连接组件减少为单像素宽骨架。

参数：image：numpy.ndarray包含要进行缩略化的对象的二进制图像。'1'代表前景，'0'代表背景。它也接受布尔值的数组，其中True是前景。
返回：skeleton：ndarray包含细化图像的矩阵。

扩展内容

medial_axis

注意

算法[Zha84]通过连续传递图像来工作，消除物体边界上的像素。这一直持续到不再有像素可以被移除。该图像与一个掩模相关联，该掩模为每个像素指定与其8个相邻像素的每个可能图案相对应的范围0 ... 255中的数字。然后使用查找表为像素分配0,1,2或3的值，这些值在迭代期间被选择性地去除。

请注意，该算法会得到与中轴转换不同的结果，后者通常也称为“骨架化”。

参考

Zha84（1，2）一种用于细化数字模式的快速并行算法，TY Zhang和CY Suen，ACM Communications，1984年3月，第27卷，第3期。

例子

>>> X, Y = np.ogrid[0:9, 0:9]
>>> ellipse = (1./3 * (X - 4)**2 + (Y - 4)**2 < 3**2).astype(np.uint8)
>>> ellipse
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.astype(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)

skeletonize_3d

skimage.morphology.skeletonize_3d(img)[资源]

计算二进制图像的骨架。

细化用于将二进制图像中的每个连接组件减少为单像素宽骨架。

参数：img：ndarray，2D或3D包含要进行镂空的对象的二进制图像。零代表背景，非零值是前景。
返回：skeleton：ndarray减薄的图像。

扩展内容

skeletonize, medial_axis

注意

[Lee94]的方法使用八叉树数据结构来检查像素的3x3x3邻域。该算法通过在图像上迭代扫描并在每次迭代中移除像素直到图像停止改变。每次迭代包括两个步骤：首先，组合拆除的候选列表; 那么这个列表中的像素会被顺序重新检查，以更好地保持图像的连通性。

该函数执行的算法是从由任一使用的算法不同的skeletonize或medial_axis，从而为2D图像由该函数产生的结果通常是不同的。

参考

Lee94（1,2）T.-C. Lee，RL Kashyap和C.-N. Chu，通过三维内侧表面/轴细化算法构建骨架模型。计算机视觉，图形和图像处理，56（6）：462-478,1994。

方形

skimage.morphology.square(width, dtype=<class 'numpy.uint8'>)[资源]

生成扁平的方形结构元素。

沿着周边的每个像素都具有不大于半径（半径= floor（width / 2））像素的棋盘距离。

参数：width：int方形的宽度和高度。
返回：selem：结构元素只包含一个结构元素，即每个像素都属于邻域。

| 其他参数：|

| | dtype：data-type结构元素的数据类型。|

星形

skimage.morphology.star(a, dtype=<class 'numpy.uint8'>)[source]

生成一个星形结构元素。

开始有8个顶点，并且是2*a + 145度旋转版本的大小平方的重叠。倾斜的边与水平轴成45或135度。

参数：a：int参数决定星形结构元素的大小。返回的正方形阵列的边是2 * a + 1 + 2 * floor（a / 2）。
返回：selem：ndarray结构元素，其中邻域的元素为1，否则为0。

| 其他参数：|

| | dtype：data-type结构元素的数据类型。|

thin

skimage.morphology.thin(image, max_iter=None)[资源]

执行二值图像的形态细化。

参数：image：binary（M，N）ndarray要变薄的图像。max_iter：int，迭代次数，可选无论此参数的值如何，如果迭代不产生任何变化，细化的图像将立即返回。如果指定了此参数，则会对所执行的迭代次数设置上限。
返回：out：bool的ndarray Thinned image。

扩展内容

skeletonize, skeletonize_3d, medial_axis

注意

该算法[R391]的工作原理是在图像上进行多次扫描，去除符合一系列准则的像素，以减少连通区域，同时保留八连通分量和2 x 2正方形[R392]。在两个子迭代中的每一个中，算法将中间骨架图像与邻域掩模相关联，然后在查找表中查找每个邻域以指示是否应该在该子迭代中删除中心像素。

参考

R391(1, 2) Z. Guo and R. W. Hall, “Parallel thinning with two-subiteration algorithms,” Comm. ACM, vol. 32, no. 3, pp. 359-373, 1989. DOI:10.1145/62065.62074

R392(1, 2) Lam, L., Seong-Whan Lee, and 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=np.uint8)
>>> square[1:-1, 2:-2] = 1
>>> square[0, 1] =  1
>>> square
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.astype(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.watershed(image, markers, connectivity=1, offset=None, mask=None, compactness=0, watershed_line=False)[资源]

从给定的标记中发现图像中的流域盆地。

参数：图像：整数的ndarray（2-D，3-D，...）数据数组，其中最低值的点首先标记。标记：int或int的ndarray，形状与image 所需数量的标记或标记盆地的数组，其中标记矩阵中要分配的值。零意味着不是一个标记。connectivity：ndarray，optional一个数组，其维数与图像的维数相同，其非零元素表示用于连接的邻居。遵循scipy惯例，默认值是图像维度的单连接数组。偏移量：形状image.ndim的array_like，连通性的可选偏移量（每个维度一个偏移量）mask：bools或0s和1s的ndarray，与图像形状相同的可选Array。只有在mask == True的地方才会被标记。紧凑性：浮动，可选使用紧凑型流域R395，具有给定的紧凑性参数。较高的值会导致更加规则的流域盆地。watershed_line：bool，可选如果watershed_line为True，一个像素宽的线将分水岭算法获得的区域分开。该行的标签为0。
返回：out：ndarray与标记相同类型和形状的标记矩阵

扩展内容

skimage.segmentation.random_walker 随机Walker分割基于各向异性扩散的分割算法，通常比分水岭慢，但对噪声数据和孔洞边界具有良好结果。

注意

该功能实现了将像素分配到标记的盆地中的分水岭算法[R393] [R394]。该算法使用优先级队列来保存像素，其中优先级队列的度量是像素值，然后是进入队列的时间 - 这决定了最接近的标记。

Soille的一些想法，“使用数学形态学的数字高程模型的自动化盆地描述”，Signal Processing 20（1990）171-182

本文最重要的见解是入队时间到队列解决了两个问题：一个像素应该分配给最大梯度的邻居，或者如果没有梯度，平台上的像素应该在相反两侧的标记之间分开。

该实现将所有参数转换为特定的最低公分母类型，然后将这些参数传递给C算法。

可以手动确定标记，或者自动使用例如图像梯度的局部最小值或距离函数的局部最大值来分离重叠对象（参见示例）。

参考

R393(1, 2) http://en.wikipedia.org/wiki/Watershed_%28image_processing%29

R394(1, 2) http://cmm.ensmp.fr/~beucher/wtshed.html

R395（1,2）Peer Neubert＆Peter Protzel（2014）。紧凑流域和抢占式SLIC：提高超像素分割算法的权衡。ICPR 2014，pp 996-1001。DOI：10.1109 / ICPR.2014.181 https://www.tu-chemnitz.de/etit/proaut/forschung/rsrc/cws_pSLIC_ICPR.pdf

例子

分水岭算法对分离重叠对象很有用。

我们首先用两个重叠的圆圈生成一个初始图像：

>>> x, y = np.indices((80, 80))
>>> x1, y1, x2, y2 = 28, 28, 44, 52
>>> r1, r2 = 16, 20
>>> mask_circle1 = (x - x1)**2 + (y - y1)**2 < r1**2
>>> mask_circle2 = (x - x2)**2 + (y - y2)**2 < r2**2
>>> image = np.logical_or(mask_circle1, mask_circle2)

接下来，我们要分开两个圈子。我们在与背景距离的最大值处生成标记：

>>> from scipy import ndimage as ndi
>>> distance = ndi.distance_transform_edt(image)
>>> from skimage.feature import peak_local_max
>>> local_maxi = peak_local_max(distance, labels=image,
...                             footprint=np.ones((3, 3)),
...                             indices=False)
>>> markers = ndi.label(local_maxi)[0]

最后，我们在图像和标记上运行分水岭：

>>> labels = watershed(-distance, markers, mask=image)

该算法也适用于三维图像，可用于分离重叠球体。

white_tophat

skimage.morphology.white_tophat(image, selem=None, out=None)[资源]

返回图像的白色top hat。

图像的白色top hat被定义为图像减去其形态开放。该操作返回比结构元素更小的图像亮点。

参数：图像：ndarray图像数组。selem：ndarray，可选该邻域表示为1和0的数组。如果无，则使用十字形结构元素（连通性= 1）。out：ndarray，可选用于存储形态结果的数组。如果None传递，将分配一个新的数组。
返回：out：数组，与image相同的形状和类型形态学白色礼帽的结果。

例子

>>> # Subtract grey background from bright peak
>>> import numpy as np
>>> from skimage.morphology import square
>>> bright_on_grey = 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_grey, 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)

  • 黔ICP备2021005045号