def label(input, structure=None, output=None):
"""Label an array of objects.
The structure that defines the object connections must be
symmetric. If no structuring element is provided an element is
generated with a squared connectivity equal to one. This function
returns a tuple consisting of the array of labels and the number
of objects found. If an output array is provided only the number of
objects found is returned.
"""
input = numpy.asarray(input)
if numpy.iscomplexobj(input):
raise TypeError, 'Complex type not supported'
if structure is None:
structure = morphology.generate_binary_structure(input.ndim, 1)
structure = numpy.asarray(structure, dtype=bool)
if structure.ndim != input.ndim:
raise RuntimeError, 'structure and input must have equal rank'
for ii in structure.shape:
if ii != 3:
raise RuntimeError, 'structure dimensions must be equal to 3'
if not structure.flags.contiguous:
structure = structure.copy()
if isinstance(output, numpy.ndarray):
if output.dtype.type != numpy.int32:
raise RuntimeError, 'output type must be int32'
else:
output = numpy.int32
output, return_value = _ni_support._get_output(output, input)
max_label = _nd_image.label(input, structure, output)
if return_value is None:
return max_label
else:
return return_value, max_label
def label(input, structure = None, output = None):
"""Label an array of objects.
The structure that defines the object connections must be
symmetric. If no structuring element is provided an element is
generated with a squared connectivity equal to one. This function
returns a tuple consisting of the array of labels and the number
of objects found. If an output array is provided only the number of
objects found is returned.
"""
input = numarray.asarray(input)
if isinstance(input.type(), numarray.ComplexType):
raise TypeError, 'Complex type not supported'
if structure == None:
structure = morphology.generate_binary_structure(input.rank, 1)
structure = numarray.asarray(structure, type = numarray.Bool)
if structure.rank != input.rank:
raise RuntimeError, 'structure and input must have equal rank'
for ii in structure.shape:
if ii != 3:
raise RuntimeError, 'structure dimensions must be equal to 3'
if not structure.iscontiguous():
structure = structure.copy()
if isinstance(output, numarray.NumArray):
if output.type() != numarray.Int32:
raise RuntimeError, 'output type must be Int32'
else:
output = numarray.Int32
output, return_value = _ni_support._get_output(output, input)
max_label = _nd_image.label(input, structure, output)
if return_value == None:
return max_label
else:
return return_value, max_label
def label(input, structure=None, output=None):
"""
Label features in an array.
Parameters
----------
input : array_like
An array-like object to be labeled. Any non-zero values in `input` are
counted as features and zero values are considered the background.
structure : array_like, optional
A structuring element that defines feature connections.
`structure` must be symmetric. If no structuring element is provided,
one is automatically generated with a squared connectivity equal to
one. That is, for a 2-D `input` array, the default structuring element
is::
[[0,1,0],
[1,1,1],
[0,1,0]]
output : (None, data-type, array_like), optional
If `output` is a data type, it specifies the type of the resulting
labeled feature array
If `output` is an array-like object, then `output` will be updated
with the labeled features from this function
Returns
-------
labeled_array : array_like
An array-like object where each unique feature has a unique value
num_features : int
How many objects were found
If `output` is None or a data type, this function returns a tuple,
(`labeled_array`, `num_features`).
If `output` is an array, then it will be updated with values in
`labeled_array` and only `num_features` will be returned by this function.
See Also
--------
find_objects : generate a list of slices for the labeled features (or
objects); useful for finding features' position or
dimensions
Examples
--------
Create an image with some features, then label it using the default
(cross-shaped) structuring element:
>>> a = array([[0,0,1,1,0,0],
... [0,0,0,1,0,0],
... [1,1,0,0,1,0],
... [0,0,0,1,0,0]])
>>> labeled_array, num_features = label(a)
Each of the 4 features are labeled with a different integer:
>>> print num_features
4
>>> print labeled_array
array([[0, 0, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0],
[2, 2, 0, 0, 3, 0],
[0, 0, 0, 4, 0, 0]])
Generate a structuring element that will consider features connected even
if they touch diagonally:
>>> s = generate_binary_structure(2,2)
or,
>>> s = [[1,1,1],
[1,1,1],
[1,1,1]]
Label the image using the new structuring element:
>>> labeled_array, num_features = label(a, structure=s)
Show the 2 labeled features (note that features 1, 3, and 4 from above are
now considered a single feature):
>>> print num_features
2
>>> print labeled_array
array([[0, 0, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0],
[2, 2, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0]])
"""
input = numpy.asarray(input)
if numpy.iscomplexobj(input):
raise TypeError('Complex type not supported')
if structure is None:
structure = morphology.generate_binary_structure(input.ndim, 1)
structure = numpy.asarray(structure, dtype=bool)
if structure.ndim != input.ndim:
raise RuntimeError('structure and input must have equal rank')
for ii in structure.shape:
if ii != 3:
raise RuntimeError('structure dimensions must be equal to 3')
if not structure.flags.contiguous:
structure = structure.copy()
if isinstance(output, numpy.ndarray):
if output.dtype.type != numpy.int32:
raise RuntimeError('output type must be int32')
else:
output = numpy.int32
output, return_value = _ni_support._get_output(output, input)
max_label = _nd_image.label(input, structure, output)
if return_value is None:
return max_label
else:
return return_value, max_label
def label(input, structure=None, output=None):
"""
Label features in an array.
Parameters
----------
input : array_like
An array-like object to be labeled. Any non-zero values in `input` are
counted as features and zero values are considered the background.
structure : array_like, optional
A structuring element that defines feature connections.
`structure` must be symmetric. If no structuring element is provided,
one is automatically generated with a squared connectivity equal to
one. That is, for a 2-D `input` array, the default structuring element
is::
[[0,1,0],
[1,1,1],
[0,1,0]]
output : (None, data-type, array_like), optional
If `output` is a data type, it specifies the type of the resulting
labeled feature array
If `output` is an array-like object, then `output` will be updated
with the labeled features from this function
Returns
-------
labeled_array : array_like
An array-like object where each unique feature has a unique value
num_features : int
How many objects were found
If `output` is None or a data type, this function returns a tuple,
(`labeled_array`, `num_features`).
If `output` is an array, then it will be updated with values in
`labeled_array` and only `num_features` will be returned by this function.
See Also
--------
find_objects : generate a list of slices for the labeled features (or
objects); useful for finding features' position or
dimensions
Examples
--------
Create an image with some features, then label it using the default
(cross-shaped) structuring element:
>>> a = array([[0,0,1,1,0,0],
... [0,0,0,1,0,0],
... [1,1,0,0,1,0],
... [0,0,0,1,0,0]])
>>> labeled_array, num_features = label(a)
Each of the 4 features are labeled with a different integer:
>>> print num_features
4
>>> print labeled_array
array([[0, 0, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0],
[2, 2, 0, 0, 3, 0],
[0, 0, 0, 4, 0, 0]])
Generate a structuring element that will consider features connected even
if they touch diagonally:
>>> s = generate_binary_structure(2,2)
or,
>>> s = [[1,1,1],
[1,1,1],
[1,1,1]]
Label the image using the new structuring element:
>>> labeled_array, num_features = label(a, structure=s)
Show the 2 labeled features (note that features 1, 3, and 4 from above are
now considered a single feature):
>>> print num_features
2
>>> print labeled_array
array([[0, 0, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0],
[2, 2, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0]])
"""
input = numpy.asarray(input)
if numpy.iscomplexobj(input):
raise TypeError('Complex type not supported')
if structure is None:
structure = morphology.generate_binary_structure(input.ndim, 1)
structure = numpy.asarray(structure, dtype = bool)
if structure.ndim != input.ndim:
raise RuntimeError('structure and input must have equal rank')
for ii in structure.shape:
if ii != 3:
raise RuntimeError('structure dimensions must be equal to 3')
if not structure.flags.contiguous:
structure = structure.copy()
requested_output = None
requested_dtype = None
if isinstance(output, numpy.ndarray):
if output.dtype.type != numpy.int32:
if output.shape != input.shape:
raise RuntimeError("output shape not correct")
# _ndimage.label() needs np.int32
requested_output = output
output = numpy.int32
else:
# output will be written directly
pass
else:
requested_dtype = output
output = numpy.int32
output, return_value = _ni_support._get_output(output, input)
max_label = _nd_image.label(input, structure, output)
if return_value is None:
# result was written in-place
return max_label
elif requested_output is not None:
# original output was not int32
requested_output[...] = output[...]
return max_label
else:
if requested_dtype is not None:
return_value = return_value.astype(requested_dtype)
return return_value, max_label