imdilate

Dilate image

collapse all in page

Syntax

J = imdilate(I,SE)

J = imdilate(I,nhood)

J = imdilate(___,packopt)

J = imdilate(___,shape)

Description

J = imdilate(I,SE) dilates the grayscale, binary, or packed binary image I using the structuring element SE.

example

J = imdilate(I,nhood) dilates the image I, where nhood is a matrix of 0s and 1s that specifies the structuring element neighborhood.

This syntax is equivalent to imdilate(I,strel(nhood)).

J = imdilate(___,packopt) specifies whether I is a packed binary image.

J = imdilate(___,shape) specifies the size of the output image.

Examples

collapse all

Dilate Image with Vertical Line Structuring Element

Open Live Script

Read a binary image into the workspace.

BW = imread("text.png");

Create a vertical line shaped structuring element.

se = strel("line",11,90);

Dilate the image with a vertical line structuring element.

BW2 = imdilate(BW,se);

Compare the original and dilated image.

imshow(BW)
title("Original")

Figure contains an axes object. The hidden axes object with title Original contains an object of type image.

imshow(BW2)
title("Dilated")

Figure contains an axes object. The hidden axes object with title Dilated contains an object of type image.

Dilate Grayscale Image with Rolling Ball

Open Live Script

Read a grayscale image into the workspace.

originalI = imread("cameraman.tif");

Create a nonflat ball-shaped structuring element.

se = offsetstrel("ball",5,5);

Dilate the image.

dilatedI = imdilate(originalI,se);

Display the original image and the dilated image.

imshowpair(originalI,dilatedI,"montage")

Figure contains an axes object. The hidden axes object contains an object of type image.

Dilate Points in 3-D Space Using Spherical Structuring Elements

Open Live Script

Create a logical 3-D volume with two points.

BW = false(100,100,100);
BW(25,25,25) = true;
BW(75,75,75) = true;

Dilate the 3D volume using a spherical structuring element.

se = strel("sphere",25);
dilatedBW = imdilate(BW,se);

Display the dilated image volume.

isosurface(dilatedBW,0.5)
axis equal

Figure contains an axes object. The axes object contains an object of type patch.

Input Arguments

collapse all

`I` — Input image
grayscale image | binary image | packed binary image

Input image, specified as a grayscale image, binary image, or packed binary image of any dimension.

`SE` — Structuring element
`strel` object | `offsetstrel` object | array of `strel` objects | array of `offsetstrel` objects

Structuring element, specified as a scalar strel object or offsetstrel object. SE can also be an array of strel object or offsetstrel objects, in which case imdilate performs multiple dilations of the input image, using each structuring element in succession.

imdilate performs grayscale dilation for all images except images of data type logical. In this case, the structuring element must be flat and imdilate performs binary dilation.

`nhood` — Structuring element neighborhood
matrix of `0`s and `1`s

Structuring element neighborhood, specified as a matrix of 0s and 1s.

Example: [0 1 0; 1 1 1; 0 1 0]

`packopt` — Indicator of packed binary image
`"notpacked"` (default) | `"packed"`

Indicator of packed binary image, specified as one of the following.

Value	Description
`"notpacked"`	`I` is treated as a normal array.
`"ispacked"`	`I` is treated as a packed binary image as produced by `bwpack`. `I` must be a 2-D `uint32` array and `SE` must be a flat 2-D structuring element. The value of `shape` must be `"same"`.

Data Types: char | string

`shape` — Size of output image
`"same"` (default) | `"full"`

Size of the output image, specified as one of the following.

Value	Description
`"same"`	The output image is the same size as the input image. If the value of `packopt` is `"ispacked"`, then `shape` must be `"same"`.
`"full"`	Compute the full dilation.

Data Types: char | string

Output Arguments

collapse all

`J` — Dilated image
grayscale image | binary image | packed binary image

