skimage.util#
通用实用函数。
此模块包含一些实用函数，用于处理一般图像。
在数组上并行地映射函数。 |
|
返回显示两幅图像差异的图像。 |
|
沿每个维度将数组 ar 裁剪 crop_width。 |
|
返回图像数据类型的强度限制，即 (min, max) 元组。 |
|
将图像转换为布尔格式。 |
|
将图像转换为浮点格式。 |
|
将图像转换为单精度（32 位）浮点格式。 |
|
将图像转换为双精度（64 位）浮点格式。 |
|
将图像转换为 16 位有符号整数格式。 |
|
将图像转换为 8 位无符号整数格式。 |
|
将图像转换为 16 位无符号整数格式。 |
|
反转图像。 |
|
为图像掩码上的坐标分配唯一的整数标签 |
|
对 scikit-image 文档字符串进行关键词搜索并打印结果。 |
|
将输入数组的值从 |
|
创建多个单通道或多通道图像的蒙太奇。 |
|
函数向浮点图像添加各种类型的随机噪声。 |
|
在 ar_shape 上找到 n_points 个均匀分布的点。 |
|
返回一个图像，该图像具有大约 `n_points` 个均匀分布的非零像素。 |
|
沿着给定的轴切片图像。 |
|
从二维数组中删除重复的行。 |
|
输入 n 维数组的块视图（使用重新跨越）。 |
|
输入 n 维数组的滚动窗口视图。 |
- skimage.util.apply_parallel(function, array, chunks=None, depth=0, mode=None, extra_arguments=(), extra_keywords=None, *, dtype=None, compute=None, channel_axis=None)[source]#
在数组上并行地映射函数。
将数组拆分为可能重叠的给定深度和边界类型的块，并行地在块上调用给定函数，组合块并返回结果数组。
- 参数:
- function函数
要映射的函数，它接受一个数组作为参数。
- arraynumpy 数组或 dask 数组
将对该数组应用函数。
- chunksint、元组或元组的元组，可选
单个整数被解释为应该在数组上平铺的正方形块的一边的长度。长度为
array.ndim的一个元组表示一个块的形状，它在数组上平铺。长度为ndim的元组列表，其中每个子元组是沿相应维度的块大小序列。如果为 None，则该数组将根据可用 cpu 的数量分解为块。有关块的更多信息，请参阅 此处 的文档。当 channel_axis 不为 None 时，元组可以为长度ndim - 1，并且沿通道轴将使用单个块。- depthint 或 int 序列，可选
添加的边界单元的深度。可以使用元组为每个数组轴指定不同的深度。默认为零。当 channel_axis 不为 None 时，并且提供了长度为
ndim - 1的元组，则沿通道轴将使用深度 0。- mode{‘reflect’, ‘symmetric’, ‘periodic’, ‘wrap’, ‘nearest’, ‘edge’}，可选
外部边界填充的类型。
- extra_arguments元组，可选
要传递给函数的参数元组。
- extra_keywords字典，可选
要传递给函数的关键字参数字典。
- dtype数据类型或 None，可选
function 输出的数据类型。如果为 None，Dask 将尝试通过在形状为
(1,) * ndim的数据上调用函数来推断它。对于期望 RGB 或多通道数据的函数，这可能会有问题。在这种情况下，用户应该手动指定此 dtype 参数。在版本 0.18 中添加：
dtype在 0.18 中添加。- computebool，可选
如果为
True，则急切地计算并返回 NumPy 数组。如果为False，则惰性地计算并返回 Dask 数组。如果为None（默认），则根据提供的数组类型进行计算（对于 NumPy 数组为急切，对于 Dask 数组为惰性）。- channel_axisint 或 None，可选
如果为 None，则假定该图像为灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
- 返回值:
- outndarray 或 dask 数组
返回应用操作的结果。类型取决于
compute参数。
备注
Numpy 边缘模式 ‘symmetric’、‘wrap’ 和 ‘edge’ 分别转换为等效的
dask边界模式 ‘reflect’、‘periodic’ 和 ‘nearest’。设置compute=False有助于链接后续操作。例如，区域选择以预览结果或将大型数据存储到磁盘而不是加载到内存中。
- skimage.util.compare_images(image0, image1, *, method='diff', n_tiles=(8, 8))[source]#
返回显示两幅图像差异的图像。
在版本 0.16 中添加。
- 参数:
- image0, image1ndarray，形状 (M, N)
要处理的图像，必须具有相同的形状。
在版本 0.24 中更改： image1 和 image2 分别重命名为 image0 和 image1。
- method字符串，可选
用于比较的方法。有效值为 {‘diff’, ‘blend’, ‘checkerboard’}。详细信息请参阅备注部分。
在版本 0.24 中更改： 此参数和以下参数为关键字专用。
- n_tiles元组，可选
仅用于 checkerboard 方法。指定将图像划分的瓦片数量（行、列）。
- 返回值:
- comparisonndarray，形状 (M, N)
显示差异的图像。
备注
'diff'计算两幅图像之间的绝对差值。'blend'计算平均值。'checkerboard'创建维度为 n_tiles 的瓦片，这些瓦片交替显示第一张图像和第二张图像。请注意，图像必须是二维的才能使用棋盘格方法进行比较。
- skimage.util.crop(ar, crop_width, copy=False, order='K')[source]#
沿每个维度将数组 ar 裁剪 crop_width。
- 参数:
- arN 维数组类
输入数组。
- crop_width{序列, 整数}
从每个轴边缘移除的值数量。
((before_1, after_1),…(before_N, after_N))指定每个轴开始和结束处的唯一裁剪宽度。((before, after),) or (before, after)指定每个轴的固定开始和结束裁剪。(n,)或n对于整数n是 before = after =n的快捷方式，适用于所有轴。- copy布尔值, 可选
如果为 True，则确保返回的数组是连续的副本。通常，裁剪操作将返回底层输入数组的不连续视图。
- order{‘C’, ‘F’, ‘A’, ‘K’}, 可选
如果
copy==True，则控制副本的内存布局。参见np.copy。
- 返回值:
- cropped数组
裁剪后的数组。如果
copy=False（默认），则它是输入数组的切片视图。
- skimage.util.dtype_limits(image, clip_negative=False)[source]#
返回图像数据类型的强度限制，即 (min, max) 元组。
- 参数:
- imagendarray
输入图像。
- clip_negative布尔值, 可选
如果为 True，则即使图像数据类型允许负值，也会剪切负值范围（即对于最小强度返回 0）。
- 返回值:
- imin, imax元组
强度下限和上限。
- skimage.util.img_as_bool(image, force_copy=False)[source]#
将图像转换为布尔格式。
- 参数:
- imagendarray
输入图像。
- force_copy布尔值, 可选
强制复制数据，无论其当前数据类型。
- 返回值:
- out布尔值 ndarray (bool_)
输出图像。
备注
输入数据类型正值范围的上半部分为 True，下半部分为 False。所有负值（如果存在）为 False。
- skimage.util.img_as_float(image, force_copy=False)[source]#
将图像转换为浮点格式。
此函数类似于
img_as_float64，但不会将较低精度的浮点数组转换为 float64。- 参数:
- imagendarray
输入图像。
- force_copy布尔值, 可选
强制复制数据，无论其当前数据类型。
- 返回值:
- out浮点型 ndarray
输出图像。
备注
从无符号或有符号数据类型转换时，浮点图像的范围为 [0.0, 1.0] 或 [-1.0, 1.0]。如果输入图像具有浮点类型，则强度值不会修改，并且可以超出范围 [0.0, 1.0] 或 [-1.0, 1.0]。
- skimage.util.img_as_float32(image, force_copy=False)[source]#
将图像转换为单精度（32 位）浮点格式。
- 参数:
- imagendarray
输入图像。
- force_copy布尔值, 可选
强制复制数据，无论其当前数据类型。
- 返回值:
- outfloat32 型 ndarray
输出图像。
备注
从无符号或有符号数据类型转换时，浮点图像的范围为 [0.0, 1.0] 或 [-1.0, 1.0]。如果输入图像具有浮点类型，则强度值不会修改，并且可以超出范围 [0.0, 1.0] 或 [-1.0, 1.0]。
- skimage.util.img_as_float64(image, force_copy=False)[source]#
将图像转换为双精度（64 位）浮点格式。
- 参数:
- imagendarray
输入图像。
- force_copy布尔值, 可选
强制复制数据，无论其当前数据类型。
- 返回值:
- outfloat64 型 ndarray
输出图像。
备注
从无符号或有符号数据类型转换时，浮点图像的范围为 [0.0, 1.0] 或 [-1.0, 1.0]。如果输入图像具有浮点类型，则强度值不会修改，并且可以超出范围 [0.0, 1.0] 或 [-1.0, 1.0]。
- skimage.util.img_as_int(image, force_copy=False)[source]#
将图像转换为 16 位有符号整数格式。
- 参数:
- imagendarray
输入图像。
- force_copy布尔值, 可选
强制复制数据，无论其当前数据类型。
- 返回值:
- outint16 型 ndarray
输出图像。
备注
值在 -32768 到 32767 之间缩放。如果输入数据类型是正值（例如，uint8），则输出图像仍然只有正值。
- skimage.util.img_as_ubyte(image, force_copy=False)[source]#
将图像转换为 8 位无符号整数格式。
- 参数:
- imagendarray
输入图像。
- force_copy布尔值, 可选
强制复制数据，无论其当前数据类型。
- 返回值:
- outubyte (uint8) 型 ndarray
输出图像。
备注
负输入值将被剪切。正值在 0 到 255 之间缩放。
- skimage.util.img_as_uint(image, force_copy=False)[source]#
将图像转换为 16 位无符号整数格式。
- 参数:
- imagendarray
输入图像。
- force_copy布尔值, 可选
强制复制数据，无论其当前数据类型。
- 返回值:
- outuint16 型 ndarray
输出图像。
备注
负输入值将被剪切。正值在 0 到 65535 之间缩放。
- skimage.util.invert(image, signed_float=False)[source]#
反转图像。
反转输入图像的强度范围，使得数据类型最大值现在变为数据类型最小值，反之亦然。此操作略微不同，具体取决于输入数据类型
无符号整数：从数据类型最大值中减去图像
有符号整数：从 -1 中减去图像（参见注释）
浮点数：从 1 中减去图像（如果 signed_float 为 False，则假设图像为无符号），或从 0 中减去（如果 signed_float 为 True）。
请参见示例以了解详细说明。
- 参数:
- imagendarray
输入图像。
- signed_float布尔值, 可选
如果为 True 且图像类型为 float，则假设范围为 [-1, 1]。如果为 False 且图像类型为 float，则假设范围为 [0, 1]。
- 返回值:
- invertedndarray
反转后的图像。
备注
理想情况下，对于有符号整数，我们只需乘以 -1。但是，有符号整数范围是不对称的。例如，对于 np.int8，可能的取值范围是 [-128, 127]，因此 -128 * -1 等于 -128！通过从 -1 中减去，我们正确地将最大数据类型值映射到最小值。
示例
>>> img = np.array([[100, 0, 200], ... [ 0, 50, 0], ... [ 30, 0, 255]], np.uint8) >>> invert(img) array([[155, 255, 55], [255, 205, 255], [225, 255, 0]], dtype=uint8) >>> img2 = np.array([[ -2, 0, -128], ... [127, 0, 5]], np.int8) >>> invert(img2) array([[ 1, -1, 127], [-128, -1, -6]], dtype=int8) >>> img3 = np.array([[ 0., 1., 0.5, 0.75]]) >>> invert(img3) array([[1. , 0. , 0.5 , 0.25]]) >>> img4 = np.array([[ 0., 1., -1., -0.25]]) >>> invert(img4, signed_float=True) array([[-0. , -1. , 1. , 0.25]])
- skimage.util.label_points(coords, output_shape)[source]#
为图像掩码上的坐标分配唯一的整数标签
- 参数:
- coords: ndarray
具有 D 维的 N 个坐标数组
- output_shape: 元组
标记 coords 的掩码的形状
- 返回值:
- labels: ndarray
一个包含零的掩码，在 coords 处包含唯一的整数标签
备注
标签分配给转换为整数的坐标，并被认为从 0 开始。
超出掩码范围的坐标将引发 IndexError。
负坐标将引发 ValueError
示例
>>> import numpy as np >>> from skimage.util._label import label_points >>> coords = np.array([[0, 1], [2, 2]]) >>> output_shape = (5, 5) >>> mask = label_points(coords, output_shape) >>> mask array([[0, 1, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], dtype=uint64)
- skimage.util.lookfor(what)[source]#
对 scikit-image 文档字符串进行关键词搜索并打印结果。
警告
此函数也可能打印不是 scikit-image 公共 API 部分的结果。
- 参数:
- what字符串
要查找的词语。
示例
>>> import skimage as ski >>> ski.util.lookfor('regular_grid') Search results for 'regular_grid' --------------------------------- skimage.util.regular_grid Find `n_points` regularly spaced along `ar_shape`. skimage.util.lookfor Do a keyword search on scikit-image docstrings and print results.
- skimage.util.map_array(input_arr, input_vals, output_vals, out=None)[source]#
将输入数组的值从
input_vals映射到output_vals。- 参数:
- input_arrint 数组，形状 (M[, …])
输入标签图像。
- input_valsint 数组，形状 (K,)
要映射的值。
- output_vals数组，形状 (K,)
要映射到的值。
- out: 数组，与 `input_arr` 形状相同
输出数组。如果未提供，将创建。它应该与 output_vals 具有相同的 dtype。
- 返回值:
- out数组，与 input_arr 形状相同
映射值的数组。
备注
如果 input_arr 包含未被 input_vals 覆盖的值，则它们将设置为 0。
示例
>>> import numpy as np >>> import skimage as ski >>> ski.util.map_array( ... input_arr=np.array([[0, 2, 2, 0], [3, 4, 5, 0]]), ... input_vals=np.array([1, 2, 3, 4, 6]), ... output_vals=np.array([6, 7, 8, 9, 10]), ... ) array([[0, 7, 7, 0], [8, 9, 0, 0]])
- skimage.util.montage(arr_in, fill='mean', rescale_intensity=False, grid_shape=None, padding_width=0, *, channel_axis=None)[source]#
创建多个单通道或多通道图像的蒙太奇。
从表示一组形状相同的单通道（灰度）或多通道（彩色）图像的输入数组创建矩形蒙太奇。
例如，使用以下 arr_in 调用
montage(arr_in)1
2
3
将返回
1
2
3
其中“*”补丁将由 fill 参数决定。
- 参数:
- arr_inndarray，形状 (K, M, N[, C])
表示一组形状相同的 K 幅图像的数组。
- fillfloat 或 array-like 的 float 或 ‘mean’，可选
用于填充填充区域和/或输出数组中多余图块的值。对于单通道集合，它必须是 float。对于多通道集合，它必须是形状为通道数量的 array-like。如果 mean，则使用所有图像的平均值。
- rescale_intensitybool，可选
是否将每个图像的强度重新缩放到 [0, 1]。
- grid_shape元组，可选
蒙太奇的所需网格形状 (ntiles_row, ntiles_column)。默认纵横比为正方形。
- padding_widthint，可选
图块之间以及图块与边框之间的间距大小。如果非零，则使单个图像的边界更容易感知。
- channel_axisint 或 None，可选
如果为 None，则假定该图像为灰度（单通道）图像。否则，此参数指示数组的哪个轴对应于通道。
- 返回值:
- arr_out(K*(M+p)+p, K*(N+p)+p[, C]) ndarray
具有将输入图像粘合在一起的输出数组（包括填充 p）。
示例
>>> import numpy as np >>> from skimage.util import montage >>> arr_in = np.arange(3 * 2 * 2).reshape(3, 2, 2) >>> arr_in array([[[ 0, 1], [ 2, 3]], [[ 4, 5], [ 6, 7]], [[ 8, 9], [10, 11]]]) >>> arr_out = montage(arr_in) >>> arr_out.shape (4, 4) >>> arr_out array([[ 0, 1, 4, 5], [ 2, 3, 6, 7], [ 8, 9, 5, 5], [10, 11, 5, 5]]) >>> arr_in.mean() 5.5 >>> arr_out_nonsquare = montage(arr_in, grid_shape=(1, 3)) >>> arr_out_nonsquare array([[ 0, 1, 4, 5, 8, 9], [ 2, 3, 6, 7, 10, 11]]) >>> arr_out_nonsquare.shape (2, 6)
- skimage.util.random_noise(image, mode='gaussian', rng=None, clip=True, **kwargs)[source]#
函数向浮点图像添加各种类型的随机噪声。
- 参数:
- imagendarray
输入图像数据。将转换为浮点数。
- modestr，可选
以下字符串之一，选择要添加的噪声类型
- ‘gaussian’（默认）
高斯分布的加性噪声。
- ‘localvar’
高斯分布的加性噪声，在 image 的每个点具有指定的局部方差。
- ‘poisson’
从数据生成的泊松分布噪声。
- ‘salt’
用 1 替换随机像素。
- ‘pepper’
用 0（对于无符号图像）或 -1（对于有符号图像）替换随机像素。
- ‘s&p’
用 1 或 low_val 替换随机像素，其中 low_val 对于无符号图像为 0，对于有符号图像为 -1。
- ‘speckle’
使用
out = image + n * image的乘性噪声，其中n是具有指定均值和方差的高斯噪声。
- rng{
numpy.random.Generator, int}，可选 伪随机数生成器。默认情况下，使用 PCG64 生成器（参见
numpy.random.default_rng()）。如果 rng 是一个 int，则它用于为生成器播种。- clipbool，可选
如果为 True（默认），则在应用模式 ‘speckle’、‘poisson’ 和 ‘gaussian’ 的噪声后，输出将被裁剪。这是维护适当图像数据范围所必需的。如果为 False，则不应用裁剪，输出可能超出范围 [-1, 1]。
- meanfloat，可选
随机分布的均值。用于‘gaussian’ 和 ‘speckle’。默认值：0。
- varfloat，可选
随机分布的方差。用于‘gaussian’ 和 ‘speckle’。注意：方差 = (标准差) ** 2。默认值：0.01
- local_varsndarray，可选
与 image 形状相同的正浮点数数组，定义每个图像点的局部方差。用于‘localvar’。
- amountfloat，可选
用噪声替换图像像素的比例，范围在 [0, 1] 内。用于‘salt’、‘pepper’ 和 ‘salt & pepper’。默认值：0.05
- salt_vs_pepperfloat，可选
‘s&p’ 的盐噪声与胡椒噪声的比例，范围在 [0, 1] 内。较高的值表示更多的盐。默认值：0.5（数量相等）
- 返回值:
- outndarray
范围在 [0, 1] 内的输出浮点图像数据，或者如果输入 image 是无符号的或有符号的，则范围在 [-1, 1] 内。
备注
斑点、泊松、局部变量和高斯噪声可能会生成超出有效图像范围的噪声。默认情况下，这些值将被裁剪（而不是混叠），但可以通过设置 clip=False 来保留它们。请注意，在这种情况下，输出可能包含超出范围 [0, 1] 或 [-1, 1] 的值。谨慎使用此选项。
由于中间计算中普遍存在仅包含正浮点图像的情况，因此仅凭 dtype 无法推断输入是否已签名。相反，会明确搜索负值。只有在找到负值的情况下，该函数才假设输入已签名。意外结果只会在很少的、暴露不佳的情况下发生（例如，如果所有值在有符号 image 中都超过 50% 的灰色）。在这种情况下，手动将输入缩放到正域将解决问题。
泊松分布仅定义为正整数。要应用此噪声类型，将找到图像中唯一值的数量，并使用两个的下一个圆形幂来放大浮点结果，然后将其缩放到浮点图像范围。
要对有符号图像生成泊松噪声，将有符号图像在浮点域中临时转换为无符号图像，生成泊松噪声，然后将其返回到原始范围。
- skimage.util.regular_grid(ar_shape, n_points)[source]#
在 ar_shape 上找到 n_points 个均匀分布的点。
返回的点（作为切片）应该尽可能接近立方体空间。本质上，这些点的间隔为输入数组大小的 N 次根，其中 N 是维数。但是，如果数组维度无法容纳完整的步长，则会“丢弃”它，并且仅对剩余的维度进行计算。
- 参数:
- ar_shapeint 的 array-like
嵌入网格的空间的形状。
len(ar_shape)是维数。- n_pointsint
要嵌入空间的（近似）点数。
- 返回值:
- slices切片对象的元组
沿着 ar_shape 的每个维度的切片，使得所有切片的交集给出规则间隔点的坐标。
在版本 0.14.1 中更改： 在 scikit-image 0.14.1 和 0.15 中，返回类型从列表更改为元组，以确保 与 Numpy 1.15 及更高版本兼容。如果您的代码要求返回结果为列表，您可以使用以下代码将此函数的输出转换为列表：
>>> result = list(regular_grid(ar_shape=(3, 20, 40), n_points=8))
示例
>>> ar = np.zeros((20, 40)) >>> g = regular_grid(ar.shape, 8) >>> g (slice(5, None, 10), slice(5, None, 10)) >>> ar[g] = 1 >>> ar.sum() 8.0 >>> ar = np.zeros((20, 40)) >>> g = regular_grid(ar.shape, 32) >>> g (slice(2, None, 5), slice(2, None, 5)) >>> ar[g] = 1 >>> ar.sum() 32.0 >>> ar = np.zeros((3, 20, 40)) >>> g = regular_grid(ar.shape, 8) >>> g (slice(1, None, 3), slice(5, None, 10), slice(5, None, 10)) >>> ar[g] = 1 >>> ar.sum() 8.0
- skimage.util.regular_seeds(ar_shape, n_points, dtype=<class 'int'>)[source]#
返回一个图像，该图像具有大约 `n_points` 个均匀分布的非零像素。
- 参数:
- ar_shapeint 元组
所需输出图像的形状。
- n_pointsint
所需非零点的数量。
- dtypenumpy 数据类型，可选
所需的输出数据类型。
- 返回值:
- seed_imgint 或 bool 数组
所需的图像。
示例
>>> regular_seeds((5, 5), 4) array([[0, 0, 0, 0, 0], [0, 1, 0, 2, 0], [0, 0, 0, 0, 0], [0, 3, 0, 4, 0], [0, 0, 0, 0, 0]])
- skimage.util.slice_along_axes(image, slices, axes=None, copy=False)[source]#
沿着给定的轴切片图像。
- 参数:
- imagendarray
输入图像。
- slices2 元组 (a, b) 列表，其中 a < b。
对于 axes 中的每个轴，对应一个 2 元组
(min_val, max_val)来进行切片（与 Python 切片一样，max_val不包含在内）。- axesint 或元组，可选
与 slices 中给定的限制相对应的轴。如果为 None，则轴按升序排列，直到 slices 的长度。
- copy布尔值, 可选
如果为 True，请确保输出不是 image 的视图。
- 返回值:
- outndarray
对应于给定切片和轴的 image 区域。
示例
>>> from skimage import data >>> img = data.camera() >>> img.shape (512, 512) >>> cropped_img = slice_along_axes(img, [(0, 100)]) >>> cropped_img.shape (100, 512) >>> cropped_img = slice_along_axes(img, [(0, 100), (0, 100)]) >>> cropped_img.shape (100, 100) >>> cropped_img = slice_along_axes(img, [(0, 100), (0, 75)], axes=[1, 0]) >>> cropped_img.shape (75, 100)
- skimage.util.unique_rows(ar)[source]#
从二维数组中删除重复的行。
特别是，如果给定一个形状为 (Npoints, Ndim) 的坐标数组，它将删除重复的点。
- 参数:
- arndarray，形状 (M, N)
输入数组。
- 返回值:
- ar_outndarray，形状 (P, N)
输入数组的副本，已删除重复行。
- 引发:
- ValueError如果 ar 不是二维的。
备注
如果 ar 不是 C 连续的，则该函数将生成 ar 的副本，这将对大型输入数组的性能产生负面影响。
示例
>>> ar = np.array([[1, 0, 1], ... [0, 1, 0], ... [1, 0, 1]], np.uint8) >>> unique_rows(ar) array([[0, 1, 0], [1, 0, 1]], dtype=uint8)
- skimage.util.view_as_blocks(arr_in, block_shape)[source]#
输入 n 维数组的块视图（使用重新跨越）。
块是输入数组的非重叠视图。
- 参数:
- arr_inndarray，形状 (M[, …])
输入数组。
- block_shape元组
块的形状。每个维度必须能被 arr_in 的对应维度整除。
- 返回值:
- arr_outndarray
输入数组的块视图。
示例
>>> import numpy as np >>> from skimage.util.shape import view_as_blocks >>> A = np.arange(4*4).reshape(4,4) >>> A array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15]]) >>> B = view_as_blocks(A, block_shape=(2, 2)) >>> B[0, 0] array([[0, 1], [4, 5]]) >>> B[0, 1] array([[2, 3], [6, 7]]) >>> B[1, 0, 1, 1] 13
>>> A = np.arange(4*4*6).reshape(4,4,6) >>> A array([[[ 0, 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23]], [[24, 25, 26, 27, 28, 29], [30, 31, 32, 33, 34, 35], [36, 37, 38, 39, 40, 41], [42, 43, 44, 45, 46, 47]], [[48, 49, 50, 51, 52, 53], [54, 55, 56, 57, 58, 59], [60, 61, 62, 63, 64, 65], [66, 67, 68, 69, 70, 71]], [[72, 73, 74, 75, 76, 77], [78, 79, 80, 81, 82, 83], [84, 85, 86, 87, 88, 89], [90, 91, 92, 93, 94, 95]]]) >>> B = view_as_blocks(A, block_shape=(1, 2, 2)) >>> B.shape (4, 2, 3, 1, 2, 2) >>> B[2:, 0, 2] array([[[[52, 53], [58, 59]]], [[[76, 77], [82, 83]]]])
- skimage.util.view_as_windows(arr_in, window_shape, step=1)[source]#
输入 n 维数组的滚动窗口视图。
窗口是输入数组的重叠视图，相邻窗口通过一行或一列（或更高维度的索引）偏移。
- 参数:
- arr_inndarray，形状 (M[, …])
输入数组。
- window_shape整数或长度为 arr_in.ndim 的元组
定义滚动窗口视图的基本 n 维正交体（更广为人知的是超矩形 [1]）的形状。如果给定整数，则形状将为边长由其值给定的超立方体。
- step整数或长度为 arr_in.ndim 的元组
指示应执行提取的步长。如果给定整数，则步长在所有维度上都是均匀的。
- 返回值:
- arr_outndarray
(滚动) 输入数组的窗口视图。
备注
在涉及内存使用时，应非常小心地使用滚动视图。实际上，虽然“视图”与基本数组具有相同的内存占用空间，但当此“视图”在计算中使用时出现的实际数组通常比原始数组大得多，尤其是对于二维数组及更高维度的数组。
例如，让我们考虑一个大小为 (100, 100, 100) 的 3 维
float64数组。此数组大约需要 8*100**3 字节来存储，这只有 8 MB。如果一个人决定在这个数组上构建一个窗口为 (3, 3, 3) 的滚动视图，那么滚动视图的假设大小（如果一个人要对视图进行重塑）将大约为 8*(100-3+1)**3*3**3，大约为 203 MB！随着输入数组的维度变大，比例会变得更糟。参考文献
示例
>>> import numpy as np >>> from skimage.util.shape import view_as_windows >>> A = np.arange(4*4).reshape(4,4) >>> A array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15]]) >>> window_shape = (2, 2) >>> B = view_as_windows(A, window_shape) >>> B[0, 0] array([[0, 1], [4, 5]]) >>> B[0, 1] array([[1, 2], [5, 6]])
>>> A = np.arange(10) >>> A array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> window_shape = (3,) >>> B = view_as_windows(A, window_shape) >>> B.shape (8, 3) >>> B array([[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9]])
>>> A = np.arange(5*4).reshape(5, 4) >>> A array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15], [16, 17, 18, 19]]) >>> window_shape = (4, 3) >>> B = view_as_windows(A, window_shape) >>> B.shape (2, 2, 4, 3) >>> B array([[[[ 0, 1, 2], [ 4, 5, 6], [ 8, 9, 10], [12, 13, 14]], [[ 1, 2, 3], [ 5, 6, 7], [ 9, 10, 11], [13, 14, 15]]], [[[ 4, 5, 6], [ 8, 9, 10], [12, 13, 14], [16, 17, 18]], [[ 5, 6, 7], [ 9, 10, 11], [13, 14, 15], [17, 18, 19]]]])