`skimage.util`#

通用工具。

此模組包含一些通用影像處理的實用函式。

`apply_parallel`	在陣列上平行映射函式。
`compare_images`	回傳顯示兩張影像差異的影像。
`crop`	沿著每個維度，將陣列 `ar` 修剪 `crop_width` 的寬度。
`dtype_limits`	回傳影像資料型別的強度限制，即 (最小值, 最大值) 元組。
`img_as_bool`	將影像轉換為布林格式。
`img_as_float`	將影像轉換為浮點數格式。
`img_as_float32`	將影像轉換為單精度 (32 位元) 浮點數格式。
`img_as_float64`	將影像轉換為雙精度 (64 位元) 浮點數格式。
`img_as_int`	將影像轉換為 16 位元有號整數格式。
`img_as_ubyte`	將影像轉換為 8 位元無號整數格式。
`img_as_uint`	將影像轉換為 16 位元無號整數格式。
`invert`	反轉影像。
`label_points`	為影像遮罩上的座標指定唯一的整數標籤
`lookfor`	在 scikit-image 文件字串上執行關鍵字搜尋並列印結果。
`map_array`	將輸入陣列中的值從 input_vals 映射到 output_vals。
`montage`	建立多個單通道或多通道影像的蒙太奇。
`random_noise`	將各種隨機雜訊新增至浮點數影像的函式。
`regular_grid`	尋找沿著 `ar_shape` 均勻間隔的 `n_points` 個點。
`regular_seeds`	回傳一個具有約 `n_points` 個均勻間隔非零像素的影像。
`slice_along_axes`	沿著給定軸切割影像。
`unique_rows`	從二維陣列中移除重複的列。
`view_as_blocks`	輸入 n 維陣列的區塊檢視 (使用重新跨步)。
`view_as_windows`	輸入 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)[原始碼]#

在陣列上平行映射函式。

將陣列分割成可能重疊的區塊，給定深度和邊界類型，在區塊上平行呼叫給定的函式，合併區塊並回傳產生的陣列。

參數:

function函式: 要映射的函式，它以陣列作為引數。
arraynumpy 陣列或 dask 陣列: 要套用函式的陣列。
chunksint、tuple 或 tuple 的 tuple，可選: 單一整數會被解讀為應在陣列上平鋪的方形區塊的一邊長度。長度為 array.ndim 的一個 tuple 代表區塊的形狀，並在陣列上平鋪。長度為 ndim 的 tuple 的列表，其中每個子 tuple 都是沿著對應維度的區塊大小序列。如果為 None，則會根據可用 CPU 的數量將陣列分割成區塊。有關區塊的更多資訊，請參閱此處的文件。當 channel_axis 不為 None 時，tuple 的長度可以是 ndim - 1，並且會沿著通道軸使用單一區塊。
depthint 或 int 序列，可選: 新增邊界儲存格的深度。可以使用 tuple 來指定每個陣列軸的不同深度。預設為零。當 channel_axis 不為 None，且提供長度為 ndim - 1 的 tuple 時，會沿著通道軸使用深度 0。
mode{‘reflect’, ‘symmetric’, ‘periodic’, ‘wrap’, ‘nearest’, ‘edge’}，可選: 外部邊界填補的類型。
extra_argumentstuple，可選: 要傳遞給函式的引數 tuple。
extra_keywordsdictionary，可選: 要傳遞給函式的關鍵字引數 dictionary。
dtype資料類型或 None，可選: function 輸出的資料類型。如果為 None，Dask 會嘗試透過在形狀為 (1,) * ndim 的資料上呼叫函式來推斷此資料類型。對於預期 RGB 或多通道資料的函式，這可能會出現問題。在這種情況下，使用者應手動指定此 dtype 引數。

0.18 版新增: 0.18 版新增了 dtype。
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))[原始碼]#

回傳顯示兩張影像差異的影像。

0.16 版新增。

參數:

image0, image1ndarray，形狀 (M, N): 要處理的影像，必須具有相同的形狀。

0.24 版變更: image1 和 image2 已分別重新命名為 image0 和 image1。
method字串，可選: 用於比較的Method。有效值為 {'diff', 'blend', 'checkerboard'}。詳細資訊請參閱注意事項一節。