Dilated image, returned as a grayscale image, binary image, or packed binary image. If the input image I is packed binary, then J is also packed binary. J has the same data type as I.

More About

collapse all

Binary Dilation

The binary dilation of A by B, denoted A ⨁ B, is defined as the set operation:

$A \oplus B = {z | {(\hat{B})}_{z} \cap A \neq \emptyset},$

where $\hat{B}$ is the reflection of the structuring element B. In other words, it is the set of pixel locations z, where the reflected structuring element overlaps with foreground pixels in A when translated to z. Note that some applications use a definition of dilation in which the structuring element is not reflected.

For more information about binary dilation, see [1].

Grayscale Dilation

In the general form of grayscale dilation, the structuring element has a height. The grayscale dilation of A(x, y) by B(x, y) is defined as:

$(A \oplus B) (x, y) = \max {A (x - x^{'}, y - y^{'}) + B (x^{'}, y^{'}) | (x^{'}, y^{'}) \in D_{B}},$

where D_B is the domain of the structuring element B and A(x, y) is assumed to be –∞ outside the domain of the image. Note that some applications define grayscale dilation using an equation with A(x + x′, y + y′) instead of A(x – x′, y – y′).

To create a structuring element with nonzero height values, use the syntax strel(nhood,height), where height gives the height values and nhood corresponds to the structuring element domain, D_B.

Most commonly, grayscale dilation is performed with a flat structuring element (B(x,y) = 0). Grayscale dilation using such a structuring element is equivalent to a local-maximum operator:

$(A \oplus B) (x, y) = \max {A (x - x^{'}, y - y^{'}) | (x^{'}, y^{'}) \in D_{B}} .$

All of the strel syntaxes except for strel(nhood,height), strel("arbitrary",nhood,height), and strel("ball",___) produce flat structuring elements.

Tips

If the dimensionality of the image I is greater than the dimensionality of the structuring element, then the imdilate function applies the same morphological dilation to all planes along the higher dimensions.
You can use this behavior to perform morphological dilation on RGB images. Specify a 2-D structuring element for RGB images to operate on each color channel separately.
When you specify a structuring element neighborhood, imdilate determines the center element of nhood by floor((size(nhood)+1)/2).
imdilate automatically takes advantage of the decomposition of a structuring element object (if it exists). Also, when performing binary dilation with a structuring element object that has a decomposition, imdilate automatically uses binary image packing to speed up the dilation [3].

References

[1] Gonzalez, Rafael C., Richard E. Woods, and Steven L. Eddins. Digital Image Processing Using MATLAB. Third edition. Knoxville: Gatesmark Publishing, 2020.

[2] Haralick, Robert M., and Linda G. Shapiro. Computer and Robot Vision. 1st ed. USA: Addison-Wesley Longman Publishing Co., Inc., 1992, pp. 158-205.

[3] Boomgaard, Rein van den, and Richard van Balen. “Methods for Fast Morphological Image Transforms Using Bitmapped Binary Images.” CVGIP: Graphical Models and Image Processing 54, no. 3 (May 1, 1992): 252–58. https://doi.org/10.1016/1049-9652(92)90055-3.

Extended Capabilities

expand all

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

imdilate supports the generation of C code (requires MATLAB^® Coder™). Note that if you choose the generic MATLAB Host Computer target platform, imdilate generates code that uses a precompiled, platform-specific shared library. Use of a shared library preserves performance optimizations but limits the target platforms for which code can be generated. For more information, see Types of Code Generation Support in Image Processing Toolbox.
The input image I must be 2-D or 3-D.
The structuring element SE must be a single element—arrays of structuring elements are not supported. To obtain the same result as that obtained using an array of structuring elements, call the function sequentially.
When the target is MATLAB Host Computer, the packopt and shape arguments must be compile-time constants. When the target is any other platform, the packopt syntax is not supported.
To generate optimized C code, all input arguments except the input image I must be compile-time constants.

