[Computer Vision] Einige grundlegende Vorgänge zur Bildverarbeitung

Bildglättungsfilterverarbeitung

Bildglättung bedeutet, dass aufgrund des Einflusses von Faktoren wie dem Sensor und der Atmosphäre bestimmte Bereiche mit übermäßigen Helligkeitsänderungen oder einigen hellen Flecken (auch als Rauschen bezeichnet) auf Fernerkundungsbildern erscheinen. Bei dieser Verarbeitungsmethode, die die Bildhelligkeit glättet, um Rauschen zu unterdrücken, handelt es sich um die Bildglättung. Bei der Bildglättung handelt es sich eigentlich um eine Tiefpassfilterung, und der Glättungsprozess führt dazu, dass die Bildränder unscharf werden.

mittlerer Filter

Die lineare Filterung wirkt sich auf die gesamte Bildmatrix aus.

• Merkmale: Je größer das Fenster, desto besser ist der Rauschunterdrückungseffekt. Je länger die Berechnungszeit ist, desto schwerwiegender ist natürlich die Bildverzerrung. Bei der tatsächlichen Verarbeitung muss ein Gleichgewicht zwischen Verzerrungs- und Rauschunterdrückungseffekten gefunden und eine geeignete Fenstergröße ausgewählt werden.
• [Vorteile] Der Algorithmus ist einfach, erfordert keine komplexe Bildverarbeitungstechnologie und benötigt nicht viel Zeit und Platz. Und es kann Rauschen effektiv beseitigen und die Bildqualität verbessern.
• [Nachteile] Der Mittelwertfilter selbst weist inhärente Mängel auf, d.
• [Anwendungsbereich] Salz- und Pfeffergeräusch
• [Ungeeigneter Bereich] Geringe Beleuchtung, starke Bildrauschen

Berechnungsprozess

Für eine gegebene Fenstergröße werden die Werte innerhalb des Fensters gemittelt und der Medianwert als Fenstermittelwert verwendet . Geben Sie beispielsweise 3 ein, was bedeutet, dass $3\times 3$ Fenster zur Neuberechnung der Pixelwerte der angegebenen Bildmatrix. [Hinweis: Diese Pixel am Rand (können nicht$3\times 3$ ), einige gültige Pixel berechnen]
Wie in der folgenden Abbildung gezeigt, nehmen Sie für Pixel 1 in der ersten Zeile und ersten Spalte, immer noch als Mittelpunkt, den Mittelwert des orangefarbenen Bereichs als neuen Wert.

Python-Implementierung

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)

Gaußscher Filter

Die lineare Filterung wirkt sich auf die gesamte Bildmatrix aus.

• 【Merkmale】
  1. Bei der Gaußschen Filterung können Breite und Höhe des Kernels unterschiedlich sein, sie müssen jedoch beide ungerade sein.
  2. Bei der Mittelwertfilterung ist das Gewicht jedes Pixels in seiner Nachbarschaft gleich. Bei der Gaußschen Filterung wird der Gewichtungswert des Mittelpunkts erhöht und der Gewichtungswert des weit vom Mittelpunkt entfernten Punkts verringert. Auf dieser Grundlage wird die Summe der unterschiedlichen Gewichte jedes Pixelwerts in der Nachbarschaft berechnet .
  3. Der Gaußsche Kernel kann als Faltungskernel betrachtet werden, der auch eine zweidimensionale Filtermatrix ist. Der Unterschied besteht darin, dass der Gaußsche Kernel auf der Grundlage des gewöhnlichen Faltungskernels gewichtet wird (die Gewichtsmatrix wird anhand der Gaußschen Funktion berechnet). ).
• [Vorteile] Während Rauschen und detaillierte Informationen im Bild entfernt werden, bleiben die Hauptmerkmale des Bildes (wie die Konturen und Kanten des Bildes) erhalten; der Unschärfegrad des Gaußschen Filters kann durch Anpassen der Größe und Standardabweichung gesteuert werden des Gaußschen Kernels.
• [Nachteile] Der Rechenaufwand ist hoch, da der Gaußsche Filter eine Faltungsoperation erfordert.
• [Anwendungsbereich] Gaußsches Rauschen beseitigen

Berechnungsprozess

