skimage.morphology.binary_closing(image, selem)  Return fast binary morphological closing of an image. 
skimage.morphology.binary_dilation(image, selem)  Return fast binary morphological dilation of an image. 
skimage.morphology.binary_erosion(image, selem)  Return fast binary morphological erosion of an image. 
skimage.morphology.binary_opening(image, selem)  Return fast binary morphological opening of an image. 
skimage.morphology.black_tophat(image, selem)  Return black top hat of an image. 
skimage.morphology.closing(image, selem[, out])  Return greyscale morphological closing of an image. 
skimage.morphology.convex_hull_image(image)  Compute the convex hull image of a binary image. 
skimage.morphology.diamond(radius[, dtype])  Generates a flat, diamondshaped structuring element of a given radius. 
skimage.morphology.dilation(image, selem[, ...])  Return greyscale morphological dilation of an image. 
skimage.morphology.disk(radius[, dtype])  Generates a flat, diskshaped structuring element of a given radius. 
skimage.morphology.erosion(image, selem[, ...])  Return greyscale morphological erosion of an image. 
skimage.morphology.greyscale_black_top_hat(...)  
skimage.morphology.greyscale_close(*args, ...)  
skimage.morphology.greyscale_dilate(*args, ...)  
skimage.morphology.greyscale_erode(*args, ...)  
skimage.morphology.greyscale_open(*args, ...)  
skimage.morphology.greyscale_white_top_hat(...)  
skimage.morphology.is_local_maximum(*args, ...)  Return a boolean array of points that are local maxima 
skimage.morphology.label  Label connected regions of an integer array. 
skimage.morphology.medial_axis(image[, ...])  Compute the medial axis transform of a binary image 
skimage.morphology.opening(image, selem[, out])  Return greyscale morphological opening of an image. 
skimage.morphology.reconstruction(seed, mask)  Perform a morphological reconstruction of an image. 
skimage.morphology.rectangle(width, height)  Generates a flat, rectangularshaped structuring element of a given width and height. 
skimage.morphology.remove_small_objects(ar)  Remove connected components smaller than the specified size. 
skimage.morphology.skeletonize(image)  Return the skeleton of a binary image. 
skimage.morphology.square(width[, dtype])  Generates a flat, squareshaped structuring element. 
skimage.morphology.watershed(image, markers)  Return a matrix labeled using the watershed segmentation algorithm 
skimage.morphology.white_tophat(image, selem)  Return white top hat of an image. 
Return fast binary morphological closing of an image.
This function returns the same result as greyscale closing but performs faster for binary images.
The morphological closing on an image is defined as a dilation followed by an erosion. Closing can remove small dark spots (i.e. “pepper”) and connect small bright cracks. This tends to “close” up (dark) gaps between (bright) features.
Parameters :  image : ndarray
selem : ndarray
out : ndarray


Returns :  closing : bool array

Return fast binary morphological dilation of an image.
This function returns the same result as greyscale dilation but performs faster for binary images.
Morphological dilation sets a pixel at (i,j) to the maximum over all pixels in the neighborhood centered at (i,j). Dilation enlarges bright regions and shrinks dark regions.
Parameters :  image : ndarray
selem : ndarray
out : ndarray


Returns :  dilated : bool array

Return fast binary morphological erosion of an image.
This function returns the same result as greyscale erosion but performs faster for binary images.
Morphological erosion sets a pixel at (i,j) to the minimum over all pixels in the neighborhood centered at (i,j). Erosion shrinks bright regions and enlarges dark regions.
Parameters :  image : ndarray
selem : ndarray
out : ndarray


Returns :  eroded : bool array

Return fast binary morphological opening of an image.
This function returns the same result as greyscale opening but performs faster for binary images.
The morphological opening on an image is defined as an erosion followed by a dilation. Opening can remove small bright spots (i.e. “salt”) and connect small dark cracks. This tends to “open” up (dark) gaps between (bright) features.
Parameters :  image : ndarray
selem : ndarray
out : ndarray


Returns :  opening : bool array

Return black top hat of an image.
The black top hat of an image is defined as its morphological closing minus the original image. This operation returns the dark spots of the image that are smaller than the structuring element. Note that dark spots in the original image are bright spots after the black top hat.
Parameters :  image : ndarray
selem : ndarray
out : ndarray


