[Visión por computadora] Algunas operaciones básicas en el procesamiento de imágenes

Procesamiento de filtro de suavizado de imágenes

El suavizado de imagen significa que, debido a la influencia de factores como el sensor y la atmósfera, aparecerán ciertas áreas con cambios excesivos de brillo o algunos puntos brillantes (también llamados ruido) en las imágenes de detección remota. Este método de procesamiento que suaviza el brillo de la imagen para suprimir el ruido es el suavizado de imagen. El suavizado de imágenes es en realidad un filtrado de paso bajo y el proceso de suavizado hará que los bordes de la imagen se vean borrosos.

filtro medio

El filtrado lineal opera en toda la matriz de la imagen.

• Características: Cuanto mayor sea el tamaño de la ventana, mejor será el efecto de eliminación de ruido. Por supuesto, cuanto mayor será el tiempo de cálculo y más grave será la distorsión de la imagen. En el procesamiento real, se debe lograr un equilibrio entre los efectos de distorsión y eliminación de ruido, y se debe seleccionar un tamaño de ventana apropiado.
• [Ventajas] El algoritmo es simple, no requiere tecnología de procesamiento de imágenes compleja y no requiere mucho tiempo ni espacio. Y puede eliminar eficazmente el ruido y mejorar la calidad de la imagen.
• [Desventajas] El filtro medio en sí tiene fallas inherentes, es decir, no puede proteger bien los detalles de la imagen. También destruye los detalles de la imagen mientras elimina el ruido de la imagen, lo que hace que la imagen sea borrosa y no pueda eliminar bien los puntos de ruido.
• [Ámbito de aplicación] Ruido de sal y pimienta.
• [Rango inadecuado] Iluminación baja, imágenes con mucho ruido

proceso de cálculo

Para un tamaño de ventana determinado, los valores dentro de la ventana se promedian y el valor mediano se utiliza como valor central de la ventana . Por ejemplo, ingrese 3, lo que significa usar $3\times 3$ ventana para recalcular los valores de píxeles de la matriz de imagen dada. [Nota: Esos píxeles en el borde (no pueden convertirse en$3\times 3$ ), calcule algunos píxeles válidos]
Como se muestra en la figura siguiente, para el píxel 1 en la primera fila y la primera columna, todavía tomándolo como el centro, tome el valor medio del área naranja como su nuevo valor.

implementación de Python

import cv2
import numpy as np

x = np.array([[1, 3, 2, 4, 6, 5, 7]])
# 对图像进行均值滤波，指定核大小为5x5
result1 = cv2.blur(x, (3, 3))
print(result1)

filtro gaussiano

El filtrado lineal opera en toda la matriz de la imagen.

• 【Características】
  1. En el filtrado gaussiano, el ancho y el alto del núcleo pueden ser diferentes, pero ambos deben ser impares.
  2. Para el filtrado medio, el peso de cada píxel en su vecindad es igual. En el filtrado gaussiano, el valor de peso del punto central aumentará y el valor de peso del punto alejado del punto central disminuirá. Sobre esta base, se calcula la suma de los diferentes pesos de cada valor de píxel en la vecindad. .
  3. El núcleo gaussiano puede considerarse como un núcleo de convolución, que también es una matriz de filtro bidimensional, la diferencia es que el núcleo gaussiano se pondera sobre la base del núcleo de convolución ordinario (la matriz de peso se calcula mediante la función gaussiana ).
• [Ventajas] Mientras se elimina el ruido y la información detallada de la imagen, se conservan las características principales de la imagen (como los contornos y bordes de la imagen); el grado de desenfoque del filtro gaussiano se puede controlar ajustando el tamaño y la desviación estándar. del núcleo gaussiano.
• [Desventajas] La complejidad computacional es alta porque el filtro gaussiano requiere una operación de convolución.
• [Ámbito de aplicación] Eliminar el ruido gaussiano

proceso de cálculo