Die Gaußsche Filterung wird normalerweise auf zwei Arten implementiert: Eine durch diskretisierte Fenster-Schiebefenster-Faltung und die Zweite durch Fourier-Transformation. Das Folgende ist eine Gaußsche Filterung, die mithilfe einer diskretisierten Fenster-Schiebefenster-Faltung implementiert wird .
Häufig verwendete Gaußsche Vorlagen lauten wie folgt: Die oben genannten Parameter werden mithilfe der Gaußschen Funktion berechnet. Weitere Informationen finden Sie in einigen Erläuterungen zur Gaußschen Filterung . Die spezifische Operation besteht darin, jedes Pixel im Bild mit einer Vorlage (oder Faltung, Maske) zu scannen und den durch die Vorlage bestimmten gewichteten durchschnittlichen Grauwert
der Pixel in der Nachbarschaft zu verwenden, um den Wert des zentralen Pixels der Vorlage zu ersetzen . Weitere Informationen finden Sie unter Gauß-Filterung .

Python-Implementierung

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)

Medianfilter

Nichtlineare Filterung, die auf Pixel in der Bildmatrix abzielt, die zum Mittelpunkt des Fensters werden.

• [Vorteile] Es ist sehr effektiv bei der Glättung von Impulsrauschen. Gleichzeitig kann es die scharfen Kanten des Bildes schützen und geeignete Punkte auswählen, um die Werte kontaminierter Punkte zu ersetzen, sodass der Verarbeitungseffekt gut ist.
• [Nachteile] Es kann leicht zu Bilddiskontinuitäten kommen. Im Vergleich zur Mittelwertfilterung ist die Verarbeitung großer Bilder aufgrund des Sortiervorgangs langsamer.
• [Anwendungsbereich] Beseitigen Sie zufälliges Rauschen wie Salz- und Pfefferrauschen, additives Gaußsches Rauschen usw.
• [Ungeeigneter Bereich] Nicht für Dauergeräusche geeignet.

Berechnungsprozess

Sortieren Sie für eine bestimmte Fenstergröße die Werte innerhalb des Fensters und verwenden Sie den Mittelwert als Fenstermittelwert . Geben Sie beispielsweise 3 ein, was bedeutet, dass $3\times 3$ Fenster zur Neuberechnung der Pixelwerte der angegebenen Bildmatrix. [Hinweis: Die an der Filterung beteiligten Pixel sind der Mittelpunkt des Fensters und die Pixel am Rand (können nicht$3\times Der\; Mittelpunkt\; des\; Fensters\; 3$ ) wird nicht berechnet. 】

Das Bild unten zeigt $6\times Die\; 6-$ Bild-Matrix wird einer Medianfilterung unterzogen. Der blaue Wert ist das Schiebefenster und der rote Wert ist der gefilterte Wert. Wie in der Abbildung gezeigt, nehmen Randpixel nicht an der Berechnung teil, und der Pixelwert, der tatsächlich an der Berechnung teilnimmt, ist der Mittelpunkt des Fensters.

Python-Implementierung

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

Bildkantenerkennung

Der Bildrand bezieht sich im Allgemeinen auf die Position, an der die Graustufenänderungsrate des Bildes am größten ist. Die Hauptgründe sind folgende:

1. Der Grauwert des Bildes ändert sich diskontinuierlich in der Normalenrichtung der Oberfläche;

2. Die räumliche Tiefe von Objekten im Bild ist inkonsistent;

3. Inkonsistente Farbe auf glatten Oberflächen;

4. Licht und Schatten von Objekten im Bild

Unter Kantenerkennung versteht man den Prozess der Erkennung von Kantenpunkten und Kantensegmenten aus Bildern und der Beschreibung der Kantenrichtung.

Robert-Operator

Der Differentialoperator erster Ordnung ist eine Gradientenberechnungsmethode für schräge Abweichungen. Die Größe des Gradienten stellt die Stärke der Kante dar, und die Richtung des Gradienten ist senkrecht (orthogonal) zur Richtung der Kante.

• [Vorteile] Die Berechnung ist einfach und die Kantenpositionierung ist genau.
• [Nachteile] Geräuschempfindlich
• [Anwendungsbereich] Gut geeignet für die Verarbeitung von Bildern mit steilen (offensichtlichen Kanten) und geringem Rauschen
• -[Nicht anwendbar] Bilder mit viel Rauschen

Berechnungsprozess

Gradientenfenster des Robert-Operators in x-Richtung:
$$G_{}=\left[\begin{array}{cc}1& 0\\ & -\end{array}\right]$$
Gradientenfenster des Robert-Operators in y-Richtung:
$$G_{}=\left[\begin{array}{cc}0& 1\\ -& \end{array}\right]$$
Gradientensumme der Pixel in der Bildmatrix (kann der maximale Absolutwert oder die Quadratwurzel aus beiden sein):
$$G=|G_{}|+|G_{}|$$

Nachdem Sie die beiden oben genannten Gradientenfenster und ihre Additionsmethoden erhalten haben, wenden Sie sie auf die Bildmatrix an. Beachten Sie, dass die letzte Zeile und die letzte erste Spalte der Bildmatrix nicht an der Berechnung beteiligt sind und direkt auf 0 gesetzt werden. Da die obige Berechnungsidee der Berechnung von $(x_{\frac{}{2}},j_{\frac{}{2}})$ Farbverlauf.

Python-Implementierung

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)