0.24 版變更: 此參數和下列參數為僅限關鍵字。
n_tilestuple，可選: 僅用於 checkerboard 方法。指定要將影像分割成的圖塊數量（行，列）。

回傳:

comparisonndarray，形狀 (M, N): 顯示差異的影像。

注意事項

'diff' 計算兩個影像之間的絕對差異。'blend' 計算平均值。'checkerboard' 建立尺寸為 n_tiles 的圖塊，交替顯示第一個和第二個影像。請注意，影像必須是二維的才能使用棋盤格方法進行比較。

邊緣運算子

視覺影像比較

skimage.util.crop(ar, crop_width, copy=False, order='K')[原始碼]#

沿著每個維度，將陣列 ar 修剪 crop_width 的寬度。

參數:

ar類陣列，階數為 N: 輸入陣列。
crop_width{序列, 整數}: 要從每個軸的邊緣移除的值的數量。((before_1, after_1), … (before_N, after_N)) 指定每個軸開始和結束時的獨特裁剪寬度。((before, after),) 或 (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)[原始碼]#

返回影像的 dtype 的強度限制，即 (最小值，最大值) 元組。

參數:

imagendarray: 輸入影像。
clip_negative布林值，可選: 如果為 True，即使影像 dtype 允許負值，也會截斷負範圍（即，最小值強度返回 0）。

回傳:

imin, imax元組: 較低和較高的強度限制。

skimage.util.img_as_bool(image, force_copy=False)[原始碼]#

將影像轉換為布林格式。

參數:

imagendarray: 輸入影像。
force_copy布林值，可選: 強制複製數據，無論其當前 dtype 為何。

回傳:

out布林值 ndarray (bool_): 輸出影像。

注意事項

輸入 dtype 正範圍的上半部分為 True，下半部分為 False。所有負值（如果存在）均為 False。

skimage.util.img_as_float(image, force_copy=False)[原始碼]#

將影像轉換為浮點數格式。

此函數與 img_as_float64 相似，但不會將較低精度的浮點陣列轉換為 float64。

參數:

imagendarray: 輸入影像。
force_copy布林值，可選: 強制複製數據，無論其當前 dtype 為何。

回傳:

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)[原始碼]#

將影像轉換為單精度 (32 位元) 浮點數格式。

參數:

imagendarray: 輸入影像。
force_copy布林值，可選: 強制複製數據，無論其當前 dtype 為何。

回傳:

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)[原始碼]#

將影像轉換為雙精度 (64 位元) 浮點數格式。

參數:

imagendarray: 輸入影像。
force_copy布林值，可選: 強制複製數據，無論其當前 dtype 為何。

回傳:

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)[原始碼]#

將影像轉換為 16 位元有號整數格式。

參數:

imagendarray: 輸入影像。
force_copy布林值，可選: 強制複製數據，無論其當前 dtype 為何。

回傳:

outint16 的 ndarray: 輸出影像。

注意事項

這些值縮放到 -32768 和 32767 之間。如果輸入數據類型僅為正數（例如，uint8），則輸出影像仍將僅具有正值。

skimage.util.img_as_ubyte(image, force_copy=False)[原始碼]#

將影像轉換為 8 位元無號整數格式。

參數:

imagendarray: 輸入影像。
force_copy布林值，可選: 強制複製數據，無論其當前 dtype 為何。

回傳:

outubyte (uint8) 的 ndarray: 輸出影像。

注意事項

負輸入值將被截斷。正值縮放到 0 和 255 之間。

skimage.util.img_as_uint(image, force_copy=False)[原始碼]#

將影像轉換為 16 位元無號整數格式。

參數:

imagendarray: 輸入影像。
force_copy布林值，可選: 強制複製數據，無論其當前 dtype 為何。

回傳:

outuint16 的 ndarray: 輸出影像。

注意事項

負輸入值將被截斷。正值縮放到 0 和 65535 之間。

skimage.util.invert(image, signed_float=False)[原始碼]#

反轉影像。

反轉輸入影像的強度範圍，使 dtype 最大值現在為 dtype 最小值，反之亦然。此操作根據輸入 dtype 略有不同

無號整數：從 dtype 最大值中減去影像
帶號整數：從 -1 中減去影像（請參閱注意事項）
浮點數：從 1 中減去影像（如果 signed_float 為 False，因此我們假設影像是無號的），或從 0 中減去影像（如果 signed_float 為 True）。

