procesamiento opencv-edge

Por que utilizar el procesamiento de bordes

• Si el núcleo es de 3 x 3, no se puede escanear un círculo de píxeles alrededor de la imagen.
• Si el kernel es (2 k + 1) x (2 k + 1), entonces los k píxeles del círculo alrededor de la imagen no se pueden escanear.

Como se muestra en la figura siguiente

, el área más grande que puede ser escaneada por el kernel de 5 x 5 es el área delimitada por el cuadro rojo No
hay forma de escanear los 2 píxeles alrededor de la imagen.

Entonces tenemos que lidiar con el borde de 2 píxeles alrededor de la imagen.
En algunos algoritmos, se agregan 2 píxeles alrededor de la imagen original y luego se eliminan después de la convolución.

Procesamiento de bordes predeterminado

Cómo lidiar con el límite en opencv

Agregue píxeles de borde antes del inicio de la convolución. El valor de píxel relleno es 0 o negro RGB. Por ejemplo, 3x3 rellena los bordes de 1 píxel en cada lado para garantizar que los bordes de la imagen se procesen y luego elimine estos bordes el proceso de convolución.

El método de procesamiento predeterminado en openCV es: BORDER_DEFAULT, además de los siguientes comúnmente utilizados:

• BORDER_CONSTANT: rellena el borde con el valor de píxel especificado
• BORDER_REPLICATE -Rellena los píxeles de borde con valores de píxeles de borde conocidos.
• BORDER_WRAP : usa los píxeles del otro lado para compensar el relleno

Debido al problema de que el límite no se puede manejar debido a la operación de convolución, podemos usar el último parámetro de la API usado por el filtro lineal personalizado en la lección anterior, borderType. A través de este parámetro, podemos tener algunos métodos de procesamiento más utilizados, los tipos de límites más utilizados son los siguientes:

enum BorderTypes {
    
    
    BORDER_CONSTANT    = 0, //!< `iiiiii|abcdefgh|iiiiiii`  with some specified `i`
    BORDER_REPLICATE   = 1, //!< `aaaaaa|abcdefgh|hhhhhhh`
    BORDER_REFLECT     = 2, //!< `fedcba|abcdefgh|hgfedcb`
    BORDER_WRAP        = 3, //!< `cdefgh|abcdefgh|abcdefg`
    BORDER_REFLECT_101 = 4, //!< `gfedcb|abcdefgh|gfedcba`
    BORDER_TRANSPARENT = 5, //!< `uvwxyz|absdefgh|ijklmno`
 
    BORDER_REFLECT101  = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101
    BORDER_DEFAULT     = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101
    BORDER_ISOLATED    = 16 //!< do not look outside of ROI
};

Procesamiento de bordes personalizado

A través de la explicación anterior, sabemos por qué necesitamos realizar el procesamiento de bordes, y también hablamos sobre el método de procesamiento de bordes predeterminado, pero el método de procesamiento de bordes predeterminado solo puede resolver el problema de
que el borde de la imagen no se puede procesar debido a operaciones como la convolución. . Es decir, un parámetro separado no puede satisfacer nuestras necesidades. Por ejemplo, queremos manejar más posiciones del borde, no solo posiciones sin procesar. Si el método predeterminado no cumple con nuestros requisitos, necesitamos personalizar el borde método de procesamiento nosotros mismos.

API

Usamos la siguiente API

void copyMakeBorder( 
    InputArray src, 
    OutputArray dst, 
    int top, 
    int bottom, 
    int left, 
    int right,
    int borderType,
    const Scalar& value = Scalar()
);

• (1) src de tipo InputArray, imagen de entrada.

• (2) dst del tipo OutputArray, la imagen de salida, el tipo de imagen es el mismo que la imagen de entrada y el tamaño es: Tamaño (src.cols + left + right, src.rows + top + bottom).

• (3) Parte superior de tipo int,

• (4) parte inferior de tipo int,

• (5) Izquierda del tipo int,

• (6) Int type right, los cuatro parámetros anteriores son el tamaño del borde que se agregará a la imagen.

• (7) El borderType del tipo int, el tipo de borde. Consulte borderInterpolate.

• (8) Valor de tipo escalar, valor límite cuando borderType == BORDER_CONSTANT

Nota: este método modificará el tamaño de la imagen.

Visualización de código

#include<iostream>
#include<opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main()
{
    
    
	Mat src;
	Mat dst;

	src = imread("C:/Users/86176/Pictures/pics/lena(1).tiff");
	if (!src.data)
	{
    
    
		cout << "could not load image !";
		return -1;
	}

	
	namedWindow("input img", CV_WINDOW_AUTOSIZE);
	namedWindow("output img", CV_WINDOW_AUTOSIZE);
	imshow("input img", src);

	int top = (int)(0.05 * src.rows);
	int botton = (int)(0.05 * src.rows);
	int left = (int)(0.05 * src.cols);
	int right = (int)(0.05 * src.cols);
	RNG rng(12345);
	int borderType = BORDER_DEFAULT;

	int c = 0;
	while (1)
	{
    
    
		c = waitKey(500);

		if ((char)c == 27)
		{
    
    
			break;
		}
		if ((char)c == 'r')
		{
    
    
			borderType = BORDER_REPLICATE;
		}
		else if ((char)c == 'v')
		{
    
    
			borderType = BORDER_WRAP;
		}
		else if ((char)c == 'c')
		{
    
    
			borderType = BORDER_CONSTANT;
		}
		else 
		{
    
    
			borderType = BORDER_DEFAULT;
		}
		Scalar color = Scalar(0 ,0 ,255);
		copyMakeBorder(src, dst, top, botton, left, right, borderType, color);
		imshow("output img", dst);
	}

	waitKey(0);
	return 0;
}

efecto

BORDER_DEFAULT

Procesamiento automático de bordes en opencv

BORDER_REPLICATE

Rellenar con píxeles circundantes

BORDER_WRAP

Rellenar con píxeles en el otro lado

BORDER_CONSTANT

Rellenar con el color especificado

Conclusión

La función copyMakeBorder puede aumentar el borde de la imagen

El procesamiento de bordes es más importante en la aplicación de convolución de imágenes.
Experimente con filter2D, GussianBlur, etc.

		//filter2D(img, src, -1, kernel, Point(-1, -1),0,BORDER_DEFAULT); 
 
        //filter2D(img, src, -1, kernel, Point(-1, -1),0,BORDER_CONSTANT); 
 
        //filter2D(img, src, -1, kernel, Point(-1, -1),0,BORDER_REPLICATE); 
 
        //filter2D(img, src, -1, kernel, Point(-1, -1),0,BORDER_WRAP);