`skimage.filters.rank`#

`skimage.filters.rank.autolevel`	使用局部直方图自动调整图像级别。
`skimage.filters.rank.autolevel_percentile`	返回图像的灰度局部自动级别。
`skimage.filters.rank.enhance_contrast`	增强图像的对比度。
`skimage.filters.rank.enhance_contrast_percentile`	增强图像的对比度。
`skimage.filters.rank.entropy`	局部熵。
`skimage.filters.rank.equalize`	使用局部直方图均衡化图像。
`skimage.filters.rank.geometric_mean`	返回图像的局部几何平均值。
`skimage.filters.rank.gradient`	返回图像的局部梯度（即局部最大值 - 局部最小值）。
`skimage.filters.rank.gradient_percentile`	返回图像的局部梯度（即局部最大值 - 局部最小值）。
`skimage.filters.rank.majority`	将每个像素分配为其邻域中最常见的值。
`skimage.filters.rank.maximum`	返回图像的局部最大值。
`skimage.filters.rank.mean`	返回图像的局部均值。
`skimage.filters.rank.mean_bilateral`	应用一个平坦核的双边滤波器。
`skimage.filters.rank.mean_percentile`	返回图像的局部均值。
`skimage.filters.rank.median`	返回图像的局部中值。
`skimage.filters.rank.minimum`	返回图像的局部最小值。
`skimage.filters.rank.modal`	返回图像的局部模式。
`skimage.filters.rank.noise_filter`	噪声特征。
`skimage.filters.rank.otsu`	每个像素的局部Otsu阈值。
`skimage.filters.rank.percentile`	返回图像的局部百分位数。
`skimage.filters.rank.pop`	返回局部像素的数量（人口）。
`skimage.filters.rank.pop_bilateral`	返回局部像素的数量（人口）。
`skimage.filters.rank.pop_percentile`	返回局部像素的数量（人口）。
`skimage.filters.rank.subtract_mean`	返回从其局部均值中减去的图像。
`skimage.filters.rank.subtract_mean_percentile`	返回从其局部均值中减去的图像。
`skimage.filters.rank.sum`	返回像素的局部和。
`skimage.filters.rank.sum_bilateral`	应用一个平坦核的双边滤波器。
`skimage.filters.rank.sum_percentile`	返回像素的局部和。
`skimage.filters.rank.threshold`	图像的局部阈值。
`skimage.filters.rank.threshold_percentile`	图像的局部阈值。
`skimage.filters.rank.windowed_histogram`	归一化滑动窗口直方图