請參閱範例以釐清說明。

參數:

imagendarray: 輸入影像。
signed_float布林值，可選: 如果為 True 且影像類型為浮點數，則假定範圍為 [-1, 1]。如果為 False 且影像類型為浮點數，則假定範圍為 [0, 1]。

回傳:

invertedndarray: 反轉影像。

注意事項

理想情況下，對於帶號整數，我們只需乘以 -1。但是，帶號整數範圍是不對稱的。例如，對於 np.int8，可能值的範圍是 [-128, 127]，因此 -128 * -1 等於 -128！通過從 -1 中減去，我們正確地將最大 dtype 值映射到最小值。

範例

>>> 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)[原始碼]#

為影像遮罩上的座標指定唯一的整數標籤

參數:

coords: ndarray: 一個 N 個坐標的陣列，維度為 D
output_shape: tuple: 在 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 的結果。

參數:

whatstr: 要搜尋的詞語。

範例

>>> 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_arr整數陣列，形狀為 (M[, …]): 輸入的標籤圖像。
input_vals整數陣列，形狀為 (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 個形狀相同的圖像的陣列。
fill浮點數或類似浮點數的陣列或 ‘mean’，可選: 用於填充輸出陣列中的填充區域和/或額外圖塊的值。對於單通道集合，必須是 float。對於多通道集合，必須是具有通道數量的類陣列。如果為 mean，則使用所有圖像的平均值。
rescale_intensity布林值，可選: 是否將每個圖像的強度重新縮放到 [0, 1]。
grid_shape元組，可選: 蒙太奇的所需網格形狀 (ntiles_row, ntiles_column)。預設縱橫比為正方形。
padding_width整數，可選: 圖塊之間以及圖塊與邊界之間的間距大小。如果非零，則更容易感知個別圖像的邊界。
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)

來自圖像的 Gabor / 初級視覺皮層“簡單細胞”

探索 3D 圖像（細胞的）

skimage.util.random_noise(image, mode='gaussian', rng=None, clip=True, **kwargs)[source]#

將各種隨機雜訊新增至浮點數影像的函式。

參數:

imagendarray

輸入的圖像資料。將會轉換為浮點數。

mode字串，可選

以下字串之一，選擇要新增的雜訊類型

‘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，整數}，可選

虛擬隨機數產生器。預設情況下，使用 PCG64 產生器（請參閱 numpy.random.default_rng()）。如果 rng 是一個整數，則會用它來設定產生器的種子。

clip布林值，可選

如果為 True（預設），則在套用雜訊後，將會針對模式 'speckle'、'poisson' 和 'gaussian' 剪切輸出。這是維持正確圖像資料範圍所需要的。如果為 False，則不會套用剪切，並且輸出可能會超出範圍 [-1, 1]。

mean浮點數，可選

隨機分佈的平均值。用於 ‘gaussian’ 和 ‘speckle’。預設值：0。

var浮點數，可選

隨機分佈的變異數。用於 ‘gaussian’ 和 ‘speckle’。注意：變異數 = (標準差) ** 2。預設值：0.01

local_varsndarray，可選

正浮點數的陣列，形狀與 image 相同，定義每個影像點的局部變異數。用於 ‘localvar’。

amount浮點數，可選

要替換為範圍 [0, 1] 上的雜訊的影像像素比例。用於 ‘salt’、‘pepper’ 和 ‘salt & pepper’。預設值：0.05

salt_vs_pepper浮點數，可選

用於 ‘s&p’ 的鹽和胡椒雜訊的比例，範圍為 [0, 1]。較高的值表示更多的鹽。預設值：0.5（等量）

回傳:

outndarray: 範圍為 [0, 1] 或 [-1, 1] 的輸出浮點數圖像資料，取決於輸入的 image 是無符號還是有符號。

注意事項

斑點、泊松、局部變異數和高斯雜訊可能會產生超出有效影像範圍的雜訊。預設值是剪切（非別名）這些值，但可以透過設定 clip=False 來保留它們。請注意，在這種情況下，輸出可能會包含超出範圍 [0, 1] 或 [-1, 1] 的值。請謹慎使用此選項。

