This laboratory was originally developed using the following hardware and software:

Open the “stills_R_W.mdl” Simulink model (generated in the "A Framework for Image Processing with the DSK6416" module).

Add to it the blocks shown in the following table:

You are now ready to set your block parameters.

Use the Image From Workspace block to import your image from the MATLAB workspace.

Set the block parameters as follows:

Use the Edge Detection block to find the edges in the intensity image. This process improves the efficiency of the Hough Lines block as it reduces the image area over which the block searches for lines. The block also converts the image to a binary image, which is the required input for the Hough Transform block. Use the default parameters.

Use the Video Viewer block to display the edges found by the Edge Detection block. Set the Input image type parameter to Intensity.

Use the Hough Transform block to compute the Hough matrix by transforming the input image into the rho-theta parameter space. The block also outputs the rho and theta values associated with the Hough matrix. Set the block parameters as follows:

Figure 2

Use the Find Local Maxima block to find the location of the maximum value in the Hough matrix. Set the block parameters as follows:

Figure 3

Use the Selector blocks to separate the indices of the rho and theta values, which are output at the Idx port, that are associated with the maximum value in the Hough matrix. Set the Selector block parameters as follows:

Set the Selector1 block parameters as follows:

Use the Variable Selector blocks to index into the rho and theta vectors and determine the rho and theta values that correspond to the longest line in the original image. Set the parameters of the Variable Selector blocks as follows:

Use the Hough Lines block to determine where the longest line intersects the edges of the original image. You use these coordinates to superimpose a white line on the original image. Use the default parameters.

Use the Draw Shapes block to draw a white line over the longest line on the original image. Set the block parameters as follows:

Use the Video Viewer block to display the original image with a white line superimposed over the longest line in the image. Set the Input image type parameter to Intensity.

Connect the blocks as shown in the figure below. Use the file circuit.tif as input.

Figure 4

Figure 5

Figure 6

Your model should resemble the following figure:

Figure 7

Double-click the "Hough Algorithm", and you should see:

Figure 8

Create a Subsystem for the “Line Drawing and Image Construction”. Select the blocks as shown in the following picture:

Figure 9

In the main menu, click on Edit/Create Subsystem (you may also enter Ctrl+G),

Your model should resemble the following figure:

Figure 10

Double-click the " Line Drawing and Image Construction ", and you should see:

Figure 11

Create a Subsystem for the “Line Detection”. Select the blocks as shown in the following picture:

Figure 12

The model should look as follows:

Figure 13

Save the file as "LineDetection.mdl"

Set the configuration parameters. Open the Configuration dialog box by selecting Configuration Parameters from the Simulation menu. Set the parameters as follows:

Run your model.

The Video Viewer window displays the edges found in the original image in white and the background in black. To view the image at its true size, right-click the window and select Set Display To True Size.

Running this gives you the images in Figure 1.

Figure 14: Line Detection

The Video Viewer1 window displays the original image with a white line drawn over the longest line in the image.

You may repeat the simulation here to experiment the various algorithms with different thresholds.

Open the “stills_R_W.mdl” Simulink model (generated in the "A Framework for Image Processing with the DSK6416" module).

Copy the "Line Detection" block from "LineDetection.mdl".

Connect the various blocks as shown in . Save the model (LineDetectionPictureDSK6416.mdl).

Figure 15: The Edge Detection Real Time Implementation Model for Stills Images

Build the project. Double-click the “Build Project” block.

Load the project. Double-click the “Load Project” block.

Run the target. Double-click the “Run” block.

Plotting the input and output in MATLAB, you will see :

Figure 16: Edge Detection using the DSK6416

Open the “video_sim.mdl” Simulink model (generated in the "A Framework for Video Processing with the DM6437 DVDP" module). Copy the “line Detection” block in this model into the “video_sim.mdl”, and connect it to the I/O blocks as follows:

Figure 18

Double-Click the “Line Detection” block. In the open window, add the “Submatrix block from the Signal Processing Toolbox (EIhter from the “Math Functions / Matrices and Linear Algebra / Matrix Operations” group or from the “Signal Management / Indexing” group. Connect it between the input node and the “Edge Detection Block” as follows:

Figure 19

Configure the “Submatrix” block as follows:

Figure 20

This will define the Region of Interest (ROI). Rename the block to “Define ROI”

Select the “Edge Detection Block”, and create a Subsystem for the “Enhanced Detection”, as shown in the following picture:

Figure 21

The model should look as follows:

Figure 22

Double Click the “Enhanced Edge Detection” block. Rename the Input port to “ROI”, and the output port to “Binary Image”

Figure 23

Add to it the blocks shown in the following table:

Place the blocks so that your model resembles the following figure. Create the “Calculated threshold based on histogram” with the selected blocks.

Figure 24

The model should look as shown in the following picture. Create the “Histogram based binary thresholding” with the selected blocks.

Figure 25

Double-click the “Hough Algorithm” block in the model. You should change it to select the two longest lines.

Figure 26

Figure 27

Add an “Embedded MATLAB function” block (from the “Simulink/User-Defined Functions” group). Double-Click the block and enter the following MATLAB function:

function [Thetas, Rhos] = fcn( thetas,rhos)
% This block supports an embeddable subset of the MATLAB language.
% See the help menu for details.

%initialise a frame count
persistent count;
if isempty(count)
   count = 0;
end

%remember previous outputs
persistent lastRhos;
persistent lastThetas;

%initialise to same as first input for first entry into function
if isempty(lastRhos)
    lastRhos = rhos;
end
if isempty(lastThetas)
    lastThetas = thetas;
end

%Assume that all is OK initially
Rhos = rhos;
Thetas = thetas;

if count == 4
   %after the 4th frame, engage the test logic 
   for I = 1:length(rhos)
         if (abs(rhos(I) - lastRhos(I)) > 30) || (abs(thetas(I) - lastThetas(I)) > 10*(pi/180))
   %too much change - just use the old values
   % outR(I) = lastRhos(I);
   % outT(I) = lastThetas(I);
       Rhos(I) = lastRhos(I); 
       Thetas(I) = lastThetas(I);
      end
     end

else
   %otherwise just output the computed values
    count = count+1;
   end

%assign outputs
  %Rhos = outR;
  %Thetas = outT;

%remember outputs for next time
lastRhos = Rhos;
lastThetas = Thetas;

Connect the block as shown in the following picture:

Figure 28

In the main model, double-click the “Line Drawing and Image Construction” block.

Change the configuration of the “Draw Lines” block as follows:

Figure 29

Now, it will draw the polygon based on the two longest lines.

Add the following blocks to the subsystem:

Connect the blocks as follows:

Figure 30

Figure 31

Figure 32

Figure 34

Figure 35

Figure 36

Rename the “Line Detection” to “Lane Detection”. Save the model as “LaneDetection.mdl” The model should look as follows:

Figure 37

Double Click the Lane Detection block. You may rename the blocks’ names. It will look as follows:

Figure 38

Run your model.

Running this gives you the images in Figure 7.

Figure 39: Edge Detection on a Video Stream

Build load and run the project from the "lane_dm6437l_tcpip.mdl" model. Double-click the "Build / Reload & Run" block.

Running the script, you will see:

Figure 53: Real-Time Edge Detection through a TCP/IP Interface