GPU Code Generation
Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Usage notes and limitations:

The input image I must be 2-D or 3-D.
Packed binary input images (packopt syntax) are not supported.
For 3-D input images with more than three channels, only C/C++ code is generated.
The structuring element SE must be a compile-time constant. CUDA^® code is generated only for 1-D or 2-D structuring elements. If the structuring element is 3-D, C/C++ code is generated. Code generation is not supported for structuring elements with more than three dimensions.
For non-flat structuring elements, only C/C++ code is generated.
To generate optimized CUDA code, all input arguments except the input image I must be compile-time constants.

Thread-Based Environment
Run code in the background using MATLAB® `backgroundPool` or accelerate code with Parallel Computing Toolbox™ `ThreadPool`.

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Usage notes and limitations:

gpuArray input must be of type uint8 or logical.
The structuring element SE must be flat and 2-D.
The packopt argument is not supported on the GPU.

For more information, see Image Processing on a GPU.

Version History

Introduced before R2006a

expand all

R2022b: Support for thread-based environments

imdilate now supports thread-based environments.

imdilate

Syntax

Description

Examples

Dilate Image with Vertical Line Structuring Element

Dilate Grayscale Image with Rolling Ball

Dilate Points in 3-D Space Using Spherical Structuring Elements

Input Arguments

`I` — Input image
grayscale image | binary image | packed binary image

`SE` — Structuring element
`strel` object | `offsetstrel` object | array of `strel` objects | array of `offsetstrel` objects

`nhood` — Structuring element neighborhood
matrix of `0`s and `1`s

`packopt` — Indicator of packed binary image
`"notpacked"` (default) | `"packed"`

`shape` — Size of output image
`"same"` (default) | `"full"`

Output Arguments

`J` — Dilated image
grayscale image | binary image | packed binary image

More About

Binary Dilation

Grayscale Dilation

Tips

References

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

GPU Code Generation
Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Thread-Based Environment
Run code in the background using MATLAB® `backgroundPool` or accelerate code with Parallel Computing Toolbox™ `ThreadPool`.

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Version History

R2022b: Support for thread-based environments

See Also

Topics

imdilate

Syntax

Description

Examples

Dilate Image with Vertical Line Structuring Element

Dilate Grayscale Image with Rolling Ball

Dilate Points in 3-D Space Using Spherical Structuring Elements

Input Arguments

I — Input image grayscale image | binary image | packed binary image

SE — Structuring element strel object | offsetstrel object | array of strel objects | array of offsetstrel objects

nhood — Structuring element neighborhood matrix of 0s and 1s

packopt — Indicator of packed binary image "notpacked" (default) | "packed"

shape — Size of output image "same" (default) | "full"

Output Arguments

J — Dilated image grayscale image | binary image | packed binary image

More About

Binary Dilation

Grayscale Dilation

Tips

References

Extended Capabilities

C/C++ Code Generation Generate C and C++ code using MATLAB® Coder™.

GPU Code Generation Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Thread-Based Environment Run code in the background using MATLAB® backgroundPool or accelerate code with Parallel Computing Toolbox™ ThreadPool.

GPU Arrays Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Version History

R2022b: Support for thread-based environments

See Also

Topics

`I` — Input image
grayscale image | binary image | packed binary image

`SE` — Structuring element
`strel` object | `offsetstrel` object | array of `strel` objects | array of `offsetstrel` objects

`nhood` — Structuring element neighborhood
matrix of `0`s and `1`s

`packopt` — Indicator of packed binary image
`"notpacked"` (default) | `"packed"`

`shape` — Size of output image
`"same"` (default) | `"full"`

`J` — Dilated image
grayscale image | binary image | packed binary image

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

GPU Code Generation
Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Thread-Based Environment
Run code in the background using MATLAB® `backgroundPool` or accelerate code with Parallel Computing Toolbox™ `ThreadPool`.

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.