Module: segmentation¶

image : (N, M) or (N, M, 3) ndarray

Input image.

snake : (N, 2) ndarray

Initialisation coordinates of snake. For periodic snakes, it should not include duplicate endpoints.

alpha : float, optional

Snake length shape parameter. Higher values makes snake contract faster.

beta : float, optional

Snake smoothness shape parameter. Higher values makes snake smoother.

w_line : float, optional

Controls attraction to brightness. Use negative values to attract to dark regions.

w_edge : float, optional

Controls attraction to edges. Use negative values to repel snake from edges.

gamma : float, optional

Explicit time stepping parameter.

bc : {‘periodic’, ‘free’, ‘fixed’}, optional

Boundary conditions for worm. ‘periodic’ attaches the two ends of the snake, ‘fixed’ holds the end-points in place, and’free’ allows free movement of the ends. ‘fixed’ and ‘free’ can be combined by parsing ‘fixed-free’, ‘free-fixed’. Parsing ‘fixed-fixed’ or ‘free-free’ yields same behaviour as ‘fixed’ and ‘free’, respectively.

max_px_move : float, optional

Maximum pixel distance to move per iteration.

max_iterations : int, optional

Maximum iterations to optimize snake shape.

convergence: float, optional

Convergence criteria.

labels : (M[, N[, …, P]]) array of int or bool

Imaging data labels.

buffer_size : int, optional

The width of the border examined. By default, only objects that touch the outside of the image are removed.

bgval : float or int, optional

Cleared objects are set to this value.

in_place : bool, optional

Whether or not to manipulate the labels array in-place.

image : (width, height, 3) or (width, height) ndarray

Input image.

scale : float

Free parameter. Higher means larger clusters.

sigma : float

Width of Gaussian kernel used in preprocessing.

min_size : int

Minimum component size. Enforced using postprocessing.

multichannel : bool, optional (default: True)

Whether the last axis of the image is to be interpreted as multiple channels. A value of False, for a 3D image, is not currently supported.

label_img : array of int or bool

An array in which different regions are labeled with either different integers or boolean values.

connectivity: int in {1, …, `label_img.ndim`}, optional

A pixel is considered a boundary pixel if any of its neighbors has a different label. connectivity controls which pixels are considered neighbors. A connectivity of 1 (default) means pixels sharing an edge (in 2D) or a face (in 3D) will be considered neighbors. A connectivity of label_img.ndim means pixels sharing a corner will be considered neighbors.

mode: string in {‘thick’, ‘inner’, ‘outer’, ‘subpixel’}

How to mark the boundaries:

• thick: any pixel not completely surrounded by pixels of the same label (defined by connectivity) is marked as a boundary. This results in boundaries that are 2 pixels thick.
• inner: outline the pixels just inside of objects, leaving background pixels untouched.
• outer: outline pixels in the background around object boundaries. When two objects touch, their boundary is also marked.
• subpixel: return a doubled image, with pixels between the original pixels marked as boundary where appropriate.

background: int, optional

For modes ‘inner’ and ‘outer’, a definition of a background label is required. See mode for descriptions of these two.

s1, s2 : numpy arrays

s1 and s2 are label fields of the same shape.

image : (M, N[, 3]) array

Grayscale or RGB image.

label_img : (M, N) array of int

Label array where regions are marked by different integer values.

color : length-3 sequence, optional

RGB color of boundaries in the output image.

outline_color : length-3 sequence, optional

RGB color surrounding boundaries in the output image. If None, no outline is drawn.

mode : string in {‘thick’, ‘inner’, ‘outer’, ‘subpixel’}, optional

The mode for finding boundaries.

background_label : int, optional

Which label to consider background (this is only useful for modes inner and outer).

image : (width, height, channels) ndarray

Input image.

ratio : float, optional, between 0 and 1

Balances color-space proximity and image-space proximity. Higher values give more weight to color-space.

kernel_size : float, optional

Width of Gaussian kernel used in smoothing the sample density. Higher means fewer clusters.

max_dist : float, optional

Cut-off point for data distances. Higher means fewer clusters.

return_tree : bool, optional

Whether to return the full segmentation hierarchy tree and distances.

sigma : float, optional

Width for Gaussian smoothing as preprocessing. Zero means no smoothing.

convert2lab : bool, optional

Whether the input should be converted to Lab colorspace prior to segmentation. For this purpose, the input is assumed to be RGB.

random_seed : int, optional

Random seed used for breaking ties.

data : array_like

Image to be segmented in phases. Gray-level data can be two- or three-dimensional; multichannel data can be three- or four- dimensional (multichannel=True) with the highest dimension denoting channels. Data spacing is assumed isotropic unless the spacing keyword argument is used.

labels : array of ints, of same shape as data without channels dimension