由於中間計算中普遍存在完全正的浮點數圖像，因此無法僅根據 dtype 來判斷輸入是否為有符號。相反地，會明確搜尋負值。只有在找到負值時，此函數才會假定為有符號輸入。只有在罕見且暴露不良的情況下才會發生意外結果（例如，如果有符號 image 中的所有值都高於 50% 灰色）。在這種情況下，手動將輸入縮放到正域將會解決問題。

泊松分佈僅針對正整數定義。為了應用此雜訊類型，會先找出影像中唯一值的數量，並使用最接近的 2 的次方值來放大浮點數結果，之後再將其縮放回浮點數影像範圍。

為了針對帶正負號的影像產生泊松雜訊，會先將帶正負號的影像暫時轉換為浮點數域中的不帶正負號的影像，產生泊松雜訊，然後再將其返回原始範圍。

skimage.util.regular_grid(ar_shape, n_points)[原始碼]#

尋找沿著 ar_shape 均勻間隔的 n_points 個點。

傳回的點（以切片形式）應盡可能接近立方體間隔。本質上，這些點之間的間隔為輸入陣列大小的 N 次方根，其中 N 是維度數。但是，如果陣列維度無法容納完整的步長，則會將其「捨棄」，而僅針對剩餘的維度執行計算。

參數:

ar_shape類似陣列的整數: 嵌入網格的空間形狀。 len(ar_shape) 是維度數。
n_points整數: 要嵌入空間中的（近似）點數。

回傳:

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'>)[原始碼]#

回傳一個具有約 `n_points` 個均勻間隔非零像素的影像。

參數:

ar_shape整數元組: 所需輸出影像的形狀。
n_points整數: 所需的非零點數。
dtypenumpy 資料類型，可選: 所需輸出的資料類型。

回傳:

seed_img整數或布林值陣列: 所需的影像。

範例

>>> 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)[原始碼]#

沿著給定軸切割影像。

參數:

imagendarray: 輸入影像。
slices2 元組 (a, b) 的列表，其中 a < b。: 對於 axes 中的每個軸，都有對應的 2 元組 (min_val, max_val) 可用於切片（與 Python 切片一樣，max_val 不包含在內）。
axes整數或元組，可選: 與 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)[原始碼]#

從二維陣列中移除重複的列。

特別是，如果給定一個形狀為 (Npoints, Ndim) 的座標陣列，它將移除重複的點。

參數:

arndarray，形狀 (M, N): 輸入陣列。

回傳:

ar_outndarray，形狀 (P, N): 輸入陣列的副本，已移除重複的列。

引發:

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)

skimage.util.view_as_blocks(arr_in, block_shape)[原始碼]#

輸入 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)[原始碼]#

輸入 n 維陣列的滾動視窗檢視。

視窗是輸入陣列的重疊視圖，相鄰的視窗會偏移單行或單欄（或更高維度的索引）。

參數:

arr_inndarray，形狀 (M[, …]): 輸入陣列。
window_shape整數或長度為 arr_in.ndim 的元組: 定義滾動視窗視圖的基本 n 維正交體（更廣為人知的名稱是超矩形 [1]）的形狀。如果給定整數，則該形狀將是邊長由其值給定的超立方體。
step整數或長度為 arr_in.ndim 的元組: 指出執行擷取時的步長。如果給定整數，則步長在所有維度中都是統一的。

回傳:

arr_outndarray: 輸入陣列的（滾動）視窗視圖。

注意事項

當涉及到記憶體使用時，應非常小心滾動視圖。事實上，雖然「視圖」的記憶體使用量與其基本陣列相同，但當在計算中使用此「視圖」時，所出現的實際陣列通常比原始陣列大得多（尤其是對於二維及更高維度的陣列）。

例如，讓我們考慮一個大小為 (100, 100, 100) 的 float64 三維陣列。此陣列需要約 8*100**3 位元組的儲存空間，僅為 8 MB。如果決定使用 (3, 3, 3) 的視窗在此陣列上建立滾動視圖，則滾動視圖的假設大小（如果將視圖重新塑形）將約為 8*(100-3+1)**3*3**3，約為 203 MB！隨著輸入陣列的維度變大，縮放情況會變得更糟。

參考文獻

[1]

https://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]]]])

來自圖像的 Gabor / 初級視覺皮層“簡單細胞”

skimage.util#

`skimage.util`#