util
Module: util
| skimage.util.apply_parallel（函数，数组） | 在数组中并行映射函数。 |
|---|---|
| skimage.util.copy_func（f，name） | 创建一个函数的副本。 |
| skimage.util.crop（ar，crop_width，copy，order） | 通过每个维度的crop_width裁剪数组。 |
| skimage.util.dtype_limits（image，clip_negative） | 返回强度限制，即 |
| skimage.util.img_as_bool（image，force_copy） | 将图像转换为布尔格式。 |
| skimage.util.img_as_float（image，force_copy） | 将图像转换为双精度（64位）浮点格式。 |
| skimage.util.img_as_int（image，force_copy） | 将图像转换为16位有符号整数格式。 |
| skimage.util.img_as_ubyte（image，force_copy） | 将图像转换为8位无符号整数格式。 |
| skimage.util.img_as_uint（image，force_copy） | 将图像转换为16位无符号整数格式。 |
| skimage.util.invert（图像） | 倒置图像。 |
| skimage.util.numpy_pad（array，pad_width，...） | 填充数组。 |
| skimage.util.pad（array，pad_width，mode，...） | 填充数组。 |
| skimage.util.random_noise（图片，模式，...） | 用于将各种类型的随机噪声添加到浮点图像。 |
| skimage.util.regular_grid（ar_shape，n_points） | 沿着ar_shape定期查找n_points。 |
| skimage.util.regular_seeds（ar_shape，n_points） | 以〜n\_points规则间隔的非零像素返回图像。 |
| skimage.util.unique_rows（AR） | 从二维数组中删除重复的行。 |
| skimage.util.view_as_blocks（arr_in，block_shape） | 输入n维数组的块视图（使用重新跨步）。 |
| skimage.util.view_as_windows（arr_in，...，step） | 输入n维数组的滚动窗口视图。 |
| skimage.util.arraycrop | arraycrop模块包含从n维数组的边缘裁剪值的函数。 |
| skimage.util.colormap | |
| skimage.util.dtype | |
| skimage.util.noise | |
| skimage.util.shape | |
| skimage.util.unique | |
apply_parallel
skimage.util.apply_parallel(function, array, chunks=None, depth=0, mode=None, extra_arguments=(), extra_keywords={})[source]
在数组中并行映射函数。
将数组拆分为可能重叠的给定深度和边界类型块，在块上并行调用给定函数，组合块并返回结果数组。
| 参数： | 函数：函数将数组作为参数映射的函数。array：numpy array该函数将应用于的数组。块：元组，元组或元组的元组，可选单个整数被解释为应该平铺在整个数组上的正方形块的一边的长度。一个长度为array.ndim的元组表示块的形状，并且它在整个数组中平铺。长度为ndim的元组列表，其中每个子元组是沿相应维度的一系列块大小。如果为None，则根据可用cpus的数量将数组分解为块。有关块的更多信息在这里的文档中。深度：int，可选Integer等于添加的边界单元的深度。默认为零。模式：{'反射'，'对称'，'周期'，'换行'，'最近'，'边缘'}，可选的外部边界填充类型。extra_arguments：元组，可选的要传递给函数的参数元组。extra_keywords：字典，可选的要传递给函数的关键字参数字典。 |
|---|
笔记
Numpy边缘模式的“对称”，“包裹”和“边缘”分别被转换为等效dask边界模式'reflect'，'periodic'和'nearest'。
copy_func
skimage.util.copy_func(f, name=None)[source]
创建一个函数的副本。
| Parameters: | f : function Function to copy. name : str, optional Name of new function. |
|---|
crop
skimage.util.crop(ar, crop_width, copy=False, order='K')[source]
ar通过crop_width每个维度裁剪数组。
| 参数： | ar：类似于排序N输入数组的数组。crop_width：{sequence，int}要从每个轴的边缘移除的值的数量。（（before_1，after_1），...（before_N，after_N））指定每个轴开始和结束处的唯一裁剪宽度。（（之前，之后），）为每个轴指定固定的开始和结束裁剪。（n，）或整数n的n是所有轴的before = after = n的快捷方式。copy：bool，可选如果为True，请确保返回的数组是连续的副本。通常，裁剪操作将返回底层输入数组的不连续视图。顺序：{'C'，'F'，'A'，'K'}，可选如果copy == True，则控制副本的内存布局。请参阅np.copy。 |
|---|---|
| 返回： | 裁剪：数组裁剪数组。如果copy = False（默认），这是输入数组的切片视图。 |
dtype_limits
skimage.util.dtype_limits(image, clip_negative=None)[source]
返回图像的dtype的强度限制，即（最小，最大）元组。
| 参数： | 图像：ndarray输入图像。clip_negative：bool，可选如果为True，即使图像dtype允许为负值，也可以剪裁负范围（即返回0表示最小强度）。默认行为（无）相当于True。 |
|---|---|
| 返回： | imin，imax：元组下限和上限强度限制。 |
img_as_bool
skimage.util.img_as_bool(image, force_copy=False)[source]
将图像转换为布尔格式。
| 参数： | 图像：ndarray输入图像。force_copy：bool，可选强制数据的副本，而不管其当前的dtype。 |
|---|---|
| 返回： | out：bool（bool_）的ndarray输出图像。 |
Notes
输入dtype的正范围的上半部分是True，下半部分是False。所有负值（如果存在）都是False。
img_as_float
skimage.util.img_as_float(image, force_copy=False)[source]
将图像转换为双精度（64位）浮点格式。
| 参数： | 图像：ndarray输入图像。force_copy：bool，可选强制数据的副本，而不管其当前的dtype。 |
|---|---|
| 返回： | out：float64的输出图像的ndarray。 |
注意
当分别从无符号或有符号数据类型转换时，浮点图像的范围为0.0，1.0或-1.0,1.0。如果输入图像具有浮点型，则强度值不会被修改，并且可能超出范围0.0,1.0或-1.0,1.0。
img_as_int
skimage.util.img_as_int(image, force_copy=False)[source]
将图像转换为16位有符号整数格式。
| 参数： | 图像：ndarray输入图像。force_copy：bool，可选强制数据的副本，而不管其当前的dtype。 |
|---|---|
| 返回： | out：uint16的ndarray输出图像。 |
注意
这些值在-32768和32767之间缩放。如果输入数据类型仅为正值（例如，uint8），则输出图像仍然只有正值。
img_as_ubyte
skimage.util.img_as_ubyte(image, force_copy=False)[source]
将图像转换为8位无符号整数格式。
| 参数： | 图像：ndarray输入图像。force_copy：bool，可选强制数据的副本，而不管其当前的dtype。 |
|---|---|
| 返回： | out：ubyte的ndarray（uint8）输出图像。 |
注意
负输入值将被剪切。正值在0和255之间缩放。
img_as_uint
skimage.util.img_as_uint(image, force_copy=False)[source]
将图像转换为16位无符号整数格式。
| 参数： | 图像：ndarray输入图像。force_copy：bool，可选强制数据的副本，而不管其当前的dtype。 |
|---|---|
| 返回： | out：uint16的ndarray输出图像。 |
注意
负输入值将被剪切。正值在0和65535之间缩放。
invert
skimage.util.invert(image)[source]
倒置图像。
将图像分解为dtype最大值允许的最大值。
| 参数： | image：ndarray输入图像。 |
|---|---|
| 返回： | 反转：ndarray倒置的图像。 |
例子
>>> 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)
numpy_pad
skimage.util.numpy_pad(array, pad_width, mode, **kwargs)[source]
填充数组。
| 参数： | array：array_like等级N输入数组pad_width：{sequence，array_like，int}填充到每个轴边缘的值的数量。（（before_1，after_1），...（before_N，after_N））每个轴的唯一焊盘宽度。（（之前，之后））在每个轴的垫之前和之后产生相同的值。（pad，）或int是所有轴的before = after = pad宽度的快捷键。模式：str或函数以下字符串值之一或用户提供的函数。'常数'具有恒定值的垫。'edge'填充数组的边缘值。'linear_ramp'使用end_value和阵列边缘值之间的线性斜坡填充焊盘。'maximum'填充沿每个轴的全部或部分向量的最大值。'mean'填充每个轴上全部或部分矢量的平均值。'中位数'填充每个轴全部或部分向量的中值。'minimum'沿每个轴填充全部或部分向量的最小值。'反映'具有镜像反射矢量沿每个轴的矢量的第一个和最后一个值。'对称'焊盘，沿着阵列的边缘反射矢量镜像。'包裹'垫沿着轴线的向量包裹。第一个值用于填充结尾，最终值用于填充开头。<函数>填充函数，请参阅注释。stat_length：sequence或int，可选用于'最大'，'平均值'，'中值'和'最小值'。用于计算统计值的每个轴的边缘值的数量。（（before_1，after_1），...（before_N，after_N））每个轴的唯一统计长度。（（之前，之后），）在每个轴的统计长度之前和之后产生相同的结果。（stat_length，）或int是所有轴的before = after =统计长度的快捷键。缺省值为None，以使用整个轴。constant_values：sequence或int，可选用于'常量'。用于设置每个轴的填充值的值。（（before_1，after_1），...（before_N，after_N））每个轴的唯一焊盘常量。（（之前，之后））在每个轴的常量之前和之后产生相同的结果。（常量）或int是所有轴之前= =后=常量的快捷方式。默认值为0. end_values：sequence或int，可选用于'linear_ramp'。用于linear_ramp的结束值的值将形成填充数组的边缘。（（before_1，after_1），...（before_N，after_N））每个轴的唯一结束值。（（之前，之后），）在每个轴的结束值之前和之后产生相同的值。（常量）或int是所有轴的before = after = end值的快捷键。默认值为0. reflect_type：{'even'，'odd'}，可选用于'反射'和'对称'。'偶'的样式是默认的，边缘值周围没有改变。对于“奇数”样式，数组的扩展部分是通过从边缘值的两倍减去反射值而创建的。 |
|---|---|
| 返回： | pad：ndarray根据pad_width增加等于阵列的等级的填充阵列。 |
注意
版本1.7.0中的新功能。
对于排序大于1的数组，稍后轴的某些填充是通过填充以前的轴来计算的。这是最容易考虑的第2列数组，其中通过使用第一个轴的填充值计算填充数组的角点。
填充函数（如果使用的话）应该返回一个等于1的数组，其长度等于vector参数，并替换填充值。它有以下签名：
padding_func(vector, iaxis_pad_width, iaxis, **kwargs)
当
vector : ndarray等级1阵列已经用零填充。填充值是矢量[：pad_tuple0]和矢量[-pad_tuple1：]。iaxis_pad_width : tuple一个2元组的整数，iaxis_pad_width0表示在向量的开始处填充的值的数量，其中iaxis_pad_width1表示向量结尾处填充的值的数量。iaxis : int当前正在计算的轴。kwargs : misc该函数需要的任何关键字参数。
例子
>>> a = [1, 2, 3, 4, 5]
>>> np.lib.pad(a, (2,3), 'constant', constant_values=(4, 6))
array([4, 4, 1, 2, 3, 4, 5, 6, 6, 6])
>>> np.lib.pad(a, (2, 3), 'edge')
array([1, 1, 1, 2, 3, 4, 5, 5, 5, 5])
>>> np.lib.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])
>>> np.lib.pad(a, (2,), 'maximum')
array([5, 5, 1, 2, 3, 4, 5, 5, 5])
>>> np.lib.pad(a, (2,), 'mean')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> np.lib.pad(a, (2,), 'median')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> a = [[1, 2], [3, 4]]
>>> np.lib.pad(a, ((3, 2), (2, 3)), 'minimum')
array([[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[3, 3, 3, 4, 3, 3, 3],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1]])
>>> a = [1, 2, 3, 4, 5]
>>> np.lib.pad(a, (2, 3), 'reflect')
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
>>> np.lib.pad(a, (2, 3), 'reflect', reflect_type='odd')
array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> np.lib.pad(a, (2, 3), 'symmetric')
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
>>> np.lib.pad(a, (2, 3), 'symmetric', reflect_type='odd')
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
>>> np.lib.pad(a, (2, 3), 'wrap')
array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
>>> def padwithtens(vector, pad_width, iaxis, kwargs):
... vector[:pad_width[0]] = 10
... vector[-pad_width[1]:] = 10
... return vector
>>> a = np.arange(6)
>>> a = a.reshape((2, 3))
>>> np.lib.pad(a, 2, padwithtens)
array([[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10, 0, 1, 2, 10, 10],
[10, 10, 3, 4, 5, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10]])
pad
skimage.util.pad(array, pad_width, mode, **kwargs)[source]
填充数组。
| 参数： | array：array_like等级N输入数组pad_width：{sequence，array_like，int}填充到每个轴边缘的值的数量。（（before_1，after_1），...（before_N，after_N））每个轴的唯一焊盘宽度。（（之前，之后））在每个轴的垫之前和之后产生相同的值。（pad，）或int是所有轴的before = after = pad宽度的快捷键。模式：str或函数以下字符串值之一或用户提供的函数。'常数'具有恒定值的垫。'edge'填充数组的边缘值。'linear_ramp'使用end_value和阵列边缘值之间的线性斜坡填充焊盘。'maximum'填充沿每个轴的全部或部分向量的最大值。'mean'填充每个轴上全部或部分矢量的平均值。'中位数'填充每个轴全部或部分向量的中值。'minimum'沿每个轴填充全部或部分向量的最小值。'反映'具有镜像反射矢量沿每个轴的矢量的第一个和最后一个值。'对称'焊盘，沿着阵列的边缘反射矢量镜像。'包裹'垫沿着轴线的向量包裹。第一个值用于填充结尾，最终值用于填充开头。<函数>填充函数，请参阅注释。stat_length：sequence或int，可选用于'最大'，'平均值'，'中值'和'最小值'。用于计算统计值的每个轴的边缘值的数量。（（before_1，after_1），...（before_N，after_N））每个轴的唯一统计长度。（（之前，之后），）在每个轴的统计长度之前和之后产生相同的结果。（stat_length，）或int是所有轴的before = after =统计长度的快捷键。缺省值为None，以使用整个轴。constant_values：sequence或int，可选用于'常量'。用于设置每个轴的填充值的值。（（before_1，after_1），...（before_N，after_N））每个轴的唯一焊盘常量。（（之前，之后））在每个轴的常量之前和之后产生相同的结果。（常量）或int是所有轴之前= =后=常量的快捷方式。默认值为0. end_values：sequence或int，可选用于'linear_ramp'。用于linear_ramp的结束值的值将形成填充数组的边缘。（（before_1，after_1），...（before_N，after_N））每个轴的唯一结束值。（（之前，之后），）在每个轴的结束值之前和之后产生相同的值。（常量）或int是所有轴的before = after = end值的快捷键。默认值为0. reflect_type：{'even'，'odd'}，可选用于'反射'和'对称'。'偶'的样式是默认的，边缘值周围没有改变。对于“奇数”样式，数组的扩展部分是通过从边缘值的两倍减去反射值而创建的。 |
|---|---|
| 返回： | pad：ndarray根据pad_width增加等于阵列的等级的填充阵列。 |
注意
版本1.7.0中的新功能。
对于排序大于1的数组，稍后轴的某些填充是通过填充以前的轴来计算的。这是最容易考虑的第2列数组，其中通过使用第一个轴的填充值计算填充数组的角点。
填充函数（如果使用的话）应该返回一个等于1的数组，其长度等于vector参数，并替换填充值。它有以下签名：
padding_func(vector, iaxis_pad_width, iaxis, **kwargs)
当
vector : ndarray等级1阵列已经用零填充。填充值是矢量[：pad_tuple0]和矢量[-pad_tuple1：]。iaxis_pad_width : tuple一个2元组的整数，iaxis_pad_width0表示在向量的开始处填充的值的数量，其中iaxis_pad_width1表示向量结尾处填充的值的数量。iaxis : int当前正在计算的轴。kwargs : misc该函数需要的任何关键字参数。
例子
>>> a = [1, 2, 3, 4, 5]
>>> np.lib.pad(a, (2,3), 'constant', constant_values=(4, 6))
array([4, 4, 1, 2, 3, 4, 5, 6, 6, 6])
>>> np.lib.pad(a, (2, 3), 'edge')
array([1, 1, 1, 2, 3, 4, 5, 5, 5, 5])
>>> np.lib.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])
>>> np.lib.pad(a, (2,), 'maximum')
array([5, 5, 1, 2, 3, 4, 5, 5, 5])
>>> np.lib.pad(a, (2,), 'mean')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> np.lib.pad(a, (2,), 'median')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> a = [[1, 2], [3, 4]]
>>> np.lib.pad(a, ((3, 2), (2, 3)), 'minimum')
array([[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[3, 3, 3, 4, 3, 3, 3],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1]])
>>> a = [1, 2, 3, 4, 5]
>>> np.lib.pad(a, (2, 3), 'reflect')
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
>>> np.lib.pad(a, (2, 3), 'reflect', reflect_type='odd')
array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> np.lib.pad(a, (2, 3), 'symmetric')
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
>>> np.lib.pad(a, (2, 3), 'symmetric', reflect_type='odd')
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
>>> np.lib.pad(a, (2, 3), 'wrap')
array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
>>> def padwithtens(vector, pad_width, iaxis, kwargs):
... vector[:pad_width[0]] = 10
... vector[-pad_width[1]:] = 10
... return vector
>>> a = np.arange(6)
>>> a = a.reshape((2, 3))
>>> np.lib.pad(a, 2, padwithtens)
array([[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10, 0, 1, 2, 10, 10],
[10, 10, 3, 4, 5, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10]])
random_noise
skimage.util.random_noise(image, mode='gaussian', seed=None, clip=True, **kwargs)[source]
用于将各种类型的随机噪声添加到浮点图像。
| 参数： | 图像：ndarray输入图像数据。将转换为浮动。mode：str以下字符串之一，选择要添加的噪声类型：“高斯”高斯分布的加性噪声。'localvar'高斯分布的加性噪声，在图像的每个点具有指定的局部方差'poisson'由数据产生的泊松分布噪声。'salt'用1'胡椒'代替随机像素用0（对于未签名图像）或-1（对于签名图像）替换随机像素。's＆p'用1或low_val替换随机像素，其中low_val对于未签名图像为0，对于已签名图像则为-1。'speckle'使用out = image + n *图像的乘法噪声，其中n是具有指定均值和方差的均匀噪声。seed：int如果提供，这将在产生噪声之前设置随机种子，用于有效的伪随机比较。clip：bool如果为True（默认值），则在噪声应用于模式'散斑'，'泊松'和'高斯'后，输出将被剪裁。这需要保持适当的图像数据范围。如果为False，则不应用剪切，并且输出可能会超出范围-1,1。mean：float随机分布的均值。用于'高斯'和'散斑'。默认值：0。var：float随机分布的方差。用于'高斯'和'散斑'。注：方差=（标准偏差）** 2.默认值：0.01 local_vars：ndarray正浮点阵列，与图像形状相同，定义每个图像点的局部方差。在'localvar'中使用。amount：float在范围0,1上用图像像素替换噪声的比例。用于“盐”，“胡椒”和“盐和胡椒粉”。默认值：0.05 salt_vs_pepper：float's＆p'的盐对胡椒噪音的比例，范围为0,1。较高的值代表更多的盐。默认值：0.5（等量） |
|---|---|
| 返回： | out：ndarray分别在范围0,1或-1上输出浮点图像数据，如果输入图像是无符号或有符号的，则分别输出1。 |
- 'gaussian'高斯分布的加性噪声。
- 'localvar'高斯分布的加性噪声，在每个点处具有指定的局部方差
image
- 由数据产生的'泊松'泊松分布噪声。
- 'salt'用1替换随机像素。
- 'pepper'用0（无符号图像）或-1（用于签名图像）替换随机像素。
‘s&p’ Replaces random pixels with either 1 or low_val, wherelow_val对于未签名图像为0，对于已签名图像为-1。
- 'speckle'使用out = image + n *图像的乘法噪声，其中n是具有指定均值和方差的均匀噪声。
seed : int
如果提供，这将在生成噪声之前设置随机种子，以进行有效的伪随机比较。
clip : bool
如果为True（默认值），则输出将被应用于模式噪声后剪切‘speckle’，‘poisson’和‘gaussian’。这需要保持适当的图像数据范围。如果为False，则不应用剪切，并且输出可能会超出范围-1,1。
mean : float
随机分布的均值。用于'高斯'和'散斑'。默认值：0。
var : float
随机分布的方差。用于'高斯'和'散斑'。注意：方差=（标准偏差）** 2.默认值：0.01
local_vars : ndarray
image在每个图像点处定义局部方差的正浮点阵列，形状相同。在'localvar'中使用。
amount : float
在范围0,1上用图像像素替换噪声的比例。用于‘salt’, ‘pepper’, and ‘salt & pepper’。默认值：0.05
salt_vs_pepper : float
's＆p'的盐对胡椒噪音的比例范围为0,1。较高的值代表更多的盐。默认值：0.5（等量）
Returns: **out** : ndarray
如果输入image是无符号或有符号的，则分别在范围0,1或-1上输出浮点图像数据。
Notes
散斑，泊松，Localvar和高斯噪声可能会在有效图像范围外产生噪声。默认是剪切（不是别名）这些值，但可以通过设置保留它们clip=False。请注意，在这种情况下，输出可能包含范围0,1或-1,1以外的值。请谨慎使用此选项。
由于在中间计算中仅存在正浮点图像，所以如果仅根据dtype对输入进行签名，则不可能直观。取而代之的是，负值被显式搜索。只有在找到该函数时才会采用带符号的输入。意外的结果只发生在罕见的，暴露不良的情况下（例如，如果所有值在签名中都高于50％灰色image）。在这种情况下，手动缩放输入到正域将解决问题。
泊松分布仅限于正整数。要应用此噪点类型，将找到图像中唯一值的数量，并使用下一个圆的幂数来放大浮点结果，然后将其缩小到浮点图像范围。
为了对带符号的图像产生泊松噪声，将带符号的图像临时转换为浮点域中的无符号图像，生成泊松噪声，然后将其返回到原始范围。
regular_grid
skimage.util.regular_grid(ar_shape, n_points)[source]
n_points定期查找间隔ar_shape。
返回的点（如切片）应尽可能接近立方体间距。本质上，这些点由输入数组大小的第N个根间隔开，其中N是维数。但是，如果数组维度不适合完整的步长，则会“丢弃”它，并且仅针对其余维度进行计算。
| 参数： | ar_shape：类似于数组的嵌入网格的空间形状。len（ar_shape）是维数。n_points：int要嵌入空间的（近似）点数。 |
|---|---|
| 返回： | 切片：切片对象列表沿着ar_shape的每个维度的切片，使得所有切片的交集给出规则间隔点的坐标。 |
例子
>>> 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
regular_seeds
skimage.util.regular_seeds(ar_shape, n_points, dtype=<class 'int'>)[source]
以〜n\_points规则间隔的非零像素返回图像。
| 参数： | ar_shape：int的元组所需输出图像的形状。n_points：int所需的非零点数。dtype：numpy数据类型，可选输出的所需数据类型。 |
|---|---|
| 返回： | seed_img：int或bool的数组所需的图像。 |
Examples
>>> 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]])
unique_rows
skimage.util.unique_rows(ar)[source]
从二维数组中删除重复的行。
特别是，如果给定一组形状坐标（Npoints，Ndim），它将删除重复的点。
| 参数： | ar：2-D ndarray输入数组。 |
|---|---|
| 返回： | ar_out：2-D ndarray删除重复行的输入数组的副本。 |
| 举： | ValueError：如果ar不是二维的。 |
注意
如果该函数ar不是C连续的，则该函数将生成一个副本，这将对大型输入数组的性能产生负面影响。
例子
>>> 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)
view_as_blocks
skimage.util.view_as_blocks(arr_in, block_shape)[source]
输入n维数组的块视图（使用重新跨步）。
块是输入数组的非重叠视图。
| 参数： | arr_in：ndarray Nd输入数组。block_shape：元组块的形状。每个维度必须均匀划分为arr_in的相应维度。 |
|---|---|
| 返回： | arr_out：ndarray输入数组的块视图。如果arr_in不连续，则进行复制。 |
例子
>>> 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]]]])
view_as_windows
skimage.util.view_as_windows(arr_in, window_shape, step=1)[source]
输入n维数组的滚动窗口视图。
Windows是输入数组的重叠视图，相邻窗口被单个行或列（或更高维的索引）移位。
| 参数： | arr_in：ndarray Nd输入数组。window_shape：整数或长度的元组arr_in.ndim定义滚动窗口视图的基本n维oorthotope的形状（更好地称为超矩形R504）。如果给出了一个整数，那么这个形状将是一个由它的值给出的边长的超立方体。步骤：长度的整数或元组arr_in.ndim指示要执行提取的步长。如果给出了整数，那么该步骤在所有维度上是均匀的。 |
|---|---|
| 返回： | arr_out：输入数组的ndarray（滚动）窗口视图。如果arr_in不连续，则进行复制。 |
注意
当涉及内存使用时，应该非常小心地滚动视图。事实上，虽然'视图'与其基本数组具有相同的内存占用空间，但在计算中使用此'视图'时出现的实际数组通常是比原始数组（大得多）更大的数组，特别是对于二维数组以上。
例如，让我们考虑一个尺寸为（100，100，100）的三维数组float64。这个阵列需要大约8 * 100 ** 3字节的存储空间，这只需8 MB。如果决定在这个阵列上建立一个滚动视图（3，3，3），滚动视图的假设尺寸（例如，如果要重新塑造视图）将是8 *（100-3 + 1 ）** 3 * 3 ** 3约203 MB！随着输入数组的尺寸变大，缩放比例变得更糟。
参考
| R504 | (1, 2) http://en.wikipedia.org/wiki/Hyperrectangle |
|---|
例子
>>> 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]]]])