El filtrado gaussiano generalmente se implementa de dos maneras: una es la convolución de ventana deslizante de ventana discretizada; la segunda es mediante la transformada de Fourier. El siguiente es el filtrado gaussiano implementado mediante convolución de ventana deslizante de ventana discretizada .
Las plantillas gaussianas más utilizadas son las siguientes: Los parámetros anteriores se calculan mediante la función gaussiana; consulte algunos conocimientos sobre el filtrado gaussiano . La operación específica es: usar una plantilla (o convolución, máscara) para escanear cada píxel de la imagen y usar el valor de gris promedio ponderado
de los píxeles en el vecindario determinado por la plantilla para reemplazar el valor del píxel central de la plantilla. . Consulte el filtrado de Gauss para obtener más detalles.

implementación de Python

import numpy as np
import cv2

x = np.array([[1, 3, 2, 4, 6, 5, 7]])
# (3,3)为滤波器的大小；1.3为滤波器的标准差，如果标准差这个参数设置为0，则程序会根据滤波器大小自动计算得到标准差。
pic = cv2.GaussianBlur(x, (1, 3), 1.3, 1.3)
print(pic)

filtro mediano

Filtrado no lineal, dirigido a píxeles en la matriz de la imagen que se convierten en el punto medio de la ventana.

• [Ventajas] Es muy eficaz para suavizar el ruido impulsivo y, al mismo tiempo, puede proteger los bordes nítidos de la imagen y seleccionar puntos apropiados para reemplazar los valores de los puntos contaminados, por lo que el efecto de procesamiento es bueno.
• [Desventajas] Es fácil causar discontinuidad en la imagen; en comparación con el filtrado medio, es más lento procesar imágenes de gran tamaño debido a la operación de clasificación.
• [Ámbito de aplicación] Elimina el ruido aleatorio como el ruido de sal y pimienta, el ruido gaussiano aditivo, etc.
• [Rango inadecuado] No apto para ruido continuo.

proceso de cálculo

