skimage.util.dtype_limits(image[, clip_negative])  Return intensity limits, i.e. 
skimage.util.img_as_bool(image[, force_copy])  Convert an image to boolean format. 
skimage.util.img_as_float(image[, force_copy])  Convert an image to doubleprecision floating point format. 
skimage.util.img_as_int(image[, force_copy])  Convert an image to 16bit signed integer format. 
skimage.util.img_as_ubyte(image[, force_copy])  Convert an image to 8bit unsigned integer format. 
skimage.util.img_as_uint(image[, force_copy])  Convert an image to 16bit unsigned integer format. 
skimage.util.pad(array, pad_width[, mode])  Pads an array. 
skimage.util.random_noise(image[, mode, ...])  Function to add random noise of various types to a floatingpoint image. 
skimage.util.regular_grid(ar_shape, n_points)  Find n_points regularly spaced along ar_shape. 
skimage.util.unique_rows(ar)  Remove repeated rows from a 2D array. 
skimage.util.view_as_blocks(arr_in, block_shape)  Block view of the input ndimensional array (using restriding). 
skimage.util.view_as_windows(arr_in, ...[, step])  Rolling window view of the input ndimensional array. 
Return intensity limits, i.e. (min, max) tuple, of the image’s dtype.
Parameters:  image : ndarray
clip_negative : bool


Convert an image to boolean format.
Parameters:  image : ndarray
force_copy : bool


Returns:  out : ndarray of bool (bool_)

Notes
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.
Convert an image to doubleprecision floating point format.
Parameters:  image : ndarray
force_copy : bool


Returns:  out : ndarray of float64

Notes
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.
Convert an image to 16bit signed integer format.
Parameters:  image : ndarray
force_copy : bool


Returns:  out : ndarray of uint16

Notes
If the input datatype is positiveonly (e.g., uint8), then the output image will still only have positive values.
Convert an image to 8bit unsigned integer format.
Parameters:  image : ndarray
force_copy : bool


Returns:  out : ndarray of ubyte (uint8)

Notes
If the input datatype is positiveonly (e.g., uint16), then the output image will still only have positive values.
Convert an image to 16bit unsigned integer format.
Parameters:  image : ndarray
force_copy : bool


Returns:  out : ndarray of uint16

Notes
Negative input values will be shifted to the positive domain.
Pads an array.
Parameters:  array : array_like of rank N
pad_width : {sequence, int}
mode : {str, function}
stat_length : {sequence, int}, optional
constant_values : {sequence, int}, optional
end_values : {sequence, int}, optional
reflect_type : str {‘even’, ‘odd’}, optional


Returns:  pad : ndarray

Notes
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
 A rank 1 array already padded with zeros. Padded values are vector[:pad_tuple[0]] and vector[pad_tuple[1]:].
 iaxis_pad_width : tuple
 A 2tuple of ints, iaxis_pad_width[0] represents the number of values padded at the beginning of vector where iaxis_pad_width[1] represents the number of values padded at the end of vector.
 iaxis : int
 The axis currently being calculated.
 kwargs : misc
 Any keyword arguments the function requires.
Examples
>>> a = [1, 2, 3, 4, 5]
>>> pad(a, (2,3), 'constant', constant_values=(4,6))
array([4, 4, 1, 2, 3, 4, 5, 6, 6, 6])
>>> pad(a, (2,3), 'edge')
array([1, 1, 1, 2, 3, 4, 5, 5, 5, 5])
>>> pad(a, (2,3), 'linear_ramp', end_values=(5,4))
array([ 5, 3, 1, 2, 3, 4, 5, 2, 1, 4])
>>> pad(a, (2,), 'maximum')
array([5, 5, 1, 2, 3, 4, 5, 5, 5])
>>> pad(a, (2,), 'mean')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> pad(a, (2,), 'median')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> a = [[1,2], [3,4]]
>>> 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]
>>> pad(a, (2,3), 'reflect')
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
>>> pad(a, (2,3), 'reflect', reflect_type='odd')
array([1, 0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> pad(a, (2,3), 'symmetric')
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
>>> pad(a, (2,3), 'symmetric', reflect_type='odd')
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
>>> 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))
>>> 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]])
Function to add random noise of various types to a floatingpoint image.
Parameters:  image : ndarray
mode : str
seed : int
clip : bool
mean : float
var : float
local_vars : ndarray
amount : float
salt_vs_pepper : float


Returns:  out : ndarray

Notes
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 floatingpoint 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 floatingpoint result, after which it is scaled back down to the floatingpoint 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.
Find n_points regularly spaced along ar_shape.
The returned points (as slices) should be as close to cubicallyspaced 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:  ar_shape : arraylike of ints
n_points : int


Returns:  slices : list of slice objects

Examples
>>> 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
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:  ar : 2D ndarray


Returns:  ar_out : 2D ndarray

Raises:  ValueError : if ar is not twodimensional. 
Notes
The function will generate a copy of ar if it is not Ccontiguous, which will negatively affect performance for large input arrays.
Examples
>>> 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)
Block view of the input ndimensional array (using restriding).
Blocks are nonoverlapping views of the input array.
Parameters:  arr_in : ndarray
block_shape : tuple


Returns:  arr_out : ndarray

Examples
>>> 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]]]])
Rolling window view of the input ndimensional 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:  arr_in : ndarray
window_shape : tuple
step : int, optional


Returns:  arr_out : ndarray

Notes
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 2dimensional 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*(1003+1)**3*3**3 which is about 203 MB! The scaling becomes even worse as the dimension of the input array becomes larger.
References
[R328]  (1, 2) http://en.wikipedia.org/wiki/Hyperrectangle 
Examples
>>> 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]]]])