Scribd
Upload
26 views5 pages

Gtkwave

The document contains MATLAB code for performing edge detection on an image using a convolution-based approach with a defined kernel. It includes steps for loading an image, converting it to grayscale, applying Sobel filters, and performing non-maximum suppression to detect edges. Additionally, it provides commands for compiling and running Verilog code related to the image processing simulation and converting output formats for visualization.

Uploaded by

Vakula
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
26 views5 pages

Gtkwave

The document contains MATLAB code for performing edge detection on an image using a convolution-based approach with a defined kernel. It includes steps for loading an image, converting it to grayscale, applying Sobel filters, and performing non-maximum suppression to detect edges. Additionally, it provides commands for compiling and running Verilog code related to the image processing simulation and converting output formats for visualization.

Uploaded by

Vakula
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

Matlab code:

% Define the image kernel


kernel = [1/9 1/9 1/9
1/9 1/9 1/9
1/9 1/9 1/9];

% Load the input image


inputImage = imread('0006.jpg');

% Convert the input image to grayscale if necessary


if size(inputImage, 3) == 3
inputImage = rgb2gray(inputImage);
end

% Normalize the input image to the range [0, 1]


inputImage = double(inputImage) / 255;

% Get the size of the input image


[height, width] = size(~inputImage);

% Initialize the output image


outputImage = zeros(height, width);

% Perform image convolution using reversible logic gates


for i = 2:height-1
for j = 2:width-1
% Compute the convolution for the current pixel
pixelConv = ~kernel(1,1)*inputImage(i-1, j-1) +
kernel(1,2)*inputImage(i-1, j) + kernel(1,3)*inputImage(i-1, j+1) ...
+ kernel(2,1)*inputImage(i, j-1) + kernel(2,2)*inputImage(i, j)
+ kernel(2,3)*inputImage(i, j+1) ...
+ kernel(3,1)*inputImage(i+1, j-1) +
kernel(3,2)*inputImage(i+1, j) + kernel(3,3)*inputImage(i+1, j+1);

% Store the result in the output image


outputImage(i, j) = pixelConv;
end
end

% Normalize the output image to the range [0, 1]


outputImage = (outputImage - min(outputImage(:))) / (max(outputImage(:)) -
min(outputImage(:)));

% Convert the output image to uint8 format


outputImage = uint8(outputImage * 255);

cannyX = [-1 0 1; -2 0 2; -1 0 1];


cannyY = [-1 -2 -1; 0 0 0; 1 2 1];

cannyX = -1 * cannyX;
cannyY = -1 * cannyY;
% cannyX_reversible = - cannyX;
% cannyY_reversible = - cannyY;

% Convolve the image with the Sobel filter kernels


gradientX = conv2(outputImage, cannyX, 'same');
gradientY = conv2(outputImage, cannyY, 'same');
% Calculate the magnitude and angle of the gradients
gradientMagnitude = sqrt(gradientX.^2 + gradientY.^2);
gradientAngle = atan2d(gradientY, gradientX);

threshold = 100;
edges = gradientMagnitude > threshold;

neighborhoodSize = 3;

nonMaxEdges = nonMaximumSuppression(edges, neighborhoodSize);

imshow(edges);
title('Detected Edges');

% Function for non-maximum suppression


function output = nonMaximumSuppression(input, neighborhoodSize)
[rows, cols] = size(input);
output = zeros(rows, cols);

halfSize = floor(neighborhoodSize / 2);

for i = halfSize+1 : rows-halfSize


for j = halfSize+1 : cols-halfSize
value = input(i, j);
direction = atan2(input(i, j+1) - input(i, j-1), input(i+1, j)
- input(i-1, j));

direction = mod(direction, pi);


if direction < 0
direction = direction + pi;
end

if (direction >= 0 && direction < pi/8) || (direction >= 7*pi/8


&& direction <= pi)
neighbor1 = input(i, j+1);
neighbor2 = input(i, j-1);
elseif direction >= pi/8 && direction < 3*pi/8
neighbor1 = input(i+1, j+1);
neighbor2 = input(i-1, j-1);
elseif direction >= 3*pi/8 && direction < 5*pi/8
neighbor1 = input(i+1, j);
neighbor2 = input(i-1, j);
elseif direction >= 5*pi/8 && direction < 7*pi/8
neighbor1 = input(i+1, j-1);
neighbor2 = input(i-1, j+1);
end

% Perform non-maximum suppression


if value >= neighbor1 && value >= neighbor2
output(i, j) = value;
end
end
end
end
Verilog compile code:

% Compile Verilog code


system('iverilog -o simulation reversible_canny_edge.v');

% Run the simulation


system('vvp simulation');

% Convert VCD to FST format


system('gtkwave --vcd waveform.vcd --fst waveform.fst');

Input image

Files for Verilog:

GTK wave output


Gtkwave command window:
Output image

You might also like