Returns :  opening : uint8 array

Examples
>>> # Change dark peak to bright peak and subtract background
>>> import numpy as np
>>> from skimage.morphology import square
>>> dark_on_grey = np.array([[7, 6, 6, 6, 7],
... [6, 5, 4, 5, 6],
... [6, 4, 0, 4, 6],
... [6, 5, 4, 5, 6],
... [7, 6, 6, 6, 7]], dtype=np.uint8)
>>> black_tophat(dark_on_grey, square(3))
array([[0, 0, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 1, 5, 1, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 0, 0]], dtype=uint8)
Return greyscale morphological closing of an image.
The morphological closing on an image is defined as a dilation followed by an erosion. Closing can remove small dark spots (i.e. “pepper”) and connect small bright cracks. This tends to “close” up (dark) gaps between (bright) features.
Parameters :  image : ndarray
selem : ndarray
out : ndarray


Returns :  closing : uint8 array

Examples
>>> # Close a gap between two bright lines
>>> import numpy as np
>>> from skimage.morphology import square
>>> broken_line = np.array([[0, 0, 0, 0, 0],
... [0, 0, 0, 0, 0],
... [1, 1, 0, 1, 1],
... [0, 0, 0, 0, 0],
... [0, 0, 0, 0, 0]], dtype=np.uint8)
>>> closing(broken_line, square(3))
array([[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[1, 1, 1, 1, 1],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]], dtype=uint8)
Compute the convex hull image of a binary image.
The convex hull is the set of pixels included in the smallest convex polygon that surround all white pixels in the input image.
Parameters :  image : ndarray


Returns :  hull : ndarray of uint8

References
[R102]  http://blogs.mathworks.com/steve/2011/10/04/binaryimageconvexhullalgorithmnotes/ 
Generates a flat, diamondshaped structuring element of a given radius. A pixel is part of the neighborhood (i.e. labeled 1) if the city block/manhattan distance between it and the center of the neighborhood is no greater than radius.
Parameters :  radius : int
dtype : datatype


Returns :  selem : ndarray

Return greyscale morphological dilation of an image.
Morphological dilation sets a pixel at (i,j) to the maximum over all pixels in the neighborhood centered at (i,j). Dilation enlarges bright regions and shrinks dark regions.
Parameters :  image : ndarray
selem : ndarray
out : ndarray
shift_x, shift_y : bool


Returns :  dilated : uint8 array

Examples
>>> # Dilation enlarges bright regions
>>> import numpy as np
>>> from skimage.morphology import square
>>> bright_pixel = np.array([[0, 0, 0, 0, 0],
... [0, 0, 0, 0, 0],
... [0, 0, 1, 0, 0],
... [0, 0, 0, 0, 0],
... [0, 0, 0, 0, 0]], dtype=np.uint8)
>>> dilation(bright_pixel, square(3))
array([[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0]], dtype=uint8)
Generates a flat, diskshaped structuring element of a given radius. A pixel is within the neighborhood if the euclidean distance between it and the origin is no greater than a radius.
Parameters :  radius : int
dtype : datatype


Returns :  selem : ndarray

Return greyscale morphological erosion of an image.
Morphological erosion sets a pixel at (i,j) to the minimum over all pixels in the neighborhood centered at (i,j). Erosion shrinks bright regions and enlarges dark regions.
Parameters :  image : ndarray
selem : ndarray
out : ndarray
shift_x, shift_y : bool


Returns :  eroded : uint8 array

Examples
>>> # Erosion shrinks bright regions
>>> import numpy as np
>>> from skimage.morphology import square
>>> bright_square = np.array([[0, 0, 0, 0, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 0, 0, 0, 0]], dtype=np.uint8)
>>> erosion(bright_square, square(3))
array([[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]], dtype=uint8)
Return a boolean array of points that are local maxima
Parameters :  image: ndarray (2D, 3D, ...) :
labels: ndarray, optional :
footprint: ndarray of bools, optional :


Returns :  result: ndarray of bools :

