Image Processing Toolbox User's Guide

Structuring Elements

An essential part of the dilation and erosion operations is the structuring element used to probe the input image. A structuring element is a matrix consisting of only 0's and 1's that can have any arbitrary shape and size. The pixels with values of 1 define the neighborhood.

Two-dimensional, or flat, structuring elements are typically much smaller than the image being processed. The center pixel of the structuring element, called the origin, identifies the pixel of interest -- the pixel being processed. The pixels in the structuring element containing 1's define the neighborhood of the structuring element. These pixels are also considered in dilation or erosion processing.

Three-dimensional, or nonflat, structuring elements use 0's and 1's to define the extent of the structuring element in the x- and y-planes and add height values to define the third dimension.

The Origin of a Structuring Element

The morphological functions use this code to get the coordinates of the origin of structuring elements of any size and dimension.

• ``````origin = floor((size(nhood)+1)/2)
``````

(In this code `nhood` is the neighborhood defining the structuring element. Because structuring elements are MATLAB objects, you cannot use the size of the `STREL` object itself in this calculation. You must use the `STREL` `getnhood` method to retrieve the neighborhood of the structuring element from the `STREL` object. For information about other `STREL` object methods, see the strel function reference page.)

For example, the following illustrates a diamond-shaped structuring element.

Origin of a Diamond-Shaped Structuring Element

Creating a Structuring Element

The toolbox dilation and erosion functions accept structuring element objects, called `STRELs`. You use the `strel` function to create `STRELs` of any arbitrary size and shape. The `strel` function also includes built-in support for many common shapes, such as lines, diamonds, disks, periodic lines, and balls.

 Note    You typically choose a structuring element the same size and shape as the objects you want to process in the input image. For example, to find lines in an image, create a linear structuring element.

For example, this code creates a flat, diamond-shaped structuring element.

• ```se = strel('diamond',3)
se =

Flat STREL object containing 25 neighbors.
Decomposition: 3 STREL objects containing a total of 13 neighbors

Neighborhood:
0     0     0     1     0     0     0
0     0     1     1     1     0     0
0     1     1     1     1     1     0
1     1     1     1     1     1     1
0     1     1     1     1     1     0
0     0     1     1     1     0     0
0     0     0     1     0     0     0
```

Structuring Element Decomposition

To enhance performance, the `strel` function might break structuring elements into smaller pieces, a technique known as structuring element decomposition.

For example, dilation by an 11-by-11 square structuring element can be accomplished by dilating first with a 1-by-11 structuring element, and then with an 11-by-1 structuring element. This results in a theoretical speed improvement of a factor of 5.5, although in practice the actual speed improvement is somewhat less.

Structuring element decompositions used for the `'disk'` and `'ball'` shapes are approximations; all other decompositions are exact. Decomposition is not used with an arbitrary structuring element unless it is a flat structuring element whose neighborhood is all 1's.

To view the sequence of structuring elements used in a decomposition, use the `STREL` `getsequence` method. The `getsequence` function returns an array of the structuring elements that form the decomposition. For example, here are the structuring elements created in the decomposition of a diamond-shaped structuring element.

• ```sel = strel('diamond',4)
sel =
Flat STREL object containing 41 neighbors.
Decomposition: 3 STREL objects containing a total of 13 neighbors

Neighborhood:
0     0     0     0     1     0     0     0     0
0     0     0     1     1     1     0     0     0
0     0     1     1     1     1     1     0     0
0     1     1     1     1     1     1     1     0
1     1     1     1     1     1     1     1     1
0     1     1     1     1     1     1     1     0
0     0     1     1     1     1     1     0     0
0     0     0     1     1     1     0     0     0
0     0     0     0     1     0     0     0     0

seq = getsequence(sel)
seq =
3x1 array of STREL objects

seq(1)
ans =
Flat STREL object containing 5 neighbors.

Neighborhood:
0     1     0
1     1     1
0     1     0

seq(2)
ans =
Flat STREL object containing 4 neighbors.

Neighborhood:
0     1     0
1     0     1
0     1     0

seq(3)
ans =
Flat STREL object containing 4 neighbors.

Neighborhood:
0     0     1     0     0
0     0     0     0     0
1     0     0     0     1
0     0     0     0     0
0     0     1     0     0
```

 Understanding Dilation and Erosion Dilating an Image