skimage.filters.rank.autolevel(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

使用局部直方图自动调整图像级别。

此过滤器局部拉伸灰度值的直方图，以覆盖从“白色”到“黑色”的整个值范围。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import autolevel
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> auto = autolevel(img, disk(5))
>>> auto_vol = autolevel(volume, ball(5))

排序过滤器

Rank filters

skimage.filters.rank.autolevel_percentile(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, p0=0, p1=1)[源代码][源代码]#

返回图像的灰度局部自动级别。

此过滤器局部拉伸灰度值的直方图，以覆盖从“白色”到“黑色”的整个值范围。

在过滤器中，仅考虑百分位数 [p0, p1] 之间的灰度值。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
p0, p1浮点数在 [0, …, 1] 之间: 定义用于计算值的 [p0, p1] 百分位区间。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

排序过滤器

Rank filters

skimage.filters.rank.enhance_contrast(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

增强图像的对比度。

如果像素灰度值更接近局部最大值，则此方法将每个像素替换为局部最大值；否则，将其替换为局部最小值。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import enhance_contrast
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> out = enhance_contrast(img, disk(5))
>>> out_vol = enhance_contrast(volume, ball(5))

排序过滤器

Rank filters

skimage.filters.rank.enhance_contrast_percentile(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, p0=0, p1=1)[源代码][源代码]#

增强图像的对比度。

如果像素灰度值更接近局部最大值而非局部最小值，则该像素将被局部最大值替换。否则，它将被局部最小值替换。

在过滤器中，仅考虑百分位数 [p0, p1] 之间的灰度值。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
p0, p1浮点数在 [0, …, 1] 之间: 定义用于计算值的 [p0, p1] 百分位区间。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

排序过滤器

Rank filters

skimage.filters.rank.entropy(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

局部熵。

熵是使用以2为底的对数计算的，即滤波器返回编码局部灰度级分布所需的最小比特数。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (float): 输出图像。

参考文献

[1]

https://en.wikipedia.org/wiki/Entropy_(information_theory)

示例

>>> from skimage import data
>>> from skimage.filters.rank import entropy
>>> from skimage.morphology import disk, ball
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> ent = entropy(img, disk(5))
>>> ent_vol = entropy(volume, ball(5))

着色灰度图像

Tinting gray-scale images

熵

Entropy

排序过滤器

Rank filters

skimage.filters.rank.equalize(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

使用局部直方图均衡化图像。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import equalize
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> equ = equalize(img, disk(5))
>>> equ_vol = equalize(volume, ball(5))

局部直方图均衡化

Local Histogram Equalization

排序过滤器

Rank filters

skimage.filters.rank.geometric_mean(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回图像的局部几何平均值。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

参考文献

[1]

Gonzalez, R. C. 和 Woods, R. E. 《数字图像处理（第三版）》. Prentice-Hall Inc, 2006.

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import mean
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> avg = geometric_mean(img, disk(5))
>>> avg_vol = geometric_mean(volume, ball(5))

skimage.filters.rank.gradient(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回图像的局部梯度（即局部最大值 - 局部最小值）。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import gradient
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> out = gradient(img, disk(5))
>>> out_vol = gradient(volume, ball(5))

分水岭变换的标记

Markers for watershed transform

排序过滤器

Rank filters

skimage.filters.rank.gradient_percentile(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, p0=0, p1=1)[源代码][源代码]#

返回图像的局部梯度（即局部最大值 - 局部最小值）。

在过滤器中，仅考虑百分位数 [p0, p1] 之间的灰度值。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
p0, p1浮点数在 [0, …, 1] 之间: 定义用于计算值的 [p0, p1] 百分位区间。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

skimage.filters.rank.majority(image, footprint, *, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

将每个像素分配为其邻域中最常见的值。

参数:

图像ndarray: 图像数组 (uint8, uint16 数组)。
足迹二维数组（整数或浮点数）: 以二维数组表示的邻域，数组元素为1和0。
出ndarray（整数或浮点数），可选: 如果为 None，将分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_yint, 可选: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

示例

>>> from skimage import data
>>> from skimage.filters.rank import majority
>>> from skimage.morphology import disk, ball
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> maj_img = majority(img, disk(5))
>>> maj_img_vol = majority(volume, ball(5))

skimage.filters.rank.maximum(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回图像的局部最大值。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

参见

skimage.morphology.dilation

注释

较低的算法复杂度使得 skimage.filters.rank.maximum 对于较大的图像和结构元素更加高效。

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import maximum
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> out = maximum(img, disk(5))
>>> out_vol = maximum(volume, ball(5))

排序过滤器

Rank filters

skimage.filters.rank.mean(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回图像的局部均值。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import mean
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> avg = mean(img, disk(5))
>>> avg_vol = mean(volume, ball(5))

均值滤波器

Mean filters

分割人类细胞（在有丝分裂中）

Segment human cells (in mitosis)

排序过滤器

Rank filters

skimage.filters.rank.mean_bilateral(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, s0=10, s1=10)[源代码][源代码]#

应用一个平坦核的双边滤波器。

这是一个边缘保持和噪声减少的去噪滤波器。它根据像素的空间接近度和辐射相似性进行平均。

空间接近度是通过仅考虑由足迹（结构元素）给出的局部像素邻域来测量的。

辐射相似性由灰度区间 [g-s0, g+s1] 定义，其中 g 是当前像素的灰度值。

只有属于足迹且灰度值在此区间内的像素才会被平均。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
s0, s1整数: 定义围绕中心像素灰度值的 [s0, s1] 区间，以用于计算值。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

参见

skimage.restoration.denoise_bilateral

示例

>>> import numpy as np
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import mean_bilateral
>>> img = data.camera().astype(np.uint16)
>>> bilat_img = mean_bilateral(img, disk(20), s0=10,s1=10)

均值滤波器

Mean filters

排序过滤器

Rank filters

skimage.filters.rank.mean_percentile(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, p0=0, p1=1)[源代码][源代码]#

返回图像的局部均值。

在过滤器中，仅考虑百分位数 [p0, p1] 之间的灰度值。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
p0, p1浮点数在 [0, …, 1] 之间: 定义用于计算值的 [p0, p1] 百分位区间。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

均值滤波器

Mean filters

skimage.filters.rank.median(image, footprint=None, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回图像的局部中值。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 以1和0的ndarray表示的邻域。如果为None，则使用大小为3的完整正方形。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

参见

skimage.filters.median: 实现了一个处理浮点精度图像的中值滤波。

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import median
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> med = median(img, disk(5))
>>> med_vol = median(volume, ball(5))

分水岭变换的标记

Markers for watershed transform

排序过滤器

Rank filters

skimage.filters.rank.minimum(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回图像的局部最小值。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

参见

skimage.morphology.erosion

注释

较低的算法复杂度使得 skimage.filters.rank.minimum 对于较大的图像和结构元素更加高效。

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import minimum
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> out = minimum(img, disk(5))
>>> out_vol = minimum(volume, ball(5))

排序过滤器

Rank filters

skimage.filters.rank.modal(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回图像的局部模式。

模式是局部直方图中出现次数最多的值。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import modal
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> out = modal(img, disk(5))
>>> out_vol = modal(volume, ball(5))

skimage.filters.rank.noise_filter(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

噪声特征。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

参考文献

[1]

N. Hashimoto et al. Referenceless image quality evaluation for whole slide imaging. J Pathol Inform 2012;3:9.

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import noise_filter
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> out = noise_filter(img, disk(5))
>>> out_vol = noise_filter(volume, ball(5))

skimage.filters.rank.otsu(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

每个像素的局部Otsu阈值。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

参考文献

[1]

https://en.wikipedia.org/wiki/Otsu’s_method

示例

>>> from skimage import data
>>> from skimage.filters.rank import otsu
>>> from skimage.morphology import disk, ball
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> local_otsu = otsu(img, disk(5))
>>> thresh_image = img >= local_otsu
>>> local_otsu_vol = otsu(volume, ball(5))
>>> thresh_image_vol = volume >= local_otsu_vol

阈值化

Thresholding

排序过滤器

Rank filters

skimage.filters.rank.percentile(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, p0=0)[源代码][源代码]#

返回图像的局部百分位数。

返回局部灰度分布的 p0 下百分位数值。

在过滤器中，仅考虑百分位数 [p0, p1] 之间的灰度值。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
p0浮点数在 [0, …, 1] 之间: 设置百分位数值。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

skimage.filters.rank.pop(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回局部像素的数量（人口）。

像素数量定义为包含在足迹和掩膜中的像素数量。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

示例

>>> from skimage.morphology import square, cube # Need to add 3D example
>>> import skimage.filters.rank as rank
>>> img = 255 * 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)
>>> rank.pop(img, square(3))
array([[4, 6, 6, 6, 4],
       [6, 9, 9, 9, 6],
       [6, 9, 9, 9, 6],
       [6, 9, 9, 9, 6],
       [4, 6, 6, 6, 4]], dtype=uint8)

skimage.filters.rank.pop_bilateral(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, s0=10, s1=10)[源代码][源代码]#

返回局部像素的数量（人口）。

像素数量被定义为包含在足迹和掩膜中的像素数量。此外，像素的灰度值必须在区间 [g-s0, g+s1] 内，其中 g 是中心像素的灰度值。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
s0, s1整数: 定义围绕中心像素灰度值的 [s0, s1] 区间，以用于计算值。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

示例

>>> import numpy as np
>>> from skimage.morphology import square
>>> import skimage.filters.rank as rank
>>> img = 255 * 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.uint16)
>>> rank.pop_bilateral(img, square(3), s0=10, s1=10)
array([[3, 4, 3, 4, 3],
       [4, 4, 6, 4, 4],
       [3, 6, 9, 6, 3],
       [4, 4, 6, 4, 4],
       [3, 4, 3, 4, 3]], dtype=uint16)

skimage.filters.rank.pop_percentile(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, p0=0, p1=1)[源代码][源代码]#

返回局部像素的数量（人口）。

像素数量定义为包含在足迹和掩膜中的像素数量。

在过滤器中，仅考虑百分位数 [p0, p1] 之间的灰度值。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
p0, p1浮点数在 [0, …, 1] 之间: 定义用于计算值的 [p0, p1] 百分位区间。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

skimage.filters.rank.subtract_mean(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回从其局部均值中减去的图像。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

注释

减去均值可能会引入下溢。为了补偿这种潜在的下溢，得到的差值按2的因子缩小，并偏移 n_bins / 2 - 1，即局部直方图的中值（对于16位图像，n_bins = max(3, image.max()) +1，否则为256）。

示例

>>> from skimage import data
>>> from skimage.morphology import disk, ball
>>> from skimage.filters.rank import subtract_mean
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> out = subtract_mean(img, disk(5))
>>> out_vol = subtract_mean(volume, ball(5))

skimage.filters.rank.subtract_mean_percentile(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, p0=0, p1=1)[源代码][源代码]#

返回从其局部均值中减去的图像。

在过滤器中，仅考虑百分位数 [p0, p1] 之间的灰度值。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
p0, p1浮点数在 [0, …, 1] 之间: 定义用于计算值的 [p0, p1] 百分位区间。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

skimage.filters.rank.sum(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

返回像素的局部和。

请注意，根据输入数组的数据类型，求和可能会溢出。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

示例

>>> from skimage.morphology import square, cube # Need to add 3D example
>>> import skimage.filters.rank as rank         # Cube seems to fail but
>>> img = np.array([[0, 0, 0, 0, 0],            # Ball can pass
...                 [0, 1, 1, 1, 0],
...                 [0, 1, 1, 1, 0],
...                 [0, 1, 1, 1, 0],
...                 [0, 0, 0, 0, 0]], dtype=np.uint8)
>>> rank.sum(img, square(3))
array([[1, 2, 3, 2, 1],
       [2, 4, 6, 4, 2],
       [3, 6, 9, 6, 3],
       [2, 4, 6, 4, 2],
       [1, 2, 3, 2, 1]], dtype=uint8)

skimage.filters.rank.sum_bilateral(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, s0=10, s1=10)[源代码][源代码]#

应用一个平坦核的双边滤波器。

这是一个边缘保持和噪声减少的去噪滤波器。它根据像素的空间接近度和辐射相似性进行平均。

空间接近度是通过仅考虑由足迹（结构元素）给出的局部像素邻域来测量的。

辐射相似性由灰度区间 [g-s0, g+s1] 定义，其中 g 是当前像素的灰度值。

只有属于足迹且灰度值在此区间内的像素才会被求和。

请注意，根据输入数组的数据类型，求和可能会溢出。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
s0, s1整数: 定义围绕中心像素灰度值的 [s0, s1] 区间，以用于计算值。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

参见

skimage.restoration.denoise_bilateral

示例

>>> import numpy as np
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import sum_bilateral
>>> img = data.camera().astype(np.uint16)
>>> bilat_img = sum_bilateral(img, disk(10), s0=10, s1=10)

skimage.filters.rank.sum_percentile(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, p0=0, p1=1)[源代码][源代码]#

返回像素的局部和。

在过滤器中，仅考虑百分位数 [p0, p1] 之间的灰度值。

请注意，根据输入数组的数据类型，求和可能会溢出。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
p0, p1浮点数在 [0, …, 1] 之间: 定义用于计算值的 [p0, p1] 百分位区间。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

skimage.filters.rank.threshold(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, shift_z=0)[源代码][源代码]#

图像的局部阈值。

生成的二进制掩码在中心像素的灰度值大于局部均值时为真。

参数:

图像([P,] M, N) ndarray (uint8, uint16): 输入图像。
足迹ndarray: 表示为 1 和 0 的 ndarray 的邻域。
出([P,] M, N) 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y, shift_z整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。

返回:

出([P,] M, N) ndarray (与输入图像相同的dtype): 输出图像。

示例

>>> from skimage.morphology import square, cube # Need to add 3D example
>>> from skimage.filters.rank import threshold
>>> img = 255 * 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)
>>> threshold(img, square(3))
array([[0, 0, 0, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 0, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 0, 0, 0]], dtype=uint8)

skimage.filters.rank.threshold_percentile(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, p0=0)[源代码][源代码]#

图像的局部阈值。

生成的二进制掩码在中心像素的灰度值大于局部均值时为真。

在过滤器中，仅考虑百分位数 [p0, p1] 之间的灰度值。

参数:

图像2-D 数组 (uint8, uint16): 输入图像。
足迹二维数组: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（与输入相同的 dtype）: 如果为 None，则分配一个新数组。
掩码ndarray: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_y整数: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
p0浮点数在 [0, …, 1] 之间: 设置百分位数值。

返回:

出2-D 数组 (与输入图像相同的 dtype): 输出图像。

skimage.filters.rank.windowed_histogram(image, footprint, out=None, mask=None, shift_x=0, shift_y=0, n_bins=None)[源代码][源代码]#

归一化滑动窗口直方图

参数:

图像二维数组（整数或浮点数）: 输入图像。
足迹二维数组（整数或浮点数）: 以二维数组表示的邻域，数组元素为1和0。
出2-D 数组（整数或浮点数），可选: 如果为 None，则分配一个新数组。
掩码ndarray（整数或浮点数），可选: 定义图像中包含在局部邻域内的区域（>0）的掩码数组。如果为 None，则使用整个图像（默认）。
shift_x, shift_yint, 可选: 添加到足迹中心点的偏移量。偏移量受足迹尺寸限制（中心点必须在给定的足迹内）。
n_bins整数或无: 直方图的箱数。如果传入 None，则默认为 image.max() + 1。

返回:

出3-D 数组 (浮点型): 维度数组 (H,W,N)，其中 (H,W) 是输入图像的维度，N 是 n_bins 或 ``image.max() + 1``（如果未提供参数值）。实际上，每个像素是一个 N 维特征向量，即直方图。特征向量中元素的总和将为 1，除非窗口中没有像素同时被 footprint 和 mask 覆盖，在这种情况下，所有元素都将为 0。

示例

>>> from skimage import data
>>> from skimage.filters.rank import windowed_histogram
>>> from skimage.morphology import disk, ball
>>> import numpy as np
>>> img = data.camera()
>>> rng = np.random.default_rng()
>>> volume = rng.integers(0, 255, size=(10,10,10), dtype=np.uint8)
>>> hist_img = windowed_histogram(img, disk(5))

滑动窗口直方图

Sliding window histogram

skimage.filters.rank#

`skimage.filters.rank`#