Array of seed markers labeled with different positive integers for different phases. Zero-labeled pixels are unlabeled pixels. Negative labels correspond to inactive pixels that are not taken into account (they are removed from the graph). If labels are not consecutive integers, the labels array will be transformed so that labels are consecutive. In the multichannel case, labels should have the same shape as a single channel of data, i.e. without the final dimension denoting channels.

beta : float

Penalization coefficient for the random walker motion (the greater beta, the more difficult the diffusion).

mode : string, available options {‘cg_mg’, ‘cg’, ‘bf’}

Mode for solving the linear system in the random walker algorithm. If no preference given, automatically attempt to use the fastest option available (‘cg_mg’ from pyamg >> ‘cg’ with UMFPACK > ‘bf’).

• ‘bf’ (brute force): an LU factorization of the Laplacian is computed. This is fast for small images (<1024x1024), but very slow and memory-intensive for large images (e.g., 3-D volumes).
• ‘cg’ (conjugate gradient): the linear system is solved iteratively using the Conjugate Gradient method from scipy.sparse.linalg. This is less memory-consuming than the brute force method for large images, but it is quite slow.
• ‘cg_mg’ (conjugate gradient with multigrid preconditioner): a preconditioner is computed using a multigrid solver, then the solution is computed with the Conjugate Gradient method. This mode requires that the pyamg module (http://pyamg.org/) is installed. For images of size > 512x512, this is the recommended (fastest) mode.

tol : float

tolerance to achieve when solving the linear system, in cg’ and ‘cg_mg’ modes.

copy : bool

If copy is False, the labels array will be overwritten with the result of the segmentation. Use copy=False if you want to save on memory.

multichannel : bool, default False

If True, input data is parsed as multichannel data (see ‘data’ above for proper input format in this case)

return_full_prob : bool, default False

If True, the probability that a pixel belongs to each of the labels will be returned, instead of only the most likely label.

spacing : iterable of floats

Spacing between voxels in each spatial dimension. If None, then the spacing between pixels/voxels in each dimension is assumed 1.

label_field : numpy array of int, arbitrary shape

An array of labels.

offset : int, optional

The return labels will start at offset, which should be strictly positive.

image : 2D, 3D or 4D ndarray

Input image, which can be 2D or 3D, and grayscale or multichannel (see multichannel parameter).

n_segments : int, optional

The (approximate) number of labels in the segmented output image.

compactness : float, optional

Balances color proximity and space proximity. Higher values give more weight to space proximity, making superpixel shapes more square/cubic. In SLICO mode, this is the initial compactness. This parameter depends strongly on image contrast and on the shapes of objects in the image. We recommend exploring possible values on a log scale, e.g., 0.01, 0.1, 1, 10, 100, before refining around a chosen value.

max_iter : int, optional

Maximum number of iterations of k-means.

sigma : float or (3,) array-like of floats, optional

Width of Gaussian smoothing kernel for pre-processing for each dimension of the image. The same sigma is applied to each dimension in case of a scalar value. Zero means no smoothing. Note, that sigma is automatically scaled if it is scalar and a manual voxel spacing is provided (see Notes section).

spacing : (3,) array-like of floats, optional

The voxel spacing along each image dimension. By default, slic assumes uniform spacing (same voxel resolution along z, y and x). This parameter controls the weights of the distances along z, y, and x during k-means clustering.

multichannel : bool, optional

Whether the last axis of the image is to be interpreted as multiple channels or another spatial dimension.

convert2lab : bool, optional

Whether the input should be converted to Lab colorspace prior to segmentation. The input image must be RGB. Highly recommended. This option defaults to True when multichannel=True and image.shape[-1] == 3.

enforce_connectivity: bool, optional

Whether the generated segments are connected or not

min_size_factor: float, optional

Proportion of the minimum segment size to be removed with respect to the supposed segment size `depth*width*height/n_segments`

max_size_factor: float, optional

Proportion of the maximum connected segment size. A value of 3 works in most of the cases.

slic_zero: bool, optional

Run SLIC-zero, the zero-parameter mode of SLIC. [R913913]

ValueError

If convert2lab is set to True but the last array dimension is not of length 3.

image: ndarray (2-D, 3-D, …) of integers

Data array where the lowest value points are labeled first.

markers: int, or ndarray of int, same shape as `image`

The desired number of markers, or an array marking the basins with the values to be assigned in the label matrix. Zero means not a marker.

connectivity: ndarray, optional

An array with the same number of dimensions as image whose non-zero elements indicate neighbors for connection. Following the scipy convention, default is a one-connected array of the dimension of the image.

offset: array_like of shape image.ndim, optional

offset of the connectivity (one offset per dimension)

mask: ndarray of bools or 0s and 1s, optional

Array of same shape as image. Only points at which mask == True will be labeled.

compactness : float, optional

Use compact watershed [R918918] with given compactness parameter. Higher values result in more regularly-shaped watershed basins.

watershed_line : bool, optional

If watershed_line is True, a one-pixel wide line separates the regions obtained by the watershed algorithm. The line has the label 0.