skimage.util.img_as_float32 (image[, force_copy]) | Convert an image to single-precision (32-bit) floating point format. |
skimage.util.img_as_float64 (image[, force_copy]) | Convert an image to double-precision (64-bit) floating point format. |
skimage.util.img_as_float (image[, force_copy]) | Convert an image to floating point format. |
skimage.util.img_as_int (image[, force_copy]) | Convert an image to 16-bit signed integer format. |
skimage.util.img_as_uint (image[, force_copy]) | Convert an image to 16-bit unsigned integer format. |
skimage.util.img_as_ubyte (image[, force_copy]) | Convert an image to 8-bit unsigned integer format. |
skimage.util.img_as_bool (image[, force_copy]) | Convert an image to boolean format. |
skimage.util.dtype_limits (image[, clip_negative]) | Return intensity limits, i.e. |
skimage.util.view_as_blocks (arr_in, block_shape) | Block view of the input n-dimensional array (using re-striding). |
skimage.util.view_as_windows (arr_in, …[, step]) | Rolling window view of the input n-dimensional array. |
skimage.util.pad (array, pad_width, mode, …) | Pads an array. |
skimage.util.crop (ar, crop_width[, copy, order]) | Crop array ar by crop_width along each dimension. |
skimage.util.montage (arr_in[, fill, …]) | Create a montage of several single- or multichannel images. |
skimage.util.montage2d (arr_in[, fill, …]) | Deprecated function. |
skimage.util.random_noise (image[, mode, …]) | Function to add random noise of various types to a floating-point image. |
skimage.util.regular_grid (ar_shape, n_points) | Find n_points regularly spaced along ar_shape . |
skimage.util.regular_seeds (ar_shape, n_points) | Return an image with ~`n_points` regularly-spaced nonzero pixels. |
skimage.util.apply_parallel (function, array) | Map a function in parallel across an array. |
skimage.util.invert (image[, signed_float]) | Invert an image. |
skimage.util.unique_rows (ar) | Remove repeated rows from a 2D array. |
skimage.util.img_as_float32(image, force_copy=False)
[source]
Convert an image to single-precision (32-bit) floating point format.
Parameters: |
|
---|---|
Returns: |
|
The range of a floating point image is [0.0, 1.0] or [-1.0, 1.0] when converting from unsigned or signed datatypes, respectively. If the input image has a float type, intensity values are not modified and can be outside the ranges [0.0, 1.0] or [-1.0, 1.0].
skimage.util.img_as_float64(image, force_copy=False)
[source]
Convert an image to double-precision (64-bit) floating point format.
Parameters: |
|
---|---|
Returns: |
|
The range of a floating point image is [0.0, 1.0] or [-1.0, 1.0] when converting from unsigned or signed datatypes, respectively. If the input image has a float type, intensity values are not modified and can be outside the ranges [0.0, 1.0] or [-1.0, 1.0].
skimage.util.img_as_float(image, force_copy=False)
[source]
Convert an image to floating point format.
This function is similar to img_as_float64
, but will not convert lower-precision floating point arrays to float64
.
Parameters: |
|
---|---|
Returns: |
|
The range of a floating point image is [0.0, 1.0] or [-1.0, 1.0] when converting from unsigned or signed datatypes, respectively. If the input image has a float type, intensity values are not modified and can be outside the ranges [0.0, 1.0] or [-1.0, 1.0].
skimage.util.img_as_int(image, force_copy=False)
[source]
Convert an image to 16-bit signed integer format.
Parameters: |
|
---|---|
Returns: |
|
The values are scaled between -32768 and 32767. If the input data-type is positive-only (e.g., uint8), then the output image will still only have positive values.
skimage.util.img_as_uint(image, force_copy=False)
[source]
Convert an image to 16-bit unsigned integer format.
Parameters: |
|
---|---|
Returns: |
|
Negative input values will be clipped. Positive values are scaled between 0 and 65535.
skimage.util.img_as_ubyte(image, force_copy=False)
[source]
Convert an image to 8-bit unsigned integer format.
Parameters: |
|
---|---|
Returns: |
|
Negative input values will be clipped. Positive values are scaled between 0 and 255.
skimage.util.img_as_bool(image, force_copy=False)
[source]
Convert an image to boolean format.
Parameters: |
|
---|---|
Returns: |
|
The upper half of the input dtype’s positive range is True, and the lower half is False. All negative values (if present) are False.
skimage.util.dtype_limits(image, clip_negative=None)
[source]
Return intensity limits, i.e. (min, max) tuple, of the image’s dtype.
Parameters: |
|
---|---|
Returns: |
|
skimage.util.view_as_blocks(arr_in, block_shape)
[source]
Block view of the input n-dimensional array (using re-striding).
Blocks are non-overlapping views of the input array.
Parameters: |
|
---|---|
Returns: |
|
>>> 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 # doctest: +NORMALIZE_WHITESPACE 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] # doctest: +NORMALIZE_WHITESPACE array([[[[52, 53], [58, 59]]], [[[76, 77], [82, 83]]]])
skimage.util.view_as_windows(arr_in, window_shape, step=1)
[source]
Rolling window view of the input n-dimensional array.
Windows are overlapping views of the input array, with adjacent windows shifted by a single row or column (or an index of a higher dimension).
Parameters: |
|
---|---|
Returns: |
|
One should be very careful with rolling views when it comes to memory usage. Indeed, although a ‘view’ has the same memory footprint as its base array, the actual array that emerges when this ‘view’ is used in a computation is generally a (much) larger array than the original, especially for 2-dimensional arrays and above.
For example, let us consider a 3 dimensional array of size (100, 100, 100) of float64
. This array takes about 8*100**3 Bytes for storage which is just 8 MB. If one decides to build a rolling view on this array with a window of (3, 3, 3) the hypothetical size of the rolling view (if one was to reshape the view for example) would be 8*(100-3+1)**3*3**3 which is about 203 MB! The scaling becomes even worse as the dimension of the input array becomes larger.
[1] | (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 # doctest: +NORMALIZE_WHITESPACE 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]]]])
skimage.util.pad(array, pad_width, mode, **kwargs)
[source]
Pads an array.
Parameters: |
|
---|---|
Returns: |
|
New in version 1.7.0.
For an array with rank greater than 1, some of the padding of later axes is calculated from padding of previous axes. This is easiest to think about with a rank 2 array where the corners of the padded array are calculated by using padded values from the first axis.
The padding function, if used, should return a rank 1 array equal in length to the vector argument with padded values replaced. It has the following signature:
padding_func(vector, iaxis_pad_width, iaxis, kwargs)
where
vector : ndarray
iaxis_pad_width : tuple
iaxis : int
kwargs : dict
>>> a = [1, 2, 3, 4, 5] >>> np.pad(a, (2,3), 'constant', constant_values=(4, 6)) array([4, 4, 1, 2, 3, 4, 5, 6, 6, 6])
>>> np.pad(a, (2, 3), 'edge') array([1, 1, 1, 2, 3, 4, 5, 5, 5, 5])
>>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4)) array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])
>>> np.pad(a, (2,), 'maximum') array([5, 5, 1, 2, 3, 4, 5, 5, 5])
>>> np.pad(a, (2,), 'mean') array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> np.pad(a, (2,), 'median') array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> a = [[1, 2], [3, 4]] >>> np.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.pad(a, (2, 3), 'reflect') array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
>>> np.pad(a, (2, 3), 'reflect', reflect_type='odd') array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> np.pad(a, (2, 3), 'symmetric') array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
>>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd') array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
>>> np.pad(a, (2, 3), 'wrap') array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
>>> def pad_with(vector, pad_width, iaxis, kwargs): ... pad_value = kwargs.get('padder', 10) ... vector[:pad_width[0]] = pad_value ... vector[-pad_width[1]:] = pad_value ... return vector >>> a = np.arange(6) >>> a = a.reshape((2, 3)) >>> np.pad(a, 2, pad_with) 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]]) >>> np.pad(a, 2, pad_with, padder=100) array([[100, 100, 100, 100, 100, 100, 100], [100, 100, 100, 100, 100, 100, 100], [100, 100, 0, 1, 2, 100, 100], [100, 100, 3, 4, 5, 100, 100], [100, 100, 100, 100, 100, 100, 100], [100, 100, 100, 100, 100, 100, 100]])
skimage.util.crop(ar, crop_width, copy=False, order='K')
[source]
Crop array ar
by crop_width
along each dimension.
Parameters: |
|
---|---|
Returns: |
|
skimage.util.montage(arr_in, fill='mean', rescale_intensity=False, grid_shape=None, padding_width=0, multichannel=False)
[source]
Create a montage of several single- or multichannel images.
Create a rectangular montage from an input array representing an ensemble of equally shaped single- (gray) or multichannel (color) images.
For example, montage(arr_in)
called with the following arr_in
1 | 2 | 3 |
will return
1 | 2 |
3 |
|
where the ‘*’ patch will be determined by the fill
parameter.
Parameters: |
|
---|---|
Returns: |
|
>>> import numpy as np >>> from skimage.util import montage >>> arr_in = np.arange(3 * 2 * 2).reshape(3, 2, 2) >>> arr_in # doctest: +NORMALIZE_WHITESPACE 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.montage2d(arr_in, fill='mean', rescale_intensity=False, grid_shape=None, padding_width=0)
[source]
Deprecated function. Use montage
instead.
Create a 2-dimensional ‘montage’ from a 3-dimensional input array representing an ensemble of equally shaped 2-dimensional images.
For example, montage2d(arr_in, fill)
with the following arr_in
1 | 2 | 3 |
will return:
1 | 2 |
3 |
|
Where the ‘*’ patch will be determined by the fill
parameter.
Parameters: |
|
---|---|
Returns: |
|
>>> import numpy as np >>> from skimage.util import montage2d >>> arr_in = np.arange(3 * 2 * 2).reshape(3, 2, 2) >>> arr_in # doctest: +NORMALIZE_WHITESPACE array([[[ 0, 1], [ 2, 3]], [[ 4, 5], [ 6, 7]], [[ 8, 9], [10, 11]]]) >>> arr_out = montage2d(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 = montage2d(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', seed=None, clip=True, **kwargs)
[source]
Function to add random noise of various types to a floating-point image.
Parameters: |
|
---|---|
Returns: |
|
Speckle, Poisson, Localvar, and Gaussian noise may generate noise outside the valid image range. The default is to clip (not alias) these values, but they may be preserved by setting clip=False
. Note that in this case the output may contain values outside the ranges [0, 1] or [-1, 1]. Use this option with care.
Because of the prevalence of exclusively positive floating-point images in intermediate calculations, it is not possible to intuit if an input is signed based on dtype alone. Instead, negative values are explicity searched for. Only if found does this function assume signed input. Unexpected results only occur in rare, poorly exposes cases (e.g. if all values are above 50 percent gray in a signed image
). In this event, manually scaling the input to the positive domain will solve the problem.
The Poisson distribution is only defined for positive integers. To apply this noise type, the number of unique values in the image is found and the next round power of two is used to scale up the floating-point result, after which it is scaled back down to the floating-point image range.
To generate Poisson noise against a signed image, the signed image is temporarily converted to an unsigned image in the floating point domain, Poisson noise is generated, then it is returned to the original range.
skimage.util.regular_grid(ar_shape, n_points)
[source]
Find n_points
regularly spaced along ar_shape
.
The returned points (as slices) should be as close to cubically-spaced as possible. Essentially, the points are spaced by the Nth root of the input array size, where N is the number of dimensions. However, if an array dimension cannot fit a full step size, it is “discarded”, and the computation is done for only the remaining dimensions.
Parameters: |
|
---|---|
Returns: |
|
>>> 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]
Return an image with ~`n_points` regularly-spaced nonzero pixels.
Parameters: |
|
---|---|
Returns: |
|
>>> 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.apply_parallel(function, array, chunks=None, depth=0, mode=None, extra_arguments=(), extra_keywords={})
[source]
Map a function in parallel across an array.
Split an array into possibly overlapping chunks of a given depth and boundary type, call the given function in parallel on the chunks, combine the chunks and return the resulting array.
Parameters: |
|
---|
Numpy edge modes ‘symmetric’, ‘wrap’, and ‘edge’ are converted to the equivalent dask
boundary modes ‘reflect’, ‘periodic’ and ‘nearest’, respectively.
skimage.util.invert(image, signed_float=False)
[source]
Invert an image.
Invert the intensity range of the input image, so that the dtype maximum is now the dtype minimum, and vice-versa. This operation is slightly different depending on the input dtype:
See the examples for clarification.
Parameters: |
|
---|---|
Returns: |
|
Ideally, for signed integers we would simply multiply by -1. However, signed integer ranges are asymmetric. For example, for np.int8, the range of possible values is [-128, 127], so that -128 * -1 equals -128! By subtracting from -1, we correctly map the maximum dtype value to the minimum.
>>> 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.unique_rows(ar)
[source]
Remove repeated rows from a 2D array.
In particular, if given an array of coordinates of shape (Npoints, Ndim), it will remove repeated points.
Parameters: |
|
---|---|
Returns: |
|
Raises: |
|
The function will generate a copy of ar
if it is not C-contiguous, which will negatively affect performance for large input arrays.
>>> 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)
© 2011 the scikit-image team
Licensed under the BSD 3-clause License.
http://scikit-image.org/docs/0.14.x/api/skimage.util.html