Bildverarbeitung

Korrosionsbetreiber

Wird für jedes Pixel der Bildmatrix berechnet.

• Merkmale: Die Korrosion des Bildes wird mit dem hervorgehobenen Teil verglichen, und das entsprechende Binärbild wird mit dem weißen Bereich verglichen. Im Allgemeinen besteht Korrosion darin, den weißen Teil auf die ursprüngliche Form zu verkleinern, den schwarzen Teil zu erweitern und zu korrodieren. Das Gegenteil von der Erweiterungsvorgang.
• 【Geltungsbereich】

  1. Lärm beseitigen

  2. Bilder teilen und Bilder verbinden

  3. Lokales Maximum und lokales Minimum finden (mathematische Faltungsoperation am Bild)

  4. Finden Sie den Farbverlauf eines Bildes

Berechnungsprozess

Geben Sie eine Bildmatrix (0/1-Matrix) und eine Vorlagenmatrix (auch Faltungskernel genannt, 0/1-Wert) ein. Verwenden Sie das in der Vorlagenmatrix als „Mitte“ markierte Pixel als Referenz, um Pixel für Pixel in der Bildmatrix zu übersetzen. Nehmen Sie das „AND“ von [Pixel mit einem Wert von 1 in der Vorlagenmatrix] und [Pixel mit entsprechender Größe in der Bildmatrix] und weisen Sie dem aktuellen Pixel den Mindestwert des Ergebnisses zu. Nur die Teile mit der gleichen Form von 1 in der Bildmatrix und der Form mit dem Wert 1 in der Vorlagenmatrix werden beibehalten.
Im Bild unten ist beispielsweise B die Schablonenmatrix („Ursprung“ in B bedeutet der Mittelpunkt), X die Bildmatrix und XB das Ergebnis nach der Korrosion. Dieses Ergebnis kann als „UND“-Verknüpfung des schwarzen Teils in B und des schwarzen Teils in X betrachtet werden.

Python-Implementierung

Hog-Funktion (Histogramm der Gradientenorientierung).

Berechnungsprozess:

1. Bildvorverarbeitung: Konvertieren Sie das Bild in Graustufen und normalisieren Sie die Pixelwerte. Wenn das Bild starke Reflexionen und andere instabile Helligkeiten aufweist, sind eine Beleuchtungsnormalisierung und andere Verarbeitungen erforderlich.

2. Berechnen Sie Gradienten- und Orientierungshistogramme: Führen Sie eine Faltungsoperation am Bild durch, um die Größe und Richtung des Gradienten zu erhalten, und teilen Sie das Bild dann in mehrere kleine Blöcke auf (z. B. $8\times 8$ kleine Blöcke) werden die Gradientenrichtungen in jedem kleinen Block gezählt und das Gradientenrichtungshistogramm im kleinen Block erhalten.

3. Normalisierung: Normalisieren Sie das Verlaufsrichtungshistogramm innerhalb jedes kleinen Blocks, um den Einfluss von Faktoren wie Beleuchtung und Schatten zu vermeiden.

4. Spleißen: Spleißen Sie die normalisierten Histogramme aller kleinen Blöcke zu einem großen Vektor zusammen, der als HOG-Merkmalsvektor bezeichnet wird.

Formel zur Berechnung der Feature-Dimension von Hog

Beispiel:
Gegebene Auflösung $H\times W=100\times Für\; ein\; Bild\; von\; 100$ ist bekannt, dass die Pixelgröße der Zelle$cel{l}_{si}=8\times 8$ , die Anzahl der Histogramm-$bins=9$ , alle$4\times 4$ Zellen bilden einen$Block,die\; Scan-$ Schrittgröße beträgt$8$ Pixel.
Dann wird die Dimension des Hog-Merkmals des Diagramms wie folgt berechnet:

1. $Block\_\_{\_}_{si}=(4\times 8)\times (4\times 8)=32\times 32$
2. 默认$Block\_\_{\_}_{strid}=cel{l}_{si}=8$ ,
3. $Block\_\_{\_}_{H/}=\frac{\left(H\right(W)-Block\_\_{\_}_{si}}{Block\_\_{\_}_{strid}}+1=9$
4. $Block\_\_{\_}_{nu}=9\times 9=81$
5. Merkmalsdimension = $bins\times Block\_\_{\_}_{nu}\times JederBlockenthältdieAnzahlderZellen\_\_=9\times 81\times 16=11664$

Gemäß der obigen Berechnungsmethode kann ein $N$ -dimensionaler HOG-Eigenvektor.

Python-Implementierung

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)

