Dilate image
IM2 = imdilate(IM,SE)
IM2 = imdilate(IM,NHOOD)
IM2 = imdilate(___,PACKOPT)
IM2 = imdilate(___,SHAPE)
gpuarrayIM2 = imdilate(gpuarrayIM,___)
IM2 = imdilate(IM,SE)
dilates the grayscale,
binary, or packed binary image IM
, returning the
dilated image, IM2
. The argument SE
is
a structuring element object, or array of structuring element objects,
returned by the strel
function.
If IM
is logical and the structuring element
is flat, imdilate
performs binary dilation; otherwise,
it performs grayscale dilation. If SE
is an array
of structuring element objects, imdilate
performs
multiple dilations of the input image, using each structuring element
in succession.
This function supports code generation (see Tips).
IM2 = imdilate(IM,NHOOD)
dilates the image IM
,
where NHOOD
is a matrix of 0's and 1's that specifies
the structuring element neighborhood. This is equivalent to the syntax imdilate(IM,strel(NHOOD))
.
The imdilate
function determines the center element
of the neighborhood by floor((size(NHOOD)+1)/2)
.
IM2 = imdilate(___,PACKOPT)
specifies
whether IM
is a packed binary image. PACKOPT
can
have either of the following values. Default value is enclosed in
braces ({}
).
Value  Description 





IM2 = imdilate(___,SHAPE)
specifies
the size of the output image. SHAPE
can have either
of the following values. Default value is enclosed in braces ({}
).
Value  Description 

 Make the output image the same size as the input image.
If the value of 
 Compute the full dilation. 
gpuarrayIM2 = imdilate(gpuarrayIM,___)
performs
the operation on a graphics processing unit (GPU), where gpuarrayIM
is
a gpuArray
that contains a grayscale or binary
image. gpuarrayIM2
is a gpuArray
of
the same class as the input image. Note that the PACKOPT
syntax
is not supported on a GPU. This syntax requires the Parallel Computing Toolbox™.
IM
can be logical or numeric and must be
real and nonsparse. It can have any dimension. If IM
is
logical, SE
must be flat. The output has the same
class as the input. If the input is packed binary, then the output
is also packed binary.
gpuarrayIM
must be a gpuArray
of
type uint8
or logical
. When
used with a gpuarray
, the structuring element must
be flat and twodimensional. The output has the same class as the
input.
The binary dilation of A by B, denoted $$A\oplus B$$, is defined as the set operation:
$$A\oplus B=\left\{z{\left(\widehat{B}\right)}_{z}\cap A\ne \varnothing \right\},$$
where $$\widehat{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 people use a definition of dilation in which the structuring element is not reflected.
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:
$$\left(A\oplus B\right)\left(x,y\right)=\mathrm{max}\left\{A(x{x}^{\prime},y{y}^{\prime})+B({x}^{\prime},{y}^{\prime})\left({x}^{\prime},{y}^{\prime}\right)\in {D}_{B}\right\},$$
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. 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 localmaximum operator:
$$\left(A\oplus B\right)\left(x,y\right)=\mathrm{max}\{A(x{x}^{\prime},y{y}^{\prime})({x}^{\prime},{y}^{\prime})\in {D}_{B}\}.$$
All of the strel
syntaxes except
for strel(nhood,height)
, strel('arbitrary',nhood,height)
,
and strel('ball', ...)
produce flat structuring
elements.
For more information about binary dilation, see [1].
[1] Gonzalez, R. C., R. E. Woods, and S. L. Eddins, Digital Image Processing Using MATLAB, Gatesmark Publishing, 2009.
[2] Haralick, R. M., and L. G. Shapiro, Computer and Robot Vision, Vol. I, AddisonWesley, 1992, pp. 158205.
[3] van den Boomgard, R, and R. van Balen, "Methods for Fast Morphological Image Transforms Using Bitmapped Images," Computer Vision, Graphics, and Image Processing: Graphical Models and Image Processing, Vol. 54, Number 3, pp. 254258, May 1992.