rank, connectivity) |
>>> print generate_binary_structure(2, 1) [[0 1 0] [1 1 1] [0 1 0]] >>> print generate_binary_structure(2, 2) [[1 1 1] [1 1 1] [1 1 1]]
Most binary morphology functions can be expressed in terms of the basic operations erosion and dilation:
input, structure=None, iterations=1, mask=None, output=None, border_value=0, origin=0) |
input, structure=None, iterations=1, mask=None, output=None, border_value=0, origin=0) |
Here is an example of using binary_dilation to find all elements that touch the border, by repeatedly dilating an empty array from the border using the data array as the mask:
>>> struct = array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) >>> a = array([[1,0,0,0,0], [1,1,0,1,0], [0,0,1,1,0], [0,0,0,0,0]]) >>> print a [[1 0 0 0 0] [1 1 0 1 0] [0 0 1 1 0] [0 0 0 0 0]] >>> print binary_dilation(zeros(a.shape), struct, -1, a, border_value=1) [[1 0 0 0 0] [1 1 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]
The binary_erosion and binary_dilation functions both
have an iterations parameter which allows the erosion or dilation to be
repeated a number of times. Repeating an erosion of a dilation with a given
structure times is equivalent to an erosions or a dilation with a structure
that is
times dilated with itself. For a low number of iterations this
is more efficient, and for this reason a function is provided that allows the
calculation of a structure that is dilated a number of times with itself:
structure, iterations, origin=None) |
>>> struct = generate_binary_structure(2, 1) >>> print struct [[0 1 0] [1 1 1] [0 1 0]] >>> print iterate_structure(struct, 2) [[0 0 1 0 0] [0 1 1 1 0] [1 1 1 1 1] [0 1 1 1 0] [0 0 1 0 0]]
>>> print iterate_structure(struct, 2, -1) (array([[0, 0, 1, 0, 0], [0, 1, 1, 1, 0], [1, 1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0]], type=Bool), [-2, -2])
Other morphology operations can be defined in terms of erosion and dilation. Following functions provide a few of these operations for convenience:
input, structure=None, iterations=1, output=None, origin=0) |
input, structure=None, iterations=1, output=None, origin=0) |
input, structure1=None, structure2=None, output=None, origin1=0, origin2=None) |
Grey-scale morphology operations are the equivalents of binary morphology operations that operate on arrays with arbritrary values. Below we describe the grey-scale equivalents of erosion, dilation, opening and closing. These operations are implemented in a similar fashion as the filters described in section 18.2, and we refer to this section for the description of filter kernels and footprints, and the handling of array borders. The grey-scale morphology operations optionally take a structure parameter that gives the values of the structuring element. If this parameter is not given the structuring element is assumed to be flat with a value equal to zero. The shape of the structure can optionally be defined by the footprint parameter. If this parameter is not given, the structure is assumed to be rectangular, with sizes equal to the dimensions of the structure array, or by the size parameter if structure is not given. The size parameter is only used if both structure and footprint are not given, in which case the structuring element is assumed to be rectangular and flat with the dimensions given by size. The size parameter, if provided, must be a sequence of sizes or a single number in which case the size of the filter is assumed to be equal along each axis. The footprint parameter, if provided, must be an array that defines the shape of the kernel by its non-zero elements.
Similar to binary erosion and dilation there are operations for grey-scale erosion and dilation:
input, size=None, footprint=None, structure=None, output=None, mode='nearest', cval=0.0, origin=0) |
input, size=None, footprint=None, structure=None, output=None, mode='nearest', cval=0.0, origin=0) |
Grey-scale opening and closing operations can be defined similar to their binary counterparts:
input, size=None, footprint=None, structure=None, output=None, mode='nearest', cval=0.0, origin=0) |
input, size=None, footprint=None, structure=None, output=None, mode='nearest', cval=0.0, origin=0) |
input, size=None, footprint=None, structure=None, output=None, mode='nearest', cval=0.0, origin=0) |
input, size=None, footprint=None, structure=None, output=None, mode='nearest', cval=0.0, origin=0) |
input, size=None, footprint=None, structure=None, output=None, mode='nearest', cval=0.0, origin=0) |
input, size=None, footprint=None, structure=None, output=None, mode='nearest', cval=0.0, origin=0) |
Send comments to the NumArray community.