See also
Notes
This function is now a wrapper for skimage.feature.peak_local_max() and is retained only for convenience and backward compatibility.
Examples
>>> image = np.zeros((4, 4))
>>> image[1, 2] = 2
>>> image[3, 3] = 1
>>> image
array([[ 0., 0., 0., 0.],
[ 0., 0., 2., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 1.]])
>>> is_local_maximum(image)
array([[ True, False, False, False],
[ True, False, True, False],
[ True, False, False, False],
[ True, True, False, True]], dtype=bool)
>>> image = np.arange(16).reshape((4, 4))
>>> labels = np.array([[1, 2], [3, 4]])
>>> labels = np.repeat(np.repeat(labels, 2, axis=0), 2, axis=1)
>>> labels
array([[1, 1, 2, 2],
[1, 1, 2, 2],
[3, 3, 4, 4],
[3, 3, 4, 4]])
>>> image
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> is_local_maximum(image, labels=labels)
array([[False, False, False, False],
[False, True, False, True],
[False, False, False, False],
[False, True, False, True]], dtype=bool)
Label connected regions of an integer array.
Two pixels are connected when they are neighbors and have the same value. They can be neighbors either in a 4 or 8connected sense:
4connectivity 8connectivity
[ ] [ ] [ ] [ ]
 \  /
[ ][ ][ ] [ ][ ][ ]
 /  [ ] [ ] [ ] [ ]
Parameters :  input : ndarray of dtype int
neighbors : {4, 8}, int
background : int


Returns :  labels : ndarray of dtype int

Examples
>>> x = np.eye(3).astype(int)
>>> print x
[[1 0 0]
[0 1 0]
[0 0 1]]
>>> print m.label(x, neighbors=4)
[[0 1 1]
[2 3 1]
[2 2 4]]
>>> print m.label(x, neighbors=8)
[[0 1 1]
[1 0 1]
[1 1 0]]
>>> x = np.array([[1, 0, 0],
... [1, 1, 5],
... [0, 0, 0]])
>>> print m.label(x, background=0)
[[ 0 1 1]
[ 0 0 1]
[1 1 1]]
Compute the medial axis transform of a binary image
Parameters :  image : binary ndarray mask : binary ndarray, optional
return_distance : bool, optional


Returns :  out : ndarray of bools
dist : ndarray of ints

