MATLAB – Detección de bordes de imagen utilizando el operador Prewitt desde cero

Operador de Prewitt: Es un operador basado en gradientes. Es una de las mejores formas de detectar la orientación y la magnitud de una imagen. Calcula la aproximación de gradiente de la función de intensidad de imagen para la detección de bordes de imagen. En los píxeles de una imagen, el operador de Prewitt produce la normal a un vector o el vector de gradiente correspondiente. Utiliza dos núcleos o máscaras de 3 x 3 que se convolucionan con la imagen de entrada para calcular aproximaciones de las derivadas, una para cambios horizontales y otra para cambios verticales.

$M_{x}=\left[\begin{array}{ccc}-1 & 0 & 1 \\ -1 & 0 & 1 \\ -1 & 0 & 1\end{array}\right] \quad M_{y}=\left[\begin{array}{ccc}-1 & -1 & -1 \\ 0 & 0 & 0 \\ 1 & 1 & 1\end{array}\right]$

Acercarse:

Paso 1: Ingresar: leer una imagen
Paso 2: Convertir la imagen RGB de color verdadero en una imagen en escala de grises
Paso 3: Convertir la imagen a doble
Paso 4: Preasignar la array de imagen_filtrada con ceros
Paso 5: Definir la máscara de operador Prewitt
Paso 6 : Proceso de detección de bordes (Calcule la aproximación del gradiente y la magnitud del vector)
Paso 7: Muestre la imagen filtrada
Paso 8: Umbral en la imagen filtrada
Paso 9: Muestre la imagen detectada por el borde

Implementación en MATLAB:

% MATLAB Code | Prewitt Operator from Scratch
  
% Read Input Image
input_image = imread('[name of input image file].[file format]');
  
% Displaying Input Image
input_image = uint8(input_image);
figure, imshow(input_image); title('Input Image');
  
% Convert the truecolor RGB image to the grayscale image
input_image = rgb2gray(input_image);
  
% Convert the image to double
input_image = double(input_image);
  
% Pre-allocate the filtered_image matrix with zeros
filtered_image = zeros(size(input_image));
  
% Prewitt Operator Mask
Mx = [-1 0 1; -1 0 1; -1 0 1];
My = [-1 -1 -1; 0 0 0; 1 1 1];
  
% Edge Detection Process
% When i = 1 and j = 1, then filtered_image pixel  
% position will be filtered_image(2, 2)
% The mask is of 3x3, so we need to traverse 
% to filtered_image(size(input_image, 1) - 2
%, size(input_image, 2) - 2)
% Thus we are not considering the borders.
for i = 1:size(input_image, 1) - 2
    for j = 1:size(input_image, 2) - 2
  
        % Gradient approximations
        Gx = sum(sum(Mx.*input_image(i:i+2, j:j+2)));
        Gy = sum(sum(My.*input_image(i:i+2, j:j+2)));
                 
        % Calculate magnitude of vector
        filtered_image(i+1, j+1) = sqrt(Gx.^2 + Gy.^2);
         
    end
end
  
% Displaying Filtered Image
filtered_image = uint8(filtered_image);
figure, imshow(filtered_image); title('Filtered Image');
  
% Define a threshold value
thresholdValue = 100; % varies between [0 255]
output_image = max(filtered_image, thresholdValue);
output_image(output_image == round(thresholdValue)) = 0;
  
% Displaying Output Image
output_image = im2bw(output_image);
figure, imshow(output_image); title('Edge Detected Image');

Imagen de entrada –

Imagen filtrada:

Imagen de borde detectado:

ventajas:

Buen rendimiento en la detección de bordes verticales y horizontales.
Mejor operador para detectar la orientación de una imagen

Limitaciones:

La magnitud del coeficiente es fija y no se puede cambiar.
Los puntos de dirección diagonal no se conservan siempre

Publicación traducida automáticamente

Artículo escrito por goodday451999 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta