Main Content

visionhdl.Opening

Morphological opening of binary pixel data

Description

visionhdl.Opening performs morphological erosion, followed by morphological dilation, using the same neighborhood for both calculations. The object operates on a stream of binary intensity values.

This object uses a streaming pixel interface with a structure for frame control signals. This interface enables the object to operate independently of image size and format, and to connect with other Vision HDL Toolbox™ objects. The object accepts and returns a scalar pixel value and control signals as a structure containing five signals. The control signals indicate the validity of each pixel and its location in the frame. To convert a pixel matrix into a pixel stream and control signals, use the visionhdl.FrameToPixels object. For a full description of the interface, see Streaming Pixel Interface.

Note

Starting in R2016b, instead of using the step method to perform the operation defined by the System object™, you can call the object with arguments, as if it were a function. For example, y = step(obj,x) and y = obj(x) perform equivalent operations.

Construction

O = visionhdl.Opening returns a System object, O, that performs morphological opening on a binary pixel stream.

O = visionhdl.Opening(Name,Value) returns a System object, O, with additional options specified by one or more Name,Value pair arguments. Name is a property name and Value is the corresponding value. Name must appear inside single quotes (''). You can specify several name-value pair arguments in any order as Name1,Value1,...,NameN,ValueN. Properties not specified retain their default values.

Properties

Neighborhood

Pixel neighborhood, specified as a vector or matrix of 1s and 0s.

The object supports neighborhoods of up to 32×32 pixels. To use a structuring element, specify Neighborhood as getnhood (Image Processing Toolbox)(strel (Image Processing Toolbox)(shape)).

When you use multipixel vector input, the neighbourhood must be at least two pixels in each dimension.

Default: ones(3,3)

LineBufferSize

Specify a power of two that accommodates the number of active pixels in a single horizontal line.

Choose a power of two that accommodates the number of active pixels in a horizontal line. If you specify a value that is not a power of two, the object uses the next largest power of two. The object allocates (neighborhood lines – 1)-by-LineBufferSize memory locations to store the pixels.

Default: 2048

PaddingMethod

Select one of these methods for padding the boundary of the input image. For more information about these methods, see Edge Padding.

  • 'Constant' — The object pads the image with ones for the erosion operation and with zeros for the dilation operation. These values prevent opening at the boundaries of the active frame.

  • 'None' — Exclude padding logic. The object does not set the pixels outside the image frame to any particular value. This option reduces the hardware resources used by the object and the blanking required between frames but affects the accuracy of the output pixels at the edges of the frame. To maintain pixel stream timing, the output frame is the same size as the input frame. However, to avoid using pixels calculated from undefined padding values, mask off the KernelSize/2 pixels around the edge of the frame for downstream operations. For details, see Increase Throughput with Padding None.

Default: 'Constant'

Methods

stepReport opened pixel value based on neighborhood
Common to All System Objects
release

Allow System object property value changes

Examples

collapse all

Perform morphological open on a thumbnail image.

Load a source image from a file. Select a portion of the image that matches the desired test size. This source image contains uint8 pixel intensity values. Apply a threshold to convert to binary pixel data.

frmOrig = imread('rice.png');
frmActivePixels = 64;
frmActiveLines = 48;
frmInput = frmOrig(1:frmActiveLines,1:frmActivePixels);
frmInput = frmInput>128;
figure
imshow(frmInput,'InitialMagnification',300)
title 'Input Image'

Create a serializer object and define inactive pixel regions. Make the number of inactive pixels following each active line at least double the horizontal size of the neighborhood. Make the number of lines following each frame at least double the vertical size of the neighborhood.

frm2pix = visionhdl.FrameToPixels(...
      'NumComponents',1,...
      'VideoFormat','custom',...
      'ActivePixelsPerLine',frmActivePixels,...
      'ActiveVideoLines',frmActiveLines,...
      'TotalPixelsPerLine',frmActivePixels+20,...
      'TotalVideoLines',frmActiveLines+10,...
      'StartingActiveLine',3,...     
      'FrontPorch',10);

Create a filter object.

 mopen = visionhdl.Opening( ...
          'Neighborhood',ones(5,5));

Serialize the test image by calling the serializer object. pixIn is a vector of intensity values. ctrlIn is a vector of control signal structures.

Note: This object syntax runs only in R2016b or later. If you are using an earlier release, replace each call of an object with the equivalent step syntax. For example, replace myObject(x) with step(myObject,x).

[pixIn,ctrlIn] = frm2pix(frmInput);

Prepare to process pixels by preallocating output vectors.

[~,~,numPixelsPerFrame] = getparamfromfrm2pix(frm2pix);
pixOut = false(numPixelsPerFrame,1);
ctrlOut  = repmat(pixelcontrolstruct,numPixelsPerFrame,1);

For each pixel in the padded frame, compute the morphed value. Monitor the control signals to determine latency of the object. The latency of a configuration depends on the number of active pixels in a line and the size of the neighborhood

foundValIn = false;
foundValOut = false;
for p = 1:numPixelsPerFrame  
    if (ctrlIn(p).valid && foundValIn==0)
        foundValIn = p;
    end
    [pixOut(p),ctrlOut(p)] = mopen(pixIn(p),ctrlIn(p));
    if (ctrlOut(p).valid && foundValOut==0)
        foundValOut = p;
    end
end
sprintf('object latency is %d cycles',foundValOut-foundValIn)
ans = 
'object latency is 368 cycles'

Create a deserializer object with a format matching that of the serializer. Convert the pixel stream to an image frame by calling the deserializer object. Display the resulting image.

pix2frm = visionhdl.PixelsToFrame(...
      'NumComponents',1,...
      'VideoFormat','custom',...
      'ActivePixelsPerLine',frmActivePixels,...
      'ActiveVideoLines',frmActiveLines);
[frmOutput,frmValid] = pix2frm(pixOut,ctrlOut);
if frmValid
    figure
    imshow(frmOutput, 'InitialMagnification',300)
    title 'Output Image'
end

Algorithms

This object implements the algorithms described on the Opening block reference page.

Introduced in R2015a