Para un tamaño de ventana determinado, ordene los valores dentro de la ventana y use el valor medio como valor central de la ventana . Por ejemplo, ingrese 3, lo que significa usar $3\times 3$ ventana para recalcular los valores de píxeles de la matriz de imagen dada. [Nota: los píxeles que participan en el filtrado son el punto central de la ventana y los píxeles en el borde (no pueden convertirse en$3\times El\; punto\; central\; de\; la\; ventana\; 3$ ) no se calculará. 】

La siguiente imagen muestra $6\times La\; matriz\; de\; 6$ imágenes se somete a filtrado mediano: el valor azul es la ventana deslizante y el valor rojo es el valor filtrado. Como se muestra en la figura, los píxeles del borde no participarán en el cálculo y el valor de píxel que realmente participa en el cálculo es el punto central de la ventana.

implementación de Python

import scipy.signal as ss
x = [1, 3, 2, 4, 6, 5, 7]
pic = ss.medfilt(x, 3)
print(pic)

Detección de bordes de imagen

El borde de la imagen generalmente se refiere a la posición donde la tasa de cambio de escala de grises de la imagen es mayor. Las principales razones son las siguientes:

1. El nivel de gris de la imagen cambia de forma discontinua en la dirección normal de la superficie;

2. La profundidad espacial de los objetos en la imagen es inconsistente;

3. Color inconsistente en superficies lisas;

4. Luces y sombras de objetos en la imagen.

La detección de bordes se refiere al proceso de detectar puntos de borde y segmentos de borde a partir de imágenes y describir la dirección del borde.

operador robert

El operador diferencial de primer orden es un método de cálculo de gradiente de desviación oblicua. El tamaño del gradiente representa la fuerza del borde y la dirección del gradiente es perpendicular (ortogonal) a la dirección del borde.

• [Ventajas] El cálculo es simple y el posicionamiento del borde es preciso.
• [Desventajas] Sensible al ruido
• [Ámbito de aplicación] Bueno para procesar imágenes con bordes pronunciados (bordes obvios) y poco ruido
• -[No aplicable] Imágenes con mucho ruido

proceso de cálculo

Ventana de gradiente del operador Robert en dirección x:
$${GRAMO}_{}=\left[\begin{array}{cc}1& 0\\ & -\end{array}\right]$$
Ventana de gradiente del operador Robert en la dirección y:
$${GRAMO}_{}=\left[\begin{array}{cc}0& 1\\ -& \end{array}\right]$$
Suma de gradiente de píxeles en la matriz de la imagen (puede ser el valor absoluto máximo o la raíz cuadrada de los dos):
$$GRAMO=|{GRAMO}_{}|+|{GRAMO}_{}|$$

Después de obtener las dos ventanas de degradado anteriores y sus métodos de suma, aplíquelas a la matriz de la imagen. Tenga en cuenta que la última fila y la última primera columna de la matriz de la imagen no participan en el cálculo y se establecen directamente en 0. Porque la idea de cálculo anterior es equivalente a calcular $(x_{\frac{}{2}},y_{\frac{}{2}})$ gradiente.

implementación de Python

import numpy as np

def Roberts(img_arr,r_x, r_y):
    w, h = img_arr.shape
    res = np.zeros((w, h))  # 取一个和原图一样大小的图片，并在里面填充0
    for x in range(w-2):
        for y in range(h-2):
            sub = img_arr[x:x + 2, y:y + 2]
            roberts_x = np.array(r_x)
            roberts_y = np.array(r_y)
            var_x =sum(sum(sub * roberts_x))#矩阵相乘，查看公式，我们要得到是一个值，所以对它进行两次相加
            var_y = sum(sum(sub * roberts_y))

            var = abs(var_x) + abs(var_y)

            res[x][y] = var#把var值放在x行y列位置上
    return res
pic_arr = np.array([[0, 0, 0, 0], [0, 10, 10, 0], [0, 10, 10, 0], [0, 0, 0, 0]])
r_x = [[1, 0], [0, -1]]
r_y = [[1, 1], [-1, 0]]
pic = Roberts(pic_arr, r_x, r_y)
print(pic)

Procesamiento de imágenes

Operador de corrosión

Calculado para cada píxel de la matriz de la imagen.

• Características: La corrosión de la imagen se compara con la parte resaltada y la imagen binaria correspondiente es con el área blanca. En términos generales, la corrosión consiste en encoger la parte blanca en la forma original, expandir la parte negra y corroer lo contrario de la operación de ampliación.
• 【Ámbito de aplicación】

  1. eliminar el ruido

  2. Dividir imágenes y unir imágenes

  3. Encuentre el máximo local y el mínimo local (operación de convolución matemática en la imagen)

  4. Encuentra el degradado de una imagen.

proceso de cálculo

Ingrese una matriz de imagen (matriz 0/1) y una matriz de plantilla (también llamada núcleo de convolución, valor 0/1). Utilice el píxel marcado como "centro" en la matriz de la plantilla como referencia para traducir píxel por píxel en la matriz de la imagen. Tome el "Y" de [píxeles con un valor de 1 en la matriz de la plantilla] y [píxeles de tamaños correspondientes en la matriz de la imagen] y asigne el valor mínimo del resultado al píxel actual. Solo se conservarán las partes con la misma forma de 1 en la matriz de imagen y la forma con un valor de 1 en la matriz de plantilla.
Por ejemplo, en la imagen siguiente: B es la matriz de la plantilla ("origen" en B significa el punto central), X es la matriz de la imagen y XB significa el resultado después de la corrosión. Este resultado puede considerarse como la operación "Y" de la parte negra en B y la parte negra en X.

implementación de Python

Función Hog ​​(histograma de orientación de degradado)

Proceso de cálculo:

1. Preprocesamiento de imagen: convierta la imagen a escala de grises y normalice los valores de píxeles. Si hay reflejos fuertes y otros brillos inestables en la imagen, se requiere normalización de la iluminación y otros procesamientos.

2. Calcule histogramas de gradiente y orientación: realice una operación de convolución en la imagen para obtener la magnitud y dirección del gradiente, y luego divida la imagen en varios bloques pequeños (por ejemplo, 8 × 8 8\ $8\times 8$ bloques pequeños), se cuentan las direcciones del gradiente en cada bloque pequeño y se obtiene el histograma de la dirección del gradiente en el bloque pequeño.

3. Normalización: normalice el histograma de dirección del gradiente dentro de cada bloque pequeño para evitar la influencia de factores como la iluminación y las sombras.

4. Empalme: empalme los histogramas normalizados de todos los bloques pequeños en un vector grande, llamado vector de características HOG.

Fórmula de cálculo de dimensiones de características de Hog

Ejemplo:
Dada la resolución $h\times W.=100\times Para\; una\; imagen\; de\; 100$ , se sabe que el tamaño de píxel de la celda es$cel\_{\_}_{tamaño\_}=8\times 8$ , el número de$contenedor\_=9$ , cada$4\times 4$ celdas forman un$bloque$ , el tamaño del paso de$escaneo$$es$$8$$8$ píxeles.
Luego, la dimensión de la característica Hog del gráfico se calcula de la siguiente manera:

1. $bloquear\_\_{\_}_{tamaño\_}=(4\times 8)\times (4\times 8)=32\times 32$
2. 默认$bloquear\_\_{\_}_{pasoapaso\_\_}=cel\_{\_}_{tamaño\_}=8$ ,
3. $bloquear\_\_{\_}_{Alto/}=\frac{\left(H\right(W)-bloque\_\_{\_}_{tamaño\_}}{bloquear\_\_{\_}_{pasoapaso\_\_}}+1=9$
4. $bloquear\_\_{\_}_{nu}=9\times 9=81$
5. Dimensión de la característica = $contenedor\_\times bloquear\_\_{\_}_{nu}\times Cadabloquecontieneelnúmerodeceldas\_\_=9\times 81\times dieciséis=11664$

Según el método de cálculo anterior, se puede obtener un $Vector\; propio\; HOG\; N$ -dimensional.

implementación de Python

import cv2
import numpy as np

gray_pic = np.ones(shape=(32, 64), dtype=np.uint8)

# 为HOG描述符指定参数

# 像素大小（以像素为单位）（宽度，高度）。 它必须小于检测窗口的大小，
# 并且必须进行选择，以使生成的块大小小于检测窗口的大小。
cell_size = (4, 4)

# 每个方向（x，y）上每个块的单元数。 必须选择为使结果
# 块大小小于检测窗口
num_cells_per_block = (2, 2)

# 块大小（以像素为单位）（宽度，高度）。必须是“单元格大小”的整数倍。
# 块大小必须小于检测窗口。
block_size = (num_cells_per_block[0] * cell_size[0],
              num_cells_per_block[1] * cell_size[1])

# 计算在x和y方向上适合我们图像的像素数
x_cells = gray_pic.shape[1] // cell_size[0]
y_cells = gray_pic.shape[0] // cell_size[1]

# 块之间的水平距离，以像元大小为单位。 必须为整数，并且必须
# 将其设置为（x_cells-num_cells_per_block [0]）/ h_stride =整数。
h_stride = 1

# 块之间的垂直距离，以像元大小为单位。 必须为整数，并且必须
# 将其设置为 (y_cells - num_cells_per_block[1]) / v_stride = integer.
v_stride = 1

# 块跨距（以像素为单位）（水平，垂直）。 必须是像素大小的整数倍。
block_stride = (cell_size[0] * h_stride, cell_size[1] * v_stride)

# 梯度定向箱的数量
num_bins = 9


# 指定检测窗口（感兴趣区域）的大小，以像素（宽度，高度）为单位。
# 它必须是“单元格大小”的整数倍，并且必须覆盖整个图像。
# 由于检测窗口必须是像元大小的整数倍，具体取决于您像元的大小，
# 因此生成的检测窗可能会比图像小一些。
# 完全可行
win_size = (x_cells * cell_size[0], y_cells * cell_size[1])

# 输出灰度图像的形状以供参考
print('\nThe gray scale image has shape: ', gray_pic.shape)
print()

# 输出HOG描述符的参数
print('HOG Descriptor Parameters:\n')
print('Window Size:', win_size)
print('Cell Size:', cell_size)
print('Block Size:', block_size)
print('Block Stride:', block_stride)
print('Number of Bins:', num_bins)
print()

# 使用上面定义的变量设置HOG描述符的参数
hog = cv2.HOGDescriptor(win_size, block_size, block_stride, cell_size, num_bins)

# 计算灰度图像的HOG描述符
hog_descriptor = hog.compute(gray_pic)
print(hog_descriptor.shape)

El tamaño de salida y la fórmula de cálculo del campo receptivo de convolución/agrupación ordinaria

Tamaño de salida de convolución ordinaria

Sea el tamaño de entrada $W.\times H$ , el tamaño del núcleo de convolución es$k\times k$ el tamaño del paso es$El\; acolchado\; S$ esPP.
Tamaño de salida$P$ ——H =$\frac{H-k+2}{S}+1Tamaño\; de\; salida$
——W=$\frac{W-k+2}{S}+1$

El tamaño de salida de la operación de agrupación.

Sea el tamaño de entrada $W.\times H$ , el tamaño del núcleo de agrupación es$k\times k$ el tamaño del paso esSS
Tamaño de salida$S$ ——H =$\frac{H-}{S}+1Tamaño\; de\; salida$
——W=$\frac{W-}{S}+1$

Campo receptivo de convolución

Este es un proceso de profundo a superficial. Se sabe que después de dos capas de convolución (k = 3, s = 2, p = 1), se obtiene un $128\times 128$ mapa de características, pregunte el campo receptivo de este mapa de características, luego calcule el campo receptivo a la inversa:
$$RF{\_}_{norte-}=f(rf{\_}_{},núcleo,\_\_\_\_paso)\_\_\_\_\_=(RF{\_}_{}-1)\times pasoapaso\_\_\_+kernelEn$$
el ejemplo anterior: (((1-1)*2+3)-1)*2+3=7

La cantidad de cálculo y parámetros de diferentes convoluciones.

Sea la forma del mapa de características de entrada $h_{}\times {W.}_{}\times C_{}$, el tamaño del núcleo de convolución es $k\times k\times C_c$, la forma del mapa de características de salida es $h_{}\times {W.}_{}\times C_{ou}$。

La cantidad de cálculo y parámetros de la convolución convencional.

计算量= $k\times k\times C_{}\times h_{}\times {W.}_{}\times C_{ou}$
参数量= $k\times k\times C_{}\times C_{ou}$

convolución agrupada

计算量= $k\times k\times C_{}\times h_{}\times {W.}_{}\times C_{ou}\times \frac{}{gramo}$
参数量= $k\times k\times C_{}\times C_{ou}\times \frac{}{gramo}$

La cantidad de cálculo y parámetros de convolución descomponible en profundidad.

计算量= $k\times k\times h_{}\times {W.}_{}\times C_{}+h_{}\times {W.}_{}\times C_{ou}\times C_{}$
参数量= $k\times k\times C_{}+C_{}\times C_{ou}$

$\frac{}{Cantidad\; computacional\; de\; convolución\; convencional.}=\frac{}{C_{ou}}+\frac{}{k^2}$

Operaciones de capa de norma por lotes

Ejemplo: $X=[x^{\left(1\right)},X^{\left(2\right)},...,X^{\left(m\right)}]$，其中$X^{\left(yo\right)}\in R^n$ representa la iésimaentrada$Yo$ muestras.

Calcula la media: $metro=\frac{}{metro}{\sum }_{yo=1}^{}{X}^{\left(yo\right)}$

Solución: ${pag}^2=\frac{}{metro}{\sum }_{yo=1}^{}(x^{\left(yo\right)}-metro{)}^2$

Forma: ${\hat{X}}^{\left(yo\right)}=\frac{X^{\left(yo\right)}-}{\sqrt{{pag}^2+ϵ}}$

donde $ϵ$ es un número muy pequeño, evita el denominador$0$ .

Escalado y compensación: $y^{\left(yo\right)}=C{\hat{X}}^{\left(yo\right)}+\beta donde\gamma$
\$c$和$\beta$ es un parámetro que se puede aprender y que se utiliza para escalar y compensar los resultados normalizados.

Durante el entrenamiento, la media y la varianza de cada minilote se calculan y se utilizan para normalizar los datos de entrada. Durante las pruebas, la media y la varianza de todas las muestras de entrenamiento se utilizan para la normalización.

Parámetros que se pueden aprender en la capa Batchnorm

1. $\gamma$ : parámetro de escala, utilizado para escalar las características normalizadas para aumentar la capacidad expresiva de la red.

2. $\beta$ : parámetro de compensación, utilizado para compensar características normalizadas para aumentar la capacidad expresiva de la red.

Estos dos parámetros se entrenan mediante el algoritmo de retropropagación. Durante la fase de inferencia, los valores de estos parámetros permanecen sin cambios porque se utilizan para escalar y compensar características, que son fijas.