MATLAB – Detección de bordes de imágenes usando Sobel Operator desde cero

Operador de Sobel: Es un operador basado en gradiente de diferenciación discreta. 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 Sobel 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 las aproximaciones derivadas vertical y horizontal respectivamente:

$M_{x}=\left[\begin{array}{ccc}-1 & 0 & 1 \\ -2 & 0 & 2 \\ -1 & 0 & 1\end{array}\right] \quad M_{y}=\left[\begin{array}{ccc}-1 & -2 & -1 \\ 0 & 0 & 0 \\ 1 & 2 & 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 de Sobel
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 | Sobel 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));
  
% Sobel Operator Mask
Mx = [-1 0 1; -2 0 2; -1 0 1];
My = [-1 -2 -1; 0 0 0; 1 2 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:

Cálculo simple y eficiente en el tiempo
Muy fácil en la búsqueda de bordes suaves

Limitaciones:

Los puntos de dirección diagonal no se conservan siempre
Sensible al ruido
No es muy preciso en la detección de bordes.
Detectar con bordes gruesos y ásperos no da resultados apropiados

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