Die Ausgabegröße und die Berechnungsformel für das Empfangsfeld der gewöhnlichen Faltung/Pooling

Ausgabegröße der gewöhnlichen Faltung

Die Eingabegröße sei $W\times H$ , die Faltungskerngröße beträgt$k\times Die\; k$ -Schrittweite beträgt$Die\; S-$ Polsterung besteht aus$P-$
Ausgabegröße – H=$\frac{H-k+2}{S}+1Ausgabegröße$
– W=$\frac{W-k+2}{S}+1$

Die Ausgabegröße des Pooling-Vorgangs

Die Eingabegröße sei $W\times H$ beträgt die Pooling-Kernelgröße$k\times Die\; k$ -Schrittweite beträgt$S-$
Ausgabegröße – H=$\frac{H-}{S}+1Ausgabegröße$
– W=$\frac{W-}{S}+1$

Empfangsfeld der Faltung

Dies ist ein Prozess von tief nach flach. Es ist bekannt, dass nach zwei Faltungsschichten (k=3, s=2, p=1) ein $128\times 128$ Feature-Map, fragen Sie bitte nach dem Empfangsfeld dieser Feature-Map und berechnen Sie dann das Empfangsfeld in umgekehrter Reihenfolge:
$$R{F}_{N-}=f(R{F}_{},kernel,stride)=(R{F}_{}-1)\times stride+kernelIm$$
obigen Beispiel: (((1-1)*2+3)-1)*2+3=7

Der Rechenaufwand und die Parameter verschiedener Faltungen

Die Form der Eingabe-Feature-Map sei $H_{}\times W_{}\times C_{}$Die Größe des Faltungskerns beträgt $k\times k\times C_c$, die Form der Ausgabe-Feature-Map ist $H_{}\times W_{}\times C_{ou}$。

Der Rechenaufwand und die Parameter der herkömmlichen Faltung

计算量= $k\times k\times C_{}\times H_{}\times W_{}\times C_{ou}$
参数量= $k\times k\times C_{}\times C_{ou}$

Gruppierte Faltung

计算量= $k\times k\times C_{}\times H_{}\times W_{}\times C_{ou}\times \frac{}{G}$
参数量= $k\times k\times C_{}\times C_{ou}\times \frac{}{G}$

Der Berechnungsaufwand und die Parameter der in die Tiefe zerlegbaren Faltung

计算量= $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{}{Rechenumfang\; der\; konventionellen\; Faltung}=\frac{}{C_{ou}}+\frac{}{k^2}$

Operationen der Batchnorm-Ebene

Beschreibung: $X=[x^{\left(1\right)},X^{\left(2\right)},...,X^{\left(m\right)}]$，其中$X^{\left(ich\right)}\in R^n$ stellt den i-tenEingang$Ich$ probiere.

Berechnen Sie den Mittelwert: $M=\frac{}{M}{\sum }_{ich=1}^{}{X}^{\left(ich\right)}$

Lösung: $P^2=\frac{}{M}{\sum }_{ich=1}^{}(x^{\left(ich\right)}-m{)}^2$

Form: ${\hat{X}}^{\left(ich\right)}=\frac{X^{\left(i\right)}-}{\sqrt{P^2+ϵ}}$

wobei $ϵ$ ist eine sehr kleine Zahl, Nenner$0$。

Skalierung und Offset: $j^{\left(ich\right)}=C{\hat{X}}^{\left(ich\right)}+\beta wo\gamma$
\$c$和$\beta$ ist ein lernbarer Parameter, der zum Skalieren und Versetzen der normalisierten Ergebnisse verwendet wird.

Während des Trainings werden der Mittelwert und die Varianz jedes Mini-Batches berechnet und zur Normalisierung der Eingabedaten verwendet. Beim Testen werden Mittelwert und Varianz aller Trainingsstichproben zur Normalisierung verwendet.

Lernbare Parameter in der Batchnorm-Ebene

1. $\gamma$ : Skalierungsparameter, der zum Skalieren der normalisierten Merkmale verwendet wird, um die Ausdrucksfähigkeit des Netzwerks zu erhöhen.

2. $\beta$ : Offset-Parameter, der zum Versetzen normalisierter Features verwendet wird, um die Ausdrucksfähigkeit des Netzwerks zu erhöhen.

Diese beiden Parameter werden durch den Backpropagation-Algorithmus trainiert. Während der Inferenzphase bleiben die Werte dieser Parameter unverändert, da sie zum Skalieren und Versetzen von Features verwendet werden, die fest sind.