See also
Notes
This algorithm computes the medial axis transform of an image as the ridges of its distance transform.
Examples
>>> square = np.zeros((7, 7), dtype=np.uint8)
>>> square[1:1, 2:2] = 1
>>> square
array([[0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
>>> morphology.medial_axis(square).astype(np.uint8)
array([[0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
Return greyscale morphological opening of an image.
The morphological opening on an image is defined as an erosion followed by a dilation. Opening can remove small bright spots (i.e. “salt”) and connect small dark cracks. This tends to “open” up (dark) gaps between (bright) features.
Parameters :  image : ndarray
selem : ndarray
out : ndarray


Returns :  opening : uint8 array

Examples
>>> # Open up gap between two bright regions (but also shrink regions)
>>> import numpy as np
>>> from skimage.morphology import square
>>> bad_connection = np.array([[1, 0, 0, 0, 1],
... [1, 1, 0, 1, 1],
... [1, 1, 1, 1, 1],
... [1, 1, 0, 1, 1],
... [1, 0, 0, 0, 1]], dtype=np.uint8)
>>> opening(bad_connection, square(3))
array([[0, 0, 0, 0, 0],
[1, 1, 0, 1, 1],
[1, 1, 0, 1, 1],
[1, 1, 0, 1, 1],
[0, 0, 0, 0, 0]], dtype=uint8)
Perform a morphological reconstruction of an image.
Morphological reconstruction by dilation is similar to basic morphological dilation: highintensity values will replace nearby lowintensity values. The basic dilation operator, however, uses a structuring element to determine how far a value in the input image can spread. In contrast, reconstruction uses two images: a “seed” image, which specifies the values that spread, and a “mask” image, which gives the maximum allowed value at each pixel. The mask image, like the structuring element, limits the spread of highintensity values. Reconstruction by erosion is simply the inverse: lowintensity values spread from the seed image and are limited by the mask image, which represents the minimum allowed value.
Alternatively, you can think of reconstruction as a way to isolate the connected regions of an image. For dilation, reconstruction connects regions marked by local maxima in the seed image: neighboring pixels lessthanorequalto those seeds are connected to the seeded region. Local maxima with values larger than the seed image will get truncated to the seed value.
Parameters :  seed : ndarray
mask : ndarray
method : {‘dilation’’erosion’}
selem : ndarray


Returns :  reconstructed : ndarray

Notes
The algorithm is taken from [R103]. Applications for greyscale reconstruction are discussed in [R104] and [R105].
References
[R103]  (1, 2) Robinson, “Efficient morphological reconstruction: a downhill filter”, Pattern Recognition Letters 25 (2004) 17591767. 
[R104]  (1, 2) Vincent, L., “Morphological Grayscale Reconstruction in Image Analysis: Applications and Efficient Algorithms”, IEEE Transactions on Image Processing (1993) 
[R105]  (1, 2) Soille, P., “Morphological Image Analysis: Principles and Applications”, Chapter 6, 2nd edition (2003), ISBN 3540429883. 
Examples
>>> import numpy as np
>>> from skimage.morphology import reconstruction
First, we create a sinusoidal mask image w/ peaks at middle and ends. >>> x = np.linspace(0, 4 * np.pi) >>> y_mask = np.cos(x)
Then, we create a seed image initialized to the minimum mask value (for reconstruction by dilation, minintensity values don’t spread) and add “seeds” to the left and right peak, but at a fraction of peak value (1). >>> y_seed = y_mask.min() * np.ones_like(x) >>> y_seed[0] = 0.5 >>> y_seed[1] = 0 >>> y_rec = reconstruction(y_seed, y_mask)
The reconstructed image (or curve, in this case) is exactly the same as the mask image, except that the peaks are truncated to 0.5 and 0. The middle peak disappears completely: Since there were no seed values in this peak region, its reconstructed value is truncated to the surrounding value (1).
As a more practical example, we try to extract the bright features of an image by subtracting a background image created by reconstruction.
>>> y, x = np.mgrid[:20:0.5, :20:0.5]
>>> bumps = np.sin(x) + np.sin(y)
To create the background image, set the mask image to the original image, and the seed image to the original image with an intensity offset, h.
>>> h = 0.3
>>> seed = bumps  h
>>> background = reconstruction(seed, bumps)
The resulting reconstructed image looks exactly like the original image, but with the peaks of the bumps cut off. Subtracting this reconstructed image from the original image leaves just the peaks of the bumps
>>> hdome = bumps  background
This operation is known as the hdome of the image and leaves features of height h in the subtracted image.
Generates a flat, rectangularshaped structuring element of a given width and height. Every pixel in the rectangle belongs to the neighboorhood.
Parameters :  width : int
height : int


Returns :  selem : ndarray

Remove connected components smaller than the specified size.
Parameters :  ar : ndarray (arbitrary shape, int or bool type)
min_size : int, optional (default: 64)
connectivity : int, {1, 2, ..., ar.ndim}, optional (default: 1)
in_place : bool, optional (default: False)


Returns :  out : ndarray, same shape and type as input ar

Raises :  ValueError :

Examples
>>> from skimage import morphology
>>> from scipy import ndimage as nd
>>> a = np.array([[0, 0, 0, 1, 0],
... [1, 1, 1, 0, 0],
... [1, 1, 1, 0, 1]], bool)
>>> b = morphology.remove_small_connected_components(a, 6)
>>> b
array([[False, False, False, False, False],
[ True, True, True, False, False],
[ True, True, True, False, False]], dtype=bool)
>>> c = morphology.remove_small_connected_components(a, 7, connectivity=2)
>>> c
array([[False, False, False, True, False],
[ True, True, True, False, False],
[ True, True, True, False, False]], dtype=bool)
>>> d = morphology.remove_small_connected_components(a, 6, in_place=True)
>>> d is a
True
Return the skeleton of a binary image.
Thinning is used to reduce each connected component in a binary image to a singlepixel wide skeleton.
Parameters :  image : numpy.ndarray


Returns :  skeleton : ndarray

See also
Notes
The algorithm [1] works by making successive passes of the image, removing pixels on object borders. This continues until no more pixels can be removed. The image is correlated with a mask that assigns each pixel a number in the range [0...255] corresponding to each possible pattern of its 8 neighbouring pixels. A look up table is then used to assign the pixels a value of 0, 1, 2 or 3, which are selectively removed during the iterations.
Note that this algorithm will give different results than a medial axis transform, which is also often referred to as “skeletonization”.
References
[R106]  A fast parallel algorithm for thinning digital patterns, T. Y. ZHANG and C. Y. SUEN, Communications of the ACM, March 1984, Volume 27, Number 3 
Examples
>>> X, Y = np.ogrid[0:9, 0:9]
>>> ellipse = (1./3 * (X  4)**2 + (Y  4)**2 < 3**2).astype(np.uint8)
>>> ellipse
array([[0, 0, 0, 1, 1, 1, 0, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 1, 1, 1, 0, 0, 0]], dtype=uint8)
>>> skel = skeletonize(ellipse)
>>> skel
array([[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
Generates a flat, squareshaped structuring element. Every pixel along the perimeter has a chessboard distance no greater than radius (radius=floor(width/2)) pixels.
Parameters :  width : int


Returns :  selem : ndarray

Return a matrix labeled using the watershed segmentation algorithm
Parameters :  image: ndarray (2D, 3D, ...) of integers :
markers: ndarray of the same shape as `image` :
connectivity: ndarray, optional :
offset: array_like of shape image.ndim, optional :
mask: ndarray of bools or 0s and 1s, optional :


Returns :  out: ndarray :

See also
Notes
This function implements a watershed algorithm [R107]_that apportions pixels into marked basins. The algorithm uses a priority queue to hold the pixels with the metric for the priority queue being pixel value, then the time of entry into the queue  this settles ties in favor of the closest marker.
Some ideas taken from Soille, “Automated Basin Delineation from Digital Elevation Models Using Mathematical Morphology”, Signal Processing 20 (1990) 171182
The most important insight in the paper is that entry time onto the queue solves two problems: a pixel should be assigned to the neighbor with the largest gradient or, if there is no gradient, pixels on a plateau should be split between markers on opposite sides.
This implementation converts all arguments to specific, lowest common denominator types, then passes these to a C algorithm.
Markers can be determined manually, or automatically using for example the local minima of the gradient of the image, or the local maxima of the distance function to the background for separating overlapping objects (see example).
References
[R107]  http://en.wikipedia.org/wiki/Watershed_%28image_processing%29 
[R108]  http://cmm.ensmp.fr/~beucher/wtshed.html 
Examples
The watershed algorithm is very useful to separate overlapping objects
>>> # Generate an initial image with two overlapping circles
>>> x, y = np.indices((80, 80))
>>> x1, y1, x2, y2 = 28, 28, 44, 52
>>> r1, r2 = 16, 20
>>> mask_circle1 = (x  x1)**2 + (y  y1)**2 < r1**2
>>> mask_circle2 = (x  x2)**2 + (y  y2)**2 < r2**2
>>> image = np.logical_or(mask_circle1, mask_circle2)
>>> # Now we want to separate the two objects in image
>>> # Generate the markers as local maxima of the distance
>>> # to the background
>>> from scipy import ndimage
>>> distance = ndimage.distance_transform_edt(image)
>>> local_maxi = is_local_maximum(distance, image, np.ones((3, 3)))
>>> markers = ndimage.label(local_maxi)[0]
>>> labels = watershed(distance, markers, mask=image)
The algorithm works also for 3D images, and can be used for example to separate overlapping spheres.
Return white top hat of an image.
The white top hat of an image is defined as the image minus its morphological opening. This operation returns the bright spots of the image that are smaller than the structuring element.
Parameters :  image : ndarray
selem : ndarray
out : ndarray


Returns :  opening : uint8 array

Examples
>>> # Subtract grey background from bright peak
>>> import numpy as np
>>> from skimage.morphology import square
>>> bright_on_grey = np.array([[2, 3, 3, 3, 2],
... [3, 4, 5, 4, 3],
... [3, 5, 9, 5, 3],
... [3, 4, 5, 4, 3],
... [2, 3, 3, 3, 2]], dtype=np.uint8)
>>> white_tophat(bright_on_grey, square(3))
array([[0, 0, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 1, 5, 1, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 0, 0]], dtype=uint8)